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();
}
