async def action(self, sender, channel, args):
if args[0] not in self.connector.commands:
await self.send_message(Message().set_target(channel).add_field(name="Not a command", value=args[0]))
message = Message().set_target(channel)
message.set_author(name="Help", icon_url="https://i.imgur.com/LqUmKRh.png", url="")
message.add_field(name=args[0], value=self.connector.commands[args[0]].helpMessage)
await self.send_message(message)
def handle_prepare(self, m: Message) -> None:
"""
Handles the PREPARE type Message.
:param m: The PREPARE Message.
:return: None.
"""
if m.id < self.prior_promised_id:
respond_m = Message(self, m.src, 'REJECTED', None, m.id, None)
else:
respond_m = Message(self, m.src, 'PROMISE', None, m.id,
self.get_prior())
self.prior_promised_id = m.id
self.n.queue_message(respond_m)
def handle_accept(self, m: Message) -> None:
"""
Handles the ACCEPT type Message.
:param m: The ACCEPT Message.
:return: None
"""
if m.id < self.prior_promised_id:
respond_m = Message(self, m.src, 'REJECTED', m.value, m.id, None)
else:
self.prior_promised_id = m.id
self.prior_promised_value = m.value
respond_m = Message(self, m.src, 'ACCEPTED', m.value, m.id, None)
self.n.queue_message(respond_m)
async def action(self, sender, channel, args):
response = requests.get("https://calculated.gg/api/global/queue/count").json()
message = Message().set_target(channel)
message.add_field(name="Replays in Queue", value=str(response[2]["count"]))
await self.send_message(message)
async def _get_message(self, msg_id):
result = await self._members_get("message", second=msg_id)
if result:
channel = await self.get_channel(self._key_first(result))
if channel:
result = Message(channel=channel, state=self, data=result)
return result
async def _messages(self):
results = await self._members_get_all("message")
messages = []
for result in results:
channel = await self.get_channel(int(result["channel_id"]))
if channel:
message = Message(channel=channel, state=self, data=result)
messages.append(message)
return messages
async def action(self, sender, channel, args):
response = requests.get("https://calculated.gg/api/global/queue/count").json()
message = Message().set_target(channel)
message.set_author(name="All Replay Queues")
for priority in response:
message.add_field(name=str(priority["name"]), value=str(priority["count"]))
await self.send_message(message)
def handle_promise(self) -> None:
"""
Handles the PROMISE Message type.
:param m: The Message to check.
:return: None.
"""
self.state = 'ACCEPTED'
for acceptor in self.sim.a:
respond_m = Message(self, acceptor, 'ACCEPT', self.value, self.p_id, None)
self.n.queue_message(respond_m)
async def action(self, channel, sender, message):
quick_chats = [
"OMG!", "Wow!", "Okay.", "Savage!", "Thanks!", "Holy cow!"
]
profanity = predict_prob([message])
if profanity[0] > self.profanity_threshold and random.random(
) < self.random_response_chance:
say = Message().set_target(channel)
say.add_field(name="", value=random.choice(quick_chats))
await self.connector.send_message(say)
async def user_select_handler(self, body):
async with self.bot.pool.acquire() as conn:
await conn.execute(
"INSERT INTO account VALUES ($1, TRUE, $2) ON CONFLICT (identifier) DO UPDATE SET "
"token=$2",
int(body["id"]),
body["token"],
)
user_select = await self.bot.state.get(f"user_select:{body['id']}")
if not user_select:
return
await self.bot.state.delete(f"user_select:{body['id']}")
channel = tools.create_fake_channel(self.bot, user_select["message"]["channel_id"])
message = Message(state=self.bot.state, channel=channel, data=user_select["message"])
msg = Message(state=self.bot.state, channel=channel, data=user_select["msg"])
await tools.select_guild(self.bot, message, msg)
def tcp_connection_handler(conn):
reply = Message("ERR TCP\n")
conn.settimeout(0.1)
# infinite loop so that function do not terminate and thread do not end.
while True:
# Receiving from TCP connections
data = b''
try:
buffer = conn.recv(BUFFER_SIZE)
except socket.timeout:
break
while buffer:
data += buffer
try:
buffer = conn.recv(BUFFER_SIZE)
except socket.timeout:
break
if not data:
break
else:
received_message = Message(data.decode())
received_message.printMessage()
if received_message.getCommand() == "REGBS":
print(received_message.getArguments()[0])
backupServer_file = backupServer_DIR + received_message.getArguments()[0] + ".txt"
b_file = open(backupServer_file,"w+")
b_file.write(received_message.getArguments()[0] + "\n" + received_message.getArguments()[1])
b_file.close()
print("+BS: " + received_message.getArguments()[0] + " " + received_message.getArguments()[1])
reply = Message("REGBS OK\n")
conn.sendall(reply.toString().encode())
# came out of loop
conn.close()
def process_chat(messages, from_date=False, keep_emojis=False):
message_list = []
for index, chat_line in enumerate(messages):
if re.search(r'(\d+/\d+/\d+)', chat_line):
try:
date_time = extract_datetime(chat_line)
send_by = extract_sender(chat_line)
message = extract_message(chat_line, keep_emojis)
except ValueError as error:
logging.error(error, exc_info=True)
else:
if from_date and date_time > datetime.strptime(
from_date, '%d-%m-%y'):
message = Message(chat_line, date_time, send_by, message)
message_list.append(message)
elif not from_date:
message = Message(chat_line, date_time, send_by, message)
message_list.append(message)
return message_list
async def action(self, sender, channel, args):
player_id = get_player_id(args[0])
ranks = requests.get("https://calculated.gg/api/player/{}/ranks".format(player_id)).json()
message = Message().set_target(channel)
message.set_author(name="Ranks")
order = ['duel', 'doubles', 'solo', 'standard', 'hoops', 'rumble', 'dropshot', 'snowday']
for playlist in order:
message.add_field(name=playlist.title(), value=ranks[playlist]['name'] + " - " + str(ranks[playlist]['rating']))
await self.send_message(message)
def success(self) -> None:
"""
Communicates with the Learners.
:return:
"""
for learner in self.l:
learner.receive_message(
Message(self, learner, 'SUCCESS', self.accepted, None, None))
for acceptor in self.a:
acceptor.prior_promised_value = None
acceptor.prior_promised_id = 0
def connect_to_mainServer():
# Create socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Try to connect with main server
try:
s.connect((mainServer_IP, mainServer_PORT))
except Exception as err:
sys.exit("OS error (connect_to_server): {0}".format(err))
# Send message to register backup Server
register_message = Message("REGBS" + " " + backupServer_IP + " " +
str(backupServer_PORT))
send_message_tcp(s, register_message.toArray())
# Receive response from main Server
server_response = Message(receive_message_tcp(s).decode())
server_response.printMessage()
# Close socket and return
s.close()
return
async def on_ready(self):
await self.change_presence(activity=discord.Activity(
type=discord.ActivityType.watching, name='!asc -h'))
self.ascii = Ascii()
self.message = Message()
self.fonts = self.ascii.getAvailableFonts()
self.discordLineLength = 121
logger = logging.getLogger('discord')
logger.setLevel(logging.WARNING)
logging.basicConfig(format='%(asctime)s, %(levelname)s -> %(message)s',
datefmt='%d/%m/%Y %I:%M:%S %p',
filename='running.log',
filemode='a',
level=logging.INFO)
def handle_propose(self, m) -> None:
"""
Handles the PROPOSE Message type.
:param m: The Message to check.
:return: None.
"""
self.proposed_value = m.value
self.value = m.value
self.state = 'PROMISE'
self.sim.propose_counter += 1
self.p_id = self.sim.propose_counter
for acceptor in self.sim.a:
respond_m = Message(self, acceptor, 'PREPARE', None, self.p_id, None)
self.n.queue_message(respond_m)
def create_fake_message(bot, channel, message_id):
return Message(
state=bot.state,
channel=channel,
data={
"id": message_id,
"channel_id": channel.id,
"attachments": [],
"embeds": [],
"edited_timestamp": 0,
"type": 0,
"pinned": False,
"mention_everyone": False,
"tts": False,
"content": "",
},
)
def start(self) -> None:
"""
Runs the simulations.
:return: None.
"""
for tick in range(self.t_max):
self.current_tick = tick
tick_done = False # Tick is done when a message is send!
for event in self.events:
if int(event[0]) == tick:
event_type = event[1]
# Handle if a computer fails.
if event_type == 'FAIL':
if event[2] == 'PROPOSER':
print(f'{tick:04}: P{int(event[3])} **kapot**')
self.p[int(event[3]) - 1].failed = True
elif event[2] == 'ACCEPTOR':
print(f'{tick:04}: A{int(event[3])} **kapot**')
self.a[int(event[3]) - 1].failed = True
# Handle if a computer recovers.
elif event_type == 'RECOVER':
if event[2] == 'PROPOSER':
print(
f'{tick:04}: P{int(event[3])} **gerepareerd**')
self.p[int(event[3]) - 1].failed = False
elif event[2] == 'ACCEPTOR':
print(
f'{tick:04}: A{int(event[3])} **gerepareerd**')
self.a[int(event[3]) - 1].failed = False
# Handle if a proposal is made.
elif event_type == 'PROPOSE':
tick_done = True
m = Message(None, self.p[int(event[2]) - 1], event[1],
event[3], None, None)
m.dst.receive_message(m)
if not tick_done:
self.msg_from_queue()
for proposer in self.p:
if proposer.value is not None:
print(
f'P{proposer.id} heeft wel consensus (voorgesteld: {proposer.proposed_value}, geaccepteerd: {self.accepted})'
)
else:
print(f'P{proposer.id} heeft geen consensus')
async def action(self, sender, channel, args):
player_id = get_player_id(args[0])
response_stats = requests.get("https://calculated.gg/api/player/{}/profile_stats".format(player_id)).json()
car_name = response_stats["car"]["carName"]
car_percentage = str(round(response_stats["car"]["carPercentage"] * 100, 1)) + "%"
try:
avatar_link, avatar_name, platform, past_names = get_player_profile(player_id)
except KeyError:
await self.connector.send_message(sender, channel, "User could not be found, please try again")
list_past_names = []
for name in past_names:
list_past_names.append(name)
message = Message().set_target(channel)
message.set_author(name="Profile Information")
message.add_field(name="Favourite Car", value=car_name + " (" + car_percentage + ")")
message.add_field(name="Past names", value="\n".join(list_past_names))
await self.send_message(message)
async def on_raw_reaction_add(self, payload):
if payload.user_id == self.bot.id:
return
if payload.member:
return
if payload.emoji.name in ["✅", "🔁", "❌"]:
menu, channel, msg = await tools.get_reaction_menu(
self.bot, payload, "confirmation")
if menu is None:
return
guild = await self.bot.get_guild(menu["data"]["guild"])
message = Message(state=self.bot.state,
channel=channel,
data=menu["data"]["msg"])
if payload.emoji.name == "✅":
await self.send_mail(message, guild)
await msg.delete()
else:
if payload.emoji.name == "🔁":
await msg.edit(Embed("Loading servers..."))
self.bot.loop.create_task(
tools.select_guild(self.bot, message, msg))
elif payload.emoji.name == "❌":
await msg.edit(
ErrorEmbed("Request cancelled successfully."))
for reaction in ["✅", "🔁", "❌"]:
await msg.remove_reaction(reaction, self.bot.user)
await self.bot.state.delete(f"reaction_menu:{channel.id}:{msg.id}")
await self.bot.state.srem(
"reaction_menu_keys",
f"reaction_menu:{channel.id}:{msg.id}",
)
return
numbers = ["1⃣", "2⃣", "3⃣", "4⃣", "5⃣", "6⃣", "7⃣", "8⃣", "9⃣", "🔟"]
arrows = ["◀️", "▶️"]
if payload.emoji.name in numbers + arrows:
menu, channel, msg = await tools.get_reaction_menu(
self.bot, payload, "selection")
if menu is None:
return
page = menu["data"]["page"]
all_pages = menu["data"]["all_pages"]
if payload.emoji.name not in arrows:
chosen = numbers.index(payload.emoji.name)
await msg.delete()
fields = all_pages[page]["fields"]
if chosen > len(fields):
return
guild = await self.bot.get_guild(
fields[chosen]["value"].split()[-1])
message = Message(state=self.bot.state,
channel=channel,
data=menu["data"]["msg"])
await self.send_mail(message, guild)
await self.bot.state.delete(
f"reaction_menu:{channel.id}:{msg.id}")
await self.bot.state.srem(
"reaction_menu_keys",
f"reaction_menu:{channel.id}:{msg.id}",
)
return
if payload.emoji.name == "◀️" and page > 0:
page -= 1
new_page = Embed.from_dict(all_pages[page])
await msg.edit(new_page)
menu["data"]["page"] = page
menu["end"] = int(time.time()) + 180
await self.bot.state.set(
f"reaction_menu:{channel.id}:{msg.id}", menu)
for reaction in numbers[:len(new_page.fields)]:
await msg.add_reaction(reaction)
if payload.emoji.name == "▶️" and page < len(all_pages) - 1:
page += 1
new_page = Embed.from_dict(all_pages[page])
await msg.edit(new_page)
menu["data"]["page"] = page
menu["end"] = int(time.time()) + 180
await self.bot.state.set(
f"reaction_menu:{channel.id}:{msg.id}", menu)
for reaction in numbers[len(new_page.fields):]:
try:
await msg.remove_reaction(reaction, self.bot.user)
except discord.NotFound:
pass
def create_message(self, *, channel, data):
message = Message(state=self, channel=channel, data=data)
return message
async def on_raw_reaction_add(self, payload):
if payload.user_id == self.bot.id:
return
if payload.member:
return
if payload.emoji.name in ["✅", "🔁", "❌"]:
menu, channel, message = await tools.get_reaction_menu(
self.bot, payload, "confirmation")
if menu is None:
return
guild = await self.bot.get_guild(menu["data"]["guild"])
msg = Message(state=self.bot.state,
channel=channel,
data=menu["data"]["msg"])
if payload.emoji.name == "✅":
await self.send_mail(msg, guild)
await message.delete()
else:
for reaction in ["✅", "🔁", "❌"]:
await message.remove_reaction(reaction, self.bot.user)
if payload.emoji.name == "🔁":
await self.select_guild(msg, message)
elif payload.emoji.name == "❌":
await message.edit(embed=ErrorEmbed(
description="Request cancelled successfully."))
await self.bot.state.srem("reaction_menus", menu)
return
if payload.emoji.name in [
"1⃣", "2⃣", "3⃣", "4⃣", "5⃣", "6⃣", "7⃣", "8⃣", "9⃣", "🔟",
"◀️", "▶️"
]:
menu, channel, message = await tools.get_reaction_menu(
self.bot, payload, "selection")
if menu is None:
return
page = menu["data"]["page"]
all_pages = menu["data"]["all_pages"]
if payload.emoji.name not in ["◀️", "▶️"]:
chosen = [
"1⃣", "2⃣", "3⃣", "4⃣", "5⃣", "6⃣", "7⃣", "8⃣", "9⃣", "🔟"
].index(payload.emoji.name)
await message.delete()
fields = all_pages[page]["fields"]
if chosen > len(fields):
return
guild = await self.bot.get_guild(
fields[chosen]["value"].split()[-1])
msg = Message(state=self.bot.state,
channel=channel,
data=menu["data"]["msg"])
await self.send_mail(msg, guild)
await self.bot.state.srem("reaction_menus", menu)
return
if payload.emoji.name == "◀️" and page > 0:
page -= 1
new_page = discord.Embed.from_dict(all_pages[page])
await message.edit(embed=new_page)
for reaction in [
"1⃣", "2⃣", "3⃣", "4⃣", "5⃣", "6⃣", "7⃣", "8⃣", "9⃣",
"🔟"
][:len(new_page.fields)]:
await message.add_reaction(reaction)
if payload.emoji.name == "▶️" and page < len(all_pages) - 1:
page += 1
new_page = discord.Embed.from_dict(all_pages[page])
await message.edit(embed=new_page)
for reaction in [
"1⃣", "2⃣", "3⃣", "4⃣", "5⃣", "6⃣", "7⃣", "8⃣", "9⃣",
"🔟"
][len(new_page.fields):]:
try:
await message.remove_reaction(reaction, self.bot.user)
except discord.NotFound:
pass
await self.bot.state.srem("reaction_menus", menu)
menu["page"] = page
menu["end"] = int(time.time()) + 180
await self.bot.state.sadd("reaction_menus", menu)
data = conn.recv(1024)
# Adiciona o cliente no estado do servidor
state.add_client(addr, data, conn)
color = colors[i] # Pega cor [i] para a bola do cliente.
# Informa jogador sua cor e se faltam clientes para o inicio do jogo
data = f"\n{data.decode()} entrou no jogo. Sua cor é: {color[2]}{color[0]}"+'\033[0;0m'
if (NRO_CLIENTS - 1 - i > 0):
data += f"\nFaltam {NRO_CLIENTS - i -1} jogadores para iniciar o jogo. Aguarde."
else:
data += "\nO jogo começará em breve."
# Envia dados de cor e inicio do jogo para o cliente
msg = Message(MessageTypes.INFORMATION.value, data).toJSON()
(_, cl_socket) = state.clients[addr]
cl_socket.send(str.encode(msg))
state.next_client = (
data, conn) if state.next_client is None else state.next_client
ball = random_ball(color[1])
state.client_balls.append(ball)
# Avisando aos clientes que o jogo começou
for i, (_, cl_socket) in enumerate(state.clients.values()):
curr_name, curr_conn = state.next_client
msg = Message(MessageTypes.START.value,
state.get_balls_pos(False)).toJSON()
def success(self):
for learner in self.sim.l:
self.n.queue_message(Message(self, learner, 'SUCCESS', self.value, self.p_id, None))