Changed timeout in loginsecurity to 60 seconds

calc.py

@@ -1,67 +1,29 @@
 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"]
+math_operators    = ["+", "-", "*", "/", "&", "|"]
+ignore_operators  = ["**", "&&", "||"] # ** may be too intensive, the others cause syntax errors
 calc_perm = "utils.calc"
-calc_perm_power = "utils.calc.power"
 
-def calc(sender, text):
+
+def calc(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:
+    for char in text:
+        if char.isdigit() or (expression and char == ".") or (should_calc and char == " "):
             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 ["(", ")"]:
+        elif char in math_operators:
             # 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:
+    if should_calc and not any(op in expression for op in ignore_operators):
         try:
             result = str(eval(expression)) # pylint: disable = W0123
         except: # pylint: disable = W0702
@@ -71,19 +33,15 @@ def calc(sender, text):
         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()
+        output = calc(message)
+        if output:
+            msg(sender, "&2=== Calc: &e" + output[0] + " &2= &c" + output[1])
 
 
 @hook.command("calc", description="Toggles chat calculations")

helpers.py

@@ -10,6 +10,8 @@ import org.bukkit.block as bblock
 import org.bukkit.event.entity as entity
 import org.bukkit.command.ConsoleCommandSender
 from org.bukkit.entity import *
+from player import get_py_player
+from player import py_players
 
 from traceback import format_exc as trace
 

loginsecurity.py

@@ -8,13 +8,12 @@ import mysqlhack
 from com.ziclix.python.sql import zxJDBC
 from java.lang import Runnable
 
-wait_time = 30 #seconds
+wait_time = 60 #seconds
 admin_perm = "utils.loginsecurity.admin"
 min_pass_length = 8
 blocked_events = ["block.BlockBreakEvent", "block.BlockPlaceEvent", "player.PlayerMoveEvent","player.AsyncPlayerChatEvent"]
 
 
-logging_in = {}
 
 
 def matches(password,user):
@@ -24,13 +23,17 @@ def matches(password,user):
 
 def matches_thread(password, user):
     hashed = get_pass(uid(user))
+    py_player = get_py_player(user)
     if crypt.verify(password, hashed):
-        if user.getName() in logging_in:
-            del logging_in[user.getName()]
+        if py_player.logging_in:
+            py_player.logging_in = False
             msg(user, "&aLogged in successfully!")
     else:
-        if user.getName() in logging_in:
-            msg(user, "&cInvalid password")
+        if py_player.logging_in:
+            msg(user, "&cInvalid password!")
+
+
+
 
 
 @simplecommand("cgpass",
@@ -39,71 +42,112 @@ def matches_thread(password, user):
 	senderLimit = 0,
 	helpNoargs  = True)
 def change_pass_command(sender, command, label, args):
-    if sender.getName() in logging_in:
+    
+    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):
-    if sender.getName() in logging_in:
+
+    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 not sender.getName() in logging_in:
+
+    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):
-    if sender.getName() in logging_in:
+    
+    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()))
@@ -159,19 +203,27 @@ def delete_pass(uuid):
     curs.close()
     conn.close()
 
-@hook.event("player.PlayerJoinEvent", "high")
+@hook.event("player.PlayerJoinEvent", "low")
 def on_join(event):
     user = event.getPlayer()
+    py_player = get_py_player(event.getPlayer())
     if is_registered(uid(user)):
         msg(event.getPlayer(), "&6You will be disconnected after 60 seconds if you don't &alogin")
         msg(user, "&cUse /login <password>")
-        logging_in[user.getName()] = time.time()
+        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):
@@ -187,15 +239,18 @@ def kick_thread():
     while True:
         time.sleep(1)
         now = time.time()
