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 Shrine_ChangeQuantumState(QuantumShrine __instance) { var shrineWorldObject = QSBWorldSync.GetWorldFromUnity <QSBSocketedQuantumObject, SocketedQuantumObject>(__instance); var isInControl = shrineWorldObject.ControllingPlayer == QSBPlayerManager.LocalPlayerId; return(isInControl); }
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 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 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 override void Serialize(QNetworkWriter writer) { base.Serialize(writer); writer.Write(ObjectId); writer.Write(Position); writer.Write(Normal); var qsbSector = QSBWorldSync.GetWorldFromUnity <QSBSector, Sector>(Sector); writer.Write(qsbSector.ObjectId); }
private void Handler(Campfire campfire, bool roasting) { if (campfire == null) { SendEvent(CreateMessage(-1, roasting)); return; } var qsbObj = QSBWorldSync.GetWorldFromUnity <QSBCampfire, Campfire>(campfire); SendEvent(CreateMessage(qsbObj.ObjectId, roasting)); }
public static bool MultiState_ChangeQuantumState(MultiStateQuantumObject __instance) { var qsbObj = QSBWorldSync.GetWorldFromUnity <QSBMultiStateQuantumObject, MultiStateQuantumObject>(__instance); if (qsbObj.ControllingPlayer == 0 && qsbObj.CurrentState == -1) { return(true); } var isInControl = qsbObj.ControllingPlayer == QSBPlayerManager.LocalPlayerId; return(isInControl); }
public override void Init(T attachedObject, int id) { InitialParent = attachedObject.transform.parent; InitialPosition = attachedObject.transform.localPosition; InitialRotation = attachedObject.transform.localRotation; InitialSector = QSBWorldSync.GetWorldFromUnity <QSBSector, Sector>(attachedObject.GetSector()); if (InitialParent.GetComponent <OWItemSocket>() != null) { var qsbObj = ItemManager.GetObject(InitialParent.GetComponent <OWItemSocket>()); InitialSocket = qsbObj; } QSBPlayerManager.OnRemovePlayer += OnPlayerLeave; }
private void AddSector(Sector sector) { var worldObject = QSBWorldSync.GetWorldFromUnity <QSBSector, Sector>(sector); if (worldObject == null) { DebugLog.ToConsole($"Error - Can't find QSBSector for sector {sector.name}!", MessageType.Error); } if (SectorList.Contains(worldObject)) { DebugLog.ToConsole($"Warning - Trying to add {sector.name} for {gameObject.name}, but is already in list", MessageType.Warning); return; } SectorList.Add(worldObject); }
public static bool Campfire_OnPressInteract(Campfire __instance, Campfire.State ____state) { var qsbCampfire = QSBWorldSync.GetWorldFromUnity <QSBCampfire, Campfire>(__instance); if (____state == Campfire.State.LIT) { qsbCampfire.StartRoasting(); } else { qsbCampfire.SetState(Campfire.State.LIT); QSBEventManager.FireEvent(EventNames.QSBCampfireState, qsbCampfire.ObjectId, Campfire.State.LIT); Locator.GetFlashlight().TurnOff(false); } return(false); }
public static void QuantumState_SetVisible(QuantumState __instance, bool visible) { if (!visible) { return; } var allMultiStates = QSBWorldSync.GetWorldObjects <QSBMultiStateQuantumObject>(); var stateObject = QSBWorldSync.GetWorldFromUnity <QSBQuantumState, QuantumState>(__instance); var owner = allMultiStates.First(x => x.QuantumStates.Contains(stateObject)); if (owner.ControllingPlayer != QSBPlayerManager.LocalPlayerId) { return; } var stateIndex = owner.QuantumStates.IndexOf(stateObject); QSBEventManager.FireEvent( EventNames.QSBMultiStateChange, owner.ObjectId, stateIndex); }
public override void Init(MultiStateQuantumObject attachedObject, int id) { ObjectId = id; AttachedObject = attachedObject; QuantumStates = AttachedObject.GetValue <QuantumState[]>("_states").ToList().Select(x => QSBWorldSync.GetWorldFromUnity <QSBQuantumState, QuantumState>(x)).ToList(); if (QSBCore.DebugMode) { DebugBoxText = DebugBoxManager.CreateBox(AttachedObject.transform, 0, CurrentState.ToString()).GetComponent <Text>(); } base.Init(attachedObject, id); }
public static bool Socketed_ChangeQuantumState( SocketedQuantumObject __instance, ref bool __result, bool skipInstantVisibilityCheck, List <QuantumSocket> ____childSockets, List <QuantumSocket> ____socketList, ref QuantumSocket ____recentlyObscuredSocket, QuantumSocket ____occupiedSocket) { var socketedWorldObject = QSBWorldSync.GetWorldFromUnity <QSBSocketedQuantumObject, SocketedQuantumObject>(__instance); if (socketedWorldObject.ControllingPlayer != QSBPlayerManager.LocalPlayerId) { return(false); } foreach (var socket in ____childSockets) { if (socket.IsOccupied()) { __result = false; return(false); } } if (____socketList.Count <= 1) { DebugLog.ToConsole($"Error - Not enough quantum sockets in list for {__instance.name}!", MessageType.Error); __result = false; return(false); } var list = new List <QuantumSocket>(); foreach (var socket in ____socketList) { if (!socket.IsOccupied() && socket.IsActive()) { list.Add(socket); } } if (list.Count == 0) { __result = false; return(false); } if (____recentlyObscuredSocket != null) { __instance.GetType().GetMethod("MoveToSocket", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { ____recentlyObscuredSocket }); ____recentlyObscuredSocket = null; __result = true; return(false); } var occupiedSocket = ____occupiedSocket; for (var i = 0; i < 20; i++) { var index = UnityEngine.Random.Range(0, list.Count); __instance.GetType().GetMethod("MoveToSocket", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { list[index] }); if (skipInstantVisibilityCheck) { __result = true; return(false); } bool socketNotSuitable; var isSocketIlluminated = (bool)__instance.GetType().GetMethod("CheckIllumination", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, null); var playersEntangled = QuantumManager.GetEntangledPlayers(__instance); if (playersEntangled.Count() != 0) { // socket not suitable if illuminated socketNotSuitable = isSocketIlluminated; } else { var checkVisInstant = (bool)__instance.GetType().GetMethod("CheckVisibilityInstantly", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, null); if (isSocketIlluminated) { // socket not suitable if object is visible socketNotSuitable = checkVisInstant; } else { // socket not suitable if player is inside object socketNotSuitable = playersEntangled.Any(x => __instance.CheckPointInside(x.CameraBody.transform.position)); } } if (!socketNotSuitable) { __result = true; return(false); } list.RemoveAt(index); if (list.Count == 0) { break; } } __instance.GetType().GetMethod("MoveToSocket", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { occupiedSocket }); __result = false; return(false); }