remade snowbrawl

1 files changed, 858 insertions, 518 deletions

diff --git a/snowbrawl.py b/snowbrawl.py
index df3e022..b8982f8 100644
--- a/snowbrawl.py
+++ b/snowbrawl.py
@@ -1,15 +1,18 @@
 #Snowbrawl
 from helpers import *
-import time
-import thread
-import copy
+import time, threading, copy
+#from Queue import Queue
 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.util.UUID import fromString as juuid
+from operator import __contains__
+from traceback import format_exc as trace
+import random
 
 #file names
-arena_file = "snowbrawl"
-sign_file = "snowbrawl_sign_coords"
+file = "snowbrawl"
 
 #permissions
 list_perm = "utils.snowbrawl.list"
@@ -18,6 +21,7 @@ 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"
@@ -27,350 +31,567 @@ name_command = "name"
 pos_command = "pos"
 create_command = "create"
 info_command = "info"
+modify_command = "modify"
+modify_command_alias = "m"
+quit_command = "quit"
 
-arenas = open_json_file(arena_file, [])
-signs = open_json_file(sign_file, [])
-matches = []
-queue = []
-
-def get_best(players):
-    highest = 2147483647
-    player_out = players[0]
-    for player in players:
-        if player["deaths"] < highest:
-            highest = player["deaths"]
-            player_out = player
-    return player_out
-        
 
-def add_match(name):
-    for arena in arenas:
-        if arena["name"] == name:
-            match = {
-                "end_time": (time.time() + int(arena["match_time"])),
-                "match_length": int(arena["match_time"]),
-                "arena": name,
-                "players": [],
-                "started": False,
-                "limit": int(arena["player_limit"])
-            }
-            matches.append(match)
-            break
 
+class Arena(object):
 
