Fix most of wrapper_command

First commit of working wrapper

.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

@@ -5,59 +5,68 @@ answers = []
 
 
 def load_answers():
-  global answers
-  answers = open_json_file("abot", [])
+    global answers
+    answers = open_json_file("abot", [])
 
-  # compile answers
-  for answer in answers:
-    answer["regex"] = [reg_compile(reg.lower()) for reg in answer["regex"]]
+    # compile answers
+    for answer in answers:
+        answer["regex"] = [reg_compile(reg.lower()) for reg in answer["regex"]]
 
 
 def list_answers(sender):
-  for answer in answers:
-    msg(sender, "&e{")
-    msg(sender, "  &eregex:")
-    for regex in answer["regex"]:
-      msg(sender, "    " + regex.pattern, basecolor="a", usecolor = False)
-    msg(sender, "  &epermission:")
-    msg(sender, "    " + str(answer["hide-perm"]), basecolor="a", usecolor = False)
-    msg(sender, "  &emessage:")
-    msg(sender, "    " + "\n    ".join(answer["message"].split("\n")))
-    msg(sender, "&e}")
+    for answer in answers:
+        msg(sender, "&e{")
+        msg(sender, "  &eregex:")
+        for regex in answer["regex"]:
+            msg(sender, "    " + regex.pattern, basecolor="a", usecolor = False)
+        msg(sender, "  &epermission:")
+        msg(sender, "    " + str(answer["hide-perm"]), basecolor="a", usecolor = False)
+        msg(sender, "  &emessage:")
+        msg(sender, "    " + "\n    ".join(answer["message"].split("\n")))
+        msg(sender, "&e}")
 
 
 @hook.command("abot")
-def on_abot_command(sender, args):
-  plugin_header(sender, "AnswerBot")
-  if sender.hasPermission("utils.abot.admin"):
-    if not args:
-      msg(sender, "&2/abot list    &eList all answers and their regex")
-      msg(sender, "&2/abot reload  &eReload the config file")
-    elif args[0] == "list":
-      list_answers(sender)
-    elif args[0] == "reload":
-      load_answers()
-      msg(sender, "&2Reloaded!")
+def on_abot_command(sender, command, label, args):
+    plugin_header(sender, "AnswerBot")
+    if sender.hasPermission("utils.abot.admin"):
+        if not args:
+            msg(sender, "&2/abot list    &eList all answers and their regex")
+            msg(sender, "&2/abot reload  &eReload the config file")
+        elif args[0] == "list":
+            list_answers(sender)
+        elif args[0] == "reload":
+            load_answers()
+            msg(sender, "&2Reloaded!")
+        else:
+            msg(sender)
     else:
-      msg(sender)
-  else:
-    noperm(sender)
-  return True
+        noperm(sender)
+    return True
+
+
+def check_msg(event, message):
+    sender = event.getPlayer()
+    for answer in answers:
+        for regex in answer["regex"]:
+            if regex.search(message):
+                if not answer["hide-perm"] or not sender.hasPermission(answer["hide-perm"]):
+                    plugin_header(sender, "AnswerBot")
+                    msg(sender, answer["message"] + "\n ")
+                    event.setCancelled(True)
+                    info("(hidden) %s: '%s'" % (sender.getName(), message))
+                    break
 
 
 @hook.event("player.AsyncPlayerChatEvent", "low")
 def on_chat(event):
-  sender  = event.getPlayer()
-  message = event.getMessage().lower()
-  for answer in answers:
-    for regex in answer["regex"]:
-      if regex.search(message):
-        if not answer["hide-perm"] or not sender.hasPermission(answer["hide-perm"]):
-          plugin_header(sender, "AnswerBot")
-          msg(sender, answer["message"] + "\n ")
-          event.setCancelled(True)
-          info("(hidden) %s: '%s'" % (sender.getName(), message))
-          break
+    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,55 +1,86 @@
 #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]"
 
 def adminchat(sender, msg):
-  name = "&7{unknown}"
-  try:
-    name = sender.getDisplayName()
-  except AttributeError:
-    name = sender.getName()
-  broadcast(ac_permission, "%s &9%s&8: &b%s" % (ac_prefix, name, msg))
+    name = "&7{unknown}"
+    try:
+        name = sender.getDisplayName()
+    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
 @hook.command("act")
 def on_act_command(sender, args):
-  if sender.hasPermission(ac_permission):
-    p = sender.getName()
-    if p in ac_toggle_list:
-      ac_toggle_list.remove(p)
-      msg(sender, "%s &aAC toggle: off" % ac_prefix)
+    if sender.hasPermission(ac_permission):
+        p = sender.getName()
+        if p in ac_toggle_list:
+            ac_toggle_list.remove(p)
+            msg(sender, "%s &aAC toggle: off" % ac_prefix)
+        else:
+            ac_toggle_list.append(p)
+            msg(sender, "%s &aAC toggle: on" % ac_prefix)
     else:
-      ac_toggle_list.append(p)
-      msg(sender, "%s &aAC toggle: on" % ac_prefix)
-  else:
-    noperm(sender)
-  return True
+        noperm(sender)
+    return True
 
 
 @hook.command("ac")
 def on_ac_command(sender, args):
-  if sender.hasPermission(ac_permission):
-    if not checkargs(sender, args, 1, -1):
-      return True
-    adminchat(sender, " ".join(args))
-  else:
-    noperm(sender)
-  return True
+    if sender.hasPermission(ac_permission):
+        if not checkargs(sender, args, 1, -1):
+            return True
+        adminchat(sender, " ".join(args))
+    else:
+        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:
-      adminchat(sender, msg)
-      event.setCancelled(True)
+    sender = event.getPlayer()
+    msg = event.getMessage()
+    if sender.hasPermission(ac_permission) and not event.isCancelled():
+        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,285 @@
+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 Runnable
+
+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
+}
+
+faces = {
+    BlockFace.DOWN  : 0,
+    BlockFace.UP    : 1,
+    BlockFace.NORTH : 2,
+    BlockFace.SOUTH : 3,
+    BlockFace.WEST  : 4,
+    BlockFace.EAST  : 5
+}
+
+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 = not default
+            elif arg2 in ("off", "disable"):
+                new = default
+            else:
+                return " &cArgument '%s' was not recognized. \n Use &o/toggle %s info &cfor more information" % (arg2, setting)
+        if enabled == new:
+            return " &cAlready %s: &a%s" % ("enabled" if enabled else "disabled", details[1])
+        if new == 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]
+            return " &aDisabled " + details[1]
+
+        if arg2 == "details":
+            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]
+                    saveSettings()
+                    if len(items) == 0:
+                        del items
+                        return " &aDisabled " + details[1]
+                    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 details &cfor more detailsrmation." % (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):
+    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 event.getBlockAgainst().getType() == Material.REDSTONE_BLOCK
+        and isEnabled("torch", uuid)
+        and player.hasPermission("utils.toggle.torch")
+        ):
+        torches_to_break.append(block)
+    """
+
+
+    if (material in (Material.PISTON_BASE, Material.PISTON_STICKY_BASE)
+        and isEnabled("piston", uuid)
+        and player.hasPermission("utils.toggle.piston")
+        ):
+        block.setData(faces[block.getFace(event.getBlockAgainst())])
+
+
+@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("Interrupted torch breaking thread")
+
+
+class torch_breaker(Runnable):
+
+    def run():
+
+        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:
+                        torches_to_break.append(block)
+        except:
+            error(trace())
+"""
+

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,138 @@
+# Chat Aliasing plugin by Curs3d #
+##################################
+# Allows users to alias words,
+# so that when they send a
+# message in chat, it gets
+# replaced by their specified
+# word. The JSON file for this
+# plugin is generated if not
+# present. Set values to -1
+# for "unlimited" setting.
+
+from helpers import *
+import re
+from traceback import format_exc as trace
+
+data = None
+
+max_entries = 10
+max_alias_length = 35
+# Minecraft message limit is 100 so I decided to give a little tolerance (and I added a bit more)
+max_overall_length = 100 + max_alias_length
+
+alias_perm = "utils.alias.allowed"
+exceed_length = "utils.alias.exceedlimit"
+exceed_entries = "utils.alias.exceedlimit"
+exceed_overall_length = "utils.alias.exceedlimit"
+
+
+def safe_open_json():
+    global data
+    if data is not None:
+        return data
+    data = open_json_file("aliases")
+    if data is None:
+        data = {}
+    save_json_file("aliases", data)
+    return data
+
+def multiple_replace(aliases, text):
+    regex = re.compile("|".join(map(re.escape, aliases.keys())))
+    return regex.sub(lambda mo: aliases[mo.group(0)], text)
+
+
+@hook.command("alias",
+              usage="/<command> [to_alias] [alias...]",
+              desc="Aliases words in chat")
+def on_alias_command(sender, cmd, label, args):
+
+    if not is_player(sender):
+        msg(sender, "Sorry, non-players cannot alias words")
+        return True
+    if not sender.hasPermission(alias_perm):
+        plugin_header(recipient=sender, name="Chat Alias")
+        noperm(sender)
+        return True
+    if len(args) == 0:
+        plugin_header(recipient=sender, name="Chat Alias")
+        msg(sender, "&7This is a plugin that allows you to get words" +
+            "replaced by other ones automatically!")
+        msg(sender, "&7\nCommands:")
+        msg(sender, "&e/alias <word> &7removes <word> from your aliases. " +
+            "Use &e/alias * &7to remove all aliases.")
+        msg(sender, "&e/alias <word> <replacement> &7will change &e<word> " +
+            "&7to &e<replacement> &7in chat")
+        msg(sender, "&7\nYour Aliases:")
+        data = safe_open_json()
+        try:
+            for alias, value in data[str(sender.getUniqueId())].items():
+                msg(sender, "&7%s &7==> %s" % (alias, value))
+        except KeyError:
+            pass
+        return True
+    elif len(args) == 1:
+        data = safe_open_json()
+        if args[0] == "*":
+            try:
+                del data[str(sender.getUniqueId())]
+            except KeyError:
+                plugin_header(recipient=sender, name="Chat Alias")
+                msg(sender, "&7No alias data to remove!")
+                return True
+            save_json_file("aliases", data)
+            plugin_header(recipient=sender, name="Chat Alias")
+            msg(sender, "&cALL &7alias data successfuly removed!")
+            return True
+        try:
+            if data[str(sender.getUniqueId())].pop(args[0], None) is None:
+                plugin_header(recipient=sender, name="Chat Alias")
+                msg(sender, "&7Could not remove: alias not present!")
+                return True
+        except KeyError:
+            plugin_header(recipient=sender, name="Chat Alias")
+            msg(sender, "&7Could not remove: you do not have any aliases!")
+            return True
+        save_json_file("aliases", data)
+        plugin_header(recipient=sender, name="Chat Alias")
+        msg(sender, "&7Alias for %s &7successfuly removed" % args[0])
+        return True
+    elif len(args) >= 2:
+        data = safe_open_json()
+        alias = " ".join(args[1:])
+        try:
+            if (len(alias) > max_alias_length) and (max_alias_length >= 0) and (not sender.hasPermission(exceed_length)):
+                plugin_header(recipient=sender, name="Chat Alias")
+                msg(sender, "&7Please do not alias long words/sentences.")
+                return True
+            if (len(data[str(sender.getUniqueId())]) >= max_entries) and (max_entries >= 0) and (not sender.hasPermission(exceed_entries)):
+                plugin_header(recipient=sender, name="Chat Alias")
+                msg(sender, "&7You have reached your alias limit!")
+                return True
+        except KeyError:
+            data[str(sender.getUniqueId())] = {}
+        data[str(sender.getUniqueId())][args[0]] = alias
+        save_json_file("aliases", data)
+        plugin_header(recipient=sender, name="Chat Alias")
+        msg(sender, "&7Chat Alias %s &7==> %s &7successfully created!" % (args[0], alias))
+        return True
+    else:
+        return False
+
+
+@hook.event("player.AsyncPlayerChatEvent", "high")
+def on_player_chat(event):
+    playerid = str(event.getPlayer().getUniqueId())
+    data = safe_open_json()
+    if event.isCancelled():
+        return
+    if not playerid in data:
+        return
+
+    event.setMessage(multiple_replace(data[playerid], event.getMessage()))
+
+    if (event.getPlayer().hasPermission("essentials.chat.color")):
+        event.setMessage(colorify(event.getMessage()))
+    if (max_overall_length >= 0) and (len(event.getMessage()) > max_overall_length) and (not event.getPlayer().hasPermission(exceed_overall_length)):
+        event.setCancelled(True)
+        plugin_header(recipient=event.getPlayer(), name="Chat Alias")
+        msg(event.getPlayer(), "&7The message generated was too long and was not sent. :/")

chatgroups.py

@@ -1,92 +1,135 @@
 #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):
-  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)
-      group = groups[sender_id]
-      del(groups[sender_id])
-      save_groups()
+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)
+            group = groups[sender_id]
+            del(groups[sender_id])
+            save_groups()
+        else:
+            msg(sender, "&aYou can't leave no group, derp!")
+    elif len(args) == 1 and args[0] == "info":
+        if sender_id in groups.keys():
+            group = groups[sender_id]
+            msg(sender, "&aCurrent chatgroup: %s" % group)
+            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:
+            msg(sender, "&aYou're in no chatgroup.")
+    elif len(args) == 2 and args[0] == "join":
+        groups[sender_id] = args[1]
+        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." % 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, "&aYou can't leave no group, derp!")
-  elif len(args) == 1 and args[0] == "info":
-    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())
-      msg(sender, "&aUsers in this group:")
-      msg(sender,  "&a%s" % ", ".join(users))
-    else:
-      msg(sender, "&aYou're in no chatgroup.")
-  elif len(args) == 2 and args[0] == "join":
-    groups[sender_id] = args[1]
-    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)
-  else:
-    msg(sender, "&e/chatgroup join <name>")
-    msg(sender, "&e/chatgroup leave")
-    msg(sender, "&e/chatgroup info")
+        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):
-  p = uid(sender)
-  if p in cg_toggle_list:
-    cg_toggle_list.remove(p)
-    msg(sender, "&8[&bCG&8] &e&oCG toggle: off")
-  else:
-    cg_toggle_list.append(p)
-    msg(sender, "&8[&bCG&8] &e&oCG toggle: on")
-  return True
+def on_cgt_command(sender, command, label, args):
+    p = uid(sender)
+    if p in cg_toggle_list:
+        cg_toggle_list.remove(p)
+        msg(sender, "&8[&bCG&8] &e&oCG toggle: off")
+    else:
+        cg_toggle_list.append(p)
+        msg(sender, "&8[&bCG&8] &e&oCG toggle: on")
+    return True
 
 
 def groupchat(sender, message, ann = False):
-  group = groups.get(uid(sender))
-  if group == None:
-    msg(sender, "&cYou are not in a group!")
-    return
-  name = sender.getDisplayName()
-  if ann:
-    mesg = "&8[&bCG&8] &e&o%s&e&o %s" % (name, message)
-  else:
-    mesg = "&8[&bCG&8] &f%s&f: &6%s" % (name, message)
-  info("[ChatGroups] %s (%s): %s" % (sender.getDisplayName(), group, message))
-  for receiver in server.getOnlinePlayers():
-    groups.get(uid(receiver)) == group and msg(receiver, mesg)
+    group = groups.get(uid(sender))
+    if group == None:
+        msg(sender, "&cYou are not in a group!")
+        return
+    name = sender.getDisplayName()
+    if ann:
+        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():
+        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)
+    save_json_file("chatgroups", groups)
 
 
 @hook.event("player.AsyncPlayerChatEvent", "normal")
 def on_chat(event):
