From 95712e552001701291c70e10cfefab378bcdab30 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 11:51:43 +0100 Subject: Ducks new progress --- modules/ducks.py | 12 +++--- modules/ducks_new.py | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 120 insertions(+), 6 deletions(-) create mode 100644 modules/ducks_new.py (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index 4bcef982..9b2d78f2 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -33,15 +33,15 @@ class Module(object): "stats!") - exports.add("channelset", {"setting": "ducks-enabled", - "help": "Toggle ducks!", "validate": Utils.bool_or_none}) + #exports.add("channelset", {"setting": "ducks-enabled", + # "help": "Toggle ducks!", "validate": Utils.bool_or_none}) - events.on("received.numeric.366").hook(self.bootstrap) + #events.on("received.numeric.366").hook(self.bootstrap) - events.on("raw").on("376").hook(self.duck_loop_entry) + #events.on("raw").on("376").hook(self.duck_loop_entry) - events.on("timer").on("duck-decoy").hook(self.duck_decoy) - events.on("timer").on("show-duck").hook(self.show_duck) + #events.on("timer").on("duck-decoy").hook(self.duck_decoy) + #events.on("timer").on("show-duck").hook(self.show_duck) def duck_loop_entry(self, event): wait = self.get_random_duck_time() diff --git a/modules/ducks_new.py b/modules/ducks_new.py new file mode 100644 index 00000000..261bb24b --- /dev/null +++ b/modules/ducks_new.py @@ -0,0 +1,114 @@ +from operator import itemgetter +import Utils +import random + +DUCK_TAIL = "・゜゜・。。・゜゜" +DUCK_HEAD = ["\_o< ", "\_O< ", "\_0< ", "\_\u00f6< ", "\_\u00f8< ", + "\_\u00f3< "] +DUCK_MESSAGE = ["QUACK!", "FLAP FLAP!", "quack!", "squawk!"] +DUCK_MESSAGE_RARE = ["beep boop!", "QUACK QUACK QUACK QUACK QUACK!!", "HONK!"] + +DELAY_REDUCE_UNIQUE = 1 +DELAY_REDUCE = 0.5 + +CHANNELS_ENABLED = [] + + +class Module(object): + def __init__(self, bot, events, exports): + self.bot = bot + self.events = events + + # events.on("received").on("command").on("bef").hook(self.duck_action, + # help="Befriend a duck!") + # events.on("received").on("command").on("bang").hook(self.duck_bang, + # help="Shoot a duck! Meanie.") + # events.on("received").on("command").on("decoy").hook(self.set_decoy, + # help="Be a sneaky fellow + ## and make a decoy duck.") + # events.on("received").on("command").on("friends").hook( + # self.duck_friends, + # help="See who the + # friendliest people to ducks are!") + # events.on("received").on("command").on("killers").hook( + # self.duck_enemies, + # help="See who shoots the + # most amount of ducks.") + # events.on("received").on("command").on("duckstats").hook( + # self.duck_stats, + # help="Shows your duck " + # "stats!") + + exports.add("channelset", {"setting": "ducks-enabled", + "help": "Toggle ducks!", + "validate": Utils.bool_or_none}) + + events.on("new.channel").hook(self.bootstrap) + + events.on("received").on("message").on("channel").hook( + self.channel_message) + + def bootstrap(self, event): + channel = event["channel"] + print("Init for " + channel.name) + self.init_game_var(channel) + # getset + ducks_enabled = channel.get_setting("ducks-enabled", False) + + print("Ducks enabled for " + channel.name + " -- " + str( + ducks_enabled)) + if ducks_enabled == True: + print("Starting game for " + channel.name) + self.start_game(channel) + + def init_game_var(self, event): + channel = event + + + if hasattr(channel, 'games') == False: + channel.games = {} + + + def start_game(self, event): + # event is immediately the IRCChannel.Channel() event for the current + # channel + + channel = event + + print("Starting duck game for channel: " + channel.name) + + if "ducks" not in channel.games.keys(): + channel.games["ducks"] = { + 'current_active_delay': 10, + 'current_unique_nicks': 3, + 'duck_spawned': 0, + 'unique_nicks': [] + } + + print(channel.games) + + + def channel_message(self, event): + channel = event["channel"] + channel_name = channel.name + + if "ducks" not in channel.games.keys(): + return + + user = event["user"] + hostname = user.hostname + game = channel.games["ducks"] + + if hostname not in game["unique_nicks"]: + game["unique_nicks"].append(hostname) + + if game["current_unique_nicks"] > 0: + game["current_unique_nicks"] = game["current_unique_nicks"] - 1 + + if game["current_active_delay"] > 0: + game["current_active_delay"] = game["current_active_delay"] \ + - DELAY_REDUCE_UNIQUE + else: + if game["current_active_delay"] > 0: + game["current_active_delay"] = game["current_active_delay"] \ + - DELAY_REDUCE -- cgit v1.3.1-10-gc9f91 From 82a20a209a4f5dc28060463d00797f0d2acd56a3 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 11:54:06 +0100 Subject: Set unique user properly. --- modules/ducks_new.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'modules') diff --git a/modules/ducks_new.py b/modules/ducks_new.py index 261bb24b..7ca9bada 100644 --- a/modules/ducks_new.py +++ b/modules/ducks_new.py @@ -96,11 +96,10 @@ class Module(object): return user = event["user"] - hostname = user.hostname game = channel.games["ducks"] - if hostname not in game["unique_nicks"]: - game["unique_nicks"].append(hostname) + if user not in game["unique_nicks"]: + game["unique_nicks"].append(user) if game["current_unique_nicks"] > 0: game["current_unique_nicks"] = game["current_unique_nicks"] - 1 @@ -112,3 +111,5 @@ class Module(object): if game["current_active_delay"] > 0: game["current_active_delay"] = game["current_active_delay"] \ - DELAY_REDUCE + + print(game) \ No newline at end of file -- cgit v1.3.1-10-gc9f91 From ac1eef729c929749413cdee31d8ab4643260b7d5 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 16:15:43 +0100 Subject: New and fresh ducks.py! And an 8ball.py adjustment...! --- modules/8ball.py | 4 +- modules/ducks.py | 432 +++++++++++++++++++++++++++++++-------------------- modules/ducks_new.py | 115 -------------- modules/ducks_old.py | 263 +++++++++++++++++++++++++++++++ 4 files changed, 531 insertions(+), 283 deletions(-) delete mode 100644 modules/ducks_new.py create mode 100644 modules/ducks_old.py (limited to 'modules') diff --git a/modules/8ball.py b/modules/8ball.py index 39e786e0..1c058a28 100644 --- a/modules/8ball.py +++ b/modules/8ball.py @@ -1,4 +1,5 @@ import random +import Utils CHOICES = [ "Definitely", @@ -26,4 +27,5 @@ class Module(object): ) def decide(selfs, event): - event["stdout"].write(random.choice(CHOICES)) + event["stdout"].write("You shake the magic ball... it " + "says " + Utils.bold(random.choice(CHOICES))) diff --git a/modules/ducks.py b/modules/ducks.py index 9b2d78f2..a29213ac 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -1,224 +1,261 @@ +import random from operator import itemgetter -from threading import Timer +from time import time + import Utils -import random -DUCK_LIST = [ - "・゜゜・。。・゜ ​ ゜\_O​< q​uack!", - "・゜゜・。。・゜ ​ ゜\_o< QUACK!", - "・゜゜・。 ​ 。・゜゜\​_ó< qu​ack!", - "・゜゜・。 ​ 。・゜゜\​_ó< qu​ack quack!", - "・゜゜ 。 ​ 。・゜ \​_ó< bawk!", - "・゜゜ 。 ​ 。・゜゜\​_ó< squawk!", - "・ ゜・。 ​ 。・゜゜ \​_ó< beep beep!" -] +DUCK_TAIL = "・゜゜・。。・゜゜" +DUCK_HEAD = ["\_o< ", "\_O< ", "\_0< ", "\_\u00f6< ", "\_\u00f8< ", + "\_\u00f3< "] +DUCK_MESSAGE = ["QUACK!", "FLAP FLAP!", "quack!", "squawk!"] +DUCK_MESSAGE_RARE = ["beep boop!", "QUACK QUACK QUACK QUACK QUACK!!", + "HONK!", "I AM THE METAL DUCK"] + +DUCK_MINIMUM_MESSAGES = 10 +DUCK_MINIMUM_UNIQUE = 3 + +CHANNELS_ENABLED = [] + class Module(object): + def __init__(self, bot, events, exports): self.bot = bot self.events = events - events.on("received.command.bef").hook(self.duck_bef, - help="Befriend a duck!") - events.on("received.command.bang").hook(self.duck_bang, - help="Shoot a duck! Meanie.") - events.on("received.command.decoy").hook(self.set_decoy, - help="Be a sneaky fellow and make a decoy duck.") - events.on("received.command.friends").hook(self.duck_friends, - help="See who the friendliest people to ducks are!") - events.on("received.command.killers").hook(self.duck_enemies, - help="See who shoots the most amount of ducks.") - events.on("received.command.duckstats").hook(self.duck_stats, - help="Shows your duck " - "stats!") + events.on("received").on("command").on("bef").hook(self.befriend, + priority=1, + help="Befriend a duck!") + events.on("received").on("command").on("bang").hook(self.shoot, + priority=1, + help="Shoot a " + "duck! " + "Meanie.", + ) + # events.on("received").on("command").on("decoy").hook(self.set_decoy, + # help="Be a + # sneaky fellow + # and make a + # decoy duck!") + events.on("received").on("command").on("friends").hook( + self.duck_friends, + help="See who the friendliest people to ducks are!") + events.on("received").on("command").on("killers").hook( + self.duck_enemies, + help="See who shoots the most smount of ducks!") + events.on("received").on("command").on("duckstats").hook( + self.duck_stats, + help="Shows your duck stats!") + + exports.add("channelset", {"setting": "ducks-enabled", + "help": "Toggle ducks!", + "validate": Utils.bool_or_none}) + + exports.add("channelset", {"setting": "ducks-kick", + "help": "Should the bot kick if there's no duck?", + "validate": Utils.bool_or_none}) + + events.on("new.channel").hook(self.bootstrap) + + events.on("received").on("message").on("channel").hook( + self.channel_message, priority=2) + def bootstrap(self, event): + channel = event["channel"] - #exports.add("channelset", {"setting": "ducks-enabled", - # "help": "Toggle ducks!", "validate": Utils.bool_or_none}) + self.init_game_var(channel) + # getset + ducks_enabled = channel.get_setting("ducks-enabled", False) - #events.on("received.numeric.366").hook(self.bootstrap) + if ducks_enabled == True: + self.start_game(channel) - #events.on("raw").on("376").hook(self.duck_loop_entry) + def is_duck_channel(self, channel): + if channel.get_setting("ducks-enabled", False) == False: + return False - #events.on("timer").on("duck-decoy").hook(self.duck_decoy) - #events.on("timer").on("show-duck").hook(self.show_duck) + if hasattr(channel, 'games') == False: + return False - def duck_loop_entry(self, event): - wait = self.get_random_duck_time() - self.bot.log.info("Sending out a wave of ducks in %s seconds", - [wait]) - self.bot.add_timer("show-duck", wait, persist=False) + if hasattr(channel["games"], 'ducks') == False: + return False - def bootstrap(self, event): - for server in self.bot.servers.values(): - for channel in server.channels.values(): - ducks_enabled = channel.get_setting("ducks-enabled", False) + return True - if ducks_enabled == True: - channel.set_setting("active-duck", False) + def init_game_var(self, channel): + if hasattr(channel, 'games') == False: + channel.games = {} - def duck_enemies(self, event): - the_enemy = event["server"].find_all_user_channel_settings( - "ducks-shot") + def clear_ducks(self, channel): + rand_time = self.generate_next_duck_time() - notorious = {} - enemy_nicks = [] - enemy_ducks = [] + channel.games["ducks"] = { + 'messages': 0, + 'duck_spawned': 0, + 'unique_users': [], + 'next_duck_time': rand_time + } - for i in the_enemy: - if i[1] in notorious.keys(): - notorious[i[1]] += i[2] - else: - notorious[i[1]] = i[2] + def start_game(self, channel): + # event is immediately the IRCChannel.Channel() event for the current + # channel + self.clear_ducks(channel) - for user, enemies in sorted(notorious.items(), key=itemgetter(1), - reverse=True): - enemy_nicks.append(user) - enemy_ducks.append(enemies) + def generate_next_duck_time(self): + rand_time = random.randint(int(time()) + 300, int(time()) + 1200) + return rand_time - sentence = "Most Notorious Users -- " + def is_duck_visible(self, event): + channel = event["target"] - length = len(enemy_nicks) if len(enemy_nicks) < 11 else 11 + visible = bool(channel.games["ducks"]["duck_spawned"]) + return visible - for i in range(0, length): - sentence += enemy_nicks[i] + " (" + str(enemy_ducks[i]) + ")" - if i < 10: - sentence += ", " + def should_kick(self, event): + channel = event["target"] + return channel.get_setting("ducks-kick", False) - sentence = sentence[0:-2] + def kick_bef(self, event): + channel = event["target"] + target = event["user"].nickname - event["stdout"].write(sentence) + channel.send_kick(target, + "You tried befriending a non-existent duck. Creepy!") - def duck_friends(self, event): - friends = event["server"].find_all_user_channel_settings( - "ducks-befriended") + def kick_bang(self, event): + channel = event["target"] + target = event["user"].nickname - friendliest = {} - friend_nicks = [] - friend_ducks = [] + channel.send_kick(target, + "You tried shooting a non-existent duck. Creepy!") - for i in friends: - if i[1] in friendliest.keys(): - friendliest[i[1]] += i[2] - else: - friendliest[i[1]] = i[2] + def should_generate_duck(self, event): + channel = event["channel"] + game = channel.games["ducks"] - for user, friends in sorted(friendliest.items(), key = itemgetter(1), - reverse = True): - friend_nicks.append(user) - friend_ducks.append(friends) + spawned = game["duck_spawned"] + unique = len(game["unique_users"]) + messages = game["messages"] + next_duck = game["next_duck_time"] - sentence = "Friendliest Users -- " + # DUCK_MINIMUM_MESSAGES = 10 + # DUCK_MINIMUM_UNIQUE = 3 - length = len(friend_nicks) if len(friend_nicks) < 11 else 11 + if spawned == 0 and next_duck < time() and unique > \ + DUCK_MINIMUM_UNIQUE and \ + messages > \ + DUCK_MINIMUM_MESSAGES: + return True + else: + return False - for i in range(0, length): - sentence += friend_nicks[i] + " (" + str(friend_ducks[i]) + ")" - if i < 10: - sentence += ", " + def show_duck(self, event): + channel = event["channel"] + duck = "" - sentence = sentence[0:-2] + if channel.games["ducks"]["duck_spawned"] == 1: + return - event["stdout"].write(sentence) + duck += DUCK_TAIL + duck += random.choice(DUCK_HEAD) + + duck = str(Utils.color(4) + Utils.bold(duck + random.choice( + DUCK_MESSAGE_RARE)) + Utils.color(4)) if 1 == random.randint(1, 20) \ + else duck + random.choice(DUCK_MESSAGE) + + channel.send_message(duck) + channel.games["ducks"]["duck_spawned"] = 1 + + def channel_message(self, event): + channel = event["channel"] + + if "ducks" not in channel.games.keys(): + return - def duck_bef(self, event): user = event["user"] - target = user.nickname - id = user.get_id() + game = channel.games["ducks"] + delay_increment = 0 - active_duck = event["target"].get_setting("active-duck", False) + if game["duck_spawned"] == 1 or channel.has_user( + event["user"]) == False: + return - if active_duck == False: - if event["server"].has_user(target): - if not event["server"].is_own_nickname(target): - event["target"].send_kick(target, - "You tried befriending a non-existent duck. Creepy!") - else: - event["stderr"].write("Nope.") - else: - event["stderr"].write("That user is not in this channel") - else: - befriended_ducks = event["target"].get_user_setting(id, - "ducks-befriended", - 0) - event["target"].set_user_setting(id, - "ducks-befriended", - befriended_ducks + 1) - event["target"].set_setting("active-duck", False) + unique = game["unique_users"] + messages = game["messages"] - grammar = "" if befriended_ducks == 0 else "s" + if user not in unique: + game["unique_users"].append(user) + messages_increment = 1 + else: + messages_increment = 0.5 - event["stdout"].write( - target + ", you've befriended " + Utils.bold(str( - befriended_ducks + 1)) + " duck" + grammar + " in " + - Utils.bold(event[ - "target"].name)) + game["messages"] = messages + messages_increment - self.duck_loop_entry(event) + if self.should_generate_duck(event) == True: + self.show_duck(event) - def duck_bang(self, event): + def befriend(self, event): + channel = event["target"] user = event["user"] - target = user.nickname - id = user.get_id() - if not event["target"].get_setting("active-duck", False): - event["stderr"].set_prefix("Kick") - if event["server"].has_user(target): - if not event["server"].is_own_nickname(target): - event["target"].send_kick(target, - "You tried shooting a non-existent duck. Creepy!") - else: - event["stderr"].write("Nope.") - else: - event["stderr"].write("That user is not in this channel") - else: - shot_ducks = event["target"].get_user_setting(id, "ducks-shot", 0) - event["target"].set_user_setting(id, "ducks-shot", shot_ducks + 1) - event["target"].set_setting("active-duck", False) + nick = user.nickname + uid = user.get_id() + print(channel) + if self.is_duck_channel(channel) == False: + return - grammar = "" if shot_ducks == 0 else "s" + if self.is_duck_visible(event) == False: + if self.should_kick(event): + self.kick_bef(event) + return - event["stdout"].write( - target + ", you've shot " - + Utils.bold(str(shot_ducks + 1)) + " duck" - + grammar + " in " - + Utils.bold(event["target"].name)) + channel.games["ducks"][ + "next_duck_time"] = self.generate_next_duck_time() + channel.games["ducks"]["duck_spawned"] = 0 - self.duck_loop_entry(event) + total_befriended = channel.get_user_setting(uid, "ducks-befriended", 0) + total_befriended = total_befriended + 1 - def get_random_duck_time(self): - return random.randint(720, 3600) + channel.set_user_setting(uid, "ducks-befriended", total_befriended) - def show_duck(self, event): - for server in self.bot.servers.values(): - for channel in server.channels.values(): - ducks_enabled = channel.get_setting("ducks-enabled", False) + event["stdout"].write( + "Aww! " + nick + " befriended a duck! You've befriended " + + Utils.bold( + str( + total_befriended)) + " ducks in " + Utils.bold( + channel.name) + "!") - if ducks_enabled == False: - continue + self.clear_ducks(channel) - active_duck = channel.get_setting("active-duck", False) + def shoot(self, event): + channel = event["target"] + user = event["user"] + nick = user.nickname + uid = user.get_id() - if ducks_enabled == True and active_duck == False: - channel.send_message(random.choice(DUCK_LIST)) + if self.is_duck_channel(channel) == False: + return - channel.set_setting("active-duck", True) + if self.is_duck_visible(event) == False: + if self.should_kick(event): + self.kick_bang(event) + return - elif ducks_enabled == True and active_duck == True: - pass + channel.games["ducks"][ + "next_duck_time"] = self.generate_next_duck_time() + channel.games["ducks"]["duck_spawned"] = 0 - else: - channel.set_setting("active-duck", False) + total_shot = channel.get_user_setting(uid, "ducks-shot", 0) + total_shot = total_shot + 1 - def duck_decoy(self, event): - self.events.on("send").on("stdout").call(target=event["channel"], - module_name="Ducks", server=event["server"], - message=random.choice(DUCK_LIST)) + channel.set_user_setting(uid, "ducks-shot", total_shot) - def set_decoy(self, event): - next_decoy_time = self.get_random_duck_time() - self.bot.add_timer("duck-decoy", next_decoy_time, persist=False, - server=event["server"], channel=event["target"]) + event["stdout"].write( + "Pow! " + nick + " shot a duck! You've shot " + Utils.bold( + str( + total_shot)) + " ducks in " + Utils.bold( + channel.name) + "!") + self.clear_ducks(channel) def duck_stats(self, event): user = event["user"] @@ -229,8 +266,8 @@ class Module(object): poached = user.get_channel_settings_per_setting("ducks-shot", [] ) friends = user.get_channel_settings_per_setting( - "ducks-befriended", [] - ) + "ducks-befriended", [] + ) channel_friends = 0 channel_poached = 0 @@ -255,9 +292,70 @@ class Module(object): event["stdout"].write( nick + ": " + str(total_poached) + " ducks killed (" + str( channel_poached) + " in " + channel + "), and " + str( - total_friends) + " ducks befriended (" + str(channel_friends) + total_friends) + " ducks befriended (" + str( + channel_friends) + " in " + channel + ")") + def duck_enemies(self, event): + the_enemy = event["server"].find_all_user_channel_settings( + "ducks-shot") + + notorious = {} + enemy_nicks = [] + enemy_ducks = [] + + for i in the_enemy: + if i[1] in notorious.keys(): + notorious[i[1]] += i[2] + else: + notorious[i[1]] = i[2] + + for user, enemies in sorted(notorious.items(), key=itemgetter(1), + reverse=True): + enemy_nicks.append(user) + enemy_ducks.append(enemies) + + sentence = "Most Notorious Users -- " + + length = len(enemy_nicks) if len(enemy_nicks) < 11 else 11 + + for i in range(0, length): + sentence += enemy_nicks[i] + " (" + str(enemy_ducks[i]) + ")" + if i < 10: + sentence += ", " + + sentence = sentence[0:-2] - + event["stdout"].write(sentence) + + def duck_friends(self, event): + friends = event["server"].find_all_user_channel_settings( + "ducks-befriended") + + friendliest = {} + friend_nicks = [] + friend_ducks = [] + + for i in friends: + if i[1] in friendliest.keys(): + friendliest[i[1]] += i[2] + else: + friendliest[i[1]] = i[2] + for user, friends in sorted(friendliest.items(), key=itemgetter(1), + reverse=True): + friend_nicks.append(user) + friend_ducks.append(friends) + + sentence = "Friendliest Users -- " + + length = len(friend_nicks) if len(friend_nicks) < 11 else 11 + + for i in range(0, length): + sentence += friend_nicks[i] + " (" + str(friend_ducks[i]) + ")" + if i < 10: + sentence += ", " + + sentence = sentence[0:-2] + + event["stdout"].write(sentence) diff --git a/modules/ducks_new.py b/modules/ducks_new.py deleted file mode 100644 index 7ca9bada..00000000 --- a/modules/ducks_new.py +++ /dev/null @@ -1,115 +0,0 @@ -from operator import itemgetter -import Utils -import random - -DUCK_TAIL = "・゜゜・。。・゜゜" -DUCK_HEAD = ["\_o< ", "\_O< ", "\_0< ", "\_\u00f6< ", "\_\u00f8< ", - "\_\u00f3< "] -DUCK_MESSAGE = ["QUACK!", "FLAP FLAP!", "quack!", "squawk!"] -DUCK_MESSAGE_RARE = ["beep boop!", "QUACK QUACK QUACK QUACK QUACK!!", "HONK!"] - -DELAY_REDUCE_UNIQUE = 1 -DELAY_REDUCE = 0.5 - -CHANNELS_ENABLED = [] - - -class Module(object): - def __init__(self, bot, events, exports): - self.bot = bot - self.events = events - - # events.on("received").on("command").on("bef").hook(self.duck_action, - # help="Befriend a duck!") - # events.on("received").on("command").on("bang").hook(self.duck_bang, - # help="Shoot a duck! Meanie.") - # events.on("received").on("command").on("decoy").hook(self.set_decoy, - # help="Be a sneaky fellow - ## and make a decoy duck.") - # events.on("received").on("command").on("friends").hook( - # self.duck_friends, - # help="See who the - # friendliest people to ducks are!") - # events.on("received").on("command").on("killers").hook( - # self.duck_enemies, - # help="See who shoots the - # most amount of ducks.") - # events.on("received").on("command").on("duckstats").hook( - # self.duck_stats, - # help="Shows your duck " - # "stats!") - - exports.add("channelset", {"setting": "ducks-enabled", - "help": "Toggle ducks!", - "validate": Utils.bool_or_none}) - - events.on("new.channel").hook(self.bootstrap) - - events.on("received").on("message").on("channel").hook( - self.channel_message) - - def bootstrap(self, event): - channel = event["channel"] - print("Init for " + channel.name) - self.init_game_var(channel) - # getset - ducks_enabled = channel.get_setting("ducks-enabled", False) - - print("Ducks enabled for " + channel.name + " -- " + str( - ducks_enabled)) - if ducks_enabled == True: - print("Starting game for " + channel.name) - self.start_game(channel) - - def init_game_var(self, event): - channel = event - - - if hasattr(channel, 'games') == False: - channel.games = {} - - - def start_game(self, event): - # event is immediately the IRCChannel.Channel() event for the current - # channel - - channel = event - - print("Starting duck game for channel: " + channel.name) - - if "ducks" not in channel.games.keys(): - channel.games["ducks"] = { - 'current_active_delay': 10, - 'current_unique_nicks': 3, - 'duck_spawned': 0, - 'unique_nicks': [] - } - - print(channel.games) - - - def channel_message(self, event): - channel = event["channel"] - channel_name = channel.name - - if "ducks" not in channel.games.keys(): - return - - user = event["user"] - game = channel.games["ducks"] - - if user not in game["unique_nicks"]: - game["unique_nicks"].append(user) - - if game["current_unique_nicks"] > 0: - game["current_unique_nicks"] = game["current_unique_nicks"] - 1 - - if game["current_active_delay"] > 0: - game["current_active_delay"] = game["current_active_delay"] \ - - DELAY_REDUCE_UNIQUE - else: - if game["current_active_delay"] > 0: - game["current_active_delay"] = game["current_active_delay"] \ - - DELAY_REDUCE - - print(game) \ No newline at end of file diff --git a/modules/ducks_old.py b/modules/ducks_old.py new file mode 100644 index 00000000..9b2d78f2 --- /dev/null +++ b/modules/ducks_old.py @@ -0,0 +1,263 @@ +from operator import itemgetter +from threading import Timer +import Utils +import random + +DUCK_LIST = [ + "・゜゜・。。・゜ ​ ゜\_O​< q​uack!", + "・゜゜・。。・゜ ​ ゜\_o< QUACK!", + "・゜゜・。 ​ 。・゜゜\​_ó< qu​ack!", + "・゜゜・。 ​ 。・゜゜\​_ó< qu​ack quack!", + "・゜゜ 。 ​ 。・゜ \​_ó< bawk!", + "・゜゜ 。 ​ 。・゜゜\​_ó< squawk!", + "・ ゜・。 ​ 。・゜゜ \​_ó< beep beep!" +] + +class Module(object): + def __init__(self, bot, events, exports): + self.bot = bot + self.events = events + + events.on("received.command.bef").hook(self.duck_bef, + help="Befriend a duck!") + events.on("received.command.bang").hook(self.duck_bang, + help="Shoot a duck! Meanie.") + events.on("received.command.decoy").hook(self.set_decoy, + help="Be a sneaky fellow and make a decoy duck.") + events.on("received.command.friends").hook(self.duck_friends, + help="See who the friendliest people to ducks are!") + events.on("received.command.killers").hook(self.duck_enemies, + help="See who shoots the most amount of ducks.") + events.on("received.command.duckstats").hook(self.duck_stats, + help="Shows your duck " + "stats!") + + + #exports.add("channelset", {"setting": "ducks-enabled", + # "help": "Toggle ducks!", "validate": Utils.bool_or_none}) + + #events.on("received.numeric.366").hook(self.bootstrap) + + #events.on("raw").on("376").hook(self.duck_loop_entry) + + #events.on("timer").on("duck-decoy").hook(self.duck_decoy) + #events.on("timer").on("show-duck").hook(self.show_duck) + + def duck_loop_entry(self, event): + wait = self.get_random_duck_time() + self.bot.log.info("Sending out a wave of ducks in %s seconds", + [wait]) + self.bot.add_timer("show-duck", wait, persist=False) + + def bootstrap(self, event): + for server in self.bot.servers.values(): + for channel in server.channels.values(): + ducks_enabled = channel.get_setting("ducks-enabled", False) + + if ducks_enabled == True: + channel.set_setting("active-duck", False) + + def duck_enemies(self, event): + the_enemy = event["server"].find_all_user_channel_settings( + "ducks-shot") + + notorious = {} + enemy_nicks = [] + enemy_ducks = [] + + for i in the_enemy: + if i[1] in notorious.keys(): + notorious[i[1]] += i[2] + else: + notorious[i[1]] = i[2] + + for user, enemies in sorted(notorious.items(), key=itemgetter(1), + reverse=True): + enemy_nicks.append(user) + enemy_ducks.append(enemies) + + sentence = "Most Notorious Users -- " + + length = len(enemy_nicks) if len(enemy_nicks) < 11 else 11 + + for i in range(0, length): + sentence += enemy_nicks[i] + " (" + str(enemy_ducks[i]) + ")" + if i < 10: + sentence += ", " + + sentence = sentence[0:-2] + + event["stdout"].write(sentence) + + def duck_friends(self, event): + friends = event["server"].find_all_user_channel_settings( + "ducks-befriended") + + friendliest = {} + friend_nicks = [] + friend_ducks = [] + + for i in friends: + if i[1] in friendliest.keys(): + friendliest[i[1]] += i[2] + else: + friendliest[i[1]] = i[2] + + for user, friends in sorted(friendliest.items(), key = itemgetter(1), + reverse = True): + friend_nicks.append(user) + friend_ducks.append(friends) + + sentence = "Friendliest Users -- " + + length = len(friend_nicks) if len(friend_nicks) < 11 else 11 + + for i in range(0, length): + sentence += friend_nicks[i] + " (" + str(friend_ducks[i]) + ")" + if i < 10: + sentence += ", " + + sentence = sentence[0:-2] + + event["stdout"].write(sentence) + + def duck_bef(self, event): + user = event["user"] + target = user.nickname + id = user.get_id() + + active_duck = event["target"].get_setting("active-duck", False) + + if active_duck == False: + if event["server"].has_user(target): + if not event["server"].is_own_nickname(target): + event["target"].send_kick(target, + "You tried befriending a non-existent duck. Creepy!") + else: + event["stderr"].write("Nope.") + else: + event["stderr"].write("That user is not in this channel") + else: + befriended_ducks = event["target"].get_user_setting(id, + "ducks-befriended", + 0) + event["target"].set_user_setting(id, + "ducks-befriended", + befriended_ducks + 1) + event["target"].set_setting("active-duck", False) + + grammar = "" if befriended_ducks == 0 else "s" + + event["stdout"].write( + target + ", you've befriended " + Utils.bold(str( + befriended_ducks + 1)) + " duck" + grammar + " in " + + Utils.bold(event[ + "target"].name)) + + self.duck_loop_entry(event) + + def duck_bang(self, event): + user = event["user"] + target = user.nickname + id = user.get_id() + if not event["target"].get_setting("active-duck", False): + event["stderr"].set_prefix("Kick") + if event["server"].has_user(target): + if not event["server"].is_own_nickname(target): + event["target"].send_kick(target, + "You tried shooting a non-existent duck. Creepy!") + else: + event["stderr"].write("Nope.") + else: + event["stderr"].write("That user is not in this channel") + else: + shot_ducks = event["target"].get_user_setting(id, "ducks-shot", 0) + event["target"].set_user_setting(id, "ducks-shot", shot_ducks + 1) + event["target"].set_setting("active-duck", False) + + grammar = "" if shot_ducks == 0 else "s" + + event["stdout"].write( + target + ", you've shot " + + Utils.bold(str(shot_ducks + 1)) + " duck" + + grammar + " in " + + Utils.bold(event["target"].name)) + + self.duck_loop_entry(event) + + def get_random_duck_time(self): + return random.randint(720, 3600) + + def show_duck(self, event): + for server in self.bot.servers.values(): + for channel in server.channels.values(): + ducks_enabled = channel.get_setting("ducks-enabled", False) + + if ducks_enabled == False: + continue + + active_duck = channel.get_setting("active-duck", False) + + if ducks_enabled == True and active_duck == False: + channel.send_message(random.choice(DUCK_LIST)) + + channel.set_setting("active-duck", True) + + elif ducks_enabled == True and active_duck == True: + pass + + else: + channel.set_setting("active-duck", False) + + def duck_decoy(self, event): + self.events.on("send").on("stdout").call(target=event["channel"], + module_name="Ducks", server=event["server"], + message=random.choice(DUCK_LIST)) + + def set_decoy(self, event): + next_decoy_time = self.get_random_duck_time() + self.bot.add_timer("duck-decoy", next_decoy_time, persist=False, + server=event["server"], channel=event["target"]) + + + def duck_stats(self, event): + user = event["user"] + channel = event["target"].name + nick = user.nickname + id = user.get_id() + + poached = user.get_channel_settings_per_setting("ducks-shot", [] + ) + friends = user.get_channel_settings_per_setting( + "ducks-befriended", [] + ) + + channel_friends = 0 + channel_poached = 0 + + total_friends = 0 + total_poached = 0 + + for room, number in friends: + if room == channel: + channel_friends = number + total_friends += number + else: + total_friends += number + + for room, number in poached: + if room == channel: + channel_poached = number + total_poached += number + else: + total_poached += number + + event["stdout"].write( + nick + ": " + str(total_poached) + " ducks killed (" + str( + channel_poached) + " in " + channel + "), and " + str( + total_friends) + " ducks befriended (" + str(channel_friends) + + " in " + channel + ")") + + + + -- cgit v1.3.1-10-gc9f91 From 5643af1fe4600e74f9af42d2aaf43e3525faed80 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 16:26:50 +0100 Subject: Rename ducks_old.py to stop it getting autoloaded. --- modules/ducks.py_old | 263 +++++++++++++++++++++++++++++++++++++++++++++++++++ modules/ducks_old.py | 263 --------------------------------------------------- 2 files changed, 263 insertions(+), 263 deletions(-) create mode 100644 modules/ducks.py_old delete mode 100644 modules/ducks_old.py (limited to 'modules') diff --git a/modules/ducks.py_old b/modules/ducks.py_old new file mode 100644 index 00000000..9b2d78f2 --- /dev/null +++ b/modules/ducks.py_old @@ -0,0 +1,263 @@ +from operator import itemgetter +from threading import Timer +import Utils +import random + +DUCK_LIST = [ + "・゜゜・。。・゜ ​ ゜\_O​< q​uack!", + "・゜゜・。。・゜ ​ ゜\_o< QUACK!", + "・゜゜・。 ​ 。・゜゜\​_ó< qu​ack!", + "・゜゜・。 ​ 。・゜゜\​_ó< qu​ack quack!", + "・゜゜ 。 ​ 。・゜ \​_ó< bawk!", + "・゜゜ 。 ​ 。・゜゜\​_ó< squawk!", + "・ ゜・。 ​ 。・゜゜ \​_ó< beep beep!" +] + +class Module(object): + def __init__(self, bot, events, exports): + self.bot = bot + self.events = events + + events.on("received.command.bef").hook(self.duck_bef, + help="Befriend a duck!") + events.on("received.command.bang").hook(self.duck_bang, + help="Shoot a duck! Meanie.") + events.on("received.command.decoy").hook(self.set_decoy, + help="Be a sneaky fellow and make a decoy duck.") + events.on("received.command.friends").hook(self.duck_friends, + help="See who the friendliest people to ducks are!") + events.on("received.command.killers").hook(self.duck_enemies, + help="See who shoots the most amount of ducks.") + events.on("received.command.duckstats").hook(self.duck_stats, + help="Shows your duck " + "stats!") + + + #exports.add("channelset", {"setting": "ducks-enabled", + # "help": "Toggle ducks!", "validate": Utils.bool_or_none}) + + #events.on("received.numeric.366").hook(self.bootstrap) + + #events.on("raw").on("376").hook(self.duck_loop_entry) + + #events.on("timer").on("duck-decoy").hook(self.duck_decoy) + #events.on("timer").on("show-duck").hook(self.show_duck) + + def duck_loop_entry(self, event): + wait = self.get_random_duck_time() + self.bot.log.info("Sending out a wave of ducks in %s seconds", + [wait]) + self.bot.add_timer("show-duck", wait, persist=False) + + def bootstrap(self, event): + for server in self.bot.servers.values(): + for channel in server.channels.values(): + ducks_enabled = channel.get_setting("ducks-enabled", False) + + if ducks_enabled == True: + channel.set_setting("active-duck", False) + + def duck_enemies(self, event): + the_enemy = event["server"].find_all_user_channel_settings( + "ducks-shot") + + notorious = {} + enemy_nicks = [] + enemy_ducks = [] + + for i in the_enemy: + if i[1] in notorious.keys(): + notorious[i[1]] += i[2] + else: + notorious[i[1]] = i[2] + + for user, enemies in sorted(notorious.items(), key=itemgetter(1), + reverse=True): + enemy_nicks.append(user) + enemy_ducks.append(enemies) + + sentence = "Most Notorious Users -- " + + length = len(enemy_nicks) if len(enemy_nicks) < 11 else 11 + + for i in range(0, length): + sentence += enemy_nicks[i] + " (" + str(enemy_ducks[i]) + ")" + if i < 10: + sentence += ", " + + sentence = sentence[0:-2] + + event["stdout"].write(sentence) + + def duck_friends(self, event): + friends = event["server"].find_all_user_channel_settings( + "ducks-befriended") + + friendliest = {} + friend_nicks = [] + friend_ducks = [] + + for i in friends: + if i[1] in friendliest.keys(): + friendliest[i[1]] += i[2] + else: + friendliest[i[1]] = i[2] + + for user, friends in sorted(friendliest.items(), key = itemgetter(1), + reverse = True): + friend_nicks.append(user) + friend_ducks.append(friends) + + sentence = "Friendliest Users -- " + + length = len(friend_nicks) if len(friend_nicks) < 11 else 11 + + for i in range(0, length): + sentence += friend_nicks[i] + " (" + str(friend_ducks[i]) + ")" + if i < 10: + sentence += ", " + + sentence = sentence[0:-2] + + event["stdout"].write(sentence) + + def duck_bef(self, event): + user = event["user"] + target = user.nickname + id = user.get_id() + + active_duck = event["target"].get_setting("active-duck", False) + + if active_duck == False: + if event["server"].has_user(target): + if not event["server"].is_own_nickname(target): + event["target"].send_kick(target, + "You tried befriending a non-existent duck. Creepy!") + else: + event["stderr"].write("Nope.") + else: + event["stderr"].write("That user is not in this channel") + else: + befriended_ducks = event["target"].get_user_setting(id, + "ducks-befriended", + 0) + event["target"].set_user_setting(id, + "ducks-befriended", + befriended_ducks + 1) + event["target"].set_setting("active-duck", False) + + grammar = "" if befriended_ducks == 0 else "s" + + event["stdout"].write( + target + ", you've befriended " + Utils.bold(str( + befriended_ducks + 1)) + " duck" + grammar + " in " + + Utils.bold(event[ + "target"].name)) + + self.duck_loop_entry(event) + + def duck_bang(self, event): + user = event["user"] + target = user.nickname + id = user.get_id() + if not event["target"].get_setting("active-duck", False): + event["stderr"].set_prefix("Kick") + if event["server"].has_user(target): + if not event["server"].is_own_nickname(target): + event["target"].send_kick(target, + "You tried shooting a non-existent duck. Creepy!") + else: + event["stderr"].write("Nope.") + else: + event["stderr"].write("That user is not in this channel") + else: + shot_ducks = event["target"].get_user_setting(id, "ducks-shot", 0) + event["target"].set_user_setting(id, "ducks-shot", shot_ducks + 1) + event["target"].set_setting("active-duck", False) + + grammar = "" if shot_ducks == 0 else "s" + + event["stdout"].write( + target + ", you've shot " + + Utils.bold(str(shot_ducks + 1)) + " duck" + + grammar + " in " + + Utils.bold(event["target"].name)) + + self.duck_loop_entry(event) + + def get_random_duck_time(self): + return random.randint(720, 3600) + + def show_duck(self, event): + for server in self.bot.servers.values(): + for channel in server.channels.values(): + ducks_enabled = channel.get_setting("ducks-enabled", False) + + if ducks_enabled == False: + continue + + active_duck = channel.get_setting("active-duck", False) + + if ducks_enabled == True and active_duck == False: + channel.send_message(random.choice(DUCK_LIST)) + + channel.set_setting("active-duck", True) + + elif ducks_enabled == True and active_duck == True: + pass + + else: + channel.set_setting("active-duck", False) + + def duck_decoy(self, event): + self.events.on("send").on("stdout").call(target=event["channel"], + module_name="Ducks", server=event["server"], + message=random.choice(DUCK_LIST)) + + def set_decoy(self, event): + next_decoy_time = self.get_random_duck_time() + self.bot.add_timer("duck-decoy", next_decoy_time, persist=False, + server=event["server"], channel=event["target"]) + + + def duck_stats(self, event): + user = event["user"] + channel = event["target"].name + nick = user.nickname + id = user.get_id() + + poached = user.get_channel_settings_per_setting("ducks-shot", [] + ) + friends = user.get_channel_settings_per_setting( + "ducks-befriended", [] + ) + + channel_friends = 0 + channel_poached = 0 + + total_friends = 0 + total_poached = 0 + + for room, number in friends: + if room == channel: + channel_friends = number + total_friends += number + else: + total_friends += number + + for room, number in poached: + if room == channel: + channel_poached = number + total_poached += number + else: + total_poached += number + + event["stdout"].write( + nick + ": " + str(total_poached) + " ducks killed (" + str( + channel_poached) + " in " + channel + "), and " + str( + total_friends) + " ducks befriended (" + str(channel_friends) + + " in " + channel + ")") + + + + diff --git a/modules/ducks_old.py b/modules/ducks_old.py deleted file mode 100644 index 9b2d78f2..00000000 --- a/modules/ducks_old.py +++ /dev/null @@ -1,263 +0,0 @@ -from operator import itemgetter -from threading import Timer -import Utils -import random - -DUCK_LIST = [ - "・゜゜・。。・゜ ​ ゜\_O​< q​uack!", - "・゜゜・。。・゜ ​ ゜\_o< QUACK!", - "・゜゜・。 ​ 。・゜゜\​_ó< qu​ack!", - "・゜゜・。 ​ 。・゜゜\​_ó< qu​ack quack!", - "・゜゜ 。 ​ 。・゜ \​_ó< bawk!", - "・゜゜ 。 ​ 。・゜゜\​_ó< squawk!", - "・ ゜・。 ​ 。・゜゜ \​_ó< beep beep!" -] - -class Module(object): - def __init__(self, bot, events, exports): - self.bot = bot - self.events = events - - events.on("received.command.bef").hook(self.duck_bef, - help="Befriend a duck!") - events.on("received.command.bang").hook(self.duck_bang, - help="Shoot a duck! Meanie.") - events.on("received.command.decoy").hook(self.set_decoy, - help="Be a sneaky fellow and make a decoy duck.") - events.on("received.command.friends").hook(self.duck_friends, - help="See who the friendliest people to ducks are!") - events.on("received.command.killers").hook(self.duck_enemies, - help="See who shoots the most amount of ducks.") - events.on("received.command.duckstats").hook(self.duck_stats, - help="Shows your duck " - "stats!") - - - #exports.add("channelset", {"setting": "ducks-enabled", - # "help": "Toggle ducks!", "validate": Utils.bool_or_none}) - - #events.on("received.numeric.366").hook(self.bootstrap) - - #events.on("raw").on("376").hook(self.duck_loop_entry) - - #events.on("timer").on("duck-decoy").hook(self.duck_decoy) - #events.on("timer").on("show-duck").hook(self.show_duck) - - def duck_loop_entry(self, event): - wait = self.get_random_duck_time() - self.bot.log.info("Sending out a wave of ducks in %s seconds", - [wait]) - self.bot.add_timer("show-duck", wait, persist=False) - - def bootstrap(self, event): - for server in self.bot.servers.values(): - for channel in server.channels.values(): - ducks_enabled = channel.get_setting("ducks-enabled", False) - - if ducks_enabled == True: - channel.set_setting("active-duck", False) - - def duck_enemies(self, event): - the_enemy = event["server"].find_all_user_channel_settings( - "ducks-shot") - - notorious = {} - enemy_nicks = [] - enemy_ducks = [] - - for i in the_enemy: - if i[1] in notorious.keys(): - notorious[i[1]] += i[2] - else: - notorious[i[1]] = i[2] - - for user, enemies in sorted(notorious.items(), key=itemgetter(1), - reverse=True): - enemy_nicks.append(user) - enemy_ducks.append(enemies) - - sentence = "Most Notorious Users -- " - - length = len(enemy_nicks) if len(enemy_nicks) < 11 else 11 - - for i in range(0, length): - sentence += enemy_nicks[i] + " (" + str(enemy_ducks[i]) + ")" - if i < 10: - sentence += ", " - - sentence = sentence[0:-2] - - event["stdout"].write(sentence) - - def duck_friends(self, event): - friends = event["server"].find_all_user_channel_settings( - "ducks-befriended") - - friendliest = {} - friend_nicks = [] - friend_ducks = [] - - for i in friends: - if i[1] in friendliest.keys(): - friendliest[i[1]] += i[2] - else: - friendliest[i[1]] = i[2] - - for user, friends in sorted(friendliest.items(), key = itemgetter(1), - reverse = True): - friend_nicks.append(user) - friend_ducks.append(friends) - - sentence = "Friendliest Users -- " - - length = len(friend_nicks) if len(friend_nicks) < 11 else 11 - - for i in range(0, length): - sentence += friend_nicks[i] + " (" + str(friend_ducks[i]) + ")" - if i < 10: - sentence += ", " - - sentence = sentence[0:-2] - - event["stdout"].write(sentence) - - def duck_bef(self, event): - user = event["user"] - target = user.nickname - id = user.get_id() - - active_duck = event["target"].get_setting("active-duck", False) - - if active_duck == False: - if event["server"].has_user(target): - if not event["server"].is_own_nickname(target): - event["target"].send_kick(target, - "You tried befriending a non-existent duck. Creepy!") - else: - event["stderr"].write("Nope.") - else: - event["stderr"].write("That user is not in this channel") - else: - befriended_ducks = event["target"].get_user_setting(id, - "ducks-befriended", - 0) - event["target"].set_user_setting(id, - "ducks-befriended", - befriended_ducks + 1) - event["target"].set_setting("active-duck", False) - - grammar = "" if befriended_ducks == 0 else "s" - - event["stdout"].write( - target + ", you've befriended " + Utils.bold(str( - befriended_ducks + 1)) + " duck" + grammar + " in " + - Utils.bold(event[ - "target"].name)) - - self.duck_loop_entry(event) - - def duck_bang(self, event): - user = event["user"] - target = user.nickname - id = user.get_id() - if not event["target"].get_setting("active-duck", False): - event["stderr"].set_prefix("Kick") - if event["server"].has_user(target): - if not event["server"].is_own_nickname(target): - event["target"].send_kick(target, - "You tried shooting a non-existent duck. Creepy!") - else: - event["stderr"].write("Nope.") - else: - event["stderr"].write("That user is not in this channel") - else: - shot_ducks = event["target"].get_user_setting(id, "ducks-shot", 0) - event["target"].set_user_setting(id, "ducks-shot", shot_ducks + 1) - event["target"].set_setting("active-duck", False) - - grammar = "" if shot_ducks == 0 else "s" - - event["stdout"].write( - target + ", you've shot " - + Utils.bold(str(shot_ducks + 1)) + " duck" - + grammar + " in " - + Utils.bold(event["target"].name)) - - self.duck_loop_entry(event) - - def get_random_duck_time(self): - return random.randint(720, 3600) - - def show_duck(self, event): - for server in self.bot.servers.values(): - for channel in server.channels.values(): - ducks_enabled = channel.get_setting("ducks-enabled", False) - - if ducks_enabled == False: - continue - - active_duck = channel.get_setting("active-duck", False) - - if ducks_enabled == True and active_duck == False: - channel.send_message(random.choice(DUCK_LIST)) - - channel.set_setting("active-duck", True) - - elif ducks_enabled == True and active_duck == True: - pass - - else: - channel.set_setting("active-duck", False) - - def duck_decoy(self, event): - self.events.on("send").on("stdout").call(target=event["channel"], - module_name="Ducks", server=event["server"], - message=random.choice(DUCK_LIST)) - - def set_decoy(self, event): - next_decoy_time = self.get_random_duck_time() - self.bot.add_timer("duck-decoy", next_decoy_time, persist=False, - server=event["server"], channel=event["target"]) - - - def duck_stats(self, event): - user = event["user"] - channel = event["target"].name - nick = user.nickname - id = user.get_id() - - poached = user.get_channel_settings_per_setting("ducks-shot", [] - ) - friends = user.get_channel_settings_per_setting( - "ducks-befriended", [] - ) - - channel_friends = 0 - channel_poached = 0 - - total_friends = 0 - total_poached = 0 - - for room, number in friends: - if room == channel: - channel_friends = number - total_friends += number - else: - total_friends += number - - for room, number in poached: - if room == channel: - channel_poached = number - total_poached += number - else: - total_poached += number - - event["stdout"].write( - nick + ": " + str(total_poached) + " ducks killed (" + str( - channel_poached) + " in " + channel + "), and " + str( - total_friends) + " ducks befriended (" + str(channel_friends) - + " in " + channel + ")") - - - - -- cgit v1.3.1-10-gc9f91 From 763333eea89d01ae10b5fdb3fefe496a83ade396 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 16:34:28 +0100 Subject: PEP8 Compliance. --- modules/ducks.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index a29213ac..31a7fbe9 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -25,7 +25,8 @@ class Module(object): events.on("received").on("command").on("bef").hook(self.befriend, priority=1, - help="Befriend a duck!") + help="Befriend a " + "duck!") events.on("received").on("command").on("bang").hook(self.shoot, priority=1, help="Shoot a " @@ -52,7 +53,8 @@ class Module(object): "validate": Utils.bool_or_none}) exports.add("channelset", {"setting": "ducks-kick", - "help": "Should the bot kick if there's no duck?", + "help": "Should the bot kick if there's no " + "duck?", "validate": Utils.bool_or_none}) events.on("new.channel").hook(self.bootstrap) @@ -160,7 +162,8 @@ class Module(object): duck += random.choice(DUCK_HEAD) duck = str(Utils.color(4) + Utils.bold(duck + random.choice( - DUCK_MESSAGE_RARE)) + Utils.color(4)) if 1 == random.randint(1, 20) \ + DUCK_MESSAGE_RARE)) + Utils.color(4)) if 1 == random.randint(1, + 20) \ else duck + random.choice(DUCK_MESSAGE) channel.send_message(duck) -- cgit v1.3.1-10-gc9f91 From 54c9616d4c72c8c8985f4753b2ea780e04c6d71f Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 17:02:03 +0100 Subject: 8ball answer updates and ducks.py fix. --- modules/8ball.py | 7 ++++++- modules/ducks.py | 2 +- 2 files changed, 7 insertions(+), 2 deletions(-) (limited to 'modules') diff --git a/modules/8ball.py b/modules/8ball.py index 1c058a28..f32b9a5a 100644 --- a/modules/8ball.py +++ b/modules/8ball.py @@ -14,7 +14,12 @@ CHOICES = [ "The answer is unclear", "Absolutely", "Dubious at best", - "I'm on a break, ask again later" + "I'm on a break, ask again later", + "As I see it, yes", + "It is certain", + "Naturally", + "Reply hazy, try again later", + Utils.color(4) + Utils.underline("DO NOT WASTE MY TIME") ] class Module(object): diff --git a/modules/ducks.py b/modules/ducks.py index 31a7fbe9..a3b3c80f 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -79,7 +79,7 @@ class Module(object): if hasattr(channel, 'games') == False: return False - if hasattr(channel["games"], 'ducks') == False: + if "ducks" not in channel.games.keys(): return False return True -- cgit v1.3.1-10-gc9f91 From f0c966403bf015e61d124974ec4bf78128aa02d2 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 17:15:11 +0100 Subject: Tweak duck timing. --- modules/ducks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index a3b3c80f..5b108e83 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -104,7 +104,7 @@ class Module(object): self.clear_ducks(channel) def generate_next_duck_time(self): - rand_time = random.randint(int(time()) + 300, int(time()) + 1200) + rand_time = random.randint(int(time()) + 180, int(time()) + 960) return rand_time def is_duck_visible(self, event): -- cgit v1.3.1-10-gc9f91 From 7023cd45d945a9e5913cbea92609e1e6526ad76f Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 17:16:13 +0100 Subject: Remove unused code. --- modules/ducks.py | 1 - 1 file changed, 1 deletion(-) (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index 5b108e83..6cb42f96 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -177,7 +177,6 @@ class Module(object): user = event["user"] game = channel.games["ducks"] - delay_increment = 0 if game["duck_spawned"] == 1 or channel.has_user( event["user"]) == False: -- cgit v1.3.1-10-gc9f91 From 2efbf7ec7ea6d8b355a11660cf3f136a7333f7b5 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 17:18:06 +0100 Subject: Remove debug code. --- modules/ducks.py | 1 - 1 file changed, 1 deletion(-) (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index 6cb42f96..e53b51d4 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -201,7 +201,6 @@ class Module(object): user = event["user"] nick = user.nickname uid = user.get_id() - print(channel) if self.is_duck_channel(channel) == False: return -- cgit v1.3.1-10-gc9f91 From 03b41c3d49dab6b97afbc0b5631c16f71dcc971c Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 17:19:52 +0100 Subject: More 8ball answers. --- modules/8ball.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) (limited to 'modules') diff --git a/modules/8ball.py b/modules/8ball.py index f32b9a5a..9c6e5d1a 100644 --- a/modules/8ball.py +++ b/modules/8ball.py @@ -19,7 +19,13 @@ CHOICES = [ "It is certain", "Naturally", "Reply hazy, try again later", - Utils.color(4) + Utils.underline("DO NOT WASTE MY TIME") + Utils.color(4) + Utils.underline("DO NOT WASTE MY TIME"), + "Hmm... Could be!", + "I'm leaning towards no", + "Without a doubt", + "Sources say no", + "Sources say yes", + "Sources say maybe" ] class Module(object): -- cgit v1.3.1-10-gc9f91 From a25139d8289e9a5e4f523443cec672f85c69f37f Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 17:24:31 +0100 Subject: Remove old ducks.py --- modules/ducks.py_old | 263 --------------------------------------------------- 1 file changed, 263 deletions(-) delete mode 100644 modules/ducks.py_old (limited to 'modules') diff --git a/modules/ducks.py_old b/modules/ducks.py_old deleted file mode 100644 index 9b2d78f2..00000000 --- a/modules/ducks.py_old +++ /dev/null @@ -1,263 +0,0 @@ -from operator import itemgetter -from threading import Timer -import Utils -import random - -DUCK_LIST = [ - "・゜゜・。。・゜ ​ ゜\_O​< q​uack!", - "・゜゜・。。・゜ ​ ゜\_o< QUACK!", - "・゜゜・。 ​ 。・゜゜\​_ó< qu​ack!", - "・゜゜・。 ​ 。・゜゜\​_ó< qu​ack quack!", - "・゜゜ 。 ​ 。・゜ \​_ó< bawk!", - "・゜゜ 。 ​ 。・゜゜\​_ó< squawk!", - "・ ゜・。 ​ 。・゜゜ \​_ó< beep beep!" -] - -class Module(object): - def __init__(self, bot, events, exports): - self.bot = bot - self.events = events - - events.on("received.command.bef").hook(self.duck_bef, - help="Befriend a duck!") - events.on("received.command.bang").hook(self.duck_bang, - help="Shoot a duck! Meanie.") - events.on("received.command.decoy").hook(self.set_decoy, - help="Be a sneaky fellow and make a decoy duck.") - events.on("received.command.friends").hook(self.duck_friends, - help="See who the friendliest people to ducks are!") - events.on("received.command.killers").hook(self.duck_enemies, - help="See who shoots the most amount of ducks.") - events.on("received.command.duckstats").hook(self.duck_stats, - help="Shows your duck " - "stats!") - - - #exports.add("channelset", {"setting": "ducks-enabled", - # "help": "Toggle ducks!", "validate": Utils.bool_or_none}) - - #events.on("received.numeric.366").hook(self.bootstrap) - - #events.on("raw").on("376").hook(self.duck_loop_entry) - - #events.on("timer").on("duck-decoy").hook(self.duck_decoy) - #events.on("timer").on("show-duck").hook(self.show_duck) - - def duck_loop_entry(self, event): - wait = self.get_random_duck_time() - self.bot.log.info("Sending out a wave of ducks in %s seconds", - [wait]) - self.bot.add_timer("show-duck", wait, persist=False) - - def bootstrap(self, event): - for server in self.bot.servers.values(): - for channel in server.channels.values(): - ducks_enabled = channel.get_setting("ducks-enabled", False) - - if ducks_enabled == True: - channel.set_setting("active-duck", False) - - def duck_enemies(self, event): - the_enemy = event["server"].find_all_user_channel_settings( - "ducks-shot") - - notorious = {} - enemy_nicks = [] - enemy_ducks = [] - - for i in the_enemy: - if i[1] in notorious.keys(): - notorious[i[1]] += i[2] - else: - notorious[i[1]] = i[2] - - for user, enemies in sorted(notorious.items(), key=itemgetter(1), - reverse=True): - enemy_nicks.append(user) - enemy_ducks.append(enemies) - - sentence = "Most Notorious Users -- " - - length = len(enemy_nicks) if len(enemy_nicks) < 11 else 11 - - for i in range(0, length): - sentence += enemy_nicks[i] + " (" + str(enemy_ducks[i]) + ")" - if i < 10: - sentence += ", " - - sentence = sentence[0:-2] - - event["stdout"].write(sentence) - - def duck_friends(self, event): - friends = event["server"].find_all_user_channel_settings( - "ducks-befriended") - - friendliest = {} - friend_nicks = [] - friend_ducks = [] - - for i in friends: - if i[1] in friendliest.keys(): - friendliest[i[1]] += i[2] - else: - friendliest[i[1]] = i[2] - - for user, friends in sorted(friendliest.items(), key = itemgetter(1), - reverse = True): - friend_nicks.append(user) - friend_ducks.append(friends) - - sentence = "Friendliest Users -- " - - length = len(friend_nicks) if len(friend_nicks) < 11 else 11 - - for i in range(0, length): - sentence += friend_nicks[i] + " (" + str(friend_ducks[i]) + ")" - if i < 10: - sentence += ", " - - sentence = sentence[0:-2] - - event["stdout"].write(sentence) - - def duck_bef(self, event): - user = event["user"] - target = user.nickname - id = user.get_id() - - active_duck = event["target"].get_setting("active-duck", False) - - if active_duck == False: - if event["server"].has_user(target): - if not event["server"].is_own_nickname(target): - event["target"].send_kick(target, - "You tried befriending a non-existent duck. Creepy!") - else: - event["stderr"].write("Nope.") - else: - event["stderr"].write("That user is not in this channel") - else: - befriended_ducks = event["target"].get_user_setting(id, - "ducks-befriended", - 0) - event["target"].set_user_setting(id, - "ducks-befriended", - befriended_ducks + 1) - event["target"].set_setting("active-duck", False) - - grammar = "" if befriended_ducks == 0 else "s" - - event["stdout"].write( - target + ", you've befriended " + Utils.bold(str( - befriended_ducks + 1)) + " duck" + grammar + " in " + - Utils.bold(event[ - "target"].name)) - - self.duck_loop_entry(event) - - def duck_bang(self, event): - user = event["user"] - target = user.nickname - id = user.get_id() - if not event["target"].get_setting("active-duck", False): - event["stderr"].set_prefix("Kick") - if event["server"].has_user(target): - if not event["server"].is_own_nickname(target): - event["target"].send_kick(target, - "You tried shooting a non-existent duck. Creepy!") - else: - event["stderr"].write("Nope.") - else: - event["stderr"].write("That user is not in this channel") - else: - shot_ducks = event["target"].get_user_setting(id, "ducks-shot", 0) - event["target"].set_user_setting(id, "ducks-shot", shot_ducks + 1) - event["target"].set_setting("active-duck", False) - - grammar = "" if shot_ducks == 0 else "s" - - event["stdout"].write( - target + ", you've shot " - + Utils.bold(str(shot_ducks + 1)) + " duck" - + grammar + " in " - + Utils.bold(event["target"].name)) - - self.duck_loop_entry(event) - - def get_random_duck_time(self): - return random.randint(720, 3600) - - def show_duck(self, event): - for server in self.bot.servers.values(): - for channel in server.channels.values(): - ducks_enabled = channel.get_setting("ducks-enabled", False) - - if ducks_enabled == False: - continue - - active_duck = channel.get_setting("active-duck", False) - - if ducks_enabled == True and active_duck == False: - channel.send_message(random.choice(DUCK_LIST)) - - channel.set_setting("active-duck", True) - - elif ducks_enabled == True and active_duck == True: - pass - - else: - channel.set_setting("active-duck", False) - - def duck_decoy(self, event): - self.events.on("send").on("stdout").call(target=event["channel"], - module_name="Ducks", server=event["server"], - message=random.choice(DUCK_LIST)) - - def set_decoy(self, event): - next_decoy_time = self.get_random_duck_time() - self.bot.add_timer("duck-decoy", next_decoy_time, persist=False, - server=event["server"], channel=event["target"]) - - - def duck_stats(self, event): - user = event["user"] - channel = event["target"].name - nick = user.nickname - id = user.get_id() - - poached = user.get_channel_settings_per_setting("ducks-shot", [] - ) - friends = user.get_channel_settings_per_setting( - "ducks-befriended", [] - ) - - channel_friends = 0 - channel_poached = 0 - - total_friends = 0 - total_poached = 0 - - for room, number in friends: - if room == channel: - channel_friends = number - total_friends += number - else: - total_friends += number - - for room, number in poached: - if room == channel: - channel_poached = number - total_poached += number - else: - total_poached += number - - event["stdout"].write( - nick + ": " + str(total_poached) + " ducks killed (" + str( - channel_poached) + " in " + channel + "), and " + str( - total_friends) + " ducks befriended (" + str(channel_friends) - + " in " + channel + ")") - - - - -- cgit v1.3.1-10-gc9f91 From 119ea1a4f66026e78c3c60673f73cebbb4b80e83 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 19:10:09 +0100 Subject: Refactor ducks.py to make sense. --- modules/ducks.py | 87 +++++++++++++++++++++++--------------------------------- 1 file changed, 36 insertions(+), 51 deletions(-) (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index e53b51d4..5fb3ecbf 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -8,8 +8,8 @@ DUCK_TAIL = "・゜゜・。。・゜゜" DUCK_HEAD = ["\_o< ", "\_O< ", "\_0< ", "\_\u00f6< ", "\_\u00f8< ", "\_\u00f3< "] DUCK_MESSAGE = ["QUACK!", "FLAP FLAP!", "quack!", "squawk!"] -DUCK_MESSAGE_RARE = ["beep boop!", "QUACK QUACK QUACK QUACK QUACK!!", - "HONK!", "I AM THE METAL DUCK"] +DUCK_MESSAGE_RARE = ["beep boop!", "QUACK QUACK QUACK QUACK QUACK!!", "HONK!", + "I AM THE METAL DUCK"] DUCK_MINIMUM_MESSAGES = 10 DUCK_MINIMUM_UNIQUE = 3 @@ -23,34 +23,31 @@ class Module(object): self.bot = bot self.events = events - events.on("received").on("command").on("bef").hook(self.befriend, - priority=1, - help="Befriend a " - "duck!") - events.on("received").on("command").on("bang").hook(self.shoot, - priority=1, - help="Shoot a " - "duck! " - "Meanie.", - ) + events.on("received.command.bef").hook(self.befriend, + priority=1, + help="Befriend a " + "duck!") + events.on("received.command.bang").hook(self.shoot, + priority=1, + help="Shoot a " + "duck! " + "Meanie.", ) # events.on("received").on("command").on("decoy").hook(self.set_decoy, # help="Be a # sneaky fellow # and make a # decoy duck!") - events.on("received").on("command").on("friends").hook( + events.on("rreceived.command.friends").hook( self.duck_friends, help="See who the friendliest people to ducks are!") - events.on("received").on("command").on("killers").hook( - self.duck_enemies, - help="See who shoots the most smount of ducks!") - events.on("received").on("command").on("duckstats").hook( - self.duck_stats, - help="Shows your duck stats!") - - exports.add("channelset", {"setting": "ducks-enabled", - "help": "Toggle ducks!", - "validate": Utils.bool_or_none}) + events.on("received.command.killers").hook( + self.duck_enemies, help="See who shoots the most smount of ducks!") + events.on("received.command.duckstats").hook( + self.duck_stats, help="Shows your duck stats!") + + exports.add("channelset", + {"setting": "ducks-enabled", "help": "Toggle ducks!", + "validate": Utils.bool_or_none}) exports.add("channelset", {"setting": "ducks-kick", "help": "Should the bot kick if there's no " @@ -91,12 +88,9 @@ class Module(object): def clear_ducks(self, channel): rand_time = self.generate_next_duck_time() - channel.games["ducks"] = { - 'messages': 0, - 'duck_spawned': 0, - 'unique_users': [], - 'next_duck_time': rand_time - } + channel.games["ducks"] = {'messages': 0, 'duck_spawned': 0, + 'unique_users': [], + 'next_duck_time': rand_time} def start_game(self, channel): # event is immediately the IRCChannel.Channel() event for the current @@ -144,9 +138,7 @@ class Module(object): # DUCK_MINIMUM_UNIQUE = 3 if spawned == 0 and next_duck < time() and unique > \ - DUCK_MINIMUM_UNIQUE and \ - messages > \ - DUCK_MINIMUM_MESSAGES: + DUCK_MINIMUM_UNIQUE and messages > DUCK_MINIMUM_MESSAGES: return True else: return False @@ -161,10 +153,10 @@ class Module(object): duck += DUCK_TAIL duck += random.choice(DUCK_HEAD) - duck = str(Utils.color(4) + Utils.bold(duck + random.choice( - DUCK_MESSAGE_RARE)) + Utils.color(4)) if 1 == random.randint(1, - 20) \ - else duck + random.choice(DUCK_MESSAGE) + duck = str(Utils.color(4) + Utils.bold( + duck + random.choice(DUCK_MESSAGE_RARE)) + Utils.color( + 4)) if 1 == random.randint(1, 20) else duck + random.choice( + DUCK_MESSAGE) channel.send_message(duck) channel.games["ducks"]["duck_spawned"] = 1 @@ -219,10 +211,9 @@ class Module(object): channel.set_user_setting(uid, "ducks-befriended", total_befriended) event["stdout"].write( - "Aww! " + nick + " befriended a duck! You've befriended " - + Utils.bold( - str( - total_befriended)) + " ducks in " + Utils.bold( + "Aww! " + nick + " befriended a duck! You've befriended " + + Utils.bold( + str(total_befriended)) + " ducks in " + Utils.bold( channel.name) + "!") self.clear_ducks(channel) @@ -252,8 +243,7 @@ class Module(object): event["stdout"].write( "Pow! " + nick + " shot a duck! You've shot " + Utils.bold( - str( - total_shot)) + " ducks in " + Utils.bold( + str(total_shot)) + " ducks in " + Utils.bold( channel.name) + "!") self.clear_ducks(channel) @@ -264,11 +254,8 @@ class Module(object): nick = user.nickname id = user.get_id() - poached = user.get_channel_settings_per_setting("ducks-shot", [] - ) - friends = user.get_channel_settings_per_setting( - "ducks-befriended", [] - ) + poached = user.get_channel_settings_per_setting("ducks-shot", []) + friends = user.get_channel_settings_per_setting("ducks-befriended", []) channel_friends = 0 channel_poached = 0 @@ -294,12 +281,10 @@ class Module(object): nick + ": " + str(total_poached) + " ducks killed (" + str( channel_poached) + " in " + channel + "), and " + str( total_friends) + " ducks befriended (" + str( - channel_friends) - + " in " + channel + ")") + channel_friends) + " in " + channel + ")") def duck_enemies(self, event): - the_enemy = event["server"].find_all_user_channel_settings( - "ducks-shot") + the_enemy = event["server"].find_all_user_channel_settings("ducks-shot") notorious = {} enemy_nicks = [] -- cgit v1.3.1-10-gc9f91 From 6d31f5ef3cebe0fe99562333a69174881e2eb15f Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 19:11:12 +0100 Subject: Full metal duck. --- modules/ducks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index 5fb3ecbf..bdf62870 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -9,7 +9,7 @@ DUCK_HEAD = ["\_o< ", "\_O< ", "\_0< ", "\_\u00f6< ", "\_\u00f8< ", "\_\u00f3< "] DUCK_MESSAGE = ["QUACK!", "FLAP FLAP!", "quack!", "squawk!"] DUCK_MESSAGE_RARE = ["beep boop!", "QUACK QUACK QUACK QUACK QUACK!!", "HONK!", - "I AM THE METAL DUCK"] + Utils.underline("I AM THE METAL DUCK")] DUCK_MINIMUM_MESSAGES = 10 DUCK_MINIMUM_UNIQUE = 3 -- cgit v1.3.1-10-gc9f91 From 83f2ec673c36639cd639c7e6a4eccb0f9b07ca49 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 19:23:35 +0100 Subject: Typo fix. --- modules/ducks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index bdf62870..37f950dc 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -37,7 +37,7 @@ class Module(object): # sneaky fellow # and make a # decoy duck!") - events.on("rreceived.command.friends").hook( + events.on("received.command.friends").hook( self.duck_friends, help="See who the friendliest people to ducks are!") events.on("received.command.killers").hook( -- cgit v1.3.1-10-gc9f91 From 89bc48cf0c647c7f71dd17316a3a4180d13a8a45 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 19:32:10 +0100 Subject: Correct comparison --- modules/ducks.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index 37f950dc..30248781 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -137,8 +137,8 @@ class Module(object): # DUCK_MINIMUM_MESSAGES = 10 # DUCK_MINIMUM_UNIQUE = 3 - if spawned == 0 and next_duck < time() and unique > \ - DUCK_MINIMUM_UNIQUE and messages > DUCK_MINIMUM_MESSAGES: + if spawned == 0 and next_duck < time() and unique >= \ + DUCK_MINIMUM_UNIQUE and messages >= DUCK_MINIMUM_MESSAGES: return True else: return False -- cgit v1.3.1-10-gc9f91 From f17cce3c3da25073615462a04e4d9cbd6cbac44c Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 19:58:44 +0100 Subject: More duck timing tweaks --- modules/ducks.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index 30248781..d7b640f6 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -98,7 +98,7 @@ class Module(object): self.clear_ducks(channel) def generate_next_duck_time(self): - rand_time = random.randint(int(time()) + 180, int(time()) + 960) + rand_time = random.randint(int(time()) + 360, int(time()) + 1200) return rand_time def is_duck_visible(self, event): -- cgit v1.3.1-10-gc9f91 From 558e2eb8463af334f6f5312e9edda1762791dca3 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 20:38:45 +0100 Subject: Trim garbage code. --- modules/ducks.py | 3 --- 1 file changed, 3 deletions(-) (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index d7b640f6..c2a3718d 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -14,9 +14,6 @@ DUCK_MESSAGE_RARE = ["beep boop!", "QUACK QUACK QUACK QUACK QUACK!!", "HONK!", DUCK_MINIMUM_MESSAGES = 10 DUCK_MINIMUM_UNIQUE = 3 -CHANNELS_ENABLED = [] - - class Module(object): def __init__(self, bot, events, exports): -- cgit v1.3.1-10-gc9f91 From 3bdc43cf71096f0f49f75e0e0c10d0a81e95c1c4 Mon Sep 17 00:00:00 2001 From: dngfx Date: Sat, 8 Sep 2018 21:58:32 +0100 Subject: Bootstrap properly on module reload. --- modules/ducks.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) (limited to 'modules') diff --git a/modules/ducks.py b/modules/ducks.py index c2a3718d..3881aaf8 100644 --- a/modules/ducks.py +++ b/modules/ducks.py @@ -53,11 +53,21 @@ class Module(object): events.on("new.channel").hook(self.bootstrap) + events.on("received").on("message").on("channel").hook( self.channel_message, priority=2) + self.bootstrap_lazy(events) + + def bootstrap_lazy(self, event): + servers = self.bot.servers + + for server in servers.values(): + for channel in server.channels.values(): + self.bootstrap(channel) + def bootstrap(self, event): - channel = event["channel"] + channel = event["channel"] if hasattr(event, "channel") else event self.init_game_var(channel) # getset -- cgit v1.3.1-10-gc9f91