-def end_match(name):
-    for i in range(len(matches)):
-        match = matches[i]
-        if match["arena"] == name:
-            for arena in arenas:
-                if arena["name"] == name:
-                    players = match["players"]
-                    players_copy = copy.deepcopy(players)
-                    best1 = None if len(players_copy) < 1 else get_best(players_copy)
-                    if best1 != None:
-                        for o in range(len(players_copy)):
-                            if players_copy[o] == best1:
-                                players_copy.pop(o)
-                                break
-                    best2 = None if len(players_copy) < 1 else get_best(players_copy)
-                    if best2 != None:
-                        for o in range(len(players_copy)):
-                            if players_copy[o] == best2:
-                                players_copy.pop(o)
-                                break
-                    best3 = None if len(players_copy) < 1 else get_best(players_copy)
-                    for k in range(len(players)):
-                        player_array = players[k]
-                        player = server.getPlayer(juuid(player_array["uuid"]))
-                        deaths = player_array["deaths"]
-                        msg(player, "&e==========================================")
-                        msg(player, "&a&a")
-                        msg(player, "&aMatch over!")
-                        if best1 != None:
-                            msg(player, "&61.&e %s &a-&6 %s deaths" % (server.getPlayer(juuid(best1["uuid"])).getName(), best1["deaths"]))
-                        if best2 != None:
-                            msg(player, "&62.&e %s &a-&6 %s deaths" % (server.getPlayer(juuid(best2["uuid"])).getName(), best2["deaths"]))
-                        if best3 != None:
-                            msg(player, "&63.&e %s &a-&6 %s deaths" % (server.getPlayer(juuid(best3["uuid"])).getName(), best3["deaths"]))
-                        msg(player, "&a&a")
-                        msg(player, "&aYour deaths:&6 %s" % deaths)
-                        msg(player, "&a&a")
-                        msg(player, "&e==========================================")
-                        pos = server.getWorld(arena["spawn_world"]).getSpawnLocation();
-                        safetp(player, server.getWorld(arena["spawn_world"]), pos.x, pos.y, pos.z, pos.yaw, pos.pitch)
-                    matches.pop(i)
-                    update_queue(name)
-                    return
+    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     
+
+    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)
+
+    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)
+
+    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
+
+    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 join_match(sender, name):
-    for match in matches:
-        if match["arena"] == name:
-            if len(match["players"]) >= int(match["limit"]):
-                add_to_queue(sender, name)
-            else:
-                player = {
-                    "uuid": uid(sender),
-                    "deaths": 0
-                }
-                match["players"].append(player)
-                msg(sender, "&aMatch joined")
-                if len(match["players"]) >= int(match["limit"]):
-                    start_match(name)
+    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)
+
+    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
-    add_match(name)
-    join_match(sender, name)
-
-
-def start_match(name):
-    for match in matches:
-        if match["arena"] == name:
-            for arena in arenas:
-                if arena["name"] == name:
-                    players = match["players"]
-                    for j in range(len(players)):
-                        player = server.getOfflinePlayer(juuid(players[j]["uuid"]))
-                        if player.isOnline():
-                            msg(player, "&e==========================================")
-                            msg(player, "&a&a")
-                            msg(player, "&aMatch started!")
-                            msg(player, "&6Player with least deaths wins!")
-                            msg(player, "&a&a")
-                            msg(player, "&e==========================================")                            
-                            safetp(player.getPlayer(), server.getWorld(arena["spawn_world"]), arena["spawn_pos_x"], arena["spawn_pos_y"], arena["spawn_pos_z"], arena["spawn_yaw"], arena["spawn_pitch"])
-                        else:
-                            match["players"].pop(j)
-                            j -= 1;
-                    match["started"] = True
-                    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 end_match(self):
+        lowest1 = 2147483647
+        lowest2 = 2147483647
+        lowest3 = 2147483647
+        best1 = None
+        best2 = None
+        best3 = None
+        for player in self.players.read():
+            if self.player_stats[player.getName() + "_deaths"] < lowest1:
+                best1 = player
+                lowest1 = self.player_stats[player.getName() + "_deaths"]
+                break
+        if best1 != None:
+            for player in self.players.read():
+                if self.player_stats[player.getName() + "_deaths"] < lowest2 and player.getName() != best1.getName():
+                    best2 = player
+                    lowest2 = self.player_stats[player.getName() + "_deaths"]
+                    break
+        if best1 != None and best2 != None:
+            for player in self.players.read():
+                if self.player_stats[player.getName() + "_deaths"] < lowest3 and player.getName() != best1.getName() and player.getName() != best2.getName():
+                    best3 = player
+                    lowest3 = self.player_stats[player.getName() + "_deaths"]
+                    break
+        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 best1 != None:
+                    msg(player, "&e1. %s (%s)" % (best1.getName(), lowest1))
+                if best2 != None:
+                    msg(player, "&e2. %s (%s)" % (best2.getName(), lowest2))
+                if best3 != None:
+                    msg(player, "&e3. %s (%s)" % (best3.getName(), lowest3))
+                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 add_to_queue(sender, name):
-    queue_player = {
-        "sender": sender,
-        "name": name
-    }
-    queue.append(queue_player)
-    msg(sender, "&a-&eMatch is currently in progress, you will be automatically teleported once it is over")
+    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 update_queue(name):
-    queue_copy = []
-    for queue_thing in queue:
-        queue_player_copy = {
-            "sender": queue_thing["sender"],
-            "name": queue_thing["name"]
-        }
-        queue_copy.append(queue_player_copy)
-    queue[:] = []
-    for queue_player in queue_copy:
-        if queue_player["name"] == name:
-            join_match(queue_player["sender"], name)
-        else:
-            queue.append(queue_player)
+    def set_player_limit(self, limit):
+        self.player_limit = limit
 
+    def set_end_goal(self, value):
+        self.match_goal = value
 
-def save_snowbrawl():
-    save_json_file(arena_file, arenas)
-    save_json_file(sign_file, signs)
+    def set_type(self, type):
+        self.arena_type = type
 
+    def get_name(self):
+        return self.name
 
