mirror/quantum-space-buddies
1
0
Fork 0
mirror of https://github.com/misternebula/quantum-space-buddies.git synced 2025-01-26 18:35:34 +00:00
Code Issues Projects Releases Wiki Activity

shit

Browse Source
This commit is contained in:
Mister_Nebula 2021-01-26 23:41:53 +00:00
parent ad5757e48c
commit 6c2a7c2b68
6 changed files with 159 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
QSB/QuantumSync/Events/MultiStateChangeEvent.cs
View File

@ -1,5 +1,6 @@
using QSB.Events; using QSB.Events;
using QSB.QuantumSync.WorldObjects; using QSB.QuantumSync.WorldObjects;
using QSB.Utility;
using QSB.WorldSync; using QSB.WorldSync;
namespace QSB.QuantumSync.Events namespace QSB.QuantumSync.Events
@ -37,6 +38,7 @@ namespace QSB.QuantumSync.Events
return; return;
} }
var qsbObj = QSBWorldSync.GetWorldObject<QSBMultiStateQuantumObject>(message.ObjectId); var qsbObj = QSBWorldSync.GetWorldObject<QSBMultiStateQuantumObject>(message.ObjectId);
DebugLog.DebugWrite($"{qsbObj.AttachedObject.name} to state {message.StateIndex}");
qsbObj.ChangeState(message.StateIndex); qsbObj.ChangeState(message.StateIndex);
} }
} }

8
QSB/QuantumSync/Events/QuantumAuthorityEvent.cs
View File

@ -23,18 +23,18 @@ namespace QSB.QuantumSync.Events
public override void OnReceiveLocal(bool server, QuantumAuthorityMessage message) public override void OnReceiveLocal(bool server, QuantumAuthorityMessage message)
{ {
DebugLog.DebugWrite($"Local set {message.ObjectId} to owner {message.AuthorityOwner}");
var objects = QSBWorldSync.GetWorldObjects<IQSBQuantumObject>(); var objects = QSBWorldSync.GetWorldObjects<IQSBQuantumObject>();
var obj = objects.First(x => (x as IWorldObject).ObjectId == message.ObjectId); var obj = objects.ToList()[message.ObjectId];
obj.ControllingPlayer = message.AuthorityOwner; obj.ControllingPlayer = message.AuthorityOwner;
DebugLog.DebugWrite($"Local set (message:{message.ObjectId}) (obj:{(obj as IWorldObject).ObjectId}) to (message:{message.AuthorityOwner}) (obj:{obj.ControllingPlayer})");
} }
public override void OnReceiveRemote(bool server, QuantumAuthorityMessage message) public override void OnReceiveRemote(bool server, QuantumAuthorityMessage message)
{ {
var objects = QSBWorldSync.GetWorldObjects<IQSBQuantumObject>(); var objects = QSBWorldSync.GetWorldObjects<IQSBQuantumObject>();
var obj = objects.First(x => (x as IWorldObject).ObjectId == message.ObjectId); var obj = objects.ToList()[message.ObjectId];
obj.ControllingPlayer = message.AuthorityOwner; obj.ControllingPlayer = message.AuthorityOwner;
DebugLog.DebugWrite($"Set {message.ObjectId} to owner {message.AuthorityOwner}"); DebugLog.DebugWrite($"Set (message:{message.ObjectId}) (obj:{(obj as IWorldObject).ObjectId}) to (message:{message.AuthorityOwner}) (obj:{obj.ControllingPlayer})");
} }
} }
} }

9
QSB/QuantumSync/Patches/ClientQuantumPatches.cs
View File

@ -6,14 +6,7 @@ namespace QSB.QuantumSync.Patches
{ {
public override QSBPatchTypes Type => QSBPatchTypes.OnNonServerClientConnect; public override QSBPatchTypes Type => QSBPatchTypes.OnNonServerClientConnect;
public override void DoPatches() public override void DoPatches() => QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumMoon>("ChangeQuantumState", typeof(ClientQuantumPatches), nameof(ReturnFalsePatch));
{
QSBCore.Helper.HarmonyHelper.AddPrefix<SocketedQuantumObject>("ChangeQuantumState", typeof(ClientQuantumPatches), nameof(ReturnFalsePatch));
QSBCore.Helper.HarmonyHelper.AddPrefix<MultiStateQuantumObject>("ChangeQuantumState", typeof(ClientQuantumPatches), nameof(ReturnFalsePatch));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumShuffleObject>("ChangeQuantumState", typeof(ClientQuantumPatches), nameof(ReturnFalsePatch));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumMoon>("ChangeQuantumState", typeof(ClientQuantumPatches), nameof(ReturnFalsePatch));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumShrine>("ChangeQuantumState", typeof(ClientQuantumPatches), nameof(ReturnFalsePatch));
}
public static bool ReturnFalsePatch() => false; public static bool ReturnFalsePatch() => false;
} }