-        for name, jointime in logging_in.iteritems():
-            if now - jointime > wait_time:
-                player = server.getPlayer(name)
-                kick = kick_class(player)
-                server.getScheduler().runTask(server.getPluginManager().getPlugin("RedstonerUtils"), kick)
-                if name in logging_in:
-                    del logging_in[name]
-                    break
-                
+        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)
@@ -206,6 +261,6 @@ thread.start()
 for blocked_event in blocked_events:
     @hook.event(blocked_event, "high")
     def on_blocked_event(event):
-        user = event.getPlayer()
-        if user.getName() in logging_in:
+        user = get_py_player(event.getPlayer())
+        if user.logging_in:
             event.setCancelled(True)

main.py

@@ -15,6 +15,8 @@ except:
     print("[RedstonerUtils] ERROR: Failed to import helpers:")
     print(print_traceback())
 
+
+
 @hook.enable
 def on_enable():
     info("RedstonerUtils enabled!")
@@ -77,9 +79,7 @@ shared["load_modules"] = [
     # Replacement for LoginSecurity
     "loginsecurity",
     # Centralized Player class
-    "playermanager",
-    # Plots
-    "plotter"
+    "player"
 ]
 shared["modules"] = {}
 for module in shared["load_modules"]:

player.py

@@ -1,27 +1,28 @@
 from helpers import *
 
-players = []
+py_players = []
 
 class py_player:
-
-	def __init__(player):
-		self.player = player
-
-	#Properties TODO
-	#Example:
-	self.logging_in = False
+    def __init__(self,player):
+        self.player = player
+        self.logging_in = False
+        self.login_time = 0
 
 def get_py_player(player):
-	py_player = players[players.index(player)]
-	return py_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","highest")
+@hook.event("player.PlayerJoinEvent","lowest")
 def on_join(event):
-	player = py_player(event.getPlayer())
-	players.append(player)
+    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):
-	players.remove(get_py_player(event.getPlayer()))
+    py_players.remove(get_py_player(event.getPlayer()))

plotter.py

@@ -5,50 +5,26 @@
 on hold because the PlotMe developer continued to develop PlotMe
 """
 
-from helpers import *
-from basecommands import simplecommand
+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)]
 
 
-@simplecommand("plotter",
-    aliases = ["pt"],
-    senderLimit = 0,
-    description = "Plot commands")
-def plotter_command(sender, command, label, args):
-    loc = sender.getLocation()
-    x = loc.getX()
-    z = loc.getZ()
-    plot = Plot.get(x, z)
-
-    if plot:
-        msg(sender, "id: %s" % [plot.idx, plot.idz])
-        msg(sender, "bottom: %s" % [plot.bottomx, plot.bottomz])
-        msg(sender, "top: %s" % [plot.topx, plot.topz])
-    else:
-        msg(sender, "&cThis is not a plot.")
-
-class Plot:
-    plot_size   = 20
-    padding     = 3
-    padded_size = plot_size + padding
-
-    def __init__(self, x, z):
-        x = int(x)
-        z = int(z)
-        self.idx     = x
-        self.idz     = z
-        self.bottomx = x * self.padded_size
-        self.bottomz = z * self.padded_size
-        self.topx    = self.bottomx + self.plot_size
-        self.topz    = self.bottomz + self.plot_size
-
-    @staticmethod
-    def is_border(x, z):
-        xborder = Plot.plot_size < x % Plot.padded_size < Plot.padded_size
-        zborder = Plot.plot_size < z % Plot.padded_size < Plot.padded_size
-        return xborder or zborder
-
-    @staticmethod
-    def get(x, z):
-        idx = x // Plot.padded_size
-        idz = z // Plot.padded_size
-        return None if Plot.is_border(x, z) else Plot(idx, idz)
+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)

snowbrawl.py

@@ -359,11 +359,11 @@ class Arena(object):
         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.explosion_damage = float(data["explosion"])
+        self.player_limit = int(data["players"])
+        self.refill = int(data["refill"])
         self.arena_type = str(data["type"])
-        self.match_goal = None if str(data["goal"]) == "None" else int(data["goal"])
+        self.match_goal = 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