-def teleport_to_arena(sender, name):
-    for arena in arenas:
-        if arena["name"] == name:
-            safetp(sender, server.getWorld(arena["tp_world"]), arena["tp_pos_x"], arena["tp_pos_y"], arena["tp_pos_z"], arena["tp_yaw"], arena["tp_pitch"])
-            break
+    def set_refill(self, amount):
+        self.refill = int(amount)
 
+    def set_name(self, name):
+        self.name = name
 
-def set_arena_sign(sender, name, sign):
-    sign.setLine(0, "")
-    sign.setLine(1, name)
-    sign.setLine(2, "")
-    sign.setLine(3, "")
-    position = sign.getLocation()
-    coord = {
-        "x": position.x,
-        "y": position.y,
-        "z": position.z,
-        "arena": name
-    }
-    signs.append(coord)
-    save_snowbrawl()
-    msg(sender, "&aArena sign set")
-
-
-def delete_arena(sender, name):
-    for i in range(len(arenas)):
-        arena = arenas[i]
-        if arena["name"] == name:
-            end_match(name)
-            arenas.pop(i)
-            save_snowbrawl()
-            msg(sender, "&aArena deleted")
-            break
+    def get_refill(self):
+        if self.refill == None:
+            return 16
+        return self.refill
 
+    def get_tp_signs(self):
+        return self.sign_location
 
-def rename_arena(sender, name, newName):
-    for arena in arenas:
-        if arena["name"] == name:
-            for match in matches:
-                if match["arena"] == name:
-                    match["arena"] = newName
-                    msg(sender, "&a-&eRunning match appended to arena&6 %s" % newName)
-            for queue_player in queue:
-                if queue_player["name"] == name:
-                    queue_player["name"] = newName
-                    msg(sender, "&a-&e Player&6 %s &ein queue relocated into&6 %s &equeue" % (queue_player["sender"].getName(), newName))
-            for sign in signs:
-                if sign["arena"] == name:
-                    sign["arena"] = newName
-                    msg(sender, "&a-&e Sign at&6 %s&e,&6 %s&e,&6 %s &erelinked to arena&6 %s" % (sign["x"], sign["y"], sign["z"], newName))
-            arena["name"] = newName
-            save_snowbrawl()
-            msg(sender, "&aArena renamed to&6 %s" % newName)
-            break
+    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
 
-def respawn_arena(sender, name):
-    for arena in arenas:
-        if arena["name"] == name:
-            loc = sender.getLocation()
-            arena["respawn_pos_x"] = float(loc.x)
-            arena["respawn_pos_y"] = float(loc.y)
-            arena["respawn_pos_z"] = float(loc.z)
-            arena["respawn_yaw"] = int(loc.yaw)
-            arena["respawn_pitch"] = int(loc.pitch)
-            arena["respawn_world"] = loc.getWorld().name
-            arena["respawn_set"] = True
-            save_snowbrawl()
-            msg(sender, "&aArena respawn set")
-            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 = int(data["explosion"])
+        self.player_limit = int(data["players"])
+        self.refill = int(data["refill"])
+        self.arena_type = str(data["type"])
+        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
+        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
 
-def spawn_arena(sender, name):
-    for arena in arenas:
-        if arena["name"] == name:
-            loc = sender.getLocation()
-            arena["spawn_pos_x"] = float(loc.x)
-            arena["spawn_pos_y"] = float(loc.y)
-            arena["spawn_pos_z"] = float(loc.z)
-            arena["spawn_yaw"] = int(loc.yaw)
-            arena["spawn_pitch"] = int(loc.pitch)
-            arena["spawn_world"] = loc.getWorld().name
-            arena["spawn_set"] = True
-            save_snowbrawl()
-            msg(sender, "&aArena spawn set")
-            break
+    #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
+    
+    def clear(self):
+        self.queue = []
 
-def tp_arena(sender, name):
+##############################################################################################
+# Initialization
+##############################################################################################
+
+def save_snowbrawl():
+    out = []
     for arena in arenas:
