public override void OnEnable()
{
var coco_ = (IEnumerator)PrivateUtilities.callPrivateMethod(stateTransceiver, "PostFixedUpdateCoroutine");
PrivateUtilities.setPrivateField(stateTransceiver, "coco_", coco_);
transceiver.StartCoroutine(coco_);
}
public override void use(ClientPlayerInfo p, string message)
{
if (!GeneralUtilities.isOnGamemode())
{
MessageUtilities.sendMessage(p, "Can't restart on lobby !");
return;
}
var serverLogic = G.Sys.GameManager_.GetComponent <ServerLogic>();
if (serverLogic == null)
{
MessageUtilities.sendMessage(p, "ServerLogic null !");
return;
}
var clients = (IEnumerable)PrivateUtilities.getPrivateField(serverLogic, "clientInfoList_");
foreach (var c in clients)
{
if (p.NetworkPlayer_ == (UnityEngine.NetworkPlayer)PrivateUtilities.getPrivateField(c, "networkPlayer_"))
{
exec(serverLogic, c);
break;
}
}
}
public override void use(ClientPlayerInfo p, string message)
{
var clientLogic = G.Sys.PlayerManager_.GetComponent <ClientLogic>();
if (clientLogic == null)
{
MessageUtilities.sendMessage(p, "Error : Client logic null !");
return;
}
try
{
var client = clientLogic.GetLocalPlayerInfo();
var oldName = client.Username_;
PrivateUtilities.setPrivateField(client, "username_", message);
MessageUtilities.sendMessage(p, oldName + " renamed to " + client.Username_);
}
catch (Exception e)
{
Console.WriteLine(e);
MessageUtilities.sendMessage(p, "Error : can't change your name !");
}
}
public override void Awake()
{
// Do RigidbodyStateTransceiver Awake
PrivateUtilities.setPrivateField(stateTransceiver, "rigidbody_", transceiver.GetComponent <Rigidbody>());
PrivateUtilities.setPrivateField(stateTransceiver, "setPositionImmediate_", true);
// Do NetworkStateTransceiverGeneric Awake
PrivateUtilities.setPrivateField(stateTransceiver, "buffer_", new Distance::SortedCircularBuffer <Distance::RigidbodyStateTransceiver.Snapshot>(32));
stateTransceiver.Clear();
}
public GameModeBridge()
{
// This class is just a stub so that Distance's CarStateTransceiver has a valid bridge to isGo_
// isGo_ needs to be true for Distance's CarStateTransceiver to do its work.
// make isGo_ true:
isStarted_ = true;
PrivateUtilities.setPrivateProperty(typeof(Distance::Timex), null, "PhysicsFrameCount_", 0);
StartPhysFrame_ = -1;
}
public ChatReplicationManager()
{
ChatLog chatLog = ChatLog.Instance_;
bufferSize = (int)PrivateUtilities.getPrivateField(chatLog, "bufferSize_");
publicChatBuffer = new CircularBuffer <string>(bufferSize);
personalChatBuffers = new Dictionary <string, CircularBuffer <string> >();
needsReplication = new List <string>();
}
public override void Awake()
{
// Do CarStateTransceiver Awake
CarLogicBridge = new CarLogicBridge();
PrivateUtilities.setPrivateField(stateTransceiver, "carLogic_", CarLogicBridge);
PrivateUtilities.setPrivateField(stateTransceiver, "mode_", new GameModeBridge());
// Do NetworkStateTransceiverGeneric Awake
PrivateUtilities.setPrivateField(stateTransceiver, "buffer_", new Distance::SortedCircularBuffer <Distance::CarDirectives>(32));
stateTransceiver.Clear();
}
public int RemoveEventListeners()
{
DebugLog("Removing event listeners...");
ChatLog chatLog = ChatLog.Instance_;
PrivateUtilities.removeParticularSubscriber <WelcomeClient.Data>(chatLog);
PrivateUtilities.removeParticularSubscriber <SetServerChat.Data>(chatLog);
var chatInputV2s = PrivateUtilities.getComponents <ChatInputV2>();
PrivateUtilities.removeParticularSubscribers <SetServerChat.Data, ChatInputV2>(chatInputV2s);
return(chatInputV2s.Count);
}
public void AddRemoteLog(string remoteLog)
{
DebugLog("Adding remote log...");
var localClient = GeneralUtilities.localClient();
if (localClient == null)
{
DebugLog("No local client. Clearing logs and setting logs directly.");
Clear();
AddPublic(remoteLog);
ChatLog.SetLog(remoteLog);
G.Sys.GameManager_.StartCoroutine(RemoveEventListenersCoroutine());
return;
}
DebugLog("Adding logs from the server:");
string[] remoteLogArray = System.Text.RegularExpressions.Regex.Split(remoteLog, $"\r\n|\n|\r");
var localNetworkPlayer = localClient.NetworkPlayer_;
var personalBuffer = GetPersonalBuffer(localNetworkPlayer);
DebugLog($"\nPublic log:\n{GetBufferString(publicChatBuffer)}");
DebugLog($"\nPersonal log:\n{GetBufferString(personalBuffer)}");
DebugLog($"\nRemote log:\n{remoteLog}");
List <DiffLine> publicDiff = DiffLine.GetDiffLines(publicChatBuffer);
DiffLine.ExecuteDiff(publicDiff, remoteLogArray);
string publicLog = DiffLine.DiffLinesToString(publicDiff);
DebugLog($"\nPublic diff:\n{DiffLine.DiffLinesToStringInfo(publicDiff)}");
List <DiffLine> personalDiff = publicDiff;
DiffLine.ExecuteDiff(personalDiff, personalBuffer, DiffLine.DiffOptions.AddFirst);
string personalLog = DiffLine.DiffLinesToString(personalDiff);
publicChatBuffer.Clear();
AddPublicNoPersonal(publicLog);
personalBuffer.Clear();
AddPersonalNoAddLocal(localNetworkPlayer, personalLog);
DebugLog($"\nFinal diff:\n{DiffLine.DiffLinesToStringInfo(personalDiff)}");
ChatLog.SetLog(personalLog);
foreach (var chatInput in PrivateUtilities.getComponents <ChatInputV2>())
{
PrivateUtilities.callPrivateMethod(chatInput, "OnEventSetServerChat", new SetServerChat.Data(personalLog));
}
}
public void Update()
{
ModeTime = Network.time + ModeTimeOffset;
PrivateUtilities.setPrivateProperty(typeof(Distance::Timex), null, "ModeTime_", ModeTime);
OnUpdateEvent.Fire();
if (StartingLevel)
{
AttemptToStartLevel();
}
else if (StartingMode && StartingModeTime != -1.0 && Network.time - StartingModeTime >= StartingModeTimeout && !StartingModeDelay)
{
AttemptToStartMode();
}
}
public override void use(ClientPlayerInfo p, string message)
{
var gameMode = G.Sys.GameManager_.Mode_;
if (gameMode == null)
{
MessageUtilities.sendMessage("Mode_ is null! Something is very wrong!");
Console.WriteLine("Mode_ is null! Something is very wrong!");
}
else
{
MessageUtilities.sendMessage($"GameMode Name_: {gameMode.Name_}");
Console.WriteLine($"GameMode Name_: {gameMode.Name_}");
MessageUtilities.sendMessage($"IsStarted_: {gameMode.IsStarted_}");
Console.WriteLine($"IsStarted_: {gameMode.IsStarted_}");
}
MessageUtilities.sendMessage("Connected players:");
MessageUtilities.sendMessage("gui : name : state : ready");
Console.WriteLine("guid : name : state : ready : levelVersion");
// more information is provided in the console. the message is meant to be sort-of compact.
var serverLogic = G.Sys.GameManager_.GetComponent <ServerLogic>();
var clientInfoList = (System.Collections.IEnumerable)PrivateUtilities.getPrivateField(serverLogic, "clientInfoList_");
foreach (object clientInfo in clientInfoList)
{
// clientInfo is a private class so we can't actually use it :(
// we can't even reference it for List<ClientInfo>
// instead we have to use reflection to get the values of everything
// (at least, i'm not aware of any other way to use it)
var networkPlayer = (UnityEngine.NetworkPlayer)PrivateUtilities.getPrivateField(clientInfo, "networkPlayer_");
var client = GeneralUtilities.getClientFromNetworkPlayer(networkPlayer);
string name = client == null ? "Unknown" : MessageUtilities.closeTags(client.GetChatName());
string rawName = client == null ? "Unknown" : client.Username_;
var stateEnum = (Enum)PrivateUtilities.getPrivateField(clientInfo, "state_");
string state = stateEnum.ToString();
bool ready = (bool)PrivateUtilities.getPrivateProperty(clientInfo, "IsOkWithTheModeBeingStarted_");
string levelVersion = (string)PrivateUtilities.getPrivateField(clientInfo, "levelVersion_");
MessageUtilities.sendMessage($"{networkPlayer.guid} : {name} : {state} : {ready}");
Console.WriteLine($"{networkPlayer.guid} : {rawName} : {state} : {ready} : {levelVersion}");
}
MessageUtilities.sendMessage("Try using !unstuck");
Console.WriteLine("Try using !unstuck");
}
public override void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
if (stream.isReading)
{
// Bypass SortedCircularBuffer logic. We assume that this is the newest CarDirectives data and update the main CarDirectives.
// TODO: use SortedCircularBuffer. Find what index is the newest, streamed in data and call Serialize on it.
// (We have to do this because Serialize is not called normally, which means that correct network data never gets turned into a non-zero CarDirectives)
var newStream = ((Distance::BitStreamUnity)PrivateUtilities.getPrivateField(typeof(Distance::NetworkStateTransceiver), stateTransceiver, "stream_"));
newStream.Encapsulate(stream);
double timestamp = double.MinValue;
newStream.Serialize(ref timestamp);
CarLogicBridge.CarDirectives_.StreamIn(newStream);
PrivateUtilities.callPrivateMethod(CarLogicBridge.CarDirectives_, "Serialize", new Distance::BitEncoder(CarLogicBridge.CarDirectives_.Bits_));
}
else
{
stateTransceiver.OnSerializeNetworkView(stream, info);
}
}
public static System.Collections.IEnumerator StartGameAfterTimeout(int id, int timeout)
{
yield return(new UnityEngine.WaitForSeconds(timeout));
Console.WriteLine("InfinteLoadingTimeoutPatch Log:");
if (loadCounter != id)
{
Console.WriteLine("\tCancelled because: new level loaded");
yield break;
}
if (Utilities.GeneralUtilities.isOnLobby())
{
Console.WriteLine("\tCancelled because: on lobby");
yield break;
}
var serverLogic = G.Sys.GameManager_.GetComponent <ServerLogic>();
if (serverLogic == null)
{
Console.WriteLine("\tCould not get ServerLogic! It does not exist!");
yield break;
}
var screens = PrivateUtilities.getComponents <OnlineMatchWaitingScreen>();
if (screens.Count == 0)
{
Console.WriteLine("\tNo loading screens. Game must be loaded.");
yield break;
}
Console.WriteLine("\tLoading screen detected after timeout. Force-starting server.");
var startPlayers = new List <UnityEngine.NetworkPlayer>();
var clientInfoList = (System.Collections.IEnumerable)PrivateUtilities.getPrivateField(serverLogic, "clientInfoList_");
foreach (object clientInfo in clientInfoList)
{
var networkPlayer = (UnityEngine.NetworkPlayer)PrivateUtilities.getPrivateField(clientInfo, "networkPlayer_");
startPlayers.Add(networkPlayer);
}
Events.Server.ReadyToStartGameMode.Broadcast(new Events.Server.ReadyToStartGameMode.Data(startPlayers.ToArray()));
Utilities.MessageUtilities.sendMessage("Force-started match after timeout");
}
public static bool StartGameIfReady()
{
Console.WriteLine("InfinteLoadingPatch Log:");
if (!GeneralUtilities.isHost() || !GeneralUtilities.isOnline())
{
Console.WriteLine("\tNot host");
return(false);
}
if (!all.getCommand <UnstuckCmd>().infiniteLoadingPatchEnabled)
{
Console.WriteLine("\tNot enabled");
return(false);
}
var serverLogic = G.Sys.GameManager_.GetComponent <ServerLogic>();
if (serverLogic == null)
{
Console.WriteLine("\tCould not get ServerLogic! It does not exist!");
return(false);
}
var hasStarted = (bool)PrivateUtilities.callPrivateMethod(serverLogic, "HasModeStarted");
if (!hasStarted)
{
Console.WriteLine("\tMatch has not started yet. Will wait for started event...");
return(false);
}
Console.WriteLine("\tMatch has already started. Firing ReadyToStartGameMode to simulate a proper start. This is the same as !unstuck 1 all.");
var startPlayers = new List <UnityEngine.NetworkPlayer>();
var clientInfoList = (System.Collections.IEnumerable)PrivateUtilities.getPrivateField(serverLogic, "clientInfoList_");
foreach (object clientInfo in clientInfoList)
{
var networkPlayer = (UnityEngine.NetworkPlayer)PrivateUtilities.getPrivateField(clientInfo, "networkPlayer_");
startPlayers.Add(networkPlayer);
}
Events.Server.ReadyToStartGameMode.Broadcast(new Events.Server.ReadyToStartGameMode.Data(startPlayers.ToArray()));
Utilities.MessageUtilities.sendMessage("Force-started match on load");
return(true);
}
void exec(ServerLogic server, object client)
{
PrivateUtilities.callPrivateMethod(server, "SendClientToCurrentLevel", client);
}
public override void Start()
{
PrivateUtilities.callPrivateMethod(stateTransceiver, "Start");
}
public override void Update()
{
PrivateUtilities.callPrivateMethod(stateTransceiver, "Update");
}
public override void use(ClientPlayerInfo p, string message)
{
var match = Regex.Match(message, @"^(\d*) ?(.*)$");
var mode = 1;
var param = "";
if (match.Success)
{
if (match.Groups[1].Value != "")
{
mode = int.Parse(match.Groups[1].Value);
}
param = match.Groups[2].Value;
}
if (mode == 1 || mode == 2)
{
var isAll = param == "all";
var addon = isAll ? " on all" : "on loaded, submitted, and started";
if (mode == 1)
{
MessageUtilities.sendMessage("Trying mode 1 (ReadyToStartMode) " + addon);
Console.WriteLine("Trying mode 1 (ReadyToStartMode) " + addon);
}
else
{
MessageUtilities.sendMessage("Trying mode 2 (StartMode) " + addon);
Console.WriteLine("Trying mode 2 (StartMode) " + addon);
}
var startPlayers = new List <UnityEngine.NetworkPlayer>();
var failedAny = false;
var serverLogic = G.Sys.GameManager_.GetComponent <ServerLogic>();
var clientInfoList = (System.Collections.IEnumerable)PrivateUtilities.getPrivateField(serverLogic, "clientInfoList_");
foreach (object clientInfo in clientInfoList)
{
// clientInfo is a private class so we can't actually use it :(
// we can't even reference it for List<ClientInfo>
// instead we have to use reflection to get the values of everything
// (at least, i'm not aware of any other way to use it)
var networkPlayer = (UnityEngine.NetworkPlayer)PrivateUtilities.getPrivateField(clientInfo, "networkPlayer_");
var client = GeneralUtilities.getClientFromNetworkPlayer(networkPlayer);
string name = client == null ? "Unknown" : MessageUtilities.closeTags(client.GetChatName());
string rawName = client == null ? "Unknown" : client.Username_;
var stateEnum = (Enum)PrivateUtilities.getPrivateField(clientInfo, "state_");
string state = stateEnum.ToString();
if (allowedStates.Contains(state) || isAll)
{
startPlayers.Add(networkPlayer);
}
else
{
failedAny = true;
MessageUtilities.sendMessage($"Not starting {name} because their state is {state}");
Console.WriteLine($"Not starting {rawName} because their state is {state}");
}
}
if (failedAny)
{
MessageUtilities.sendMessage("You can force start all players using !unstuck all");
Console.WriteLine("You can force start all players using !unstuck all");
}
if (mode == 1)
{
Events.Server.ReadyToStartGameMode.Broadcast(new Events.Server.ReadyToStartGameMode.Data(startPlayers.ToArray()));
}
else
{
var gameMode = G.Sys.GameManager_.Mode_;
double startTime;
if (gameMode == null)
{
MessageUtilities.sendMessage("Mode_ is null! Something is very wrong! Using 0 for start time.");
Console.WriteLine("Mode_ is null! Something is very wrong! Using 0 for start time.");
startTime = 0;
}
else
{
startTime = (double)PrivateUtilities.callPrivateMethod(typeof(GameMode), gameMode, "CalcStartTime");
}
foreach (UnityEngine.NetworkPlayer player in startPlayers)
{
Events.ServerToClient.StartMode.Broadcast(player, new Events.ServerToClient.StartMode.Data(startTime, false));
}
}
MessageUtilities.sendMessage($"Tried to start {startPlayers.Count} players.");
Console.WriteLine($"Tried to start {startPlayers.Count} players.");
}
else if (mode == 3)
{
MessageUtilities.sendMessage("Trying mode 3 (Destroy OnlineMatchWaitingScreen)");
Console.WriteLine("Trying mode 3 (Destroy OnlineMatchWaitingScreen)");
var screens = PrivateUtilities.getComponents <OnlineMatchWaitingScreen>();
MessageUtilities.sendMessage($"Found {screens.Count} screens.");
Console.WriteLine($"Found {screens.Count} screens.");
foreach (var screen in screens)
{
UnityEngine.Object.Destroy(screen.transform.root.gameObject);
}
MessageUtilities.sendMessage($"Destroyed {screens.Count} screens.");
Console.WriteLine($"Destroyed {screens.Count} screens.");
}
else
{
MessageUtilities.sendMessage($"Unknown mode: {mode}");
Console.WriteLine($"Unknown mode: {mode}");
}
}
public override void use(ClientPlayerInfo p, string message)
{
if (GeneralUtilities.isOnLobby())
{
MessageUtilities.sendMessage(p, "You can't do that on the lobby !");
return;
}
try
{
var playersInfos = (List <ModePlayerInfoBase>)PrivateUtilities.getPrivateField(G.Sys.GameManager_.Mode_, "modePlayerInfos_");
playersInfos.Sort((a, b) =>
{
if (a.finishType_ == FinishType.Normal && b.finishType_ == FinishType.Normal)
{
double diff = a.modeData_ - b.modeData_;
return(diff < 0 ? -1 : diff > 0 ? 1 : 0);
}
else if (a.finishType_ == FinishType.None && b.finishType_ == FinishType.None)
{
if (a is TimeBasedModePlayerInfo)
{
double diff = ((TimeBasedModePlayerInfo)a).distanceToFinish_ - ((TimeBasedModePlayerInfo)b).distanceToFinish_;
return(diff < 0 ? -1 : diff > 0 ? 1 : 0);
}
else
{
double diff = a.modeData_ - b.modeData_;
return(diff < 0 ? -1 : diff > 0 ? 1 : 0);
}
}
else
{
return(Array.IndexOf(finishTypeValues, a.finishType_) - Array.IndexOf(finishTypeValues, b.finishType_));
}
});
foreach (var pI in playersInfos)
{
string playerStr = pI.Name_ + " : ";
switch (pI.finishType_)
{
case FinishType.None:
playerStr += $"[FFFFFF]{textInfoOf(pI, false)}[-]";
break;
case FinishType.DNF:
playerStr += "[FF2222]DNF[-]";
break;
case FinishType.JoinedLate:
playerStr += "[FFFF22]Joined late[-]";
break;
case FinishType.Normal:
playerStr += $"[22FF22]Finished {textInfoOf(pI, true)}[-]";
break;
case FinishType.Spectate:
playerStr += "[88FF88]Spectator[-]";
break;
default:
playerStr += "None";
break;
}
MessageUtilities.sendMessage(p, playerStr);
}
}
catch (Exception e)
{
MessageUtilities.sendMessage(p, "Error !");
Console.WriteLine(e);
}
}
public override void OnDisable()
{
transceiver.StopCoroutine((IEnumerator)PrivateUtilities.getPrivateField(stateTransceiver, "coco_"));
}
public override void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
{
stateTransceiver.OnSerializeNetworkView(stream, info);
var buffer = (Distance::SortedCircularBuffer <Distance::RigidbodyStateTransceiver.Snapshot>)PrivateUtilities.getPrivateField(stateTransceiver, "buffer_");
}
public override void use(ClientPlayerInfo p, string message)
{
if (message == "")
{
help(p);
return;
}
Match msgMatch = Regex.Match(message, settingRegex);
if (msgMatch.Success)
{
string setting = msgMatch.Groups[1].Value.ToLower();
if (setting == "reload")
{
reload(p);
return;
}
/* // TODO: fix this to use new FileSystem stuff
* else if (setting == "writemarkdown")
* { // command used to generate markdown help for settings. not shown to user.
* string style = msgMatch.Groups[2].Value.ToLower();
* if (style == "command" || style == "both")
* {
* string txt = "";
* foreach (Cmd Command in Cmd.all.list())
* {
* string txt2 = "";
* foreach (CmdSetting Setting in Command.settings)
* {
* if (Setting.SettingsId != "")
* txt2 += $" * `!settings {Setting.SettingsId} {Setting.UsageParameters}` \n{Setting.HelpMarkdown} \nDefault: {Setting.DefaultTypeless} \n";
* }
* if (txt2 != "")
* txt += $"* `!{Command.name}` Settings\n" + txt2;
* }
* string FilePath = Path.Combine(Defaults.SettingsDirectory, "servermod-settings.command.md");
* using (var sw = new StreamWriter(FilePath, false))
* {
* sw.Write(txt);
* }
* }
*
* if (style == "file" || style == "both")
* {
* string txt = "";
* foreach (Cmd Command in Cmd.all.list())
* {
* string txt2 = "";
* foreach (CmdSetting Setting in Command.settings)
* {
* if (Setting.FileId != "")
* txt2 += $"* `\"{Setting.FileId}\" : {Setting.UsageParameters},` \n{Setting.HelpMarkdown} \nDefault: {Setting.DefaultTypeless} \n";
* }
* if (txt2 != "")
* txt += txt2;
* }
* string FilePath = Path.Combine(Defaults.SettingsDirectory, "servermod-settings.file.md");
* using (var sw = new StreamWriter(FilePath, false))
* {
* sw.Write(txt);
* }
* }
*
* if (style != "file" && style != "command" && style != "both")
* Console.WriteLine("Unknown style type. Styles: command, file, both");
* return;
* }
*/
else if (setting == "help")
{
string settingHelp = msgMatch.Groups[2].Value.ToLower();
if (settingHelp.Length == 0)
{
help(p);
return;
}
foreach (Cmd Command in Cmd.all.list())
{
foreach (CmdSetting Setting in Command.settings)
{
if (Setting.SettingsId.ToLower() == settingHelp.ToLower())
{
MessageUtilities.sendMessage(p, $"{GeneralUtilities.formatCmd($"!settings {Setting.SettingsId} {Setting.UsageParameters}")}");
MessageUtilities.sendMessage(p, Setting.HelpLong);
return;
}
}
}
MessageUtilities.sendMessage(p, $"Could not find setting by the name of `{msgMatch.Groups[2].Value}`");
}
else if (setting == "mod")
{
UIExInputGeneric <string> inputBox = UIExInputGeneric <string> .current_;
string settingHelp = msgMatch.Groups[2].Value.ToLower();
if (settingHelp.Length == 0)
{
help(p);
return;
}
foreach (Cmd Command in Cmd.all.list())
{
foreach (CmdSetting Setting in Command.settings)
{
if (Setting.SettingsId.ToLower() == settingHelp.ToLower())
{
MessageUtilities.sendMessage(p, $"Editing settings {Setting.SettingsId}");
inputBox.Value_ = $"!settings {Setting.SettingsId} {Setting.ValueTypeless}";
PrivateUtilities.callPrivateMethod(inputBox, "StartEdit");
return;
}
}
}
MessageUtilities.sendMessage(p, $"Could not find setting by the name of `{msgMatch.Groups[2].Value}`");
}
else if (setting == "reset")
{
string settingHelp = msgMatch.Groups[2].Value.ToLower();
if (settingHelp.Length == 0)
{
help(p);
return;
}
foreach (Cmd Command in Cmd.all.list())
{
foreach (CmdSetting Setting in Command.settings)
{
if (Setting.SettingsId.ToLower() == settingHelp.ToLower())
{
Setting.ValueTypeless = Setting.DefaultTypeless;
MessageUtilities.sendMessage(p, $"Setting {Setting.SettingsId} reset to default:");
MessageUtilities.sendMessage(p, $"{Setting.DefaultTypeless}");
Entry.save();
return;
}
}
}
MessageUtilities.sendMessage(p, $"Could not find setting by the name of `{msgMatch.Groups[2].Value}`");
}
else if (setting == "default")
{
string settingHelp = msgMatch.Groups[2].Value.ToLower();
if (settingHelp.Length == 0)
{
help(p);
return;
}
foreach (Cmd Command in Cmd.all.list())
{
foreach (CmdSetting Setting in Command.settings)
{
if (Setting.SettingsId.ToLower() == settingHelp.ToLower())
{
MessageUtilities.sendMessage(p, $"{Setting.SettingsId} default:");
MessageUtilities.sendMessage(p, $"{Setting.DefaultTypeless}");
return;
}
}
}
MessageUtilities.sendMessage(p, $"Could not find setting by the name of `{msgMatch.Groups[2].Value}`");
}
else
{
foreach (Cmd Command in Cmd.all.list())
{
foreach (CmdSetting Setting in Command.settings)
{
if (Setting.SettingsId.ToLower() == setting.ToLower())
{
UpdateResult result = Setting.UpdateFromStringTypeless(msgMatch.Groups[2].Value);
if (!result.Valid)
{
MessageUtilities.sendMessage(p, $"Failed to set setting: {result.Message}");
}
else
{
MessageUtilities.sendMessage(p, $"Set {Setting.SettingsId} successfully.");
if (result.Message != "")
{
MessageUtilities.sendMessage(p, result.Message);
}
}
Setting.ValueTypeless = result.NewValueTypeless;
Entry.save();
return;
}
}
}
MessageUtilities.sendMessage(p, $"Could not find setting by the name of `{msgMatch.Groups[1].Value}`");
return;
}
}
else
{
Match baseMatch = Regex.Match(message, baseRegex);
if (baseMatch.Success)
{
string setting = baseMatch.Groups[1].Value.ToLower();
if (setting == "reload")
{
reload(p);
return;
}
else if (setting == "summary")
{
foreach (Cmd Command in Cmd.all.list())
{
string txt = "";
foreach (CmdSetting Setting in Command.settings)
{
if (Setting.SettingsId != "")
{
txt += $"\n {GeneralUtilities.formatCmd($"{Setting.SettingsId}")}: {Setting.ValueTypeless}";
}
}
if (txt != "")
{
MessageUtilities.sendMessage(p, $"[b][D00000]!{Command.name} Settings[-][/b]{txt}");
}
}
return;
}
else if (setting == "defaults")
{
foreach (Cmd Command in Cmd.all.list())
{
string txt = "";
foreach (CmdSetting Setting in Command.settings)
{
if (Setting.SettingsId != "")
{
txt += $"\n {GeneralUtilities.formatCmd($"{Setting.SettingsId}")}: {Setting.DefaultTypeless}";
}
}
if (txt != "")
{
MessageUtilities.sendMessage(p, $"[b][D00000]!{Command.name} Default Settings[-][/b]{txt}");
}
}
return;
}
else
{
foreach (Cmd Command in Cmd.all.list())
{
foreach (CmdSetting Setting in Command.settings)
{
if (Setting.SettingsId.ToLower() == setting.ToLower())
{
MessageUtilities.sendMessage(p, $"Value of {Setting.SettingsId}: {Setting.ValueTypeless}");
return;
}
}
}
}
}
}
help(p);
}
public void Initialize(IManager manager, string ipcIdentifier)
{
IPCIdentifier = ipcIdentifier;
if (Instance != null)
{
Console.WriteLine("Attempt to create a second Entry");
throw new Exception("There should only be one Entry");
}
Instance = this;
GeneralUtilities.logExceptions(() =>
{
var levelFilters = new LevelFilter[]
{
new LevelFilterAll(),
new LevelFilterAuthor(),
new LevelFilterCreated(),
new LevelFilterDifficulty(),
new LevelFilterIndex(),
new LevelFilterIsNew(),
new LevelFilterIsUpdated(),
new LevelFilterLast(),
new LevelFilterMode(),
new LevelFilterName(),
new LevelFilterPage(),
new LevelFilterPlaylist(),
new LevelFilterRegex(),
new LevelFilterSaved(),
new LevelFilterStars(),
new LevelFilterTime(),
new LevelFilterUpdated(),
new LevelSortFilterAuthor(),
new LevelSortFilterCreated(),
new LevelSortFilterDifficulty(),
new LevelSortFilterIndex(),
new LevelSortFilterMode(),
new LevelSortFilterName(),
new LevelSortFilterShuffle(),
new LevelSortFilterStars(),
new LevelSortFilterTime(),
new LevelSortFilterUpdated()
};
foreach (var filter in levelFilters)
{
FilteredPlaylist.AddFilterType(filter);
}
});
load(); // load existing data
save(); // save defaults that were not loaded
// player data list stuff
Events.Player.AddRemovePlayerData.Subscribe((data) =>
{
if (data.added_)
{
playerInfos.Add(new PlayerInfo(data.player_));
}
else
{
playerInfos.RemoveAll((info) => info.playerData == data.player_);
}
});
// chat stuff
Events.Local.ChatSubmitMessage.Subscribe(data =>
{
GeneralUtilities.logExceptions(() =>
{
Chat_MessageSent(data);
});
});
var sendingClientToAllClientsMessage = false;
AddMessage.Subscribe(data =>
{
if (!sendingClientToAllClientsMessage &&
(MessageUtilities.currentState == null || !MessageUtilities.currentState.forPlayer))
{
chatReplicationManager.AddPublic(data.message_);
}
});
ChatMessage.Subscribe(data =>
{
GeneralUtilities.logExceptions(() =>
{
sendingClientToAllClientsMessage = true;
var author = MessageUtilities.ExtractMessageAuthor(data.message_);
if (!MessageUtilities.IsSystemMessage(data.message_) && !sendingLocalChat && !string.IsNullOrEmpty(author))
{
Chat_MessageReceived(author, MessageUtilities.ExtractMessageBody(data.message_), data);
}
else
{
addMessageFromRemote(data);
chatReplicationManager.AddPublic(data.message_);
}
sendingLocalChat = false;
sendingClientToAllClientsMessage = false;
});
});
Events.Network.ServerInitialized.Subscribe(data =>
{
chatReplicationManager.Clear();
G.Sys.GameManager_.StartCoroutine(serverInit());
});
replicateLocalChatFunc = PrivateUtilities.removeParticularSubscriber <ChatSubmitMessage.Data>(PrivateUtilities.getComponent <ClientLogic>());
addMessageFromRemote = PrivateUtilities.removeParticularSubscriber <ChatMessage.Data>(G.Sys.NetworkingManager_);
chatReplicationManager = new ChatReplicationManager();
chatReplicationManager.Setup();
Events.Game.LevelLoaded.Subscribe(data =>
{
UnstuckCmd.PatchLoadSequence();
});
}
