def send(self, *player_indexes):
"""Send the user message."""
# We need to handle the ShowMenu user message with bitbuffers
# differently, because the maximum size is 255. If the message exceeds
# this length, we need to sent it in several parts.
if UserMessage.is_protobuf():
recipients = RecipientFilter(*player_indexes)
user_message = UserMessage(recipients, self.message_name)
self.protobuf(user_message.buffer, self)
user_message.send()
else:
self.bitbuf(player_indexes, self)
def send(self, *player_indexes):
"""Send the user message."""
# We need to handle the ShowMenu user message with bitbuffers
# differently, because the maximum size is 255. If the message exceeds
# this length, we need to sent it in several parts.
if UserMessage.is_protobuf():
recipients = RecipientFilter(*player_indexes)
user_message = UserMessage(recipients, self.message_name)
self.protobuf(user_message.buffer, self)
user_message.send()
else:
self.bitbuf(player_indexes, self)
def __init__(
self, message, index=0, chat=False,
color=(' \x01' if UserMessage.is_protobuf() else '\x01')):
"""Initialize the SayText instance."""
super().__init__(message=message, index=index, chat=chat)
super(AttrDict, self).__setattr__("color", color)
def _send(self, player_indexes, translated_kwargs):
"""Send the user message to the given players.
:param iterable player_indexes: All players with the same language
setting.
:param AttrDict translated_kwargs: The translated arguments.
"""
recipients = RecipientFilter(*player_indexes)
user_message = UserMessage(recipients, self.message_name)
if user_message.is_protobuf():
self.protobuf(user_message.buffer, translated_kwargs)
else:
self.bitbuf(user_message.buffer, translated_kwargs)
user_message.send()
def _send(self, player_indexes, translated_kwargs):
"""Send the user message to the given players.
:param iterable player_indexes: All players with the same language
setting.
:param AttrDict translated_kwargs: The translated arguments.
"""
recipients = RecipientFilter(*player_indexes)
user_message = UserMessage(recipients, self.message_name)
if user_message.is_protobuf():
self.protobuf(user_message.buffer, translated_kwargs)
else:
self.bitbuf(user_message.buffer, translated_kwargs)
user_message.send()
def _send(self, player_indexes, translated_kwargs):
"""Send the user message to the given players.
:param iterable player_indexes: All players with the same language
setting.
:param AttrDict translated_kwargs: The translated arguments.
"""
recipients = RecipientFilter(*player_indexes)
recipients.reliable = self.reliable
user_message = UserMessage(recipients, self.message_name)
if user_message.is_protobuf():
self.protobuf(user_message.buffer, translated_kwargs)
user_message.send()
else:
try:
self.bitbuf(user_message.buffer, translated_kwargs)
except:
# In case of an error during writing to the buffer (e. g. by using
# the wrong data type for the write_* methods) reset the buffer
# and send the message. This causes the engine to silently ignore
# the user message and the server doesn't crash upon creating
# another user message.
# See also:
# https://github.com/Source-Python-Dev-Team/Source.Python/issues/315
user_message.buffer.reset()
# Re-raise the exception to make the user aware of the problem
raise
finally:
user_message.send()
def __init__(
self, message, index=0, chat=False,
param1='', param2='', param3='', param4='',
color=(' \x01' if UserMessage.is_protobuf() else '\x01')):
"""Initialize the SayText2 instance."""
super().__init__(
message=message, index=index, chat=chat,
param1=param1, param2=param2, param3=param3, param4=param4)
super(AttrDict, self).__setattr__("color", color)
def bitbuf(self, player_indexes, kwargs):
"""Send the ShowMenu with bitbuf."""
menu_string = kwargs.menu_string
length = len(menu_string)
recipients = RecipientFilter(*player_indexes)
while True:
user_message = UserMessage(recipients, self.message_name)
buffer = user_message.buffer
buffer.write_word(kwargs.valid_slots)
buffer.write_char(kwargs.display_time)
buffer.write_byte(length > self.chunk_size)
buffer.write_string(menu_string[:self.chunk_size])
user_message.send()
if length > self.chunk_size:
menu_string = menu_string[self.chunk_size:]
length -= self.chunk_size
else:
break
def bitbuf(self, player_indexes, kwargs):
"""Send the ShowMenu with bitbuf."""
menu_string = kwargs.menu_string
length = len(menu_string)
recipients = RecipientFilter(*player_indexes)
while True:
user_message = UserMessage(recipients, self.message_name)
buffer = user_message.buffer
buffer.write_word(kwargs.valid_slots)
buffer.write_char(kwargs.display_time)
buffer.write_byte(length > self.chunk_size)
buffer.write_string(menu_string[:self.chunk_size])
user_message.send()
if length > self.chunk_size:
menu_string = menu_string[self.chunk_size:]
length -= self.chunk_size
else:
break
def _send_message(self, recipient, **kwargs):
"""Send the message to the given recipient filter."""
# Get a UserMessage instance
usermsg = UserMessage(recipient, self._message_name)
# Loop through all required parameters
for parameter_name in self._required_parameters:
# Get the current parameter data
parameter_data = self._required_parameters[parameter_name]
# Get the current parameter length
parameter_length = parameter_data['length']
# Is the current parameter larger than one value?
if parameter_length > 1:
# Try to prepare the current parameter values
try:
# Prepare the given values
parameter_values = self._prepare_parameter(
parameter_name, kwargs[parameter_name])
# I'm not really fan of this but, to prevent crashes, we need
# to hook any exceptions that may occurs...
except:
# Print the exception to the console
except_hooks.print_exception()
# Print a debugging message
echo_console(
'"{0}" is not a valid value for "{1}.{2}"'.format(
kwargs[parameter_name],
self._message_name,
parameter_name))
# Use the default values
parameter_values = self._prepare_parameter(
parameter_name, parameter_data['default_values'])
# Get the current parameter field name
field_name = parameter_data['field_name']
# Loop through all values
for parameter_index, parameter_type, parameter_value in zip(
range(parameter_length), parameter_data['types'],
parameter_values):
# Write the current parameter
self._write_field_value(
parameter_name, usermsg, parameter_type,
field_name, parameter_value, parameter_index)
# Otherwise
else:
# Try to convert the given value
try:
# Prepare the current parameter
parameter_value = self._prepare_parameter(
parameter_name, kwargs[parameter_name])
# I'm not really fan of this but, to prevent crashes, we need
# to hook any exceptions that may occurs...
except:
# Print the exception to the console
except_hooks.print_exception()
# Print a debugging message
echo_console(
'"{0}" is not a valid value for "{1}.{2}"'.format(
kwargs[parameter_name],
self._message_name,
parameter_name))
# Use the default value
parameter_value = self._prepare_parameter(
parameter_name, parameter_data['default_value'])
# Write the current parameter
self._write_field_value(
parameter_name, usermsg, parameter_data['type'],
parameter_data['field_name'], parameter_value)
# Send the message
usermsg.send_message()
