From 474ce0b310d821755417c73fe6a3ce2a16032078 Mon Sep 17 00:00:00 2001 From: PanFritz Date: Mon, 29 Jun 2015 22:16:18 +0200 Subject: remade snowbrawl --- snowbrawl.py | 1376 ++++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 858 insertions(+), 518 deletions(-) (limited to 'snowbrawl.py') 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 &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 " % 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 ") + 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 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 respawn/spawn/sign set/add/del ") + msg(sender, "&c/sb pos bounds corner1/corner2") + return + if "bounds" not in args: + if len(args) < 4: + msg(sender, "&c/sb pos respawn/spawn/sign set/add/del ") + msg(sender, "&c/sb pos 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 respawn/spawn/sign set/add/del ") + msg(sender, "&c/sb pos 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 ") + 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 ") + 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 ") + 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 limit/mode/players/explosion/refill ") + 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 add/del ") + 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 " % 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 " % 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_command) - else: - msg(sender, "&cArena to rename is not specified") - msg(sender, "&a/snowbrawl %s " % 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 " % pos_command) - else: - msg(sender, "&cArena to set position of is not specified") - msg(sender, "&a/snowbrawl %s re/spawn " % 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 " % create_command) - else: - msg(sender, "&cPlayer limit is not specified") - msg(sender, "&a/snowbrawl %s " % create_command) - else: - msg(sender, "&cArena name is not specified") - msg(sender, "&a/snowbrawl %s " % 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 " % 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 -- cgit v1.2.3