-        if arena["name"] == name:
-            loc = sender.getLocation()
-            arena["tp_pos_x"] = float(loc.x)
-            arena["tp_pos_y"] = float(loc.y)
-            arena["tp_pos_z"] = float(loc.z)
-            arena["tp_yaw"] = int(loc.yaw)
-            arena["tp_pitch"] = int(loc.pitch)
-            arena["tp_world"] = loc.getWorld().name
-            save_snowbrawl()
-            msg(sender, "&aArena teleport position set")
-            break
+        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
 
-def create_arena(sender, name, limit, time):
-    loc = sender.getLocation()
-    arena = {
-        "name": name,
-        "player_limit": limit,
-        "match_time": time,
-        "respawn_pos_x": 0,
-        "respawn_pos_y": 0,
-        "respawn_pos_z": 0,
-        "respawn_pitch": 0,
-        "respawn_yaw": 0,
-        "respawn_world": "null",
-        "spawn_pos_x": 0,
-        "spawn_pos_y": 0,
-        "spawn_pos_z": 0,
-        "spawn_pitch": 0,
-        "spawn_yaw": 0,
-        "spawn_world": "null",
-        "spawn_set": False,
-        "respawn_set": False,
-        "tp_pos_x": float(loc.x),
-        "tp_pos_y": float(loc.y),
-        "tp_pos_z": float(loc.z),
-        "tp_yaw": 0,
-        "tp_pitch": 0,
-        "tp_world": loc.getWorld().name
-    }
-    arenas.append(arena)
-    save_snowbrawl()
-    msg(sender, "&aArena&6 %s &acreated" % arena["name"])
+arenas = load_snowbrawl()
 
+##############################################################################################
+# Threads
+##############################################################################################
 
-def print_help(sender):
-    plugin_header(sender, "Snowbrawl")
-    msg(sender, "&a- &eAlias: &6/sb")
-    if sender.hasPermission(teleport_perm):
-        msg(sender, "&a/snowbrawl <name>      &eTeleport to a certain arena")
-    if sender.hasPermission(list_perm):
-        msg(sender, "&a/snowbrawl %s      &eDisplay the list of arenas" % list_command)
-    if sender.hasPermission(info_perm):
-        msg(sender, "&a/snowbrawl %s      &eDisplay info about an arena" % info_command)
-    if sender.hasPermission(modify_perm):
-        msg(sender, "&a/snowbrawl %s      &eSet a snowbrawl arena sign" % set_command)
-        msg(sender, "&a/snowbrawl %s      &eDelete a snowbrawl arena sign" % del_command)
-        msg(sender, "&a/snowbrawl %s      &eChange an arena sign name" % name_command)
-        msg(sender, "&a/snowbrawl %s      &eSet the tp position for the arena" % pos_command)
-    if sender.hasPermission(create_perm):
-        msg(sender, "&a/snowbrawl %s      &eCreate an arena" % create_command)
+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:
+                        arena.end_match()
 
+    
+timingsThread = threading.Thread(target = timings)
+timingsThread.daemon = True
+timingsThread.start()
 
-def check_valid_name(name):
-    if name in [list_command, del_command, set_command, name_command, pos_command, info_command]:
-        return False
-    for arena in arenas:
-        if name == arena["name"]:
-            return False
-    return True
 
 
-@hook.event("player.PlayerRespawnEvent", "high")
-def onRespawn(event):
+
+
+##############################################################################################
+# Events
+##############################################################################################
+
+@hook.event("player.PlayerMoveEvent", "high")
+def onMove(event):
     if event.getPlayer().getWorld().getName() != "minigames":
         return
     player = event.getPlayer()
