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) 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 _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()