142
QSB/QuantumSync/Patches/QuantumPatches.cs
View File

@ -1,5 +1,12 @@
using QSB.Events; using QSB.Events;
using QSB.Patches; using QSB.Patches;
using QSB.Player;
using QSB.QuantumSync.WorldObjects;
using QSB.Utility;
using QSB.WorldSync;
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine; using UnityEngine;
namespace QSB.QuantumSync.Patches namespace QSB.QuantumSync.Patches
@ -10,10 +17,145 @@ namespace QSB.QuantumSync.Patches
public override void DoPatches() public override void DoPatches()
{ {
QSBCore.Helper.HarmonyHelper.AddPrefix<SocketedQuantumObject>("ChangeQuantumState", typeof(QuantumPatches), nameof(Socketed_ChangeQuantumState));
QSBCore.Helper.HarmonyHelper.AddPostfix<SocketedQuantumObject>("MoveToSocket", typeof(QuantumPatches), nameof(Socketed_MoveToSocket));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumShuffleObject>("ChangeQuantumState", typeof(QuantumPatches), nameof(Shuffle_ChangeQuantumState));
QSBCore.Helper.HarmonyHelper.AddPrefix<MultiStateQuantumObject>("ChangeQuantumState", typeof(QuantumPatches), nameof(MultiState_ChangeQuantumState));
QSBCore.Helper.HarmonyHelper.AddPostfix<QuantumState>("SetVisible", typeof(QuantumPatches), nameof(QuantumState_SetVisible));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumShrine>("IsPlayerInDarkness", typeof(QuantumPatches), nameof(Shrine_IsPlayerInDarkness));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumShrine>("ChangeQuantumState", typeof(QuantumPatches), nameof(Shrine_ChangeQuantumState));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumShrine>("OnEntry", typeof(QuantumPatches), nameof(Shrine_OnEntry)); QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumShrine>("OnEntry", typeof(QuantumPatches), nameof(Shrine_OnEntry));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumShrine>("OnExit", typeof(QuantumPatches), nameof(Shrine_OnExit)); QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumShrine>("OnExit", typeof(QuantumPatches), nameof(Shrine_OnExit));
} }
public static bool Socketed_ChangeQuantumState(SocketedQuantumObject __instance)
=> QSBWorldSync.GetWorldObject<QSBSocketedQuantumObject>(QuantumManager.Instance.GetId(__instance)).ControllingPlayer == QSBPlayerManager.LocalPlayerId;
public static void Socketed_MoveToSocket(SocketedQuantumObject __instance, QuantumSocket socket)
{
var id = QuantumManager.Instance.GetId(__instance);
var worldObject = QSBWorldSync.GetWorldObject<QSBSocketedQuantumObject>(id);
if (worldObject == null)
{
DebugLog.DebugWrite($"Worldobject is null for id {id}!");
return;
}
if (worldObject.ControllingPlayer != QSBPlayerManager.LocalPlayerId)
{
return;
}
var objId = QuantumManager.Instance.GetId(__instance);
var socketId = QuantumManager.Instance.GetId(socket);
DebugLog.DebugWrite($"{__instance.name} to socket {socketId}");
GlobalMessenger<int, int, Quaternion>
.FireEvent(
EventNames.QSBSocketStateChange,
objId,
socketId,
__instance.transform.localRotation);
}
public static bool Shuffle_ChangeQuantumState(
QuantumShuffleObject __instance,
ref List<int> ____indexList,
ref Vector3[] ____localPositions,
ref Transform[] ____shuffledObjects,
ref bool __result)
{
if (QSBWorldSync.GetWorldObject<QSBQuantumShuffleObject>(QuantumManager.Instance.GetId(__instance)).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]];
}
DebugLog.DebugWrite($"{__instance.name} shuffled.");
GlobalMessenger<int, int[]>
.FireEvent(
EventNames.QSBQuantumShuffle,
QuantumManager.Instance.GetId(__instance),
____indexList.ToArray());
__result = true;
return false;
}
public static bool MultiState_ChangeQuantumState(MultiStateQuantumObject __instance)
{
var qsbObj = QSBWorldSync.GetWorldObject<QSBMultiStateQuantumObject>(QuantumManager.Instance.GetId(__instance));
var isInControl = qsbObj.ControllingPlayer == QSBPlayerManager.LocalPlayerId;
DebugLog.DebugWrite($"Multistate (instance:{__instance.name}) (obj:{qsbObj.AttachedObject.name}) change state - in control:{isInControl} ({qsbObj.ControllingPlayer} vs {QSBPlayerManager.LocalPlayerId})");
return isInControl;
}
public static void QuantumState_SetVisible(QuantumState __instance, bool visible)
{
if (!visible)
{
return;
}
var allMultiStates = QSBWorldSync.GetWorldObjects<QSBMultiStateQuantumObject>();
var owner = allMultiStates.First(x => x.QuantumStates.Contains(__instance));
DebugLog.DebugWrite($"{owner.AttachedObject.name} controller is {owner.ControllingPlayer}");
if (owner.ControllingPlayer != QSBPlayerManager.LocalPlayerId)
{
return;
}
DebugLog.DebugWrite($"{owner.AttachedObject.name} to quantum state {Array.IndexOf(owner.QuantumStates, __instance)}");
GlobalMessenger<int, int>
.FireEvent(
EventNames.QSBMultiStateChange,
QuantumManager.Instance.GetId(owner.AttachedObject),
Array.IndexOf(owner.QuantumStates, __instance));
}
public static bool Shrine_IsPlayerInDarkness(ref bool __result, Light[] ____lamps, float ____fadeFraction, bool ____isProbeInside, NomaiGateway ____gate)
{
foreach (var lamp in ____lamps)
{
if (lamp.intensity > 0f)
{
__result = false;
return false;
}
}
var playersInMoon = QSBPlayerManager.PlayerList.Where(x => x.IsInMoon);
if (playersInMoon.Any(x => !x.IsInShrine)
|| playersInMoon.Any(x => x.FlashLight != null && x.FlashLight.FlashlightOn)
|| (QSBPlayerManager.LocalPlayer.IsInShrine && PlayerState.IsFlashlightOn()))
{
__result = false;
return false;
}
// TODO : make this *really* check for all players - check other probes and other jetpacks!
__result = ____gate.GetOpenFraction() == 0f
&& !____isProbeInside
&& Locator.GetThrusterLightTracker().GetLightRange() <= 0f;
return false;
}
public static bool Shrine_ChangeQuantumState(QuantumShrine __instance)
{
var isInControl = QSBWorldSync.GetWorldObject<QSBSocketedQuantumObject>(QuantumManager.Instance.GetId(__instance)).ControllingPlayer == QSBPlayerManager.LocalPlayerId;
DebugLog.DebugWrite($"Shrine change state - in control? {isInControl}");
return isInControl;
}
public static bool Shrine_OnEntry( public static bool Shrine_OnEntry(
GameObject hitObj, GameObject hitObj,
ref bool ____isPlayerInside, ref bool ____isPlayerInside,

91
QSB/QuantumSync/Patches/ServerQuantumPatches.cs
View File

@ -2,11 +2,7 @@
using QSB.Events; using QSB.Events;
using QSB.Patches; using QSB.Patches;
using QSB.Player; using QSB.Player;
using QSB.QuantumSync.WorldObjects;
using QSB.Utility; using QSB.Utility;
using QSB.WorldSync;
using System;
using System.Collections.Generic;
using System.Diagnostics; using System.Diagnostics;
using System.Linq; using System.Linq;
using System.Reflection; using System.Reflection;
@ -20,69 +16,8 @@ namespace QSB.QuantumSync.Patches
public override void DoPatches() public override void DoPatches()
{ {
QSBCore.Helper.HarmonyHelper.AddPostfix<SocketedQuantumObject>("MoveToSocket", typeof(ServerQuantumPatches), nameof(Socketed_MoveToSocket));
QSBCore.Helper.HarmonyHelper.AddPostfix<QuantumState>("SetVisible", typeof(ServerQuantumPatches), nameof(QuantumState_SetVisible));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumShuffleObject>("ChangeQuantumState", typeof(ServerQuantumPatches), nameof(Shuffle_ChangeQuantumState));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumMoon>("ChangeQuantumState", typeof(ServerQuantumPatches), nameof(Moon_ChangeQuantumState)); QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumMoon>("ChangeQuantumState", typeof(ServerQuantumPatches), nameof(Moon_ChangeQuantumState));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumMoon>("CheckPlayerFogProximity", typeof(ServerQuantumPatches), nameof(Moon_CheckPlayerFogProximity)); QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumMoon>("CheckPlayerFogProximity", typeof(ServerQuantumPatches), nameof(Moon_CheckPlayerFogProximity));
QSBCore.Helper.HarmonyHelper.AddPrefix<QuantumShrine>("IsPlayerInDarkness", typeof(ServerQuantumPatches), nameof(Shrine_IsPlayerInDarkness));
}
public static void Socketed_MoveToSocket(SocketedQuantumObject __instance, QuantumSocket socket)
{
var objId = QuantumManager.Instance.GetId(__instance);
var socketId = QuantumManager.Instance.GetId(socket);
GlobalMessenger<int, int, Quaternion>
.FireEvent(
EventNames.QSBSocketStateChange,
objId,
socketId,
__instance.transform.localRotation);
}
public static void QuantumState_SetVisible(QuantumState __instance, bool visible)
{
if (!visible)
{
return;
}
var allMultiStates = QSBWorldSync.GetWorldObjects<QSBMultiStateQuantumObject>();
var owner = allMultiStates.First(x => x.QuantumStates.Contains(__instance));
DebugLog.DebugWrite($"{owner.AttachedObject.name} to state {Array.IndexOf(owner.QuantumStates, __instance)}");
GlobalMessenger<int, int>
.FireEvent(
EventNames.QSBMultiStateChange,
QuantumManager.Instance.GetId(owner.AttachedObject),
Array.IndexOf(owner.QuantumStates, __instance));
}
public static bool Shuffle_ChangeQuantumState(
QuantumShuffleObject __instance,
ref List<int> ____indexList,
ref Vector3[] ____localPositions,
ref Transform[] ____shuffledObjects,
ref bool __result)
{
____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]];
}
GlobalMessenger<int, int[]>
.FireEvent(
EventNames.QSBQuantumShuffle,
QuantumManager.Instance.GetId(__instance),
____indexList.ToArray());
__result = true;
return false;
} }
public static bool Moon_ChangeQuantumState( public static bool Moon_ChangeQuantumState(
@ -313,31 +248,5 @@ namespace QSB.QuantumSync.Patches
____shipLandingCamFogBubble.SetFogAlpha(fogAlpha); ____shipLandingCamFogBubble.SetFogAlpha(fogAlpha);
return false; return false;
} }
public static bool Shrine_IsPlayerInDarkness(ref bool __result, Light[] ____lamps, float ____fadeFraction, bool ____isProbeInside, NomaiGateway ____gate)
{
foreach (var lamp in ____lamps)
{
if (lamp.intensity > 0f)
{
__result = false;
return false;
}
}
var playersInMoon = QSBPlayerManager.PlayerList.Where(x => x.IsInMoon);
if (playersInMoon.Any(x => !x.IsInShrine)
|| playersInMoon.Any(x => x.FlashLight != null && x.FlashLight.FlashlightOn)
|| (QSBPlayerManager.LocalPlayer.IsInShrine && PlayerState.IsFlashlightOn()))
{
__result = false;
return false;
}
// TODO : make this *really* check for all players - check other probes and other jetpacks!
__result = ____gate.GetOpenFraction() == 0f
&& !____isProbeInside
&& Locator.GetThrusterLightTracker().GetLightRange() <= 0f;
return false;
}
} }
} }

