def change_persona_client(name, _connection=None):
output = sims4.commands.CheatOutput(_connection)
# output("working")
client_manager = services.client_manager()
client = client_manager.get(1000)
client._account._persona_name = name
output(client._account._persona_name)
def add_event(self, msg_id, msg, immediate=False):
if self.client is None:
logger.error(
'Could not add event {0} because there are no attached clients',
msg_id)
return
output("client_specific", "Trying to add an event to a client.")
function_name = get_command_function_from_pb(msg_id)
output("client_specific", "Function is {}".format(function_name))
if function_name is not None:
client_id = try_get_client_id_of_pending_command(function_name)
output("client_specific", "Client is {}".format(client_id))
if client_id is not None:
remove_earliest_command_client(function_name)
target_client = self.get_client(client_id)
if target_client is not None:
target_client.add_event(msg_id, msg, immediate)
output("client_specific", "Adding event to client")
return
output(
"client_specific",
"No suitable client found, so I'm just going to send it to everybody"
)
self.events.append((msg_id, msg))
if immediate:
self.process_events()
def rem(_connection=None):
#Forcefully remove the multiplayer client. Only supports one multiplayer client at the moment.
output = sims4.commands.CheatOutput(_connection)
output("Attempting to remove client")
distributor.system._distributor_instance.remove_client_from_id(1000)
client_manager = services.client_manager()
client = client_manager.get(1000)
client_manager.remove(client)
output("Removed client")
def distribute_dialog(self, dialog_type, dialog_msg, immediate=False):
distributor = Distributor.instance()
# distributor.add_event(dialog_type, dialog_msg, immediate=immediate)
distributor_to_send_to = distributor.get_distributor_with_active_sim_matching_sim_id(
dialog_msg.owner_id)
distributor.add_event_for_client(distributor_to_send_to, dialog_type,
dialog_msg, immediate)
try:
output("events", "{}".format(dialog_msg.owner_id))
except Exception as e:
pass
def send_loop(self):
while True:
if self.clientsocket is not None:
output("locks", "acquiring outgoing lock")
with outgoing_lock:
for data in outgoing_commands:
generic_send_loop(data, self.clientsocket)
outgoing_commands.remove(data)
output("locks", "releasing outgoing lock")
def add_client_sims(_connection=None):
output = sims4.commands.CheatOutput(_connection)
client = services.client_manager().get(1000)
first_client = services.client_manager().get_first_client()
#Add the first client's selectable sims to the new client's. Only expecst one multiplayer client at the moment.
for sim in client._selectable_sims:
output(str(sim))
output(str(len(client._selectable_sims)))
for sim_info in first_client._selectable_sims:
client._selectable_sims.add_selectable_sim_info(sim_info)
client.set_next_sim()
def cnc(_connection=None):
#Create a new client. Deprecated.
output = sims4.commands.CheatOutput(_connection)
client = services.client_manager().get_first_client()
account = server.account.Account(865431, "Jon Snow")
new_client = services.client_manager().create_client(
1000, account, client._household_id)
# new_client.clear_selectable_sims()
# for sim_info in client._selectable_sims:
# new_client._selectable_sims.add_selectable_sim_info(sim_info)
# new_client.set_next_sim()
output("Adding client")
def send_loop(self):
self.serversocket.connect((self.host, self.port))
self.connected = True
while True:
output("locks", "acquiring outgoing lock")
with outgoing_lock:
for data in outgoing_commands:
generic_send_loop(data, self.serversocket)
outgoing_commands.remove(data)
output("locks", "releasing outgoing lock")
def enter_dialog_callback(dialog):
if not dialog.accepted:
return
dialog_text = dialog.text_input_responses.get("dialog")
output("chat", 'Showing message')
distributor = Distributor.instance(
).get_distributor_with_active_sim_matching_sim_id(target_id)
if distributor is not None:
client = distributor.client
output("chat", 'Showing message')
show_notif(client.active_sim, dialog_text)
def send_lot_architecture_and_reload(_connection=None):
# output = sims4.commands.CheatOutput(_connection)
# output("working")
zone = services.current_zone()
name = str(hex(zone.id)).replace("0x", "")
output("zone_id", "{}, {}".format(name, zone.id))
file_path = None
# output(str(name))
file_path, file_name = get_file_matching_name(name)
if file_path is not None:
with outgoing_lock:
output("zone_id", "{}, {}".format(file_path, file_name))
msg = File(name, open(file_path, "rb").read())
outgoing_commands.append(msg)
def parse_arg(arg):
#Horrible, hacky way of parsing arguments from the client commands.
new_arg = arg
orig_arg = new_arg.replace('"', "").replace("(", "").replace(")", "").replace("'", "").strip()
new_arg = orig_arg
try:
new_arg = float(orig_arg)
try:
new_arg = int(orig_arg)
except BaseException:
pass
except BaseException:
pass
output("arg_handler", str(new_arg) + "\n")
return new_arg
def mp_chat(target_id=None, _connection=None):
try:
target_id = int(target_id)
output("chat", target_id)
distributor = Distributor.instance(
).get_distributor_with_active_sim_matching_sim_id(target_id)
client = distributor.client
output("chat", client)
def enter_dialog_callback(dialog):
if not dialog.accepted:
return
dialog_text = dialog.text_input_responses.get("dialog")
output("chat", 'Showing message')
distributor = Distributor.instance(
).get_distributor_with_active_sim_matching_sim_id(target_id)
if distributor is not None:
client = distributor.client
output("chat", 'Showing message')
show_notif(client.active_sim, dialog_text)
localized_title = lambda **_: LocalizationHelperTuning.get_raw_text(
"Say Something")
localized_text = lambda **_: LocalizationHelperTuning.get_raw_text(
"Say something to anybody who's listening.")
localized_fname = lambda **_: LocalizationHelperTuning.get_raw_text(
"Type your message here!")
localized_lname = lambda **_: LocalizationHelperTuning.get_raw_text(
"Type your emote here!")
text_input_1 = UiTextInput(sort_order=0)
text_input_1.default_text = localized_fname
text_input_1.title = None
text_input_1.max_length = 100
text_input_1.initial_value = localized_fname
text_input_1.length_restriction = Scum_TextInputLengthName()
inputs = AttributeDict({'dialog': text_input_1})
dialog = UiDialogTextInputOkCancel.TunableFactory().default(
client.active_sim,
text=localized_text,
title=localized_title,
text_inputs=inputs,
is_special_dialog=True)
output("chat", "Dialog id: {}".format(dialog.dialog_id))
dialog.add_listener(enter_dialog_callback)
dialog.show_dialog()
except Exception as e:
output('chat', e)
def wrapper_client(func, *args, **kwargs):
#Wrapper for functions that have their data needed to be sent to the server.
#This is used for client commands so the server can respond.
#For example, selecting a choice from the pie menu.
#Only supports one multiplayer client at the moment.
output("locks", "acquiring outgoing lock")
with outgoing_lock:
output_irregardelessly(
"arg_handler",
"\n" + str(func.__name__) + ", " + str(args) + " " + str(kwargs))
outgoing_commands.append("\n" + str(func.__name__) + ", " + str(args) +
" " + str(kwargs))
def do_nothing():
pass
return do_nothing
output("locks", "releasing outgoing lock")
def send_message_server(self, msg_id, msg):
#Send message override for the server.
#This overrides it so any message for a client with an id of 1000 gets packed into a Message and is placed in the outgoing_commands list for
#sending out to the multiplayer clients.
#Only supports one multiplayer client at the moment.
global outgoing_commands
if self.id != 1000:
if self.active:
omega.send(self.id, msg_id, msg.SerializeToString())
# output_irregardelessly("msg", msg)
else:
message = Message(msg_id, msg.SerializeToString())
output("locks", "acquiring outgoing lock")
#We use a lock here because outgoing_commands is also being altered by the client socket thread.
with outgoing_lock:
outgoing_commands.append(message)
output("locks", "releasing outgoing lock")
pass
def client_sync():
output("locks", "acquiring incoming lock 1")
with incoming_lock:
global incoming_commands
output("receive", "{} \n".format(len(incoming_commands)))
for unpacked_msg_data in incoming_commands:
if type(unpacked_msg_data) is Message:
try:
client = services.client_manager().get_first_client()
client_instance = services.client_manager().get_first_client()
if client == None:
return
except Exception:
continue
omega.send(client_instance.id, unpacked_msg_data.msg_id, unpacked_msg_data.msg)
incoming_commands.remove(unpacked_msg_data)
elif type(unpacked_msg_data) is File:
client_file = open(get_file_matching_name(unpacked_msg_data.file_name)[0], "wb")
new_architecture_data = unpacked_msg_data.file_contents
client_file.write(new_architecture_data)
client_file.close()
incoming_commands.remove(unpacked_msg_data)
output("locks", "releasing incoming lock")
def server_sync():
output("locks", "acquiring incoming lock 1")
with incoming_lock:
global incoming_commands
client_instance = services.client_manager().get_first_client()
for command in incoming_commands:
current_line = command.split(',')
function_name = current_line[0]
if function_name == '':
continue
parsed_args = []
for arg_index in range(1, len(current_line)):
arg = current_line[arg_index].replace(')', '').replace('{}', '').replace('(', '')
if "'" not in arg:
arg = regex.sub('', arg)
arg = arg.replace('<._ = ', '').replace('>', '')
parsed_arg = parse_arg(arg)
parsed_args.append(parsed_arg)
#set connection to other client
client_id = 1000
parsed_args[-1] = client_id
function_to_execute = "{}({})".format(function_name, str(parsed_args).replace('[', '').replace(']',''))
function_name = function_name.strip()
output_irregardelessly("client_specific", "New function called {} recieved".format(function_name))
if function_name in pendable_functions:
with pending_commands_lock:
if function_name not in pending_commands:
pending_commands[function_name] = []
if client_id not in pending_commands[function_name]:
pending_commands[function_name].append(client_id)
output_irregardelessly('arg_handler', str(function_to_execute) )
try:
do_command(function_name, *parsed_args)
except Exception as e:
output_irregardelessly("Execution Errors", "Something happened: {}".format(e))
incoming_commands.remove(command)
output("locks", "releasing incoming lock")
def load_zone(_connection=None):
try:
zone = services.current_zone()
name = str(hex(zone.id)).replace("0x", "")
zone_objects_pb = serialization.ZoneObjectData()
zone_objects_message = open(get_file_matching_name(name)[0],
"rb").read()
output("msg", dir(zone_objects_pb))
zone_objects_pb.ParseFromString(zone_objects_message)
output("msg", zone_objects_pb)
output("msg", zone_objects_message)
persistence_module.run_persistence_operation(
persistence_module.PersistenceOpType.kPersistenceOpLoadZoneObjects,
zone_objects_pb, 0, None)
except Exception as e:
output("er", e)
def generic_listen_loop(socket, recieved_commands, data, size):
# output("receive", "{}, {} \n".format(size, sys.getsizeof(data)))
if size == None:
size = socket.recv(8)
(size,) = unpack('>Q', size)
size = int(size)
elif size > sys.getsizeof(data):
bytes_to_recieve = size - sys.getsizeof(data)
new_data = socket.recv(bytes_to_recieve)
data += new_data
elif size == sys.getsizeof(data):
data = pickle.loads(data)
output("locks", "acquiring incoming lock")
with incoming_lock:
recieved_commands.append(data)
output("locks", "releasing incoming lock")
size = None
data = b''
return recieved_commands, data, size
def get_con(_connection=None):
#Gets the current client connection
output = sims4.commands.CheatOutput(_connection)
output(str(_connection))
def get_name(_connection=None):
output = sims4.commands.CheatOutput(_connection)
output(str(socket.gethostname()))
def change_persona(_connection=None):
output = sims4.commands.CheatOutput(_connection)
# output("working")
client = services.client_manager().get_first_client()
client._account._persona_name = "Corrin"
output(client._account._persona_name)
def csn_show_usage(output):
output("usage: rename [OldFirst OldLast]")
def get_modules(_connection=None):
for thing in sys.modules.keys():
output("modules", thing)
def get_zone_id(_connection=None):
output = sims4.commands.CheatOutput(_connection)
client = services.client_manager().get_first_client()
zone = services.current_zone()
output(str(zone.id))
def stuff(_connection=None):
output("msg", dir(_buildbuy))
import sims4
import socket
from config import user_directory
try:
is_client = False
try:
open("{}client".format(user_directory), "rb")
is_client = True
except Exception:
pass
import multiplayer_server
import multiplayer_client
if is_client:
client_instance = multiplayer_client.Client()
client_instance.listen()
client_instance.send()
else:
server_instance = multiplayer_server.Server()
server_instance.listen()
server_instance.send()
@sims4.commands.Command('shutdown',
command_type=sims4.commands.CommandType.Live)
def shutdown_server(_connection=None):
server_instance.shutdown(socket.SHUT_RDWR)
server_instance.close()
except Exception as e:
output("errors", str(e))
def get_clients(_connection=None):
output = sims4.commands.CheatOutput(_connection)
clients = services.client_manager()._objects.values()
#Gets all the current client connections
for client in clients:
output(str(client.id))
