def stop_quest(self): HandlerManager.remove_handler('on_duel_complete', self.on_duel_complete) redis = RedisManager.get() self.reset_progress(redis=redis) redis.delete(self.points_required_key)
def stop_quest(self): HandlerManager.remove_handler('on_duel_complete', self.on_duel_complete) redis = RedisManager.get() self.reset_progress(redis=redis)
def command_start(self, **options): bot = options['bot'] source = options['source'] message = options['message'] if self.trivia_running: bot.me('{}, a trivia is already running'.format(source.username_raw)) return self.trivia_running = True self.job.resume() try: self.point_bounty = int(message) if self.point_bounty < 0: self.point_bounty = 0 elif self.point_bounty > 50: self.point_bounty = 50 except: self.point_bounty = self.settings['default_point_bounty'] if self.point_bounty > 0: bot.me('The trivia has started! {} points for each right answer!'.format(self.point_bounty)) else: bot.me('The trivia has started!') HandlerManager.add_handler('on_message', self.on_message)
def stop_quest(self): HandlerManager.remove_handler('on_message', self.on_message) redis = RedisManager.get() self.reset_progress(redis=redis) redis.delete(self.current_emote_key)
def command_start(self, **options): bot = options['bot'] source = options['source'] message = options['message'] if self.trivia_running: bot.me('{}, a trivia is already running'.format( source.username_raw)) return self.trivia_running = True self.job.resume() try: self.point_bounty = int(message) if self.point_bounty < 0: self.point_bounty = 0 elif self.point_bounty > 50: self.point_bounty = 50 except: self.point_bounty = self.settings['default_point_bounty'] if self.point_bounty > 0: bot.me('The trivia has started! {} points for each right answer!'. format(self.point_bounty)) else: bot.me('The trivia has started!') HandlerManager.add_handler('on_message', self.on_message)
def enable(self, bot): self.bot = bot HandlerManager.add_handler('on_message', self.on_message, priority=100) HandlerManager.add_handler('on_commit', self.on_commit) if bot: self.run_later = bot.execute_delayed if 'safebrowsingapi' in bot.config['main']: # XXX: This should be loaded as a setting instead. # There needs to be a setting for settings to have them as "passwords" # so they're not displayed openly self.safeBrowsingAPI = SafeBrowsingAPI(bot.config['main']['safebrowsingapi'], bot.nickname, bot.version) else: self.safeBrowsingAPI = None if self.db_session is not None: self.db_session.commit() self.db_session.close() self.db_session = None self.db_session = DBManager.create_session() self.blacklisted_links = [] for link in self.db_session.query(BlacklistedLink): self.blacklisted_links.append(link) self.whitelisted_links = [] for link in self.db_session.query(WhitelistedLink): self.whitelisted_links.append(link)
def start_quest(self): HandlerManager.add_handler('on_message', self.on_message) redis = RedisManager.get() self.load_progress(redis=redis) self.load_data(redis=redis)
def award_tokens(self, tokens, redis=None, force=False): """ Returns True if tokens were awarded properly. Returns False if not. Tokens can only be rewarded once per stream ID. """ streamer = StreamHelper.get_streamer() stream_id = StreamHelper.get_current_stream_id() if stream_id is False: return False if redis is None: redis = RedisManager.get() key = '{streamer}:{username}:tokens'.format(streamer=streamer, username=self.username) if force: res = True redis.hset(key, stream_id, tokens) else: res = True if redis.hsetnx(key, stream_id, tokens) == 1 else False if res is True: HandlerManager.trigger('on_user_gain_tokens', self, tokens) return res
def create_stream(self, status): log.info('Attempting to create a stream!') with DBManager.create_session_scope(expire_on_commit=False) as db_session: stream_chunk = db_session.query(StreamChunk).filter_by(broadcast_id=status['broadcast_id']).one_or_none() new_stream = False if stream_chunk is not None: stream = stream_chunk.stream else: log.info('checking if there is an active stream already') stream = db_session.query(Stream).filter_by(ended=False).order_by(Stream.stream_start.desc()).first() new_stream = stream is None if new_stream: log.info('No active stream, create new!') stream = Stream(status['created_at'], title=status['title']) db_session.add(stream) db_session.commit() log.info('Successfully added stream!') stream_chunk = StreamChunk(stream, status['broadcast_id'], status['created_at']) db_session.add(stream_chunk) db_session.commit() stream.stream_chunks.append(stream_chunk) log.info('Created stream chunk') self.current_stream = stream self.current_stream_chunk = stream_chunk db_session.expunge_all() if new_stream: HandlerManager.trigger('on_stream_start', stop_on_false=False) log.info('Successfully created a stream')
def enable(self, bot): self.bot = bot HandlerManager.add_handler('on_message', self.on_message, priority=100) HandlerManager.add_handler('on_commit', self.on_commit) if bot: self.run_later = bot.execute_delayed if 'safebrowsingapi' in bot.config['main']: # XXX: This should be loaded as a setting instead. # There needs to be a setting for settings to have them as "passwords" # so they're not displayed openly self.safeBrowsingAPI = SafeBrowsingAPI( bot.config['main']['safebrowsingapi'], bot.nickname, bot.version) else: self.safeBrowsingAPI = None if self.db_session is not None: self.db_session.commit() self.db_session.close() self.db_session = None self.db_session = DBManager.create_session() self.blacklisted_links = [] for link in self.db_session.query(BlacklistedLink): self.blacklisted_links.append(link) self.whitelisted_links = [] for link in self.db_session.query(WhitelistedLink): self.whitelisted_links.append(link)
def award_tokens(self, tokens, redis=None, force=False): """ Returns True if tokens were awarded properly. Returns False if not. Tokens can only be rewarded once per stream ID. """ streamer = StreamHelper.get_streamer() stream_id = StreamHelper.get_current_stream_id() if stream_id is False: return False if redis is None: redis = RedisManager.get() key = '{streamer}:{username}:tokens'.format( streamer=streamer, username=self.username) if force: res = True redis.hset(key, stream_id, tokens) else: res = True if redis.hsetnx(key, stream_id, tokens) == 1 else False if res is True: HandlerManager.trigger('on_user_gain_tokens', self, tokens) return res
def stop_quest(self): HandlerManager.remove_handler('on_user_win_hs_bet', self.on_user_win_hs_bet) redis = RedisManager.get() self.reset_progress(redis=redis)
def start_quest(self): HandlerManager.add_handler('on_user_win_hs_bet', self.on_user_win_hs_bet) redis = RedisManager.get() self.load_progress(redis=redis)
def start_quest(self): HandlerManager.add_handler('on_user_win_hs_bet', self.on_user_win_hs_bet) redis = RedisManager.get() self.load_progress(redis=redis) self.load_data(redis=redis) self.LIMIT = self.hsbet_points_required
def disable(self, bot): HandlerManager.remove_handler('on_message', self.on_message) HandlerManager.remove_handler('on_commit', self.on_commit) if self.db_session is not None: self.db_session.commit() self.db_session.close() self.db_session = None self.links = {}
def start_quest(self): HandlerManager.add_handler('on_duel_complete', self.on_duel_complete) redis = RedisManager.get() self.load_progress(redis=redis) self.load_data(redis=redis) self.LIMIT = self.points_required
def commit_all(self): log.info('Commiting all...') for key, manager in self.commitable.items(): log.info('Commiting {0}'.format(key)) manager.commit() log.info('Done with {0}'.format(key)) log.info('ok!') HandlerManager.trigger('on_commit', stop_on_false=False)
def base_paid_timeout(self, bot, source, message, _time, _cost): if message is None or len(message) == 0: return False username = message.split(' ')[0] if len(username) < 2: return False with bot.users.find_context(username) as victim: if victim is None: bot.whisper(source.username, 'This user does not exist FailFish') return False if victim.last_active is None or (datetime.datetime.now() - victim._last_active).total_seconds() > 10 * 60: bot.whisper(source.username, 'This user has not been active in chat within the last 10 minutes.') return False """ if victim == source: bot.whisper(source.username, 'You can\'t timeout yourself FailFish') return False """ if victim.moderator is True: bot.whisper(source.username, 'This person has mod privileges, timeouting this person is not worth it.') return False if victim.level >= self.settings['bypass_level']: bot.whisper(source.username, 'This person\'s user level is too high, you can\'t timeout this person.') return False now = datetime.datetime.now() if victim.timed_out is True and victim.timeout_end > now: victim.timeout_end += datetime.timedelta(seconds=_time) bot.whisper(victim.username, '{victim.username}, you were timed out for an additional {time} seconds by {source.username}'.format( victim=victim, source=source, time=_time)) bot.whisper(source.username, 'You just used {0} points to time out {1} for an additional {2} seconds.'.format(_cost, username, _time)) num_seconds = int((victim.timeout_end - now).total_seconds()) bot._timeout(username, num_seconds) else: bot.whisper(source.username, 'You just used {0} points to time out {1} for {2} seconds.'.format(_cost, username, _time)) bot.whisper(username, '{0} just timed you out for {1} seconds. /w {2} !$unbanme to unban yourself for points forsenMoney'.format(source.username, _time, bot.nickname)) bot._timeout(username, _time) victim.timed_out = True victim.timeout_start = now victim.timeout_end = now + datetime.timedelta(seconds=_time) if self.settings['show_on_clr']: payload = {'user': source.username, 'victim': victim.username} bot.websocket_manager.emit('timeout', payload) HandlerManager.trigger('on_paid_timeout', source, victim, _cost, stop_on_false=False)
def enable(self, bot): HandlerManager.add_handler('on_message', self.on_message, priority=200) HandlerManager.add_handler('on_commit', self.on_commit) if self.db_session is not None: self.db_session.commit() self.db_session.close() self.db_session = None self.links = {} self.db_session = DBManager.create_session()
def accept_duel(self, **options): """ Accepts any active duel requests you've received. How to add: !add funccommand accept accept_duel --cd 0 --usercd 0 How to use: !accept """ bot = options['bot'] source = options['source'] init_dueling_variables(source) duel_tax = 0.3 # 30% tax if source.duel_request is not False: if not source.can_afford(source.duel_price) or not source.duel_request.can_afford(source.duel_price): bot.whisper(source.username, 'Your duel request with {} was cancelled due to one of you not having enough points.'.format(source.duel_request.username_raw)) bot.whisper(source.duel_request.username, 'Your duel request with {} was cancelled due to one of you not having enough points.'.format(source.username_raw)) source.duel_request.duel_target = False source.duel_request = False return False source.points -= source.duel_price source.duel_request.points -= source.duel_price winning_pot = int(source.duel_price * (1.0 - duel_tax)) participants = [source, source.duel_request] winner = random.choice(participants) participants.remove(winner) loser = participants.pop() winner.points += source.duel_price winner.points += winning_pot bot.duel_manager.user_won(winner, winning_pot) bot.duel_manager.user_lost(loser, source.duel_price) arguments = { 'winner': winner.username, 'loser': loser.username, 'total_pot': source.duel_price, 'extra_points': winning_pot, } if source.duel_price > 0: message = self.get_phrase('message_won_points', **arguments) if source.duel_price >= 500: bot.websocket_manager.emit('notification', {'message': '{} won the duel vs {}'.format(winner.username_raw, loser.username_raw)}) else: message = self.get_phrase('message_won', **arguments) bot.say(message) source.duel_request.duel_target = False source.duel_request = False source.duel_price = 0 HandlerManager.trigger('on_duel_complete', winner, loser, winning_pot, source.duel_price)
def on_message(self, source, msg_raw, message_emotes, whisper, urls, event): if len(message_emotes) > 0: if hasattr(self, 'bingo_running') and self.bingo_running is True: if len(message_emotes) == 1 and len(msg_raw.split(' ')) == 1: if message_emotes[0]['code'] == self.bingo_target: HandlerManager.trigger('on_bingo_win', source, self.bingo_points, self.bingo_target) self.bingo_running = False self.bingo_bttv_twitch_running = False self.bot.me('{0} won the bingo! {1} was the target. Congrats, {2} points to you PogChamp'.format(source.username_raw, self.bingo_target, self.bingo_points)) source.points += self.bingo_points log.info('{0} won the bingo for {1} points!'.format(source.username_raw, self.bingo_points))
def command_stop(self, **options): bot = options['bot'] source = options['source'] if not self.trivia_running: bot.me('{}, no trivia is active right now'.format(source.username_raw)) return self.job.pause() self.trivia_running = False self.step_end() bot.me('The trivia has been stopped.') HandlerManager.remove_handler('on_message', self.on_message)
def command_stop(self, **options): bot = options['bot'] source = options['source'] if not self.trivia_running: bot.me('{}, no trivia is active right now'.format( source.username_raw)) return self.job.pause() self.trivia_running = False self.step_end() bot.me('The trivia has been stopped.') HandlerManager.remove_handler('on_message', self.on_message)
def parse_message(self, msg_raw, source, event, tags={}, whisper=False): msg_lower = msg_raw.lower() emote_tag = None for tag in tags: if tag['key'] == 'subscriber' and event.target == self.channel: source.subscriber = tag['value'] == '1' elif tag['key'] == 'emotes' and tag['value']: emote_tag = tag['value'] elif tag['key'] == 'display-name' and tag['value']: source.username_raw = tag['value'] elif tag['key'] == 'user-type': source.moderator = tag['value'] == 'mod' or source.username == self.streamer # source.num_lines += 1 if source is None: log.error('No valid user passed to parse_message') return False if source.banned: self.ban(source.username) return False # If a user types when timed out, we assume he's been unbanned for a good reason and remove his flag. if source.timed_out is True: source.timed_out = False # Parse emotes in the message message_emotes = self.emotes.parse_message_twitch_emotes(source, msg_raw, emote_tag, whisper) urls = self.find_unique_urls(msg_raw) # log.debug('{2}{0}: {1}'.format(source.username, msg_raw, '<w>' if whisper else '')) res = HandlerManager.trigger('on_message', source, msg_raw, message_emotes, whisper, urls, event, stop_on_false=True) if res is False: return False source.last_seen = datetime.datetime.now() source.last_active = datetime.datetime.now() if source.ignored: return False if msg_lower[:1] == '!': msg_lower_parts = msg_lower.split(' ') trigger = msg_lower_parts[0][1:] msg_raw_parts = msg_raw.split(' ') remaining_message = ' '.join(msg_raw_parts[1:]) if len(msg_raw_parts) > 1 else None if trigger in self.commands: command = self.commands[trigger] extra_args = { 'emotes': message_emotes, 'trigger': trigger, } command.run(self, source, remaining_message, event=event, args=extra_args, whisper=whisper)
def on_message(self, source, message, emotes, whisper, urls, event): if whisper is False and source.username in self.valid_usernames: # Did twitchnotify tell us about a new sub? m = self.new_sub_regex.search(message) if m: username = m.group(1) user = self.bot.users[username] self.on_new_sub(user) HandlerManager.trigger('on_user_sub', user) else: # Did twitchnotify tell us about a resub? m = self.resub_regex.search(message) if m: username = m.group(1) num_months = int(m.group(2)) user = self.bot.users[username] self.on_resub(user, num_months) HandlerManager.trigger('on_user_resub', user, num_months)
def go_offline(self): with DBManager.create_session_scope(expire_on_commit=False) as db_session: self.current_stream.ended = True self.current_stream.stream_end = self.first_offline self.current_stream_chunk.chunk_end = self.first_offline db_session.add(self.current_stream) db_session.add(self.current_stream_chunk) db_session.commit() db_session.expunge_all() self.last_stream = self.current_stream self.current_stream = None self.current_stream_chunk = None HandlerManager.trigger('on_stream_stop', stop_on_false=False)
def go_offline(self): with DBManager.create_session_scope( expire_on_commit=False) as db_session: self.current_stream.ended = True self.current_stream.stream_end = self.first_offline self.current_stream_chunk.chunk_end = self.first_offline db_session.add(self.current_stream) db_session.add(self.current_stream_chunk) db_session.commit() db_session.expunge_all() self.last_stream = self.current_stream self.current_stream = None self.current_stream_chunk = None HandlerManager.trigger('on_stream_stop', stop_on_false=False)
def end_raffle(self): if not self.raffle_running: return False self.raffle_running = False if len(self.raffle_users) == 0: self.bot.me('Wow, no one joined the raffle DansGame') return False winner = random.choice(self.raffle_users) self.raffle_users = [] self.bot.websocket_manager.emit('notification', {'message': '{} won {} points in the raffle!'.format(winner.username_raw, self.raffle_points)}) self.bot.me('The raffle has finished! {0} won {1} points! PogChamp'.format(winner.username_raw, self.raffle_points)) winner.points += self.raffle_points HandlerManager.trigger('on_raffle_win', winner, self.raffle_points)
def enable(self, bot): HandlerManager.add_handler('on_stream_start', self.on_stream_start) HandlerManager.add_handler('on_stream_stop', self.on_stream_stop) HandlerManager.add_handler('on_managers_loaded', self.on_managers_loaded) self.bot = bot
def start_quest(self): HandlerManager.add_handler('on_raffle_win', self.on_raffle_win) HandlerManager.add_handler('on_bingo_win', self.on_bingo_win) HandlerManager.add_handler('on_multiraffle_win', self.on_multiraffle_win) self.load_progress()
def stop_quest(self): HandlerManager.remove_handler('on_raffle_win', self.on_raffle_win) HandlerManager.remove_handler('on_bingo_win', self.on_bingo_win) HandlerManager.remove_handler('on_multiraffle_win', self.on_multiraffle_win) self.reset_progress()
def on_pubmsg(self, chatconn, event): if event.source.user == self.nickname: return False # We use .lower() in case twitch ever starts sending non-lowercased usernames source = self.users[event.source.user.lower()] res = HandlerManager.trigger('on_pubmsg', source, event.arguments[0], stop_on_false=True) if res is False: return False self.parse_message(event.arguments[0], source, event, tags=event.tags)
def create_stream(self, status): log.info('Attempting to create a stream!') with DBManager.create_session_scope( expire_on_commit=False) as db_session: stream_chunk = db_session.query(StreamChunk).filter_by( broadcast_id=status['broadcast_id']).one_or_none() new_stream = False if stream_chunk is not None: stream = stream_chunk.stream else: log.info('checking if there is an active stream already') stream = db_session.query(Stream).filter_by( ended=False).order_by(Stream.stream_start.desc()).first() new_stream = stream is None if new_stream: log.info('No active stream, create new!') stream = Stream(status['created_at'], title=status['title']) db_session.add(stream) db_session.commit() log.info('Successfully added stream!') stream_chunk = StreamChunk(stream, status['broadcast_id'], status['created_at']) db_session.add(stream_chunk) db_session.commit() stream.stream_chunks.append(stream_chunk) log.info('Created stream chunk') self.current_stream = stream self.current_stream_chunk = stream_chunk db_session.expunge_all() if new_stream: HandlerManager.trigger('on_stream_start', stop_on_false=False) log.info('Successfully created a stream')
def parse_message(self, msg_raw, source, event, tags={}, whisper=False): msg_lower = msg_raw.lower() if source is None: log.error('No valid user passed to parse_message') return False if source.banned: self.ban(source.username) return False # If a user types when timed out, we assume he's been unbanned for a good reason and remove his flag. if source.timed_out is True: source.timed_out = False emote_tag = None for tag in tags: if tag['key'] == 'subscriber' and event.target == self.channel: if source.subscriber and tag['value'] == '0': source.subscriber = False elif not source.subscriber and tag['value'] == '1': source.subscriber = True elif tag['key'] == 'emotes' and tag['value']: emote_tag = tag['value'] elif tag['key'] == 'display-name' and tag['value']: try: source.update_username(tag['value']) except: log.exception( 'Exception caught while updating a users username') elif tag['key'] == 'user-type': source.moderator = tag[ 'value'] == 'mod' or source.username == self.streamer # Parse emotes in the message message_emotes = self.emotes.parse_message_twitch_emotes( source, msg_raw, emote_tag) urls = self.find_unique_urls(msg_raw) log.debug('{2}{0}: {1}'.format(source.username, msg_raw, '<w>' if whisper else '')) res = HandlerManager.trigger('on_message', source, msg_raw, message_emotes, whisper, urls, event, stop_on_false=True) if res is False: return False source.last_seen = datetime.datetime.now() source.last_active = datetime.datetime.now() if source.ignored: return False if msg_lower[:1] == '!': msg_lower_parts = msg_lower.split(' ') trigger = msg_lower_parts[0][1:] msg_raw_parts = msg_raw.split(' ') remaining_message = ' '.join( msg_raw_parts[1:]) if len(msg_raw_parts) > 1 else None if trigger in self.commands: command = self.commands[trigger] extra_args = { 'emotes': message_emotes, 'trigger': trigger, } command.run(self, source, remaining_message, event=event, args=extra_args, whisper=whisper)
def disable(self, bot): HandlerManager.remove_handler('on_pubmsg', self.on_pubmsg)
def start_quest(self): HandlerManager.add_handler('on_duel_complete', self.on_duel_complete) redis = RedisManager.get() self.load_progress(redis=redis)
def disable(self, bot): HandlerManager.remove_handler('on_paid_timeout', self.on_paid_timeout)
def enable(self, bot): self.bot = bot HandlerManager.add_handler('on_message', self.on_message, priority=50)
def enable(self, bot): HandlerManager.add_handler('on_pubmsg', self.on_pubmsg) self.bot = bot
def poll_trackobot_stage2(self, game_data): latest_game = game_data['history'][0] if latest_game['id'] != self.last_game_id: winners = [] losers = [] total_winning_points = 0 total_losing_points = 0 points_bet = { 'win': 0, 'loss': 0, } bet_game_id = None with DBManager.create_session_scope() as db_session: bet_game = HSBetGame(latest_game['id'], latest_game['result']) db_session.add(bet_game) db_session.flush() bet_game_id = bet_game.id db_bets = {} for username in self.bets: bet_for_win, points = self.bets[username] """ self.bot.me('{} bet {} points on the last game to end up as a {}'.format( username, points, 'win' if bet_for_win else 'loss')) """ user = self.bot.users[username] correct_bet = (latest_game['result'] == 'win' and bet_for_win is True) or (latest_game['result'] == 'loss' and bet_for_win is False) points_bet['win' if bet_for_win else 'loss'] += points db_bets[username] = HSBetBet(bet_game_id, user.id, 'win' if bet_for_win else 'loss', points, 0) if correct_bet: winners.append((user, points)) total_winning_points += points user.remove_debt(points) else: losers.append((user, points)) total_losing_points += points user.pay_debt(points) db_bets[username].profit = -points self.bot.whisper(user.username, 'You bet {} points on the wrong outcome, so you lost it all. :('.format( points)) for obj in losers: user, points = obj log.debug('{} lost {} points!'.format(user, points)) for obj in winners: points_reward = 0 user, points = obj if points == 0: # If you didn't bet any points, you don't get a part of the cut. HandlerManager.trigger('on_user_win_hs_bet', user, points_reward) continue pot_cut = points / total_winning_points points_reward = int(pot_cut * total_losing_points) db_bets[user.username].profit = points_reward user.points += points_reward HandlerManager.trigger('on_user_win_hs_bet', user, points_reward) self.bot.whisper(user.username, 'You bet {} points on the right outcome, that rewards you with a profit of {} points! (Your bet was {:.2f}% of the total pool)'.format( points, points_reward, pot_cut * 100)) """ self.bot.me('{} bet {} points, and made a profit of {} points by correctly betting on the HS game!'.format( user.username_raw, points, points_reward)) """ with DBManager.create_session_scope() as db_session: for username in db_bets: bet = db_bets[username] db_session.add(bet) self.bot.me('A new game has begun! Vote with !hsbet win/lose POINTS') self.bets = {} self.last_game_id = latest_game['id'] self.last_game_start = datetime.datetime.now() + datetime.timedelta(seconds=self.settings['time_until_bet_closes']) payload = { 'time_left': self.settings['time_until_bet_closes'], 'win': 0, 'loss': 0, } self.bot.websocket_manager.emit('hsbet_new_game', data=payload) # stats about the game ratio = 0.0 try: ratio = (total_losing_points / total_winning_points) * 100.0 except: pass self.bot.me('The game ended as a {result}. {points_bet[win]} points bet on win, {points_bet[loss]} points bet on loss. Winners can expect a {ratio:.2f}% return on their bet points.'.format(ratio=ratio, result=latest_game['result'], points_bet=points_bet)) redis = RedisManager.get() redis.set('{streamer}:last_hsbet_game_id'.format(streamer=StreamHelper.get_streamer()), self.last_game_id) redis.set('{streamer}:last_hsbet_game_start'.format(streamer=StreamHelper.get_streamer()), self.last_game_start.timestamp())
def stop_quest(self): HandlerManager.remove_handler("on_user_win_hs_bet", self.on_user_win_hs_bet) redis = RedisManager.get() self.reset_progress(redis=redis)
def enable(self, bot): HandlerManager.add_handler('on_paid_timeout', self.on_paid_timeout)
def multi_end_raffle(self): if not self.raffle_running: return False self.raffle_running = False if len(self.raffle_users) == 0: self.bot.me('Wow, no one joined the raffle DansGame') return False # Shuffle the list of participants random.shuffle(self.raffle_users) num_participants = len(self.raffle_users) abs_points = abs(self.raffle_points) max_winners = min(num_participants, 200) min_point_award = 100 negative = self.raffle_points < 0 # Decide how we should pick the winners log.info('Num participants: {}'.format(num_participants)) for winner_percentage in [x * 0.01 for x in range(1, 26)]: log.info('Winner percentage: {}'.format(winner_percentage)) num_winners = math.ceil(num_participants * winner_percentage) points_per_user = math.ceil(abs_points / num_winners) log.info('nw: {}, ppu: {}'.format(num_winners, points_per_user)) if num_winners > max_winners: num_winners = max_winners points_per_user = math.ceil(abs_points / num_winners) break elif points_per_user < min_point_award: num_winners = max(1, min(math.floor(abs_points / min_point_award), num_participants)) points_per_user = math.ceil(abs_points / num_winners) break log.info('k done. got {} winners'.format(num_winners)) winners = self.raffle_users[:num_winners] self.raffle_users = [] if negative: points_per_user *= -1 self.bot.me('The multi-raffle has finished! {0} users won {1} points each! PogChamp'.format(len(winners), points_per_user)) winners_arr = [] for winner in winners: winner.points += points_per_user winners_arr.append(winner) winners_str = generate_winner_list(winners_arr) if len(winners_str) > 300: self.bot.me('{} won {} points each!'.format(winners_str, points_per_user)) winners_arr = [] winner.save() if len(winners_arr) > 0: winners_str = generate_winner_list(winners_arr) self.bot.me('{} won {} points each!'.format(winners_str, points_per_user)) HandlerManager.trigger('on_multiraffle_win', winners, points_per_user)
def disable(self, bot): HandlerManager.remove_handler('on_user_sub', self.on_user_sub) HandlerManager.remove_handler('on_user_resub', self.on_user_resub)
def disable(self, bot): HandlerManager.remove_handler('on_message', self.on_message)
def enable(self, bot): self.bot = bot HandlerManager.add_handler('on_user_sub', self.on_user_sub) HandlerManager.add_handler('on_user_resub', self.on_user_resub)