use directory (untested!)

- avoid long methods
- clarify errors
- better traceback example

.gitignore

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

CONTRIBUTING.md

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

LICENSE.md

@@ -1,21 +0,0 @@
-# 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,8 +2,245 @@
 
 Redstoner's custom plugins, written in python.
 
-------
 
-## Contributing
+# Installation / Set-up
 
-If you want to contribute, please [read through the pages on the wiki](https://github.com/RedstonerServer/redstoner-utils/wiki).
+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())
+```

abot.py

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

adminchat.py

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

adminnotes.py

@@ -1,134 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

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

calc.py

@@ -1,110 +0,0 @@
-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

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

chatgroups.py

@@ -1,28 +1,20 @@
 #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_defaultkey  = ":"
-cg_keys        = open_json_file("chatgroup_keys", {})
+cg_key         = ":"
 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, command, label, args):
+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)
-            if sender in cg_toggle_list:
-                cg_toggle_list.remove(p)
       group = groups[sender_id]
       del(groups[sender_id])
       save_groups()
@@ -32,7 +24,12 @@ def on_chatgroup_command(sender, command, label, args):
     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]
+      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:
@@ -42,25 +39,15 @@ def on_chatgroup_command(sender, command, label, args):
     groupchat(sender, "joined the group", True)
     save_groups()
     msg(sender, "&aYour chatgroup is set to '%s'" % args[1])
-        msg(sender, "&aUse chat like '&e%s<message>' to send messages to this group." % 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")
+    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 key")
-        msg(sender, "&e/chatgroup tpahere")
 
 
 @hook.command("cgt")
-def on_cgt_command(sender, command, label, args):
+def on_cgt_command(sender, args):
   p = uid(sender)
   if p in cg_toggle_list:
     cg_toggle_list.remove(p)
@@ -81,19 +68,11 @@ def groupchat(sender, message, ann = False):
     mesg = "&8[&bCG&8] &e&o%s&e&o %s" % (name, message)
   else:
     mesg = "&8[&bCG&8] &f%s&f: &6%s" % (name, message)
-    mesg = colorify(mesg)
-    
   info("[ChatGroups] %s (%s): %s" % (sender.getDisplayName(), group, message))
-    do_for_chatgroup(group, msg, mesg, usecolor = False)
-
-def do_for_chatgroup(group, func, *args, **kwargs):
   for receiver in server.getOnlinePlayers():
-        if groups.get(uid(receiver)) == group:
-            func(receiver, *args, **kwargs)
+    groups.get(uid(receiver)) == group and msg(receiver, mesg)
+
 
-def send_tpa_request(receiver, sender):
-    if not receiver == sender:
-        runas(sender, "/tpahere " + receiver.getName())
 
 def save_groups():
   save_json_file("chatgroups", groups)
@@ -102,37 +81,12 @@ def save_groups():
 @hook.event("player.AsyncPlayerChatEvent", "normal")
 def on_chat(event):
   sender = event.getPlayer()
-    user = get_py_player(sender)
   msge = event.getMessage()
-    if (not user.logging_in) and (not event.isCancelled()):
+  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:])
+    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)
-
-@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

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

cycle.py

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

damnspam.py

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

forcefield.py

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

friends.py

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

helpers.py

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

imbusy.py

@@ -1,318 +0,0 @@
-"""
-This plugin permits users to   
-send a command that renders    
-them "busy", not letting them  
-to get tpa requests or direct 
-messages, except from console. 
-On restart, all busy data will 
-be cleared.                    
-"""
-
-from helpers import *
-from friends import is_friend_of
-import org.bukkit.command.Command as Command
-from time import time as now
-
-imbusy_version = "v1.1.0"
-
-base_permission = "utils.imbusy" # for /busy status
-use_permission = "utils.imbusy.use" # for being busy
-override_permission = "utils.imbusy.override" # for being able to bother busy people
-
-busy_status_change_timeout = 15 # seconds
-
-busy_players = {} # name : (status, timeout_expire)
-# possible statuses: True if SUPER busy, False if normal busy, None if not busy
-
-
-@hook.command("imbusy",
-    aliases = ["busy"],
-    usage = "/<command> [on, off, status/check]",
-    description = "Offers control over your busy status"
-    )
-@debug
-def on_busy_command(sender, cmd, label, args):
-    if not is_player(sender):
-        msg(sender, "&7Sorry, Console cannot be busy")
-        return True
-
-    plugin_header(recipient = sender, name = "I'M BUSY!")
-
-    if not sender.hasPermission(base_permission):
-        noperm(sender)
-        return True
-
-    if len(args) == 0:
-        return toggle(sender)
-
-    arg0 = args[0].lower()
-    if arg0 == "on":
-        return on(sender)
-    if arg0 == "off":
-        return off(sender)
-    if arg0 in ("status", "check"):
-        return status(sender, args[1:])
-    if arg0 == "super":
-        return super_cmd(sender)
-    return help(sender)
-
-
-def change_status(target, status):
-    target_name = target.getName()
-    old_status = None
-    if target_name in busy_players:
-        value = busy_players[target_name]
-        time_left = value[1] - now()
-        if time_left > 0:
-            msg(target, "&cYou must wait %.2fs untill you can change your status" % time_left)
-            return
-        old_status = value[0]
-
-    if old_status is status:
-        if status is True:
-            msg(target, "&cYou are already SUPER busy")
-        elif status is False:
-            msg(target, "&cYou are already busy")
-        else:
-            msg(target, "&cYou weren't busy yet")
-        return
-
-    busy_players[target_name] = (status, now() + busy_status_change_timeout)
-    if status is True:
-        broadcast(None, target.getDisplayName() + " &7is now SUPER busy")
-    elif status is False:
-        broadcast(None, target.getDisplayName() + " &7is now busy")
-    else:
-        broadcast(None, target.getDisplayName() + " &7is not busy anymore")
-
-
-def get_status(target):
-    return busy_players.get(target.getName(), (None,))[0]
-
-
-def toggle(sender):
-    if not sender.hasPermission(use_permission):
-        noperm(sender)
-        return True
-    if get_status(sender) is None:
-        change_status(sender, False)
-    else:
-        change_status(sender, None)
-    return True
-
-
-def help(sender):
-    msg(sender, "Let's you put yourself in busy status, preventing pms and tpa requests from other players")
-    msg(sender, "\n&eCommands:")
-    msg(sender, "&e/busy &7- Toggles busy status")
-    msg(sender, "&e/busy on &7- Turns on busy status")
-    msg(sender, "&e/busy off &7- Turns off busy status")
-    msg(sender, "&e/busy status [player] &7- shows your or [player]'s current busy status")
-    msg(sender, "&e/busy super &7- sets your status to SUPER busy such that even friends can not bother you")
-    return True
-
-
-def on(sender):
-    if not sender.hasPermission(use_permission):
-        noperm(sender)
-        return True
-    change_status(sender, False)
-    return True
-
-
-def off(sender):
-    if not sender.hasPermission(use_permission):
-        noperm(sender)
-        return True
-    change_status(sender, None)
-    return True
-
-
-def status(sender, args):
-    if not sender.hasPermission(base_permission):
-        noperm(sender)
-        return True
-    if len(args) == 0:
-        target = sender
-    else:
-        target = server.getPlayer(args[0])
-        if target is None:
-            msg(sender, "&cThat player is not online")
-            return True
-    status = get_status(target)
-    if status is True:
-        status_str = "SUPER busy"
-    elif status is False:
-        status_str = "busy"
-    else:
-        status_str = "not busy"
-    msg(sender, "&7%s currently %s" % ("You are" if target is sender else "Player %s&7 is" % target.getDisplayName()), status_str)
-    return True
-
-
-def super_cmd(sender):
-    if not sender.hasPermission(use_permission):
-        noperm(sender)
-        return True
-    change_status(sender, True)
-    return True
-
-
-@hook.event("player.PlayerQuitEvent", "lowest")
-def on_player_leave(event):
-    player_name = event.getPlayer().getName()
-    if player_name in busy_players:
-        del busy_players[player_name]
-
-
-# Block any bothering if should be. If a busy player msgs someone else, they can be replied to and /msg'd as well.
-# It's not entirely perfect in that regard as the ability to reply is lost when you are /msg'd by someone else. 
-
-reply_targets = {} # name : (reply_target_name, true if initiated by target)
-
-
-def can_send(sender, target):
-    if target is sender or sender.hasPermission(override_permission):
-        return True
-    status = get_status(target)
-    if status is None:
-        return True
-    return status is False and is_friend_of(target, sender)
-
-
-def whisper(sender, target_name):
-    target = server.getPlayer(target_name)
-
-    if target is not None:
-        sender_name = sender.getName()
-        if not can_send(sender, target):
-            value = reply_targets[sender_name]
-            if value[0] != target_name or value[1] is False:
-                msg(sender, "&c[&fBUSY&c] %s&r is busy!" % target.getDisplayName())
-                return False
-
-        reply_targets[sender_name] = (target_name, False)
-        reply_targets[target_name] = (sender_name, True)
-    return True
-
-
-def reply(sender):
-    sender_name = sender.getName()
-    if sender_name in reply_targets:
-        value = reply_targets[sender_name]
-        target = server.getPlayer(value[0])
-        if target is not None: 
-            if not value[1] and not can_send(sender, target):
-                msg(sender, "&c[&fBUSY&c] %s&r is busy!" % target.getDisplayName())
-                return False
-
-            reply_targets[target.getName()] = (sender_name, True)
-    return True
-
-
-class CommandWrapper(Command):
-
-    def __init__(self, wrapped, checker):
-        Command.__init__(self, wrapped.getName())
-        self.setDescription(wrapped.getDescription())
-        self.setPermission(wrapped.getPermission())
-        self.setUsage(wrapped.getUsage())
-        self.setAliases(wrapped.getAliases())
-        self.wrapped = wrapped
-        self.checker = checker
-
-    def execute(self, sender, label, args):
-        try:
-            if not is_player(sender) or self.checker(sender, args):
-                return self.wrapped.execute(sender, label, args)
-        except:
-            error(trace())
-        return True
-
-    def tabComplete(self, sender, alias, args):
-        return self.wrapped.tabComplete(sender, alias, args)
-
-
-def msg_command_checker(sender, args):
-    return len(args) <= 1 or whisper(sender, args[0])
-
-def reply_command_checker(sender, args):
-    return len(args) == 0 or reply(sender)
-
-def tpa_command_checker(sender, args):
-    if len(args) == 0:
-        return True
-    target = server.getPlayer(args[0])
-    if target is not None and not can_send(sender, target):
-        msg(sender, "&c[&fBUSY&c] %s&r is busy!" % target.getDisplayName())
-        return False
-    return True
-
-def tpahere_command_checker(sender, args):
-    return tpa_command_checker(sender, args)
-
-def mail_command_checker(sender, args):
-    if len(args) < 3 or args[0].lower() != "send":
-        return True
-    target = server.getPlayer(args[1])
-    if target is not None and not can_send(sender, target):
-        msg(sender, "&c[&fBUSY&c] %s&r is busy!" % target.getDisplayName())
-        return False
-    return True
-
-
-@hook.event("player.PlayerCommandPreprocessEvent", "monitor")
-def on_player_command_preprocess(event):
-    message = event.getMessage().split(" ")
-    if len(message) > 1 and message[0].lower() in ("/tell", "/minecraft:tell") and not whisper(event.getPlayer(), message[1]):
-        event.setCancelled(True)
-
-
-def replace_ess_commands():
-
-    try:
-        map_field = server.getPluginManager().getClass().getDeclaredField("commandMap")
-        map_field.setAccessible(True)
-        command_map = map_field.get(server.getPluginManager())
-
-        commands_field = command_map.getClass().getDeclaredField("knownCommands")
-        commands_field.setAccessible(True)
-        map = commands_field.get(command_map)
-
-        ess_msg_cmd = map.get("essentials:msg")
-        ess_reply_cmd = map.get("essentials:reply")
-        ess_tpa_cmd = map.get("essentials:tpa")
-        ess_tpahere_cmd = map.get("essentials:tpahere")
-        ess_mail_cmd = map.get("essentials:mail")
-
-        msg_cmd_wrapper = CommandWrapper(ess_msg_cmd, msg_command_checker)
-        reply_cmd_wrapper = CommandWrapper(ess_reply_cmd, reply_command_checker)
-        tpa_cmd_wrapper = CommandWrapper(ess_tpa_cmd, tpa_command_checker)
-        tpahere_cmd_wrapper = CommandWrapper(ess_tpahere_cmd, tpahere_command_checker)
-        mail_cmd_wrapper = CommandWrapper(ess_mail_cmd, mail_command_checker)
-
-        iterator = map.entrySet().iterator()
-        wrapped_commands = []
-        while iterator.hasNext():
-            entry = iterator.next()
-            value = entry.getValue()
-            changed = True
-            if value is ess_msg_cmd:
-                entry.setValue(msg_cmd_wrapper)
-            elif value is ess_reply_cmd:
-                entry.setValue(reply_cmd_wrapper)
-            elif value is ess_tpa_cmd:
-                entry.setValue(tpa_cmd_wrapper)
-            elif value is ess_tpahere_cmd:
-                entry.setValue(tpahere_cmd_wrapper)
-            elif value is ess_mail_cmd:
-                entry.setValue(mail_cmd_wrapper)
-            else:
-                changed = False
-            if changed:
-                wrapped_commands.append(entry.getKey())
-        info("[imbusy] wrapped commands: /" + ", /".join(wrapped_commands))
-
-    except:
-        error("[Imbusy] Failed to wrap essentials commands")
-        error(trace())

imout.py

@@ -1,32 +0,0 @@
-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

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

lagchunks.py

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

loginsecurity.py

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

main.py

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

mentio.py

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

misc.py

@@ -1,205 +1,128 @@
 #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):
-    """
-    Welcome new players
-    """
   player = event.getPlayer()
 
   # send welcome broadcast
   if not player.hasPlayedBefore():
-        broadcast("utils.greet_new", "\n&a&lPlease welcome &f" + player.getDisplayName() + " &a&lto Redstoner!\n")
+    broadcast("utils.greet_new", "")
+    broadcast("utils.greet_new", "&a&lPlease welcome &f" + player.getDisplayName() + " &a&lto Redstoner!")
+    broadcast("utils.greet_new", "")
 
     # 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, "  &6look at the &a&l/FAQ &6command.")
     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 "PORTAL" in [str(headloc), str(loginloc)]:
+  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())
 
-"""
-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:]))
-
-
-
-
-""" 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"):
+@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
-    parts = material.split("_")
-    length = len(parts)
-    return length > 1 and (parts[0] == "DIODE" or parts[1] in ("TORCH", "WIRE", "BUTTON", "HOOK") or (length == 3 and parts[1] == "COMPARATOR"))
-
-
-@hook.event("player.PlayerInteractEvent")
-def on_interact(event):
-    if (not event.isCancelled()
-        and str(event.getAction()) == "RIGHT_CLICK_BLOCK"
-        and str(event.getMaterial()) in ("REDSTONE_COMPARATOR_OFF", "REDSTONE_COMPARATOR_ON")
-        and not can_build(player, event.getClickedBlock())
-    ):
-        event.setCancelled(True)
-
-
-sudo_blacklist = ["pyeval", "script_backup_begin", "script_backup_end", "script_backup_error", "script_backup_database_begin", "script_backup_database_dumps", "script_backup_database_end",
-"script_backup_database_error", "script_backup_database_abort", "script_trim", "script_trim_result", "script_spigot_update", "script_disk_filled", "script_restart", "script_restart_abort",
-"script_stop", "script_stop_abort", "script_shutdown", "stop", "esudo", "essentials:sudo", "sudo", "essentials:esudo"]
-
-@simplecommand("sudo",
-        usage        = "<player> [cmd..]",
-        description  = "Makes <player> write [cmd..] in chat",
-        amin         = 2,
-        helpNoargs   = True)
-def on_sudo_command(sender, command, label, args):
     target = args[0]
+
     cmd =  " ".join(args[1:])
-    msg(sender, "&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
+    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
 
 
+#
+# Clicking redstone_sheep with shears will drop redstone + wool and makes a moo sound
+#
 
-@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
+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)
 
 
+#
+# /pluginversions - print all plugins + versions; useful when updating plugins
+#
 
 @hook.command("pluginversions")
-def on_pluginversions_command(sender, command, label, args):
-    """
-    /pluginversions
-    print all plugins + versions; useful when updating plugins
-    """
-    try:
+def on_pluginversions_command(sender, args):
   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 = 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" + pl.getDescription().getName() + "&r: &e" + pl.getDescription().getVersion())
+    msg(sender, "&6" + plugin.getDescription().getName() + "&r: &e" + plugin.getDescription().getVersion())
   return True
-    except:
-        error(trace())
 
 
+#
+# /echo - essentials echo sucks and prints mail alerts sometimes
+#
+
 @hook.command("echo")
-def on_echo_command(sender, command, label, args):
-    """
-    /echo
-    essentials echo sucks and prints mail alerts sometimes
-    """
+def on_echo_command(sender, args):
   msg(sender, " ".join(args).replace("\\n", "\n"))
 
 
+#
+# /pyeval - run python ingame
+#
+# has to be in main.py so we can access the modules
 
 def eval_thread(sender, code):
-    """
-    /pyeval
-    run python ingame
-    """
   try:
     result = eval(code)
     msg(sender, ">>> %s: %s" % (colorify("&3") + type(result).__name__, colorify("&a") + unicode(result) + "\n "), usecolor = False)
@@ -212,102 +135,22 @@ def eval_thread(sender, code):
     msg(sender, ">>> %s: %s" % (eclass.__name__, e) + "\n ", False, "c")
   thread.exit()
 
-pythoners = (
-    "e452e012-2c82-456d-853b-3ac8e6b581f5", # Nemes
-    "ae795aa8-6327-408e-92ab-25c8a59f3ba1", # jomo
-    "d2693e91-93e1-4e3f-929f-f38e1ce8df03", # Pepich1851
-    "51f2ad3c-6cc8-40ea-aa2b-f25970316921", # Dico200
-    "15ad0e60-8691-4e29-9de9-2d6b538bf56d"  # psrcek
-)
 
-@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")
+@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")
     thread.start_new_thread(eval_thread, (sender, " ".join(args)))
-    return None
-
-
-
-@simplecommand("tempadd",
-        usage       = "<user> <group> [duration]",
-        description = "Temporarily adds <user> to <group> for \n[duration] minutes. Defaults to 1 week.",
-        helpNoargs  = True,
-        helpSubcmd  = True,
-        amin        = 2,
-        amax        = 3)
-def tempadd_command(sender, command, label, args):
-    if not sender.hasPermission("permissions.manage.membership." + args[1]):
-        return "&cYou do not have permission to manage that group!"
-    if len(args) == 3:
-        if not args[2].isdigit():
-            return "&cThats not a number!"
-        duration = int(args[2]) * 60
   else:
-        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)
-
+    noperm(sender)
+  return True
 
 
 @hook.command("modules")
-def on_modules_command(sender, command, label, args):
-    """
-    /modules
-    list all modules, unloaded modules in red
-    """
+def on_modules_command(sender, args):
   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]
-"""
-
-
-
+  for mod in shared["load_modules"]:
+    color = "a" if mod in shared["modules"] else "c"
+    msg(sender, "&" + color + mod)

motd.py

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

mysqlhack.py

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

nametags.py

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

player.py

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

playermanager.py

@@ -1,192 +0,0 @@
-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

@@ -0,0 +1,28 @@
+#!/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.
+
+import sys
+
+x_plot_size = 3
+z_plot_size = 3
+padding     = 1
+
+def base_coords(x, z):
+  pid = plot_id(x, z)
+  return [pid[0] * (x_plot_size + padding), pid[1] * (z_plot_size + padding)]
+
+def bounds(x, z):
+  base = base_coords(x, z)
+  return [base, [base[0] + x_plot_size, base[1] + z_plot_size]]
+
+def plot_id(x, z):
+  return [x // (x_plot_size + padding), z // (z_plot_size + padding)]
+
+
+x = int(sys.argv[1])
+z = int(sys.argv[2])
+print "id: %s" % plot_id(x, z)
+print "base: %s" % base_coords(x, z)
+print "bounds: %s" % bounds(x, z)

plugin.yml

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

pmtoggle.py

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

punishments.py

@@ -1,130 +0,0 @@
-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())
-            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,7 +2,6 @@ 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"
@@ -14,83 +13,42 @@ rp_permission = "utils.rp"
 
 def print_help(sender):
   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 list          &eList unresolved 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)")
+  msg(sender, " &2/rp del <id>     &eResolve a report")
 
 
-def print_list(sender, closed):
+def print_list(sender):
   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, "&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")
-        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 %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)
+    msg(sender, "&aTeleported to report #%s" % rep_id )
 
 
 def delete_report(sender, rep_id):
-    if not sender.hasPermission(rp_permission + ".del"):
-        noperm(sender)
-        return
-    action = "&cdeleted"
-    report = edit_report(sender, rep_id)
-    if report != None:
-        reports.remove(report)
-        save_reports()
-        msg(sender, "&aReport #%s %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)
+    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:
-        server.dispatchCommand(sender, "mail send %s %s" % (reporter.getName(), colorify(message)))
+    msg(sender, "&cThat report does not exist!")
 
 
 def save_reports():
@@ -98,16 +56,13 @@ def save_reports():
 
 
 @hook.command("rp")
-def on_rp_command(sender, command, label, args):
+def on_rp_command(sender, args):
   if sender.hasPermission(rp_permission):
     plugin_header(sender, "Reports")
     if len(args) > 0:
-            subcmd = args[0].lower()
-            if subcmd == "closed":
+      if args[0] == "list":
         # 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,))
+        thread.start_new_thread(print_list, (sender))
       else:
         if not checkargs(sender, args, 2, 2):
           return True
@@ -117,17 +72,13 @@ def on_rp_command(sender, command, label, args):
           msg(sender, "&cDoesn't look like &3" + args[1] + "&c is a valid number!")
           print_help(sender)
           return True
-                if subcmd == "tp":
+        if args[0] == "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":
+        elif args[0] == "del":
           delete_report(sender, repid)
-                elif subcmd == "reopen":
-                    resolve_reopen_report(sender, repid, False)
         else:
           print_help(sender)
     else:
@@ -138,7 +89,7 @@ def on_rp_command(sender, command, label, args):
 
 
 @hook.command("report")
-def on_report_command(sender, command, label, args):
+def on_report_command(sender, args):
   plugin_header(sender, "Report")
   if not is_player(sender):
     msg(sender, "&conly players can do this")
@@ -158,8 +109,7 @@ def on_report_command(sender, command, label, args):
     "yaw": int(loc.yaw),
     "pitch": int(loc.pitch),
     "world": loc.getWorld().name,
-        "time": time.strftime(time_format),
-        "closed": False
+    "time": time.strftime(time_format)
   }
   reports.append(report)
   save_reports()
@@ -175,9 +125,9 @@ def reports_reminder(): # needs 2 args for unknown reason
       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))
+    if len(reports) > 0:
+      broadcast(rp_permission, "&2--=[ Reports ]=--")
+      broadcast(rp_permission, "&aThere are %s pending reports!" % len(reports))
 
 
 def stop_reporting():
@@ -186,15 +136,4 @@ def stop_reporting():
   check_reports = False
 
 
-def get_reports(closed):
-    targeted_reports = []
-    for report in reports:
-        if report["closed"] == closed:
-            targeted_reports.append(report)
-    return targeted_reports
-
-
-def get_reporter(report):
-    return server.getOfflinePlayer(juuid(report["uuid"]))
-
 thread.start_new_thread(reports_reminder, ())

saylol.py

@@ -1,12 +1,11 @@
 from time import time
 from helpers import *
 from random import randrange
-import math
 
 lols     = open_json_file("lol", [])
 timeout  = 15
 last_msg = 0
-list_limit = 20
+
 
 
 def save_lols():
@@ -31,8 +30,10 @@ def print_lol(sender, lid):
       broadcast(None, "&8[&blol&8] &7%s&8: &e%s" % (dispname, lols[lid]))
       last_msg = time()
     else:
+      plugin_header(sender, "SayLol")
       msg(sender, "&cInvalid id")
   else:
+    plugin_header(sender, "SayLol")
     msg(sender, "&cYou can use SayLol again in &a%s seconds!" % int(timeout + 1 - (time() - last_msg)))
 
 
@@ -40,16 +41,15 @@ def search_lols(sender, keyword):
   if not keyword:
     msg(sender, "&cPlease provide a keyword to search for!")
     return
-    keyword = keyword.lower()
   msg(sender, "&aLols containing '&6%s&a':" % keyword)
   for i, lol in enumerate(lols):
-        if keyword in lol.lower():
+    if keyword in lol:
       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, command, label, args):
+def on_lol_command(sender, args):
   plugin_header(sender, "SayLol")
 
   cmd = args[0] if len(args) > 0 else None
@@ -70,26 +70,8 @@ def on_lol_command(sender, command, label, args):
       noperm(sender)
 
   elif cmd == "list":
-        arg1 = args[1] if len(args) > 1 else None
-        if not arg1:
-            arg1 = "1"        
-        if not arg1.isdigit():
-            msg(sender, "&cInvalid argument \"%s\"" % arg1)
-            return True
-        if int(arg1) == 0:
-            msg(sender, "&cPage 0 does not exist")
-            return True
-        arg1 = int(arg1) - 1
-        offset = list_limit * arg1
-        if offset > len(lols):
-            msg(sender, "&cNot a valid page (too high).")
-            return True
-        msg(sender, "    &9&nLol list page %s/%s" % (arg1 + 1, int(math.ceil(len(lols) / float(list_limit))))) #"\t" symbol displays weirdly, hence the 4 spaces
-        for i in range(offset, min(offset + list_limit, len(lols))):
+    for i in range(len(lols)):
       msg(sender, "&a%s: &e%s" % (str(i).rjust(3), lols[i]))
-        msg(sender, "")        
-        msg(sender, "&eFor a specific page, type &a/lol list <page>&e.")
-        msg(sender, "") #emptyline
 
   elif cmd == "search":
     if sender.hasPermission("utils.lol.search"):
@@ -115,7 +97,7 @@ def on_lol_command(sender, command, label, args):
 
   else:
     msg(sender, "&a/lol            &eSay random message")
-        msg(sender, "&a/lol list [page]   &eList messages")
+    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")

scriptutils.py

@@ -1,212 +0,0 @@
-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

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

servercontrol.py

@@ -1,115 +0,0 @@
-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

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

setup.sh

@@ -1,175 +0,0 @@
-#!/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

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

snowbrawl.py

@@ -1,969 +0,0 @@
-#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,9 +1,3 @@
-"""
-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
@@ -38,7 +32,7 @@ def spawn(dispname, sender, x, y, z):
 
 
 @hook.command("spawnplayer")
-def on_spawnplayer_command(sender, command, label, args):
+def on_spawnplayer_command(sender, args):
   global amount, row, ground, goup
 
   # X and Z position

synchronizeranks.py

@@ -1,112 +0,0 @@
-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

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

tilehelper.py

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

toolbox/__init__.py

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

toolbox/rstoolbox.py

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

vanish.py

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

vanishfix.py

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

webtoken.py

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