def _universe(self, data, connection):
"""
Universal chat. Sends a message that everyone can see.
:param data: The packet containing the command.
:param connection: The connection from which the packet came.
:return: Null
"""
if self.plugins['chat_manager'].mute_check(connection.player):
send_message(connection, "You are muted and cannot chat.")
return False
if data:
yield from self._send_to_server(data,
ChatSendMode.UNIVERSE,
connection)
if link_plugin_if_available(self, "irc_bot"):
# Try sending it to IRC if we have that available.
asyncio.ensure_future(
self.plugins["irc_bot"].bot_write(
"<{}> {}".format(connection.player.alias,
" ".join(data))))
if link_plugin_if_available(self, "discord_bot"):
discord = self.plugins['discord_bot']
asyncio.ensure_future(discord.bot.send_message(
discord.bot.get_channel(discord.channel),
"**<{}>** {}".format(connection.player.alias, " ".join(
data))))
return True
def _readmail(self, data, connection):
if connection.player.uuid not in self.storage['mail']:
self.storage['mail'][connection.player.uuid] = []
mailbox = self.storage['mail'][connection.player.uuid]
if data:
try:
index = int(data[0]) - 1
mail = mailbox[index]
mail.unread = False
yield from send_message(connection, "From {} on {}: \n{}"
.format(mail.author.alias,
mail.time.strftime("%d %b "
"%H:%M"),
mail.message))
except ValueError:
yield from send_message(connection, "Specify a valid number.")
except IndexError:
yield from send_message(connection, "No mail with that "
"number.")
else:
unread_mail = False
for mail in mailbox:
if mail.unread:
unread_mail = True
mail.unread = False
yield from send_message(connection, "From {} on {}: \n{}"
.format(mail.author.alias,
mail.time
.strftime("%d %b %H:%M"),
mail.message))
if not unread_mail:
yield from send_message(connection, "No unread mail to "
"display.")
def _sendmail(self, data, connection):
if data:
target = self.find_player(data[0])
if not target:
raise SyntaxWarning("Couldn't find target.")
if not data[1]:
raise SyntaxWarning("No message provided.")
uid = target.uuid
if uid not in self.storage['mail']:
self.storage['mail'][uid] = []
mailbox = self.storage['mail'][uid]
if len(mailbox) >= self.max_mail:
yield from send_message(
connection, "{}'s mailbox is full!".format(target.alias))
else:
mail = Mail(" ".join(data[1:]), connection.player)
mailbox.insert(0, mail)
yield from send_message(
connection, "Mail delivered to {}.".format(target.alias))
if target.logged_in:
yield from send_message(
target.connection, "New mail from "
"{}!".format(connection.player.alias))
else:
raise SyntaxWarning("No target provided.")
def _delmail(self, data, connection):
uid = connection.player.uuid
if uid not in self.storage['mail']:
self.storage['mail'][uid] = []
mailbox = self.storage['mail'][uid]
if data:
if data[0] == "all":
self.storage['mail'][uid] = []
yield from send_message(connection, "Deleted all mail.")
elif data[0] == "unread":
for mail in mailbox:
if mail.unread:
self.storage['mail'][uid].remove(mail)
yield from send_message(connection, "Deleted all unread mail.")
elif data[0] == "read":
for mail in mailbox:
if not mail.unread:
self.storage['mail'][uid].remove(mail)
yield from send_message(connection, "Deleted all read mail.")
else:
try:
index = int(data[0]) - 1
self.storage['mail'][uid].pop(index)
yield from send_message(connection,
"Deleted mail {}.".format(data[0]))
except ValueError:
raise SyntaxWarning("Argument must be a category or "
"number. Valid categories: \"read\","
" \"unread\", \"all\"")
except IndexError:
yield from send_message(connection, "No message at "
"that index.")
else:
raise SyntaxWarning("No argument provided.")
def ban_by_name(self, name, reason, protocol):
p = self.get_player_by_name(name)
if p is not None:
self.ban_by_ip(p.ip, reason, protocol)
else:
send_message(protocol,
"Couldn't find a player by the name %s" % name)
def _readmail(self, data, connection):
if connection.player.uuid not in self.storage['mail']:
self.storage['mail'][connection.player.uuid] = []
mailbox = self.storage['mail'][connection.player.uuid]
if data:
try:
index = int(data[0]) - 1
mail = mailbox[index]
mail.unread = False
yield from send_message(
connection, "From {} on {}: \n{}".format(
mail.author.alias, mail.time.strftime("%d %b "
"%H:%M"),
mail.message))
except ValueError:
yield from send_message(connection, "Specify a valid number.")
except IndexError:
yield from send_message(connection, "No mail with that "
"number.")
else:
unread_mail = False
for mail in mailbox:
if mail.unread:
unread_mail = True
mail.unread = False
yield from send_message(
connection, "From {} on {}: \n{}".format(
mail.author.alias,
mail.time.strftime("%d %b %H:%M"), mail.message))
if not unread_mail:
yield from send_message(connection, "No unread mail to "
"display.")
def _protect_ship(self, connection):
"""
Add protection to a ship.
:param connection: Connection of player to have ship protected.
:return: Null.
"""
yield from asyncio.sleep(3)
try:
if connection.player.location.locationtype() is "ShipWorld":
ship = connection.player.location
uuid = connection.player.uuid
if ship.uuid.decode("utf-8") == uuid:
if not self.planet_protect.check_protection(ship):
self.planet_protect.add_protection(
ship, connection.player)
send_message(
connection, "Your ship has been auto-claimed in "
"your name.")
if uuid not in self.storage["owners"]:
self.storage["owners"][uuid] = []
self.storage["owners"][uuid].append(str(ship))
if uuid not in self.storage["owners"]:
self.storage["owners"][uuid] = [str(ship)]
elif str(ship) not in self.storage["owners"][uuid]:
self.storage["owners"][uuid].append(str(ship))
except AttributeError:
pass
def _move_ship(self, connection, location):
"""
Generate packet that moves ship.
:param connection: Player being moved.
:param location: The intended destination of the player.
:return: Null.
:raise: NotImplementedError when POI does not exist.
"""
if location not in self.storage["pois"]:
send_message(connection, "That POI does not exist!")
raise NotImplementedError
else:
location = self.storage["pois"][location]
destination = data_parser.FlyShip.build(dict(
world_x=location.x,
world_y=location.y,
world_z=location.z,
location=dict(
type=SystemLocationType.COORDINATE,
world_x=location.x,
world_y=location.y,
world_z=location.z,
world_planet=location.planet,
world_satellite=location.satellite
)
))
flyship_packet = pparser.build_packet(packets.packets["fly_ship"],
destination)
yield from connection.client_raw_write(flyship_packet)
def waiting_message(user_id):
if user_id:
utilities.send_message(user_id, {"text": "It is coming!"})
time.sleep(1.5)
utilities.send_message(user_id,
{"text": "I beg you few more seconds."})
return
def handle_debug(text, id):
if text[3:] == "waitlist":
log_waitlisted_users()
elif text[3:] == "update":
update_users()
elif text[3:] == "campaign":
send_campaign()
elif text[3:] == "emoticon":
send_emoticon(id)
elif text[3:] == "webview":
message = {
"attachment": {
"type": "template",
"payload": {
"template_type":
"button",
"text":
"Test Webview?",
"buttons": [{
"type": "web_url",
"url": APP_URL + "webview/",
"title": "Show page",
"webview_height_ratio": "compact"
}]
}
}
}
send_message(message=message, id=id)
def _protect_ship(self, connection):
"""
Add protection to a ship.
:param connection: Connection of player to have ship protected.
:return: Null.
"""
yield from asyncio.sleep(.5)
try:
if connection.player.location.locationtype() is "ShipWorld":
ship = connection.player.location
alias = connection.player.alias
if ship.player == alias:
if not self.planet_protect.check_protection(ship):
self.planet_protect. add_protection(ship,
connection.player)
send_message(connection,
"Your ship has been auto-claimed in "
"your name.")
if alias not in self.storage["owners"]:
self.storage["owners"][alias] = []
self.storage["owners"][alias].append(str(ship))
if alias not in self.storage["owners"]:
self.storage["owners"][alias] = [str(ship)]
elif str(ship) not in self.storage["owners"][alias]:
self.storage["owners"][alias].append(str(ship))
except AttributeError:
pass
def ban_by_name(self, name, reason, protocol):
p = self.get_player_by_name(name)
if p is not None:
self.ban_by_ip(p.ip, reason, protocol)
else:
send_message(protocol,
"Couldn't find a player by the name %s" % name)
def planetary_broadcast(self, player, message):
for p in self.players.values():
if p.logged_in and p.location is player.location:
send_message(p.protocol,
message,
name=p.name)
return None
def _delete_player(self, data, connection):
"""
Removes a player from the player database. By default. you cannot
remove a logged-in player, so either they need to be removed from
the server first, or you have to apply the *force operation.
:param data: The packet containing the command.
:param connection: The connection from which the packet came.
:return: Null.
:raise: NameError if is not available. ValueError if player is
currently logged in.
"""
if data[-1] == "*force":
force = True
data.pop()
else:
force = False
alias = " ".join(data)
player = self.get_player_by_alias(alias)
if player is None:
raise NameError
if (not force) and player.logged_in:
raise ValueError(
"Can't delete a logged-in player; please kick them first. If "
"absolutely necessary, append *force to the command.")
self.players.pop(player.uuid)
del player
send_message(connection, "Player {} has been deleted.".format(alias))
def _here(self, data, connection):
"""
Displays all players on the same planet as the user.
:param data: The packet containing the command.
:param connection: The connection from which the packet came.
:return: Null.
"""
ret_list = []
location = str(connection.player.location)
for uid in self.plugins.player_manager.players_online:
p = self.plugins.player_manager.get_player_by_uuid(uid)
if str(p.location) == location:
if connection.player.perm_check(
"general_commands.who_clientids"):
ret_list.append(
"[^red;{}^reset;] {}{}^reset;"
.format(p.client_id,
p.chat_prefix,
p.alias))
else:
ret_list.append("{}{}^reset;".format(
p.chat_prefix, p.alias))
send_message(connection,
"{} players on planet:\n{}".format(len(ret_list),
", ".join(ret_list)))
def send_pref_prompt(id):
message = TextTemplate(
text=
"Whom do you want to chat with? We will notify when someone of the selected gender is waiting to chat."
).get_message()
replies = [{
"title": "Men",
"payload": json.dumps({
"keyword": "subscribe",
"ans": "male"
})
}, {
"title": "Women",
"payload": json.dumps({
"keyword": "subscribe",
"ans": "female"
})
}]
message = add_quick_reply(message,
title=replies[0]["title"],
payload=replies[0]["payload"])
message = add_quick_reply(message,
title=replies[1]["title"],
payload=replies[1]["payload"])
send_message(message, id)
def _sendmail(self, data, connection):
if data:
target = self.find_player(data[0])
if not target:
raise SyntaxWarning("Couldn't find target.")
if not data[1]:
raise SyntaxWarning("No message provided.")
uid = target.uuid
if uid not in self.storage['mail']:
self.storage['mail'][uid] = []
mailbox = self.storage['mail'][uid]
if len(mailbox) >= self.max_mail:
yield from send_message(connection, "{}'s mailbox is full!"
.format(target.alias))
else:
mail = Mail(" ".join(data[1:]), connection.player)
mailbox.insert(0, mail)
yield from send_message(connection, "Mail delivered to {}."
.format(target.alias))
if target.logged_in:
yield from send_message(target.connection, "New mail from "
"{}!"
.format(connection.player.alias))
else:
raise SyntaxWarning("No target provided.")
def _delete_player(self, data, connection):
"""
Removes a player from the player database. By default. you cannot
remove a logged-in player, so either they need to be removed from
the server first, or you have to apply the *force operation.
:param data: The packet containing the command.
:param connection: The connection from which the packet came.
:return: Null.
:raise: NameError if is not available. ValueError if player is
currently logged in.
"""
if data[-1] == "*force":
force = True
data.pop()
else:
force = False
alias = " ".join(data)
player = self.get_player_by_alias(alias)
if player is None:
raise NameError
if (not force) and player.logged_in:
raise ValueError(
"Can't delete a logged-in player; please kick them first. If "
"absolutely necessary, append *force to the command.")
self.players.pop(player.uuid)
del player
send_message(connection, "Player {} has been deleted.".format(alias))
def _protect_ship(self, connection):
"""
Add protection to a ship.
:param connection: Connection of player to have ship protected.
:return: Null.
"""
if not hasattr(connection, "player"):
return
try:
if connection.player.location.locationtype() is "ShipWorld":
ship = connection.player.location
uuid = connection.player.uuid
if ship.uuid.decode("utf-8") == uuid:
if not self.planet_protect.check_protection(ship):
self.planet_protect. add_protection(ship,
connection.player)
send_message(connection,
"Your ship has been auto-claimed in "
"your name.")
if uuid not in self.storage["owners"]:
self.storage["owners"][uuid] = []
self.storage["owners"][uuid].append(str(ship))
if uuid not in self.storage["owners"]:
self.storage["owners"][uuid] = [str(ship)]
elif str(ship) not in self.storage["owners"][uuid]:
self.storage["owners"][uuid].append(str(ship))
except AttributeError:
pass
def _delmail(self, data, connection):
uid = connection.player.uuid
if uid not in self.storage['mail']:
self.storage['mail'][uid] = []
mailbox = self.storage['mail'][uid]
if data:
if data[0] == "all":
self.storage['mail'][uid] = []
yield from send_message(connection, "Deleted all mail.")
elif data[0] == "unread":
for mail in mailbox:
if mail.unread:
self.storage['mail'][uid].remove(mail)
yield from send_message(connection, "Deleted all unread mail.")
elif data[0] == "read":
for mail in mailbox:
if not mail.unread:
self.storage['mail'][uid].remove(mail)
yield from send_message(connection, "Deleted all read mail.")
else:
try:
index = int(data[0]) - 1
self.storage['mail'][uid].pop(index)
yield from send_message(connection, "Deleted mail {}."
.format(data[0]))
except ValueError:
raise SyntaxWarning("Argument must be a category or "
"number. Valid categories: \"read\","
" \"unread\", \"all\"")
except IndexError:
yield from send_message(connection, "No message at "
"that index.")
else:
raise SyntaxWarning("No argument provided.")
def send_campaign():
message = TextTemplate(
text="NEW FEATURE: SUBSCRIPTIONS \n\n" +
"Hi there, this week a new feature is coming out and that is SUBSCRIPTIONS.\n\n"
+
"How it works: When someone gets into the Waiting List due to non availability of "
+
"partners, we will send out a message to our subscribed users. For example, if you "
+
"subscribe for women, we will notify you when a woman is looking for a partner even "
+
"when you are not active and hence you'll gain the chance to chat if you are free. \n\n"
+
"The feature will be made available to every user after one month but some users will "
+
"be given access to it within 1-2 days. To be eligible for getting access, LIKE our "
+
"page and leave a REVIEW on our page within 36 hours. Just to emphasize, please "
+
"complete both to be eligible. \n\nIf you have any question, post it on our page. "
+
"We'll guide you, but make it within the 36 hours because after that, the feature will be out."
)
print("IN CAMPAIGN")
message = TextTemplate(text="F*****G TEST")
#users = User.query.all()
#for user in users:
# id = user.id
#send_message(message, id=id)
users = ["1708022462556195", "1145959985508112"]
for user in users:
send_message(message, id=user)
def _move_ship(self, connection):
"""
Generate packet that moves ship.
:param connection: Player being moved to spawn.
:return: Null.
:raise: NotImplementedError when spawn planet not yet set.
"""
if "spawn_location" not in self.storage["spawn"]:
send_message(connection, "Spawn planet not currently set.")
raise NotImplementedError
else:
spawn_location = self.storage["spawn"]["spawn_location"]
destination = data_parser.FlyShip.build(dict(
world_x=spawn_location.x,
world_y=spawn_location.y,
world_z=spawn_location.z,
location=dict(
type=SystemLocationType.COORDINATE,
world_x=spawn_location.x,
world_y=spawn_location.y,
world_z=spawn_location.z,
world_planet=spawn_location.planet,
world_satellite=spawn_location.satellite
)
))
flyship_packet = pparser.build_packet(packets.packets["fly_ship"],
destination)
yield from connection.client_raw_write(flyship_packet)
def _nick(self, data, connection):
"""
Change your name as it is displayed in the chat window.
:param data: The packet containing the command.
:param connection: The connection from which the packet came.
:return: Null.
"""
if len(data) > 1 and connection.player.perm_check(
"general_commands.nick_others"):
target = self.plugins.player_manager.find_player(data[0])
alias = " ".join(data[1:])
else:
alias = " ".join(data)
target = connection.player
if len(data) == 0:
alias = connection.player.name
conflict = self.plugins.player_manager.get_player_by_alias(alias)
if conflict and target != conflict:
raise ValueError("There's already a user by that name.")
else:
clean_alias = self.plugins['player_manager'].clean_name(alias)
if clean_alias is None:
send_message(connection,
"Nickname contains no valid characters.")
return
old_alias = target.alias
target.alias = clean_alias
broadcast(connection, "{}'s name has been changed to {}".format(
old_alias, clean_alias))
def _move_ship(self, connection, location):
"""
Generate packet that moves ship.
:param connection: Player being moved.
:param location: The intended destination of the player.
:return: Null.
:raise: NotImplementedError when POI does not exist.
"""
if location not in self.storage["pois"]:
send_message(connection, "That POI does not exist!")
raise NotImplementedError
else:
location = self.storage["pois"][location]
destination = data_parser.FlyShip.build(
dict(world_x=location.x,
world_y=location.y,
world_z=location.z,
location=dict(type=SystemLocationType.COORDINATE,
world_x=location.x,
world_y=location.y,
world_z=location.z,
world_planet=location.planet,
world_satellite=location.satellite)))
flyship_packet = pparser.build_packet(packets.packets["fly_ship"],
destination)
yield from connection.client_raw_write(flyship_packet)
def run_command(self, command, connection, to_parse):
"""
Evaluate the command passed in, passing along the arguments. Raise
various errors depending on what might have gone wrong.
:param command: Command to be executed. Looked up in commands dict.
:param connection: Connection which is calling the command.
:param to_parse: Arguments to provide to the command.
:return: Null.
:raise: SyntaxWarning on improper syntax usage. NameError when object
could not be found. ValueError when improper input is provided.
General Exception error as a last-resort catch-all.
"""
try:
yield from self.commands[command](extractor(to_parse),
connection)
except SyntaxWarning as e:
self._send_syntax_error(command, e, connection)
except NameError as e:
self._send_name_error(e, connection)
except ValueError as e:
send_message(connection, str(e))
except SystemExit as e:
raise SystemExit
except:
self.logger.exception("Unknown exception encountered. Ignoring.",
exc_info=True)
def _move_ship(self, connection):
"""
Generate packet that moves ship.
:param connection: Player being moved to spawn.
:return: Null.
:raise: NotImplementedError when spawn planet not yet set.
"""
if "spawn_location" not in self.storage["spawn"]:
send_message(connection, "Spawn planet not currently set.")
raise NotImplementedError
else:
spawn_location = self.storage["spawn"]["spawn_location"]
destination = data_parser.FlyShip.build(
dict(world_x=spawn_location.x,
world_y=spawn_location.y,
world_z=spawn_location.z,
location=dict(type=SystemLocationType.COORDINATE,
world_x=spawn_location.x,
world_y=spawn_location.y,
world_z=spawn_location.z,
world_planet=spawn_location.planet,
world_satellite=spawn_location.satellite)))
flyship_packet = pparser.build_packet(packets.packets["fly_ship"],
destination)
yield from connection.client_raw_write(flyship_packet)
def _socialspy(self, data, connection):
if connection.player in self.social_spies:
self.social_spies.remove(connection.player)
yield from send_message(connection, "Social spy disabled.")
else:
self.social_spies.add(connection.player)
yield from send_message(connection, "Social spy enabled.")
def who(self, data, protocol):
ret_list = []
for player in self.plugins['player_manager'].players.values():
if player.logged_in:
ret_list.append(player.name)
send_message(protocol,
"%d players online: %s" % (len(ret_list),
", ".join(ret_list)))
def _purge_claims(self, data, connection):
target = self.plugins.player_manager.find_player(" ".join(data))
if target.uuid in self.storage['owners']:
self.storage['owners'][target.uuid] = []
yield from send_message(connection, "Purged claims of {}"
.format(target.alias))
else:
yield from send_message(connection, "Target has no claims.")
def send_name_error(self, player_name, protocol):
"""
Sends an error about an incorrect player name.
:param player_name: The non-existent player's name
:param protocol: The active player protocol.
:return: None
"""
send_message(protocol, "Unknown player %s" % player_name)
return None
def invite_new_user(r):
content = request.get_json()
necessary_values = ['phone', 'contacted', 'inviter_identifier']
isGoodRequest = check_for_values_in_request(necessary_values, content)
if (isGoodRequest[0] == False):
return make_response(
{
'response':
'bad request, please try again and specify the ' +
str(isGoodRequest[1]) +
' parameter(s) in the JSON request body.'
}, status.HTTP_400_BAD_REQUEST)
phone = content['phone']
contacted = content['contacted']
inviter_identifier = content['inviter_identifier']
invite_message = "You've been invited to download Exposeure, an app that helps you track your exposure to COVID-19! Find out more at getmyexposure.com"
if (contacted == "False"):
didSend = send_message(invite_message, phone)
if didSend:
return make_response(
{
'response':
'sent messsage to' + str(phone) + 'successfully!'
}, status.HTTP_200_OK)
else:
return make_response(
{
'response':
'did not send messsage to' + str(phone) + 'successfully.'
}, status.HTTP_200_OK)
else:
proto_user = retrieve_or_create_protouser_from_number(phone)
current_proto_user_contacts = proto_user.contactedIds
current_proto_user_contacts.append(inviter_identifier)
proto_user.contactedIds = current_proto_user_contacts
proto_user.save()
proto_user_id = proto_user.identifier
#link this identifier in redis to the push notification feature.
r.set(str(proto_user_id), phone)
didSend = send_message(invite_message, phone)
if didSend:
return make_response(
{
'response':
'sent messsage to' + str(phone) + 'successfully!',
'new_identifier': proto_user_id
}, status.HTTP_200_OK)
else:
return make_response(
{
'response':
'did not send messsage to' + str(phone) + 'successfully.',
'new_identifier': proto_user_id
}, status.HTTP_200_OK)
def list_builders(self, data, protocol):
if not self.check_protection(protocol.player.location):
send_message(protocol, "This location has never been" "protected.")
else:
protection = self.get_protection(protocol.player.location)
players = ", ".join(protection.get_builders())
send_message(
protocol, "Players allowed to build at location "
"'%s': %s" % (protocol.player.location, players))
def send_name_error(self, player_name, protocol):
"""
Sends an error about an incorrect player name.
:param player_name: The non-existent player's name
:param protocol: The active player protocol.
:return: None
"""
send_message(protocol, "Unknown player %s" % player_name)
return None
def protect_ship(self, protocol):
yield from asyncio.sleep(.5)
if isinstance(protocol.player.location, Ship):
ship = protocol.player.location
if not self.check_protection(ship):
if ship.player == protocol.player.name:
self.add_protection(ship, protocol.player)
send_message(protocol,
"Your ship has been auto-protected.")
def protect_ship(self, protocol):
yield from asyncio.sleep(.5)
if isinstance(protocol.player.location, Ship):
ship = protocol.player.location
if not self.check_protection(ship):
if ship.player == protocol.player.name:
self.add_protection(ship, protocol.player)
send_message(protocol,
"Your ship has been auto-protected.")
def whois(self, data, protocol):
if len(data) == 0:
raise SyntaxWarning
name = " ".join(data)
info = self.plugins['player_manager'].get_player_by_name(name)
if info is not None:
send_message(protocol, self.generate_whois(info))
else:
send_message(protocol, "Player not found!")
def list_bans(self, data, protocol):
if len(self.shelf['bans'].keys()) == 0:
send_message(protocol, "There are no active bans.")
else:
res = ["Active bans:"]
for ban in self.shelf['bans'].values():
res.append("IP: %(ip)s - "
"Reason: %(reason)s - "
"Banned by: %(banned_by)s" % ban.__dict__)
send_message(protocol, "\n".join(res))
def list_builders(self, data, protocol):
if not self.check_protection(protocol.player.location):
send_message(protocol, "This location has never been"
"protected.")
else:
protection = self.get_protection(protocol.player.location)
players = ", ".join(protection.get_builders())
send_message(protocol, "Players allowed to build at location "
"'%s': %s" % (protocol.player.location,
players))
def del_builder(self, data, protocol):
p = self.plugins.player_manager.get_player_by_name(" ".join(data))
if p is not None:
protection = self.get_protection(protocol.player.location)
protection.del_builder(p)
send_message(protocol,
"Removed player from build list for this location.")
else:
send_message(protocol, "Couldn't find a player with name "
"%s" % " ".join(data))
def list_bans(self, data, protocol):
if len(self.shelf['bans'].keys()) == 0:
send_message(protocol, "There are no active bans.")
else:
res = ["Active bans:"]
for ban in self.shelf['bans'].values():
res.append("IP: %(ip)s - "
"Reason: %(reason)s - "
"Banned by: %(banned_by)s" % ban.__dict__)
send_message(protocol, "\n".join(res))
def _whoami(self, data, connection):
"""
Displays your current nickname and connection information.
:param data: The packet containing the command.
:param connection: The connection from which the packet came.
:return: Null.
"""
send_message(connection,
self.generate_whois(connection.player))
def _send_name_error(self, player_name, connection):
"""
Sends an error about an incorrect player name.
:param player_name: The non-existent player's name
:param connection: The active player connection.
:return: None
"""
send_message(connection, "Unknown player {}".format(player_name))
return None
def _add_helper(self, data, connection):
location = connection.player.location
alias = connection.player.alias
target = self.plugins.player_manager.get_player_by_alias(
" ".join(data))
if target is not None:
if not self.is_owner(alias, location):
send_message(connection, "You don't own this planet!")
else:
protection = self.planet_protect.get_protection(location)
protection.add_builder(target)
try:
send_message(
connection, "Granted build access to player"
" {}.".format(target.alias))
yield from send_message(
target.connection, "You've been "
"granted build "
"access on {}.".format(location))
except AttributeError:
send_message(
connection, "Player {} isn't online, granted "
"build access anyways.".format(target.alias))
else:
send_message(
connection,
"Player {} could not be found.".format(" ".join(data)))
def del_builder(self, data, protocol):
p = self.plugins.player_manager.get_player_by_name(" ".join(data))
if p is not None:
protection = self.get_protection(protocol.player.location)
protection.del_builder(p)
send_message(protocol,
"Removed player from build list for this location.")
else:
send_message(
protocol, "Couldn't find a player with name "
"%s" % " ".join(data))
def list_players(self, data, protocol):
players = [player for player in self.players.values()]
players.sort(key=attrgetter('name'))
send_message(protocol, "%d players found:" % len(players))
for x, player in enumerate(players):
player_info = " %d. %s%s"
if player.logged_in:
l = " (logged-in)"
else:
l = ""
send_message(protocol, player_info % (x + 1, player.name, l))
def list_players(self, data, protocol):
players = [player for player in self.players.values()]
players.sort(key=attrgetter('name'))
send_message(protocol,
"%d players found:" % len(players))
for x, player in enumerate(players):
player_info = " %d. %s%s"
if player.logged_in:
l = " (logged-in)"
else:
l = ""
send_message(protocol, player_info % (x + 1, player.name, l))
def _whoami(self, data, connection):
"""
Displays your current nickname and connection information.
:param data: The packet containing the command.
:param connection: The connection from which the packet came.
:return: Null.
"""
# TODO: currently this is buggy, and will sometime not work...
# instead, the Starbound version of /whoami will take over.
send_message(connection,
self.generate_whois(connection.player))
def _display_unread(self, connection):
yield from asyncio.sleep(3)
if connection.player.uuid not in self.storage['mail']:
self.storage['mail'][connection.player.uuid] = []
mailbox = self.storage['mail'][connection.player.uuid]
unread_count = len([x for x in mailbox if x.unread])
mail_count = len(mailbox)
if unread_count > 0:
yield from send_message(connection, "You have {} unread messages."
.format(unread_count))
if mail_count >= self.max_mail * 0.8:
yield from send_message(connection, "Your mailbox is almost full!")
def _unprotect(self, data, connection):
"""
Unprotect a location. Location is taken for the player's current
location.
:param data: The packet containing the command.
:param connection: The connection from which the packet came.
:return: Null.
"""
location = connection.player.location
self.disable_protection(location)
send_message(connection, "Unprotected location ()".format(location))
def _give_item(self, data, connection):
"""
Give item(s) to a player.
:param data: The packet containing the command.
:param connection: The connection from which the packet came.
:return: Null.
:raise: SyntaxWarning if too many arguments provided or item count
cannot be properly converted. NameError if a target player
cannot be resolved.
"""
arg_count = len(data)
target = self.plugins.player_manager.find_player(data[0])
if arg_count == 1:
target = connection.player
item = data[0]
count = 1
elif arg_count == 2:
if data[1].isdigit():
target = connection.player
item = data[0]
count = int(data[1])
else:
item = data[1]
count = 1
elif arg_count == 3:
item = data[1]
if not data[2].isdigit():
raise SyntaxWarning("Couldn't convert %s to an item count." %
data[2])
count = int(data[2])
else:
raise SyntaxWarning("Too many arguments")
if target is None:
raise NameError(target)
target = target.connection
if count > 10000 and item != "money":
count = 10000
item_base = data_parser.GiveItem.build(dict(name=item,
count=count,
variant_type=7,
description=""))
item_packet = pparser.build_packet(packets.packets['give_item'],
item_base)
yield from target.raw_write(item_packet)
send_message(connection,
"Gave {} (count: {}) to {}".format(
item,
count,
target.player.alias))
send_message(target, "{} gave you {} (count: {})".format(
connection.player.alias, item, count))
def unban_by_ip(self, ip, connection):
"""
Unban a player based on their IP address. Should be compatible with both
IPv4 and IPv6.
:param ip: String: IP of player to be unbanned.
:param connection: Connection of target player to be unbanned.
:return: Null
"""
# ban = IPBan(ip, reason, connection.player.alias)
del self.shelf["bans"][ip]
send_message(connection,
"Ban removed: {}".format(ip))
def _show_spawn(self, data, connection):
"""
Display the coordinates of the current spawn location.
:param data: The packet containing the command.
:param connection: The connection from which the packet came.
:return: Null.
"""
if "spawn_location" not in self.storage["spawn"]:
send_message(connection, "Spawn planet not currently set.")
else:
spawn_location = self.storage["spawn"]["spawn_location"]
send_message(connection, "{}".format(spawn_location))