-  sender = event.getPlayer()
-  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:])
-      event.setCancelled(True)
-    elif sender_id in cg_toggle_list:
-      groupchat(sender, msge)
-      event.setCancelled(True)
+    sender = event.getPlayer()
+    msge = event.getMessage()
+    if not event.isCancelled():
+        sender_id = uid(sender)
+        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,95 @@
+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` 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]) if results else (None, None)
+
+
+# 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])
+        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,47 +4,47 @@ no_cyclers = open_json_file("cycle", [])
 
 
 @hook.command("cycle")
-def on_cycler_command(sender, args):
-  plugin_header(sender, "Cycle")
-  if not is_player(sender):
-    msg(sender, "&conly players can do this")
-    return True
-  if not len(args) == 1:
-    msg(sender, "&cUsage: /cycle <on|off>")
-    return True
+def on_cycler_command(sender, command, label, args):
+    plugin_header(sender, "Cycle")
+    if not is_player(sender):
+        msg(sender, "&conly players can do this")
+        return True
+    if not len(args) == 1:
+        msg(sender, "&cUsage: /cycle <on|off>")
+        return True
 
-  cmd = args[0].lower()
-  pid = uid(sender)
-  nop = pid in no_cyclers
-  if cmd == "on":
-    if nop:
-      no_cyclers.remove(pid)
-      save_cyclers()
-      msg(sender, "&aTurned &2on&a inventory cycling!")
+    cmd = args[0].lower()
+    pid = uid(sender)
+    nop = pid in no_cyclers
+    if cmd == "on":
+        if nop:
+            no_cyclers.remove(pid)
+            save_cyclers()
+            msg(sender, "&aTurned &2on&a inventory cycling!")
+        else:
+            msg(sender, "&aAlready turned on.")
+    elif cmd == "off":
+        if not nop:
+            no_cyclers.append(pid)
+            save_cyclers()
+            msg(sender, "&aTurned &coff&a inventory cycling!")
+        else:
+            msg(sender, "&aAlready turned off.")
     else:
-      msg(sender, "&aAlready turned on.")
-  elif cmd == "off":
-    if not nop:
-      no_cyclers.append(pid)
-      save_cyclers()
-      msg(sender, "&aTurned &coff&a inventory cycling!")
-    else:
-      msg(sender, "&aAlready turned off.")
-  else:
-    msg(sender, "&cUsage: /cycle <on|off>")
-  return True
+        msg(sender, "&cUsage: /cycle <on|off>")
+    return True
 
 
 @hook.event("player.PlayerItemHeldEvent", "normal")
 def on_slot_change(event):
-  player    = event.getPlayer()
-  if is_creative(player) and uid(player) not in no_cyclers and not player.isSneaking():
-    prev_slot = event.getPreviousSlot()
-    new_slot  = event.getNewSlot()
-    if (prev_slot == 0 and new_slot == 8): # left -> right
-      do_cycle(player, True)
-    elif (prev_slot == 8 and new_slot == 0): # right -> left
-      do_cycle(player, False)
+    player    = event.getPlayer()
+    if is_creative(player) and uid(player) not in no_cyclers and not player.isSneaking():
+        prev_slot = event.getPreviousSlot()
+        new_slot  = event.getNewSlot()
+        if (prev_slot == 0 and new_slot == 8): # left -> right
+            do_cycle(player, True)
+        elif (prev_slot == 8 and new_slot == 0): # right -> left
+            do_cycle(player, False)
 
 # ITEM SLOTS #
 #_____________________________
@@ -55,16 +55,16 @@ def on_slot_change(event):
 # | 0| 1| 2| 3| 4| 5| 6| 7| 8|
 
 def do_cycle(player, down):
-  inv   = player.getInventory()
-  items = inv.getContents()
-  shift = -9 if down else 9
-  shift = shift % len(items)
-  for _ in range(4):
-    items      = items[shift:] + items[:shift] # shift "around"
-    uniq_items = sorted(set(list(items)[:9]))  # get unique inventory
-    if uniq_items != [None]: # row not empty
-      break
-  inv.setContents(items)
+    inv   = player.getInventory()
+    items = inv.getContents()
+    shift = -9 if down else 9
+    shift = shift % len(items)
+    for _ in range(4):
+        items      = items[shift:] + items[:shift] # shift "around"
+        uniq_items = sorted(set(list(items)[:9]))  # get unique inventory
+        if uniq_items != [None]: # row not empty
+            break
+    inv.setContents(items)
 
 def save_cyclers():
-  save_json_file("cycle", no_cyclers)
+    save_json_file("cycle", no_cyclers)

damnspam.py

@@ -5,119 +5,147 @@ import org.bukkit.event.block.BlockBreakEvent as BlockBreakEvent
 
 inputs          = open_json_file("damnspam", {}) # format "x;y;z;World"
 accepted_inputs = ["WOOD_BUTTON", "STONE_BUTTON", "LEVER"]
+changing_input  = False
+removing_input  = False
 
 
 def save_inputs():
-  save_json_file("damnspam", inputs)
+    save_json_file("damnspam", inputs)
 
 
 def location_str(block):
-  return ";".join([block.getWorld().getName(), str(block.getX()), str(block.getY()), str(block.getZ())])
+    return ";".join([block.getWorld().getName(), str(block.getX()), str(block.getY()), str(block.getZ())])
 
 
 def add_input(creator, block, timeout_off, timeout_on):
-  inputs[location_str(block)] = {
-    "creator"     : uid(creator),
-    "timeout_off" : timeout_off,
-    "timeout_on"  : timeout_on,
-    "last_time"   : 0
-  }
+    inputs[location_str(block)] = {
+        "creator"     : uid(creator),
+        "timeout_off" : timeout_off,
+        "timeout_on"  : timeout_on,
+        "last_time"   : 0
+    }
 
 
 @hook.command("damnspam")
-def on_dammnspam_command(sender, args):
-  plugin_header(sender, "DamnSpam")
-  if len(args) in [1,2]:
+def on_dammnspam_command(sender, command, label, args):
+    global changing_input
 
-    if not is_creative(sender):
-      msg(sender, "&cYou can only do this in Creative mode.")
-      return True
+    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.")
+            return True
 
     # /damnspam <secs>
     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.")
-          return True
-      except ValueError:
-        msg(sender, "&cThe timeout must be a number")
-        return True
+        timeout_on = args[0]
+        try:
+            timeout_on  = round(float(timeout_on), 2)
+            timeout_off = timeout_on
+            if 60 >= timeout_on <= -2 or timeout_on == 0:
+                timeout_on = False
+            if timeout_on == False:
+                msg(sender, "&cThe timeout must be within 0-60 or -1.")
+                return True
+        except ValueError:
+            msg(sender, "&cThe timeout must be a number")
+            return True
 
     # /damnspam <off> <on>
     elif len(args) == 2:
-      timeout_on  = args[0]
-      timeout_off = args[1]
-      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.")
-          return True
-      except ValueError:
-        msg(sender, "&cThe timeout must be a number")
-        return True
+        timeout_on  = args[0]
+        timeout_off = args[1]
+        try:
+            timeout_on  = round(float(timeout_on), 2)
+            timeout_off = round(float(timeout_off), 2)
+            if 60 >= timeout_on <= -2 or timeout_on == 0:
+                timeout_on = False
+            if 60 >= timeout_off <= -2 or timeout_off == 0:
+                timeout_off = False
+            if timeout_on == False or timeout_off == False:
+                msg(sender, "&cThe timeout must be within 0-60 or -1.")
+                return True
+        except ValueError:
+            msg(sender, "&cThe timeout must be a number")
+            return True
 
     # get the block we're looking at
     target = sender.getTargetBlock(None, 10)
     ttype  = str(target.getType())
     if ttype not in accepted_inputs:
-      msg(sender, "&cPlease look at a button or lever while executing this command!")
-      return True
+        msg(sender, "&cPlease look at a button or lever while executing this command!")
+        return True
 
+    if location_str(target) in inputs:
+        changing_input = True # this input already has a timeout
+    # test if player is allowed to build here
     test_event = BlockBreakEvent(target, sender)
     server.getPluginManager().callEvent(test_event)
+    changing_input = False
     if test_event.isCancelled():
-      msg(sender, "&cYou are not allowed to modify this button")
-      return True
+        msg(sender, "&cYou are not allowed to modify this %s" % str(target.getType()).lower())
+        return True
 
     # add block to inputs
     add_input(sender, target, timeout_off, timeout_on)
     save_inputs()
-    msg(sender, "&aSuccessfully set a timeout for this %s." % ttype.lower())
+    msg(sender, "&aSuccessfully set a timeout for this %s." % ttype.lower().replace("_", " "))
     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():
-    pos_str = location_str(block)
-    if inputs.get(pos_str):
-      plugin_header(sender, "DamnSpam")
-      if sender.isSneaking():
-        inputs.pop(pos_str) # remove
-        save_inputs()
-        msg(sender, "&eSuccessfully removed the input!")
-        return True
-      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
+    global removing_input
+
+    if removing_input:
+        return
+    sender = event.getPlayer()
+    block  = event.getBlock()
+    btype  = str(block.getType()).lower()
+    if str(block.getType()) in accepted_inputs and not event.isCancelled():
+        pos_str = location_str(block)
+        if inputs.get(pos_str):
+            if sender.isSneaking():
+                # test if player is allowed to build here
+                removing_input = True
+                test_event     = BlockBreakEvent(block, sender)
+                server.getPluginManager().callEvent(test_event)
+                removing_input = False
+                if test_event.isCancelled():
+                    event.setCancelled(True)
+                    msg(sender, "&cYou are not allowed to remove this %s" % btype)
+                    return True
+                inputs.pop(pos_str) # remove
+                save_inputs()
+                msg(sender, "&eSuccessfully removed this %s!" % btype)
+                return True
+            elif not changing_input:
+                event.setCancelled(True)
+                msg(sender, "&cYou cannot destroy this %s!" % btype)
+                msg(sender, "&c&nSneak&c and break if you want to remove it.")
+                return True
 
 
 @hook.event("player.PlayerInteractEvent", "normal")
 def on_interact(event):
-  if (str(event.getAction()) == "RIGHT_CLICK_BLOCK") and not event.isCancelled():
-    sender  = event.getPlayer()
-    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))
-      else:
-        inputs[pos_str]["last_time"] = round(now(), 2)
+    if (str(event.getAction()) == "RIGHT_CLICK_BLOCK") and not event.isCancelled():
+        sender  = event.getPlayer()
+        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 checktime == -1:
+                event.setCancelled(True)
+                msg(sender, "&cThis %s is locked permanently by /damnspam." % (btype))
+            elif data["last_time"] + checktime > now():
+                event.setCancelled(True)
+                msg(sender, "&cThis %s has a damnspam timeout of %ss." % (btype, checktime))
+            else:
+                inputs[pos_str]["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,128 +17,131 @@ whitelists = {} # {ff_owner_id: [white, listed, ids]} (Adding file usage later,
 
 
 @hook.command("forcefield")
-def on_forcefield_command(sender, args):
-  if not is_player(sender) or not sender.hasPermission(ff_perm):
-    noperm(sender)
-    return True
+def on_forcefield_command(sender, command, label, args):
+    if not is_player(sender) or not sender.hasPermission(ff_perm):
+        noperm(sender)
+        return True
 
-  if not args or args[0].upper() in ["ON", "OFF"]: # Toggle
-    forcefield_toggle(sender, args[:1])
-    return True
+    if not args or args[0].upper() in ["ON", "OFF"]: # Toggle
+        forcefield_toggle(sender, args[:1])
+        return True
 
-  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)
-      return True
+    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":
+            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.
-    if args[1] == "CLEAR":
-      whitelist_clear(sender)
-    elif args[1] in ["ADD", "+"]:
-      change_whitelist(sender, True, args[2:])
-    elif args[1] in ["REMOVE", "DELETE", "REM", "DEL", "-"]:
-      change_whitelist(sender, False, args[2:])
+        args[1] = args[1].upper() # If it gets too this point, there is a second argument.
+        if args[1] == "CLEAR":
+            whitelist_clear(sender)
+        elif args[1] in ["ADD", "+"]:
+            change_whitelist(sender, True, args[2:])
+        elif args[1] in ["REMOVE", "DELETE", "REM", "DEL", "-"]:
+            change_whitelist(sender, False, args[2:])
+        else:
+            forcefield_header(sender, "&cInvalid syntax. Use &e/ff ? &cfor info.")
+
+    elif args[0] in ["HELP", "?"]: # /forcefield help
+        forcefield_help(sender)
     else:
-      forcefield_header(sender, "&cInvalid syntax. Use &e/ff ? &cfor info.")
-
-  elif args[0] in ["HELP", "?"]: # /forcefield help
-    forcefield_help(sender)
-  else:
-    forcefield_header(sender, "&cInvalid syntax. Use &e/ff ? &cfor info.")
-  return True
+        forcefield_header(sender, "&cInvalid syntax. Use &e/ff ? &cfor info.")
+    return True
 
 
 def change_whitelist(sender, add, names): #Add names if add == True else Remove names.
-  if names:
-    sender_id = uid(sender)
-    if sender_id not in whitelists:
-      whitelists[sender_id] = []
+    if names:
+        sender_id = uid(sender)
+        if sender_id not in whitelists:
+            whitelists[sender_id] = []
 
-    for name in names:
-      player = server.getPlayer(name)
-      if player:
-        player_id = uid(player)
-        pname     = player.getName()
-        sname     = stripcolors(sender.getDisplayName())
+        for name in names:
+            player = server.getPlayer(name)
+            if player:
+                player_id = uid(player)
+                pname     = player.getName()
+                sname     = stripcolors(sender.getDisplayName())
 
-        # add player to whitelist if not already added
-        if add and player_id not in whitelists[sender_id]:
-          if sender != player:
-            whitelists[sender_id].append(player_id)
-            forcefield_header(sender, "&bAdded &f%s &bto your forcefield whitelist." % pname)
-            forcefield_header(player, "&f%s &badded you to his forcefield whitelist." % sname)
-          else:
-            forcefield_header(sender, "&cYou can't whitelist yourself.")
+                # add player to whitelist if not already added
+                if add and player_id not in whitelists[sender_id]:
+                    if sender != player:
+                        whitelists[sender_id].append(player_id)
+                        forcefield_header(sender, "&bAdded &f%s &bto your forcefield whitelist." % pname)
+                        forcefield_header(player, "&f%s &badded you to his forcefield whitelist." % sname)
+                    else:
+                        forcefield_header(sender, "&cYou can't whitelist yourself.")
 
-        # remove player from whitelist if whitelisted
-        elif not add and player_id in whitelists[sender_id]:
-          whitelists[sender_id].remove(player_id)
-          forcefield_header(sender, "&cRemoved &f%s &cfrom your forcefield whitelist." % pname)
-          forcefield_header(player, "&f%s &cremoved you from his forcefield whitelist." % sname)
+                # remove player from whitelist if whitelisted
+                elif not add and player_id in whitelists[sender_id]:
+                    whitelists[sender_id].remove(player_id)
+                    forcefield_header(sender, "&cRemoved &f%s &cfrom your forcefield whitelist." % pname)
+                    forcefield_header(player, "&f%s &cremoved you from his forcefield whitelist." % sname)
 
-        # player was already / not added to whitelist
-        else:
-          var = "already" if add == True else "not"
-          forcefield_header(sender, "&f%s &cwas %s in your forcefield whitelist!" % (pname, var))
+                # player was already / not added to whitelist
+                else:
+                    var = "already" if add == True else "not"
+                    forcefield_header(sender, "&f%s &cwas %s in your forcefield whitelist!" % (pname, var))
 
-      else:
-        forcefield_header(sender, "&cplayer &f%s &cwas not found (must be online)." % name)
-  else:
-    forcefield_header(sender, "&cGive space-separated playernames.")
+            else:
+                forcefield_header(sender, "&cplayer &f%s &cwas not found (must be online)." % name)
+    else:
+        forcefield_header(sender, "&cGive space-separated playernames.")
 
 
 def whitelist_list(player):
-  player_id = uid(player)
-  count     = 0
-  forcefield_header(player, "&bForcefield whitelist:")
-  for user_id in whitelists.get(player_id, []):
-    count += 1
-    pname = retrieve_player(user_id).getName()
-    msg(player, "&b %s. &f%s" % (count, pname))
-  if count == 0:
-    msg(player, "&c Your whitelist has no entries.")
+    try:
+        player_id = uid(player)
+        count     = 0
+        forcefield_header(player, "&bForcefield whitelist:")
+        for user_id in whitelists.get(player_id, []):
+            count += 1
+            pname = retrieve_player(user_id).getName()
+            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):
-  player_id = uid(player)
-  if whitelists.get(player_id):
-    whitelists.pop(player_id)
-    forcefield_header(player, "&bForcefield whitelist cleared.")
-  else:
-    forcefield_header(player, "&cYou had no players whitelisted.")
+    player_id = uid(player)
+    if whitelists.get(player_id):
+        whitelists.pop(player_id)
+        forcefield_header(player, "&bForcefield whitelist cleared.")
+    else:
+        forcefield_header(player, "&cYou had no players whitelisted.")
 
 
 def forcefield_help(player):
-  msg(player, " ")
-  forcefield_header(player, "&b&l/Forcefield help:     Your forcefield is %s" % ("&2&lON" if uid(player) in ff_users else "&c&lOFF"))
-  msg(player, "&b You can use the forcefield to keep players on distance.")
-  msg(player, "&b Commands:")
-  msg(player, "&b 1. &6/ff &ohelp &b                         aliases: &6?")
-  msg(player, "&b 2. &6/ff &o(on off)")
-  msg(player, "&b 3. &6/ff &owhitelist (list) &b             aliases: &6wlist, wl")
-  msg(player, "&b 4. &6/ff wl &oclear")
-  msg(player, "&b 5. &6/ff wl &oadd <players> &b         aliases: &6+")
-  msg(player, "&b 6. &6/ff wl &oremove <players> &b     aliases: &6delete, rem, del, -")
-  msg(player, " ")
+    msg(player, " ")
+    forcefield_header(player, "&b&l/Forcefield help:     Your forcefield is %s" % ("&2&lON" if uid(player) in ff_users else "&c&lOFF"))
+    msg(player, "&b You can use the forcefield to keep players on distance.")
+    msg(player, "&b Commands:")
+    msg(player, "&b 1. &6/ff &ohelp &b                         aliases: &6?")
+    msg(player, "&b 2. &6/ff &o(on off)")
+    msg(player, "&b 3. &6/ff &owhitelist (list) &b             aliases: &6wlist, wl")
+    msg(player, "&b 4. &6/ff wl &oclear")
+    msg(player, "&b 5. &6/ff wl &oadd <players> &b         aliases: &6+")
+    msg(player, "&b 6. &6/ff wl &oremove <players> &b     aliases: &6delete, rem, del, -")
+    msg(player, " ")
 
 
 def forcefield_toggle(player, arg): # arg is a list with max 1 string
-  player_id = uid(player)
-  enabled   = player_id in ff_users
-  argoff    = arg[0].upper() == "OFF" if arg else False
-  if enabled and (not arg or argoff): # 3 possibilities for arg: [], ["OFF"], ["ON"]. This is the most efficient way. (Case insensitive)
-    ff_users.remove(player_id)
-    forcefield_header(player, "&bForcefield toggle: &c&lOFF")
-  elif not enabled and not argoff:
-    ff_users.append(player_id)
-    forcefield_header(player, "&bForcefield toggle: &2&lON")
-  else:
-    forcefield_header(player, "&cYour forcefield is already %s!" % arg[0].lower())
+    player_id = uid(player)
+    enabled   = player_id in ff_users
+    argoff    = arg[0].upper() == "OFF" if arg else False
+    if enabled and (not arg or argoff): # 3 possibilities for arg: [], ["OFF"], ["ON"]. This is the most efficient way. (Case insensitive)
+        ff_users.remove(player_id)
+        forcefield_header(player, "&bForcefield toggle: &c&lOFF")
+    elif not enabled and not argoff:
+        ff_users.append(player_id)
+        forcefield_header(player, "&bForcefield toggle: &2&lON")
+    else:
+        forcefield_header(player, "&cYour forcefield is already %s!" % arg[0].lower())
 
 
 def forcefield_header(player, message):
-  msg(player, "%s %s" % (ff_prefix, message))
+    msg(player, "%s %s" % (ff_prefix, message))
 
 
 #--------------------------------------------------------------------------------------------------------#
@@ -145,41 +149,41 @@ def forcefield_header(player, message):
 
 @hook.event("player.PlayerMoveEvent")
 def on_move(event):
-  if ff_users:
-    player = event.getPlayer()
-    if is_creative(player):
-      player_id = uid(player)
+    if ff_users:
+        player = event.getPlayer()
+        if is_creative(player):
+            player_id = uid(player)
 
-      # moving player has forcefield, nearby player should be moved away
-      if player_id in ff_users:
-        for entity in player.getNearbyEntities(fd, fd, fd):
-          whitelisted = (uid(entity) in whitelists.get(player_id, []))
-          if is_player(entity) and not entity.hasPermission(pass_perm) and not whitelisted:
-            move_away(player, entity)
+            # moving player has forcefield, nearby player should be moved away
+            if player_id in ff_users:
+                for entity in player.getNearbyEntities(fd, fd, fd):
+                    whitelisted = (uid(entity) in whitelists.get(player_id, []))
+                    if is_player(entity) and not entity.hasPermission(pass_perm) and not whitelisted:
+                        move_away(player, entity)
 
-      # nearby player has forcefield, moving player should be moved away
-      if not player.hasPermission(pass_perm):
-        for entity in player.getNearbyEntities(fd, fd, fd):
-          entity_id   = uid(entity)
-          ff_enabled  = (entity_id in ff_users)
-          whitelisted = (player_id in whitelists.get(entity_id, []))
-          if is_player(entity) and is_creative(entity) and ff_enabled and not whitelisted:
-            move_away(entity, player)
+            # nearby player has forcefield, moving player should be moved away
+            if not player.hasPermission(pass_perm):
+                for entity in player.getNearbyEntities(fd, fd, fd):
+                    entity_id   = uid(entity)
+                    ff_enabled  = (entity_id in ff_users)
+                    whitelisted = (player_id in whitelists.get(entity_id, []))
+                    if is_player(entity) and is_creative(entity) and ff_enabled and not whitelisted:
+                        move_away(entity, player)
 
 
 def move_away(player, entity):
-  # Pushes entity away from player
+    # Pushes entity away from player
 
-  player_loc = player.getLocation()
-  entity_loc = entity.getLocation()
+    player_loc = player.getLocation()
+    entity_loc = entity.getLocation()
 
-  dx = entity_loc.getX() - player_loc.getX()
-  vx = sin(Xv * dx)
-  dy = entity_loc.getY() - player_loc.getY()
-  vy = sin(Xv * dy)
-  dz = entity_loc.getZ() - player_loc.getZ()
-  vz = sin(Xv * dz)
-  entity.setVelocity(Vector(vx , vy, vz))
+    dx = entity_loc.getX() - player_loc.getX()
+    vx = sin(Xv * dx)
+    dy = entity_loc.getY() - player_loc.getY()
+    vy = sin(Xv * dy)
+    dz = entity_loc.getZ() - player_loc.getZ()
+    vz = sin(Xv * dz)
+    entity.setVelocity(Vector(vx , vy, vz))
 
 
 #--------------------------------------------------------------------------------------------------------#
@@ -187,7 +191,7 @@ def move_away(player, entity):
 
 @hook.event("player.PlayerQuitEvent")
 def on_quit(event):
-  player    = event.getPlayer()
-  player_id = uid(player)
-  if player_id in ff_users:
-    ff_users.remove(player_id)
+    player    = event.getPlayer()
+    player_id = uid(player)
+    if player_id in ff_users:
+        ff_users.remove(player_id)

friends.py

@@ -1,3 +1,4 @@
+import thread
 from helpers import *
 
 friends           = open_json_file("friends", {}) # {Player_UUID:[List_of_friend_uuids]}
@@ -7,152 +8,153 @@ friend_join_sound = "random.orb"
 
 @hook.event("player.PlayerJoinEvent", "high") # creates sound and sends a bold message on friend join
 def fjm(event): # friend join message
-  player    = event.getPlayer()
-  player_id = uid(player)
+    player    = event.getPlayer()
+    player_id = uid(player)
 
-  for onlineplayer in list(server.getOnlinePlayers()):
-    if player_id in friends.get(uid(onlineplayer), []):
-      msg(onlineplayer, "&a&l%s &ajoined!" % player.getName())
-      onlineplayer.playSound(onlineplayer.getLocation(), friend_join_sound, 1, 0)
+    for onlineplayer in list(server.getOnlinePlayers()):
+        if player_id in friends.get(uid(onlineplayer), []):
+            msg(onlineplayer, "&a&l%s &ajoined!" % player.getName())
+            onlineplayer.playSound(onlineplayer.getLocation(), friend_join_sound, 1, 0)
 
 
 def save_friends(): # saves to friends file
-  save_json_file("friends", friends)
+    save_json_file("friends", friends)
 
 
 def friendmessage(player, message): # sends a message with a prefix
-  msg(player, "&7[&aFriends&7] " + message)
+    msg(player, "&7[&aFriends&7] " + message)
 
 
 def ls(sender):
-  sender_friends = friends.get(uid(sender), False)
-  if sender_friends:
-    friends_string = ""
-    for uuid in sender_friends:
-      friends_string += (retrieve_player(uuid).getName() + ", ")
-    friendmessage(sender, "&aYour friends list: " + friends_string[:len(friends_string)-2])
-  else:
-    friendmessage(sender, "&cYour friends list is empty")
+    try:
+        sender_friends = friends.get(uid(sender), False)
+        if sender_friends:
+            friends_string = ""
+            for uuid in sender_friends:
+                friends_string += (retrieve_player(uuid).getName() + ", ")
+            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)
+    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()
-  else:
-    friendmessage(sender, "&cYour friends list is already empty")
+    if friends.get(sender_id, False):
+        friends.pop(sender_id)
+        friendmessage(sender, "&aFriends list cleared")
+        save_friends()
+    else:
+        friendmessage(sender, "&cYour friends list is already empty")
 
 
 def add(sender, names):
-  sender_id     = uid(sender)
-  added         = []
-  notfound      = []
-  friendalready = []
+    sender_id     = uid(sender)
+    added         = []
+    notfound      = []
+    friendalready = []
 
-  if not sender_id in friends:
-    friends[sender_id] = []
+    if not sender_id in friends:
+        friends[sender_id] = []
 
-  for name in names:
-    player = server.getPlayer(name)
-    if player:
-      player_id = uid(player)
-      not_yourself = player != sender
+    for name in names:
+        player = server.getPlayer(name)
+        if player:
+            player_id = uid(player)
+            not_yourself = player != sender
 
-      if not player_id in friends[sender_id]:
-        if not_yourself:
-          friends[sender_id].append(player_id)
-          added.append(player.getName())
-          friendmessage(player.getPlayer(), "&a&o%s &aadded you to their friends list" % stripcolors(sender.getDisplayName()))
-      else:
-        friendalready.append(player.getName())
+            if not player_id in friends[sender_id]:
+                if not_yourself:
+                    friends[sender_id].append(player_id)
+                    added.append(player.getName())
+                    friendmessage(player.getPlayer(), "&a&o%s &aadded you to their friends list" % stripcolors(sender.getDisplayName()))
+            else:
+                friendalready.append(player.getName())
 
-    else:
-      notfound.append(name)
+        else:
+            notfound.append(name)
 
-  save_friends()
-  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))
-  if friendalready:
-    friendmessage(sender, "&c&o%s&c is/are already your friend." % ", ".join(friendalready))
-  if not not_yourself:
-    friendmessage(sender, "&cYou can't add yourself to your friends list.")
+    save_friends()
+    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))
+    if friendalready:
+        friendmessage(sender, "&c&o%s&c is/are already your friend." % ", ".join(friendalready))
+    if not not_yourself:
+        friendmessage(sender, "&cYou can't add yourself to your friends list.")
 
 
 def rem(sender, names):
-  sender_id  = uid(sender)
-  removed    = []
-  notfound   = []
-  notafriend = []
+    sender_id  = uid(sender)
+    removed    = []
+    notfound   = []
+    notafriend = []
 
-  for name in names:
-    player = server.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())
-        friendmessage(player.getPlayer(), "&c&o%s &cremoved you from their friends list" % stripcolors(sender.getDisplayName()))
-      else:
-        notafriend.append(player.getName())
-    else:
-      notfound.append(name)
+    for name in names:
+        player = server.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())
+                friendmessage(player.getPlayer(), "&c&o%s &cremoved you from their friends list" % stripcolors(sender.getDisplayName()))
+            else:
+                notafriend.append(player.getName())
+        else:
+            notfound.append(name)
 
-  save_friends()
-  if removed:
-    friendmessage(sender, "&a&o%s&a removed." % ", ".join(removed))
-  if notfound:
-    friendmessage(sender, "&c&o%s&c not found. (must be online)" % ", ".join(notfound))
-  if notafriend:
-    friendmessage(sender, "&c&o%s&c is/are not in your friends list." % ", ".join(notafriend))
+    save_friends()
+    if removed:
+        friendmessage(sender, "&a&o%s&a removed." % ", ".join(removed))
+    if notfound:
+        friendmessage(sender, "&c&o%s&c not found. (must be online)" % ", ".join(notfound))
+    if notafriend:
+        friendmessage(sender, "&c&o%s&c is/are not in your friends list." % ", ".join(notafriend))
 
 
 def fhelp(sender):
-  friendmessage(sender, "&a&l/friends help")
-  msg(sender, "&a1. /friends &oadd <names...>    &6aliases: &o+")
-  msg(sender, "&a2. /friends &orem <names...>    &6aliases: &oremove, delete, del, -")
-  msg(sender, "&a3. /friends &oclear              &6aliases: &o/")
-  msg(sender, "&a4. /friends &olist                 &6aliases: &olst, *")
-  msg(sender, "&a5. /friends &ohelp               &6aliases: &o?")
+    friendmessage(sender, "&a&l/friends help")
+    msg(sender, "&a1. /friends &oadd <names...>    &6aliases: &o+")
+    msg(sender, "&a2. /friends &orem <names...>    &6aliases: &oremove, delete, del, -")
+    msg(sender, "&a3. /friends &oclear              &6aliases: &o/")
+    msg(sender, "&a4. /friends &olist                 &6aliases: &olst, *")
+    msg(sender, "&a5. /friends &ohelp               &6aliases: &o?")
 
 
 @hook.command("friends")
-def on_friend_command(sender, args):
-  if not is_player(sender):
-    friendmessage(sender, "&c&lYou can't have friends!")
+def on_friend_command(sender, command, label, args):
+    if not is_player(sender):
+        friendmessage(sender, "&c&lYou can't have friends!")
+        return True
+
+    cmd   = args[0] if args else None
+    fargs = args[1:]
+
+    # /friends list
+    if cmd in ["list", "lst", "*"]:
+        thread.start_new_thread(ls, (sender,))
+
+    # /friends clear
+    elif cmd in ["clear", "/"]:
+        clear(sender)
+
+    # /friends add <names>
+    elif cmd in ["add", "+"]:
+        if fargs:
+            add(sender, fargs)
+        else:
+            fhelp(sender)
+
+    # /friends remove <names>
+    elif cmd in ["remove", "rem", "delete", "del", "-"]:
+        if fargs:
+            rem(sender, fargs)
+        else:
+            fhelp(sender)
+
+    else:
+        fhelp(sender)
     return True
-
-  cmd   = args[0] if args else None
-  fargs = args[1:]
-
-  # /friends list
-  if cmd in ["list", "lst", "*"]:
-    ls(sender)
-
-  # /friends clear
-  elif cmd in ["clear", "/"]:
-    clear(sender)
-
-  # /friends add <names>
-  elif cmd in ["add", "+"]:
-    if fargs:
-      add(sender, fargs)
-    else:
-      fhelp(sender)
-
-  # /friends remove <names>
-  elif cmd in ["remove", "rem", "delete", "del", "-"]:
-    if fargs:
-      rem(sender, fargs)
-    else:
-      fhelp(sender)
-
-  else:
-    fhelp(sender)
-  return True

helpers.py

@@ -1,12 +1,30 @@
 #pylint: disable = F0401
+
+import org.bukkit as bukkit
+import org.bukkit.block as bblock
+import org.bukkit.Location as Location
+import org.bukkit.event.entity as entity
+import org.bukkit.entity.Player as Player
+import org.bukkit.command.ConsoleCommandSender
+import org.bukkit.event.block.BlockBreakEvent as BlockBreakEvent
+import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause as TeleportCause
+
 from re import sub
+from thread_utils import *
+from player import py_players
+from org.bukkit.entity import *
+from player import get_py_player
+from traceback import format_exc as trace
 from java.util.UUID import fromString as juuid
 from json import dumps as json_dumps, loads as json_loads
-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.block as bblock
+
+#Imports for async query
+import threading
+import mysqlhack
+
+from secrets import *
+from com.ziclix.python.sql import zxJDBC
+
 
 
 shared = {} # this dict can be used to share stuff across modules
@@ -15,205 +33,248 @@ server = bukkit.Bukkit.getServer()
 
 
 def info(text):
-  server.getLogger().info("[RedstonerUtils] %s" % text)
+    """
+    Log info to console
+    """
+    server.getLogger().info("[RedstonerUtils] %s" % text)
 
 
 def warn(text):
-  server.getLogger().warning("[RedstonerUtils] %s" % text)
+    """
+    Log warning to console
+    """
+    server.getLogger().warning("[RedstonerUtils] %s" % text)
 
 
 def error(text):
-  server.getLogger().severe("[RedstonerUtils] %s" % 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
-  the player may be None or offline, which this method just ignores
-  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 basecolor:
-      if usecolor:
+    """
+    send a message to player
+    the player may be None or offline, which this method just ignores
+    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.isOnline()): # getPlayer() returns None when offline
+        if basecolor:
+            if usecolor:
+                text = colorify(text)
+            player.sendMessage(colorify("&%s" % basecolor) + text)
+        else:
+            player.sendMessage(colorify(text) if usecolor else 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)
-      player.sendMessage(colorify("&%s" % basecolor) + text)
-    else:
-      player.sendMessage(colorify(text) if usecolor else text)
-
-
-def broadcast(perm, text):
-  """
-  better than bukkit's broadcast.
-  bukkit only works with permissibles that are subscribed to perm
-  """
-  text = colorify(text)
-  for recipient in list(server.getOnlinePlayers()) + [server.getConsoleSender()]:
-    if not perm or recipient.hasPermission(perm):
-      msg(recipient, text)
+    for recipient in list(server.getOnlinePlayers()) + [server.getConsoleSender()]:
+        if not perm or recipient.hasPermission(perm):
+            msg(recipient, text, usecolor = False)
 
 
 def colorify(text):
-  """
-  replace &-codes with real color codes
-  """
-  return sub("&(?=[?\\da-fk-or])", u"\u00A7", "%s" % text)
+    """
+    replace &-codes with real color codes
+    """
+    return sub("&" + u"\u00A7", "&", "%s" % sub("&(?=[?\\da-fk-or])", u"\u00A7", "%s" % text))
 
 
 def stripcolors(text):
-  """
-  strips all (real) color codes from text
-  """
-  return sub(u"\u00A7[\\da-fk-or]", "", "%s" % text)
+    """
+    strips all (real) color codes from text
+    """
+    return sub(u"\u00A7[\\da-fk-or]", "", "%s" % text)
 
 
 def safetp(player, world, x, y, z, yaw = 0, pitch = 0):
-  """
-  teleports the player to the given Location
-  if the player would spawn inside blocks, the location is escalated until the location is safe
-  """
-  tpblock = Location(world, x, y, z).getBlock()
-  if (tpblock.isEmpty() and tpblock.getRelative(bblock.BlockFace.UP).isEmpty()) or y > 255:
-    player.teleport(Location(world, x+0.5, y, z+0.5, yaw, pitch), TeleportCause.COMMAND)
-  else:
-    safetp(player, world, x, y+1, z, yaw, pitch)
+    """
+    teleports the player to the given Location
+    if the player would spawn inside blocks, the location is escalated until the location is safe
+    """
+    tpblock = Location(world, x, y, z).getBlock()
+    if (tpblock.isEmpty() and tpblock.getRelative(bblock.BlockFace.UP).isEmpty()) or y > 255:
+        player.teleport(Location(world, x+0.5, y, z+0.5, yaw, pitch), TeleportCause.COMMAND)
+    else:
+        safetp(player, world, x, y+1, z, yaw, pitch)
 
 
 def plugin_header(recipient = None, name="Redstoner Utils"):
-  """
-  sends the recipient a "Plugin Header", in the format of: --=[ PluginName ]=--
-  """
+    """
+    sends the recipient a "Plugin Header", in the format of: --=[ PluginName ]=--
+    """
 
-  head = "\n&2--=[ %s ]=--" % name
-  msg(recipient, head)
-  return head
+    head = "\n&2--=[ %s ]=--" % name
+    msg(recipient, head)
+    return head
 
 
 def noperm(player):
-  msg(player, "&cno permission")
+    """
+    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 /
-  """
-  server.dispatchCommand(player, cmd)
+    """
+    run a command as player
+    the cmd should NOT be prefixed with a /
+    """
+    if is_player(player):
+        player.chat("/" + cmd)
+    else:
+        server.dispatchCommand(player, cmd)
 
 
 def is_player(obj):
-  """
-  return True when ob is a bukkit Player
-  """
-  return (isinstance(obj, Player))
+    """
+    return True when ob is a bukkit Player
+    """
+    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
-  amin is the minimum amount of args
-  amax is the maximum amount of args
-  if amax is < 0, infinite args will be accepted
-  return True if args has a valid length, False otherwise
-  """
-  if not (len(args) >= amin and (amax < 0 or len(args) <= amax)):
-    if amin == amax:
-      msg(sender, "&cNeeds " + str(amin) + " arguments!")
-      return False
-    elif amax < 0:
-      msg(sender, "&cNeeds at least " + str(amin) + " arguments!")
-      return False
-    else:
-      msg(sender, "&cNeeds " + str(amin) + " to " + str(amax) + " arguments!")
-      return False
-  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
+    """
+    check if a command has a valid amount of args, otherwise notify the sender
+    amin is the minimum amount of args
+    amax is the maximum amount of args
+    if amax is < 0, infinite args will be accepted
+    return True if args has a valid length, False otherwise
+    """
+    if not (len(args) >= amin and (amax < 0 or len(args) <= amax)):
+        if amin == amax:
+            msg(sender, "&cNeeds " + str(amin) + " arguments!")
+            return False
+        elif amax < 0:
+            msg(sender, "&cNeeds at least " + str(amin) + " arguments!")
+            return False
+        else:
+            msg(sender, "&cNeeds " + str(amin) + " to " + str(amax) + " arguments!")
+            return False
+    return True
 
 
 def is_creative(player):
-  """
-  returns True if the player is in Creative mode
-  """
-  return str(player.getGameMode()) == "CREATIVE"
+    """
+    returns True if the player is in Creative mode
+    """
+    return str(player.getGameMode()) == "CREATIVE"
+
+
+def is_rank(player, rank):
+    """
+    rank: a string equal to the PEX group name found in /pex groups
+    returns True if one of the following conditions are met:
+    - the player is of the given rank,
+    - their rank inherits the given rank.
+    """
+    return player.hasPermission("groups." + rank)
 
 
 def uid(player):
-  """
-  returns the player's UUID
-  """
-  return str(player.getUniqueId())
+    """
+    returns the player's UUID
+    """
+    return str(player.getUniqueId())
 
 
 def retrieve_player(uuid_str):
-  """
-  gets an offline player by UUID string
-  the uuid MUST contain dashes
-  """
-  return server.getOfflinePlayer(juuid(uuid_str))
+    """
+    gets an offline player by UUID string
+    the uuid MUST contain dashes
+    """
+    return server.getOfflinePlayer(juuid(uuid_str))
 
 
 def known_player(player):
-  """
-  to be used on OfflinePlayer (which can be online!)
-  returns True if the player has been on the server
-  this is different to HasPlayedBefore(), which will return False on first join
-  """
-  return player.hasPlayedBefore()
+    """
+    to be used on OfflinePlayer (which can be online!)
+    returns True if the player has been on the server
+    this is different to HasPlayedBefore(), which will return False on first join
+    """
+    return player.hasPlayedBefore()
 
-
-def open_json_file(filename, default):
-  """
-  opens the given json file and returns an object or returns None on error
-  filename is the path + name of the file.
-  """
-  data = None
-  try:
-    with open("plugins/redstoner-utils.py.dir/files/%s.json" % filename) as obj:
-      data = json_loads(obj.read())
-  except Exception, e:
-    error("Failed to read from %s: %s" % (filename, e))
-  return (default if data is None else data)
+def open_json_file(filename, default = None):
+    """
+    opens the given json file and returns an object or returns None on error
+    filename is only the name of the file without .json appended.
+    """
+    try:
+        with open("plugins/redstoner-utils.py.dir/files/%s.json" % filename) as obj:
+            default = json_loads(obj.read())
+    except Exception, e:
+        error("Failed to read from %s: %s" % (filename, e))
+    return default
 
 
 def save_json_file(filename, obj):
-  """
-  saves the given object as json into filename
-  filename is the path + name of the file.
-  """
-  try:
-    with open("plugins/redstoner-utils.py.dir/files/%s.json" % filename, "w") as f:
-      f.write(json_dumps(obj))
-  except Exception, e:
-    error("Failed to write to %s: %s" % (filename, e))
+    """
+    saves the given object as json into filename
+    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:
+            f.write(json_dumps(obj))
+    except Exception, e:
+        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"):
-  """
-  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"
-  """
+def toggle(player, ls, name = "Toggle", add = None):
+    """
+    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)
+    if pid in ls or add == False:
+        ls.remove(pid)
+        msg(player, "&a%s turned off!" % name)
+    elif add != False:
+        ls.append(pid)
+        msg(player, "&a%s turned on!" % name)
 
-  pid     = uid(player)
-  enabled = pid in ls
+def send_JSON_message(playername, message):
+    bukkit.Bukkit.getServer().dispatchCommand(bukkit.Bukkit.getServer().getConsoleSender(), "tellraw " + playername + " " + message)
 
-  # Do some checks and remove pid.
-  if enabled and add == False:
-    ls.remove(pid)
-    msg(player, on)
 
-  # Do some checks and append pid.
-  elif not enabled and add == True:
-    ls.append(pid)
-    msg(player, off)
-
-  # Already on/off (optional)
-  else:
-    msg(player, already % (" ON" if add else " OFF"))
+def isIP(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:
+            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

imbusy.py

@@ -0,0 +1,107 @@
+# I'M BUSY! Plugin by Curs3d #
+##############################
+# Concept by CookieManors :D #
+# http://bit.ly/1GnNPW8      #
+##############################
+# 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 basecommands import simplecommand
+from traceback import format_exc as trace
+busy_players = []
+
+
+def unclear():
+    msg(sender, "Umm, what? Sorry, directions unlclear, got head stuck in washing machine")
+
+
+@hook.command("busy",
+    aliases = ["focus"],
+    usage = "/<command> <on|off|status>",
+    description = "Sets busy mode on, you cannot recieve tpas and MSGs"
+    )
+def on_busy_command(sender, cmd, label, args):
+
+    if not is_player(sender):
+       msg(sender, "Sorry, Console cannot be busy")
+       return True
+
+    if not sender.hasPermission("utils.busy.allowed"):
+        plugin_header(recipient = sender, name = "I'M BUSY!")
+        noperm(sender)
+        return True
+
+    if len(args) == 0:
+        plugin_header(recipient = sender, name = "I'M BUSY!")
+        msg(sender, "This plugin allows being busy, and when turned on you will not recieve any direct messages or tpa requests.")
+        msg(sender, "\nCommands:")
+        msg(sender, "/busy on: turns on busy mode")
+        msg(sender, "/busy off: turns off busy mode")
+        msg(sender, "/busy status [player]: shows your or [player]'s current busy status.")
+        return True
+
+    elif len(args) == 1:
+        if args[0] == "on":
+            if sender.getName() in busy_players:
+                plugin_header(recipient = sender, name = "I'M BUSY!")
+                msg(sender, "You cannot be even more focused than this without being a jedi!")
+                return True
+            busy_players.append(sender.getName())
+            plugin_header(recipient = sender, name = "I'M BUSY!")
+            broadcast(None, "%s is now SUPER busy! Don't even TRY bothering them, it will not work!" % sender.getName())
+            return True
+
+        elif args[0] == "off":
+            plugin_header(recipient = sender, name = "I'M BUSY!")
+            try:
+                busy_players.remove(sender.getName())
+                msg(sender, "Master has sent /busy command, %s is freeee!" % sender.getName())
+                return True
+            except ValueError:
+                msg(sender, "You are not busy! You cannot be even less busy! Are you perhaps bored?")
+                return True
+
+        elif args[0] == "status":
+            plugin_header(recipient = sender, name = "I'M BUSY!")
+            if sender.getName() in busy_players:
+                msg(sender, "You are super-duper busy and concentrated right now. Think, think, think!")
+                return True
+            else:
+                msg(sender, "You are completely unable to focus right now.")
+                return True
+
+        else:
+            plugin_header(recipient = sender, name = "I'M BUSY!")
+            unclear()
+            return False
+
+    elif len(args) == 2 and args[0] == "status":
+        plugin_header(recipient = sender, name = "I'M BUSY!")        
+        if args[1] in busy_players:
+            msg(sender, "Yes, %s is busy. Shhh..." % args[1])
+            return True
+        else:
+            msg(sender, "No, you're good. Feel free to chat with %s!" % args[1])
+            return True
+
+    else:
+        plugin_header(recipient = sender, name = "I'M BUSY!")
+        unclear()
+        return False
+
+
+@hook.event("player.PlayerCommandPreprocessEvent", "monitor")
+def on_cmd_preprocess_event(event):
+    message = event.getMessage().split(" ")
+    if message[0] == "/msg" or message[0] == "/w" or message[0] == "/m" or \
+        message[0] == "/tell" or message[0] == "/tpa" or message[0] == "/tpahere":
+        if message[1] in busy_players:
+            plugin_header(recipient = event.getPlayer(), name = "I'M BUSY!")
+            msg(event.getPlayer(), "We are sorry, but %s is currently busy. Please try again later." % message[1])
+            event.setCancelled(True)

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,107 @@
+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"
+
+
+@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 = ?", (uuid, json.dumps(ips), ))
+    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 uuid = ?", (ip, json.dumps(uuids), ))
+        conn.commit()
+    curs.close()
+    conn.close()
+
+
+@hook.command("getinfo")
+def on_getinfo_command(sender, args):
+    t = threading.Thread(target=on_player_join_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 isIP(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

@@ -6,55 +6,55 @@ lagchunks = []
 
 
 def print_help(sender):
-  msg(sender, " &b/lagchunks <amount> &eList chunks where #entities >= <amount>")
-  msg(sender, " &b/lagchunks list     &eShow list again")
-  msg(sender, " &b/lagchunks tp <num> &eTeleport to chunk <num> from list")
+    msg(sender, " &b/lagchunks <amount> &eList chunks where #entities >= <amount>")
+    msg(sender, " &b/lagchunks list     &eShow list again")
+    msg(sender, " &b/lagchunks tp <num> &eTeleport to chunk <num> from list")
 
 
 def scan_chunks(amount):
-  global lagchunks
-  chunks = []
-  for world in bukkit.Bukkit.getServer().getWorlds():
-    for chunk in world.getLoadedChunks():
-      if len(chunk.getEntities()) >= amount:
-        ents = chunk.getEntities()
-        #                [0]world           [1]X                                [2]Y                               [3]Z                               [4]amount
-        chunks.append([chunk.getWorld(), int(ents[-1].getLocation().getX()), int(ents[0].getLocation().getY()), int(ents[0].getLocation().getZ()), len(ents)])
-  chunks.sort(key = lambda entry: entry[4], reverse = True)
-  lagchunks = chunks
+    global lagchunks
+    chunks = []
+    for world in bukkit.Bukkit.getServer().getWorlds():
+        for chunk in world.getLoadedChunks():
+            if len(chunk.getEntities()) >= amount:
+                ents = chunk.getEntities()
+                #                [0]world           [1]X                                [2]Y                               [3]Z                               [4]amount
+                chunks.append([chunk.getWorld(), int(ents[-1].getLocation().getX()), int(ents[0].getLocation().getY()), int(ents[0].getLocation().getZ()), len(ents)])
+    chunks.sort(key = lambda entry: entry[4], reverse = True)
+    lagchunks = chunks
 
 
 def list_chunks(sender):
-  for id, chunk in enumerate(lagchunks):
-    msg(sender, "&b%s&a: (&b%s&a) %s&7, &a%s &7(%s)" % (id, chunk[4], chunk[1], chunk[3], chunk[0].getName()))
-  msg(sender, "&2------------------")
+    for id, chunk in enumerate(lagchunks):
+        msg(sender, "&b%s&a: (&b%s&a) %s&7, &a%s &7(%s)" % (id, chunk[4], chunk[1], chunk[3], chunk[0].getName()))
+    msg(sender, "&2------------------")
 
 
 def tp_chunk(sender, id):
-  chunk = lagchunks[id]
-  safetp(sender, chunk[0], chunk[1], chunk[2], chunk[3])
-  msg(sender, "&aTeleported to &b%s&a, &b%s&a in &7%s&a with &b%s&a entities nearby." % (chunk[1], chunk[3], chunk[0].getName(), chunk[4]))
+    chunk = lagchunks[id]
+    safetp(sender, chunk[0], chunk[1], chunk[2], chunk[3])
+    msg(sender, "&aTeleported to &b%s&a, &b%s&a in &7%s&a with &b%s&a entities nearby." % (chunk[1], chunk[3], chunk[0].getName(), chunk[4]))
 
 
 @hook.command("lagchunks")
-def on_lagchunks_command(sender, args):
-  if sender.hasPermission("utils.lagchunks"):
-    plugin_header(sender, "Lagchunks")
-    global lagchunks
-    if len(args) == 1 and args[0].isdigit() and int(args[0]) > 0:
-      amount = args[0]
-      msg(sender, "&aChunks with at least &b%s &aentities:" % amount, )
-      scan_chunks(int(amount))
-      list_chunks(sender)
-    elif len(args) == 1 and args[0].lower() == "list":
-      list_chunks(sender)
-    elif len(args) == 2 and args[0].lower() == "tp" and args[1].isdigit() and int(args[1]) <= len(lagchunks)-1:
-      if isinstance(sender, Player):
-        tp_chunk(sender, int(args[1]))
-      else:
-        msg(sender, "&cOnly players can do this!")
+def on_lagchunks_command(sender, command, label, args):
+    if sender.hasPermission("utils.lagchunks"):
+        plugin_header(sender, "Lagchunks")
+        global lagchunks
+        if len(args) == 1 and args[0].isdigit() and int(args[0]) > 0:
+            amount = args[0]
+            msg(sender, "&aChunks with at least &b%s &aentities:" % amount, )
+            scan_chunks(int(amount))
+            list_chunks(sender)
+        elif len(args) == 1 and args[0].lower() == "list":
+            list_chunks(sender)
+        elif len(args) == 2 and args[0].lower() == "tp" and args[1].isdigit() and int(args[1]) <= len(lagchunks)-1:
+            if isinstance(sender, Player):
+                tp_chunk(sender, int(args[1]))
+            else:
+                msg(sender, "&cOnly players can do this!")
+        else:
+            print_help(sender)
     else:
-      print_help(sender)
-  else:
-    noperm(sender)
-  return True
+        noperm(sender)
+    return True

login.py

@@ -0,0 +1,129 @@
+from wrapper import *
+from passlib.hash import pbkdf2_sha256 as crypt
+
+@event_handler("player_login","normal", utils = True)
+def player_join(*args):
+    player = args[1]
+    if not player.registered:
+        player.authenticated = True
+        player.msg("Successfully logged in!")
+
+"""
+@event_handler("player.PlayerCommandPreprocessEvent", "lowest")
+def on_login_command(event):
+    player = event.player
+    password = event.message.replace("/login", "").replace(" ", "")
+    event.message = event.player.name + " Attempting to login!"
+    event.cancelled = True
+
+    @async(daemon = True)
+    def check_pass(player, password):
+        print password
+        if not player.registered:
+            player.msg("You are not registered! use /register <password> to register!")
+            return
+        else:
+            if crypt.verify(password, player.password):
+                player.authenticated = True
+                player.msg("Successfully logged in!")
+            else:
+                print event.message
+                player.msg("Wrong password!")
+    check_pass(player, password)"""
+
+@command("login")
+@async(daemon = True)
+def on_login_command(**kwargs):
+    player = kwargs["sender"]
+    args = kwargs["args"]
+
+    if not player.registered:
+        player.msg("You are not registered! use /register <password> to register!")
+        return
+    if len(args) > 1:
+        player.msg("The syntax is /login <password>")
+        return
+    elif len(args) is 1:
+        if crypt.verify(args[0], player.password):
+            player.authenticated = True
+            player.msg("Successfully logged in!")
+        else:
+            player.msg("Wrong password!")
+
+@command("changepass")
+@async(daemon = True)
+def on_changepass_command(**kwargs):
+    player = kwargs["sender"]
+    args = kwargs["args"]
+
+    if not player.registered:
+        player.msg("You are not registered! use /register <password> to register!")
+        return
+
+    if len(args) < 2:
+        player.msg("The syntax is /login <current_password> <new_password>")
+        return
+    elif len(args) is 2:
+        if crypt.verify(args[0], player.password):
+            player.password = crypt.encrypt(args[1], rounds=200000, salt_size=16)
+            player.msg("Successfully changed your password!")
+            player.save()
+        else:
+            player.msg("You have entered an incorrect current password!")
+
+@command("removepass")
+@async(daemon = True)
+def on_removepass_command(**kwargs):
+    player = kwargs["sender"]
+    args = kwargs["args"]
+
+    if not player.registered:
+        player.msg("You are not registered! use /register <password> to register!")
+        return
+
+    if len(args) < 1:
+        player.msg("The syntax is /removepass <current_password>")
+        return
+
+    elif len(args) is 1:
+        if crypt.verify(args[0], player.password):
+            player.password = "None"
+            player.registered = False
+            player.save()
+            player.msg("Successfully removed your password!")
+        else:
+            player.msg("You have entered an incorrect current password!")
+
+
+
+
+@command("register")
+@async(daemon = True)
+def on_register_command(**kwargs):
+    player = kwargs["sender"]
+    args = kwargs["args"]
+    if len(args) > 1:
+        player.msg("The syntax is /register <password>")
+        return
+    elif len(args) is 1:
+        if player.registered:
+            player.msg("You are already registered!")
+            return 
+        player.password = crypt.encrypt(args[0], rounds=200000, salt_size=16)
+        player.registered = True
+        print player.password
+        player.save()
+        player.msg("Successfully registered!")
+
+
+blocked_events = ["block.BlockBreakEvent", "block.BlockPlaceEvent", "player.PlayerMoveEvent",
+                    "player.AsyncPlayerChatEvent","player.PlayerTeleportEvent",
+                     "player.PlayerInteractEvent"]
+
+for event in blocked_events:
+    @event_handler(event_name = event, priority = "highest")
+    def on_blocked_event(event):
+        if not event.player.authenticated:
+            event.cancelled = True
+
+

main.py

@@ -9,48 +9,39 @@ 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:
-  from helpers import *
+    # Library that adds a bunch of re-usable methods which are used in nearly all other modules
+    from helpers import *
+    #from wrapper import *
 except:
-  print("[RedstonerUtils] ERROR: Failed to import helpers:")
-  print(print_traceback())
-
-
+    error("[RedstonerUtils] ERROR: Failed to import Wrapper:")
+    error(print_traceback())
 
 @hook.enable
 def on_enable():
-  info("RedstonerUtils enabled!")
+    info("RedstonerUtils enabled!")
 
 
 @hook.disable
 def on_disable():
-  shared["modules"]["reports"].stop_reporting()
-  info("RedstonerUtils disabled!")
+    #shared["modules"]["reports"].stop_reporting()
+    info("RedstonerUtils disabled!")
 
 
 info("Loading RedstonerUtils...")
 
+
+
 # Import all modules, in this order
 shared["load_modules"] = [
-  "misc",
-  "adminchat",
-  "lagchunks",
-  "reports",
-  "chatgroups",
-  "webtoken",
-  "saylol",
-  "skullclick",
-  "mentio",
-  "cycle",
-  "motd",
-  "abot",
-  "forcefield",
-  "friends"
+    "test", 
+#    "login",
 ]
+
 shared["modules"] = {}
 for module in shared["load_modules"]:
-  try:
-    shared["modules"][module] = __import__(module)
-    info("Module %s loaded." % module)
-  except:
-    error("Failed to import module %s:" % module)
-    error(print_traceback())
+    try:
+        shared["modules"][module] = __import__(module)
+        info("Module %s loaded." % module)
+    except:
+        error("Failed to import module %s:" % module)
+        error(print_traceback())

mentio.py

@@ -4,140 +4,146 @@ 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
 
 
 def saveMentions():
-  save_json_file("mentio", mentions)
+    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()
-    words      = event.getMessage().split(" ")
-    recipients = event.getRecipients() # set of <Player>, may be a lazy or unmodifiable collection
+    if not event.isCancelled():
+        sender     = event.getPlayer()
+        words      = event.getMessage().split(" ")
+        recipients = event.getRecipients() # set of <Player>, may be a lazy or unmodifiable collection
 
-    for recipient in list(recipients):
-      recuid = uid(recipient)
+        for recipient in list(recipients):
+            recuid = uid(recipient)
 
-      if recuid in mentions:
-        keywords = mentions[uid(recipient)]
-      else:
-        # player
-        keywords = [recipient.getName().lower(), stripcolors(recipient.getDisplayName()).lower()]
+            if recuid in mentions:
+                keywords = mentions[uid(recipient)]
+            else:
+                # player
+                keywords = [recipient.getName().lower(), stripcolors(recipient.getDisplayName()).lower()]
 
-      rec_words = words[:] # copy
-      for index, word in enumerate(rec_words):
-        isMentioned = False
+            rec_words = words[:] # copy
+            for index, word in enumerate(rec_words):
+                isMentioned = False
 
-        for keyword in keywords:
-          if keyword in word.lower(): # is the keyword mentioned
-            isMentioned = True
+                for keyword in keywords:
+                    if keyword in word.lower(): # is the keyword mentioned
+                        isMentioned = True
 
-        if isMentioned:
-          # join all color codes used upto this word
-          colors = "".join(colors_reg.findall("".join(words[:index+1])))
-          # highlight the word containing mention, then apply all previous color codes
-          rec_words[index] = colorify("&r&a&o") + stripcolors(word) + colorify("&r") + colors
-          # No need to
-          break
+                if isMentioned:
+                    # join all color codes used upto this word
+                    colors = "".join(colors_reg.findall("".join(words[:index+1])))
+                    # highlight the word containing mention, then apply all previous color codes
+                    rec_words[index] = colorify("&r&a&o") + stripcolors(word) + colorify("&r") + colors
+                    # No need to
+                    break
 
-      # player was mentioned
-      if rec_words != words:
-        try:
-          recipients.remove(recipient) # don't send original message
-        except:
-          # list might not be mutable, ignoring. Receiver will get the message twice
-          pass
-        message = " ".join([sender.getDisplayName(), arrow] + rec_words)
-        msg(recipient, message, usecolor = False)
-        recipient.playSound(recipient.getLocation(), "mob.chicken.plop", 1, 2)
+            # player was mentioned
+            if rec_words != words:
+                try:
+                    recipients.remove(recipient) # don't send original message
+                except:
+                    # list might not be mutable, ignoring. Receiver will get the message twice
+                    pass
+                message = " "+" ".join([sender.getDisplayName(), arrow] + rec_words)
+                msg(recipient, message, usecolor = False)
+                recipient.playSound(recipient.getLocation(), "mob.chicken.plop", 1, 2)
 
 
 def get_keywords(player):
-  sender_id = uid(player)
-  if sender_id in mentions.keys():
-    keywords = mentions[sender_id]
-  else:
-    keywords = []
-  return keywords
+    sender_id = uid(player)
+    if sender_id in mentions.keys():
+        keywords = mentions[sender_id]
+    else:
+        keywords = []
+    return keywords
 
 
 def add_keyword(sender, args):
-  keywords = get_keywords(sender)
-  new_word = stripcolors(args[1].lower())
+    keywords = get_keywords(sender)
+    new_word = stripcolors(args[1].lower())
 
-  if len(keywords) >= max_amount:
-    msg(sender, "&cYou are already listening for %s words! Try &6/mentio del <word>" % 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
+
+    if len(new_word) > 20:
+        msg(sender, "&cThis word is longer than 20 characters. Pick a shorter one!")
+        return True
+
+    if new_word in keywords:
+        msg(sender, "&cYou are already listening for this word! Try &6/mentio list")
+        return True
+
+    keywords.append(new_word)
+    if keywords:
+        mentions[uid(sender)] = keywords
+
+    msg(sender, "&aYou are now listening for '&2%s&2'!" % new_word)
+    saveMentions()
     return True
 
-  if len(new_word) > 20:
-    msg(sender, "&cThis word is longer than 20 characters. Pick a shorter one!")
-    return True
-
-  if new_word in keywords:
-    msg(sender, "&cYou are already listening for this word! Try &6/mentio list")
-    return True
-
-  keywords.append(new_word)
-  if keywords:
-    mentions[uid(sender)] = keywords
-
-  msg(sender, "&aYou are now listening for '&2%s'!" % new_word)
-  saveMentions()
-  return True
-
 
 def del_keyword(sender, args):
-  keywords = get_keywords(sender)
-  del_word = stripcolors(args[1].lower())
+    keywords = get_keywords(sender)
+    del_word = stripcolors(args[1].lower())
 
-  if not keywords:
-    msg(sender, "&cYou are currently listening for no words! Try &6/mentio add <word>")
-    return
+    if not keywords:
+        msg(sender, "&cYou are currently listening for no words! Try &6/mentio add <word>")
+        return
 
-  if del_word in keywords:
-    keywords.remove(del_word)
-    sender_id = uid(sender)
-    if keywords:
-      mentions[sender_id] = keywords
-    elif sender_id in mentions:
-      del mentions[sender_id]
-    saveMentions()
-    msg(sender, "&aYou are no longer listening for '&2%s&e'!" % del_word)
-  else:
-    msg(sender, "&cWe can't remove something that doesn't exist! Try &6/mentio list")
+    if del_word in keywords:
+        keywords.remove(del_word)
+        sender_id = uid(sender)
+        if keywords:
+            mentions[sender_id] = keywords
+        elif sender_id in mentions:
+            del mentions[sender_id]
+        saveMentions()
+        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):
-  plugin_header(sender, "Mentio")
+def onListenCommand(sender, command, label, args):
+    plugin_header(sender, "Mentio")
 
-  argnum = len(args)
-  if argnum:
-    cmd = args[0].lower()
+    argnum = len(args)
+    if argnum:
+        cmd = args[0].lower()
 
-    # /mentio add <word>
-    if argnum == 2 and cmd == "add":
-      add_keyword(sender, args)
+        # /mentio add <word>
+        if argnum == 2 and cmd == "add":
+            add_keyword(sender, args)
 
-    # /mentio del <word>
-    elif argnum == 2 and cmd == "del":
-      del_keyword(sender, args)
+        # /mentio del <word>
+        elif argnum == 2 and cmd == "del":
+            del_keyword(sender, args)
 
-    # /mentio list
-    elif argnum == 1 and cmd == "list":
-      msg(sender, "&aWords you're listening for:")
-      keywords = get_keywords(sender)
-      for word in keywords:
-        msg(sender, "&c- &3%s" % word)
-      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")
-  return True
+        # /mentio list
+        elif argnum == 1 and cmd == "list":
+            msg(sender, "&aWords you're listening for:")
+            keywords = get_keywords(sender)
+            for word in keywords:
+                msg(sender, "&c- &3%s" % word)
+            if not keywords:
+                msg(sender, "&cYou are currently listening for no words! Try &6/mentio add <word>")
+        else:
+            show_help(sender)
+    else:
+        show_help(sender)
+    return True

misc.py

@@ -1,156 +1,301 @@
 #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
+
 
-#
-# Welcome new players
-#
 
 @hook.event("player.PlayerJoinEvent", "monitor")
 def on_join(event):
-  player = event.getPlayer()
+    """
+    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", "")
+    # send welcome broadcast
+    if not player.hasPlayedBefore():
+        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, "  \n&6thank you and happy playing ;)")
-    msg(player, " \n \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 &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":
-    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())
+    # teleport to spawn when spawning inside portal
+    loginloc = player.getLocation().getBlock().getType()
+    headloc = player.getEyeLocation().getBlock().getType()
+    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)
+
+Keep in mind that, on "lowest" priority, PlotMe might cancel events.
 
 
-#
-# /sudo - execute command/chat *as* a player/console
-#
+"""
+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:]))
 
 
-@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):
-      return True
+
+
+""" 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"))
+
+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"]
+
+@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
+    cmd    =  " ".join(args[1:])
+    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):
-  plugin_header(sender, "Plugin versions")
-  plugins = list(server.getPluginManager().getPlugins())
-  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())
-  return True
+def on_pluginversions_command(sender, command, label, args):
+    """
+    /pluginversions
+    print all plugins + versions; useful when updating plugins
+    """
+    try:
+        plugin_header(sender, "Plugin versions")
+        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" + 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):
-  msg(sender, " ".join(args).replace("\\n", "\n"))
+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):
-  try:
-    result = eval(code)
-    msg(sender, ">>> %s: %s" % (colorify("&3") + type(result).__name__, colorify("&a") + unicode(result) + "\n "), usecolor = False)
-  except:
-    e = exc_info()[1]
+    """
+    /pyeval
+    run python ingame
+    """
     try:
-      eclass = e.__class__
-    except AttributeError:
-      eclass = type(e)
-    msg(sender, ">>> %s: %s" % (eclass.__name__, e) + "\n ", False, "c")
-  thread.exit()
+        result = eval(code)
+        msg(sender, ">>> %s: %s" % (colorify("&3") + type(result).__name__, colorify("&a") + unicode(result) + "\n "), usecolor = False)
+    except:
+        e = exc_info()[1]
+        try:
+            eclass = e.__class__
+        except AttributeError:
+            eclass = type(e)
+        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
+"305ccbd7-0589-403e-a45b-d791dcfdee7d", # PanFritz
+"51f2ad3c-6cc8-40ea-aa2b-f25970316921"  # Dico
+]
 
-@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)))
-  else:
-    noperm(sender)
-  return True
+    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:
+        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):
-  plugin_header(sender, "Modules")
-  for mod in shared["load_modules"]:
-    color = "a" if mod in shared["modules"] else "c"
-    msg(sender, "&" + color + mod)
+def on_modules_command(sender, command, label, args):
+    """
+    /modules
+    list all modules, unloaded modules in red
+    """
+    plugin_header(sender, "Modules")
+    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,31 +5,31 @@ default_motd = colorify(server.getMotd())
 motd         = default_motd
 
 @hook.command("getmotd")
-def on_getmotd_command(sender, args):
-  plugin_header(sender, "MOTD")
-  msg(sender, motd, usecolor = False)
+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):
-  global motd
-  if sender.hasPermission("utils.setmotd"):
-    if not checkargs(sender, args, 1, -1):
-      return True
+def on_setmotd_command(sender, command, label, args):
+    global motd
+    if sender.hasPermission("utils.setmotd"):
+        if not checkargs(sender, args, 1, -1):
+            return True
 
-    motd = colorify(" ".join(args).replace("\\n", "\n"))
+        motd = colorify(" ".join(args).replace("\\n", "\n"))
 
-    if motd == "--reset":
-      motd = default_motd
+        if motd == "--reset":
+            motd = default_motd
 
-    broadcast(None, plugin_header(name="MOTD"))
-    broadcast(None, "&aNew MOTD:&r\n%s" % motd)
-    broadcast(None, " ")
-  else:
-    noperm(sender)
-  return True
+        broadcast(None, plugin_header(name="MOTD"))
+        broadcast(None, "&aNew MOTD:&r\n%s" % motd)
+        broadcast(None, " ")
+    else:
+        noperm(sender)
+    return True
 
 
 @hook.event("server.ServerListPingEvent")
 def on_server_ping(event):
-  event.setMotd(motd)
+    event.setMotd(motd)

mysql_utils.py

@@ -0,0 +1,45 @@
+import mysqlhack
+from secrets import *
+from thread_utils import *
+from com.ziclix.python.sql import zxJDBC
+from traceback import format_exc as trace
+
+class mysql_connect:
+    def __init__(self):
+        self.conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+        self.curs = self.conn.cursor()
+
+    def execute(self, query, args=None):
+        if args is None:
+            return self.curs.execute(query)
+        else:
+            print query
+            print args
+            return self.curs.execute(query, args)
+
+    def fetchall(self):
+        return self.curs.fetchall()
+
+    @property
+    def columns(self):
+        self.execute("SHOW COLUMNS FROM utils_players")
+        fetched = self.fetchall()
+        columns = []
+
+        for row in fetched:
+            columns.append(row[0])
+        return columns
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_inst, exc_tb):
+        if exc_type is None:
+            try:        
+                self.conn.commit()
+                self.curs.close()
+                self.conn.close()
+            except:
+                print(trace())
+        else:
+            print(exc_tb)

mysqlhack.py

@@ -1,10 +1,15 @@
 #pylint: disable = F0401
-import java.lang.reflect.Method
-import java.io.File
-import java.net.URL
-import java.net.URLClassLoader
+"""
+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 jarray
+import java.net.URL
+import java.io.File
 from java.lang import Class
+import java.net.URLClassLoader
+import java.lang.reflect.Method
 
 
 # hacky code to add mysql-connector to java's classpath ('classPathHack')

player.py

@@ -0,0 +1,29 @@
+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):
+    py_players.remove(get_py_player(event.getPlayer()))
+

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
 
@@ -10,15 +12,15 @@ z_plot_size = 3
 padding     = 1
 
 def base_coords(x, z):
-  pid = plot_id(x, z)
-  return [pid[0] * (x_plot_size + padding), pid[1] * (z_plot_size + padding)]
+    pid = plot_id(x, z)
+    return [pid[0] * (x_plot_size + padding), pid[1] * (z_plot_size + padding)]
 
 def bounds(x, z):
-  base = base_coords(x, z)
-  return [base, [base[0] + x_plot_size, base[1] + z_plot_size]]
+    base = base_coords(x, z)
+    return [base, [base[0] + x_plot_size, base[1] + z_plot_size]]
 
 def plot_id(x, z):
-  return [x // (x_plot_size + padding), z // (z_plot_size + padding)]
+    return [x // (x_plot_size + padding), z // (z_plot_size + padding)]
 
 
 x = int(sys.argv[1])

plugin.yml

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

pmtoggle.py

@@ -0,0 +1,53 @@
+from helpers import *
+import org.bukkit.Bukkit as Bukkit
+from java.util.UUID import fromString as juuid
+
+toggle_dict = {}
+permission = "utils.pmtoggle"
+
+@hook.command("tm")
+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"
@@ -12,128 +13,188 @@ 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 tp <id>      &eTeleport to report's location & show details")
-  msg(sender, " &2/rp del <id>     &eResolve a report")
+    msg(sender, " &2/report <text>     &eReport something")
+    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 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):
-  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"]))
-  except:
-    warn("Failed to complete report's print_list() thread")
+def print_list(sender, closed):
+    try: # new thread, anything can happen.
+        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 )
+    if rep_id >= len(reports) or rep_id < 0:
+        msg(sender, "&cReport &3#" + str(rep_id) + "&c does not exist!")
+    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 %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)
-    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:
+    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 %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():
-  save_json_file("reports", reports)
+    save_json_file("reports", reports)
 
 
 @hook.command("rp")
-def on_rp_command(sender, args):
-  if sender.hasPermission(rp_permission):
-    plugin_header(sender, "Reports")
-    if len(args) > 0:
-      if args[0] == "list":
-        # needs to run in seperate thread because of getOfflinePlayer
-        thread.start_new_thread(print_list, (sender))
-      else:
-        if not checkargs(sender, args, 2, 2):
-          return True
-        try:
-          repid = int(args[1])
-        except ValueError:
-          msg(sender, "&cDoesn't look like &3" + args[1] + "&c is a valid number!")
-          print_help(sender)
-          return True
-        if args[0] == "tp":
-          if not is_player(sender):
-            msg(sender, "&conly players can do this")
-            return True
-          tp_report(sender, repid)
-        elif args[0] == "del":
-          delete_report(sender, repid)
+def on_rp_command(sender, command, label, args):
+    if sender.hasPermission(rp_permission):
+        plugin_header(sender, "Reports")
+        if len(args) > 0:
+            subcmd = args[0].lower()
+            if subcmd == "closed":
+                # needs to run in seperate thread because of getOfflinePlayer
+                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
+                try:
+                    repid = int(args[1])
+                except ValueError:
+                    msg(sender, "&cDoesn't look like &3" + args[1] + "&c is a valid number!")
+                    print_help(sender)
+                    return True
+                if subcmd == "tp":
+                    if not is_player(sender):
+                        msg(sender, "&conly players can do this")
+                        return True
+                    tp_report(sender, repid)
+                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:
-          print_help(sender)
+            print_help(sender)
     else:
-      print_help(sender)
-  else:
-    noperm(sender)
-  return True
+        noperm(sender)
+    return True
 
 
 @hook.command("report")
-def on_report_command(sender, args):
-  plugin_header(sender, "Report")
-  if not is_player(sender):
-    msg(sender, "&conly players can do this")
+def on_report_command(sender, command, label, args):
+    plugin_header(sender, "Report")
+    if not is_player(sender):
+        msg(sender, "&conly players can do this")
+        return True
+    if not checkargs(sender, args, 1, -1):
+        return True
+    text = " ".join(args)
+    loc = sender.getLocation()
+    reporter = sender.name
+    reporter_id = uid(sender)
+    report = {
+        "uuid": reporter_id,
+        "msg": text,
+        "x": int(loc.x),
+        "y": int(loc.y),
+        "z": int(loc.z),
+        "yaw": int(loc.yaw),
+        "pitch": int(loc.pitch),
+        "world": loc.getWorld().name,
+        "time": time.strftime(time_format),
+        "closed": False
+    }
+    reports.append(report)
+    save_reports()
+    broadcast(rp_permission, "&aReport #" + str(len(reports) -1) + ": " + reporter + "&f: " + text)
+    msg(sender, "&aReported \"&e" + text + "&a\"")
     return True
-  if not checkargs(sender, args, 1, -1):
-    return True
-  text = " ".join(args)
-  loc = sender.getLocation()
-  reporter = sender.name
-  reporter_id = uid(sender)
-  report = {
-    "uuid": reporter_id,
-    "msg": text,
-    "x": int(loc.x),
-    "y": int(loc.y),
-    "z": int(loc.z),
-    "yaw": int(loc.yaw),
-    "pitch": int(loc.pitch),
-    "world": loc.getWorld().name,
-    "time": time.strftime(time_format)
-  }
-  reports.append(report)
-  save_reports()
-  broadcast(rp_permission, "&aReport #" + str(len(reports) -1) + ": " + reporter + "&f: " + text)
-  msg(sender, "&aReported \"&e" + text + "&a\"")
-  return True
 
 
 def reports_reminder(): # needs 2 args for unknown reason
-  while True:
-    for i in range(0, check_delay*2):
-      time.sleep(0.5) # check every 0.5 seconds if we should kill the thread
-      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))
+    while True:
+        for i in range(0, check_delay*2):
+            time.sleep(0.5) # check every 0.5 seconds if we should kill the thread
+            if not check_reports:
+                info("Reports reminder thread killed.")
+                thread.exit()
+        targeted_reports = get_reports(False)
+        if len(targeted_reports) > 0:
+            broadcast(rp_permission, "&aThere are %s open reports!" % len(targeted_reports))
 
 
 def stop_reporting():
-  global check_reports
-  info("Ending reports reminder thread")
-  check_reports = False
+    global check_reports
+    info("Ending reports reminder thread")
+    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

@@ -9,96 +9,95 @@ last_msg = 0
 
 
 def save_lols():
-  save_json_file("lol", lols)
+    save_json_file("lol", lols)
 
 
 def add_lol(txt):
-  lols.append(txt)
-  save_lols()
+    lols.append(txt)
+    save_lols()
 
 
 def del_lol(lid):
-  lols.pop(lid)
-  save_lols()
+    lols.pop(lid)
+    save_lols()
 
 
 def print_lol(sender, lid):
-  global last_msg
-  if time() - last_msg > timeout:
-    if len(lols) > lid:
-      dispname = sender.getDisplayName() if is_player(sender) else sender.getName()
-      broadcast(None, "&8[&blol&8] &7%s&8: &e%s" % (dispname, lols[lid]))
-      last_msg = time()
+    global last_msg
+    if time() - last_msg > timeout:
+        if len(lols) > lid:
+            dispname = sender.getDisplayName() if is_player(sender) else sender.getName()
+            broadcast(None, "&8[&blol&8] &7%s&8: &e%s" % (dispname, lols[lid]))
+            last_msg = time()
+        else:
+            msg(sender, "&cInvalid id")
     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)))
+        msg(sender, "&cYou can use SayLol again in &a%s seconds!" % int(timeout + 1 - (time() - last_msg)))
 
 
 def search_lols(sender, keyword):
-  if not keyword:
-    msg(sender, "&cPlease provide a keyword to search for!")
-    return
-  msg(sender, "&aLols containing '&6%s&a':" % keyword)
-  for i, lol in enumerate(lols):
-    if keyword in lol:
-      msg(sender, "&a%s: &e%s" % (str(i).rjust(3), lol))
-  msg(sender, "") # empty line showing end of list
+    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.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):
-  plugin_header(sender, "SayLol")
+def on_lol_command(sender, command, label, args):
+    plugin_header(sender, "SayLol")
+
+    cmd = args[0] if len(args) > 0 else None
+    if len(args) == 0:
+        if sender.hasPermission("utils.lol"):
+            print_lol(sender, randrange(len(lols)))
+        else:
+            noperm(sender)
+
+    elif cmd == "id":
+        if sender.hasPermission("utils.lol.id"):
+            try:
+                i = int(args[1])
+                print_lol(sender, i)
+            except ValueError:
+                msg(sender, "&cInvalid number '&e%s&c'" % args[1])
+        else:
+            noperm(sender)
+
+    elif cmd == "list":
+        for i in range(len(lols)):
+            msg(sender, "&a%s: &e%s" % (str(i).rjust(3), lols[i]))
+
+    elif cmd == "search":
+        if sender.hasPermission("utils.lol.search"):
+            search_lols(sender, " ".join(args[1:]))
+        else:
+            noperm(sender)
+
+    elif cmd == "add":
+        if sender.hasPermission("utils.lol.modify"):
+            add_lol(" ".join(args[1:]))
+            msg(sender, "&aNew lol message added!")
+        else:
+            noperm(sender)
+
+    elif cmd == "del":
+        if sender.hasPermission("utils.lol.modify"):
+            try:
+                i = int(args[1])
+                del_lol(i)
+                msg(sender, "&aLol message &e#%s&a deleted!" % i)
+            except ValueError:
+                msg(sender, "&cInvalid number '&e%s&c'" % args[1])
 
-  cmd = args[0] if len(args) > 0 else None
-  if len(args) == 0:
-    if sender.hasPermission("utils.lol"):
-      print_lol(sender, randrange(len(lols)))
     else:
-      noperm(sender)
-
-  elif cmd == "id":
-    if sender.hasPermission("utils.lol.id"):
-      try:
-        i = int(args[1])
-        print_lol(sender, i)
-      except ValueError:
-        msg(sender, "&cInvalid number '&e%s&c'" % args[1])
-    else:
-      noperm(sender)
-
-  elif cmd == "list":
-    for i in range(len(lols)):
-      msg(sender, "&a%s: &e%s" % (str(i).rjust(3), lols[i]))
-
-  elif cmd == "search":
-    if sender.hasPermission("utils.lol.search"):
-      search_lols(sender, " ".join(args[1:]))
-    else:
-      noperm(sender)
-
-  elif cmd == "add":
-    if sender.hasPermission("utils.lol.modify"):
-      add_lol(" ".join(args[1:]))
-      msg(sender, "&aNew lol message added!")
-    else:
-      noperm(sender)
-
-  elif cmd == "del":
-    if sender.hasPermission("utils.lol.modify"):
-      try:
-        i = int(args[1])
-        del_lol(i)
-        msg(sender, "&aLol message &e#%s&a deleted!" % i)
-      except ValueError:
-        msg(sender, "&cInvalid number '&e%s&c'" % args[1])
-
-  else:
-    msg(sender, "&a/lol            &eSay random message")
-    msg(sender, "&a/lol list       &eList all 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")
-  return True
+        msg(sender, "&a/lol            &eSay random message")
+        msg(sender, "&a/lol list       &eList all 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")
+    return True

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,312 @@
+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
+
+"""
+  # About permissions:
+  # To use the command, the user needs to have utils.serversigns.
+  # To use ANY subcommand, the user needs to have utils.serversigns.<subcommand> IN ADDITION to the previously mentioned node.
+  # To be able to add commands as messages to a sign, a user will need the node utils.serversigns.command.
+  # To be able to claim a sign for another player or to edit signs that the user doesn't own, they will need utils.serversigns.admin.
+"""
+
+blocked_cmds = ("pex", "kick", "ban", "tempban", "pyeval", "sudo", "stop", "reload", "op", "deop", "whitelist")
+
+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)
+
+signs = load_signs() # {("world", x, y, z): ["owner_id", "msg1", "msg2"]}
+
+lines = {} # Accumulated messages so players can have longer messages: {"Dico200": "Message...........", ""}
+
+@hook.enable
+def check_all_signs(): 
+    # Check if all saved signs actually represent a sign block. There are ways to break the signs without the plugin knowing.
+    for loc in dict(signs): # Can't change dict size during iteration, using a copy
+        world = server.getWorld(loc[0])
+        if world and world.getBlockAt(loc[1], loc[2], loc[3]).getType() in (Material.SIGN_POST, Material.WALL_SIGN):
+            continue
+        del signs[loc]
+        info("[Server Signs] Couldn't find a %s, removed the data for the sign that was once there." % identifySign(loc))
+    save_signs()
+
+
+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
+
+
+@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()
+    Validate.isTrue(arg1 in ("claim", "reset", "add", "remove", "info", "clear", "help", "switch", "reverse", "unclaim"), 
+        signsMsg("That argument could not be recognized, use &o/svs help &4for expected arguments"))
+    Validate.isAuthorized(sender, "utils.serversigns." + arg1)
+
+    #-------------------- Sub commands that don't require any conditions -----------------------
+    if arg1 == "help":
+        admin = sender.hasPermission("utils.serversigns.admin")
+        msg = signsMsg("Server signs lets you add messages to a sign.", 'a')
+        msg += "\nRight clicking the sign will display all the messages. Commands"
+        msg += "\ncan also be added, by prefixing the message with a '/'."
+        msg += "\nHow to use &b/serversigns&a:"
+        msg += "\n&b/svs claim" + ("" if not sender.hasPermission("utils.serversigns.admin") else " [owner]")
+        msg += "\n&a- Claims the sign so that you can add messages to it"
+        msg += "\n&b/svs info"
+        msg += "\n&a- Displays information about the (claimed) sign"
+        msg += "\n&b/svs add <message>[++]"
+        msg += "\n&a- Adds the message to the sign. Use ++ at the end"
+        msg += "\n&a- to add the message to your buffer. You can then use"
+        msg += "\n&a- the same command again to create a longer message."
+        msg += "\n&b/svs remove <message ID>"
+        msg += "\n&a- Removes the message with the given ID from the sign."
+        msg += "\n&a- The ID is given before each message by &b/svs info&a."
+        msg += "\n&b/svs switch|reverse <message ID 1> <message ID 2>"
+        msg += "\n&a- Reverses the order in which the given messages are shown."
+        msg += "\n&b/svs clear"
+        msg += "\n&a- Removes all messages from the sign."
+        msg += "\n&b/svs reset|unclaim"
+        msg += "\n&a- Resets the sign, removing all messages and its owner."
+        return msg
+    #-------------------------------------------------------------------------------------------
+
+    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 arg1 == "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 arg1 == "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 arg1 == "add":
+        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] = ""
+            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(line[0] != "/" or line.split(" ")[0][1:] not in blocked_cmds, signsMsg("Usage of that command with server signs is prohibited"))
+        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 arg1 == "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 arg1 in ("switch", "reverse"):
+        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 arg1 == "clear":
+        signs[loc] = [sign[0]]
+        save_signs()
+        return signsMsg("Removed all messages from the %s" % signName, 'a')
+
+
+    if arg1 in ("reset", "unclaim"):
+        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):
+    global checking_block
+    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()
+    sign = getSign(fromLoc(block.getLocation()))
+    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:
+        loc = fromLoc(block.getLocation())
+        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()
+

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)

skullclick.py

@@ -4,13 +4,13 @@ from helpers import msg
 
 @hook.event("player.PlayerInteractEvent", "monitor")
 def on_block_interact(event):
-  if (str(event.getAction()) == "RIGHT_CLICK_BLOCK"):
-    sender = event.getPlayer()
-    block  = event.getClickedBlock().getState()
-    if (isinstance(block, bukkit.block.Skull) and not event.isCancelled()):
-      owner = block.getOwner()
-      if (owner):
-        msg(sender, "&eThat's %s." % owner)
-      else:
-        msg(sender, "&cThis skull has no name (Steve)")
-      event.setCancelled(True)
+    if (str(event.getAction()) == "RIGHT_CLICK_BLOCK"):
+        sender = event.getPlayer()
+        block  = event.getClickedBlock().getState()
+        if (isinstance(block, bukkit.block.Skull) and not event.isCancelled()):
+            owner = block.getOwner()
+            if (owner):
+                msg(sender, "&eThat's %s." % owner)
+            else:
+                msg(sender, "&cThis skull has no name (Steve)")
+            event.setCancelled(True)

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
@@ -18,45 +24,45 @@ upmul  = 0.95  # multiplicate with goup each row
 
 
 def spawn(dispname, sender, x, y, z):
-  """
-  Sends the actual player to sender
-  """
-  server  = bukkit.getServer().getServer()
-  world   = server.getWorldServer(0)                      # main world
-  profile = GameProfile(dispname, dispname)               # set player details
-  manager = PlayerInteractManager(world)
-  entity  = EntityPlayer(server, world, profile, manager) # create Player's entity
-  entity.setPosition(x, y, z)
-  packet  = PacketPlayOutNamedEntitySpawn(entity)         # create packet for entity spawn
-  sender.getHandle().playerConnection.sendPacket(packet)  # send packet
+    """
+    Sends the actual player to sender
+    """
+    server  = bukkit.getServer().getServer()
+    world   = server.getWorldServer(0)                      # main world
+    profile = GameProfile(dispname, dispname)               # set player details
+    manager = PlayerInteractManager(world)
+    entity  = EntityPlayer(server, world, profile, manager) # create Player's entity
+    entity.setPosition(x, y, z)
+    packet  = PacketPlayOutNamedEntitySpawn(entity)         # create packet for entity spawn
+    sender.getHandle().playerConnection.sendPacket(packet)  # send packet
 
 
 @hook.command("spawnplayer")
-def on_spawnplayer_command(sender, args):
-  global amount, row, ground, goup
+def on_spawnplayer_command(sender, command, label, args):
+    global amount, row, ground, goup
 
-  # X and Z position
-  xpos = sender.getLocation().add(-float(row-1 * shift + (amount * margin) / 2), 0, 0).getX()
-  row  = sender.getLocation().add(0, 0, -row).getZ()
+    # X and Z position
+    xpos = sender.getLocation().add(-float(row-1 * shift + (amount * margin) / 2), 0, 0).getX()
+    row  = sender.getLocation().add(0, 0, -row).getZ()
 
-  count = 0
-  stop  = False
-  while not stop:
-    for i in range(amount):
-      player = players[count]
-      x = int(xpos + i*margin)
-      spawn(player, sender, x, ground, row)
-      print(player, x, ground, row)
-      count += 1
-      if count >= len(players):
-        stop = True
-        print "breaking"
-        break
-    print("next row")
-    row -= 1                      # next row (-z)
-    xpos -= shift                 # shift left
-    amount += int(shift*margin*2) # add players left and right
-    if abs(row) % int(goup) == 0:
-      goup   *= upmul
-      ground += 1
-      print "Going up by 1: %s" % ground
+    count = 0
+    stop  = False
+    while not stop:
+        for i in range(amount):
+            player = players[count]
+            x = int(xpos + i*margin)
+            spawn(player, sender, x, ground, row)
+            print(player, x, ground, row)
+            count += 1
+            if count >= len(players):
+                stop = True
+                print "breaking"
+                break
+        print("next row")
+        row -= 1                      # next row (-z)
+        xpos -= shift                 # shift left
+        amount += int(shift*margin*2) # add players left and right
+        if abs(row) % int(goup) == 0:
+            goup   *= upmul
+            ground += 1
+            print "Going up by 1: %s" % ground

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")
+

thread_utils.py

@@ -0,0 +1,24 @@
+import threading
+"""
+Quick implementation of a @synchronized and @asynchronized decorators
+"""
+
+#To be replaced by bukkit scheduler.
+"""
+def sync(lock=None):
+    def decorator(wrapped):
+        def wrapper(*args, **kwargs):
+            with lock:
+                return wrapped(*args, **kwargs)
+        return wrapper
+    return decorator
+"""
+
+def async(daemon = True):
+    def decorator(function):
+        def wrapper(*args,**kwargs):
+            thread = threading.Thread(target=function,args=args,kwargs=kwargs)
+            thread.daemon = daemon
+            thread.start()
+        return wrapper
+    return decorator

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
@@ -9,13 +12,13 @@ from helpers import *
 tilehelpers = open_json_file("tilehelpers", [])
 
 dirmap = {
-  #    [x, y, z]
-  "n": [0, 0, -1],
-  "e": [+1, 0, 0],
-  "s": [0, 0, +1],
-  "w": [-1, 0, 0],
-  "u": [0, +1, 0],
-  "d": [0, -1, 0]
+    #    [x, y, z]
+    "n": [0, 0, -1],
+    "e": [+1, 0, 0],
+    "s": [0, 0, +1],
+    "w": [-1, 0, 0],
+    "u": [0, +1, 0],
+    "d": [0, -1, 0]
 }
 
 # FIXME: disallow multiple regions by single person.
@@ -24,111 +27,111 @@ dirmap = {
 
 @hook.event("block.BlockPlaceEvent", "low")
 def on_place_block(event):
-  if not event.isCancelled():
-    player = event.getPlayer()
-    block  = event.getBlockPlaced()
-    for th in tilehelpers:
-      area = th.get("area")
-      if th.get("owner") == uid(player) and str(block.getWorld().getUID()) == th.get("world") and block.getX() in range(area[0][0], area[0][1]+1) and block.getY() in range(area[1][0], area[1][1]+1) and block.getZ() in range(area[2][0], area[2][1]+1) and event.canBuild():
+    if not event.isCancelled():
+        player = event.getPlayer()
+        block  = event.getBlockPlaced()
+        for th in tilehelpers:
+            area = th.get("area")
+            if th.get("owner") == uid(player) and str(block.getWorld().getUID()) == th.get("world") and block.getX() in range(area[0][0], area[0][1]+1) and block.getY() in range(area[1][0], area[1][1]+1) and block.getZ() in range(area[2][0], area[2][1]+1) and event.canBuild():
 
-        # stack block in directions
-        for direction in th.get("directions"):
-          directions = dirmap[direction]
-          size       = [
-            1 + abs(area[0][1] - area[0][0]),
-            1 + abs(area[1][1] - area[1][0]),
-            1 + abs(area[2][1] - area[2][0])
-          ]
-          against = event.getBlockAgainst()
+                # stack block in directions
+                for direction in th.get("directions"):
+                    directions = dirmap[direction]
+                    size       = [
+                        1 + abs(area[0][1] - area[0][0]),
+                        1 + abs(area[1][1] - area[1][0]),
+                        1 + abs(area[2][1] - area[2][0])
+                    ]
+                    against = event.getBlockAgainst()
 
-          newblock = block.getWorld().getBlockAt(
-            block.getX() + size[0] * directions[0],
-            block.getY() + size[1] * directions[1],
-            block.getZ() + size[2] * directions[2]
-          )
+                    newblock = block.getWorld().getBlockAt(
+                        block.getX() + size[0] * directions[0],
+                        block.getY() + size[1] * directions[1],
+                        block.getZ() + size[2] * directions[2]
+                    )
 
-          newagainst = against.getWorld().getBlockAt(
-            against.getX() + size[0] * directions[0],
-            against.getY() + size[1] * directions[1],
-            against.getZ() + size[2] * directions[2]
-          )
-          newstate = newblock.getState()
-          newstate.setType(block.getType())
-          newstate.setData(block.getState().getData())
+                    newagainst = against.getWorld().getBlockAt(
+                        against.getX() + size[0] * directions[0],
+                        against.getY() + size[1] * directions[1],
+                        against.getZ() + size[2] * directions[2]
+                    )
+                    newstate = newblock.getState()
+                    newstate.setType(block.getType())
+                    newstate.setData(block.getState().getData())
 
-          event = BlockPlaceEvent(newstate.getBlock(), newblock.getState(), newagainst, event.getItemInHand(), player, event.canBuild())
-          server.getPluginManager().callEvent(event)
-          if not event.isCancelled():
-            newblock.setType(block.getType())
-            newblock.setData(block.getData())
+                    event = BlockPlaceEvent(newstate.getBlock(), newblock.getState(), newagainst, event.getItemInHand(), player, event.canBuild())
+                    server.getPluginManager().callEvent(event)
+                    if not event.isCancelled():
+                        newblock.setType(block.getType())
+                        newblock.setData(block.getData())
 
 
 @hook.event("block.BlockBreakEvent", "low")
 def on_break_block(event):
-  if not event.isCancelled():
-    player = event.getPlayer()
-    block  = event.getBlock()
-    for th in tilehelpers:
-      area = th.get("area")
-      if th.get("owner") == uid(player) and str(block.getWorld().getUID()) == th.get("world") and block.getX() in range(area[0][0], area[0][1]+1) and block.getY() in range(area[1][0], area[1][1]+1) and block.getZ() in range(area[2][0], area[2][1]+1):
+    if not event.isCancelled():
+        player = event.getPlayer()
+        block  = event.getBlock()
+        for th in tilehelpers:
+            area = th.get("area")
+            if th.get("owner") == uid(player) and str(block.getWorld().getUID()) == th.get("world") and block.getX() in range(area[0][0], area[0][1]+1) and block.getY() in range(area[1][0], area[1][1]+1) and block.getZ() in range(area[2][0], area[2][1]+1):
 
-        # stack block in directions
-        for direction in th.get("directions"):
-          directions = dirmap[direction]
-          size       = [
-            1 + abs(area[0][1] - area[0][0]),
-            1 + abs(area[1][1] - area[1][0]),
-            1 + abs(area[2][1] - area[2][0])
-          ]
+                # stack block in directions
+                for direction in th.get("directions"):
+                    directions = dirmap[direction]
+                    size       = [
+                        1 + abs(area[0][1] - area[0][0]),
+                        1 + abs(area[1][1] - area[1][0]),
+                        1 + abs(area[2][1] - area[2][0])
+                    ]
 
-          newblock = block.getWorld().getBlockAt(
-            block.getX() + size[0] * directions[0],
-            block.getY() + size[1] * directions[1],
-            block.getZ() + size[2] * directions[2]
-          )
+                    newblock = block.getWorld().getBlockAt(
+                        block.getX() + size[0] * directions[0],
+                        block.getY() + size[1] * directions[1],
+                        block.getZ() + size[2] * directions[2]
+                    )
 
-          event = BlockBreakEvent(newblock, player)
-          server.getPluginManager().callEvent(event)
-          if not event.isCancelled():
-            newblock.setTypeId(0)
+                    event = BlockBreakEvent(newblock, player)
+                    server.getPluginManager().callEvent(event)
+                    if not event.isCancelled():
+                        newblock.setTypeId(0)
 
 
 @hook.event("player.PlayerInteractEvent", "low")
 def on_block_interact(event):
-  action = event.getAction()
-  if not event.isCancelled() and str(action) == "RIGHT_CLICK_BLOCK":
-    player = event.getPlayer()
-    block  = event.getClickedBlock()
-    for th in tilehelpers:
-      area = th.get("area")
-      if th.get("owner") == uid(player) and str(block.getWorld().getUID()) == th.get("world") and block.getX() in range(area[0][0], area[0][1]+1) and block.getY() in range(area[1][0], area[1][1]+1) and block.getZ() in range(area[2][0], area[2][1]+1):
+    action = event.getAction()
+    if not event.isCancelled() and str(action) == "RIGHT_CLICK_BLOCK":
+        player = event.getPlayer()
+        block  = event.getClickedBlock()
+        for th in tilehelpers:
+            area = th.get("area")
+            if th.get("owner") == uid(player) and str(block.getWorld().getUID()) == th.get("world") and block.getX() in range(area[0][0], area[0][1]+1) and block.getY() in range(area[1][0], area[1][1]+1) and block.getZ() in range(area[2][0], area[2][1]+1):
 
-        # stack block in directions
-        for direction in th.get("directions"):
-          directions = dirmap[direction]
-          size       = [
-            1 + abs(area[0][1] - area[0][0]),
-            1 + abs(area[1][1] - area[1][0]),
-            1 + abs(area[2][1] - area[2][0])
-          ]
+                # stack block in directions
+                for direction in th.get("directions"):
+                    directions = dirmap[direction]
+                    size       = [
+                        1 + abs(area[0][1] - area[0][0]),
+                        1 + abs(area[1][1] - area[1][0]),
+                        1 + abs(area[2][1] - area[2][0])
+                    ]
 
-          newblock = block.getWorld().getBlockAt(
-            block.getX() + size[0] * directions[0],
-            block.getY() + size[1] * directions[1],
-            block.getZ() + size[2] * directions[2]
-          )
+                    newblock = block.getWorld().getBlockAt(
+                        block.getX() + size[0] * directions[0],
+                        block.getY() + size[1] * directions[1],
+                        block.getZ() + size[2] * directions[2]
+                    )
 
-          event = PlayerInteractEvent(event.getPlayer(), action, event.getItem(), newblock, event.getBlockFace())
-          server.getPluginManager().callEvent(event)
-          if not event.isCancelled():
-            # FIXME: do not use bukkit API calls outside main thread
-            thread.start_new_thread(update_block, (block, newblock))
+                    event = PlayerInteractEvent(event.getPlayer(), action, event.getItem(), newblock, event.getBlockFace())
+                    server.getPluginManager().callEvent(event)
+                    if not event.isCancelled():
+                        # FIXME: do not use bukkit API calls outside main thread
+                        thread.start_new_thread(update_block, (block, newblock))
 
 
 def update_block(block, newblock):
-  try: # we're in a thread, the universe may hace collapsed in another thread
-    sleep(0.2)
-    newblock.setType(block.getType())
-    newblock.setData(block.getData())
-  except Exception, e:
-    error("Failed to update %s block in %s at %s,%s,%s: '%s'" % (str(block.getType()), block.getWorld().getName(), block.getX(), block.getY(), block.getZ(), e))
+    try: # we're in a thread, the universe may hace collapsed in another thread
+        sleep(0.2)
+        newblock.setType(block.getType())
+        newblock.setData(block.getData())
+    except Exception, e:
+        error("Failed to update %s block in %s at %s,%s,%s: '%s'" % (str(block.getType()), block.getWorld().getName(), block.getX(), block.getY(), block.getZ(), e))

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)

util_events.py

@@ -0,0 +1,80 @@
+from thread_utils import *
+
+MONITOR_PRIORITY = "monitor"
+HIGHEST_PRIORITY = "highest"
+HIGH_PRIORITY    = "high"
+NORMAL_PRIORITY  = "normal"
+LOW_PRIORITY     = "low"
+LOWEST_PRIORITY  = "lowest"
+
+priorities = ["lowest","low","normal","high","highest","monitor"]
+events = []
+
+class base_event():
+    def __init__(self,event_name):
+        self.name = event_name
+        self.cancelled = False
+        self._handlers = [ [],[],[],[],[],[] ]
+
+        self.cancelled_lock = threading.Lock()
+
+    def add_handler(self,function,priority):
+        for prior in priorities:
+            if prior == priority:
+                self._handlers[priorities.index(prior)].append(function)
+
+    def fire(self,*args):
+        for priority in self._handlers:
+            for handler in priority:
+                handler(self,*args)
+
+    def set_cancelled(self,state):
+        with self.cancelled_lock:
+            self.cancelled = state
+
+
+class utils_events(base_event):
+    def __init__(self,event_name):
+        base_event.__init__(self,event_name)
+
+
+def add_event(event_name, event_class = base_event):
+    """
+      # Adds a new event type of the given class with the given name
+    """
+    event = event_class(event_name)
+    events.append(event)
+
+def fire_event(event_name,*args):
+    """
+      # Calls the ehe event with the given arguments
+    """
+    for event in events:
+        if event.name == event_name:
+            event.call(*args)
+            return event
+
+def check_events(event_name):
+    """
+      # Returns whether there is an event with the name event_name
+    """
+    for event in events:
+        if event.name == event_name:
+            return True
+    return False
+
+
+#Decorator
+def utils_event(event_name, priority, create_event=base_event):
+    def event_decorator(function):
+        def wrapper(*args, **kwargs):
+            pass
+
+        if not check_events(event_name): #Check if the event exists, if not create it.
+            add_event(event_name,create_event)
+
+        for event in events: #Go through the list of events, find the one we need and call all of its handlers
+            if event.name == event_name:
+                event.add_handler(function,priority)
+        return wrapper
+    return event_decorator

vanish.py

@@ -0,0 +1,116 @@
+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 I guess.
+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)
+
+
+def get_online_vanished_players():
+    return (player.getPlayer() for player in (retrieve_player(uuid) for uuid in vanished) if player.isOnline())
+
+
+@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):
+    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
+
+    Validate.isTrue(current_state != new_state, "&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")
+
+
+@hook.event("player.PlayerJoinEvent")
+def on_player_join(event):
+    player = event.getPlayer()
+    if not is_authorized(player):
+        for vanished in get_online_vanished_players():
+            player.hidePlayer(vanished)
+
+
+@hook.event("player.PlayerQuitEvent")
+def on_player_quit(event):
+    player = event.getPlayer()
+    if not is_authorized(player):
+        for vanished in get_online_vanished_players():
+            player.showPlayer(vanished)
+
+    elif is_vanished(player):
+        disable_vanish(player)
+
+
+@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
+
+    Validate.isTrue(current_state != new_state, "&cThat player was %s vanished!" % ("already" if current_state else "not yet"))
+    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

@@ -18,96 +18,96 @@ from random import randrange
 
 
 def mysql_query(query, args, fetch = True):
-  conn    = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
-  curs    = conn.cursor()
-  curs.execute(query, args)
-  if fetch:
-    results = curs.fetchall()
-  else:
-    results = conn.commit()
-  curs.close()
-  conn.close()
-  return results
+    conn    = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
+    curs    = conn.cursor()
+    curs.execute(query, args)
+    if fetch:
+        results = curs.fetchall()
+    else:
+        results = conn.commit()
+    curs.close()
+    conn.close()
+    return results
 
 
 def generate_token(length):
-  cons = 'bcdfghjklmnpqrstvwxyz'
-  vows = 'aeiou'
+    cons = 'bcdfghjklmnpqrstvwxyz'
+    vows = 'aeiou'
 
-  token = ''
-  start = randrange(2)
-  for i in range(0, length):
-    if i % 2 == start:
-      token += cons[randrange(21)]
-    else:
-      token += vows[randrange(5)]
-  return token
+    token = ''
+    start = randrange(2)
+    for i in range(0, length):
+        if i % 2 == start:
+            token += cons[randrange(21)]
+        else:
+            token += vows[randrange(5)]
+    return token
 
 
 def get_token(uuid):
-  results = mysql_query("SELECT DISTINCT `token`, `email` FROM register_tokens WHERE `uuid` = ? LIMIT 1", (uuid,))
-  return results[0] if len(results) == 1 else None
+    results = mysql_query("SELECT DISTINCT `token`, `email` FROM register_tokens WHERE `uuid` = ? LIMIT 1", (uuid,))
+    return results[0] if len(results) == 1 else None
 
 
 def token_command(sender):
-  plugin_header(sender, "Website Token")
-  if is_player(sender):
-    try:
-      token = get_token(sender.getUniqueId().toString().replace("-", ""))
-      if token:
-        msg(sender, "&aEmail: &e%s" % token[1])
-        msg(sender, "&aToken: &e%s" % token[0])
-        msg(sender, "&cIMPORTANT: never share the token with anyone!")
-        msg(sender, "&cIt could be used to claim your website account!")
-      else:
-        msg(sender, "&cYou don't have a token yet! Use &e/gettoken <email>&c.")
-    except Exception, e:
-      error(e)
-      msg(sender, "&cError getting your token, please contact an admin!")
-  else:
-    msg(sender, "&cThis is only for players..")
+    plugin_header(sender, "Website Token")
+    if is_player(sender):
+        try:
+            token = get_token(sender.getUniqueId().toString().replace("-", ""))
+            if token:
+                msg(sender, "&aEmail: &e%s" % token[1])
+                msg(sender, "&aToken: &e%s" % token[0])
+                msg(sender, "&cIMPORTANT: never share the token with anyone!")
+                msg(sender, "&cIt could be used to claim your website account!")
+            else:
+                msg(sender, "&cYou don't have a token yet! Use &e/gettoken <email>&c.")
+        except Exception, e:
+            error(e)
+            msg(sender, "&cError getting your token, please contact an admin!")
+    else:
+        msg(sender, "&cThis is only for players..")
 
 
 def tokengen_command(sender, args):
-  plugin_header(sender, "Website Token")
-  if is_player(sender):
-    if len(args) < 1:
-      msg(sender, "&cPlease use &e/gettoken <email adress>")
+    plugin_header(sender, "Website Token")
+    if is_player(sender):
+        if len(args) < 1:
+            msg(sender, "&cPlease use &e/gettoken <email adress>")
+        else:
+            # email may contain spaces
+            mail = " ".join(args)
+            # email regex, needs something followed by an @ followed by domain or IP
+            if match("^.+@(.+\\..{2,}|\\[[0-9a-fA-F:.]+\\])$", mail) != None:
+                token = generate_token(6)
+                uuid  = sender.getUniqueId().toString().replace("-", "")
+                try:
+                    mysql_query("DELETE FROM register_tokens WHERE `uuid` = ?", (uuid,), False)
+                    mysql_query("INSERT INTO register_tokens (`uuid`, `token`, `email`) VALUES (?, ?, ?)", (uuid, token, mail), False)
+                    msg(sender, "&aToken generated!")
+                    msg(sender, "&aEmail: &e%s" % mail)
+                    msg(sender, "&aToken: &e%s" % token)
+                    msg(sender, "&cIMPORTANT: never share the token with anyone!")
+                    msg(sender, "&cIt could be used to claim your website account!")
+                except Exception, e:
+                    error(e)
+                    msg(sender, "&cError getting your token, please contact an admin!")
+            else:
+                msg(sender, "&c'&6%s&c' doesn't look like a valid email adress!" % mail)
     else:
-      # email may contain spaces
-      mail = " ".join(args)
-      # email regex, needs something followed by an @ followed by domain or IP
-      if match("^.+@(.+\\..{2,}|\\[[0-9a-fA-F:.]+\\])$", mail) != None:
-        token = generate_token(6)
-        uuid  = sender.getUniqueId().toString().replace("-", "")
-        try:
-          mysql_query("DELETE FROM register_tokens WHERE `uuid` = ?", (uuid,), False)
-          mysql_query("INSERT INTO register_tokens (`uuid`, `token`, `email`) VALUES (?, ?, ?)", (uuid, token, mail), False)
-          msg(sender, "&aToken generated!")
-          msg(sender, "&aEmail: &e%s" % mail)
-          msg(sender, "&aToken: &e%s" % token)
-          msg(sender, "&cIMPORTANT: never share the token with anyone!")
-          msg(sender, "&cIt could be used to claim your website account!")
-        except Exception, e:
-          error(e)
-          msg(sender, "&cError getting your token, please contact an admin!")
-      else:
-        msg(sender, "&c'&6%s&c' doesn't look like a valid email adress!" % mail)
-  else:
-    msg(sender, "&cThis is only for players..")
+        msg(sender, "&cThis is only for players..")
 
 
 
 @hook.command("token")
-def on_token_command(sender, args):
-  thread.start_new_thread(token_command, (sender,))
-  return True
+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):
-  thread.start_new_thread(tokengen_command, (sender, args))
-  return True
+def on_gettoken_command(sender, command, label, args):
+    thread.start_new_thread(tokengen_command, (sender, args))
+    return True
 
 
 

wrapper.py

@@ -0,0 +1,12 @@
+"""
+Adapter classes for spigot api for more idiomatic python code.
+
+Before you run away from this if the class you need to use isn't here, please create it.
+
+
+"""
+from helpers import *
+from wrapper_event import *
+from wrapper_player import *
+from wrapper_command import *
+from util_events import utils_event, fire_event, utils_events

wrapper_command.py

@@ -0,0 +1,328 @@
+from wrapper_player import *
+from helpers import *
+
+class Command(object):
+    """
+      # Documentation to come.s
+    """
+
+    SENDER_ANY = 0
+    SENDER_PLAYER = 1
+    SENDER_CONSOLE = 2
+
+    ACTION_IGNORE = 3
+    ACTION_SYNTAXERROR = 4
+    ACTION_DISPLAYSYNTAX = 5
+    ACTION_DISPLAYHELP = 6
+
+    def __init__(self,
+                command, 
+                parent = None,
+                aliases = tuple(), 
+                permission = None,
+                description = "Description",
+                type = 0, 
+                no_arg_action = 3,
+                help_request_action = 3,
+                arguments = tuple(), 
+        ):
+
+        self.command = command.lower()
+        self.aliases = tuple(alias.lower() for alias in aliases)
+        self.description = description
+        self.type = type
+        self.no_arg_action = no_arg_action
+        self.help_request_action = help_request_action
+        self.arguments = arguments
+        self.parent = parent
+        self.sub_commands = Command_dict()
+
+        # ---- Check if argument layout is valid ----
+        prev_arg = arguments[0] if len(arguments) > 0 else None
+        for arg_info in arguments[1:]:
+
+            if not prev_arg.required and arg_info.required:
+                raise Argument_exception("Command: %s; There may not be required arguments after non-required arguments" % command)
+
+            if prev_arg.type == Argument.MESSAGE:
+                raise Argument_exception("Command: %s; An argument of type MESSAGE may not be followed by other arguments" % command)
+
+            prev_arg = arg_info
+
+        # ---- Add self to parent sub_commands and set permission node ----
+        perm_builder = "utils"
+        if self.parent == None:
+            root_commands[self.command] = self
+        else:
+            try:
+                parent_route = self.parent.split(" ")
+                parent_sub_commands = root_commands
+                parent_obj = None
+                for cmd_name in parent_route:
+                    parent_obj = parent_sub_commands[cmd_name]
+                    parent_sub_commands = parent_obj.sub_commands
+
+                parent_obj.sub_commands[self.command] = self
+
+            except KeyError as e:
+                raise Argument_exception("Error occurred while setting up command hierarchy: " + e.message + "\n" + trace())
+
+        perm_builder += "." + (permission if permission else command).lower()
+
+    def __call__(self, handler):
+        """
+          # To clarify: This function is called when you 'call' an instance of a class.
+          # This means, that Command() calls __init__() and Command()() calls __call__().
+          # This makes it possible to use class instances for decoration. The decorator is this function.
+        """
+        self.handler = handler
+
+        if self.parent == None:
+            @hook.command(self.command, aliases = self.aliases)
+            def run(sender, command, label, args):
+                """
+                  # This function will take care of prefixing and colouring of messages in the future.
+                  # So it's very much WIP.
+                """
+                try:
+                    message = self.execute(sender, command, label, args)
+                except Command_exception as e:
+                    message = e.message
+                except Argument_exception as e:
+                    message = e.message
+                except Exception:
+                    error(trace())
+                    return True
+                if message:
+                    sender.sendMessage(message)
+                return True
+
+        return handler
+
+    def execute(self, sender, command, label, args):
+        try:
+            return self.sub_commands[args[0].lower()].execute(sender, command, label, args[1:])
+        except (KeyError, IndexError):
+            return self.execute_checks(sender, command, label, args)
+
+    def execute_checks(self, sender, command, label, args):
+
+        # ---- Check sender type ----
+        if is_player(sender):
+            Validate.is_true(self.type != Command.SENDER_CONSOLE, "That command can only be used by the console")
+            #sender = py_players.__getattr__(sender)
+        else:
+            Validate.is_true(self.type != Command.SENDER_PLAYER, "That command can only be used by players")
+
+        # ---- Check permission ----
+        Validate.is_authorized(sender, self.permission)
+
+        # ---- Check if a help message is expected ----
+        if len(args) == 0:
+            action = self.no_arg_action
+        elif args[0].lower() == "help":
+            action = self.help_request_action
+        else:
+            action = Command.ACTION_IGNORE
+
+        if action != Command.ACTION_IGNORE:
+            if action == Command.ACTION_SYNTAXERROR:
+                return "&cInvalid syntax, please try again."
+            if action == Command.ACTION_DISPLAYSYNTAX:
+                return self.syntax()
+            if action == Command.ACTION_DISPLAYHELP:
+                return self.help()
+
+        # ---- Set up passed arguments, prepare for handler call ----
+        scape = Command_scape(args, self.arguments, command, label)
+        if is_player(sender):
+            #sender = py_players[sender]
+            pass
+
+        return self.handler(sender, self, scape)
+        # @Command("hello") def on_hello_command(sender, command, scape/args)
+
+    def syntax(self):
+        return " ".join(tuple(arg_info.syntax() for arg_info in self.arguments))
+
+    def help(self):
+        syntax = self.syntax()
+        return syntax #WIP...
+
+class Argument():
+
+    """
+      # A more advanced implementation of amin and amax, though it doesn't do exactly the same.
+      # You can now pass a list of Argument objects which define what the argument represents.
+      # In the process of doing so, you can set an argument type, one of the ones mentioned below.
+      # For example, if Argument.PLAYER is given, the server will be searched for the given player, and
+      # they will be passed as the argument, instead of a string representing their name.
+      #
+      # Feel free to add your own argument types. If you want to make a change to the API to make it different,
+      # please don't do so on your own behalf.
+    """
+
+    STRING = 0
+    INTEGER = 1
+    FLOAT = 2
+    PLAYER = 3
+    OFFLINE_PLAYER = 4
+    MESSAGE = 5
+
+    def __init__(self, name, type, definition, required = True):
+        self.name = name
+        self.type = type
+        self.definition = definition
+        self.required = required
+
+    def syntax(self):
+        syntax = self.name
+        if self.type == Argument.MESSAGE:
+            syntax += "..."
+        return (("<%s>" if self.required else "[%s]") % syntax)
+
+class Validate():
+
+    """
+      # Much like what you often see in Java.
+      # Instead of having to check if a condition is met, and if not,
+      # sending the player a message and returning true,
+      # You can use one of these methods to check the condition, and
+      # pass a message if it's not met.
+      #
+      # For example:
+      # > if not sender.hasPermission("utils.smth"):
+      #       noperm(sender)
+      #       return True
+      #
+      # Can be replaced with:
+      # > Validate.is_authorized(sender, "utils.smth")
+      #
+    """
+
+    @staticmethod
+    def is_true(expression, fail_message):
+        if not expression:
+            raise Command_exception(fail_message)
+
+    @staticmethod
+    def not_none(obj, fail_message):
+        if obj == None:
+            raise Command_exception(fail_message)
+
+    @staticmethod
+    def is_authorized(player, permission, msg = "You do not have permission to use that command"):
+        if not player.hasPermission(permission):
+            raise Command_exception(msg)
+
+    @staticmethod
+    def is_player(sender):
+        if not is_player(sender):
+            raise Command_exception("That command can only be used by players")
+
+    @staticmethod
+    def is_console(sender):
+        if is_player(sender):
+            raise Command_exception("That command can only be used by the console")
+
+"""
+  # ---------- API classes ----------
+"""
+
+class Command_dict(dict):
+    #{"cmd1" : cmd_object}
+    def __getattr__(self, alias):
+        for cmd_name, cmd_obj in self.iteritems():
+            if alias == cmd_name or alias in cmd_obj.aliases:
+                return cmd_obj
+        raise KeyError("Subcommand '%s' was not found" % alias)
+
+root_commands = Command_dict() # {"command": command_object}
+
+class Command_exception(Exception):
+
+    def __init__(self, message):
+        self.message = message
+
+class Command_scape(list):
+
+    def __init__(self, args, arg_layout, command, label):
+        super(list, self).__init__()
+        self.raw = args
+        self.arg_layout = arg_layout
+        self.command = command
+        self.label = label
+
+        has_message = False
+        for i in range(len(arg_layout)):
+            arg_info = arg_layout[i]
+
+            given = (len(args) >= i + 1)
+            if arg_info.required and not given:
+                raise Argument_exception("You must specify the " + arg_info.name)
+
+            if not given:
+                self.append(None)
+                continue
+
+            given_arg = args[i]
+            arg_type = arg_info.type
+
+            if arg_type == Argument.STRING:
+                self.append(given_arg)
+
+            elif arg_type == Argument.INTEGER:
+                try:
+                    value = int(given_arg)
+                except ValueError:
+                    raise Argument_exception("The %s has to be a round number" % arg_info.name)
+                self.append(value)
+
+            elif arg_type == Argument.FLOAT:
+                try:
+                    value = float(given_arg)
+                except ValueError:
+                    raise Argument_exception("The %s has to be a number" % arg_info.name)
+                self.append(value)
+
+            elif arg_type == Argument.PLAYER:
+                target = server.getPlayer(given_arg)
+                if target == None:
+                    raise Argument_exception("The %s has to be an online player" % arg_info.name)
+                self.append(target)
+                #self.append(py_players[target])
+
+            elif arg_type == Argument.OFFLINE_PLAYER:
+                try:
+                    # Code to get the PY PLAYER by name. Possibly, uid(server.getOfflinePlayer(given_arg)) can be used?
+                    pass
+                except KeyError:
+                    raise Argument_exception("The %s has to be an existing player" % arg_info.name)
+                self.append(None)
+
+            elif arg_type == Argument.MESSAGE:
+                self.append(" ".join(args[i:]))
+                has_message = True
+            else:
+                error("Argument type not found: %d" % arg_type)
+                raise Argument_exception("A weird thing has happened, please contact an administrator")
+
+        if not has_message:
+            self.remainder = args[len(arg_layout):]
+        else:
+            self.remainder = None
+
+    def has_flag(self, flag, check_all = False):
+        return (("-" + flag) in self.raw) if check_all else (("-" + flag) in self.remainder)
+
+    def get_raw(self):
+        return self.raw
+
+    def get_arg_layout(self):
+        return self.arg_layout
+
+class Argument_exception(Exception):
+
+    def __init__(self, message):
+        self.message = message
+

wrapper_event.py

@@ -0,0 +1,56 @@
+from wrapper import *
+from util_events import utils_event, utils_events
+from wrapper_player import *
+from traceback import format_exc as print_traceback
+
+class py_event(object):
+    def __init__(self,event):
+        self.event = event
+        try:
+            self.player = py_players[event.getPlayer()]
+        except:
+            warn("Player doesn't exist")
+
+    @property
+    def cancelled(self):
+        return self.event.isCancelled()
+
+    @cancelled.setter
+    def cancelled(self, value):
+        self.event.setCancelled(value)
+
+    @property
+    def message(self):
+        try:
+            return self.event.getMessage()
+        except:
+            raise AttributeError
+    
+    @message.setter
+    def message(self, msg):
+        try:
+            self.event.setMessage(msg)
+        except:
+            raise AttributeError
+
+def event_handler(event_name = None, priority = "normal", utils = False):
+    if not utils:
+        def decorator(wrapped):
+            @hook.event(event_name, priority)
+            def wrapper(event):
+                try:
+                    wrapped(py_event(event))
+                except:
+                    print(print_traceback())
+        return decorator
+    elif utils:
+        def decorator(wrapped):
+            @utils_event(event_name, priority, create_event = utils_events)
+            def wrapper(*args):
+                try:
+                    wrapped(*args)
+                except:
+                    print(print_traceback())
+        return decorator
+
+

wrapper_player.py

@@ -0,0 +1,186 @@
+import time
+import mysqlhack
+from mysql_utils import *
+from util_events import fire_event
+from thread_utils import *
+#from players_secret import *
+from datetime import datetime
+from com.ziclix.python.sql import zxJDBC
+from traceback import format_exc as print_traceback
+
+class py_player(object):
+    def __init__(self,player):
+        self.player = player
+        self.logging_in = True
+        self.authenticated = False
+        self.login_time = time.time()
+        
+        self.props = {
+            "uuid":self.uuid,
+            "name":self.name,
+            "nickname":self.name,
+            "registered":False,
+            "password":"None",
+            "banned":False,
+            "banned_reason":None,
+            "played_time":time.time() - self.login_time,
+            "last_login":datetime.now(),
+            "first_seen":datetime.now(),
+        }
+
+    def __setattr__(self, attribute, value):
+        if not attribute in dir(self):
+            if not 'props' in self.__dict__:
+                self.__dict__[attribute] = value
+            else:
+                self.props[attribute] = value
+        else:
+            object.__setattr__(self, attribute, value)
+
+    def __getattr__(self, attribute):
+        try:
+            return self.props[attribute]
+        except:
+            raise AttributeError("Attribute %s does not exist on this py_player" % attribute)
+            
+    def save(self):
+        properties = []
+        keys = []
+        columns = []
+
+        with mysql_connect() as sql:
+            columns = sql.columns
+        
+        for key, value in self.props.items():
+            if key not in columns:
+                with mysql_connect() as sql:
+                    if isinstance(value, int):
+                        sql.execute("ALTER TABLE utils_players ADD %s INT" % key)
+                    elif isinstance(value, str):
+                        sql.execute("ALTER TABLE utils_players ADD %s TEXT" % key)
+                    elif isinstance(value, bool):
+                        sql.execute("ALTER TABLE utils_players ADD %s TINYINT(1)" % key)
+            if key == "uuid":
+                continue
+            keys.append(key+"=?")
+            properties.append(value)
+            print value
+        properties.append(self.props["uuid"])
+        keys = str(tuple(keys)).replace("\'","").replace("(","").replace(")","")
+
+
+        with mysql_connect() as sql:
+            sql.execute("UPDATE utils_players set %s WHERE uuid = ?" % keys, properties)
+
+
+    def kick(self, kick_message = "You have been kicked from the server!"):
+        self.player.KickPlayer(kick_message)
+
+    def msg(self, message):
+        self.player.sendMessage(message)
+
+    @property
+    def name(self):
+        return self.player.getName()
+
+    @property
+    def uuid(self):
+        return str(self.player.getUniqueId())
+ 
+    
+
+class Py_players:
+    def __init__(self):
+        self.players = []
+
+    def __len__(self):
+        return len(self.players)
+
+    def __getitem__(self, player):
+        for py_player in self.players:
+            if py_player.name == player.getName():
+                return py_player
+        else:
+            return None
+
+    def remove(self, player):
+        self.players.remove(player)
+
+    def append(self, player):
+        self.players.append(player)
+
+py_players = Py_players()
+
+@async(daemon=True)
+def fetch_player(player):
+    properties = []
+    keys = []
+    for key, value in player.props.iteritems():
+        keys.append(key)
+        properties.append(value)
+
+    with mysql_connect() as sql:
+        sql.execute("SELECT * FROM utils_players WHERE uuid = ?", (player.uuid,))
+        result = sql.fetchall()
+
+    if len(result) is 0:
+        with mysql_connect() as sql:
+            sql.execute("INSERT INTO utils_players %s \
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)" % str(tuple(keys)).replace("\'","")
+                ,args=tuple(properties))
+
+    elif len(result) is 1:
+        keys = []
+        props = result[0]
+        with mysql_connect() as sql:
+            sql.execute("SHOW COLUMNS FROM utils_players")
+            result = sql.fetchall()
+            for row in result:
+                keys.append(row[0]) 
+
+        for key in keys:
+            player.props[key] = props[keys.index(key)]
+
+        for prop in properties:
+            print str(prop)
+
+    else:
+        player.kick("Something went wrong while loading your player data, please contact an admin")
+        return
+    
+    player.logging_in = False
+    player.msg("You have succesfully logged into redstoner!")
+    fire_event("player_login", player)
+
+
+
+
+blocked_events = ["block.BlockBreakEvent", "block.BlockPlaceEvent", "player.PlayerMoveEvent",
+                    "player.AsyncPlayerChatEvent","player.PlayerTeleportEvent",
+                    "player.PlayerCommandPreprocessEvent", "player.PlayerInteractEvent"]
+
+for event in blocked_events:
+    @hook.event(event,"highest")
+    def on_blocked_event(event):
+        """player = py_players[event.getPlayer()]
+                                if player.logging_in:
+                                    event.setCancelled(True)"""
+        pass
+
+
+
+@hook.event("player.PlayerJoinEvent","lowest")
+def on_join(event):
+    try:
+        player = py_player(event.getPlayer())
+    except:
+        error(print_traceback())
+        time.sleep(10)
+    py_players.append(player)
+    player.msg("Your input will be blocked for a short while")
+    #fetch_player(player)
+
+
+@hook.event("player.PlayerQuitEvent","highest")
+def on_leave(event):
+    py_players.remove(py_players[event.getPlayer()])