Fix hooking commands throwing UnsupportedOperationException. Server will instead tell us that the command 'serversigns' was not found in RedstonerUtils at the end of start, which is bullshit, everything works.

Fixed typo

.gitignore

@@ -1,6 +1,10 @@
 *.pyc
 *.class
 *sublime*
+*.bat*
+secrets.py
+excluded.txt
+.idea
 
 # these are player/ingame specific
 files/

CONTRIBUTING.md

@@ -0,0 +1 @@
+If you want to contribute, please [read through the pages on the wiki](https://github.com/RedstonerServer/redstoner-utils/wiki).

LICENSE.md

@@ -0,0 +1,21 @@
+# The MIT License (MIT)
+
+Copyright (c) Redstoner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE

README.md

@@ -2,245 +2,8 @@
 
 Redstoner's custom plugins, written in python.
 
+------
 
-# Installation / Set-up
+## Contributing
 
-1-line-install-script for bash:
-`wget -O install.sh "http://pastie.org/pastes/9310905/download?key = 6byp4mrqmiui8yqeo3s6yw"; md5sum --check <<<"3499671c0832e561bc9c7d476d2167cb  install.sh" && sh install.sh`
-
-Detailed description:
-
-0. Create a new directory called 'redstoner'
-0. Download [the latest spigot](http://ci.md-5.net/job/Spigot/lastStableBuild/artifact/Spigot-Server/target/spigot.jar)
-0. Run it once inside redstoner, then shut it down again
-0. Create a new directory (inside redstoner) called 'lib'
-0. Download [mysql-connector](https://dev.mysql.com/get/Downloads/Connector-J/mysql-connector-java-5.1.30.zip), extract 'mysql-connector-java-X.X.XX-bin.jar
-' and save it as 'mysql-connector.jar' inside lib
-0. Download [PyPluginLoader](http://bamboo.gserv.me/browse/PLUG-PYPL/latestSuccessful/artifact/JOB1/Version-agnostic-jar/PyPluginLoader.jar) (we're using [this fork](https://github.com/gdude2002/Python-Plugin-Loader)) into the plugins directory
-0. inside plugins, clone this directory into 'redstoner-utils**.py.dir**':  
-`git clone git@bitbucket.org:redstonesheep/redstoner-utils.git redstoner-utils.py.dir`
-0. Download [PEX](http://dev.bukkit.org/media/files/789/291/PermissionsEx.jar) into plugins
-0. **if you want** to develop mysql things, set up a local MySQL server
-
-
-# branches
-
-* **dev**
-  Always use this branch to change code, please test before pushing. (If something goes wrong here, that's okay)
-
-* **master**
-  Never commit into this branch directly! Only merge stable versions of *dev*:
-  ```bash
-  git checkout master
-  git merge dev
-  ```
-
-
-# Deploying on the server
-
-**Never** edit the files directly on the server!
-The dev server uses the *dev* branch, the live server uses *master*.
-**Do not use `git pull` on the server!** *(All files must be pulled/owned by the 'redstoner' user.)*
-
-### Deploying on test server
-* Push all changes
-* Run `<server-dir>/git_pull_utils.sh`.
-* Restart (You can try reloading here, but expect the unexpected)
-
-### Deploying on production server
-* Test all code carefully on the test server  
-  ***on your machine:***
-* `git checkout master`
-* `git pull`
-* `git merge dev`
-* `git push -u origin master`
-* `git checkout dev`  
-  ***on the server:***
-* `rs update_utils`
-* Restart
-
-
-# Modules / Files
-
-If you add a new file, please update this list!
-
-If you want the server to load a file (*module*) on startup, add it to the `modules` list in `main.py`.
-
-
-* `files/`
-
-  > All config / storage files go here
-
-* `plugin.yml`
-
-  > The plugin.yml file required for bukkut plugins
-
-* `main.py`
-
-  > The only file loaded by PyPluginLoader, loads all other modules  
-  > Contains a few methods that **need to be cleaned up**
-
-* `helpers.py`
-
-  > Library that adds a bunch of re-usable methods which are used in nearly all other modules
-
-* `adminchat.py`
-
-  > Adds chat for staff using `/ac <text` or `,<text>`
-
-* `chatgroups.py`
-
-  > Adds group-chat with `/chatgroup` and `/cgt` to toggle normal chat into group mode
-
-* `lagchunks.py`
-
-  > Plugin to locate laggy chunks. `/lc <n>` lists chunks with more than `n` entities
-
-* `mysqlhack.py`
-
-  > A library that makes use of the so called ClassPathHack for jython to allow proper loading of `mysql-connector.jar` at runtime. import only, no methods.
-
-* `plotter.py`
-
-  > Start of a custom plot-plugin like PlotMe, on hold because the PlotMe developer continued to develop PlotMe
-
-* `reports.py`
-
-  > The `/report <text>` and `/rp` plugin
-
-* `saylol.py`
-
-  > Remake of sheep's old SayLol plugin, originally written as a standalone plugin in Java
-
-* `skullclick.py`
-
-  > Shows the owner of a skull when right-clicked
-
-* `webtoken.py`
-
-  > Adds `/token`, reads and writes from the database to generate *pronouncable* (and thus memorable) registration-tokens for the website
-
-* `spawnplayer.py`
-
-  > Code that was used once to create [this](http://www.reddit.com/r/Minecraft/comments/28le52/screenshot_of_all_players_that_joined_my_server/) awesome [screenshot](http://i.imgur.com/v4wg5kl.png)
-
-* `tilehelper.py`
-
-  > A plugin that automatically tiles (stacks) blocks inside a selected region in configurable directions.
-
-* `mentio.py`
-
-  > Adds `/listen`, highlights chat and plays a sound when your name was mentioned
-
-* `cycler.py`
-
-  > Adds `/cycler`, swaps the hotbar with inventory when player changes slot from right->left or left->right
-
-* `motd.py`
-
-  > Adds `/getmotd` & `/setmotd` to update the motd on the fly (no reboot).
-
-* `abot.py`
-
-  > AnswerBot. Hides stupid questions from chat and tells the sender about `/faq` or the like
-
-* `damnspam.py`
-
-  > Adds `/damnspam`, creates timeout for buttons/levers to mitigate button spam.
-
-* `forcefield.py`
-
-  > Adds '/forcefield', creates forcefield for players who want it.
-
-# Code styleguide & tips
-
-## Indentation
-Never use tabs!
-Use 2 spaces to indent.
-
-## Quotes
-Always use double-quotes!
-Only use single-quotes when the string contains double-quotes that would need to be escaped.
-
-## Capitalization
-Do not use camelCase for variable or function names! Use under_score naming.
-camelCase is okay when used like `import foo.bar.camelCase as camelCase`.
-
-## Aligning variable assignments
-In case you have multiple variable assignments, align the equals sign:
-
-```Python
-# bad
-foo = 1
-foobar = 2
-a = 3
-
-# good
-foo    = 1
-foobar = 2
-a      = 3
-```
-
-Pro Tip: Use the AlignTab plugin for Sublime Text!
-
-## Horizontal spacing
-Use at least one space left and one space right to equals signs, and one space right to colons.
-
-## Vertical spacing
-Leave two empty lines before function definitions. In case you need to use `@hook.something`, add the two lines before that, directly followed by the definition.
-
-## Meaningful names
-Give function and variable names meaningful names. If you want to shorten long names, that's fine, but leave a comment on assigment with the actual meaning.
-
-## Readability
-Don't create long lines with lots of function calls. Split into multiple lines instead.
-Also avoid methods with lots of lines. Split into multiple methods instead.
-
-```Python
-# bad
-foo = int(player_data[str(server.getPlayer(args[4]).getUniqueId())]["details"].["last_login"].strftime("%s"))
-
-# good
-player     = server.getPlayer(args[4])
-player_id  = uid(player)
-logintime  = player_data[played_id]["last_login"]
-epoch_time = int(logintime.strftime("%s"))
-```
-
-## Comments
-Comments are good!
-Please comment everything that's non-obious or makes it easier to understand
-
-## Debugging
-Debugging can be a bit special with jython/PyPluginLoader.
-
-When something goes wrong, you probably see a weird traceback that's not telling you shit.
-...unless you take a closer look.
-
-You will not see a direct traceback of the python methods.
-Instead, you'll probably see a bunch of java, bukkit and python things, because it tries to translate python into java, line per line.
-Take a closer look at the method names, they might tell you what it's trying to do and where it's coming from.
-
-Watch out for something like `org.python.pycode._pyx5.horribleCode$23(/path/to/badcode.py:214) ~[?:?]`
-0. In this case, `_pyx5` is our module.
-0. `horribleCode` is the method that was called
-0. `/path/to/badcode.py` is the actual file of our module
-0. `:214` is the line in which the error occured.
-
-Please note that the line may not be accurate. You'll often get the start of a loop, or the end of a method - when the actual error was somewhere in there.
-
-In many cases, this is enough to find your bug. If you still cannot find it,try to catch exceptions in your code, as follows:
-
-
-## Catching exceptions
-
-If you want to catch all exceptions (e.g. for debugging), do not `catch Exception`.
-Since we're using jython, this will not catch Java exceptions.
-This will give you some more deatails:
-```python
-from traceback import format_exc as trace
-try:
-  #code
-except: # everything
-  print(trace())
-```
+If you want to contribute, please [read through the pages on the wiki](https://github.com/RedstonerServer/redstoner-utils/wiki).

abot.py

@@ -27,7 +27,7 @@ def list_answers(sender):
 
 
 @hook.command("abot")
-def on_abot_command(sender, args):
+def on_abot_command(sender, command, label, args):
     plugin_header(sender, "AnswerBot")
     if sender.hasPermission("utils.abot.admin"):
         if not args:
@@ -45,10 +45,8 @@ def on_abot_command(sender, args):
     return True
 
 
-@hook.event("player.AsyncPlayerChatEvent", "low")
-def on_chat(event):
+def check_msg(event, message):
     sender = event.getPlayer()
-  message = event.getMessage().lower()
     for answer in answers:
         for regex in answer["regex"]:
             if regex.search(message):
@@ -60,4 +58,15 @@ def on_chat(event):
                     break
 
 
+@hook.event("player.AsyncPlayerChatEvent", "low")
+def on_chat(event):
+    check_msg(event, event.getMessage().lower())
+
+@hook.event("player.PlayerCommandPreprocessEvent", "low")
+def on_any_cmd(event):
+    words = event.getMessage().lower().split(" ")
+    cmd = words[0][1:]
+    if cmd in ["msg", "m", "t", "pm", "mail", "r", "reply"]:
+        check_msg(event, " ".join(words[1:]))
+
 load_answers()

adminchat.py

@@ -1,8 +1,12 @@
 #pylint: disable = F0401
 from helpers import *
+from basecommands import simplecommand
 
 ac_permission  = "utils.ac"
-ac_key         = ","
+
+ac_defaultkey  = ","
+ac_keys        = open_json_file("adminchat_keys", {})
+
 ac_toggle_list = []
 ac_prefix      = "&8[&cAC&8]"
 
@@ -13,6 +17,7 @@ def adminchat(sender, msg):
     except AttributeError:
         name = sender.getName()
     broadcast(ac_permission, "%s &9%s&8: &b%s" % (ac_prefix, name, msg))
+    # Needs something here like fine(message) to show up in the logs when you use ackey, but fine doesnt work for some reason. It did on the server with /pyeval (not show up on console, but show up in logs nevertheless)
 
 
 # ac toggle
@@ -41,15 +46,41 @@ def on_ac_command(sender, args):
         noperm(sender)
     return True
 
+def get_key(uuid):
+    key = ac_keys.get(uuid)
+    return key if key != None else ac_defaultkey
+
+@simplecommand("adminchatkey",
+        aliases = ["ackey"],
+        senderLimit = 0,
+        helpNoargs = True,
+        helpSubcmd = True,
+        description = "Sets a key character for adminchat",
+        usage = "<key>")
+def adminchatkey_command(sender, command, label, args):
+    key = " ".join(args)
+    uuid = uid(sender)
+    if key.lower() == "default" or key == ac_defaultkey:
+        del ac_keys[uuid]
+        save_keys()
+        return "&aYour adminchat key was set to the default character: '&c%s&a'" % ac_defaultkey
+    ac_keys[uid(sender)] = key
+    save_keys()
+    return "&aYour adminchat key was set to: '&c%s&a'" % key
+
+def save_keys():
+    save_json_file("adminchat_keys", ac_keys)
+
 
 @hook.event("player.AsyncPlayerChatEvent", "low")
 def on_chat(event):
     sender = event.getPlayer()
     msg = event.getMessage()
     if sender.hasPermission(ac_permission) and not event.isCancelled():
-    if msg[:len(ac_key)] == ac_key:
-      adminchat(sender, msg[1:])
-      event.setCancelled(True)
-    elif sender.getName() in ac_toggle_list:
+        key = get_key(uid(sender))
+        if sender.getName() in ac_toggle_list:
             adminchat(sender, msg)
             event.setCancelled(True)
+        elif msg[:len(key)] == key:
+            adminchat(sender, msg[len(key):])
+            event.setCancelled(True)

adminnotes.py

@@ -0,0 +1,134 @@
+from helpers import *
+from traceback import format_exc as print_traceback
+import time
+
+an_permission      = "utils.an";
+notes              = open_json_file("adminnotes", [])
+continued_messages = {}
+
+
+def save_notes():
+    save_json_file("adminnotes", notes)
+
+
+def r_ago(unit, i):
+    # Return ago + plural
+    if i != 1:
+        unit += "s"
+    return "%s %s ago" % (i, unit)
+
+
+def calc_diff(time_ago):
+    current = time.time()
+    s = current-time_ago
+    s = int(s)
+    ago = "Some time ago"
+
+    if s < 10:
+        ago = "Just now"
+    elif s >= 10 and s < 60:
+        ago = r_ago("second", s)
+    elif s >= 60 and s < 3600:
+        ago = r_ago("minute", s/60)
+    elif s >= 3600 and s < 43200:
+        ago = r_ago("hour", s/60/60)
+    elif s >= 43200:
+        ago = r_ago("day", s/60/60/12)
+    return ago
+
+
+def show_all_notes(sender):
+    if len(notes) == 0:
+        msg(sender, "&aNo open notes at the moment!")
+        return
+    for i in range(0, len(notes)):
+        arr = notes[i]
+        name      = arr[0]
+        message   = arr[1]
+        note_time = arr[2]
+
+        ago = calc_diff(note_time)
+
+        msg(sender, "&6#%s - &e%s&6, %s:" % (str(i+1), name, ago))
+        msg(sender, "&7%s" % colorify(message))
+
+
+def show_an_help(sender):
+    msg(sender, "&6AdminNotes Help:")
+    msg(sender, "&e- /an")
+    msg(sender, "&7&oLists all notes")
+    msg(sender, "&e- /an del <ID>")
+    msg(sender, "&7&oRemove a note")
+    msg(sender, "&e- /an help")
+    msg(sender, "&7&oShows this menu")
+    msg(sender, "&e- /an Some text...")
+    msg(sender, "&7&oWrite a new note")
+    msg(sender, "&e- /an This text is very++")
+    msg(sender, "&7&oContinue writing your note when using &e/an long guys!&7&o again")
+
+
+@hook.command("an", aliases=["adminnotes", "adminnote"])
+def adminnotes_command(sender, command, label, args):
+    if not sender.hasPermission(an_permission):
+        noperm(sender)
+        return
+    try:
+        arglen = len(args)
+
+        # arg length not valid
+        if arglen == 0:
+            show_all_notes(sender)
+            return
+
+        # Shows note help
+        subcmd = args[0].lower()
+        if subcmd == "help":
+            show_an_help(sender)
+            return
+
+        # Delete note
+        if subcmd == "del":
+            if arglen != 2:
+                show_an_help(sender)
+                return
+            if not args[1].isdigit():
+                msg(sender, "&cThe ID has to be numeric (check /an if you're unsure)")
+                return
+            note_id = int(args[1])-1
+            if note_id >= len(notes):
+                msg(sender, "&cThere is no note with that ID!")
+                return
+            # Deletes note by index
+            del notes[note_id]
+            save_notes()
+            msg(sender, "&aSuccessfully deleted note #%s!" % str(note_id+1))
+            return
+
+        message = " ".join(args)
+        name = sender.getName()
+        if name in continued_messages:
+            message = continued_messages[name] + " " + message
+            del continued_messages[name]
+
+        if message[-2:] == "++":
+            message = message[:-2]
+            continued_messages[name] = message
+            msg(sender, "&6You can continue writing by using &e/an <text ...>")
+        else:
+            notes.append([name, message, time.time()])
+            save_notes()
+            msg(sender, "&eNew note:&6 " + message)
+            broadcast(an_permission, "&a%s just added a new note! &2Type /an" % name)
+    except:
+        error(print_traceback())
+
+
+@hook.event("player.PlayerJoinEvent", "monitor")
+def on_an_join(event):
+    player = event.getPlayer()
+    if not player.hasPermission(an_permission):
+        return
+    if len(notes) > 0:
+        msg(player, "&cThere are currently %s open notes!" % len(notes))
+    elif len(notes) == 0:
+        msg(player, "&aThere are currently no open notes!")

badges.py

@@ -0,0 +1,137 @@
+from helpers import *
+
+badges            = open_json_file("badges", {})
+badges_available  = {
+    "helpful"          : "A very helpful player",
+    "expert_minecraft" : "An expert in Minecraft",
+    "expert_coder"     : "A good coder",
+    "oldtimer"         : "A long time player",
+    "good_builder"     : "A very good builder",
+    "friendly"         : "Many think that this player is friendly",
+    "very_active"      : "A very active player",
+    "trustworthy"      : "This player is very trustworthy",
+}
+badges_perm_add   = "utils.badges.add"
+badges_perm_del   = "utils.badges.delete"
+
+def save_badges():
+    save_json_file("badges", badges)
+
+
+def get_badges(player):
+    sender_id = uid(player)
+    return badges.get(sender_id, [])
+
+
+def show_badges(sender, player):
+    player_badges = get_badges(player)
+    if player_badges:
+        msg(sender, "&6Badges of " + player.getName())
+        for key in player_badges:
+            msg(sender, "&b> &3&o%s" % badges_available[key])
+    else:
+        msg(sender, "&eThis player has no badges yet")
+
+
+def new_badge_event(player, badge):
+    msg(player, "")
+    msg(player, "&6Wow! You just received a badge!")
+    msg(player, "&b-> &3%s" % badges_available[badge])
+    msg(player, "&7Type /badge to see all your badges!")
+    msg(player, "")
+    player.playSound(player.getLocation(), "random.orb", 1, 1)
+
+
+def del_badge_event(player, badge):
+    msg(player, "&cWe took your badge \"%s\"." % badges_available[badge])
+
+
+def list_badges(sender):
+    if badges_available:
+        for key in badges_available.keys():
+            msg(sender, "&b> &3%s &7&o\"%s\"" % (key, badges_available[key]))
+    else:
+        msg(sender, "&cThere are currently no badges available")
+
+
+def add_badge(sender, target, badge):
+    if badge in badges_available:
+        player_badges = get_badges(target)
+        if badge in player_badges:
+            msg(sender, "&cThis player got this badge already!")
+            return
+        player_badges.append(badge)
+        if player_badges:
+            badges[uid(target)] = player_badges
+            msg(sender, "&aYou just gave %s a new badge!" % target.getName())
+            new_badge_event(target, badge)
+            save_badges()
+    else:
+        msg(sender, "&cThere is no badge called %s. Check /badge list!" % badge)
+
+
+def del_badge(sender, target, badge):
+    if badge in badges_available.keys():
+        player_badges = get_badges(target)
+        if badge in player_badges:
+            player_badges.remove(badge)
+            badges[uid(target)] = player_badges
+            msg(sender, "&aYou just took %s from %s!" % (badge, target.getName()))
+            save_badges()
+            del_badge_event(target, badge)
+            return
+        msg(sender, "&c%s doesn't have this badge!" % target.getName())
+    else:
+        msg(sender, "&cThere is no badge called %s. Check /badge list!" % badge)
+
+
+@hook.command("badge", aliases=["badges", "rewards"])
+def on_badge_command(sender, command, label, args):
+    argnum = int(len(args))
+
+    # No arguments
+    if argnum is 0:
+        show_badges(sender, sender)
+
+    # Length of arguments is 1
+    if argnum == 1:
+
+        # If only argument is "list"
+        if args[0].lower() == "list":
+            list_badges(sender)
+            return True
+
+        # If only argument is a player name
+        target = server.getPlayer(args[0])
+        if is_player(target):
+            show_badges(sender, target)
+            return True
+        else:
+            msg(sender, "&cThere is no player called %s online." % args[0])
+            return True
+
+        msg(sender, "&cUnknown syntax: /badge <playername> &o&c /badge list")
+        return True
+
+    # Length of arguments is 3
+    if argnum == 3:
+        cmd = args[0].lower()
+        target = server.getPlayer(args[1])
+        new_badge = args[2].lower()
+
+        if cmd == "add":
+            if not sender.hasPermission(badges_perm_add):
+                noperm(sender)
+                return True
+            add_badge(sender, target, new_badge)
+            return True
+
+        if cmd == "take" or cmd == "del":
+            if not sender.hasPermission(badges_perm_del):
+                noperm(sender)
+                return True
+            del_badge(sender, target, new_badge)
+            return True
+
+        msg(sender, "&cUnknown syntax: /badge <add|take> <playername> <badge>")
+        return True

basecommands.py

@@ -0,0 +1,164 @@
+from helpers import *
+
+"""
+@simplecommand is a decorator which is meant to replace @hook.command in redstoner-utils, where useful.
+It takes care of checks such as whether the sender is a player, whether they have permission,
+whether there are enough argumens, and also takes care of a help message.
+On top of that, it makes the code shorter and easier to write with features like Validate, and returning a message instead of a boolean value.
+@simplecommand has an inbuilt tracing feature, so you won't have to put all your code in a try/except statement anymore.
+Make sure to `from basecommands import simplecommand` before using this decorator.
+
+The arguments are as follows:
+* cmd: the command, self explanatory (required);
+
+* aliases: A list containing any aliases for the command, like shortcuts;
+
+* usage: a String defining the expected arguments for the command. Example:
+    Let's say I have a command /tp <player_to_teleport> <destination_player>. The usage is: "<player_to_teleport> <destination_player>".
+    I suggest we use the same format throughout redstoner-utils:
+    - Separate arguments by spaces;
+    - Use <> if the argument is required, and [] if the argument is optional;
+    - Add .. to the argument's identifier (name) if it is for example a message (containing spaces).
+      for example in /msg, the usage would be "<player> <msg..>"
+
+* description: a description of what the command does. Defaults to "Handles cmd".
+    This is used for the help message, where the description is (meant to be) indented. To keep this indentation 
+    with longer descriptions, call the help message (with the command, ingame) and add '\n' 
+    when it jumps to a new line in the chat. The decorator will take care of the indentation after that.
+
+* senderLimit: an integer resembling the accepted sender type. Defaults to -1. Use:
+    -1 for console as well as players;
+    0 for players only;
+    1 for console only.
+
+* amin: an integer resembling the minimum amount of arguments. Defaults to 0
+
+* amax: an integer resembling the maximum amount of arguments. Defaults to -1, which means that there is no maximum.
+
+* helpNoargs: a boolean value resembling whether the help message should be displayed when no arguments are given.
+    Defaults to False.
+
+* helpSubcmd: a boolean value resembling whether the help message should be displayed when the first argument.lower() equals "help".
+    Defaults to False.
+
+Comments on the function added to the decorator:
+It should return a message to send to the player. Color codes are translated automatically. It can return None or an empty string to send nothing.
+Returning "HELP" makes it show the help message.
+
+Inside the function, calls to static methods in the class Validate can be used to make the code shorter and easier to write (maybe not easier to read).
+For example, to make sure that a condition is met, use Validate.isTrue(condition, message to send to the player if the condition is not met)
+Don't forget to `from basecommands import Validate` if you wish to make use of this.
+For all other Validate checks, see the code below. Feel free to add your own.
+
+Instead of returning a message mid-code to describe an error, you can also use raise CommandException(msg), but it is almost always possible
+to replace this return statement with a call to one of the functions in the Validate class. Once again, if you use raise CommandException(msg),
+don't forget to `from basecommands import CommandException`.
+"""
+
+to_see_permission = "utils.showpermission" # See cmd permission in help
+
+def isSenderValid(senderLimit, isPlayer):
+    return True if senderLimit == -1 else senderLimit != isPlayer
+
+def invalidSenderMsg(isPlayer):
+        return "&cThat command can only be used by " + ("the console" if isPlayer else "players")
+
+def helpMsg(sender, cmd, description, usage, aliases, permission):
+    help_msg  = "&aInformation about command /%s:\n    &9%s" % (cmd, description.replace("\n", "\n    "))
+    help_msg += "\n \n&aSyntax: /%s %s" % (cmd, usage)
+    if aliases:
+        help_msg += ("\n&6Aliases: " + "".join([(alias + ", ") for alias in aliases]))[:-2]
+    if sender.hasPermission(to_see_permission):
+        help_msg += "\n&6Required permission: " + permission
+    return help_msg
+
+
+def simplecommand(cmd,
+                aliases     = [],
+                usage       = "[args...]",
+                description = None,
+                senderLimit = -1,
+                amin        = 0,
+                amax        = -1,
+                helpNoargs  = False,
+                helpSubcmd  = False):
+    cmd = cmd.lower()
+    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 decorator(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 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
+
+            try:
+                return function(sender, command, label, args)
+            except CommandException, e:
+                return e.message
+            except Exception, e:
+                error(trace())
+                return "&cAn internal error occurred while attempting to perform this command"
+
+        return call
+    return decorator
+
+
+class CommandException(Exception):
+    pass
+
+
+class Validate():
+    @staticmethod
+    def notNone(obj, msg):
+        if obj == None:
+            raise CommandException(msg)
+
+    @staticmethod
+    def isPlayer(sender):
+        if not is_player(sender):
+            raise CommandException("&cThat command can only be run by players")
+
+    @staticmethod
+    def isConsole(sender):
+        if is_player(sender):
+            raise CommandException("&cThat command can only be run from the console")
+
+    @staticmethod
+    def isAuthorized(sender, permission, msg = "that command"):
+        if not sender.hasPermission(permission):
+            raise CommandException("&cYou do not have permission to use " + msg)
+
+    @staticmethod
+    def isTrue(obj, msg):
+        if obj != True:
+            raise CommandException(msg)
+
+    @staticmethod
+    def checkArgs(sender, args, amin, amax):
+        if not checkargs(sender, args, amin, amax):
+            raise CommandException("")
+
+

blockplacemods.py

@@ -0,0 +1,318 @@
+from helpers import *
+from basecommands import simplecommand, Validate, CommandException
+from time import sleep
+from collections import deque
+import thread
+import org.bukkit.event.block.BlockBreakEvent as BlockBreakEvent
+import org.bukkit.block.Furnace as Furnace
+import org.bukkit.inventory.ItemStack as ItemStack
+import org.bukkit.Material as Material
+import org.bukkit.event.block.Action as Action
+import org.bukkit.block.BlockFace as BlockFace
+import org.bukkit.scheduler.BukkitRunnable as BukkitRunnable
+
+"""
+  # Permissions:
+  # - utils.toggle: for use of the command
+  # - utils.toggle.cauldron
+  # - utils.toggle.slab
+  # - utils.toggle.furnace
+  # - utils.toggle.piston
+  # - utils.toggle.dropper
+  # - utils.toggle.hopper
+"""
+
+settingInformation = dict( #[setting type, identifying description, detailed description, aliases, (optional) max slot id], setting types: 0 = toggle, default on. 1 = Set your setting to held itemstack, 2 = toggle, default off
+    cauldron = [0,
+        "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",
+        ["caul", "water"]
+    ],
+    slab = [0,
+        "automatically flipping placed slabs upside-down",
+        "Toggles whether slabs/steps which you place should be automatically flipped upside-down",
+        ["step"]
+    ],
+    furnace = [1,
+        "automatically filling furnaces upon placement",
+        "Sets your preferred default furnace contents to your currently held itemstack. Use an empty hand to empty a slot, or /toggle furnace clear to clear all slots.",
+        ["cooker", "fillf"], 2
+    ],
+    torch = [0,
+        "removal of torches you place on redstone blocks",
+        "Toggles whether redstone torches which you place on redstone blocks will be deleted after a short amount of delay.",
+        ["redstonetorch", "tor"]
+    ],
+    piston = [2,
+        "rotating pistons, droppers and hoppers to face the block you place them against",
+        "Toggles whether pistons or sticky pistons which you place will be rotated to face the block which you placed them against.",
+        ["invert", "rp"]
+    ],
+    dropper = [1,
+        "automatically filling droppers upon placement",
+        "Sets your preferred default dropper contents to your currently held itemstack. Use an empty hand to empty a slot, or /toggle dropper clear to clear all slots.",
+        ["itemshooter", "filld"], 8
+    ],
+    hopper = [1,
+        "automatically filling hoppers upon placement",
+        "Sets your preferred default hopper contents to your currently held itemstack. Use an empty hand to empty a slot, or /toggle hopper clear to clear all slots.",
+        ["itemtransporter", "fillh"], 4
+    ]
+)
+
+defaults = {
+    0: list,
+    1: dict,
+    2: list
+}
+
+piston_faces = {
+    BlockFace.DOWN  : 0,
+    BlockFace.UP    : 1,
+    BlockFace.NORTH : 2,
+    BlockFace.SOUTH : 3,
+    BlockFace.WEST  : 4,
+    BlockFace.EAST  : 5
+}
+
+torch_faces = {
+    1: BlockFace.WEST,
+    2: BlockFace.EAST,
+    3: BlockFace.NORTH,
+    4: BlockFace.SOUTH,
+    5: BlockFace.DOWN
+}
+
+playerSettings = open_json_file("blockplacemods", {})
+
+for setting, details in settingInformation.iteritems():
+    if playerSettings.get(setting) == None:
+        playerSettings[setting] = defaults[details[0]]()
+
+def get(setting):
+    return playerSettings[setting]
+
+def saveSettings():
+    save_json_file("blockplacemods", playerSettings)
+
+def getSettingDetails(arg):
+    try:
+        arg = arg.lower()
+        for setting, details in settingInformation.iteritems():
+            if setting == arg or arg in details[3]:
+                return (setting, details)
+    except:
+        error(trace())
+    raise CommandException(" &cThat setting could not be found.\n For command help, use &o/toggle &cor &o/set")
+
+@simplecommand("toggle",
+        aliases = ["setting", "set", "config"],
+        usage = "<setting> [value|info]",
+        description = "Toggles or sets your preferences for our redstone \nutilities. The following settings are available:\n" + ", ".join([x for x in settingInformation]),
+        senderLimit = 0,
+        helpNoargs = True,
+        helpSubcmd = True,
+        amax = 2)
+def toggle_command(sender, command, label, args):
+    setting, details = getSettingDetails(args[0])
+    Validate.isAuthorized(sender, "utils.toggle." + setting, "that setting")
+
+    values = get(setting)
+    player = server.getPlayer(sender.getName())
+    uuid   = uid(player)
+    arglen = len(args)
+
+    if details[0] in (0,2): # Toggle
+        default = details[0] == 0 # If True: toggle on if list doesn't contain the uuid
+
+        enabled = (uuid not in values) == default #Invert if details[0] == 2 (toggle disabled by default)
+        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: [on|enable|off|disable|toggle|switch|info]\n &6Aliases: %s" % (setting, details[2], ", ".join(details[3]))
+            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. \n Use &o/toggle %s info &cfor more information" % (arg2, setting)
+        if enabled is new:
+            return " &cAlready %s: &a%s" % ("enabled" if enabled else "disabled", details[1])
+        if new is default:
+            values.remove(uuid)
+        else:
+            values.append(uuid)
+        saveSettings()
+        return (" &aEnabled " if new else " &aDisabled ") + details[1]
+
+
+    elif details[0] == 1: # Save ItemStack in hand
+        arg2 = args[1].lower() if arglen > 1 else ""
+        enabled = uuid in values
+
+        if arg2 == "clear":
+            if enabled:
+                del values[uuid]
+                saveSettings()
+                return " &aDisabled " + details[1]
+            return " &cAlready disabled: " + details[1]
+
+        if arg2 == "info":
+            return " &aSetting %s:\n &9%s \n&6Accepted arguments: [<slot>|clear|details]" % (setting, details[2])
+
+        slot = int(arg2) if arg2.isdigit() else 0
+        if not (0 <= slot <= details[4]):
+            return " &cSlot number must be more than or equal to 0 and less than or equal to %s!" % details[4]
+
+        item = fromStack(player.getItemInHand())
+        if item[0] == 0 or item[1] <= 0:
+            if enabled:
+                items = values[uuid]
+                if slot in items:
+                    del items[slot]
+                    if len(items) == 0:
+                        del items
+                        saveSettings()
+                        return " &aDisabled " + details[1]
+                    saveSettings()
+                    return " &aCleared slot %s of setting %s" % (slot, setting)
+                return " &cSlot %s of setting %s was already cleared!" % (slot, setting)
+            return " &cAlready disabled: " + details[1]
+
+        if arglen == 2 and not arg2.isdigit():
+            return " &cArgument '%s' was not recognized. \nUse &o/toggle %s info &cfor more information." % (arg2, setting)
+
+        if not enabled:
+            values[uuid] = {}
+        values[uuid][slot] = item
+        saveSettings()
+        return ((" &aEnabled setting %s, S" % setting) if len(values[uuid]) == 1 else " &aS") + "et itemstack in slot %s to item in hand" % (slot)
+
+    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)) == (settingInformation[toggleSetting][0] == 0) #Invert if off by default
+
+
+
+@hook.event("block.BlockPlaceEvent", "monitor")
+def on_block_place(event):
+    try:
+
+        if event.isCancelled():
+            return
+        player = event.getPlayer()
+        if not is_creative(player):
+            return
+
+        uuid     = uid(player)
+        block    = event.getBlockPlaced()
+        material = block.getType()
+
+
+        if (material in (Material.WOOD_STEP, Material.STEP)
+            and isEnabled("slab", uuid)
+            and player.hasPermission("utils.toggle.slab")
+            and block.getData() < 8
+            ):
+            block.setData(block.getData() + 8) # Flip upside down
+
+
+        elif (material == Material.CAULDRON
+            and isEnabled("cauldron", uuid)
+            and player.hasPermission("utils.toggle.cauldron")
+            ):
+            block.setData(3) #3 layers of water, 3 signal strength
+
+
+        elif ((material == Material.FURNACE and player.hasPermission("utils.toggle.furnace"))
+            or (material == Material.DROPPER and player.hasPermission("utils.toggle.dropper"))
+            or (material == Material.HOPPER and player.hasPermission("utils.toggle.hopper"))
+            ):
+            stacks = get(str(material).lower()).get(uuid)
+            if stacks != None: # Enabled
+                state = block.getState()
+                inv = state.getInventory()
+                for slot, stack in stacks.iteritems():
+                    inv.setItem(int(slot), toStack(stack))
+                state.update()
+
+
+        elif (material == Material.REDSTONE_TORCH_ON
+            and isEnabled("torch", uuid)
+            and player.hasPermission("utils.toggle.torch")
+            and block.getData() in torch_faces
+            and block.getRelative(torch_faces[block.getData()]).getType() is Material.REDSTONE_BLOCK
+            ):
+            torches_to_break.append(block)
+
+
+        elif (material in (Material.PISTON_BASE, Material.PISTON_STICKY_BASE)
+            and isEnabled("piston", uuid)
+            and player.hasPermission("utils.toggle.piston")
+            ):
+            block.setData(piston_faces[block.getFace(event.getBlockAgainst())])
+    except:
+        error(trace())
+
+
+@hook.event("player.PlayerInteractEvent", "monitor")
+def on_interact(event):
+    player = event.getPlayer()
+    if (isEnabled("cauldron", uid(player))
+        and player.hasPermission("utils.toggle.cauldron")
+        and is_creative(player)
+        and event.getAction() == Action.RIGHT_CLICK_BLOCK
+        and (not event.hasItem() or event.getItem().getType() == Material.REDSTONE)
+        and event.getClickedBlock().getType() == Material.CAULDRON
+        ):
+        block = event.getClickedBlock()
+        event2 = BlockBreakEvent(block, player)
+        server.getPluginManager().callEvent(event2)
+        if not event2.isCancelled():
+            block.setData(block.getData() - 1 if block.getData() > 0 else 3)
+
+
+break_torches = True
+torches_to_break = deque()
+
+def stop_breaking_torches():
+    break_torches = False
+    info("[BlockPlaceMods] Interrupted torch breaking thread")
+
+
+class JBukkitRunnable(BukkitRunnable):
+
+    def __init__(self, func):
+        self.run = func
+
+
+def torch_breaker():
+
+    try:
+        if break_torches:
+            for i in range(len(torches_to_break)):
+                block = torches_to_break.popleft()
+                mat = block.getType()
+                if mat == Material.REDSTONE_TORCH_OFF:
+                    block.setTypeId(0)
+                elif mat == Material.REDSTONE_TORCH_ON:
+                    if block.getData() in torch_faces and block.getRelative(torch_faces[block.getData()]).getType() is Material.REDSTONE_BLOCK:
+                        torches_to_break.append(block)
+    except:
+        error(trace())
+
+
+def schedule_torch_breaker():
+    JBukkitRunnable(torch_breaker).runTaskTimer(server.getPluginManager().getPlugin("RedstonerUtils"), 0, 1)

calc.py

@@ -0,0 +1,110 @@
+from helpers import *
+import threading
+import time
+
+calc_users        = open_json_file("calc", [])
+math_operators    = ["+", "-", "*", "/", "%", ">", "<", "^", "&", "|"]
+allowed_strings   = ["0b", "0x", "(", ")", "hex(", "bin(", "abs(", "int(", "min(", "max(", "round(", "float("]
+allowed_alpha     = ["a", "b", "c", "d", "e", "f"]
+calc_perm = "utils.calc"
+calc_perm_power = "utils.calc.power"
+
+def calc(sender, text):
+    try:
+        return do_calc(sender, text.lower())
+    except:
+        return None
+
+def do_calc(sender, text):
+    """
+    extracts a mathematical expression from `text`
+    returns (expression, result) or None
+    """
+    expression = ""
+    should_calc = False
+    i = 0
+    while True:
+        if i >= len(text):
+            break
+        char = text[i]
+        if i < len(text) - 5 and str(char + text[i+1] + text[i+2] + text[i+3] + text[i+4] + text[i+5]) in allowed_strings:
+            expression += char
+            expression += text[i + 1]
+            expression += text[i + 2]
+            expression += text[i + 3]
+            expression += text[i + 4]
+            expression += text[i + 5]
+            i += 5
+            should_calc = True
+        elif i < len(text) - 3 and str(char + text[i+1] + text[i+2] + text[i+3]) in allowed_strings:
+            expression += char
+            expression += text[i + 1]
+            expression += text[i + 2]
+            expression += text[i + 3]
+            i += 3
+            should_calc = True
+        elif i < len(text) - 1 and str(char + text[i + 1]) in allowed_strings:
+            expression += char
+            expression += text[i + 1]
+            i += 1
+            should_calc = True
+        elif char.isdigit() or char in allowed_alpha or (expression and char == ".") or (should_calc and char == " ") or (should_calc and char == ","):
+            expression += char
+            should_calc = True
+        elif char in math_operators or char in ["(", ")"]:
+            # calculation must include at least 1 operator
+            should_calc = True
+            expression += char
+        elif should_calc and char.isalpha():
+            # don't include any more text in the calculation
+            break
+        i += 1
+    last_char = ' '
+    for char in expression:
+        if last_char == '*' and char == '*':
+            if sender.hasPermission(calc_perm_power):
+                break
+            else:
+                return None
+        last_char = char
+    if should_calc:
+        try:
+            result = str(eval(expression)) # pylint: disable = W0123
+        except: # pylint: disable = W0702
+            # we can run into all kinds of errors here
+            # most probably SyntaxError
+            return None
+        return (expression, result)
+    return None
+
+def thread_calc(message, sender):
+    output = calc(sender, message)
+    if output and sender.isOnline():
+        msg(sender, "&2=== Calc: &e" + output[0] + " &2= &c" + output[1])
+
+@hook.event("player.AsyncPlayerChatEvent", "monitor")
+def on_calc_chat(event):
+    sender = event.getPlayer()
+    message = event.getMessage()
+    if not event.isCancelled() and uid(sender) in calc_users and sender.hasPermission(calc_perm):
+        thread = threading.Thread(target=thread_calc, args=(message, sender))
+        thread.daemon = True
+        thread.start()
+
+
+@hook.command("calc", description="Toggles chat calculations")
+def on_calc_command(sender, command, label, args):
+    plugin_header(sender, "Chat Calculator")
+    if not sender.hasPermission(calc_perm):
+        noperm(sender)
+        return True
+    if not checkargs(sender, args, 0, 1):
+        return True
+    if not is_player(sender):
+        msg(sender, "&cYou are not a player!")
+        return True
+
+    toggle(sender, calc_users, name = "Calc")
+    save_json_file("calc", calc_users)
+
+    return True

chatalias.py

@@ -0,0 +1,402 @@
+# TODO: Add cg/ac/msg support
+
+import os
+import mysqlhack
+import org.bukkit as bukkit
+from org.bukkit import *
+from helpers import *
+
+
+# Version number and requirements
+
+alias_version = "2.1.0"
+helpers_versions = ["1.1.0", "2.0.0"]
+enabled = False
+error_msg = colorify("&cUnspecified error")
+commands_per_page = 5
+global_aliases = {"./":"/"}
+data = {}
+use_mysql = True
+
+# Permissions:
+
+# Grants full access immediately
+permission_ALL = "utils.alias.*"
+# Access to the command to display the help screen
+permission_BASE = "utils.alias"
+# Make replacements only when the user has this permission
+permission_USE = "utils.alias.use"
+# Modify aliases
+permission_MODIFY = "utils.alias.modify"
+permission_MODIFY_OTHERS = "utils.alias.modify.others"
+# List aliases
+permission_LIST = "utils.alias.list"
+permission_LIST_OTHERS = "utils.alias.list.others"
+# Set alias amounts/length limits, e.g. utils.alias.amount.420
+permission_AMOUNT = "utils.alias.amount."
+default_alias_limit = 15
+permission_LENGTH = "utils.alias.length."
+default_length_limit = 120
+# See when the plugin was disabled due to version errors
+permission_INFO = "utils.alias.info"
+permission_FINFO = "utils.alias.finfo"
+
+
+def safe_open_json(uuid):
+    if not os.path.exists("plugins/redstoner-utils.py.dir/files/aliases"):
+        os.makedirs("plugins/redstoner-utils.py.dir/files/aliases")
+    value = open_json_file("aliases/" + uuid)
+    if value is None:
+        value = dict(global_aliases)
+        save_json_file("aliases/" + uuid, value)
+    return value
+
+
+def get_player_alias_limit(player):
+    value = get_permission_content(player, permission_AMOUNT)
+    if value is not None and value.isdigit():
+        return int(value)
+    return default_alias_limit
+
+
+def get_player_length_limit(player):
+    value = get_permission_content(player, permission_LENGTH)
+    if value is not None and value.isdigit():
+        return int(value)
+    return default_length_limit
+
+
+@hook.event("player.PlayerJoinEvent", "high")
+def on_join(event):
+    if enabled:
+        t = threading.Thread(target=load_data, args=(uid(event.getPlayer()), ))
+        t.daemon = True
+        t.start()
+    else:
+        if event.getPlayer().hasPermission(permission_FINFO):
+            disabled_fallback(event.getPlayer())
+
+
+@hook.event("player.AsyncPlayerChatEvent", "high")
+def on_player_chat(event):
+    if enabled:
+        if event.isCancelled():
+            return
+        player = event.getPlayer() 
+        if not hasPerm(player, permission_USE):
+            return
+        msg_limit = get_player_length_limit(player)
+        for alias, value in data[uid(player)].iteritems():
+            if player.hasPermission("essentials.chat.color"):
+                event.setMessage(event.getMessage().replace(colorify(alias), colorify(value)))
+            else:
+                event.setMessage(event.getMessage().replace(alias, value))
+            if not player.hasPermission(permission_ALL) and len(event.getMessage()) > msg_limit:
+                event.setCancelled(True)
+                plugin_header(player, "Chatalias")
+                msg(player, "The message you wanted to generate would exceed the length limit limit of %d. Please make it shorter!" % msg_limit)
+                return
+
+
+def hasPerm(player, permission):
+    return (player.hasPermission(permission)) or (player.hasPermission(permission_ALL))
+
+
+def disabled_fallback(receiver):
+    if not hasPerm(receiver, permission_INFO):
+        msg(receiver, colorify("&cUnknown command. Use &e/help&c, &e/plugins &cor ask a mod."))
+    else:
+        msg(receiver, colorify("&cPlugin alias v" + alias_version + " has experienced an &eEMERGENCY SHUTDOWN:"))
+        msg(receiver, error_msg)
+        msg(receiver, colorify("&cPlease contact a dev/admin (especially pep :P) about this to take a look at it."))
+
+
+def can_remote(player):
+    return hasPerm(player, permission_LIST_OTHERS) or hasPerm(player, permission_MODIFY_OTHERS)
+
+
+# Command
+
+@hook.command("alias",
+              usage="/<command> <add, remove, list, help> [...]",
+              desc="Allows aliasing of words")
+def on_alias_command(sender, cmd, label, args):
+    plugin_header(sender, "Chatalias")
+    try:
+        args = array_to_list(args)
+        if not enabled:
+            disabled_fallback(sender)
+            return
+        if not hasPerm(sender, permission_BASE):
+            noperm(sender)
+            return
+        if args[0].lower() != "player" and not is_player(sender):
+            msg(sender, "&cThe console cannot have aliases")
+            return True
+        subcommands[args[0].lower()](sender, args[1:])
+    except:
+        subcommands["help"](sender, "1")
+    return True
+
+
+def help(sender, args):
+    commands = [colorify("&e/alias help [page]")]
+    if hasPerm(sender, permission_LIST):
+        commands += [colorify("&e/alias list &7- Lists all your aliases")]
+    if hasPerm(sender, permission_MODIFY):
+        commands += [colorify("&e/alias add <word> <alias> &7- Add an alias")]
+        commands += [colorify("&e/alias remove <word> &7- Remove an alias")]
+    if can_remote(sender):
+        while len(commands) < commands_per_page:
+            commands += [""]
+        commands += [colorify("&7Following commands will be executed on <player> yet all output will be redirected to you, except when you set silent to false, then <player> will see it too.")]
+    if hasPerm(sender, permission_LIST_OTHERS):
+        commands += [colorify("&e/alias player <name> list [silent]")]
+    if hasPerm(sender, permission_MODIFY_OTHERS):
+        commands += [colorify("&e/alias player <name> add <word> <alias> [silent]")]
+        commands += [colorify("&e/alias player <name> remove <word> [silent]")]
+    pages = (len(commands)-1)/commands_per_page + 1
+    page = 1
+    if len(args) != 0:
+        page = int(args[0])
+    if (page > pages):
+        page = pages
+    if page < 1:
+        page = 1
+    msg(sender, colorify("&e---- &6Help &e-- &6Page &c" + str(page) + "&6/&c" + str(pages) + " &e----"))
+    page -= 1
+    to_display = commands[5*page:5*page+5]
+    for message in to_display:
+        msg(sender, message)
+    if page+1 < pages:
+        msg(sender, colorify("&6To display the next page, type &c/alias help " + str(page+2)))
+
+
+def add(sender, args):
+    uuid = uid(sender)
+    args = [args[0]] + [" ".join(args[1:])]
+    if (args[0] not in data[uuid]) and is_alias_limit_reached(sender, sender):
+        return
+    if not add_alias_data(uuid, args[0], args[1]):
+        msg(sender, colorify("&c") + "Could not add this alias because it would cause some sequences to be replaced multiple times", usecolor = False)
+        return
+    msg(sender, colorify("&7Alias: ") + args[0] + colorify("&7 -> ") + args[1] + colorify("&7 was succesfully created!"), usecolor=sender.hasPermission("essentials.chat.color"))
+
+
+def radd(sender, sender_name, target, args, silent):
+    if len(args) < 2:
+        msg(sender, "&cYou must pass a sequence and an alias for it")
+        return
+    replaced = args[0]
+    alias = " ".join(args[1:])
+    uuid = uid(target)
+    if not silent:
+        if sender is not target:
+            plugin_header(target, "Chatalias")
+        msg(target, "&cPlayer %s &cis creating an alias for you!" % sender_name)
+    if (replaced not in data[uuid]) and is_alias_limit_reached(target, sender, silent):
+        return
+    if not add_alias_data(uuid, replaced, alias):
+        message = colorify("&c") + "Could not add this alias because it would cause some sequences to be replaced multiple times"
+        msg(sender, message, usecolor = False)
+        if not silent:
+            msg(target, message, usecolor = False)
+        return
+    message = colorify("&7Alias: &7%s&7 -> &7%s&7 was successfully created!") % ((colorify(replaced), colorify(alias)) if target.hasPermission("essentials.chat.color") else (replaced, alias))
+    msg(sender, message, usecolor = False)
+    if not silent:
+        msg(target, message, usecolor = False)
+
+
+def is_alias_limit_reached(player, recipient, silent = True):
+    if player.hasPermission(permission_ALL):
+        return False
+    alias_limit = get_player_alias_limit(player)
+    if len(data[uid(player)]) >= alias_limit:
+        message = ("&cYour limit of %d has been reached" if player is recipient else "&cThe limit of %d has been reached for that player") % alias_limit
+        msg(recipient, message)
+        if not silent:
+            msg(player, message)
+        return True
+    return False
+
+
+def add_alias_data(puuid, aliased, new_alias):
+    prior = dict(data[puuid])
+    if aliased in prior:
+        info("Checking prior, removing previous alias for " + aliased)
+        del prior[aliased]
+
+    # prevent 2 -> 3 if there is 1 -> 2
+    for alias in prior.values():
+        if aliased in alias:
+            info("aliased %s in alias %s" % (aliased, alias))
+            return False
+
+    # prevent 1 -> 2 if there is 2 -> 3
+    for sequence in prior:
+        if sequence in new_alias:
+            info("sequence %s in new_alias %s" % (sequence, new_alias))
+            return False
+
+    data[puuid][aliased] = new_alias
+    save_data(puuid)
+    return True
+
+
+def remove(sender, args):
+    try:
+        msg(sender, colorify("&7Successfully removed alias ") + args[0] + colorify(" &7-> ") + data[uid(sender)].pop(args[0]) + colorify("&7!"), usecolor=sender.hasPermission("essentials.chat.color"))
+        save_data(uid(sender))
+    except:
+        msg(sender, colorify("&cCould not remove alias ") + args[0] + colorify(", it does not exist."), usecolor=sender.hasPermission("essentials.chat.color"))
+
+
+def rremove(sender, sender_name, target, args, silent):
+    if len(args) < 1:
+        msg(sender, "&cYou must specify a sequence whose alias is to be removed")
+        return
+    removed = args[0]
+    uuid = uid(target)
+    aliases = data[uuid]
+    if not silent:
+        msg(target, "&cPlayer %s &cis removing an alias for you!" % sender_name)
+    if removed in aliases:
+        alias = aliases.pop(removed)
+        message = colorify("&7Alias: &7%s&7 -> &7%s&7 successfully removed!") % ((colorify(removed), colorify(alias)) if target.hasPermission("essentials.chat.color") else (removed, alias))
+        msg(sender, message, usecolor = False)
+        if not silent:
+            msg(target, message, usecolor = False)
+        save_data(uuid)
+    else:
+        message = colorify("&cCould not remove alias &7%s&c, it does not exist") % colorify(removed) if target.hasPermission("essentials.chat.color") else removed
+        msg(sender, message, usecolor = False)
+        if not silent:
+            msg(target, message, usecolor = False)
+
+
+def list_alias(sender, args):
+    msg(sender, "&7You have a total of " + str(len(data[uid(sender)])) + " aliases:")
+    for word, alias in data[str(uid(sender))].items():
+        msg(sender, colorify("&7") + word + colorify("&7 -> ") + alias, usecolor=sender.hasPermission("essentials.chat.color"))
+
+
+def rlist_alias(sender, sender_name, target, args, silent):
+    aliases = data[uid(target)]
+    msg(sender, "&7Player %s has a total of %d aliases:" % (target.getName(), len(aliases)))
+    if not silent:
+        if sender is not target:
+            plugin_header(target, "Chatalias")
+        msg(target, "&cPlayer %s &cis listing your aliases" % sender_name)
+    if target.hasPermission("essentials.chat.color"):
+        for pair in aliases.iteritems():
+            msg(sender, colorify("&7%s&7 -> %s" % pair), usecolor = False)
+    else:
+        for pair in aliases.iteritems():
+            msg(sender, colorify("&7%s&7 -> %s") % pair, usecolor = False)
+
+
+def remote(sender, args):
+    if len(args) < 2:
+        msg(sender, "&cAlias remotes take at least 3 arguments")
+        return
+    target_remote = remotes.get(args[1].lower())
+    if target_remote is None:
+        msg(sender, "&cThat remote command does not exist")
+        return
+    target = server.getOfflinePlayer(args[0])
+    if target is None or not (target.hasPlayedBefore() or target.isOnline()):
+        msg(sender, "&cThat player could not be found")
+        return
+    silent = True
+    if len(args) > (2 if target_remote is rlist_alias else 3 if target_remote is rremove else 4):
+        if args[-1].lower() == "false":
+            silent = sender is target or not target.isOnline()
+            args = args[:-1]
+        elif args[-1].lower() == "true":
+            args = args[:-1]
+    target_remote(sender, sender.getDisplayName() if is_player(sender) else colorify("&6Console"), target, args[2:], silent)
+
+
+subcommands = {
+    "help": help,
+    "?": help,
+    "add": add,
+    "remove": remove,
+    "del": remove,
+    "delete": remove,
+    "player": remote,
+    "remote": remote,
+    "list": list_alias
+}
+
+remotes = {
+    "add": radd,
+    "remove": rremove,
+    "del": rremove,
+    "delete": rremove,
+    "list": rlist_alias,
+}
+
+
+# Storage
+# MySQL Table:
+# CREATE TABLE `chatalias` (`uuid` VARCHAR(36) PRIMARY KEY, `alias` TEXT);
+
+def load_data(uuid):
+    if use_mysql:
+        try:
+            t = threading.Thread(target=load_data_thread, args=(uuid,))
+            t.daemon = True
+            t.start()
+        except:
+            error(trace())
+    else:
+        data[uuid] = safe_open_json(uuid)
+
+def load_data_thread(uuid):
+    conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs = conn.cursor()
+    curs.execute("SELECT `alias` FROM `chatalias` WHERE `uuid` = ?;", (uuid, ))
+    results = curs.fetchall()
+    curs.close()
+    conn.close()
+    if len(results) == 0:
+        value = dict(global_aliases)
+    else:
+        value = json_loads(results[0][0])
+    data[uuid] = value
+
+
+def save_data(uuid):
+    if use_mysql:
+        try:
+            t = threading.Thread(target=save_data_thread, args=(uuid,))
+            t.daemon = True
+            t.start()
+        except:
+            error(trace())
+    else:
+        save_json_file("aliases/" + uuid, data[uuid])
+
+def save_data_thread(uuid):
+    conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs = conn.cursor()
+    curs.execute("INSERT INTO `chatalias` (`uuid`, `alias`) VALUES (?, ?) ON DUPLICATE KEY UPDATE `alias` = VALUES(`alias`);", 
+        (uuid, json_dumps(data[uuid])))
+    conn.commit()
+    curs.close()
+    conn.close()
+
+
+# OnModuleLoad
+
+enabled = helpers_version in helpers_versions
+if not enabled:
+    error_msg = colorify("&6Incompatible versions detected (&chelpers.py&6)")
+for player in server.getOnlinePlayers():
+    if enabled:
+        load_data(uid(player))
+    else:
+        if player.hasPermission(permission_FINFO):
+            disabled_fallback(player)

chatgroups.py

@@ -1,20 +1,28 @@
 #pylint: disable = F0401
 from helpers import *
+from basecommands import simplecommand
 from java.util.UUID import fromString as juuid
+from traceback import format_exc as trace
 
 groups         = open_json_file("chatgroups", {})
-cg_key         = ":"
+cg_defaultkey  = ":"
+cg_keys        = open_json_file("chatgroup_keys", {})
 cg_toggle_list = []
 
+def get_key(uuid):
+    key = cg_keys.get(uuid)
+    return key if key != None else cg_defaultkey
 
 
 @hook.command("chatgroup")
-def on_chatgroup_command(sender, args):
+def on_chatgroup_command(sender, command, label, args):
     plugin_header(sender, "ChatGroups")
     sender_id = uid(sender)
     if len(args) == 1 and args[0] == "leave":
         if sender_id in groups.keys():
             groupchat(sender, "left the group", True)
+            if sender in cg_toggle_list:
+                cg_toggle_list.remove(p)
             group = groups[sender_id]
             del(groups[sender_id])
             save_groups()
@@ -24,12 +32,7 @@ def on_chatgroup_command(sender, args):
         if sender_id in groups.keys():
             group = groups[sender_id]
             msg(sender, "&aCurrent chatgroup: %s" % group)
-      users = []
-      for uuid, ugroup in groups.iteritems():
-        if ugroup == group:
-          usr = server.getPlayer(juuid(uuid))
-          if usr:
-            users.append(usr.getDisplayName())
+            users = [user.getDisplayName() for user in [server.getPlayer(juuid(uuid)) for uuid, ugroup in groups.iteritems() if ugroup == group] if user]
             msg(sender, "&aUsers in this group:")
             msg(sender,  "&a%s" % ", ".join(users))
         else:
@@ -39,15 +42,25 @@ def on_chatgroup_command(sender, args):
         groupchat(sender, "joined the group", True)
         save_groups()
         msg(sender, "&aYour chatgroup is set to '%s'" % args[1])
-    msg(sender, "&aUse chat like '&e%s<message>' to send messages to this group." % cg_key)
+        msg(sender, "&aUse chat like '&e%s<message>' to send messages to this group." % get_key(sender_id))
+    elif len(args) == 1 and args[0] == "key":
+        msg(sender, "&aYour chatgroup key is currently: '&c%s&a'" % get_key(sender_id))
+    elif len(args) == 1 and args[0] == "tpahere":
+        if sender_id in groups.keys():
+            do_for_chatgroup(groups[sender_id], send_tpa_request, sender)
+            msg(sender, "&aSent a tpahere request to all users in your chatgroup")
+        else:
+            msg(sender, "&cYou have to be in a chatgroup to do that")
     else:
         msg(sender, "&e/chatgroup join <name>")
         msg(sender, "&e/chatgroup leave")
         msg(sender, "&e/chatgroup info")
+        msg(sender, "&e/chatgroup key")
+        msg(sender, "&e/chatgroup tpahere")
 
 
 @hook.command("cgt")
-def on_cgt_command(sender, args):
+def on_cgt_command(sender, command, label, args):
     p = uid(sender)
     if p in cg_toggle_list:
         cg_toggle_list.remove(p)
@@ -68,11 +81,19 @@ def groupchat(sender, message, ann = False):
         mesg = "&8[&bCG&8] &e&o%s&e&o %s" % (name, message)
     else:
         mesg = "&8[&bCG&8] &f%s&f: &6%s" % (name, message)
+    mesg = colorify(mesg)
+    
     info("[ChatGroups] %s (%s): %s" % (sender.getDisplayName(), group, message))
+    do_for_chatgroup(group, msg, mesg, usecolor = False)
+
+def do_for_chatgroup(group, func, *args, **kwargs):
     for receiver in server.getOnlinePlayers():
-    groups.get(uid(receiver)) == group and msg(receiver, mesg)
-
+        if groups.get(uid(receiver)) == group:
+            func(receiver, *args, **kwargs)
 
+def send_tpa_request(receiver, sender):
+    if not receiver == sender:
+        runas(sender, "/tpahere " + receiver.getName())
 
 def save_groups():
     save_json_file("chatgroups", groups)
@@ -84,9 +105,33 @@ def on_chat(event):
     msge = event.getMessage()
     if not event.isCancelled():
         sender_id = uid(sender)
-    if msge[:len(cg_key)] == cg_key and sender_id in groups.keys():
-      groupchat(sender, msge[1:])
+        key = get_key(sender_id)
+        keylen = len(key)
+        if msge[:keylen] == key and sender_id in groups.keys():
+            groupchat(sender, msge[keylen:])
             event.setCancelled(True)
         elif sender_id in cg_toggle_list:
             groupchat(sender, msge)
             event.setCancelled(True)
+
+@simplecommand("chatgroupkey",
+        aliases = ["cgkey"],
+        senderLimit = 0,
+        helpNoargs = True,
+        helpSubcmd = True,
+        description = "Sets a key character for chatting to your chatgroup",
+        usage = "<key>")
+def chatgroupkey_command(sender, command, label, args):
+    key = " ".join(args)
+    uuid = uid(sender)
+    if key.lower() == "default" or key == cg_defaultkey:
+        del cg_keys[uuid]
+        save_keys()
+        return "&aYour chatgroup key was set to the default character: '&c%s&a'" % cg_defaultkey
+    cg_keys[uid(sender)] = key
+    save_keys()
+    return "&aYour chatgroup key was set to: '&c%s&a'" % key
+
+
+def save_keys():
+    save_json_file("chatgroup_keys", cg_keys)

check.py

@@ -0,0 +1,97 @@
+import json
+import urllib2
+import datetime
+import mysqlhack #pylint: disable = unused-import
+from traceback import format_exc as print_traceback
+from com.ziclix.python.sql import zxJDBC
+from secrets import *
+from helpers import *
+
+
+# receive info based on the user's IP. information provided by ipinfo.io
+def ip_info(player):
+    if player.isOnline():
+        return json.load(urllib2.urlopen("http://ipinfo.io%s/json" % str(player.getAddress().getAddress())))
+    else:
+      return {}
+
+
+# receive first join date based on the player data (may not be accurate)
+def get_first_join(player):
+    first_join = int(player.getFirstPlayed())
+    dt = datetime.datetime.fromtimestamp(first_join/1000.0)
+    return dt.strftime("%Y-%m-%d %H:%M")
+
+
+# receive last seen date based on the player data
+def get_last_seen(player):
+    last_seen = int(player.getLastPlayed())
+    dt = datetime.datetime.fromtimestamp(last_seen/1000.0)
+    return dt.strftime("%Y-%m-%d %H:%M")
+
+
+# receive link and email from website
+def get_website_data(player):
+    conn    = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs    = conn.cursor()
+    uuid = str(uid(player)).replace("-", "")
+    curs.execute("SELECT DISTINCT `id`, `email`, `confirmed` FROM users WHERE `uuid` = ? LIMIT 1", (uuid,))
+    results = curs.fetchall()
+    curs.close()
+    conn.close()
+    return ("http://redstoner.com/users/%s" % results[0][0], results[0][1], False if results[0][2] == 0 else True) if results else (None, None, True)
+
+
+# receive country based on the user's IP
+def get_country(data):
+    return str(data.get("country"))
+
+
+def get_all_names(player):
+    uuid = str(uid(player)).replace("-", "")
+    names = json.load(urllib2.urlopen("https://api.mojang.com/user/profiles/%s/names" % uuid))
+    # [ {"name": "some_name"}, {"name": "other_name"} ]
+    return ", ".join([name["name"] for name in names])
+
+
+# combines data
+def get_all_data(sender, player):
+    data = ip_info(player)
+
+    msg(sender, "")
+
+    try:
+        msg(sender, "&7   -- Data provided by Redstoner")
+        msg(sender, "&6>  UUID: &e%s" % str(uid(player)))
+        msg(sender, "&6>  First joined: &7(y-m-d h:m:s) &e%s" % get_first_join(player))
+        msg(sender, "&6>  Last seen: &7(y-m-d h:m:s) &e%s" % get_last_seen(player))
+        website = get_website_data(player)
+        msg(sender, "&6>  Website account: &e%s" % website[0])
+        msg(sender, "&6>    email: &e%s" % website[1])
+        if not website[2]:
+            msg(sender, "&6>    &cEmail NOT Confirmed!")
+        msg(sender, "&7   -- Data provided by ipinfo.io")
+        msg(sender, "&6>  Country: &e%s" % get_country(data))
+        msg(sender, "&7   -- Data provided by Mojang")
+        msg(sender, "&6>  All ingame names used so far: &e%s" % get_all_names(player))
+    except:
+        # can throw exceptions such as timeouts when Mojang API is down
+        warn(print_traceback())
+        msg(sender, "&cSorry, something went wrong while fetching data")
+
+
+@hook.command("check", description="Displays useful stuff about a user", usage="/check <player>")
+def on_hook_command(sender, command, label, args):
+    if sender.hasPermission("utils.check"):
+        if not checkargs(sender, args, 1, 1):
+            return True
+        plugin_header(sender, "Check")
+        msg(sender, "&7Please notice that the data may not be fully accurate!")
+        player = server.getOfflinePlayer(args[0]) if len(args) > 0 else None
+        
+        t = threading.Thread(target=get_all_data, args=(sender, player))
+        t.daemon = True
+        t.start()
+    else:
+        msg(sender, "&4You don't have the required permissions to execute this command!")
+    return True

cycle.py

@@ -4,7 +4,7 @@ no_cyclers = open_json_file("cycle", [])
 
 
 @hook.command("cycle")
-def on_cycler_command(sender, args):
+def on_cycler_command(sender, command, label, args):
     plugin_header(sender, "Cycle")
     if not is_player(sender):
         msg(sender, "&conly players can do this")
@@ -56,7 +56,7 @@ def on_slot_change(event):
 
 def do_cycle(player, down):
     inv   = player.getInventory()
-  items = inv.getContents()
+    items = inv.getStorageContents()
     shift = -9 if down else 9
     shift = shift % len(items)
     for _ in range(4):
@@ -64,7 +64,7 @@ def do_cycle(player, down):
         uniq_items = sorted(set(list(items)[:9]))  # get unique inventory
         if uniq_items != [None]: # row not empty
             break
-  inv.setContents(items)
+    inv.setStorageContents(items)
 
 def save_cyclers():
     save_json_file("cycle", no_cyclers)

damnspam.py

@@ -1,10 +1,15 @@
 #pylint: disable = F0401
 from helpers import *
 from time import time as now
-import org.bukkit.event.block.BlockBreakEvent as BlockBreakEvent
+import org.bukkit.Material as Material
+import org.bukkit.block.BlockFace as BlockFace
 
 inputs          = open_json_file("damnspam", {}) # format "x;y;z;World"
 accepted_inputs = ["WOOD_BUTTON", "STONE_BUTTON", "LEVER"]
+changing_input  = False
+removing_input  = False
+max_timeout     = 240
+timeout_error_str = "&cThe timeout must be -1 or within 0 and %d" % max_timeout
 
 
 def save_inputs():
@@ -24,24 +29,35 @@ def add_input(creator, block, timeout_off, timeout_on):
     }
 
 
-@hook.command("damnspam")
-def on_dammnspam_command(sender, args):
-  plugin_header(sender, "DamnSpam")
-  if len(args) in [1,2]:
+def is_acceptable_timeout(timeout):
+    return (0 < timeout <= max_timeout) or timeout == -1
 
+
+@hook.command("damnspam")
+def on_dammnspam_command(sender, command, label, args):
+    plugin_header(sender, "DamnSpam")
+
+    if not checkargs(sender, args, 1, 2):
+        msg(sender, "&c/damnspam <seconds> &e(Buttons/Levers)")
+        msg(sender, "&c/damnspam <seconds after off> <seconds after on> &e(Levers only)")
+        return True
+        #Gittestlol
     if not is_creative(sender):
-      msg(sender, "&cYou can only do this in Creative mode.")
+        msg(sender, "&cYou can only do this in Creative mode")
         return True
 
     # /damnspam <secs>
+    destroying_input = False # if both timeouts are 0, the plugin will attempt to remove the protection
     if len(args) == 1:
         timeout_on = args[0]
         try:
             timeout_on  = round(float(timeout_on), 2)
-        timeout_off = timeout_on
-        if not 0 <= timeout_on <= 60:
-          msg(sender, "&cThe timeout must be within 0-60.")
+            if timeout_on == 0:
+                destroying_input = True
+            elif not is_acceptable_timeout(timeout_on):
+                msg(sender, "&cThe timeout must be -1 or within 0 and %d" % max_timeout)
                 return True
+            timeout_off = timeout_on
         except ValueError:
             msg(sender, "&cThe timeout must be a number")
             return True
@@ -53,8 +69,10 @@ def on_dammnspam_command(sender, args):
         try:
             timeout_on  = round(float(timeout_on), 2)
             timeout_off = round(float(timeout_off), 2)
-        if not 0 <= timeout_on <= 60 or not 0 <= timeout_off <= 60:
-          msg(sender, "&cThe timeout must be within 0-60.")
+            if timeout_on == 0 and timeout_off == 0:
+                destroying_input = True
+            elif not (is_acceptable_timeout(timeout_on) and is_acceptable_timeout(timeout_off)):
+                msg(sender, "&cThe timeout must be -1 or within 0 and %d" % max_timeout)
                 return True
         except ValueError:
             msg(sender, "&cThe timeout must be a number")
@@ -67,57 +85,113 @@ def on_dammnspam_command(sender, args):
         msg(sender, "&cPlease look at a button or lever while executing this command!")
         return True
 
-    test_event = BlockBreakEvent(target, sender)
-    server.getPluginManager().callEvent(test_event)
-    if test_event.isCancelled():
-      msg(sender, "&cYou are not allowed to modify this button")
+    global changing_input
+    target_loc_str = location_str(target)
+    if target_loc_str in inputs:
+        changing_input = True # this input already has a timeout
+
+    type_str = ttype.lower().replace("_", " ")
+
+    # test if player is allowed to build here
+    build_check = can_build(sender, target)
+    changing_input = False
+    if not build_check:
+        msg(sender, "&cYou are not allowed to modify this %s" % type_str)
         return True
 
     # add block to inputs
+    if destroying_input:
+        if target_loc_str not in inputs:
+            msg(sender, "&cThere is no timeout to remove on this %s (by setting the timeout to 0)" % type_str)
+            return True
+        del inputs[target_loc_str]
+        msg(sender, "&aSuccessfully removed the timeout for this %s" % type_str)
+    else:
         add_input(sender, target, timeout_off, timeout_on)
+        msg(sender, "&aSuccessfully set a timeout for this %s" % type_str)
     save_inputs()
-    msg(sender, "&aSuccessfully set a timeout for this %s." % ttype.lower())
     return True
 
-  else:
-    msg(sender, "&c/damnspam <seconds> &e(Buttons/Levers)")
-    msg(sender, "&c/damnspam <seconds after off> <seconds after on> &e(Levers only)")
 
-
-@hook.event("block.BlockBreakEvent", "normal")
-def on_block_break(event):
-  sender = event.getPlayer()
-  block = event.getBlock()
-  if str(block.getType()) in accepted_inputs and not event.isCancelled():
+def check_block_break(break_event, block):
+    if str(block.getType()) not in accepted_inputs:
+        return
     pos_str = location_str(block)
-    if inputs.get(pos_str):
-      plugin_header(sender, "DamnSpam")
-      if sender.isSneaking():
-        inputs.pop(pos_str) # remove
+    if pos_str not in inputs:
+        return
+    sender = break_event.getPlayer()
+    input_str = ("this %s" if block is break_event.getBlock() else "the %s attached to that block") % str(block.getType()).lower().replace("_", " ")
+    if not sender.isSneaking():
+        msg(sender, "&cYou cannot destroy " + input_str)
+        msg(sender, "&c&nSneak&c and break or set the timeout to 0 if you want to remove it.")
+        break_event.setCancelled(True)
+        return
+    global removing_input
+    removing_input = True
+    success = can_build(sender, block)
+    removing_input = False
+    if success:
+        del inputs[pos_str]
         save_inputs()
-        msg(sender, "&eSuccessfully removed the input!")
-        return True
+        msg(sender, "&aSuccessfully removed %s!" % input_str)
     else:
-        event.setCancelled(True)
-        msg(sender, "&cYou cannot destroy this input!")
-        msg(sender, "&c&nSneak&c and break if you want to remove it.")
-        return True
+        msg(sender, "&cYou are not allowed to remove " + input_str)
+        break_event.setCancelled(True)
+
+
+# a dict for levers and buttons, with a tuple of tuples as value. The tuples in the tuple represent
+# the data values which the block must have if the block were placed towards the linked blockface to be affected.
+# The order is DOWN, UP, NORTH, SOUTH, WEST, EAST
+attached_blocks = {
+
+    Material.LEVER: ((0, 7, 8, 15), (5, 6, 13, 14), (4, 12), (3, 11), (2, 10), (1, 9)),
+    Material.STONE_BUTTON: ((0, 8), (5, 6, 7, 13, 14, 15), (4, 12), (3, 11), (2, 10), (1, 9)),
+    Material.WOOD_BUTTON: ((0, 8), (5, 6, 7, 13, 14, 15), (4, 12), (3, 11), (2, 10), (1, 9)),
+
+}
+
+# returns a generator containing the levers or buttons that would be broken if this block were broken
+def get_attached_blocks(block):
+    for i, face in ((0, BlockFace.DOWN), (1, BlockFace.UP), (2, BlockFace.NORTH), (3, BlockFace.SOUTH), (4, BlockFace.WEST), (5, BlockFace.EAST)):
+        side = block.getRelative(face)
+        dvalues = attached_blocks.get(side.getType())
+        if dvalues is not None and side.getData() in dvalues[i]:
+            yield side
+
+
+@hook.event("block.BlockBreakEvent", "highest")
+def on_block_break(event):
+    if removing_input or changing_input or event.isCancelled():
+        return
+    block = event.getBlock()
+    check_block_break(event, event.getBlock())
+    for affected_block in get_attached_blocks(block):
+        check_block_break(event, affected_block)
 
 
 @hook.event("player.PlayerInteractEvent", "normal")
 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()
-    btype   = str(block.getType()).lower()
-    powered = (block.getData() & 0x8) == 0x8 if btype == "lever" else False # data > 7, but this is how bukkit does it
         pos_str = location_str(block)
         data    = inputs.get(pos_str)
         if data:
-      checktime = data["timeout_on"] if powered else data["timeout_off"]
-      if data["last_time"] + checktime > now():
-        event.setCancelled(True)
-        plugin_header(sender, "DamnSpam")
-        msg(sender, "&cThis %s has a timeout of %ss." % (btype, checktime))
+            sender = event.getPlayer()
+            btype  = str(block.getType()).lower().replace("_", " ")
+            if btype == "lever" and block.getData() < 8:
+                checktime = data["timeout_off"]
             else:
-        inputs[pos_str]["last_time"] = round(now(), 2)
+                checktime = data["timeout_on"]
+            time_left = data["last_time"] + checktime - now()
+
+            if checktime == -1:
+                event.setCancelled(True)
+                msg(sender, "&cThis %s is locked permanently by /damnspam." % (btype))
+            elif time_left > 0:
+                event.setCancelled(True)
+                msg(sender, "&cThis %s has a damnspam timeout of %.2fs, with %.2fs left." % (btype, checktime, time_left))
+            else:
+                data["last_time"] = round(now(), 2)

forcefield.py

@@ -1,4 +1,5 @@
 #pylint: disable = F0401
+import thread
 from helpers import *
 from org.bukkit.util import Vector
 from math import sin
@@ -16,7 +17,7 @@ whitelists = {} # {ff_owner_id: [white, listed, ids]} (Adding file usage later,
 
 
 @hook.command("forcefield")
-def on_forcefield_command(sender, args):
+def on_forcefield_command(sender, command, label, args):
     if not is_player(sender) or not sender.hasPermission(ff_perm):
         noperm(sender)
         return True
@@ -28,7 +29,7 @@ def on_forcefield_command(sender, args):
     args[0] = args[0].upper() # If it gets to this point, there are argument(s).
     if args[0] in ["WHITELIST", "WL", "WLIST"]: # Whitelist commands
         if not args[1:] or args[1].upper() == "LIST":
-      whitelist_list(sender)
+            thread.start_new_thread(whitelist_list, (sender,))
             return True
 
         args[1] = args[1].upper() # If it gets too this point, there is a second argument.
@@ -88,6 +89,7 @@ def change_whitelist(sender, add, names): #Add names if add == True else Remove
 
 
 def whitelist_list(player):
+    try:
         player_id = uid(player)
         count     = 0
         forcefield_header(player, "&bForcefield whitelist:")
@@ -97,6 +99,8 @@ def whitelist_list(player):
             msg(player, "&b %s. &f%s" % (count, pname))
         if count == 0:
             msg(player, "&c Your whitelist has no entries.")
+    except:
+        warn("Unable to finish whitelist_list process")
 
 
 def whitelist_clear(player):

friends.py

@@ -1,9 +1,14 @@
+import thread
 from helpers import *
 
 friends           = open_json_file("friends", {}) # {Player_UUID:[List_of_friend_uuids]}
 friend_join_sound = "random.orb"
 
 
+def is_friend_of(player, other):
+    lst = friends.get(uid(player))
+    return lst is not None and uid(other) in lst
+
 
 @hook.event("player.PlayerJoinEvent", "high") # creates sound and sends a bold message on friend join
 def fjm(event): # friend join message
@@ -24,7 +29,15 @@ def friendmessage(player, message): # sends a message with a prefix
     msg(player, "&7[&aFriends&7] " + message)
 
 
+def get_player(name):
+    result = server.getOfflinePlayer(name)
+    if result is not None and (result.hasPlayedBefore() or result.isOnline()):
+        return result
+    return None
+
+
 def ls(sender):
+    try:
         sender_friends = friends.get(uid(sender), False)
         if sender_friends:
             friends_string = ""
@@ -33,14 +46,14 @@ def ls(sender):
             friendmessage(sender, "&aYour friends list: " + friends_string[:len(friends_string)-2])
         else:
             friendmessage(sender, "&cYour friends list is empty")
+    except:
+        warn("Unable to finish friends' ls process")
 
 
 def clear(sender):
     sender_id = uid(sender)
 
     if friends.get(sender_id, False):
-    for uuid in friends[sender_id]:
-      friendmessage(retrieve_player(uuid), "&c&o%s &cremoved you from their friends list" % stripcolors(sender.getDisplayName()))
         friends.pop(sender_id)
         friendmessage(sender, "&aFriends list cleared")
         save_friends()
@@ -53,21 +66,25 @@ def add(sender, names):
     added         = []
     notfound      = []
     friendalready = []
+    added_self    = False
 
     if not sender_id in friends:
         friends[sender_id] = []
 
     for name in names:
-    player = server.getPlayer(name)
+        player = get_player(name)
         if player:
             player_id = uid(player)
-      not_yourself = player != sender
+            not_yourself = sender != player
 
             if not player_id in friends[sender_id]:
                 if not_yourself:
                     friends[sender_id].append(player_id)
                     added.append(player.getName())
+                    if player.isOnline():
                         friendmessage(player.getPlayer(), "&a&o%s &aadded you to their friends list" % stripcolors(sender.getDisplayName()))
+                else:
+                    added_self = True
             else:
                 friendalready.append(player.getName())
 
@@ -78,10 +95,10 @@ def add(sender, names):
     if added:
         friendmessage(sender, "&a&o%s&a added." % ", ".join(added))
     if notfound:
-    friendmessage(sender, "&c&o%s&c not found. (must be online)" % ", ".join(notfound))
+        friendmessage(sender, "&c&o%s&c not found." % ", ".join(notfound))
     if friendalready:
         friendmessage(sender, "&c&o%s&c is/are already your friend." % ", ".join(friendalready))
-  if not not_yourself:
+    if added_self:
         friendmessage(sender, "&cYou can't add yourself to your friends list.")
 
 
@@ -92,18 +109,21 @@ def rem(sender, names):
     notafriend = []
 
     for name in names:
-    player = server.Player(name)
+        player = get_player(name)
         if player:
             player_id = uid(player)
             if player_id in friends.get(sender_id, []):
                 friends[sender_id].remove(player_id)
                 removed.append(player.getName())
+                if player.isOnline():
                     friendmessage(player.getPlayer(), "&c&o%s &cremoved you from their friends list" % stripcolors(sender.getDisplayName()))
             else:
                 notafriend.append(player.getName())
         else:
             notfound.append(name)
 
+    if not friends.get(sender_id, False):
+        del friends[sender_id]
     save_friends()
     if removed:
         friendmessage(sender, "&a&o%s&a removed." % ", ".join(removed))
@@ -123,7 +143,8 @@ def fhelp(sender):
 
 
 @hook.command("friends")
-def on_friend_command(sender, args):
+def on_friend_command(sender, command, label, args):
+    try:
         if not is_player(sender):
             friendmessage(sender, "&c&lYou can't have friends!")
             return True
@@ -133,7 +154,7 @@ def on_friend_command(sender, args):
 
         # /friends list
         if cmd in ["list", "lst", "*"]:
-    ls(sender)
+            thread.start_new_thread(ls, (sender,))
 
         # /friends clear
         elif cmd in ["clear", "/"]:
@@ -156,3 +177,5 @@ def on_friend_command(sender, args):
         else:
             fhelp(sender)
         return True
+    except:
+        error(trace())

helpers.py

@@ -6,26 +6,53 @@ import org.bukkit as bukkit
 import org.bukkit.Location as Location
 import org.bukkit.entity.Player as Player
 import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause as TeleportCause
+import org.bukkit.event.block.BlockBreakEvent as BlockBreakEvent
 import org.bukkit.block as bblock
+import org.bukkit.event.entity as entity
+import org.bukkit.command.ConsoleCommandSender
+from org.bukkit.entity import *
 
+#Imports for async query
+from secrets import *
+import mysqlhack
+from com.ziclix.python.sql import zxJDBC
+import threading
 
+from traceback import format_exc as trace
+
+helpers_version = "2.0.0"
 shared = {} # this dict can be used to share stuff across modules
 
 server = bukkit.Bukkit.getServer()
 
 
 def info(text):
+    """
+    Log info to console
+    """
     server.getLogger().info("[RedstonerUtils] %s" % text)
 
 
 def warn(text):
+    """
+    Log warning to console
+    """
     server.getLogger().warning("[RedstonerUtils] %s" % text)
 
 
 def error(text):
+    """
+    Log error to console
+    """
     server.getLogger().severe("[RedstonerUtils] %s" % text)
 
 
+def fine(text):
+    """
+    Log anything to the logs alone, not the console
+    """
+    server.getLogger().fine(text)
+
 def msg(player, text, usecolor = True, basecolor = None):
     """
     send a message to player
@@ -33,7 +60,7 @@ def msg(player, text, usecolor = True, basecolor = None):
     unless usecolor is False, &-codes are translated to real color codes
     for that case, basecolor can be useful. basecolor accepts a single character as color code
     """
-  if player and (player == server.getConsoleSender() or player.getPlayer()): # getPlayer() returns None when offline
+    if player and (player == server.getConsoleSender() or player.isOnline()): # getPlayer() returns None when offline
         if basecolor:
             if usecolor:
                 text = colorify(text)
@@ -42,15 +69,16 @@ def msg(player, text, usecolor = True, basecolor = None):
             player.sendMessage(colorify(text) if usecolor else text)
 
 
-def broadcast(perm, text):
+def broadcast(perm, text, usecolor = True):
     """
     better than bukkit's broadcast.
     bukkit only works with permissibles that are subscribed to perm
     """
+    if usecolor:
         text = colorify(text)
     for recipient in list(server.getOnlinePlayers()) + [server.getConsoleSender()]:
         if not perm or recipient.hasPermission(perm):
-      msg(recipient, text)
+            msg(recipient, text, usecolor = False)
 
 
 def colorify(text):
@@ -90,14 +118,20 @@ def plugin_header(recipient = None, name="Redstoner Utils"):
 
 
 def noperm(player):
+    """
+    Send the default permission failure message to the player
+    """
     msg(player, "&cno permission")
 
 
 def runas(player, cmd):
     """
     run a command as player
-  the cmd should no be prefixed with a /
+    the cmd should NOT be prefixed with a /
     """
+    if is_player(player):
+        player.chat("/" + cmd)
+    else:
         server.dispatchCommand(player, cmd)
 
 
@@ -108,6 +142,15 @@ def is_player(obj):
     return (isinstance(obj, Player))
 
 
+def can_build(player, block):
+    """
+    return True if the player can change/build at the location of given block
+    """
+    event = BlockBreakEvent(block, player)
+    server.getPluginManager().callEvent(event)
+    return not event.isCancelled()
+
+
 def checkargs(sender, args, amin, amax):
     """
     check if a command has a valid amount of args, otherwise notify the sender
@@ -129,13 +172,6 @@ def checkargs(sender, args, amin, amax):
     return True
 
 
-def warp(player, args, warpname):
-  if not checkargs(player, args, 0, 1):
-    return False # You can check if it worked
-  runas(player, "warp %s" % warpname)
-  return True
-
-
 def is_creative(player):
     """
     returns True if the player is in Creative mode
@@ -166,25 +202,48 @@ def known_player(player):
     """
     return player.hasPlayedBefore()
 
+"""
+Runs a async query, calls target function with fetchall as an argument, it will be an empty list if there is nothing to fetch.
+(So make sure your function takes that argument.)
 
-def open_json_file(filename, default):
+If you want your function to run sync in the case you are doing something spigot wouldn't like to be async use the bukkit scheduler.
+Example can be found in loginsecurity.py
+
+"""
+def async_query(mysql_database,query,query_args,target,*target_args,**target_kwargs):
+
+    def async_query_t(mysql_database,query,query_args,target,target_args,target_kwargs):
+        db_conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+        db_curs = db_conn.cursor()
+        db_curs.execute(query,query_args)
+        db_conn.commit()
+        fetchall = db_curs.fetchall()
+        db_curs.close()
+        db_conn.close()
+        target(fetchall,target_args,target_kwargs)
+
+    t = threading.Thread(target=async_query_t,args=(mysql_database,query,query_args,target,target_args,target_kwargs))
+    t.daemon = True
+    t.start()
+
+
+def open_json_file(filename, default = None):
     """
     opens the given json file and returns an object or returns None on error
-  filename is the path + name of the file.
+    filename is only the name of the file without .json appended.
     """
-  data = None
     try:
         with open("plugins/redstoner-utils.py.dir/files/%s.json" % filename) as obj:
-      data = json_loads(obj.read())
+            default = json_loads(obj.read())
     except Exception, e:
         error("Failed to read from %s: %s" % (filename, e))
-  return (default if data is None else data)
+    return default
 
 
 def save_json_file(filename, obj):
     """
     saves the given object as json into filename
-  filename is the path + name of the file.
+    filename is only the name of the file without .json appended.
     """
     try:
         with open("plugins/redstoner-utils.py.dir/files/%s.json" % filename, "w") as f:
@@ -193,27 +252,72 @@ def save_json_file(filename, obj):
         error("Failed to write to %s: %s" % (filename, e))
 
 
-def toggle(player, ls, add = None, on = "&aToggle now on!", off = "&cToggle now off!", already = "&cToggle was already %s"):
+def toggle(player, ls, name = "Toggle", add = None):
     """
-  Toggle presence of a player's UUID in a list (ls)
-  'add' controls if a player should be added(True) or removed(False)
-  if 'add' is None, ls will simply be toggled for that player.
-  when 'add' is given, but won't change anything, %s in 'already' is replaced with "ON" or "OFF"
+    Toggles presence of a player's UUID in a list
+    If add is given, True explicitely adds it whereas False removes it
     """
-
     pid = uid(player)
-  enabled = pid in ls
-
-  # Do some checks and remove pid.
-  if enabled and add == False:
+    if pid in ls or add is False:
         ls.remove(pid)
-    msg(player, on)
-
-  # Do some checks and append pid.
-  elif not enabled and add == True:
+        msg(player, "&a%s turned off!" % name)
+    elif add is not False:
         ls.append(pid)
-    msg(player, off)
+        msg(player, "&a%s turned on!" % name)
 
-  # Already on/off (optional)
+
+
+def send_JSON_message(playername, message):
+    bukkit.Bukkit.getServer().dispatchCommand(bukkit.Bukkit.getServer().getConsoleSender(), "tellraw " + playername + " " + message)
+
+
+# Allows to check if a String is a valid IPv4 or not. Accepts any string, returns true if the String is a valid IPv4
+def is_ip(tocheck):
+    subsets = ["","","",""]
+    i = 0
+    for j in range(0,len(tocheck)):
+        if not (tocheck[j] in "0123456789."):
+            return False
+        elif tocheck[j] == ".":
+            i += 1
+            if (i >= 4):
+                return False
         else:
-    msg(player, already % (" ON" if add else " OFF"))
+            subsets[i] +=  tocheck[j]
+    if not (i == 3):
+        return False
+    for j in range(0,3):
+        if not ((int(subsets[j]) >= 0) & (int(subsets[j]) <= 255)):
+            return False
+    return True
+
+
+# Allows the use of e.g. numeric permission nodes like "permission.amount.5" and similar.
+# To get the data fetch the player and the start of the permission node, looking like "permission.amount."
+def get_permission_content(player, permnode, default_value = None):
+    try:
+        perms = player.getEffectivePermissions()
+        for perm in perms:
+            if str(perm.getPermission()).startswith(permnode):
+                   return str(perm.getPermission())[len(permnode):]
+        return default_value
+    except:
+        error(trace())
+
+
+def array_to_list(array):
+    return_list = []
+    for a in array:
+        return_list.append(a)
+    return return_list
+
+
+#debug wrapper
+def debug(func):
+    def wrap(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except:
+            error(trace())
+            return None
+    return wrap

imbusy.py

@@ -0,0 +1,251 @@
+"""
+This plugin permits users to   
+send a command that renders    
+them "busy", not letting them  
+to get tpa requests or direct 
+messages, except from console. 
+On restart, all busy data will 
+be cleared.                    
+"""
+
+from helpers import *
+from friends import is_friend_of
+import org.bukkit.command.Command as Command
+from time import time as now
+
+imbusy_version = "v1.1.0"
+
+base_permission = "utils.imbusy" # for /busy status
+use_permission = "utils.imbusy.use" # for being busy
+override_permission = "utils.imbusy.override" # for being able to bother busy people
+
+busy_status_change_timeout = 15 # seconds
+
+busy_players = {} # name : (status, timeout_expire)
+# possible statuses: True if SUPER busy, False if normal busy, None if not busy
+
+
+@hook.command("imbusy",
+    aliases = ["busy"],
+    usage = "/<command> [on, off, status/check]",
+    description = "Offers control over your busy status"
+    )
+@debug
+def on_busy_command(sender, cmd, label, args):
+    if not is_player(sender):
+        msg(sender, "&7Sorry, Console cannot be busy")
+        return True
+
+    plugin_header(recipient = sender, name = "I'M BUSY!")
+
+    if not sender.hasPermission(base_permission):
+        noperm(sender)
+        return True
+
+    if len(args) == 0:
+        return toggle(sender)
+
+    arg0 = args[0].lower()
+    if arg0 == "on":
+        return on(sender)
+    if arg0 == "off":
+        return off(sender)
+    if arg0 in ("status", "check"):
+        return status(sender, args[1:])
+    if arg0 == "super":
+        return super_cmd(sender)
+    return help(sender)
+
+
+def change_status(target, status):
+    target_name = target.getName()
+    old_status = None
+    if target_name in busy_players:
+        value = busy_players[target_name]
+        time_left = value[1] - now()
+        if time_left > 0:
+            msg(target, "&cYou must wait %.2fs untill you can change your status" % time_left)
+            return
+        old_status = value[0]
+
+    if old_status is status:
+        if status is True:
+            msg(target, "&cYou are already SUPER busy")
+        elif status is False:
+            msg(target, "&cYou are already busy")
+        else:
+            msg(target, "&cYou weren't busy yet")
+        return
+
+    busy_players[target_name] = (status, now() + busy_status_change_timeout)
+    if status is True:
+        broadcast(None, target.getDisplayName() + " &7is now SUPER busy")
+    elif status is False:
+        broadcast(None, target.getDisplayName() + " &7is now busy")
+    else:
+        broadcast(None, target.getDisplayName() + " &7is not busy anymore")
+
+
+def get_status(target):
+    return busy_players.get(target.getName(), (None,))[0]
+
+
+def toggle(sender):
+    if not sender.hasPermission(use_permission):
+        noperm(sender)
+        return True
+    if get_status(sender) is None:
+        change_status(sender, False)
+    else:
+        change_status(sender, None)
+    return True
+
+
+def help(sender):
+    msg(sender, "Let's you put yourself in busy status, preventing pms and tpa requests from other players")
+    msg(sender, "\n&eCommands:")
+    msg(sender, "&e/busy &7- Toggles busy status")
+    msg(sender, "&e/busy on &7- Turns on busy status")
+    msg(sender, "&e/busy off &7- Turns off busy status")
+    msg(sender, "&e/busy status [player] &7- shows your or [player]'s current busy status")
+    msg(sender, "&e/busy super &7- sets your status to SUPER busy such that even friends can not bother you")
+    return True
+
+
+def on(sender):
+    if not sender.hasPermission(use_permission):
+        noperm(sender)
+        return True
+    change_status(sender, False)
+    return True
+
+
+def off(sender):
+    if not sender.hasPermission(use_permission):
+        noperm(sender)
+        return True
+    change_status(sender, None)
+    return True
+
+
+def status(sender, args):
+    if not sender.hasPermission(base_permission):
+        noperm(sender)
+        return True
+    if len(args) == 0:
+        target = sender
+    else:
+        target = server.getPlayer(args[0])
+        if target is None:
+            msg(sender, "&cThat player is not online")
+            return True
+    status = get_status(target)
+    if status is True:
+        status_str = "SUPER busy"
+    elif status is False:
+        status_str = "busy"
+    else:
+        status_str = "not busy"
+    msg(sender, "&7%s currently %s" % ("You are" if target is sender else "Player %s&7 is" % target.getDisplayName()), status_str)
+    return True
+
+
+def super_cmd(sender):
+    if not sender.hasPermission(use_permission):
+        noperm(sender)
+        return True
+    change_status(sender, True)
+    return True
+
+
+@hook.event("player.PlayerQuitEvent", "lowest")
+def on_player_leave(event):
+    player_name = event.getPlayer().getName()
+    if player_name in busy_players:
+        del busy_players[player_name]
+
+
+# Block any bothering if should be. If a busy player msgs someone else, they can be replied to and /msg'd as well.
+# It's not entirely perfect in that regard as the ability to reply is lost when you are /msg'd by someone else. 
+
+reply_targets = {} # name : (reply_target_name, true if initiated by target)
+
+
+def can_send(sender, target):
+    if target is sender or sender.hasPermission(override_permission):
+        return True
+    status = get_status(target)
+    if status is None:
+        return True
+    return status is False and is_friend_of(target, sender)
+
+
+def whisper(sender, target_name):
+    target = server.getPlayer(target_name)
+
+    if target is not None:
+        sender_name = sender.getName()
+        if not can_send(sender, target):
+            value = reply_targets[sender_name]
+            if value[0] != target_name or value[1] is False:
+                msg(sender, "&c[&fBUSY&c] %s&r is busy!" % target.getDisplayName())
+                return False
+
+        reply_targets[sender_name] = (target_name, False)
+        reply_targets[target_name] = (sender_name, True)
+    return True
+
+
+def reply(sender):
+    sender_name = sender.getName()
+    if sender_name in reply_targets:
+        value = reply_targets[sender_name]
+        target = server.getPlayer(value[0])
+        if target is not None: 
+            if not value[1] and not can_send(sender, target):
+                msg(sender, "&c[&fBUSY&c] %s&r is busy!" % target.getDisplayName())
+                return False
+
+            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])
+
+    def reply_interception(sender, args):
+        return not is_player(sender) or len(args) == 0 or reply(sender)
+
+    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
+        return True
+
+    def tpahere_interception(sender, args):
+        return tpa_command_checker(sender, 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
+        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)
+
+except:
+    error("[Imbusy] Failed to intercept commands:")
+    error(trace())

imout.py

@@ -0,0 +1,32 @@
+from helpers import *
+from adminchat import *
+
+imout_toggle_list = []
+
+@hook.command("imout")
+def on_imout_command(sender, command, label, args):
+    if not is_player(sender):
+        msg(sender, "&cThis command can't be run from the console")
+        return True
+    if sender.hasPermission("utils.imout"):
+        name = sender.getName()
+        symbol = "&a&l+"
+        if name in imout_toggle_list:
+            msg(sender, "&eWelcome back! You are no longer hidden")
+            msg(sender, "&6We disabled /act for you!")
+            runas(sender, "vanish off")
+            if name in imout_toggle_list:
+                imout_toggle_list.remove(name)
+            if name in ac_toggle_list:
+                ac_toggle_list.remove(name)
+        else:
+            symbol = "&c&l-"
+            msg(sender, "&eYou just left... Or didn't you?")
+            imout_toggle_list.append(name)
+            runas(sender, "vanish on")
+            if name not in ac_toggle_list:
+                msg(sender, "&6We enabled /act for you!")
+                ac_toggle_list.append(name)
+
+        broadcast(None, "%s &7%s" % (symbol, name))
+    return True

iptracker.py

@@ -0,0 +1,108 @@
+import mysqlhack
+import org.bukkit as bukkit
+import json
+from java.util import UUID as UUID
+from helpers import *
+from org.bukkit import *
+from traceback import format_exc as trace
+from iptracker_secrets import *
+
+
+iptrack_permission = "utils.iptrack"
+iptrack_version = "1.1.0"
+
+
+@hook.event("player.PlayerJoinEvent", "low")
+def on_player_join(event):
+    t = threading.Thread(target=on_player_join_thread, args=(event, ))
+    t.daemon = True
+    t.start()
+
+def on_player_join_thread(event):
+    player = event.getPlayer()
+    ip = player.getAddress().getHostString()
+    uuid = uid(player)
+    conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs = conn.cursor()
+    curs.execute("SELECT ips FROM uuid2ips WHERE uuid = ?", (uuid, ))
+    results = curs.fetchall()
+    if len(results) == 0:
+        ips = []
+    else:
+        ips = json.loads(results[0][0])
+    curs.execute("SELECT uuids FROM ip2uuids WHERE ip = ?", (ip, ))
+    results = curs.fetchall()
+    if len(results) == 0:
+        uuids = []
+    else:
+        uuids = json.loads(results[0][0])
+    new_ip_entry = (len(ips) == 0)
+    new_uuid_entry = (len(uuids) == 0)
+    if ip not in ips:
+        ips.append(ip)
+        if new_ip_entry:
+            curs.execute("INSERT INTO uuid2ips VALUES (?,?)", (uuid, json.dumps(ips), ))
+        else:
+            curs.execute("UPDATE uuid2ips SET ips = ? WHERE uuid = ?", (json.dumps(ips), uuid, ))
+    if uuid not in uuids:
+        uuids.append(uuid)
+        if new_uuid_entry:
+            curs.execute("INSERT INTO ip2uuids VALUES (?,?)", (ip, json.dumps(uuids), ))
+        else:
+            curs.execute("UPDATE ip2uuids SET uuids = ? WHERE ip = ?", (json.dumps(uuids), ip, ))
+        conn.commit()
+    curs.close()
+    conn.close()
+
+
+@hook.command("getinfo")
+def on_getinfo_command(sender, args):
+    t = threading.Thread(target=on_getinfo_command_thread, args=(sender, args))
+    t.daemon = True
+    t.start()
+
+def on_getinfo_command_thread(sender, args):
+    if(sender.hasPermission(iptrack_permission)):
+        if not checkargs(sender, args, 1, 1):
+            return False
+        else:
+            if is_ip(args[0]):
+                conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+                curs = conn.cursor()
+                curs.execute("SELECT uuids FROM ip2uuids WHERE ip = ?", (args[0], ))
+                results = curs.fetchall()
+                curs.close()
+                conn.close()
+                if len(results) == 0:
+                    msg(sender, "IP " + args[0] + " is not registered in the database, maybe you got a number wrong?")
+                else:
+                    uuids = json.loads(results[0][0])
+                    msg(sender, "IP " + args[0] + " was seen with " + str(len(uuids)) + " different Accounts:")
+                    for i in range(0, len(uuids)):
+                        p=Bukkit.getOfflinePlayer(UUID.fromString(uuids[i]))
+                        if is_player(sender):
+                            send_JSON_message(sender.getName(), '["",{"text":"' + p.getName() + ' - (uuid: ' + uuids[i] + '","color":"gold","clickEvent":{"action":"run_command","value":"/getinfo ' + p.getName() + '"},"hoverEvent":{"action":"show_text","value":{"text":"","extra":[{"text":"To search for ' + p.getName() + ' in the database, simply click the name!","color":"gold"}]}}}]')
+                        else:
+                            msg(sender,p.getName() + " - (uuid: " + uuids[i] + ")")
+            else:
+                target = Bukkit.getOfflinePlayer(args[0])
+                uuid = target.getUniqueId()
+                conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+                curs = conn.cursor()
+                curs.execute("SELECT ips FROM uuid2ips WHERE uuid = ?", (uuid.toString(), ))
+                results = curs.fetchall()
+                curs.close()
+                conn.close()
+                if len(results) == 0:
+                    msg(sender, "Player " + args[0] + " is not registered in the database, maybe you misspelled the name?")
+                else:
+                    ips = json.loads(results[0][0])
+                    msg(sender, "Player " + args[0] + " was seen with " + str(len(ips)) + " different IPs:")
+                    for i in range(0, len(ips)):
+                        if is_player(sender):
+                            send_JSON_message(sender.getName(), '["",{"text":"' + ips[i] + '","color":"gold","clickEvent":{"action":"run_command","value":"/getinfo ' + ips[i] + '"},"hoverEvent":{"action":"show_text","value":{"text":"","extra":[{"text":"To search for the IP ' + ips[i] + ' in the database, simply click the IP!","color":"gold"}]}}}]')
+                        else:
+                            msg(sender,ips[i])
+    else:
+        noperm(sender)
+    return True

lagchunks.py

@@ -37,7 +37,7 @@ def tp_chunk(sender, id):
 
 
 @hook.command("lagchunks")
-def on_lagchunks_command(sender, args):
+def on_lagchunks_command(sender, command, label, args):
     if sender.hasPermission("utils.lagchunks"):
         plugin_header(sender, "Lagchunks")
         global lagchunks

loginsecurity.py

@@ -0,0 +1,276 @@
+from helpers import *
+from passlib.hash import pbkdf2_sha256 as crypt
+from basecommands import simplecommand
+import time
+import threading
+from login_secrets import * #Don't forget to make login_secrets aswell
+import mysqlhack
+from com.ziclix.python.sql import zxJDBC
+from java.lang import Runnable
+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"]
+
+
+
+
+def matches(password,user):
+    thread = threading.Thread(target=matches_thread, args = (password,user))
+    thread.start()
+
+
+def matches_thread(password, user):
+    hashed = get_pass(uid(user))
+    py_player = get_py_player(user)
+    if crypt.verify(password, hashed):
+        if py_player.logging_in:
+            py_player.logging_in = False
+            msg(user, "&aLogged in successfully!")
+    else:
+        if py_player.logging_in:
+            msg(user, "&cInvalid password!")
+
+
+
+
+
+@simplecommand("cgpass",
+    usage       = "<password> <new password>",
+    description = "Changes your password",
+    senderLimit = 0,
+    helpNoargs  = True)
+def change_pass_command(sender, command, label, args):
+    
+    py_player = get_py_player(sender)
+
+    if py_player.logging_in:
+        return "&cYou are not logged in"
+    if not len(args) == 2:
+        return "&cInvalid arguments"
+
+    password = args[0]
+    new_password = args[1]
+    uuid = uid(sender)
+
+    if is_registered(uuid):
+        change_pass(uuid, crypt.encrypt(new_password, rounds=200000, salt_size=16))
+        return "&aPassword changed"
+    return "&cYou are not registered"
+
+
+
+
+@simplecommand("login",
+        usage       = "<password>",
+        description = "Logs you in if <password> matches your password.",
+        senderLimit = 0,
+        helpNoargs  = True)
+def login_command(sender, command, label, args):
+    py_player = get_py_player(sender)
+
+    if not py_player.logging_in:
+        msg(sender,"&cAlready logged in!")
+
+    password = args[0]
+    matches(password, sender)
+
+
+
+
+@simplecommand("register",
+        usage       = "<password>",
+        description = "Registers you with <password>. Next time you join, log in with /login",
+        senderLimit = 0,
+        helpNoargs  = True)
+def register_command(sender, command, label, args):
+
+    py_player = get_py_player(sender)
+
+    if len(args) > 1:
+        return "&cPassword can only be one word!"
+
+    uuid = uid(sender)
+    if is_registered(uuid):
+        return "&cYou are already registered!"
+
+    password = args[0]
+
+    if len(password) < min_pass_length:
+        return "&cThe password has to be made up of at least %s characters!" % min_pass_length
+
+    create_pass(uuid, password)
+    return "&cPassword set. Use /login <password> upon join."
+
+
+
+
+@simplecommand("rmpass",
+        description = "Removes your password if the password matches",
+        senderLimit = 0,
+        amax = 0,
+        helpNoargs  = False)
+def rmpass_command(sender, command, label, args):
+
+    py_player = get_py_player(sender)
+
+    if py_player.logging_in:
+        return "&cYou are not logged in"
+
+    if not is_registered(uid(sender)):
+        return "&cYou are not registered!"
+
+    if py_player.logging_in == False:
+        delete_pass(uid(sender))
+        return "&aPassword removed successfully. You will not be prompted anymore."
+    return "&cFailed to remove password, please contact a staff member"
+
+
+
+
+@simplecommand("rmotherpass",
+        aliases     = ["lacrmpass"],
+        usage       = "<user>",
+        senderLimit = -1,
+        description = "Removes password of <user> and sends them a notification",
+        helpNoargs  = True)
+def rmotherpass_command(sender, command, label, args):
+    
+    py_player = get_py_player(sender)
+
+    if py_player.logging_in:
+        return "&cYou are not logged in"
+    
+    if not sender.hasPermission(admin_perm):
+        noperm(sender)
+        return
+
+    user = server.getOfflinePlayer(args[0])
+    
+    if is_registered(uid(user)):
+        delete_pass(uid(user))
+        runas(server.getConsoleSender(), colorify("mail send %s &cYour password was reset by a staff member. Use &6/register&c to set a new one." % user.getName()))
+        return "&aPassword of %s reset successfully" % user.getName()
+    return "&cThat player could not be found (or is not registered)"
+
+def change_pass(uuid, pw):
+    conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs = conn.cursor()
+    curs.execute("UPDATE secret SET pass = ? WHERE uuid = ?", (pw,uuid,))
+    conn.commit()
+    curs.close()
+    conn.close()
+
+def get_pass(uuid):
+    conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs = conn.cursor()
+    curs.execute("SELECT pass FROM secret WHERE uuid = ?", (uuid,))
+    results = curs.fetchall()
+    curs.close()
+    conn.close()
+    return results[0][0]
+
+def create_pass(uuid,pw):
+    thread = threading.Thread(target=create_pass_thread, args=(uuid,pw))
+    thread.start()
+
+def create_pass_thread(uuid, pw):
+    pw = crypt.encrypt(pw, rounds=200000, salt_size=16)
+    conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs = conn.cursor()
+    curs.execute("INSERT INTO secret VALUES (?,?)", (uuid,pw,))
+    conn.commit()
+    curs.close()
+    conn.close()
+
+def is_registered(uuid):
+    conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs = conn.cursor()
+    curs.execute("SELECT EXISTS(SELECT * FROM secret WHERE uuid = ?)", (uuid,))
+    results = curs.fetchall()
+    curs.close()
+    conn.close()
+    if results[0][0] == 1:
+        return True
+    return False
+
+def delete_pass(uuid):
+    conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs = conn.cursor()
+    curs.execute("DELETE FROM secret WHERE uuid = ?", (uuid,))
+    conn.commit()
+    curs.close()
+    conn.close()
+
+@hook.event("player.PlayerJoinEvent", "highest")
+def on_join(event):
+    user = event.getPlayer()
+    py_player = get_py_player(event.getPlayer())
+    if is_registered(uid(user)):
+        msg(event.getPlayer(), "&4You will be disconnected after 60 seconds if you don't &alogin")
+        msg(user, "&cUse /login <password>")
+        py_player.logging_in = True
+        py_player.login_time = time.time()
+        return
+    elif user.hasPermission(admin_perm):
+        pass #Do what? force them to make a password, lots of code, maybe just message us on slack?
+
+#This shouldn't be needed anymore as py_player gets removed anyway.
+"""
+
+@hook.event("player.PlayerQuitEvent", "high")
+def on_quit(event):
+    if event.getPlayer().getName() in logging_in:
+        del logging_in[event.getPlayer().getName()]
+"""
+
+##Threading start
+class kick_class(Runnable):
+
+    def __init__(self, player):
+        self.player = player
+
+    def run(self):
+        if self.player.isOnline():
+            self.player.kickPlayer(colorify("&aLogin timed out"))
+
+def kick_thread():
+    while True:
+        time.sleep(1)
+        now = time.time()
+        for py_player in py_players:
+            if py_player.logging_in:
+                if now - py_player.login_time > wait_time:
+                    player = py_player.player
+                    kick = kick_class(player)
+                    server.getScheduler().runTask(server.getPluginManager().getPlugin("RedstonerUtils"), kick)
+                    
+
+                    """if name in logging_in:
+                        del logging_in[name]
+                        break
+                    """
+
+
+thread = threading.Thread(target = kick_thread)
+thread.daemon = True
+thread.start()
+##Threading end
+
+for blocked_event in blocked_events:
+    @hook.event(blocked_event, "high")
+    def on_blocked_event(event):
+        user = get_py_player(event.getPlayer())
+        if user.logging_in:
+            event.setCancelled(True)
+
+@hook.event("player.PlayerCommandPreprocessEvent","normal")
+def pre_command_proccess(event):
+    player = get_py_player(event.getPlayer())
+    if player.logging_in:
+        args = event.getMessage().split(" ")
+        if not args[0].lower() == "/login":
+            msg(player.player, "&4You need to login before you do that!")
+            event.setCancelled(True)

main.py

@@ -9,6 +9,7 @@ from traceback import format_exc as print_traceback
 sys.path += ['', '/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2', '/usr/lib/python2.7/lib-tk', '/usr/lib/python2.7/lib-old', '/usr/lib/python2.7/lib-dynload', '/usr/local/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages', '/usr/lib/pymodules/python2.7', '/usr/lib/pyshared/python2.7']
 
 try:
+    # Library that adds a bunch of re-usable methods which are used in nearly all other modules
     from helpers import *
 except:
     print("[RedstonerUtils] ERROR: Failed to import helpers:")
@@ -18,11 +19,16 @@ except:
 
 @hook.enable
 def on_enable():
+    if "blockplacemods" in shared["modules"]:
+        shared["modules"]["blockplacemods"].schedule_torch_breaker()
+    if "serversigns" in shared["modules"]:
+        shared["modules"]["serversigns"].check_all_signs_and_intercept_command()
     info("RedstonerUtils enabled!")
 
 
 @hook.disable
 def on_disable():
+    if "reports" in shared["modules"]:
         shared["modules"]["reports"].stop_reporting()
     info("RedstonerUtils disabled!")
 
@@ -31,20 +37,80 @@ info("Loading RedstonerUtils...")
 
 # Import all modules, in this order
 shared["load_modules"] = [
+    # Collection of tiny utilities
     "misc",
+    # Adds chat for staff using /ac <text or ,<text>
     "adminchat",
+    # Adds /badge, allows to give players achievements
+    "badges",
+    # Adds a few block placement corrections/mods
+    "blockplacemods",
+    # Adds /calc, toggles automatic solving of Math expressions in chat
+    "calc",
+    # Adds aliasing of chat words
+    "chatalias",
+    # For players to point friends
+    "friends",
+    # Plugin to locate laggy chunks. /lc <n> lists chunks with more than n entities
     "lagchunks",
+    # Adds /report and /rp, Stores reports with time and location
     "reports",
+    # Adds group-chat with /chatgroup and /cgt to toggle normal chat into group mode
     "chatgroups",
+    # Adds /token, reads and writes from the database to generate pronouncable (and thus memorable) registration-tokens for the website
     "webtoken",
+    # Adds /lol, broadcasts random funyy messages. A bit like the splash text in the menu
     "saylol",
+    # Adds /signalstrength, lets you request a signal strength and an amount of items will be inserted into target container to meet that strength.
+    "signalstrength",
+    # Shows the owner of a skull when right-clicked
     "skullclick",
+    # Adds /listen, highlights chat and plays a sound when your name was mentioned
     "mentio",
+    # Adds /cycler, swaps the hotbar with inventory when player changes slot from right->left or left->right
     "cycle",
+    # Adds /getmotd & /setmotd to update the motd on the fly (no reboot)
     "motd",
+    # AnswerBot. Hides stupid questions from chat and tells the sender about /faq or the like
     "abot",
+    # Adds '/forcefield', creates forcefield for players who want it.
     "forcefield",
-  "friends"
+    # Adds /damnspam, creates timeout for buttons/levers to mitigate button spam.
+    "damnspam",
+    # Adds /check, useful to lookup details about a player
+    "check",
+    # Adds /an, a command you can use to share thoughts/plans/news
+    "adminnotes",
+    # Adds busy status to players
+    "imbusy",
+    # Adds /imout, displays fake leave/join messages
+    "imout",
+    #adds snowbrawl minigame
+    "snowbrawl",
+    # Adds /tm [player] for a messages to be sent to this player via /msg
+    "pmtoggle",
+    # Replacement for LoginSecurity
+    "loginsecurity",
+    # Centralized Player class
+    "player",
+    # Servercontrol extension for telnet access to logs/AC
+    #"servercontrol",
+    # Script helper plugin
+    "scriptutils",
+    # Per-player notes
+    "tag",
+    # vanish toggle module - temporary fix
+    #"vanishfix",
+    # obisidian mining punishment plugin
+    "punishments",
+    # a simple replacement for the buggy essentials /vanish
+    "vanish",
+    # ip-tracking utility - disabled as of instability
+    #"iptracker",
+    #server signs for everyone
+    "serversigns",
+    # Makes player's names colored, sorts tab list by rank
+    "nametags"
 ]
 shared["modules"] = {}
 for module in shared["load_modules"]:

mentio.py

@@ -4,7 +4,7 @@ from traceback import format_exc as print_traceback
 
 
 mentions   = open_json_file("mentio", {}) # contains a list of keywords for each player (uuid)
-max_amount = 3
+max_amount = 1000
 arrow      = colorify(u"&r&7\u2192&r")
 colors_reg = reg_compile(u"\u00A7[\\da-fk-or]") # finds color codes
 
@@ -13,7 +13,7 @@ def saveMentions():
     save_json_file("mentio", mentions)
 
 
-@hook.event("player.AsyncPlayerChatEvent", "high")
+@hook.event("player.AsyncPlayerChatEvent", "monitor")
 def onChat(event):
     if not event.isCancelled():
         sender     = event.getPlayer()
@@ -52,7 +52,7 @@ def onChat(event):
                 except:
                     # list might not be mutable, ignoring. Receiver will get the message twice
                     pass
-        message = " ".join([sender.getDisplayName(), arrow] + rec_words)
+                message = " "+" ".join([sender.getDisplayName(), arrow] + rec_words)
                 msg(recipient, message, usecolor = False)
                 recipient.playSound(recipient.getLocation(), "mob.chicken.plop", 1, 2)
 
@@ -70,7 +70,7 @@ def add_keyword(sender, args):
     keywords = get_keywords(sender)
     new_word = stripcolors(args[1].lower())
 
-  if len(keywords) >= max_amount:
+    if (len(keywords) >= max_amount) and (max_amount >= 0):
         msg(sender, "&cYou are already listening for %s words! Try &6/mentio del <word>" % max_amount)
         return True
 
@@ -86,7 +86,7 @@ def add_keyword(sender, args):
     if keywords:
         mentions[uid(sender)] = keywords
 
-  msg(sender, "&aYou are now listening for '&2%s'!" % new_word)
+    msg(sender, "&aYou are now listening for '&2%s&2'!" % new_word)
     saveMentions()
     return True
 
@@ -107,13 +107,19 @@ def del_keyword(sender, args):
         elif sender_id in mentions:
             del mentions[sender_id]
         saveMentions()
-    msg(sender, "&aYou are no longer listening for '&2%s&e'!" % del_word)
+        msg(sender, "&aYou are no longer listening for '&2%s&2'!" % del_word)
     else:
         msg(sender, "&cWe can't remove something that doesn't exist! Try &6/mentio list")
 
 
+def show_help(player):
+    msg(player, "&a/mentio add <word>")
+    msg(player, "&a/mentio del <word>")
+    msg(player, "&a/mentio list")
+
+
 @hook.command("mentio")
-def onListenCommand(sender, args):
+def onListenCommand(sender, command, label, args):
     plugin_header(sender, "Mentio")
 
     argnum = len(args)
@@ -137,7 +143,7 @@ def onListenCommand(sender, args):
             if not keywords:
                 msg(sender, "&cYou are currently listening for no words! Try &6/mentio add <word>")
         else:
-    msg(sender, "&a/mentio add <word>")
-    msg(sender, "&a/mentio del <word>")
-    msg(sender, "&a/mentio list")
+            show_help(sender)
+    else:
+        show_help(sender)
     return True

misc.py

@@ -1,128 +1,328 @@
 #pylint: disable = F0401
 from helpers import *
 from time import time as now
+from time import sleep
 from sys import exc_info
 import thread
 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)
 
-#
-# Welcome new players
-#
 
 @hook.event("player.PlayerJoinEvent", "monitor")
 def on_join(event):
+    """
+    Welcome new players
+    """
     player = event.getPlayer()
 
     # send welcome broadcast
     if not player.hasPlayedBefore():
-    broadcast("utils.greet_new", "")
-    broadcast("utils.greet_new", "&a&lPlease welcome &f" + player.getDisplayName() + " &a&lto Redstoner!")
-    broadcast("utils.greet_new", "")
+        broadcast("utils.greet_new", "\n&a&lPlease welcome &f" + player.getDisplayName() + " &a&lto Redstoner!\n")
 
         # clear out some eventual crap before
         msg(player, " \n \n \n \n \n \n \n \n \n \n \n \n ")
         msg(player, "  &4Welcome to the Redstoner Server!")
         msg(player, "  &6Before you ask us things, take a quick")
-    msg(player, "  &6look at the &a&l/FAQ &6command.")
+        msg(player, "  &6look at &a&nredstoner.com/info")
         msg(player, "  \n&6thank you and happy playing ;)")
         msg(player, " \n \n")
 
     # teleport to spawn when spawning inside portal
     loginloc = player.getLocation().getBlock().getType()
     headloc = player.getEyeLocation().getBlock().getType()
-  if str(loginloc) == "PORTAL" or str(headloc) == "PORTAL":
+    if "PORTAL" in [str(headloc), str(loginloc)]:
         msg(player, "&4Looks like you spawned in a portal... Let me help you out")
         msg(player, "&6You can use /back if you &nreally&6 want to go back")
         player.teleport(player.getWorld().getSpawnLocation())
 
+"""
+This code fixes /up 0 destroying/replacing blocks in plots that are not yours.
+If you use //up, this is caught by plotme and cancelled if you are not allowed to build.
+However, if you use //up, WorldEdit does the following on "low" priority:
+* Change the command to /up with the same arguments
+* Run another event with /up but its cancelled (dunno why it does this)
 
-#
-# /sudo - execute command/chat *as* a player/console
-#
+Keep in mind that, on "lowest" priority, PlotMe might cancel events.
 
 
-@hook.command("sudo")
-def on_sudo_command(sender, args):
-  if sender.hasPermission("utils.sudo"):
-    plugin_header(sender, "Sudo")
-    if not checkargs(sender, args, 2, -1):
+"""
+dup = 0 #Used to store when someone used //up
+
+@hook.event("player.PlayerCommandPreprocessEvent", "lowest")
+def cmd_event(event):
+    global dup
+    if event.getMessage().split(" ")[0] in ("//up", "/worldedit:/up"):
+        dup = True
+
+@hook.event("player.PlayerCommandPreprocessEvent", "normal")
+def cmd_event2(event):
+    global dup
+    args = event.getMessage().split(" ")
+    if args[0].lower() in ("/up", "/worldedit:up"):
+        if dup: #If plotme cancelled this, it will not matter. This lets it through but PlotMe doesn't.
+            dup = False
+        elif not event.isCancelled():
+            event.setCancelled(True)
+            event.getPlayer().chat("//up " + " ".join(args[1:]))
+
+
+
+
+""" Disabled while builder can't access Trusted
+@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):
+    world = event.getPlayer().getWorld()
+    if world.getName() in ("Survival_1", "TrustedSurvival_1"):
+        for player in world.getPlayers():
+            player.setSleepingIgnored(True)
+
+
+@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.PlayerInteractEvent")
+def on_interact(event):
+    if (not event.isCancelled()
+        and str(event.getAction()) == "RIGHT_CLICK_BLOCK"
+        and str(event.getMaterial()) in ("REDSTONE_COMPARATOR_OFF", "REDSTONE_COMPARATOR_ON")
+        and not can_build(player, event.getClickedBlock())
+    ):
+        event.setCancelled(True)
+
+
+sudo_blacklist = ["pyeval", "script_backup_begin", "script_backup_end", "script_backup_error", "script_backup_database_begin", "script_backup_database_dumps", "script_backup_database_end",
+"script_backup_database_error", "script_backup_database_abort", "script_trim", "script_trim_result", "script_spigot_update", "script_disk_filled", "script_restart", "script_restart_abort",
+"script_stop", "script_stop_abort", "script_shutdown", "stop", "esudo", "essentials:sudo", "sudo", "essentials:esudo"]
+
+@simplecommand("sudo",
+        usage        = "<player> [cmd..]",
+        description  = "Makes <player> write [cmd..] in chat",
+        amin         = 2,
+        helpNoargs   = True)
+def on_sudo_command(sender, command, label, args):
     target = args[0]
-
     cmd    =  " ".join(args[1:])
-    msg(sender, "Running '&e%s&r' as &3%s" % (cmd, target))
-    if cmd[0] == "/":
-      cmd = cmd[1:]
-      if target.lower() == "server" or target.lower() == "console":
-        runas(server.getConsoleSender(), cmd)
-      elif server.getPlayer(target):
-        runas(server.getPlayer(target), cmd)
-      else:
-        msg(sender, "&cPlayer %s not found!" % target)
-    else:
-      if target.lower() == "server" or target.lower() == "console":
-        runas(server.getConsoleSender(), "say %s" % cmd)
-      elif server.getPlayer(target):
-        server.getPlayer(target).chat(cmd)
-      else:
-        msg(sender, "&cPlayer %s not found!" % target)
-  else:
-    noperm(sender)
-  return True
+    msg(sender, "&2[SUDO] &rRunning '&e%s&r' as &3%s" % (cmd, target))
+    is_cmd     = cmd[0] == "/"
+    is_console = target.lower() in ["server", "console"]
+    first_cmd = (args[1])[1:] if is_cmd else None
+    if first_cmd in sudo_blacklist and (is_player(sender) and uid(sender) not in pythoners):
+        return "&cYou can't sudo this command"
+    if is_console:
+        server.dispatchCommand(server.getConsoleSender(), cmd[1:] if is_cmd else cmd)
+        return None
+    target_player = server.getPlayer(target)
+    if target_player:
+        target_player.chat(cmd)
+        return None
+    return "&cPlayer %s not found!" % target
 
 
-#
-# Clicking redstone_sheep with shears will drop redstone + wool and makes a moo sound
-#
 
-last_shear = 0.0
-
-@hook.event("player.PlayerInteractEntityEvent")
-def on_player_entity_interact(event):
-  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)
+@simplecommand("me",
+        usage        = "[message..]",
+        description  = "Sends a message in third person",
+        helpNoargs   = True)
+def on_me_command(sender, command, label, args):
+    text = colorify("&7- %s &7%s " % (sender.getDisplayName() if isinstance(sender, Player) else "&9CONSOLE", u"\u21E6"))
+    broadcast("utils.me", text + " ".join(args), usecolor = sender.hasPermission("essentials.chat.color"))
+    return None
 
 
-#
-# /pluginversions - print all plugins + versions; useful when updating plugins
-#
 
 @hook.command("pluginversions")
-def on_pluginversions_command(sender, args):
+def on_pluginversions_command(sender, command, label, args):
+    """
+    /pluginversions
+    print all plugins + versions; useful when updating plugins
+    """
+    try:
         plugin_header(sender, "Plugin versions")
-  plugins = list(server.getPluginManager().getPlugins())
+        raw_plugins = server.getPluginManager().getPlugins() # Plugin[]
+        plugins = [raw_plugins[i].getDescription() for i in range(len(raw_plugins))]
+        info(type(plugins[0]).__name__)
         plugins.sort(key = lambda pl: pl.getDescription().getName())
         msg(sender, "&3Listing all " + str(len(plugins)) + " plugins and their version:")
         for plugin in plugins:
-    msg(sender, "&6" + plugin.getDescription().getName() + "&r: &e" + plugin.getDescription().getVersion())
+            msg(sender, "&6" + pl.getDescription().getName() + "&r: &e" + pl.getDescription().getVersion())
         return True
+    except:
+        error(trace())
 
 
-#
-# /echo - essentials echo sucks and prints mail alerts sometimes
-#
-
 @hook.command("echo")
-def on_echo_command(sender, args):
+def on_echo_command(sender, command, label, args):
+    """
+    /echo
+    essentials echo sucks and prints mail alerts sometimes
+    """
     msg(sender, " ".join(args).replace("\\n", "\n"))
 
 
-#
-# /pyeval - run python ingame
-#
-# has to be in main.py so we can access the modules
 
 def eval_thread(sender, code):
+    """
+    /pyeval
+    run python ingame
+    """
     try:
         result = eval(code)
         msg(sender, ">>> %s: %s" % (colorify("&3") + type(result).__name__, colorify("&a") + unicode(result) + "\n "), usecolor = False)
@@ -135,22 +335,101 @@ def eval_thread(sender, code):
         msg(sender, ">>> %s: %s" % (eclass.__name__, e) + "\n ", False, "c")
     thread.exit()
 
+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
+)
 
-@hook.command("pyeval")
-def on_pyeval_command(sender, args):
-  if sender.hasPermission("utils.pyeval"):
-    if not checkargs(sender, args, 1, -1):
-      return True
-    msg(sender, "%s" % " ".join(args), False, "e")
+@simplecommand("pyeval",
+        usage       = "[code..]",
+        description = "Runs python [code..] and returns the result",
+        helpNoargs  = True)
+def on_pyeval_command(sender, command, label, args):
+    if is_player(sender) and uid(sender) not in pythoners:
+        return noperm(sender)
+    msg(sender, " ".join(args), False, "e")
     thread.start_new_thread(eval_thread, (sender, " ".join(args)))
+    return None
+
+
+
+@simplecommand("tempadd",
+        usage       = "<user> <group> [duration]",
+        description = "Temporarily adds <user> to <group> for \n[duration] minutes. Defaults to 1 week.",
+        helpNoargs  = True,
+        helpSubcmd  = True,
+        amin        = 2,
+        amax        = 3)
+def tempadd_command(sender, command, label, args):
+    if not sender.hasPermission("permissions.manage.membership." + args[1]):
+        return "&cYou do not have permission to manage that group!"
+    if len(args) == 3:
+        if not args[2].isdigit():
+            return "&cThats not a number!"
+        duration = int(args[2]) * 60
     else:
-    noperm(sender)
-  return True
+        duration = 604800
+    if duration <= 0:
+        return "&cThats too short!"
+    cmd = "pex user %s group add %s * %s" % (args[0], args[1], duration)
+    runas(sender, cmd)
+
+    m, s = divmod(duration, 60)
+    h, m = divmod(m, 60)
+    d, h = divmod(h, 24)
+    return "&aAdded to group for %dd%dh%dm" % (d, h, m)
+
 
 
 @hook.command("modules")
-def on_modules_command(sender, args):
+def on_modules_command(sender, command, label, args):
+    """
+    /modules
+    list all modules, unloaded modules in red
+    """
     plugin_header(sender, "Modules")
-  for mod in shared["load_modules"]:
-    color = "a" if mod in shared["modules"] else "c"
-    msg(sender, "&" + color + mod)
+    msg(sender, ", ".join([(("&a" if mod in shared["modules"] else "&c") + mod) for mod in shared["load_modules"]]))
+
+
+@simplecommand("warn",
+        usage       = "",
+        description = "Warns everybody on the server that you will cause lag shortly",
+        amax        = 0,
+        helpSubcmd  = True)
+def warn_command(sender, command, label, args):
+    if sender.hasPermission("utils.warn"):
+        broadcast(None, " &b= &2&lLag incoming! &r-%s" % sender.getDisplayName())
+    else:
+        noperm(sender)
+
+
+@simplecommand("warnp",
+        usage       = "",
+        description = "Warns everybody on the server that you might cause lag shortly",
+        amax        = 0,
+        helpSubcmd  = True)
+def warnp_command(sender, command, label, args):
+    if sender.hasPermission("utils.warnp"):
+        broadcast(None, " &b= &2&lPossible lag incoming! &r-%s" % sender.getDisplayName())
+    else:
+        noperm(sender)
+
+
+
+""" Something I'm planning for schematics
+@hook.event("player.PlayerCommandPreprocessEvent", "low")
+def on_command(event):
+    msg = " ".split(event.getMessage())
+    if len(msg) < 3:
+        return
+    if msg[0].lower() not in ("/schematic", "/schem"):
+        return
+    if msg[1].lower() not in ("save", "load"):
+        return
+    msg[2] = event.getPlayer().getName() + "/" + msg[2]
+"""
+
+
+

motd.py

@@ -5,13 +5,13 @@ default_motd = colorify(server.getMotd())
 motd         = default_motd
 
 @hook.command("getmotd")
-def on_getmotd_command(sender, args):
+def on_getmotd_command(sender, command, label, args):
     plugin_header(sender, "MOTD")
     msg(sender, motd, usecolor = False)
 
 
 @hook.command("setmotd")
-def on_setmotd_command(sender, args):
+def on_setmotd_command(sender, command, label, args):
     global motd
     if sender.hasPermission("utils.setmotd"):
         if not checkargs(sender, args, 1, -1):

mysqlhack.py

@@ -1,4 +1,9 @@
 #pylint: disable = F0401
+"""
+A library that makes use of the so called ClassPathHack for jython
+to allow proper loading of mysql-connector.jar at runtime.
+Import only, no methods.
+"""
 import java.lang.reflect.Method
 import java.io.File
 import java.net.URL

nametags.py

@@ -0,0 +1,37 @@
+from helpers import *
+
+##############################################################
+#                                                            #
+# This module automatically puts people in the corresponding #
+# scoreboard team so that their name is colored properly and #
+# tab will be nicely sorted.                                 #
+#                                                            #
+##############################################################
+
+ranks = ["visitor", "member", "builder", "trusted", "trainingmod", "mod", "admin"]
+# prefixes are used for sorting in the tab list
+prefixes = {"admin":"a", "mod":"b", "trainingmod":"c", "trusted":"d", "builder":"e", "member":"f","visitor":"g"}
+
+@hook.event("player.PlayerJoinEvent", "low")
+def on_player_join(event):
+    player = event.getPlayer()
+    team = get_team(player)
+    if team:
+        cmd = "scoreboard teams join %s %s" % (team, player.getName())
+        server.dispatchCommand(server.getConsoleSender(), cmd)
+
+def get_rank(player):
+    player_rank = None
+    for rank in ranks:
+        if not player.hasPermission("group.%s" % rank):
+            break
+        player_rank = rank
+    if not player_rank:
+        warn("Couldn't find rank for player %s" % player.getName())
+    return player_rank
+
+def get_team(player):
+    rank = get_rank(player)
+    if rank:
+        prefix = prefixes.get(rank)
+        return "_".join([prefix, rank])

player.py

@@ -0,0 +1,30 @@
+from helpers import *
+
+py_players = []
+
+class py_player:
+    def __init__(self,player):
+        self.player = player
+        self.logging_in = False
+        self.login_time = 0
+
+def get_py_player(player):
+    #py_player = py_players[py_players.index(player)]
+
+    for py_player in py_players:
+        if py_player.player.getName() == player.getName():
+            return py_player
+
+
+@hook.event("player.PlayerJoinEvent","lowest")
+def on_join(event):
+    player = py_player(event.getPlayer())
+    py_players.append(player)
+    print str(len(py_players))+event.getPlayer().getName()
+
+
+@hook.event("player.PlayerQuitEvent","highest")
+def on_leave(event):
+    player = get_py_player(event.getPlayer())
+    if player in py_players:
+        py_players.remove(player)

playermanager.py

@@ -0,0 +1,192 @@
+from helpers import *
+import org.bukkit.entity.Player as Base_player
+import blockplacemods as blockmods
+import snowbrawl
+import loginsecurity as login
+import calc
+import chatgroups as cg
+import adminchat as ac
+import cycle
+import forcefield as ff
+import imout
+import mentio
+import pmtoggle
+
+
+get_info_perm = "utils.playermanager.info"
+
+players = []
+
+
+###############################################################
+# Outside-accessible functions
+
+def get_player(name):
+    for player in players:
+        if player.get_name() == name:
+            return player
+    return None
+
+##############################################################
+# Events
+
+@hook.event("player.PlayerQuitEvent", "highest")
+def on_quit(event):
+    for i in range(len(players)):
+        if players[i].get_uuid() == uid(event.getPlayer()):
+            players.remove(players[i])
+            return
+
+@hook.event("player.PlayerJoinEvent", "highest")
+def on_join(event):
+    players.append(Player(event.getPlayer()))
+
+#############################################################
+# Commands
+
+def send(sender, name, data):
+    if isinstance(data, bool):
+        if data == True:
+            msg(sender, "&e-&a %s&e:&a True" % name)
+        else:
+            msg(sender, "&e-&a %s&e:&c False" % name)
+    else:
+        msg(sender, "&e-&a %s&e:&6 %s" % (name, str(data)))
+
+def send_header(sender, name):
+    msg(sender, "&e- &2 %s&e:" % name.upper())
+
+def print_info(sender, player):
+    send_header(sender, "general")
+    send(sender, "Name", player.get_name())
+    send(sender, "UUID", player.get_uuid())
+    send(sender, "Logged in", player.logged_in())
+    send_header(sender, "snowbrawl")
+    send(sender, "In arena", player.in_sb_arena())
+    send(sender, "Arena", player.get_sb_arena())
+    send_header(sender, "place-mods")
+    send(sender, "Slab flip", player.has_autoflip_slab())
+    send(sender, "Cauldron fill", player.has_autofill_cauldron())
+    send(sender, "Piston face", player.has_autoface_piston())
+    send_header(sender, "chat groups")
+    send(sender, "In chatgroup", player.in_cg())
+    send(sender, "Chatgroup", player.get_cg())
+    send(sender, "Key", player.get_cg_key())
+    send(sender, "Toggle", player.has_cg_toggle())
+    send_header(sender, "Admin chat")
+    send(sender, "In adminchat", player.in_ac())
+    send(sender, "Key", player.get_ac_key())
+    send(sender, "Toggle", player.has_ac_toggle())
+    send_header(sender, "forcefield")
+    send(sender, "Whitelist", "&e, &6".join(player.get_ff_whitelist()))
+    send(sender, "Toggle", player.has_ff_toggle())
+    send_header(sender, "miscellaneous")
+    send(sender, "Calc", player.has_calc())
+    send(sender, "PM toggle", player.has_pm_toggle())
+    send(sender, "Cycle toggle", player.has_cycle())
+    send(sender, "Imout toggle", player.has_imout_toggle())
+    send(sender, "Mentio", "&e, &6".join(player.get_mentio_list()))
+
+@hook.command("getinfo")
+def on_command(sender, cmd, label, args):
+    if sender.hasPermission(get_info_perm):
+        if len(args) != 1:
+            msg(sender, "&e-&a /getinfo <name>")
+        else:
+            player = get_player(args[0])
+            if player != None:
+                print_info(sender, player)
+            else:
+                msg(sender, "&e-&c Player not online or does not exist")
+    else:
+        noperm(sender)
+    return True
+
+#############################################################
+# Player class
+
+class Player():
+
+    def __init__(self, player):
+        self.player = player
+
+    def get_java_player(self):
+        return self.player
+
+    def get_uuid(self):
+        return uid(self.player)
+
+    def get_name(self):
+        return self.get_java_player().getName()
+
+    def get_display_name(self):
+        return self.get_java_player().getDisplayName()
+
+    def in_sb_arena(self):
+        for arena in snowbrawl.arenas:
+            if arena.in_players(self.get_java_player()):
+                return True
+        return False
+
+    def get_sb_arena(self):
+        for arena in snowbrawl.arenas:
+            if arena.in_players(self.get_java_player()):
+                return arena
+        return None
+
+    def logged_in(self):
+        return self.get_name() not in login.logging_in
+
+    def has_autoflip_slab(self):
+        return blockmods.isEnabled("slab", self.get_uuid())
+
+    def has_autofill_cauldron(self):
+        return blockmods.isEnabled("cauldron", self.get_uuid())
+
+    def has_autoface_piston(self):
+        return blockmods.isEnabled("piston", self.get_uuid())
+
+    def has_calc(self):
+        return self.get_uuid() in calc.calc_users
+
+    def in_cg(self):
+        return self.get_uuid() in cg.groups.keys()
+
+    def get_cg(self):
+        if self.in_cg():
+            return cg.groups[self.get_uuid()]
+        else:
+            return None
+
+    def get_cg_key(self):
+        return cg.get_key(self.get_uuid())
+
+    def has_cg_toggle(self):
+        return self.get_uuid() in cg.cg_toggle_list
+
+    def in_ac(self):
+        return self.get_java_player().hasPermission(ac.ac_permission)
+
+    def get_ac_key(self):
+        return ac.get_key(self.get_uuid())
+
+    def has_ac_toggle(self):
+        return self.get_name() in ac.ac_toggle_list
+
+    def has_cycle(self):
+        return self.get_uuid() not in cycle.no_cyclers
+
+    def has_ff_toggle(self):
+        return self.get_uuid() in ff.ff_users
+
+    def get_ff_whitelist(self):
+        return ff.whitelists.get(self.get_uuid(), [])
+
+    def has_imout_toggle(self):
+        return self.get_name() in imout.imout_toggle_list
+
+    def get_mentio_list(self):
+        return mentio.get_keywords(self.get_java_player())
+
+    def has_pm_toggle(self):
+        return self.get_uuid() in pmtoggle.toggle_dict

plotter.py

@@ -1,7 +1,9 @@
 #!/usr/bin/python
 
-# this was going to be a PlotMe-like plugin "plotter"
-# but it seems like PlotMe is still beeing developed, so we don't need our own.
+"""
+*Very basic* start of a custom plot-plugin like PlotMe
+on hold because the PlotMe developer continued to develop PlotMe
+"""
 
 import sys
 

plugin.yml

@@ -1,4 +1,4 @@
 name: RedstonerUtils
 main: main.py
-version: 3.0.0
+version: 3.1.0
 author: redstone_sheep

pmtoggle.py

@@ -0,0 +1,57 @@
+from helpers import *
+import org.bukkit.Bukkit as Bukkit
+from java.util.UUID import fromString as juuid
+
+toggle_dict = {}
+permission = "utils.pmtoggle"
+
+@hook.command("pmtoggle",
+              aliases = ["tm", "mt", "tmsg", "msgt", "pmt", "tpm"],
+              usage = "/<command> [player]",
+              description = "Toggle automatic sending of messages"
+              )
+def on_toggle_message_command(sender, command, label, args):
+    if not sender.hasPermission(permission) or not is_player(sender):
+        noperm(sender)
+        return True
+    plugin_header(sender, "Private Message Toggle")
+    uuid = uid(sender)
+    if len(args) > 0:
+        if len(args) > 1:
+            msg(sender, "&cToo many arguments!")
+            return True
+        target = Bukkit.getPlayer(args[0])
+        if target:
+            toggle_dict[uuid] = uid(target)
+            msg(sender, "&2Enabled toggle so that you're now sending only to %s &2by default" % target.getDisplayName())
+        else:
+            msg(sender, "&cThat player could not be found")
+    elif uuid in toggle_dict:
+        del toggle_dict[uuid]
+        msg(sender, "&2Disabled toggle successfully")
+    else:
+        msg(sender, "&cExpected a player as argument")
+    return True
+
+
+@hook.event("player.AsyncPlayerChatEvent", "normal")
+def on_chat(event):
+    if event.isCancelled():
+        return
+    player = event.getPlayer()
+    uuid = uid(player)
+    if uuid in toggle_dict:
+        event.setCancelled(True)
+        target = Bukkit.getPlayer(juuid(toggle_dict[uuid])).getName()
+        runas(player, "msg %s %s" % (target, event.getMessage()))
+
+
+@hook.event("player.PlayerQuitEvent", "normal")
+def on_quit(event):
+    uuid = uid(event.getPlayer())
+    if uuid in toggle_dict:
+        del toggle_dict[uuid]
+    for pid in list(toggle_dict):
+        if toggle_dict[pid] == uuid:
+            del toggle_dict[pid]
+            msg(Bukkit.getPlayer(juuid(pid)), "%s &cwent off so your Private Message Toggle has been disabled!" % Bukkit.getPlayer(juuid(uuid)).getDisplayName())

punishments.py

@@ -0,0 +1,129 @@
+from helpers import *
+from java.util.UUID import fromString as juuid
+import org.bukkit.Material as Material
+
+spawn_world = "Spawn"
+punish_world = "Punishments"
+
+slave_perm = "utils.minerslaves"
+
+slaves = []
+
+def save_slaves():
+    buf = []
+    for slave in slaves:
+        buf.append(slave.get_data())
+    save_json_file("miner_slaves", buf)
+
+def load_slaves():
+    buf = open_json_file("miner_slaves", [])
+    for data in buf:
+        slave = Slave(True, None, None)
+        slave.load_data(data)
+        slaves.append(slave)
+
+def get_slave(player):
+    for slave in slaves:
+        if slave.get_uuid() == player:
+            return slave
+    return None
+
+class Slave(object):
+
+    def __init__(self, from_file, player, amount):
+        if from_file:
+            self.players = None
+            self.blocks = None
+            return
+        slave = get_slave(uid(player))
+        if slave != None:
+            slave.set_blocks(slave.get_blocks() + amount)
+        else:
+            self.player = uid(player)
+            self.blocks = amount
+            slaves.append(self)
+
+    def get_uuid(self):
+        return self.player
+
+    def get_blocks(self):
+        return self.blocks
+
+    def set_blocks(self, amount):
+        self.blocks = amount
+
+    def update(self):
+        self.blocks -= 1
+        if self.blocks <= 0:
+            server.getPlayer(juuid(self.get_uuid())).teleport(server.getWorld(spawn_world).getSpawnLocation())
+            slaves.remove(self)
+            save_slaves()
+
+    def get_data(self):
+        return {
+        "player": self.player,
+        "amount": self.blocks
+        }
+
+    def load_data(self, data):
+        self.player = str(data["player"])
+        self.blocks = int(data["amount"])
+
+load_slaves()
+
+@hook.event("block.BlockBreakEvent", "low")
+def event(event):
+    if event.getPlayer().getWorld().getName() != punish_world:
+        return
+    slave = get_slave(uid(event.getPlayer()))
+    if slave != None and event.getBlock().getType() == Material.OBSIDIAN:
+        slave.update()
+
+@hook.command("miner")
+def command(sender, cmd, label, args):
+    if not sender.hasPermission(slave_perm):
+        noperm(sender)
+        return True
+    if len(args) == 0 or (len(args) != 1 and args[0] == "list") or (len(args) != 2 and args[0] == "rem") or (len(args) != 3 and args[0] == "add"):
+        msg(sender, "&e-&a /miner add/rem/list <name> <amount>")
+        return True
+    if args[0] == "add":
+        try:
+            int(args[2])
+        except:
+            msg(sender, "&cArgument <amount> is not a number")
+            return True
+    if args[0] == "list":
+        if len(slaves) == 0:
+            msg(sender, "&e-&a There are no people mining obsidian")
+            return True
+        for slave in slaves:
+            msg(sender, "&e-&a %s: %s blocks" % (server.getOfflinePlayer(juuid(slave.get_uuid())).getName(), slave.get_blocks()))
+        return True
+    elif args[0] == "add":
+        player = server.getOfflinePlayer(str(args[1]))
+        if player.isOnline():
+            player.teleport(server.getWorld(punish_world).getSpawnLocation())
+            Slave(False, player, int(args[2]))
+            save_slaves()
+            msg(player, "&e-&a You have been punished, mine %s blocks of obsidian to get out!" % args[2])
+            msg(sender, "&e-&a Player %s has been added into punishments for %s blocks of obsidian" % (player.getName(), args[2]))
+        else:
+            msg(sender, "&cYou can only punish online players")
+            return True
+    elif args[0] == "rem":
+        player = server.getOfflinePlayer(str(args[1]))
+        if player.isOnline():
+            slave = get_slave(uid(player))
+            if slave != None:
+                server.getPlayer(juuid(slave.get_uuid())).teleport(server.getWorld(spawn_world).getSpawnLocation())
+                slaves.remove(slave)
+                save_slaves()
+            else:
+                msg(sender, "&e-&a Player not in punishments")
+        else:
+            msg(sender, "&cYou can only remove online players")
+            return True
+    else:
+        msg(sender, "&e-&a /miner add/rem/list <name> <amount>")
+    return True

reports.py

@@ -2,6 +2,7 @@ from helpers import *
 from java.util.UUID import fromString as juuid
 import time
 import thread
+from traceback import format_exc as trace
 
 
 time_format   = "%Y.%m.%d %H:%M"
@@ -13,42 +14,83 @@ rp_permission = "utils.rp"
 
 def print_help(sender):
     msg(sender, " &2/report <text>     &eReport something")
-  msg(sender, " &2/rp list          &eList unresolved reports (id, player, text)")
+    msg(sender, " &2/rp open            &eList open reports (id, player, text)")
+    msg(sender, " &2/rp closed         &eList closed reports (id, player, text)")
     msg(sender, " &2/rp tp <id>         &eTeleport to report's location & show details")
-  msg(sender, " &2/rp del <id>     &eResolve a report")
+    msg(sender, " &2/rp close <id>     &eResolve an open report")
+    msg(sender, " &2/rp reopen <id>   &eReopen a resolved report")
+    msg(sender, " &2/rp del <id>        &eDelete a report (admin only)")
 
 
-def print_list(sender):
+def print_list(sender, closed):
     try: # new thread, anything can happen.
-    msg(sender, "&a" + str(len(reports)) + " reports:")
-    for i, report in enumerate(reports):
-      name = server.getOfflinePlayer(juuid(report["uuid"])).getName()
-      msg(sender, "&8[&e%s&c%s&8] &3%s&f: &a%s" % (i, report["time"], name, report["msg"]))
+        targeted_reports = dict(enumerate(reports))
+        for i in list(targeted_reports):
+            report = targeted_reports[i]
+            if report["closed"] != closed:
+                targeted_reports.pop(i)
+
+        msg(sender, "&a%s %s reports:" % (len(targeted_reports), "closed" if closed else "open"))
+        for i in targeted_reports:
+            report = targeted_reports[i]
+            name = retrieve_player(report["uuid"]).getName()
+            msg(sender, "&8[&e%s &c%s&8] &3%s&f: &a%s" % (i, report["time"], name, report["msg"]))
     except:
         warn("Failed to complete report's print_list() thread")
+        error(trace())
 
 
 def tp_report(sender, rep_id):
     if rep_id >= len(reports) or rep_id < 0:
         msg(sender, "&cReport &3#" + str(rep_id) + "&c does not exist!")
-    return True
     else:
         report = reports[rep_id]
         safetp(sender, server.getWorld(report["world"]), report["x"], report["y"], report["z"], report["yaw"], report["pitch"])
-    msg(sender, "&aTeleported to report #%s" % rep_id )
+        msg(sender, "&aTeleported to %s&areport #%s" % ("&cclosed " if report["closed"] else "", rep_id))
+
+
+# resolve == True: You're resolving, False: reopening
+def resolve_reopen_report(sender, rep_id, resolve):
+    action = "resolved" if resolve else "reopened"
+    report = edit_report(sender, rep_id)
+    if report != None:
+        if report["closed"] == resolve:
+            msg(sender, "&cReport &3#%s&c was already %s!" % (rep_id, action))
+        else:
+            report["closed"] = resolve
+            save_reports()
+            msg(sender, "&aReport #%s %s" % (rep_id, action))
+            message_reporter(sender, report, action)
 
 
 def delete_report(sender, rep_id):
-  if len(reports) > rep_id >= 0:
-    report = reports[rep_id]
-    reports.pop(rep_id)
+    if not sender.hasPermission(rp_permission + ".del"):
+        noperm(sender)
+        return
+    action = "&cdeleted"
+    report = edit_report(sender, rep_id)
+    if report != None:
+        reports.remove(report)
         save_reports()
-    msg(sender, "&aReport #%s deleted." % rep_id)
-    reporter = server.getOfflinePlayer(juuid(report["uuid"]))
-    plugin_header(reporter, "Report")
-    msg(reporter, "&aReport '&e%s&a' was resolved by %s." % (report["msg"], sender.getName()))
-  else:
+        msg(sender, "&aReport #%s %s" % (rep_id, action))
+        message_reporter(sender, report, action)
+
+
+def edit_report(sender, rep_id):
+    if len(reports) > rep_id >= 0:
+        return reports[rep_id]
     msg(sender, "&cThat report does not exist!")
+    return None
+
+
+def message_reporter(sender, report, action):
+    reporter = get_reporter(report)
+    message = "&aReport '&e%s&a' was %s &aby %s." % (report["msg"], action, sender.getName())
+    if reporter.isOnline():
+        plugin_header(reporter, "Reports")
+        msg(reporter, message)
+    else:
+        server.dispatchCommand(sender, "mail send %s %s" % (reporter.getName(), colorify(message)))
 
 
 def save_reports():
@@ -56,13 +98,16 @@ def save_reports():
 
 
 @hook.command("rp")
-def on_rp_command(sender, args):
+def on_rp_command(sender, command, label, args):
     if sender.hasPermission(rp_permission):
         plugin_header(sender, "Reports")
         if len(args) > 0:
-      if args[0] == "list":
+            subcmd = args[0].lower()
+            if subcmd == "closed":
                 # needs to run in seperate thread because of getOfflinePlayer
-        thread.start_new_thread(print_list, (sender))
+                thread.start_new_thread(print_list, (sender, True,))
+            elif subcmd in ["open", "list"]:
+                thread.start_new_thread(print_list, (sender, False,))
             else:
                 if not checkargs(sender, args, 2, 2):
                     return True
@@ -72,13 +117,17 @@ def on_rp_command(sender, args):
                     msg(sender, "&cDoesn't look like &3" + args[1] + "&c is a valid number!")
                     print_help(sender)
                     return True
-        if args[0] == "tp":
+                if subcmd == "tp":
                     if not is_player(sender):
                         msg(sender, "&conly players can do this")
                         return True
                     tp_report(sender, repid)
-        elif args[0] == "del":
+                elif subcmd == "close":
+                    resolve_reopen_report(sender, repid, True)
+                elif subcmd == "del":
                     delete_report(sender, repid)
+                elif subcmd == "reopen":
+                    resolve_reopen_report(sender, repid, False)
                 else:
                     print_help(sender)
         else:
@@ -89,7 +138,7 @@ def on_rp_command(sender, args):
 
 
 @hook.command("report")
-def on_report_command(sender, args):
+def on_report_command(sender, command, label, args):
     plugin_header(sender, "Report")
     if not is_player(sender):
         msg(sender, "&conly players can do this")
@@ -109,7 +158,8 @@ def on_report_command(sender, args):
         "yaw": int(loc.yaw),
         "pitch": int(loc.pitch),
         "world": loc.getWorld().name,
-    "time": time.strftime(time_format)
+        "time": time.strftime(time_format),
+        "closed": False
     }
     reports.append(report)
     save_reports()
@@ -125,9 +175,9 @@ def reports_reminder(): # needs 2 args for unknown reason
             if not check_reports:
                 info("Reports reminder thread killed.")
                 thread.exit()
-    if len(reports) > 0:
-      broadcast(rp_permission, "&2--=[ Reports ]=--")
-      broadcast(rp_permission, "&aThere are %s pending reports!" % len(reports))
+        targeted_reports = get_reports(False)
+        if len(targeted_reports) > 0:
+            broadcast(rp_permission, "&aThere are %s open reports!" % len(targeted_reports))
 
 
 def stop_reporting():
@@ -136,4 +186,15 @@ def stop_reporting():
     check_reports = False
 
 
+def get_reports(closed):
+    targeted_reports = []
+    for report in reports:
+        if report["closed"] == closed:
+            targeted_reports.append(report)
+    return targeted_reports
+
+
+def get_reporter(report):
+    return server.getOfflinePlayer(juuid(report["uuid"]))
+
 thread.start_new_thread(reports_reminder, ())

saylol.py

@@ -5,7 +5,7 @@ from random import randrange
 lols     = open_json_file("lol", [])
 timeout  = 15
 last_msg = 0
-
+list_limit = 20
 
 
 def save_lols():
@@ -30,10 +30,8 @@ def print_lol(sender, lid):
             broadcast(None, "&8[&blol&8] &7%s&8: &e%s" % (dispname, lols[lid]))
             last_msg = time()
         else:
-      plugin_header(sender, "SayLol")
             msg(sender, "&cInvalid id")
     else:
-    plugin_header(sender, "SayLol")
         msg(sender, "&cYou can use SayLol again in &a%s seconds!" % int(timeout + 1 - (time() - last_msg)))
 
 
@@ -41,15 +39,16 @@ def search_lols(sender, keyword):
     if not keyword:
         msg(sender, "&cPlease provide a keyword to search for!")
         return
+    keyword = keyword.lower()
     msg(sender, "&aLols containing '&6%s&a':" % keyword)
     for i, lol in enumerate(lols):
-    if keyword in lol:
+        if keyword in lol.lower():
             msg(sender, "&a%s: &e%s" % (str(i).rjust(3), lol))
     msg(sender, "") # empty line showing end of list
 
 
 @hook.command("lol")
-def on_lol_command(sender, args):
+def on_lol_command(sender, command, label, args):
     plugin_header(sender, "SayLol")
 
     cmd = args[0] if len(args) > 0 else None
@@ -70,8 +69,26 @@ def on_lol_command(sender, args):
             noperm(sender)
 
     elif cmd == "list":
-    for i in range(len(lols)):
+        arg1 = args[1] if len(args) > 1 else None
+        if not arg1:
+            arg1 = "1"        
+        if not arg1.isdigit():
+            msg(sender, "&cInvalid argument \"%s\"" % arg1)
+            return True
+        if int(arg1) == 0:
+            msg(sender, "&cPage 0 does not exist")
+            return True
+        arg1 = int(arg1) - 1
+        offset = list_limit * arg1
+        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
+        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, "")        
+        msg(sender, "&eFor a specific page, type &a/lol list <page>&e.")
+        msg(sender, "") #emptyline
 
     elif cmd == "search":
         if sender.hasPermission("utils.lol.search"):
@@ -97,7 +114,7 @@ def on_lol_command(sender, args):
 
     else:
         msg(sender, "&a/lol               &eSay random message")
-    msg(sender, "&a/lol list       &eList all messages")
+        msg(sender, "&a/lol list [page]   &eList messages")
         msg(sender, "&a/lol id <id>       &eSay specific message")
         msg(sender, "&a/lol add <text>    &eAdd message")
         msg(sender, "&a/lol del <id>      &eDelete message")

scriptutils.py

@@ -0,0 +1,212 @@
+from helpers import *
+
+"""
+Prints server restart message
+arg 0 timeout
+arg 1 $(whoami)
+arg 2: reason
+"""
+@hook.command("script_restart")
+def print_restart(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&2&l=============================================")
+        broadcast(None, "&r")
+        broadcast(None, "&r")
+        broadcast(None, "&9%s is restarting the server." % args[1])
+        broadcast(None, "&a&lServer is going to restart in %s seconds." % args[0])
+        broadcast(None, "&6&l%s" % " ".join(args[2:]))
+        broadcast(None, "&r")
+        broadcast(None, "&r")
+        broadcast(None, "&2&l=============================================")
+    else:
+        noperm(sender)
+
+"""
+Prints the server shut down message
+arg 0 timeout
+arg 1 $(whoami)
+arg 2: reason
+"""
+@hook.command("script_stop")
+def print_stop(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&2&l=============================================")
+        broadcast(None, "&r")
+        broadcast(None, "&r")
+        broadcast(None, "&9%s is shutting down the server." % args[1])
+        broadcast(None, "&a&lServer is going to shut down in %s seconds." % args[0])
+        broadcast(None, "&6&l%s" % " ".join(args[2:]))
+        broadcast(None, "&r")
+        broadcast(None, "&r")
+        broadcast(None, "&2&l=============================================")
+    else:
+        noperm(sender)
+
+"""
+Prints the shut down abort message
+"""
+@hook.command("script_stop_abort")
+def abort_stop(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&4&oShut down has been aborted.")
+    else:
+        noperm(sender)
+
+"""
+Prints the restart abort message
+"""
+@hook.command("script_restart_abort")
+def abort_restart(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&4&oRestart has been aborted.")
+    else:
+        noperm(sender)
+
+"""
+Prints the backup started message, saves all worlds and turns off world saving
+"""
+@hook.command("script_backup_begin")
+def print_backup_begin(sender, command, lable, args):
+    if not is_player(sender):
+        broadcast(None, "&4 =&2 Starting backup now.")
+        server.dispatchCommand(server.getConsoleSender(), "save-all")
+        server.dispatchCommand(server.getConsoleSender(), "save-off")
+    else:
+        noperm(sender)
+
+"""
+Prints the backup finished message and turns on world saving
+"""
+@hook.command("script_backup_end")
+def print_backup_end(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&4 =&2 Backup completed.")
+        server.dispatchCommand(server.getConsoleSender(), "save-on")
+    else:
+        noperm(sender)
+
+"""
+Prints the backup error message and turns on world saving
+"""
+@hook.command("script_backup_error")
+def print_backup_error(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&4 =&c&l Error while backing up!")
+        server.dispatchCommand(server.getConsoleSender(), "save-on")
+    else:
+        noperm(sender)
+
+"""
+Prints the world trimming started message and starts trimming
+"""
+@hook.command("script_trim")
+def print_backup_trim(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&4 =&3 Deleting all chunks beyond border now.")
+        server.dispatchCommand(server.getConsoleSender(), "wb Creative trim 1000000 15")
+        server.dispatchCommand(server.getConsoleSender(), "wb trim confirm")
+    else:
+        noperm(sender)
+
+"""
+Prints the thimming finished message
+arg 0 size difference of world
+arg 1: world border trim data
+"""
+@hook.command("script_trim_result")
+def print_backup_trim_res(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&4 =&3 Chunk deletion saved %s (&a%sMB&3)" % (" ".join(args[1:]), args[0]))
+    else:
+        noperm(sender)
+
+"""
+Prints the database backup started message and admin-chat warning
+"""
+@hook.command("script_backup_database_begin")
+def print_backup_db_begin(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&6 =&2 Starting database backup now.")
+        server.dispatchCommand(server.getConsoleSender(), "ac &aLogblock may be unavailable!")
+    else:
+        noperm(sender)
+
+"""
+Prints the database dumps compression started message
+"""
+@hook.command("script_backup_database_dumps")
+def print_backup_db_dumps(sender, command, label, args):
+    if not is_player(sender):
+        server.dispatchCommand(server.getConsoleSender(), "ac &aDumps completed, logblock available again.")
+        server.dispatchCommand(server.getConsoleSender(), "ac &aNow compressing dumps, will take a while...")
+    else:
+        noperm(sender)
+
+"""
+Prints the database finished message and backup size in admin-chat
+arg 0 size of backup
+"""
+@hook.command("script_backup_database_end")
+def print_backup_db_end(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&6 =&2 Database backup completed.")
+        server.dispatchCommand(server.getConsoleSender(), "ac &abackup size: &2%sMB&a." % args[0])
+    else:
+        noperm(sender)
+
+"""
+Prints the database backup error message
+"""
+@hook.command("script_backup_database_error")
+def print_backup_db_error(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&6 =&c&l Error while backing up database!")
+    else:
+        noperm(sender)
+
+"""
+Prints the database backup abort message
+"""
+@hook.command("script_backup_database_abort")
+def print_backup_db_abort(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&6 =&2 Database backup aborted.")
+    else:
+        noperm(sender)
+
+"""
+Prints the spigot update message
+"""
+@hook.command("script_spigot_update")
+def print_update(sender, command, label, args):
+    if not is_player(sender):
+        broadcast(None, "&9 =&2 A new Spigot version has been downloaded!")
+        broadcast(None, "&9 =&2 Update will be applied after the next reboot.")
+    else:
+        noperm(sender)
+
+"""
+Prints the admin-chat warning for disk is filled
+arg 0 fill percentage
+"""
+@hook.command("script_disk_filled")
+def print_disk_filled(sender, command, label, args):
+    if not is_player(sender):
+        server.dispatchCommand(server.getConsoleSender(), "ac &4&lWARNING:&6 Disk is filled > 96% (" + args[0] + "%)")
+        server.dispatchCommand(server.getConsoleSender(), "ac &4  Server will shut down at 98%!")
+        server.dispatchCommand(server.getConsoleSender(), "ac &4  Contact an admin &nimmediately&4!")
+    else:
+        noperm(sender)
+
+"""
+Saves all worlds, kicks players and shuts down the server
+arg 0: reason
+"""
+@hook.command("script_shutdown")
+def shutdown(sender, command, label, args):
+    if not is_player(sender):
+        server.dispatchCommand(server.getConsoleSender(), "save-all")
+        server.dispatchCommand(server.getConsoleSender(), "kickall %s" % " ".join(args))
+        server.dispatchCommand(server.getConsoleSender(), "stop")
+    else:
+        noperm(sender)

secrets.py.example

@@ -0,0 +1,3 @@
+mysql_database = "jdbc:mysql://localhost/database"
+mysql_user     = "username"
+mysql_pass     = "secret"

servercontrol.py

@@ -0,0 +1,115 @@
+from helpers import *
+import socket
+import threading
+import time
+from java.lang import Runnable
+from adminchat import adminchat
+
+"""
+Module to allow our servercontrol telnet server forward chat and speak in AC
+
+
+"""
+host = ""
+port = 1122
+
+sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
+
+try:
+	sock.bind((host,port))
+	sock.setblocking(True)
+	sock.listen(5)
+except socket.error as e:
+	print(str(e))
+
+def command_process(text):
+    text = list(text)
+    args = []
+    arg = ""
+    
+    for char in text:
+        if char != " " and char != "\n" and char != "\r" and char != "\t":
+            arg += char
+        elif arg != "":
+            args.append(arg)
+            arg = ""
+    if arg != "":
+        args.append(arg)
+    return args
+
+clients = []
+clients_l = threading.Lock()
+
+class client():
+	def __init__(self,conn,address,name):
+		self.conn = conn
+		self.address = address
+		self.name = name
+		
+		with clients_l:
+			clients.append(self)
+
+		self.conn.setblocking(False)
+
+		self.client_thread = threading.Thread(target=self.client_t)
+		self.client_thread.daemon = True
+		self.client_thread.start()
+
+	def getName(self):
+		return self.name
+
+
+	def close_connection(self):
+		try:
+			self.conn.close()
+			with clients_l:
+				clients.remove(self)
+		except:
+			pass
+
+
+	def client_t(self):
+
+		while True:
+			time.sleep(0.1)
+			try:
+				data = self.conn.recv(1024)
+			except:
+				if self not in clients:
+					self.close_connection()
+				continue
+
+			if self not in clients: #If the connection was closed, kill the thread
+				break
+
+			adminchat(self,data)
+
+
+def handle_conn():
+	while True:
+		try:
+			conn, address = sock.accept()
+		except:
+			time.sleep(0.1)
+			continue
+
+		#Send name
+		data = conn.recv(1024)
+		data = command_process(data)
+		print "servercontrol connected! %s " %data[0]
+		client_c = client(conn, address,data[0])
+
+
+handle_conn_t = threading.Thread(target=handle_conn)
+handle_conn_t.daemon = True
+handle_conn_t.start()
+
+
+@hook.event("player.AsyncPlayerChatEvent","low")
+def on_chat(event):
+	sender = event.getPlayer().getName()
+	msg = event.getMessage()
+	
+	for entry in clients:
+		entry.conn.sendall(sender + " " + msg)

serversigns.py

@@ -0,0 +1,423 @@
+from helpers import *
+from basecommands import simplecommand, Validate
+import org.bukkit.Material as Material
+import java.util.UUID as UUID
+import org.bukkit.Material as Material
+import org.bukkit.block.BlockFace as BlockFace
+from math import ceil
+
+commands_whitelist = (
+    "mail", "email", "memo",
+    "echo", "ping", 
+    "cg join",
+    "cg info",
+    "chatgroup join",
+    "chatgroup info",
+    "i",
+    "item",
+    "p h", "plot home", "plot h", "p home", "plotme home", "plotme h",
+    "up",
+    "tppos",
+    "seen",
+)
+
+max_line_length = 256
+max_lines = 20
+help_page_size = 12
+
+def load_signs():
+    signs_obj = open_json_file("serversigns", [])
+    loaded = {}
+    for entry in signs_obj:
+        loaded[tuple(entry[:4])] = list(entry[4:])
+    return loaded
+
+def save_signs():
+    signs_obj = []
+    for key, value in signs.iteritems():
+        signs_obj.append(key + tuple(value))
+    save_json_file("serversigns", signs_obj)
+
+# {("world", x, y, z): ["owner_id", "msg1", "msg2"]}
+signs = load_signs() 
+
+# Accumulated messages so players can have longer messages: {"Dico200": "Message...........", ""}
+lines = {}
+
+def fromLoc(bLoc):
+    """
+      # Returns a tuple containing the (bukkit)location's world's name and its x, y and z coordinates
+      # The format for the tuple is ("world_name", x, y, z)
+    """
+    return (bLoc.getWorld().getName(), bLoc.getBlockX(), bLoc.getBlockY(), bLoc.getBlockZ())
+
+def equals(loc1, loc2):
+    """
+      # Returns whether loc1 and loc2 represent the same block
+    """
+    for i in range(4):
+        if loc1[i] != loc2[i]:
+            return False
+    return True
+
+def getOwner(sign):
+    """
+      # Returns the name of the sign its owner
+    """
+    return retrieve_player(sign[0]).getName()
+
+def isOwner(sign, player):
+    """
+      # Returns whether the given player owns the sign
+    """ 
+    return sign and sign[0] == uid(player)
+
+def canEdit(sign, player):
+    """ 
+      # Returns whether the given player can edit the sign.
+      # Returns False if the sign wasn't claimed.
+    """
+    return (sign and player.hasPermission("utils.serversigns.admin")) or isOwner(sign, player)
+
+def getSign(locAt):
+    """
+      # If data was found for a sign at the given location, returns the data.
+      # This data follows the format of ["owner_id", "msg1", "msg2"...].
+    """
+    for loc, sign in signs.iteritems():
+        if equals(locAt, loc):
+            return sign
+    return None
+
+def identifySign(loc):
+    """
+      # Returns a string from which the user can tell what sign you're talking about.
+      # The string follows the format of "sign at (x,y,z) in world_name".
+    """
+    return "sign at (%s) in %s" % (",".join((str(i) for i in loc[1:])), loc[0])
+
+def signsMsg(msg, colour = '4'):
+    """
+      # Returns the given msg, prefixed with '[Signs] '.
+      # The given colour is after applied to the msg.
+      # The colour defaults to 4 (dark red).
+    """
+    return "&c[Signs] &" + colour + msg
+
+
+# /svs command
+
+
+subcommand_info = (
+
+    (("claim",), (
+        "Claims the sign so that you can add messages to it", 
+    ), (("[owner]", "claims.other"),)),
+    (("info", "lines"), (
+        "Displays information about the (claimed) sign",
+    )),
+    (("add",), (
+        "Adds the message to the sign. Use ++ at the end",
+        "to add the message to your buffer. You can then use",
+        "the same command again to create a longer message",
+    ), (("<message>[++]", None),)),
+    (("remove", "rem", "del", "delete"), (
+        "Removes the message with the given ID from the sign.",
+        "The ID is given before each message by &b/svs info&a.",
+    ), (("<message ID>", None),)),
+    (("switch", "reverse"), (
+        "Reverses the order in which the given messages are shown.",
+    ), (("<message ID 1> <message ID 2>", None),)),
+    (("clear",), (
+        "Removes all messages from the sign.",
+    )),
+    (("reset", "unclaim"), (
+        "Resets the sign, removing all messages and its owner.",
+    )),
+    (("whitelist", "commands", "wl"), (
+        "Displays a list of whitelisted commands",
+    )),
+    (("help",), (
+        "Displays this help page",
+    ), (("[page]", None),)),
+
+)
+
+
+
+@simplecommand(cmd = "serversigns", aliases = ["svs", "signmsg"],
+    description = "Makes something happen when you right click signs. \nUse /svs help for more details.",
+    usage = "<claim|reset|add <msg>[++]|remove <ID>|clear|info|help>",
+    helpNoargs = True,
+    senderLimit = 0)
+def svs_command(sender, command, label, args):
+    arg1 = args[0].lower()
+
+    cmd_info = None
+    for cmd in subcommand_info:
+        if arg1 in cmd[0]:
+            cmd_info = cmd
+            break
+
+    Validate.notNone(cmd_info, signsMsg("That command could not be recognized, use &o/svs help &4for expected arguments"))
+    cmd = cmd_info[0][0]
+    Validate.isAuthorized(sender, "utils.serversigns." + cmd)
+
+    #-------------------- Sub commands that don't require any conditions -----------------------
+    if cmd == "help":
+        all_lines = [
+            "&aServer signs let's you add messages to a sign.",
+            "Right clicking the sign will display all the messages. Commands",
+            "can also be added, by prefixing the message with a '/'.",
+            "How to use &b/serversigns&a:",
+        ]
+
+        for cmd in subcommand_info:
+            if sender.hasPermission("utils.serversigns." + cmd[0][0]):
+                params = ""
+                if len(cmd) == 3:
+                    for param, perm in cmd[2]:
+                        if perm is None or sender.hasPermission("utils.serversigns." + perm):
+                            params += param + " "
+                all_lines.append("&b/svs %s %s" % ("|".join(cmd[0]), params))
+                for info_line in cmd[1]:
+                    all_lines.append("&a- " + info_line)
+
+        last_page = int(ceil(len(all_lines) / help_page_size))
+        info("last page: %d" % last_page)
+        page = 1
+        if len(args) > 1 and args[1].isdigit():
+            page = int(args[1])
+            if page <= 0:
+                page = 1
+            elif page > last_page:
+                page = last_page
+
+        first_line = signsMsg("Serversigns help page %d" % page, '6')
+        if page < last_page:
+            first_line += ", &e/svs help %d&6 for the next" % (page + 1)
+        page_lines = [first_line] + all_lines[(page - 1) * help_page_size : min(page * help_page_size, len(all_lines))]
+        return "\n".join(page_lines)
+
+
+    if cmd == "whitelist":
+        return signsMsg("Whitelisted commands: &3" + ", ".join(commands_whitelist), 'a')
+    #-------------------------------------------------------------------------------------------
+
+    block = sender.getTargetBlock(None, 5)
+    Validate.isTrue(block.getType() in (Material.SIGN_POST, Material.WALL_SIGN), signsMsg("You have to be looking at a sign to use that!"))
+
+    loc      = fromLoc(block.getLocation())
+    sign     = getSign(loc)
+    signName = identifySign(loc)
+    arg2     = args[1].lower() if len(args) > 1 else None
+
+    #------------------------ Sub commands that require the block to be a sign -------------------------------
+    if cmd == "claim":
+        Validate.isTrue(not sign, signsMsg("The %s was already claimed" % signName))
+        Validate.isTrue(can_build2(sender, block), signsMsg("You are not permitted to claim signs here"))
+        target = sender
+        if arg2:
+            Validate.isTrue(player.hasPermission("utils.serversigns.admin"), signsMsg("You are not authorized to claim signs for other players"))
+            target = server.getOfflinePlayer(arg2)
+            Validate.notNone(target, signsMsg("That player could not be found"))
+            Validate.isTrue(target.isOnline(), signsMsg("The target has to be online"))
+        uuid = uid(target)
+        if sign != None:
+            if sign[0] == uuid:
+                return signsMsg("The " + signName + " was already owned by that player")
+            else:
+                sign[0] = uuid
+        else:
+            signs[loc] = [uuid]
+        save_signs()
+        return signsMsg("Claimed the " + signName + ((" for %s" % target.getName()) if (target != sender) else ""), 'a')
+    #----------------------------------------------------------------------------------------------------------
+
+    Validate.notNone(sign, signsMsg("The %s has not been claimed" % signName))
+
+    #----------------------Sub commands that require the sign to be claimed as well------------------------------------
+    if cmd == "info":
+        sign_lines = ""
+        for id, line in enumerate(sign[1:]):
+            sign_lines += ("\n &a%s: \"&f%s&a\"" % (id + 1, line))
+        return signsMsg("Properties of the %s:\n Owner: %s\n Lines: %s" % (signName, getOwner(sign), sign_lines), 'a')
+    #---------------------------------------------------------------------------------------------------------------
+
+    Validate.isTrue(canEdit(sign, sender), signsMsg("You do not own the %s!" % signName))
+
+    #---------------------- Sub commands that require you to own targeted sign as well -------------------------
+    if cmd == "add":
+        Validate.isTrue(len(sign) - 1 <= max_lines, signsMsg("This sign already has the maximum amount of lines, you cannot add more"))
+
+        line = " ".join(args[1:])
+        Validate.isTrue(line != "" and line != None, signsMsg("You have to enter a message to add or accumulate"))
+        key  = sender.getName()
+        global lines
+        Validate.isTrue(key in lines or line[:1] != "/" or sender.hasPermission("utils.serversigns.command"), signsMsg("You cannot add commands to a sign!"))
+
+        if line[-2:] == "++":
+            if key not in lines:
+                lines[key] = ""
+            Validate.isTrue(len(lines[key]) + len(line[:-2]) + 1 <= max_line_length, signsMsg("This line would be too long, so the given message was not added to the accumulated message"))
+            lines[key] += " " + line[:-2]
+            return signsMsg("Added given message to the message you're accumulating. \nYour accumulated message is now as follows: \n&f%s" % lines[key], 'a')
+
+        if key in lines:
+            line = (lines[key] + " " + line)[1:]
+            Validate.isTrue(len(line) <= max_line_length, signsMsg("This line would be too long, so it was not added to the sign. It is however still accumulated."))
+
+        if line[0] == "/":
+            cmd = line[1:].lower()
+            whitelisted = False
+            for wl_cmd in commands_whitelist:
+                if cmd[:len(wl_cmd)] == wl_cmd:
+                    whitelisted = True
+                    break
+            Validate.isTrue(whitelisted, signsMsg("That command is not whitelisted for use with serversigns"))
+
+        if key in lines:
+            del lines[key]
+
+        sign.append(colorify(line) if line[0] != "/" else line)
+        save_signs()
+        return signsMsg("Added line \"&f%s&a\" to the %s" % (line, signName), 'a')
+
+
+    if cmd == "remove":
+        Validate.notNone(arg2, signsMsg("You have to enter the ID of the message to remove!"))
+        try:
+            id = int(arg2)
+        except:
+            return signsMsg("The ID of the message has to be a number and can be found by using &o/svs info")
+        Validate.isTrue(id != 0 and id < len(sign), signsMsg("The %s has no message with an ID of %s, use &o/svs info &4for all messages." % (signName, id)))
+        del sign[id]
+        return signsMsg("Removed message with id %s from the %s" % (id, signName), 'a')
+
+
+    if cmd == "switch":
+        Validate.isTrue(len(args) == 3, signsMsg("You have to enter the 2 IDs of the messages to reverse"))
+        try:
+            id1 = int(args[1])
+            id2 = int(args[2])
+        except:
+            return signsMsg("The ID of the message has to be a number and can be found by using &o/svs info")
+        for id in (id1, id2):
+            Validate.isTrue(id != 0 and id < len(sign), signsMsg("The %s has no message with an ID of %s, use &o/svs info &4for all messages." % (signName, id)))
+        sign[id1], sign[id2] = sign[id2], sign[id1]
+        save_signs()
+        return signsMsg("Reversed the messages with IDs %s and %s of the %s" % (id1, id2, signName), 'a')
+
+
+    if cmd == "clear":
+        signs[loc] = [sign[0]]
+        save_signs()
+        return signsMsg("Removed all messages from the %s" % signName, 'a')
+
+
+    if cmd == "reset":
+        del signs[loc]
+        save_signs()
+        return signsMsg("Removed all messages and the owner from the %s, it can now be claimed" % signName, 'a')
+
+    #-------------------------------------------------------------------------------------------------------
+
+
+@hook.event("player.PlayerInteractEvent")
+def on_click(event):
+    if str(event.getAction()) != "RIGHT_CLICK_BLOCK":
+        return
+    block = event.getClickedBlock()
+    if block.getType() not in (Material.WALL_SIGN, Material.SIGN_POST):
+        return
+    sign = getSign(fromLoc(block.getLocation()))
+    if sign != None:
+        player = event.getPlayer()
+        for message in sign[1:]:
+            if message[:1] == "/":
+                server.dispatchCommand(player, message[1:])
+            else:
+                msg(player, message, usecolor = False)
+
+# ---------------------------Sign breaking--------------------------------
+
+checking_block = False
+
+faces = {
+    BlockFace.NORTH : (0,1,2,),
+    BlockFace.SOUTH : (3,),
+    BlockFace.WEST  : (4,),
+    BlockFace.EAST  : (5,),
+}
+
+@hook.event("block.BlockBreakEvent", "monitor")
+def on_break(event):
+    if checking_block or event.isCancelled():
+        return
+
+    block = event.getBlock()
+    if block.getType() in (Material.SIGN_POST, Material.WALL_SIGN):
+        check_sign(event, block, attached = False)
+
+    for block_face, data_values in faces.iteritems():
+        block2 = block.getRelative(block_face)
+        if block2.getType() == Material.WALL_SIGN and block2.getData() in data_values:
+            check_sign(event, block2)
+
+    block3 = block.getRelative(BlockFace.UP)
+    if block3.getType() == Material.SIGN_POST:
+        check_sign(event, block3)
+
+
+def check_sign(event, block, attached = True):
+    player = event.getPlayer()
+    loc = fromLoc(block.getLocation())
+    if block.getType() not in (Material.WALL_SIGN, Material.SIGN_POST) or getSign(loc) is None:
+        return
+    if not can_build2(player, block):
+        event.setCancelled(True)
+        msg(event.getPlayer(), signsMsg("You cannot break %s" % ("the sign attached to that block" if attached else "that sign")))
+    else:
+        del signs[loc]
+        save_signs()
+        msg(player, signsMsg("Reset the %s which you just broke" % identifySign(loc)))
+
+
+def can_build2(player, block):
+    global checking_block
+    event = BlockBreakEvent(block, player)
+    checking_block = True
+    server.getPluginManager().callEvent(event)
+    checking_block = False
+    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.
+    """
+
+    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]

setup.sh

@@ -0,0 +1,175 @@
+#!/usr/bin/env bash
+
+# exit on failure
+set -e
+
+for cmd in curl java unzip git pip; do
+  if ! which "$cmd" >/dev/null; then
+    tput setf 4 >&2
+    echo "Error: please install '$cmd' to proceed" >&2
+    tput sgr0 >&2
+    exit 1
+  fi
+done
+
+echo -e "> This will only set up Spigot and all the plugins, configuration files are still up to you to manage"
+echo -e "> Press enter to coninue"
+read
+
+mkdir -v "redstoner"
+cd "redstoner"
+
+mkdir -v "server"
+
+mkdir -v "build"
+cd "build"
+
+echo -e "\n> Downloading Spigot build tools"
+curl --progress-bar -Lo "BuildTools.jar" "https://hub.spigotmc.org/jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar"
+
+echo -e "\n> Building Spigot, this will take a while ..."
+java -jar BuildTools.jar > /dev/null
+
+cp -v spigot-*.jar "../server/spigot.jar"
+rm spigot-*.jar
+cd "../server/"
+
+mkdir -v "plugins"
+cd "plugins"
+
+echo ">> Downloading essentials.jar ..."
+curl --progress-bar -Lo "essentials.jar" "https://github.com/RedstonerServer/Essentials/releases/download/stable-2.9.6-REDSTONER/Essentials-2.x-REDSTONER.jar"
+echo ">> Downloading essentialschat.jar ..."
+curl --progress-bar -Lo "essentialschat.jar" "https://hub.spigotmc.org/jenkins/job/Spigot-Essentials/lastSuccessfulBuild/artifact/EssentialsChat/target/EssentialsChat-2.x-SNAPSHOT.jar"
+echo ">> Downloading imageonmap.jar ..."
+curl --progress-bar -Lo "imageonmap.jar." "https://dev.bukkit.org/media/files/772/680/imageonmap.jar"
+echo ">> Downloading logblock.jar ..."
+curl --progress-bar -Lo "logblock.jar." "https://dev.bukkit.org/media/files/757/963/LogBlock.jar"
+echo ">> Downloading logblockquestioner.zip ..."
+curl --progress-bar -Lo "logblockquestioner.zip" "https://cloud.github.com/downloads/DiddiZ/LogBlockQuestioner/LogBlockQuestioner%20v0.03.zip"
+echo ">> Downloading multiverse-core.jar ..."
+curl --progress-bar -Lo "multiverse-core.jar" "https://dev.bukkit.org/media/files/588/781/Multiverse-Core-2.4.jar"
+echo ">> Downloading multiverse-portals.jar ..."
+curl --progress-bar -Lo "multiverse-portals.jar." "https://dev.bukkit.org/media/files/588/790/Multiverse-Portals-2.4.jar"
+echo ">> Downloading multiverse-netherportals.jar ..."
+curl --progress-bar -Lo "multiverse-netherportals.jar." "https://dev.bukkit.org/media/files/589/64/Multiverse-NetherPortals-2.4.jar"
+echo ">> Downloading multiverse-inventories.jar ..."
+curl --progress-bar -Lo "multiverse-inventories.jar." "https://dev.bukkit.org/media/files/663/303/Multiverse-Inventories-2.5.jar"
+echo ">> Downloading permissionsex.jar ..."
+curl --progress-bar -Lo "permissionsex.jar" "https://dev.bukkit.org/media/files/882/992/PermissionsEx-1.23.3.jar"
+echo ">> Downloading plotme.jar ..."
+curl --progress-bar -Lo "plotme.jar" "http://ci.worldcretornica.com/job/PlotMe-Core/244/artifact/target/PlotMe-Core.jar"
+echo ">> Downloading plotme-defaultgenerator.jar ..."
+curl --progress-bar -Lo "plotme-defaultgenerator.jar" "http://ci.worldcretornica.com/job/PlotMe-DefaultGenerator/83/artifact/target/PlotMe-DefaultGenerator.jar"
+echo ">> Downloading serversigns.jar ..."
+curl --progress-bar -Lo "serversigns.jar." "https://dev.bukkit.org/media/files/876/381/ServerSigns.jar"
+echo ">> Downloading redstoneclockdetector.jar ..."
+curl --progress-bar -Lo "redstoneclockdetector.jar." "https://dev.bukkit.org/media/files/577/253/RedstoneClockDetector.jar"
+echo ">> Downloading vault.jar ..."
+curl --progress-bar -Lo "vault.jar" "https://dev.bukkit.org/media/files/837/976/Vault.jar"
+echo ">> Downloading worldborder.jar ..."
+curl --progress-bar -Lo "worldborder.jar." "https://dev.bukkit.org/media/files/883/629/WorldBorder.jar"
+echo ">> Downloading worldguard.jar ..."
+curl --progress-bar -Lo "worldguard.jar." "https://github.com/RedstonerServer/WorldGuard/releases/download/6.0.0-redstoner/worldguard-6.0.0-REDSTONER.jar"
+echo ">> Downloading worldedit.jar ..."
+curl --progress-bar -Lo "worldedit.jar" "https://dev.bukkit.org/media/files/880/435/worldedit-bukkit-6.1.jar"
+echo ">> Downloading pythonpluginloader.jar ..."
+curl --progress-bar -Lo "pythonpluginloader.jar" "https://bamboo.gserv.me/browse/PLUG-PYPL/latestSuccessful/artifact/JOB1/Version-agnostic-jar/PyPluginLoader.jar"
+
+echo -e "\n> Unpacking LogBlockQuestioner"
+unzip -q "logblockquestioner.zip" "LogBlockQuestioner.jar"
+rm "logblockquestioner.zip"
+mv -v "LogBlockQuestioner.jar" "logblockquestioner.jar."
+
+echo -e "\n> Pulling redstoner-utils ..."
+git clone -q "git@github.com:RedstonerServer/redstoner-utils.git" "redstoner-utils.py.dir" > /dev/null
+
+echo -e "\n> Installing dependencies"
+pip install passlib
+
+echo -e "\n> All plugins downloaded"
+
+cd "redstoner-utils.py.dir"
+echo -e "\n> Duplicating sample files"
+for file in ./*.example; do
+  cp -v "$file" "$(echo "$file" | rev | cut -d "." -f 2- | rev)"
+done
+
+cd "../.."
+
+mkdir -v "lib"
+cd "lib"
+
+echo -e "\n> Downloading MySQL Connector ..."
+curl --progress-bar -Lo "mysql-connector.zip" "https://dev.mysql.com/get/Downloads/Connector-J/mysql-connector-java-5.1.36.zip"
+echo "> Extracting MySQL Connector"
+unzip -p mysql-connector.zip "mysql-connector-java-5.1.36/mysql-connector-java-5.1.36-bin.jar" > mysql-connector.jar
+rm "mysql-connector.zip"
+
+cd ".."
+
+echo -e "\n> Creating startup script"
+
+cat > start.sh <<EOF
+#!/usr/bin/env bash
+java -Xms512m -Xmx1g -jar spigot.jar
+EOF
+chmod +x start.sh
+
+port="25565"
+re='^[0-9]+$'
+if [[ "$1" =~ $re ]]; then
+  port="$1"
+fi
+
+echo "> Setting port to $port"
+echo "> Generating server.properties"
+
+cat > server.properties <<EOF
+#Minecraft server properties
+#Sat Jul 25 15:42:21 CEST 2015
+spawn-protection=16
+generator-settings=
+force-gamemode=false
+allow-nether=true
+gamemode=1
+broadcast-console-to-ops=true
+enable-query=false
+player-idle-timeout=0
+difficulty=1
+spawn-monsters=true
+op-permission-level=4
+resource-pack-hash=
+announce-player-achievements=true
+pvp=true
+snooper-enabled=true
+level-type=FLAT
+hardcore=false
+enable-command-block=false
+max-players=20
+network-compression-threshold=256
+max-world-size=29999984
+server-port=$port
+server-ip=
+spawn-npcs=true
+allow-flight=false
+level-name=world
+view-distance=10
+resource-pack=
+spawn-animals=true
+white-list=false
+generate-structures=true
+online-mode=true
+max-build-height=256
+level-seed=
+use-native-transport=true
+motd=Redstoner dev server
+enable-rcon=false
+EOF
+
+echo -e "> Generating eula.txt"
+echo "eula=true" > eula.txt
+
+echo -e "\n> $(tput setf 2)All Done! $(tput sgr0)Don't forget to configure plugins for your needs."
+echo "> Run redstoner/server/start.sh to start the server"
+echo "> Our plugins are in redstoner/server/plugins/redstoner-utils.py.dir"

signalstrength.py

@@ -0,0 +1,159 @@
+from helpers import *
+import org.bukkit.inventory.ItemStack as ItemStack
+import org.bukkit.Material as Material
+from math import ceil
+from basecommands import simplecommand, Validate, CommandException
+
+""" Suggestion by Armadillo28, see thread: http://redstoner.com/forums/threads/2213?page=1#reply-14507 """
+
+disallowed_item_types = (
+    Material.getMaterial(0),
+    Material.getMaterial(175),
+    Material.getMaterial(383),
+)
+
+default_args = open_json_file("signalstrengthdefaults", {})
+
+def save_defaults():
+    save_json_file("signalstrengthdefaults", default_args)
+
+
+def item_name(item_type, remove_underscores = True):
+    typ = str(item_type).lower()
+    return typ.replace("_", "") if remove_underscores else typ
+
+
+def item_type_allowed(item_type):
+    return not item_type in disallowed_item_types
+
+
+def required_item_count(strength, stack_size, slot_count):
+    if strength == 0:
+        item_count = 0
+    elif strength == 1:
+        item_count = 1
+    else:
+        item_count = int(ceil(slot_count * stack_size / 14.0 * (strength - 1)))
+
+    resulting_strength = 0 if item_count == 0 else int(1 + 14.0 * item_count / stack_size / slot_count)
+    #Clarification on these formulas at http://minecraft.gamepedia.com/Redstone_Comparator#Containers
+
+    return item_count if resulting_strength == strength else None
+
+
+def get_data(player, args):
+    uuid = uid(player)
+    if uuid in default_args:
+        strength, item_type, item_data = default_args[uuid]
+        item_type = Material.getMaterial(item_type)
+    else:
+        strength  = 1
+        item_type = Material.REDSTONE
+        item_data = 0
+
+    if len(args) > 0:
+        Validate.isTrue(args[0].isdigit() and 0 <= int(args[0]) <= 15, "&cThe signal strength has to be a value from 0 to 15")
+        strength = int(args[0])
+
+    if len(args) > 1:
+        if args[1].isdigit():
+            item_type = Material.getMaterial(int(args[1]))
+        else:
+            item_type = Material.matchMaterial(args[1])
+        Validate.notNone(item_type, "&cThat item type could not be found")
+        Validate.isTrue(item_type not in disallowed_item_types, "&cThat item type may not be used")
+
+    if len(args) > 2:
+        Validate.isTrue(args[2].isdigit() and 0 <= int(args[2]) <= 15, "&cThe data has to be a value from 0 to 15")
+        item_data = int(args[2])
+
+    return (strength, item_type, item_data)
+
+
+def get_inventory(block):
+    try:
+        return block.getState().getInventory()
+    except AttributeError:
+        return None
+
+
+def get_entire_container(container):
+    container_blocks = [container]
+    container_type = container.getType()
+    if container_type in (Material.CHEST, Material.TRAPPED_CHEST):
+        loc = container.getLocation()
+        x = loc.getBlockX()
+        y = loc.getBlockY()
+        z = loc.getBlockZ()
+        world = loc.getWorld()
+
+        container_blocks += [
+            block for block in (
+                world.getBlockAt(x + 1, y, z), 
+                world.getBlockAt(x - 1, y, z), 
+                world.getBlockAt(x, y, z + 1), 
+                world.getBlockAt(x, y, z - 1),
+            ) if block.getType() == container_type
+        ]
+
+    return container_blocks
+
+
+
+@simplecommand("signalstrength",
+        usage = "(default) [signalstrength] [item] [data]",
+        aliases = ["ss", "level"],
+        description = "Fills the targeted container with the correct amount of items to achieve the desired signal strength.",
+        amin = 0,
+        amax = 4,
+        helpSubcmd = True,
+        senderLimit = 0)
+def on_signalstrength_command(sender, command, label, args):
+
+    if len(args) > 0 and args[0].lower() in ("default", "defaults", "setdefaults"):
+        strength, item_type, item_data = get_data(sender, args[1:])
+
+        uuid = uid(sender)
+        if strength == 1 and item_type == Material.REDSTONE and item_data == 0:
+            if uuid in default_args:
+                del default_args[uuid]
+                save_defaults()
+        else:
+            default_args[uuid] = (strength, str(item_type), item_data)
+            save_defaults()
+
+        return "&aSet your signal strength defaults to (%s, %s, %s)" % (strength, item_name(item_type, False), item_data)
+
+    Validate.isTrue(len(args) <= 3, "&cExpected at most 3 arguments")
+
+    target_block = sender.getTargetBlock(None, 5)
+    Validate.notNone(target_block, "&cThat command can only be used when a container is targeted")
+
+    inventory = get_inventory(target_block)
+    Validate.notNone(inventory, "&cThat command can only be used if a container is targeted")
+
+    strength, item_type, item_data = get_data(sender, args)
+
+    #--------Get the stack size and required amount of items to achieve the desired signal strength---------
+    stack_size = item_type.getMaxStackSize()
+    slot_count = inventory.getSize()
+
+    item_count = required_item_count(strength, stack_size, slot_count)
+    Validate.notNone(item_count, "&cThe desired signal strength could not be achieved with the requested item type")
+
+    #--------Add the other side of the chest if target is a double chest and check if player can build---------
+    container_blocks = get_entire_container(target_block)
+    for block in container_blocks:
+        Validate.isTrue(can_build(sender, block), "&cYou do not have permission to do that here")
+
+    #----------------Insert items-------------
+    full_stack_count, remaining = divmod(item_count, stack_size)
+    for block in container_blocks:
+        inv = block.getState().getInventory()
+        inv.clear()
+        for i in range(full_stack_count):
+            inv.setItem(i, ItemStack(item_type, stack_size, item_data))
+        if remaining > 0:
+            inv.setItem(full_stack_count, ItemStack(item_type, remaining, item_data))
+
+    return "&aComparators attached to that %s will now put out a signal strength of %s" % (item_name(target_block.getType()), strength)

snowbrawl.py

@@ -0,0 +1,969 @@
+#Snowbrawl
+from helpers import *
+import time, threading, copy
+import org.bukkit.inventory.ItemStack as ItemStack
+import org.bukkit.Material as Material
+import org.bukkit.potion.PotionEffect as PotionEffect
+import org.bukkit.potion.PotionEffectType as PotionEffectType
+from java.lang import Runnable
+from java.util.UUID import fromString as juuid
+from operator import __contains__
+from traceback import format_exc as trace
+import random
+from synchronize import make_synchronized
+
+#file names
+file = "snowbrawl"
+
+#permissions
+list_perm = "utils.snowbrawl.list"
+modify_perm = "utils.snowbrawl.modify"
+teleport_perm = "utils.snowbrawl.tp"
+create_perm = "utils.snowbrawl.create"
+info_perm = "utils.snowbrawl.info"
+join_perm = "utils.snowbrawl.join"
+quit_perm = "utils.snowbrawl.quit"
+
+#commands - tp command does not exist
+list_command = "list"
+del_command = "del"
+set_command = "set"
+name_command = "name"
+pos_command = "pos"
+create_command = "create"
+info_command = "info"
+modify_command = "modify"
+modify_command_alias = "m"
+quit_command = "quit"
+
+
+
+class Arena(object):
+
+    def __init__(self, name):
+        self.queue = Queue()
+        self.name = name
+        self.refill = None
+        self.player_limit = None
+        self.start_time = None
+        self.match_goal = None # amount of deaths or time until the match ends (depends on arena_type)
+        self.arena_type = None # arena type (death or time)
+        self.explosion_damage = None
+
+        self.player_stats = {}
+        self.players = Queue()
+        self.spawn_location = []
+        self.respawn_location = []
+        self.sign_location = []
+        self.sign_click = []
+
+        self.corner1 = None # The corner1 given by the player (really bad for 3D position compare)
+        self.corner2 = None # The corner2 given by the player (really bad for 3D position compare)
+        self.tpp = None # The top, positive x, positive z corner
+        self.bnn = None # The bottom, negative x, negative z corner
+
+    #set corners of arena
+    def set_corner(self, sender, type):
+        loc = sender.getLocation()
+        if type == "1":
+            self.corner1 = Coords(loc)
+        elif type == "2":
+            self.corner2 = Coords(loc)
+        msg(sender, "&a-&e Arena corner %s set" % type)
+        self.update_corner_points()
+
+    #Compares the corner1 and corner2 locations and figures out tpp and bnn so that we dont have to do it everytime we run in_arena()
+    def update_corner_points(self):
+        self.tpp = None
+        self.bnn = None
+        if self.corner1 == None or self.corner2 == None:
+            return
+        corn1 = self.corner1.get_location()
+        corn2 = self.corner2.get_location()
+        if not corn1.getWorld().getName() == corn2.getWorld().getName():
+            return
+
+        top = corn1.y if corn1.y > corn2.y else corn2.y
+        bottom = corn1.y if corn1.y < corn2.y else corn2.y
+        pos_x = corn1.x if corn1.x > corn2.x else corn2.x
+        pos_z = corn1.z if corn1.z > corn2.z else corn2.z
+        neg_x = corn1.x if corn1.x < corn2.x else corn2.x
+        neg_z = corn1.z if corn1.z < corn2.z else corn2.z
+
+        self.tpp = Coords(corn1.getWorld(), pos_x, top, pos_z, 0, 0)
+        self.bnn = Coords(corn2.getWorld(), neg_x, bottom, neg_z, 0, 0)
+
+    #add sign to sign list
+    def add_sign(self, sender, name):
+        mats = set()
+        mats = None
+        block = sender.getTargetBlock(mats, 3).getState()
+        if isinstance(block, bukkit.block.Sign):
+            self.sign_click.append(NamedCoords(name, Coords(block.getLocation())))
+            msg(sender, "&a-&e Arena tp sign %s created and set" % name)
+
+    #Delete a sign from the sign list
+    def del_sign(self, sender, name):
+        for sign in self.sign_click:
+            if sign.get_name() == name:
+                self.sign_click.remove(sign)
+                msg(sender, "&a-&e Arena tp sign %s removed" % sign.get_name())
+                return
+        msg(sender, "&a-&e Arena tp sign with this name doesn't exist")
+
+    #Adds a player to the queue if they aren't already there.
+    def add_player(self, player):
+        if not self.queue.contains(player):
+            self.queue.put(player)
+            self.start_match()
+            return True
+        return False
+
+    #remove a player from the queue
+    def remove_player(self, player):
+        if self.queue.contains(player):
+            self.queue.remove(player)
+            return True
+        return False
+
+    #return true if loc is inside the arena boundries
+    def in_arena(self, loc):
+        if self.tpp == None or self.bnn == None:
+            return False
+        loc_tpp = self.tpp.get_location()
+        loc_bnn = self.bnn.get_location()
+
+        if loc.y > loc_tpp.y:
+            return False
+        if loc.y < loc_bnn.y:
+            return False
+        if loc.x > loc_tpp.x:
+            return False
+        if loc.x < loc_bnn.x:
+            return False
+        if loc.z > loc_tpp.z:
+            return False
+        if loc.z < loc_bnn.z:
+            return False
+        return True
+
+    def get_respawn(self):
+        id = random.randint(0, len(self.respawn_location) - 1)
+        return self.respawn_location[id]
+
+
+    def spawn_player(self, player):
+        id = random.randint(0, len(self.spawn_location) - 1)
+        loc = self.spawn_location[id].get_location().get_location()
+        safetp(player, loc.getWorld(), loc.x, loc.y, loc.z, loc.yaw, loc.pitch)
+
+    #Start match
+    def start_match(self):
+        if self.player_limit == None or self.match_goal == None or self.arena_type == None or len(self.spawn_location) == 0 or len(self.respawn_location) == 0 or len(self.sign_location) == 0:
+            return
+        if len(self.queue.read()) >= self.player_limit and len(self.players.read()) == 0:
+            self.start_time = time.time()
+            for i in range(self.player_limit):
+                player = self.queue.get()
+                self.players.put(player)
+            for player in self.players.read():
+                self.player_stats[player.getName() + "_deaths"] = 0
+                self.spawn_player(player)
+                msg(player, "&6The match has started!")
+
+    def bubbleSort(self, alist):
+        for passnum in range(len(alist)-1,0,-1):
+            for i in range(passnum):
+                if self.player_stats[alist[i].getName()+"_deaths"]>self.player_stats[alist[i+1].getName()+"_deaths"]:
+                    temp = alist[i]
+                    alist[i] = alist[i+1]
+                    alist[i+1] = temp
+        return alist
+
+    @make_synchronized #Jython synchronized block
+    def end_match(self): #End match, sort the players and print the 3 players with least amount of deaths
+
+        sorted_list = self.bubbleSort(self.players.read())
+
+        for player in self.players.read():
+            if player.isOnline():
+                loc = self.sign_location[0].get_location().get_location()
+                safetp(player, loc.getWorld(), loc.x, loc.y, loc.z, loc.yaw, loc.pitch)
+                msg(player, "&6================= Match over =================")
+                msg(player, "&c&c")
+                if not len(sorted_list) < 1:
+                    msg(player, "&e1. %s (%s)" % (sorted_list[0].getName(), self.player_stats[sorted_list[0].getName()+"_deaths"]))
+                if not len(sorted_list) < 2:
+                    msg(player, "&e2. %s (%s)" % (sorted_list[1].getName(), self.player_stats[sorted_list[1].getName()+"_deaths"]))
+                if not len(sorted_list) < 3:
+                    msg(player, "&e3. %s (%s)" % (sorted_list[2].getName(), self.player_stats[sorted_list[2].getName()+"_deaths"]))
+                msg(player, "&c&c")
+                msg(player, "&e Your deaths:&6 %s" % str(self.player_stats[player.getName() + "_deaths"]))
+                msg(player, "&c&c")
+                msg(player, "&6==============================================")
+        self.players.clear()
+        self.player_stats = {}
+        self.start_match()
+
+    def check_deaths(self):
+        if self.arena_type == "death":
+            for player in self.players.read():
+                if self.player_stats[player.getName() + "_deaths"] >= self.match_goal:
+                    return True
+        return False
+
+    def is_running(self):
+        if len(self.players.read()) == 0:
+            return False
+        return True
+
+    def set_explosion_damage(self, dmg):
+        self.explosion_damage = dmg
+
+    def get_explosion_damage(self):
+        if self.explosion_damage == None:
+            return 1
+        return self.explosion_damage
+
+    def in_players(self, player):
+        return self.players.contains(player)
+
+    def set_player_limit(self, limit):
+        self.player_limit = limit
+
+    def set_end_goal(self, value):
+        self.match_goal = value
+
+    def set_type(self, type):
+        self.arena_type = type
+
+    def get_name(self):
+        return self.name
+
+    def set_refill(self, amount):
+        self.refill = int(amount)
+
+    def set_name(self, name):
+        self.name = name
+
+    def get_refill(self):
+        if self.refill == None:
+            return 16
+        return self.refill
+
+    def get_tp_signs(self):
+        return self.sign_location
+
+    def get_click_signs(self):
+        return self.sign_click
+
+    #Check if player is in the queue
+    def in_queue(self,player):
+        if self.queue.contains(player):
+            return True
+        return False
+
+    #Returns queue contents in list. use "".join(queue) to get a string
+    def get_queue_contents(self):
+        return self.queue.read()
+    #Returns queue object
+    def get_queue(self):
+        return self.queue
+
+    #Returns list of location objects of type, type.
+    def get_location(self, type):
+        if type == "spawn":
+            return self.spawn_location
+        elif type == "respawn":
+            return self.respawn_location
+        elif type == "sign":
+            return self.sign_location
+
+    #Add a location to list of type location
+    def add_location(self, name, location, type):
+        named_loc = NamedCoords(name, Coords(location))
+        if type == "spawn":
+            self.spawn_location.append(named_loc)
+        elif type == "respawn":
+            self.respawn_location.append(named_loc)
+        elif type == "sign":
+            self.sign_location.append(named_loc)
+
+    #Change location of location of type, type
+    def change_location(self, name, location, type):
+        if type == "spawn":
+            for spawn in self.spawn_location:
+                if spawn.get_name() == name:
+                    spawn.get_location().set_location(location)
+                    break
+        elif type == "respawn":
+            for respawn in self.respawn_location:
+                if respawn.get_name() == name:
+                    respawn.get_location().set_location(location)
+                    break
+        elif type == "sign":
+            for sign in self.sign_location:
+                if sign.get_name() == name:
+                    sign.get_location().set_location(location)
+                    break
+
+    #Remove location out of location
+    def delete_location(self, name, type):
+        if type == "spawn":
+            for spawn in self.spawn_location[:]:
+                if spawn.get_name() == name:
+                    self.spawn_location.remove(spawn)
+                    break
+        elif type == "respawn":
+            for respawn in self.respawn_location[:]:
+                if respawn.get_name() == name:
+                    self.respawn_location.remove(respawn)
+                    break
+        elif type == "sign":
+            for sign in self.sign_location[:]:
+                if sign.get_name() == name:
+                    self.sign_location.remove(sign)
+                    break
+
+    def get_data(self):
+        spawns = []
+        for spawn in self.spawn_location:
+            spawns.append(spawn.get_data())
+        respawns = []
+        for respawn in self.respawn_location:
+            respawns.append(respawn.get_data())
+        signs = []
+        for sign in self.sign_location:
+            signs.append(sign.get_data())
+        sign_clicks = []
+        for click in self.sign_click:
+            sign_clicks.append(click.get_data())
+        corners = []
+        corners.append(self.corner1.get_data() if not self.corner1 == None else None)
+        corners.append(self.corner2.get_data() if not self.corner2 == None else None)
+        corners.append(self.tpp.get_data() if not self.tpp == None else None)
+        corners.append(self.bnn.get_data() if not self.bnn == None else None)
+        data = {
+        "spawns": spawns,
+        "respawns": respawns,
+        "signs": signs,
+        "clicks": sign_clicks,
+        "corners": corners,
+        "explosion": self.explosion_damage,
+        "players": self.player_limit,
+        "refill": self.refill,
+        "type": self.arena_type,
+        "goal": self.match_goal,
+        "name": self.name
+        }
+        return data
+
+    def load(self, data):
+        self.explosion_damage = None if str(data["explosion"]) == "None" else float(data["explosion"])
+        self.player_limit = None if str(data["players"]) == "None" else int(data["players"])
+        self.refill = None if str(data["refill"]) == "None" else int(data["refill"])
+        self.arena_type = str(data["type"])
+        self.match_goal = None if str(data["goal"]) == "None" else int(data["goal"])
+        self.corner1 = Coords(None).load(data["corners"][0]) if not data["corners"][0] == None else None
+        self.corner2 = Coords(None).load(data["corners"][1]) if not data["corners"][1] == None else None
+        self.tpp = Coords(None).load(data["corners"][2]) if not data["corners"][2] == None else None
+        self.bnn = Coords(None).load(data["corners"][3]) if not data["corners"][3] == None else None
+        for subdata in data["spawns"]:
+            self.spawn_location.append(NamedCoords(None, None).load(subdata))
+        for subdata in data["respawns"]:
+            self.respawn_location.append(NamedCoords(None, None).load(subdata))
+        for subdata in data["signs"]:
+            self.sign_location.append(NamedCoords(None, None).load(subdata))
+        for subdata in data["clicks"]:
+            self.sign_click.append(NamedCoords(None, None).load(subdata))
+        self.name = data["name"]
+        return self
+
+#coord = an instance of Coords class, adds a name to it.
+class NamedCoords(object):
+
+    def __init__(self, name, coord):
+        self.name = name
+        self.coord = coord
+
+    def get_name(self):
+        return self.name
+
+    def get_location(self):
+        return self.coord
+
+    def get_data(self):
+        coords = self.coord.get_location()
+        data = {
+        "x": coords.x,
+        "y": coords.y,
+        "z": coords.z,
+        "yaw": coords.yaw,
+        "pitch": coords.pitch,
+        "world": coords.getWorld().getName(),
+        "name": self.name
+        }
+        return data
+
+    def load(self, data):
+        self.name = str(data["name"])
+        self.coord = Coords(None).load(data)
+        return self
+
+class Coords(object):
+
+    def __init__(self, world = None, x = None, y = None, z = None, yaw = None, pitch = None):
+        if world == None:
+            self.world = None
+            self.x = None
+            self.y = None
+            self.z = None
+            self.yaw = None
+            self.pitch = None
+            return
+        if not isinstance(world, Location):
+            self.x = x
+            self.y = y
+            self.z = z
+            self.yaw = yaw
+            self.pitch = pitch
+            self.world = world.getName()
+        else:
+            location = world
+            self.x = location.x
+            self.y = location.y
+            self.z = location.z
+            self.yaw = location.yaw
+            self.pitch = location.pitch
+            self.world = location.getWorld().getName()
+
+    def get_location(self):
+        return Location(server.getWorld(str(self.world)), float(self.x), float(self.y), float(self.z), int(self.yaw), int(self.pitch))
+
+    def set_location(self, location):
+        self.x = location.x
+        self.y = location.y
+        self.z = location.z
+        self.yaw = location.yaw
+        self.pitch = location.pitch
+        self.world = location.getWorld().getName()
+
+    def get_data(self):
+        data = {
+        "x": self.x,
+        "y": self.y,
+        "z": self.z,
+        "yaw": self.yaw,
+        "pitch": self.pitch,
+        "world": self.world
+        }
+        return data
+
+    def load(self, data):
+        self.x = float(data["x"])
+        self.y = float(data["y"])
+        self.z = float(data["z"])
+        self.yaw = int(data["yaw"])
+        self.pitch = int(data["pitch"])
+        self.world = str(data["world"])
+        return self
+
+class Queue(object):
+
+    def __init__(self):
+        self.queue = []
+
+    #Appends to queue
+    def put(self,args):
+        self.queue.append(args)
+
+    #Returns the first item in the queue and removes it
+    def get(self):
+        if len(self.queue) > 0:
+            return self.queue.pop(0)
+
+        else:
+            return False
+
+    #Returns the queue's list object
+    def read(self):
+        return self.queue
+
+    #Removes the value args from the queue
+    def remove(self,args):
+        self.queue.remove(args)
+
+    #Check if queue contains player
+    def contains(self, player):
+        if player in self.queue:
+            return True
+        return False
+
+    #Clear the queue
+    def clear(self):
+        self.queue = []
+
+##############################################################################################
+# Initialization
+##############################################################################################
+
+def save_snowbrawl():
+    out = []
+    for arena in arenas:
+        out.append(arena.get_data())
+    save_json_file(file, out)
+
+def load_snowbrawl():
+    out = []
+    buffer = open_json_file(file, [])
+    for data in buffer:
+        out.append(Arena(None).load(data))
+    return out
+
+arenas = load_snowbrawl()
+
+##############################################################################################
+# Threads
+##############################################################################################
+
+class timings_runnable(Runnable):
+
+    def __init__(self, arena):
+        self.arena = arena
+
+    def run(self):
+        self.arena.end_match()
+
+#timings thread to end arenas if their type is time
+def timings():
+    while True:
+        for arena in arenas:
+            if arena.is_running():
+                if arena.arena_type == "time":
+                    current_time = time.time()
+                    start_time = arena.start_time
+                    if arena.start_time + arena.match_goal < current_time:
+                        timing = timings_runnable(arena)
+                        server.getScheduler().runTask(server.getPluginManager().getPlugin("RedstonerUtils"), timing)
+
+        time.sleep(0.1)
+
+
+timingsThread = threading.Thread(target = timings)
+timingsThread.daemon = True #Thread dies if main thread dies
+timingsThread.start()
+
+
+
+
+
+##############################################################################################
+# Events
+##############################################################################################
+
+@hook.event("player.PlayerMoveEvent", "low")
+def onMove(event):
+    if event.getPlayer().getWorld().getName() != "minigames":
+        return
+    player = event.getPlayer()
+    for arena in arenas:
+        if arena.in_players(player):
+            loc = player.getLocation()
+            block = player.getWorld().getBlockAt(int(loc.x), int(loc.y) - 1, int(loc.z))
+            if block != None:
+                material = block.getType()
+                if material == Material.SPONGE:
+                    player.addPotionEffect(PotionEffect(PotionEffectType.JUMP, 60, 0))
+                elif material == Material.GLASS or material == Material.STAINED_GLASS:
+                    player.addPotionEffect(PotionEffect(PotionEffectType.SPEED, 60, 0))
+                elif material == Material.OBSIDIAN:
+                    player.addPotionEffect(PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, 300, 0))
+            break
+
+@hook.event("entity.PlayerDeathEvent", "high")
+def onDeath(event):
+    if event.getEntity().getWorld().getName() != "minigames":
+        return
+    if not isinstance(event.getEntity(), bukkit.entity.Player):
+        return
+    for arena in arenas:
+        if arena.in_players(event.getEntity()):
+            arena.player_stats[event.getEntity().getName() + "_deaths"] += 1
+            if arena.check_deaths():
+                arena.end_match()
+            break
+
+@hook.event("player.PlayerRespawnEvent", "high")
+def onRespawn(event):
+    if event.getPlayer().getWorld().getName() != "minigames":
+        return
+    player = event.getPlayer()
+    for arena in arenas:
+        if arena.in_players(player):
+            event.setRespawnLocation(arena.get_respawn().get_location().get_location())
+            break
+
+@hook.event("entity.ProjectileHitEvent", "high")
+def onHit(event):
+    if event.getEntity().getWorld().getName() != "minigames":
+        return
+    if event.getEntity().getName() != "Snowball":
+        return
+    location = event.getEntity().getLocation()
+    for arena in arenas:
+        if arena.in_arena(location):
+            event.getEntity().getWorld().createExplosion(location.x, location.y, location.z, float(arena.get_explosion_damage()), False, False)
+            break
+
+@hook.event("player.PlayerInteractEvent", "high")
+def onClick(event):
+    if event.getPlayer().getWorld().getName() != "minigames":
+        return
+    if str(event.getAction()) != "RIGHT_CLICK_BLOCK":
+        return
+    block = event.getClickedBlock().getState()
+    if event.getClickedBlock().getType() == Material.SNOW_BLOCK:
+        for arena in arenas:
+            if arena.in_players(event.getPlayer()):
+                inv = event.getPlayer().getInventory()
+                inv.remove(Material.SNOW_BALL)
+                inv.setItemInHand(ItemStack(Material.SNOW_BALL, arena.get_refill()))
+                event.getPlayer().updateInventory()
+                break
+
+    elif isinstance(block, bukkit.block.Sign):
+        line = str(block.getLine(1))
+        if not event.getPlayer().hasPermission(join_perm):
+            msg(event.getPlayer(), "&a-&e You don't have permission to join snowbrawl matches")
+            return
+        #go through arenas, if name matches line then add player to it
+        for arena in arenas:
+            if line == arena.get_name():
+                for sign in arena.get_click_signs():
+                    sign_loc = sign.get_location().get_location()
+                    loc = block.getLocation()
+                    if sign_loc.getWorld().getName() == loc.getWorld().getName() and sign_loc.x == loc.x and sign_loc.y == loc.y and sign_loc.z == loc.z:
+                        if arena.add_player(event.getPlayer()):
+                            msg(event.getPlayer(),"&a- &eYou have been added to the queue")
+                        else:
+                            msg(event.getPlayer(),"&a- &eYou are already in the queue")
+                        break
+        return
+
+
+@hook.event("player.PlayerQuitEvent", "normal")
+def on_quit(event):
+    #remove the player from the queue
+    player = event.getPlayer().getName()
+    for arena in arenas:
+        if arena.in_queue(player):
+            arena.remove_player(player)
+
+
+
+##############################################################################################
+# Command handling
+##############################################################################################
+
+
+def create_arena(sender, args):
+    if len(args) == 0:
+        msg(sender, "&c/sb %s <name>" % create_command)
+        return
+    arena = Arena(args[0])
+    arenas.append(arena)
+    msg(sender, "&a-&e Arena %s created" % args[0])
+
+def list_arenas(sender):
+    if len(arenas) == 0:
+        msg(sender, "&a-&e There are currently no arenas")
+        return
+    for arena in arenas:
+        msg(sender, "&a-&e %s" % arena.get_name())
+
+def arena_info(sender, args):
+    if len(args) == 0:
+        msg(sender, "&a-&e /sb info <name>")
+        return
+    if len(arenas) == 0:
+        msg(sender, "&a-&e There are currently no arenas")
+        return
+    for arena in arenas:
+        if arena.get_name() == args[0]:
+            msg(sender, "&a-&e %s" % arena.get_name())
+            #msg(sender, "&ePlayers:&6 " + "&e,&6 ".join(arena.get_queue_contents()))
+            spawn_list = []
+            for spawn in arena.get_location("spawn"):
+                spawn_list.append(spawn.get_name())
+            msg(sender, "&eSpawns:&6 " + "&e,&6 ".join(spawn_list))
+            respawn_list = []
+            for respawn in arena.get_location("respawn"):
+                respawn_list.append(respawn.get_name())
+            msg(sender, "&eRespawns:&6 " + "&e,&6 ".join(respawn_list))
+            sign_list = []
+            for sign in arena.get_location("sign"):
+                sign_list.append(sign.get_name())
+            msg(sender, "&eSigns:&6 " + "&e,&6 ".join(sign_list))
+            break
+
+def quit_match(sender):
+    for arena in arenas:
+        if arena.in_queue(sender):
+            arena.remove_player(sender)
+            msg(sender, "&a-&e Quit arena")
+            return
+    msg(sender, "&a-&e You're not in a queue")
+
+def print_help(sender):
+    msg(sender, "&a-&e Alias: &6/sb")
+    if sender.hasPermission(teleport_perm):
+        msg(sender, "&a-&e /sb <name>     Teleport to an arena")
+    if sender.hasPermission(quit_perm):
+        msg(sender, "&a-&e /sb %s   Quit a queue" % quit_command)
+    if sender.hasPermission(list_perm):
+        msg(sender, "&a-&e /sb %s   List all existing arenas" % list_command)
+    if sender.hasPermission(create_perm):
+        msg(sender, "&a-&e /sb %s   Create an arena" % create_command)
+    if sender.hasPermission(info_perm):
+        msg(sender, "&a-&e /sb %s   Show info about an arena" % info_command)
+    if sender.hasPermission(modify_perm):
+        msg(sender, "&a-&e /sb %s   Deletes an arena" % del_command)
+        msg(sender, "&a-&e /sb %s   Sets a teleport for an arena to a sign" % set_command)
+        msg(sender, "&a-&e /sb %s   Renames an arena" % name_command)
+        msg(sender, "&a-&e /sb %s   Sets the locations for an arena" % pos_command)
+        msg(sender, "&a-&e /sb %s   Modifies the arena" % modify_command)
+        msg(sender, "&a-&e Modify Aliases: &6/sbm&e,&6 /sb %s" % modify_command_alias)
+
+def set_location(sender, args):
+    if len(args) < 3:
+        msg(sender, "&c/sb pos <arena name> respawn/spawn/sign set/add/del <name>")
+        msg(sender, "&c/sb pos <arena name> bounds corner1/corner2")
+        return
+    if "bounds" not in args:
+        if len(args) < 4:
+            msg(sender, "&c/sb pos <arena name> respawn/spawn/sign set/add/del <name>")
+            msg(sender, "&c/sb pos <arena name> bounds corner1/corner2")
+            return
+    if len(arenas) == 0:
+        msg(sender, "&a-&e There are currently no arenas")
+        return
+    for arena in arenas:
+        if arena.get_name() == args[0]:
+            if args[1] == "respawn":
+                set_location_of_type(sender, args[2:], "respawn", arena)
+            elif args[1] == "spawn":
+                set_location_of_type(sender, args[2:], "spawn", arena)
+            elif args[1] == "sign":
+                set_location_of_type(sender, args[2:], "sign", arena)
+            elif args[1] == "bounds":
+                set_location_of_type(sender, args[2:], "bounds", arena)
+            break
+
+def set_location_of_type(sender, args, type, arena):
+    if len(args) == 0:
+        msg(sender, "&c/sb pos <arena name> respawn/spawn/sign set/add/del <name>")
+        msg(sender, "&c/sb pos <arena name> bounds corner1/corner2")
+        return
+    location = sender.getLocation()
+    if args[0] == "set":
+        arena.change_location(args[1], location, type)
+        msg(sender, "&a-&e Location of name %s and type %s changed to your current location" % (args[1], type))
+    elif args[0] == "add":
+        arena.add_location(args[1], location, type)
+        msg(sender, "&a-&e Location of name %s and type %s created at your current location" % (args[1], type))
+    elif args[0] == "del":
+        arena.delete_location(args[1], type)
+        msg(sender, "&a-&e Location of name %s deleted" % args[1])
+    elif args[0] == "corner1":
+        arena.set_corner(sender, "1")
+    elif args[0] == "corner2":
+        arena.set_corner(sender, "2")
+
+def rename_arena(sender, args):
+    if len(args) < 2:
+        msg(sender, "&c/sb name <name> <new name>")
+        return
+    for arena in arenas:
+        if arena.get_name() == args[0]:
+            arena.set_name(args[1])
+            msg(sender, "&a-&e Arena %s renamed to %s" % (args[0], args[1]))
+            return
+    msg(sender, "&a-&e Arena with this name doesn't exist")
+
+def delete_arena(sender, args):
+    if len(args) == 0:
+        msg(sender, "&c/sb del <name>")
+        return
+    for arena in arenas:
+        if arena.get_name() == args[0]:
+            arenas.remove(arena)
+            msg(sender, "&a-&e Arena %s deleted" % arena.get_name())
+            return
+    msg(sender, "&a-&e Arena with this name doesn't exist")
+
+def teleport_to_arena(sender, name, id):
+    try:
+        int(id)
+    except ValueError:
+        msg(sender, "&c/sb <name> <id of teleport>")
+        return
+    for arena in arenas:
+        if arena.get_name() == name:
+            i = 0
+            if int(id) > len(arena.get_tp_signs()):
+                msg(sender, "&cGiven tp id is out of range")
+                return
+            for sign in arena.get_tp_signs():
+                i += 1
+                if i == int(id):
+                    loc = sign.get_location().get_location()
+                    safetp(sender, loc.getWorld(), loc.x, loc.y, loc.z, loc.yaw, loc.pitch)
+                    break
+            msg(sender, "&a-&e Teleporting to arena %s" % name)
+            return
+    msg(sender, "&a-&e Arena with this name doesn't exist")
+
+def modify_arena(sender, args):
+    if len(args) < 3:
+        msg(sender, "&c/sb modify <arena name> limit/mode/players/explosion/refill <amount/mode (death/time)>")
+        return
+    for arena in arenas:
+        if arena.get_name() == args[0]:
+            if args[1] == "limit":
+                try:
+                    int(args[2])
+                except ValueError:
+                    msg(sender, "&cLast parameter has to be a number")
+                    return
+                arena.set_end_goal(int(args[2]))
+                msg(sender, "&a-&e Set time/death limit to:&6 %s" % int(args[2]))
+            elif args[1] == "mode":
+                if args[2] == "time" or args[2] == "death":
+                    arena.set_type(args[2])
+                    msg(sender, "&a-&e Set mode to:&6 %s" % args[2])
+                else:
+                    msg(sender, "&cInvalid mode (time, death)")
+            elif args[1] == "players":
+                try:
+                    int(args[2])
+                except ValueError:
+                    msg(sender, "&cLast parameter has to be a number")
+                    return
+                arena.set_player_limit(int(args[2]))
+                msg(sender, "&a-&e Set player limit to:&6 %s" % int(args[2]))
+            elif args[1] == "explosion":
+                try:
+                    float(args[2])
+                except ValueError:
+                    msg(sender, "&cLast parameter has to be a number")
+                    return
+                arena.set_explosion_damage(float(args[2]))
+                msg(sender, "&a-&e Set explosion power to:&6 %s" % float(args[2]))
+            elif args[1] == "refill":
+                try:
+                    int(args[2])
+                except ValueError:
+                    msg(sender, "&cLast parameter has to be a number")
+                    return
+                arena.set_refill(int(args[2]))
+                msg(sender, "&a-&e Set snowball refill to:&6 %s" % int(args[2]))
+            return
+    msg(sender, "&a-&e Arena with this name doesn't exist")
+
+def set_arena_sign(sender, args):
+    if len(args) < 3:
+        msg(sender, "&c/sb set <arena name> add/del <name>")
+        return
+    for arena in arenas:
+        if arena.get_name() == args[0]:
+            if args[1] == "add":
+                arena.add_sign(sender, args[2])
+            elif args[1] == "del":
+                arena.del_sign(sender, args[2])
+
+@hook.command("snowbrawl")
+def on_snowbrawl_command(sender, command, label, args):
+    if len(args) == 0:
+        #print help
+        plugin_header(sender, "Snowbrawl")
+        print_help(sender)
+        return True
+    elif args[0] == list_command:
+        if sender.hasPermission(list_perm):
+            #print the list of arenas
+            list_arenas(sender)
+        else:
+            noperm(sender)
+        return True
+    elif args[0] == del_command:
+        if sender.hasPermission(modify_perm):
+            #delete an arena
+            delete_arena(sender, args[1:])
+            save_snowbrawl()
+        else:
+            noperm(sender)
+        return True
+    elif args[0] == info_command:
+        if sender.hasPermission(info_perm):
+            #print info about an arena
+            arena_info(sender, args[1:])
+        else:
+            noperm(sender)
+        return True
+    elif args[0] == create_command:
+        if sender.hasPermission(create_perm):
+            #create an arena
+            create_arena(sender, args[1:])
+            save_snowbrawl()
+        else:
+            noperm(sender)
+        return True
+    elif args[0] == pos_command:
+        if sender.hasPermission(modify_perm):
+            #set arena spawn/respawn/sign tp locations
+            set_location(sender, args[1:])
+            save_snowbrawl()
+        else:
+            noperm(sender)
+        return True
+    elif args[0] == name_command:
+        if sender.hasPermission(modify_perm):
+            #rename an arena
+            rename_arena(sender, args[1:])
+            save_snowbrawl()
+        else:
+            noperm(sender)
+        return True
+    elif args[0] == set_command:
+        if sender.hasPermission(modify_perm):
+            #set an arena tp sign
+            set_arena_sign(sender, args[1:])
+            save_snowbrawl()
+        else:
+            noperm(sender)
+        return True
+    elif args[0] == modify_command or args[0] == modify_command_alias:
+        if sender.hasPermission(modify_perm):
+            #modify the arena
+            modify_arena(sender, args[1:])
+            save_snowbrawl()
+        else:
+            noperm(sender)
+        return True
+    elif args[0] == quit_command:
+        if sender.hasPermission(quit_perm):
+            #quit match
+            quit_match(sender)
+        else:
+            noperm(sender)
+        return True
+    else:
+        if sender.hasPermission(teleport_perm):
+            #try to tp to an arena
+            if len(args) > 1:
+                teleport_to_arena(sender, args[0], args[1])
+            else:
+                teleport_to_arena(sender, args[0], 1)
+        else:
+            noperm(sender)
+    return True

spawnplayer.py

@@ -1,3 +1,9 @@
+"""
+Code that was used once to create this awesome screenshot
+- https://i.imgur.com/v4wg5kl.png
+- https://i.imgur.com/tIZ3jmC.png
+- https://www.reddit.com/r/Minecraft/comments/28le52/screenshot_of_all_players_that_joined_my_server/
+"""
 import net.minecraft.server.v1_7_R1.EntityPlayer as EntityPlayer
 import net.minecraft.server.v1_7_R1.PacketPlayOutNamedEntitySpawn as PacketPlayOutNamedEntitySpawn
 import net.minecraft.server.v1_7_R1.PlayerInteractManager as PlayerInteractManager
@@ -32,7 +38,7 @@ def spawn(dispname, sender, x, y, z):
 
 
 @hook.command("spawnplayer")
-def on_spawnplayer_command(sender, args):
+def on_spawnplayer_command(sender, command, label, args):
     global amount, row, ground, goup
 
     # X and Z position

synchronizeranks.py

@@ -0,0 +1,112 @@
+from helpers import *
+from secrets import *
+import mysqlhack
+from com.ziclix.python.sql import zxJDBC
+
+"""
+WORK IN PROGRESS
+"""
+
+#-----------------------Config--------------------------
+
+config_file = "website-roles"
+
+ranks = {
+    "member"      : 3,
+    "builder"     : 7,
+    "trusted"     : 8,
+    "helper"      : 9,
+    "trainingmod" : 10,
+    "mod"         : 4,
+    "admin"       : 5
+}
+
+ranks = open_json_file(config_file, ranks)
+
+def save_ranks():
+    save_json_file(config_file, ranks)
+
+#-----------------------Event---------------------------
+
+@hook.event("player.PlayerJoinEvent", "normal")
+def on_player_join(event):
+    user = event.getPlayer()
+    uuid = uid(player).replace("-", "")
+
+    sql_instruction
+
+    def callback_thing(role, args):
+
+        if role in [1, 2, 6]: #Disabled/Banned/Superadmin
+            return
+        if role != None:
+            for rank in ranks:
+                if user.hasPermission("group." + rank):
+                    if role != ranks[rank]:
+                        set_role(uuid, ranks[rank])
+        elif user.hasPlayedBefore():
+            msg(user, "&cYou haven't registed yet! Make sure to do so on redstoner.com")
+
+
+def get_role(uuid):
+    results = execute_query("SELECT `role_id` FROM users WHERE `uuid` = ? LIMIT 1;", uuid)
+    return results[0][0]
+    # Returns a table with 1 row (LIMIT 1) and 1 column (SELECT `role_id`), so we're looking for the first row of the first column.
+
+
+def set_role(uuid, role_id):
+    execute_update("UPDATE users SET `role_id` = ? WHERE `uuid` = ?;", (role_id, uuid,))
+    # %d is like %s for integers (unlogically, you'd expect something like %i), though %s also works here.
+
+
+def execute_query(query, uuid):
+    conn    = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs    = conn.cursor()
+    curs.execute(query, (uuid,))
+    results = curs.fetchall()
+    curs.close()
+    conn.close()
+    return results
+
+
+def execute_update(update, uuid):
+    conn    = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs    = conn.cursor()
+    curs.execute(update, (uuid,))
+    conn.commit()
+    curs.close()
+    conn.close()
+
+def get_role(uuid):
+    sql_instruction()
+
+#--------------------------------Queries / Updates----------------------------
+
+def sql_instruction(instruction, args, fetch = True, callback_func = ignored_func, callback_args = tuple()):
+    thread = threading.Thread(target = curs_instruction, args = (instruction_executor, instruction, fetch, callback_func, callback_args))
+    thread.start()
+    
+
+def curs_instruction(func, instruction, fetch, callback_func, callback_args):
+    conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs = conn.getCursor()
+
+    if fetch:
+        returned = func(curs, instruction, fetch)
+        curs.close()
+        conn.close()
+        callback_func(returned, callback_args)
+
+    else:
+        func(curs, instruction, fetch)
+        conn.commit()
+        curs.close()
+        conn.close()
+
+
+def instruction_executor(curs, instruction, fetch):
+    curs.execute(instruction)
+    return curs.fetchall() if fetch else None
+
+def ignored_func(*args):
+    pass

tag.py

@@ -0,0 +1,78 @@
+from helpers import *
+
+add_perm = "utils.tag.add"
+del_perm = "utils.tag.del"
+check_perm = "utils.tag.check"
+
+data = open_json_file("tag", {})
+
+@hook.command("tag")
+def command(sender, command, label, args):
+    if len(args) > 0:
+        if str(args[0]) == "add":
+            if sender.hasPermission(add_perm):
+                if len(args) > 2:
+                    add(sender, args[1:])
+                else:
+                    msg(sender, "&a-&c Usage: /tag add <name> <reason>")
+            else:
+                noperm(sender)
+        elif str(args[0]) == "check":
+            if sender.hasPermission(check_perm):
+                if len(args) == 2:
+                    check(sender, args[1:])
+                else:
+                    msg(sender, "&a-&c Usage: /tag check <name>")
+            else:
+                noperm(sender)
+        elif str(args[0]) == "del":
+            if sender.hasPermission(del_perm):
+                if len(args) == 3:
+                    delete(sender, args[1:])
+                else:
+                    msg(sender, "&a-&c Usage: /tag del <id>")
+        else:
+            msg(sender, "&a-&c Unknown subcommand! (add, check, del)")
+    else:
+        msg(sender, "&a&c Usage: /tag add/check/del")
+    return True
+
+def delete(sender, args):
+    player = server.getOfflinePlayer(args[0])
+    uuid = uid(player)
+    try:
+        if data[uuid] == None:
+            pass
+    except:
+        msg(sender, "&a-&e There are no notes about this player")
+        return
+    if int(args[1]) - 1 >= len(data[uuid]):
+        msg(sender, "&a-&c Id of note is out of range")
+        return
+    del (data[uuid])[int(args[1]) - 1]
+    save_json_file("tag", data)
+    msg(sender, "&a-&e Deleted note at %s" % args[1])
+
+def add(sender, args):
+    player = server.getOfflinePlayer(args[0])
+    uuid = uid(player)
+    try:
+        if data[uuid] == None:
+            pass
+    except:
+        data[uuid] = []
+    data[uuid].append(" ".join(args[1:]))
+    msg(sender, "&a-&e Note added")
+    save_json_file("tag", data)
+
+def check(sender, args):
+    player = server.getOfflinePlayer(args[0])
+    uuid = uid(player)
+    try:
+        num = 0
+        for tag in data[uuid]:
+            num += 1
+            msg(sender, "&a-&e %s: %s" % (str(num), str(tag)))
+    except:
+        msg(sender, "&a-&e There are no notes about this player")
+

tilehelper.py

@@ -1,4 +1,7 @@
 #pylint: disable = F0401
+"""
+A plugin that automatically tiles (stacks) blocks inside a selected region in configurable directions.
+"""
 import org.bukkit.event.block.BlockPlaceEvent as BlockPlaceEvent
 import org.bukkit.event.block.BlockBreakEvent as BlockBreakEvent
 import org.bukkit.event.player.PlayerInteractEvent as PlayerInteractEvent

toolbox/__init__.py

@@ -1,4 +0,0 @@
-import glob
-tools = []
-for module_name in glob.glob("plugins/redstoner-utils.py.dir/toolbox/*.py"):
-  tools.append(__import__(module_name))

toolbox/rstoolbox.py

@@ -1,42 +0,0 @@
-from helpers import *
-
-gamemode_permission = {"self":"gamemode.self","other":"gamemode.other"}
-
-# Helping functions
-
-def setGamemode(sender, gmstring):
-  gmstring = gmstring.lower()
-  if is_player(sender):
-    if gmstring == "c" || gmstring == "creative" || gmstring == "1":
-      sender.setGameMode(GameMode.CREATIVE)
-    elif gmstring == "s" || gmstring == "survival" || gmstring == "0":
-      sender.setGameMode(GameMode.SURVIVAL)
-    elif gmstring == "a" || gmstring == "adventure" || gmstring == "2":
-      sender.setGameMode(GameMode.ADVENTURE)
-    else
-      msg(sender, "&c%s is no known gamemode (survival/creative/adventure)")
-  else
-    msg(sender, "&cYou have to be a valid player to perform this command. Try /gamemode <player> <gamemode>")
-
-# /toolbox
-@hook.command("toolbox", desc="The basic command of Toolbox")
-def toolbox_command(sender, args):  
-  msg(sender, "&6Toolbox&f is a command library written for Redstoner.com")
-
-# /gamemode
-@hook.command("gamemode", aliases=["gm"], desc="Change a player's gamemode")
-def toolbox_gamemode_command(sender, args):
-  param1 = args[0].lower() if len(args)>0 else None
-  param2 = args[1] if len(args)>1 else None
-  
-  if len(args) == 1:
-    if sender.hasPermission(gamemode_permission["self"]) || sender.hasPermission(gamemode_permission["other"]):
-      setGameMode(sender, param1)
-    else
-      noperm(sender)
-  elif len(args) == 2:
-    if sender.hasPermission(gamemode_permission["other"]):
-      if server.getPlayer(param) != None:  
-        setGameMode(server.getPlayer(param), param2)
-      else
-        msg(sender, "&cThere's no online player called "+param)

vanish.py

@@ -0,0 +1,121 @@
+from helpers import *
+from basecommands import simplecommand
+from basecommands import Validate
+
+vanished = []
+
+
+def is_authorized(player):
+    return player.hasPermission("utils.vanish")
+
+
+def is_vanished(player):
+    return uid(player) in vanished
+
+
+#this can be used to silently set the vanished state of a player
+def set_state(player, state):
+    if state == is_vanished(player):
+        return
+
+    if state:
+        enable_vanish(player)
+    else:
+        disable_vanish(player)
+
+
+def enable_vanish(target):
+    vanished.append(uid(target))
+    for player in list(server.getOnlinePlayers()):
+        if not is_authorized(player):
+            player.hidePlayer(target)
+
+
+def disable_vanish(target):
+    vanished.remove(uid(target))
+    for player in list(server.getOnlinePlayers()):
+        player.showPlayer(target)
+
+
+@simplecommand("vanish", 
+        aliases = ["v"],
+        usage = "[on/off]",
+        description = "Toggles vanish mode, hiding you and your online status \nfrom other players.",
+        senderLimit = 0,
+        amin = 0,
+        amax = 1,
+        helpNoargs = False,
+        helpSubcmd = True
+)
+def vanish_command(sender, command, label, args):
+    try:
+        current_state = is_vanished(sender)
+        new_state = not current_state
+
+        if len(args) == 1:
+            arg = args[0].lower()
+            if arg == "on":
+                new_state = True
+            elif arg == "off":
+                new_state = False
+
+        if current_state == new_state:
+            return "&cYou were %s vanished!" % ("already" if current_state else "not yet")
+
+        set_state(sender, new_state)
+        return "&a%s vanish mode!" % ("Enabled" if new_state else "Disabled")
+    except:
+        error(trace())
+
+
+@hook.event("player.PlayerJoinEvent")
+def on_player_join(event):
+    player = event.getPlayer()
+
+    if not is_authorized(player):
+        for uuid in vanished:
+            player.hidePlayer(retrieve_player(uuid))
+
+    elif is_vanished(player):
+        msg(player, "&cKeep in mind that you are still vanished! Use /vanish to disable.")
+
+
+@hook.event("player.PlayerQuitEvent")
+def on_player_quit(event):
+    player = event.getPlayer()
+
+    if not is_authorized(player):
+        for uuid in vanished:
+            player.showPlayer(retrieve_player(uuid))
+
+
+@simplecommand("vanishother",
+        usage = "{player} [on/off]",
+        description = "Toggles vanish mode for someone, hiding them and their online status from other players.",
+        amin = 1,
+        amax = 2,
+        helpNoargs = True,
+        helpSubcmd = True)
+def vanishother_command(sender, command, label, args):
+    target = server.getPlayer(args[0])
+    Validate.notNone(target, "&cThe specified player is not online")
+
+    current_state = is_vanished(target)
+    new_state     = not current_state
+
+    if len(args) == 2:
+        arg = args[1].lower()
+        if arg == "on":
+            new_state = True
+        elif arg == "off":
+            new_state = False
+
+    if current_state == new_state:
+        return "&cThat player was already vanished!" if current_state else "&cThat player was not yet vanished!"
+
+    set_state(target, new_state)
+
+    enabled_str = "enabled" if new_state else "disabled"
+    if target != sender:
+        msg(target, "&aVanish mode %s by %s" % (enabled_str, sender.getDisplayName() if is_player(sender) else "&9CONSOLE"))
+    return "&aVanish mode %s%s" % (enabled_str, " for " + target.getDisplayName() if target != sender else "")

vanishfix.py

@@ -0,0 +1,14 @@
+from helpers import *
+from java.lang import Runnable
+
+class run(Runnable):
+
+    def run(self):
+        players = server.getOnlinePlayers()
+        for player in players:
+            if player.hasPermission("essentials.vanish"):
+                player.performCommand("vanish")
+                player.performCommand("vanish")
+
+def enabled():
+    server.getScheduler().runTaskTimer(server.getPluginManager().getPlugin("RedstonerUtils"), run(), 20, 1200)

webtoken.py

@@ -99,13 +99,13 @@ def tokengen_command(sender, args):
 
 
 @hook.command("token")
-def on_token_command(sender, args):
+def on_token_command(sender, command, label, args):
     thread.start_new_thread(token_command, (sender,))
     return True
 
 
 @hook.command("gettoken")
-def on_gettoken_command(sender, args):
+def on_gettoken_command(sender, command, label, args):
     thread.start_new_thread(tokengen_command, (sender, args))
     return True