public static bool MultiState_Start(MultiStateQuantumObject __instance, Sector ____sector, bool ____collapseOnStart) { var qsbObj = QSBWorldSync.GetWorldFromUnity <QSBMultiStateQuantumObject, MultiStateQuantumObject>(__instance); if (qsbObj.ControllingPlayer == 0) { return(true); } foreach (var state in qsbObj.QuantumStates) { if (!state.IsMeantToBeEnabled) { state.SetVisible(false); } } if (____sector == null) { __instance.GetType().GetMethod("CheckEnabled", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, null); } if (____collapseOnStart) { __instance.GetType().GetMethod("Collapse", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { true }); } return(false); }
public static bool Shrine_ChangeQuantumState(QuantumShrine __instance) { var shrineWorldObject = QSBWorldSync.GetWorldFromUnity <QSBSocketedQuantumObject, SocketedQuantumObject>(__instance); var isInControl = shrineWorldObject.ControllingPlayer == QSBPlayerManager.LocalPlayerId; return(isInControl); }
public static void Socketed_MoveToSocket(SocketedQuantumObject __instance, QuantumSocket socket) { if (socket == null) { DebugLog.ToConsole($"Error - Trying to move {__instance.name} to a null socket!", MessageType.Error); return; } var objectWorldObject = QSBWorldSync.GetWorldFromUnity <QSBSocketedQuantumObject, SocketedQuantumObject>(__instance); var socketWorldObject = QSBWorldSync.GetWorldFromUnity <QSBQuantumSocket, QuantumSocket>(socket); if (objectWorldObject == null) { DebugLog.ToConsole($"Worldobject is null for {__instance.name}!"); return; } if (objectWorldObject.ControllingPlayer != QSBPlayerManager.LocalPlayerId) { return; } QSBEventManager.FireEvent( EventNames.QSBSocketStateChange, objectWorldObject.ObjectId, socketWorldObject.ObjectId, __instance.transform.localRotation); }
public static bool Shuffle_ChangeQuantumState( QuantumShuffleObject __instance, ref List <int> ____indexList, ref Vector3[] ____localPositions, ref Transform[] ____shuffledObjects, ref bool __result) { var shuffleWorldObject = QSBWorldSync.GetWorldFromUnity <QSBQuantumShuffleObject, QuantumShuffleObject>(__instance); if (shuffleWorldObject.ControllingPlayer != QSBPlayerManager.LocalPlayerId) { return(false); } ____indexList.Clear(); ____indexList = Enumerable.Range(0, ____localPositions.Length).ToList(); for (var i = 0; i < ____indexList.Count; ++i) { var random = UnityEngine.Random.Range(i, ____indexList.Count); var temp = ____indexList[i]; ____indexList[i] = ____indexList[random]; ____indexList[random] = temp; } for (var j = 0; j < ____shuffledObjects.Length; j++) { ____shuffledObjects[j].localPosition = ____localPositions[____indexList[j]]; } QSBEventManager.FireEvent( EventNames.QSBQuantumShuffle, shuffleWorldObject.ObjectId, ____indexList.ToArray()); __result = true; return(false); }
public override void OnReceiveLocal() { if (QSBCore.IsHost) { QSBWorldSync.SetDialogueCondition(ConditionName, ConditionState); } }
public override void OnReceiveRemote() { var controller = QSBWorldSync.GetUnityObjects <PlayerCloneController>().First(); controller._warpFlickerActivated = true; controller._warpTime = Time.time + 0.5f; }
public override void OnReceiveRemote() { if (QSBCore.IsHost) { QSBWorldSync.SetDialogueCondition(ConditionName, ConditionState); } var sharedInstance = DialogueConditionManager.SharedInstance; var flag = true; if (sharedInstance.ConditionExists(ConditionName)) { if (sharedInstance._dictConditions[ConditionName] == ConditionState) { flag = false; } sharedInstance._dictConditions[ConditionName] = ConditionState; } else { sharedInstance.AddCondition(ConditionName, ConditionState); } if (flag) { GlobalMessenger <string, bool> .FireEvent("DialogueConditionChanged", ConditionName, ConditionState); } if (ConditionName == "LAUNCH_CODES_GIVEN") { PlayerData.LearnLaunchCodes(); } }
public override void OnReceiveLocal(bool server, RevealFactMessage message) { if (server) { QSBWorldSync.AddFactReveal(message.FactId, message.SaveGame, message.ShowNotification); } }
private void OnDisable(Shape s) { if (!IsEnabled) { return; } if (GetAttachedShapes().Any(x => x.gameObject.activeInHierarchy)) { return; } IsEnabled = false; if (!QSBCore.HasWokenUp && !QSBCore.IsServer) { return; } if (ControllingPlayer != QSBPlayerManager.LocalPlayerId) { // not being controlled by us, don't care if we leave area return; } var id = QSBWorldSync.GetIdFromTypeSubset <IQSBQuantumObject>(this); // send event to other players that we're releasing authority QSBEventManager.FireEvent(EventNames.QSBQuantumAuthority, id, 0u); }
public override void OnReceiveLocal(bool server, DialogueConditionMessage message) { if (server) { QSBWorldSync.SetDialogueCondition(message.ConditionName, message.ConditionState); } }
public override void OnStopClient() // Called on the client when closing connection { DebugLog.DebugWrite("OnStopClient", MessageType.Info); DebugLog.ToConsole("Disconnecting from server...", MessageType.Info); Destroy(GetComponent <RespawnOnDeath>()); Destroy(GetComponent <ServerStateManager>()); Destroy(GetComponent <ClientStateManager>()); QSBPlayerManager.PlayerList.ForEach(player => player.HudMarker?.Remove()); QSBWorldSync.RemoveWorldObjects(); if (WakeUpSync.LocalInstance != null) { WakeUpSync.LocalInstance.OnDisconnect(); } if (_everConnected) { var specificType = QSBCore.IsHost ? QSBPatchTypes.OnServerClientConnect : QSBPatchTypes.OnNonServerClientConnect; QSBPatchManager.DoUnpatchType(specificType); QSBPatchManager.DoUnpatchType(QSBPatchTypes.OnClientConnect); } _everConnected = false; }
public static void QuantumState_SetVisible(QuantumState __instance, bool visible) { if (!QSBWorldSync.AllObjectsReady) { return; } if (!visible) { return; } var allMultiStates = QSBWorldSync.GetWorldObjects <QSBMultiStateQuantumObject>(); var stateObject = __instance.GetWorldObject <QSBQuantumState>(); var owner = allMultiStates.FirstOrDefault(x => x.QuantumStates.Contains(stateObject)); if (owner == default) { DebugLog.ToConsole($"Error - Could not find QSBMultiStateQuantumObject for state {__instance.name}", MessageType.Error); return; } if (owner.ControllingPlayer != QSBPlayerManager.LocalPlayerId) { return; } var stateIndex = owner.QuantumStates.IndexOf(stateObject); owner.SendMessage(new MultiStateChangeMessage(stateIndex)); }
public override void OnReceiveRemote(bool server, SocketItemMessage message) { var socketWorldObject = QSBWorldSync.GetWorldFromId <IQSBOWItemSocket>(message.SocketId); var itemWorldObject = QSBWorldSync.GetWorldFromId <IQSBOWItem>(message.ItemId); switch (message.SocketType) { case SocketEventType.Socket: socketWorldObject.PlaceIntoSocket(itemWorldObject); return; case SocketEventType.StartUnsocket: if (!socketWorldObject.IsSocketOccupied()) { DebugLog.ToConsole($"Warning - Trying to start unsocket on socket that is unoccupied! Socket:{(socketWorldObject as IWorldObject).Name}"); return; } socketWorldObject.RemoveFromSocket(); return; case SocketEventType.CompleteUnsocket: itemWorldObject.OnCompleteUnsocket(); return; } }
public override void OnReceiveLocal() { if (QSBCore.IsHost) { QSBWorldSync.SetPersistentCondition(_conditionName, _conditionState); } }
public static bool ItemTool_StartUnsocketItem(OWItemSocket socket) { var socketId = QSBWorldSync.GetIdFromTypeSubset(ItemManager.GetObject(socket)); QSBEventManager.FireEvent(EventNames.QSBSocketItem, socketId, 0, SocketEventType.StartUnsocket); return(true); }
public static bool ItemTool_CompleteUnsocketItem(OWItem ____heldItem) { var itemId = QSBWorldSync.GetIdFromTypeSubset(ItemManager.GetObject(____heldItem)); QSBEventManager.FireEvent(EventNames.QSBSocketItem, 0, itemId, SocketEventType.CompleteUnsocket); return(true); }
public static IQSBQuantumObject GetObject(QuantumObject unityObject) { IQSBQuantumObject worldObj = null; if (unityObject.GetType() == typeof(SocketedQuantumObject) || unityObject.GetType() == typeof(QuantumShrine)) { worldObj = QSBWorldSync.GetWorldFromUnity <QSBSocketedQuantumObject, SocketedQuantumObject>((SocketedQuantumObject)unityObject); } else if (unityObject.GetType() == typeof(MultiStateQuantumObject)) { worldObj = QSBWorldSync.GetWorldFromUnity <QSBMultiStateQuantumObject, MultiStateQuantumObject>((MultiStateQuantumObject)unityObject); } else if (unityObject.GetType() == typeof(QuantumShuffleObject)) { worldObj = QSBWorldSync.GetWorldFromUnity <QSBQuantumShuffleObject, QuantumShuffleObject>((QuantumShuffleObject)unityObject); } else if (unityObject.GetType() == typeof(QuantumMoon)) { worldObj = QSBWorldSync.GetWorldFromUnity <QSBQuantumMoon, QuantumMoon>((QuantumMoon)unityObject); } else if (unityObject.GetType() == typeof(EyeProxyQuantumMoon)) { worldObj = QSBWorldSync.GetWorldFromUnity <QSBEyeProxyQuantumMoon, EyeProxyQuantumMoon>((EyeProxyQuantumMoon)unityObject); } else { DebugLog.ToConsole($"Warning - couldn't work out type of QuantumObject {unityObject.name}.", MessageType.Warning); } return(worldObj); }
public static bool ItemTool_MoveItemToCarrySocket(OWItem item) { var itemId = QSBWorldSync.GetIdFromTypeSubset(ItemManager.GetObject(item)); QSBEventManager.FireEvent(EventNames.QSBMoveToCarry, itemId); return(true); }
public override async UniTask BuildWorldObjects(OWScene scene, CancellationToken ct) { // wait for all late initializers (which includes nomai text) to finish await UniTask.WaitUntil(() => LateInitializerManager.isDoneInitializing, cancellationToken : ct); QSBWorldSync.Init <QSBNomaiText, NomaiText>(typeof(GhostWallText)); }
public static void StartLift(Elevator __instance) { var isGoingUp = __instance.GetValue <bool>("_goingToTheEnd"); var id = QSBWorldSync.GetIdFromUnity <QSBElevator, Elevator>(__instance); QSBEventManager.FireEvent(EventNames.QSBStartLift, id, isGoingUp); }
public override void OnClientConnect() // Called on the client when connecting to a server { DebugLog.DebugWrite("OnClientConnect", MessageType.Info); base.OnClientConnect(); OnClientConnected?.SafeInvoke(); QSBMessageManager.Init(); gameObject.AddComponent <RespawnOnDeath>(); gameObject.AddComponent <ServerStateManager>(); gameObject.AddComponent <ClientStateManager>(); if (QSBSceneManager.IsInUniverse) { QSBWorldSync.BuildWorldObjects(QSBSceneManager.CurrentScene).Forget(); } var specificType = QSBCore.IsHost ? QSBPatchTypes.OnServerClientConnect : QSBPatchTypes.OnNonServerClientConnect; QSBPatchManager.DoPatchType(specificType); QSBPatchManager.DoPatchType(QSBPatchTypes.OnClientConnect); Delay.RunWhen(() => PlayerTransformSync.LocalInstance, () => new PlayerJoinMessage(PlayerName).Send()); if (!QSBCore.IsHost) { Delay.RunWhen(() => PlayerTransformSync.LocalInstance, () => new RequestStateResyncMessage().Send()); } _everConnected = true; }
public override void OnReceiveRemote(bool server, SetAsTranslatedMessage message) { if (!QSBCore.HasWokenUp) { return; } if (message.EnumValue == NomaiTextType.WallText) { var obj = QSBWorldSync.GetWorldFromId <QSBWallText>(message.ObjectId); obj.HandleSetAsTranslated(message.TextId); } else if (message.EnumValue == NomaiTextType.Computer) { var obj = QSBWorldSync.GetWorldFromId <QSBComputer>(message.ObjectId); obj.HandleSetAsTranslated(message.TextId); } else if (message.EnumValue == NomaiTextType.VesselComputer) { var obj = QSBWorldSync.GetWorldFromId <QSBVesselComputer>(message.ObjectId); obj.HandleSetAsTranslated(message.TextId); } else { throw new System.NotImplementedException($"TextType <{message.EnumValue}> not implemented."); } }
public override void OnReceiveRemote() { if (QSBCore.IsHost) { QSBWorldSync.SetPersistentCondition(_conditionName, _conditionState); } var gameSave = PlayerData._currentGameSave; if (gameSave.dictConditions.ContainsKey(_conditionName)) { gameSave.dictConditions[_conditionName] = _conditionState; } else { gameSave.dictConditions.Add(_conditionName, _conditionState); } if (_conditionName is not "LAUNCH_CODES_GIVEN" and not "PLAYER_ENTERED_TIMELOOPCORE" and not "PROBE_ENTERED_TIMELOOPCORE" and not "PLAYER_ENTERED_TIMELOOPCORE_MULTIPLE") { PlayerData.SaveCurrentGame(); } }
private void Update() { if (!QSBCore.IsInMultiplayer) { return; } var controller = Locator.GetPlayerController(); if (controller == null) { return; } var collidingQuantumObject = controller.GetValue <QuantumObject>("_collidingQuantumObject"); if (_previousCollidingQuantumObject != collidingQuantumObject) { var objectIndex = (collidingQuantumObject != null) ? QSBWorldSync.GetIdFromTypeSubset(QuantumManager.GetObject(collidingQuantumObject)) : -1; QSBEventManager.FireEvent( EventNames.QSBPlayerEntangle, objectIndex); _previousCollidingQuantumObject = collidingQuantumObject; } }
public override void OnReceiveLocal() { if (QSBCore.IsHost) { QSBWorldSync.AddFactReveal(FactId, SaveGame); } }
public override void OnReceiveRemote(bool server, WorldObjectMessage message) { var player = QSBPlayerManager.GetPlayer(message.AboutId); var itemObject = QSBWorldSync.GetWorldFromId <IQSBOWItem>(message.ObjectId); var itemType = itemObject.GetItemType(); Transform itemSocket = null; switch (itemType) { case ItemType.Scroll: itemSocket = player.ScrollSocket; break; case ItemType.SharedStone: itemSocket = player.SharedStoneSocket; break; case ItemType.WarpCore: itemSocket = ((QSBWarpCoreItem)itemObject).IsVesselCoreType() ? player.VesselCoreSocket : player.WarpCoreSocket; break; default: itemSocket = player.ItemSocket; break; } itemObject.PickUpItem(itemSocket, message.AboutId); }
public QSBSector GetClosestSector(Transform trans) // trans rights \o/ { if (!QSBSectorManager.Instance.IsReady) { DebugLog.ToConsole($"Warning - Tried to get closest sector to {trans.name} before QSBSectorManager was ready.", MessageType.Warning); return(null); } var listToCheck = SectorList.Count(x => x.ShouldSyncTo()) == 0 ? QSBWorldSync.GetWorldObjects <QSBSector>() : SectorList; /* Explanation of working out which sector to sync to : * A) Closer sectors are best * B) Smaller sub-sectors are preferred * So, get all non-null sectors that aren't blacklisted and are active * (They need to be active otherwise it'll sync to disabled sectors, like the eye shuttle - which makes the player invisible) * Then, sort that list also by the radius of the sector. * We want smaller subsectors (e.g. Starting_Camp) to be preferred over general sectors (e.g. Village) * TL;DR : Sync to the smallest, closest sector */ var activeNotNullNotBlacklisted = listToCheck.Where(sector => sector.AttachedObject != null && sector.ShouldSyncTo()); if (activeNotNullNotBlacklisted.Count() == 0) { return(default);
public override void OnReceiveRemote(bool server, DialogueConditionMessage message) { if (server) { QSBWorldSync.SetDialogueCondition(message.ConditionName, message.ConditionState); } DialogueConditionManager.SharedInstance.SetConditionState(message.ConditionName, message.ConditionState); }
public override async UniTask BuildWorldObjects(OWScene scene, CancellationToken ct) { QSBWorldSync.Init <QSBCharacterAnimController, CharacterAnimController>(); QSBWorldSync.Init <QSBTravelerController, TravelerController>(); QSBWorldSync.Init <QSBSolanumController, NomaiConversationManager>(); QSBWorldSync.Init <QSBSolanumAnimController, SolanumAnimController>(); QSBWorldSync.Init <QSBHearthianRecorderEffects, HearthianRecorderEffects>(); QSBWorldSync.Init <QSBTravelerEyeController, TravelerEyeController>(); }
public override void OnReceiveLocal(bool server, MultiStateChangeMessage message) { if (!QSBCore.DebugMode) { return; } var qsbObj = QSBWorldSync.GetWorldFromId<QSBMultiStateQuantumObject>(message.ObjectId); qsbObj.DebugBoxText.text = message.StateIndex.ToString(); }