15
QSB/QuantumSync/WorldObjects/QSBQuantumObject.cs
View File

@ -2,6 +2,7 @@
using QSB.Player; using QSB.Player;
using QSB.Utility; using QSB.Utility;
using QSB.WorldSync; using QSB.WorldSync;
using System.Linq;
using UnityEngine; using UnityEngine;
namespace QSB.QuantumSync.WorldObjects namespace QSB.QuantumSync.WorldObjects
@ -20,13 +21,15 @@ namespace QSB.QuantumSync.WorldObjects
private void OnEnable() private void OnEnable()
{ {
if (ControllingPlayer != 0 && !QSBCore.IsServer) if (ControllingPlayer != 0)
{ {
// controlled by another player, dont care that we activate it (unless we're the server!) // controlled by another player, dont care that we activate it
return; return;
} }
// no one is controlling this object right now (or we're the server, and we want to take ownership), request authority var id = QSBWorldSync.GetWorldObjects<IQSBQuantumObject>().ToList().IndexOf(this);
GlobalMessenger<int, uint>.FireEvent(EventNames.QSBQuantumAuthority, ObjectId, QSBPlayerManager.LocalPlayerId); DebugLog.DebugWrite($"ON ENABLE {(this as WorldObject<T>).AttachedObject.name} ({id})");
// no one is controlling this object right now, request authority
GlobalMessenger<int, uint>.FireEvent(EventNames.QSBQuantumAuthority, id, QSBPlayerManager.LocalPlayerId);
} }
private void OnDisable() private void OnDisable()
@ -36,8 +39,10 @@ namespace QSB.QuantumSync.WorldObjects
// not being controlled by us, don't care if we leave area // not being controlled by us, don't care if we leave area
return; return;
} }
var id = QSBWorldSync.GetWorldObjects<IQSBQuantumObject>().ToList().IndexOf(this);
DebugLog.DebugWrite($"ON DISABLE {(this as WorldObject<T>).AttachedObject.name} ({id})");
// send event to other players that we're releasing authority // send event to other players that we're releasing authority
GlobalMessenger<int, uint>.FireEvent(EventNames.QSBQuantumAuthority, ObjectId, 0); GlobalMessenger<int, uint>.FireEvent(EventNames.QSBQuantumAuthority, id, 0);
} }
} }
} }