-    for i in range(len(matches)):
-        match = matches[i]
-        players = match["players"]
-        for j in range(len(players)):
-            if uid(player) == players[j]["uuid"]:
-                for k in range(len(arenas)):
-                    arena = arenas[k]
-                    if arena["name"] == match["arena"]:
-                        event.setRespawnLocation(Location(server.getWorld(arena["respawn_world"]), arena["respawn_pos_x"], arena["respawn_pos_y"], arena["respawn_pos_z"], arena["respawn_yaw"], arena["respawn_pitch"]))
-                        return
-
+    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
-    player = event.getEntity()
-    for i in range(len(matches)):
-        match = matches[i]
-        players = match["players"]
-        for j in range(len(players)):
-            if uid(player) == players[j]["uuid"]:
-                for k in range(len(arenas)):
-                    arena = arenas[k]
-                    if arena["name"] == match["arena"]:
-                        players[j]["deaths"] += 1
-                        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):
@@ -378,53 +599,289 @@ def onHit(event):
         return
     if event.getEntity().getName() != "Snowball":
         return
-    entity = event.getEntity()
-    location = entity.getLocation()
-    entity.getWorld().createExplosion(location.getX(), location.getY(), location.getZ(), float(1), False, False)
-
+    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):
+        try:
+                bleh(event)
+        except:
+                print trace()
+
+def bleh(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:
-        inv = event.getPlayer().getInventory()
-        inv.remove(Material.SNOW_BALL)
-        inv.setItemInHand(ItemStack(Material.SNOW_BALL, 16))
-        event.getPlayer().updateInventory()
-    elif not isinstance(block, bukkit.block.Sign):
+        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
-    elif not event.isCancelled():
-        line = block.getLine(1)
-        for j in range(len(arenas)):
-            arena = arenas[j]
-            if arena["name"] == line:
-                for i in range(len(signs)):
-                    sign = signs[i]
-                    if sign["arena"] == line:
-                        pos = block.getLocation()
-                        if sign["x"] == pos.x and sign["y"] == pos.y and sign["z"] == pos.z:
-                            if arena["spawn_set"] and arena["respawn_set"]:
-                                if event.getPlayer().hasPermission(join_perm):
-                                    for queue_player in queue:
-                                        if queue_player["sender"].getName() == event.getPlayer().getName():
-                                            msg(event.getPlayer(), "&a-&e You are already in a queue for a match")
-                                            return
-                                    for match in matches:
-                                        for match_player in match["players"]:
-                                            if match_player["uuid"] == uid(event.getPlayer()):
-                                                if line == match["arena"]:
-                                                    msg(event.getPlayer(), "&a-&e You are already in this match")
-                                                else:
-                                                    msg(event.getPlayer(), "&a-&e You are already in a different match")
-                                                return
-                                    join_match(event.getPlayer(), line)
-                                else:
-                                    msg(event.getPlayer(), "&a-&e You don't have permission to join snowbrawl matches")
-                                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.getName()):
+            arena.remove_player(sender.getName())
+            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:
+                    int(args[2])
+                except ValueError:
+                    msg(sender, "&cLast parameter has to be a number")
+                    return
+                arena.set_explosion_damage(int(args[2]))
+                msg(sender, "&a-&e Set explosion power to:&6 %s" % int(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("sbm")
+def on_snowbrawl_command_modify(sender, command, label, args):
+    args_ = args
+    args_.insert(0, modify_command)
+    return on_snowbrawl_command(sender, command, label, args_)
+
 @hook.command("sb")
 def on_snowbrawl_command_short(sender, command, label, args):
     return on_snowbrawl_command(sender, command, label, args)
@@ -432,204 +889,87 @@ def on_snowbrawl_command_short(sender, command, label, args):
 
 @hook.command("snowbrawl")
 def on_snowbrawl_command(sender, command, label, args):
-
-    cmd = args[0] if len(args) > 0 else None
-    if cmd == None: # No arguments, print help
+    if len(args) == 0:
+        #print help
+        plugin_header(sender, "Snowbrawl")
         print_help(sender)
-    elif cmd == list_command: # Print the list of arenas
+        return True
+    elif args[0] == list_command:
         if sender.hasPermission(list_perm):
-            if len(arenas) > 0:
-                for i in range(len(arenas)):
-                    msg(sender, "&a- &e%s" % arenas[i]["name"])
-            else:
-                msg(sender, "&a- &eNo snowbrawl arenas exist")
+            #print the list of arenas
+            list_arenas(sender)
         else:
             noperm(sender)
-    elif cmd == set_command: # Set an arena tp sign
-        if not is_player(sender):
-            msg(sender, "&cOnly players can do this")
-            return True
+        return True
+    elif args[0] == del_command:
         if sender.hasPermission(modify_perm):
-            if len(args) > 1:
-                exists = False
-                for arena in arenas:
-                    if str(args[1]) == arena["name"]:
-                        exists = True
-                        break
-                if exists:
-                    mats = set()
-                    mats = None
-                    block = sender.getTargetBlock(mats, 3).getState()
-                    if isinstance(block, bukkit.block.Sign):
-                        set_arena_sign(sender, str(args[1]), block)
-                    else:
-                        msg(sender, "&cYou are not looking at a sign")
-                else:
-                    msg(sender, "&cArena&e %s &cdoes not exist" % str(args[1]))
-            else:
-                msg(sender, "&cArena to create is not specified")
-                msg(sender, "&e/snowbrawl %s <name>" % set_command)
+            #delete an arena
+            delete_arena(sender, args[1:])
+            save_snowbrawl()
         else:
             noperm(sender)
-    elif cmd == del_command: # Delete an arena
+        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):
-            if len(args) > 1:
-                exists = False
-                for arena in arenas:
-                    if str(args[1]) == arena["name"]:
-                        exists = True
-                        break
-                if exists:
-                    delete_arena(sender, str(args[1]))
-                else:
-                    msg(sender, "&cArena&e %s &cdoes not exist" % str(args[1]))
-            else:
-                msg(sender, "&cArena to delete is not specified")
-                msg(sender, "&a/snowbrawl %s <name>" % del_command)
+            #set arena spawn/respawn/sign tp locations
+            set_location(sender, args[1:])
+            save_snowbrawl()
         else:
             noperm(sender)
-    elif cmd == name_command: # Rename an arena
+        return True
+    elif args[0] == name_command:
         if sender.hasPermission(modify_perm):
-            if len(args) > 1:
-                if len(args) > 2:
-                    exists = False
-                    for arena in arenas:
-                        if str(args[1]) == arena["name"]:
-                            exists = True
-                            break
-                    if exists:
-                        if check_valid_name(str(args[2])):
-                            rename_arena(sender, str(args[1]), str(args[2]))
-                        else:
-                            msg(sender, "&cArena name is invalid")
-                    else:
-                        msg(sender, "&cArena&e %s &cdoes not exist" % str(args[1]))
-                else:
-                    msg(sender, "&cNew name is not specified")
-                    msg(sender, "&a/snowbrawl %s <name> <newName>" % name_command)
-            else:
-                msg(sender, "&cArena to rename is not specified")
-                msg(sender, "&a/snowbrawl %s <name> <newName>" % name_command)
+            #rename an arena
+            rename_arena(sender, args[1:])
+            save_snowbrawl()
         else:
             noperm(sender)
-    elif cmd == pos_command: # Set a tp position for an arena
-        if not is_player(sender):
-            msg(sender, "&cOnly players can do this")
-            return True
+        return True
+    elif args[0] == set_command:
         if sender.hasPermission(modify_perm):
-            if len(args) > 1:
-                if len(args) > 2:
-                    exists = False
-                    for arena in arenas:
-                        if str(args[2]) == arena["name"]:
-                            exists = True
-                            break
-                    if exists:
-                        if str(args[1]) == "spawn":
-                            spawn_arena(sender, str(args[2]))
-                        elif str(args[1]) == "respawn":
-                            respawn_arena(sender, str(args[2]))
-                        elif str(args[1]) == "teleport":
-                            tp_arena(sender, str(args[1]))
-                        else:
-                            msg(sender, "&cInvalid mode")
-                            msg(sender, "&aValid modes: &6spawn&a,&6 respawn&a,&6 teleport")
-                    else:
-                        msg(sender, "&cArena&e %s &cdoes not exist" % str(args[2]))
-                else:
-                    msg(sender, "&cSpawn/respawn not specified")
-                    msg(sender, "&a/snowbrawl %s re/spawn <name>" % pos_command)
-            else:
-                msg(sender, "&cArena to set position of is not specified")
-                msg(sender, "&a/snowbrawl %s re/spawn <name>" % pos_command)
+            #set an arena tp sign
+            set_arena_sign(sender, args[1:])
+            save_snowbrawl()
         else:
             noperm(sender)
-    elif cmd == create_command: # Create an arena
-        if sender.hasPermission(create_perm):
-            if len(args) > 1:
-                if len(args) > 2:
-                    if len(args) > 3:
-                        if check_valid_name(str(args[1])):
-                            if str(args[2]).isdigit():
-                                if str(args[3]).isdigit():
-                                    create_arena(sender, str(args[1]), int(args[2]), int(args[3]))
-                                else:
-                                    msg(sender, "&cTime is not in a valid format")
-                                    msg(sender, "&aFormat:&6 seconds")
-                            else:
-                                msg(sender, "&cPlayer is not in a valid format")
-                                msg(sender, "&aFormat:&6 amount of players")
-                        else:
-                            msg(sender, "&cArena name is invalid")
-                    else:
-                        msg(sender, "&cMatch time is not specified")
-                        msg(sender, "&a/snowbrawl %s <name> <playerLimit> <matchTime>" % create_command)
-                else:
-                    msg(sender, "&cPlayer limit is not specified")
-                    msg(sender, "&a/snowbrawl %s <name> <playerLimit> <matchTime>" % create_command)
-            else:
-                msg(sender, "&cArena name is not specified")
-                msg(sender, "&a/snowbrawl %s <name> <playerLimit> <matchTime>" % create_command)
+        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)
-    elif cmd == info_command: # Print info about an arena
-        if sender.hasPermission(info_perm):
-            if len(args) > 1:
-                exists = False
-                arenaId = 0
-                for i in range(len(arenas)):
-                    arena = arenas[i]
-                    if str(args[1]) == arena["name"]:
-                        exists = True
-                        arenaId = i
-                        break
-                if exists:
-                    msg(sender, "&a- &e%s" % arenas[arenaId])
-                else:
-                    msg(sender, "&cArena&e %s &cdoes not exist" % cmd)
-            else:
-                msg(sender, "&cArena name is not specified")
-                msg(sender, "&a/snowbrawl %s <name>" % info_command)
+        return True
+    elif args[0] == quit_command:
+        if sender.hasPermission(quit_perm):
+            #quit match
+            quit_match(sender)
         else:
             noperm(sender)
-    else: # Arguments dont match, teleport to an arena
-        if not is_player(sender):
-            msg(sender, "&cOnly players can do this")
-            return True
+        return True
+    else:
         if sender.hasPermission(teleport_perm):
-            exists = False
-            for i in range(len(arenas)):
-                arena = arenas[i]
-                if cmd == arena["name"]:
-                    exists = True
-                    break
-            if exists:
-                msg(sender, "&a-&e Teleporting to arena&6 %s" % cmd)
-                teleport_to_arena(sender, cmd)
+            #try to tp to an arena
+            if len(args) > 1:
+                teleport_to_arena(sender, args[0], args[1])
             else:
-                msg(sender, "&a- &eArena&6 %s &edoes not exist" % cmd)
+                teleport_to_arena(sender, args[0], 1)
         else:
             noperm(sender)
     return True
-
-
-isThreadRunning = True
-
-def countdown_timer():
-    while True:
-        time.sleep(1)
-        if not isThreadRunning:
-            thread.exit()
-        for i in range(len(matches)):
-            match = matches[i]
-            if bool(match["started"]):
-                if int(match["end_time"]) < time.time():
-                    end_match(match["arena"])
-
-def stop_match_end_thread():
-    global isThreadRunning
-    print("Stopping snowbrawl match check thread")
-    isThreadRunning = False
-
-
-thread.start_new_thread(countdown_timer, ())
\ No newline at end of file