mirror/quantum-space-buddies
1
0
Fork 0
mirror of https://github.com/misternebula/quantum-space-buddies.git synced 2025-02-04 03:39:55 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #254 from misternebula/statue-sync

Browse Source 
Statue sync - DRAFT
This commit is contained in:
_nebula 2021-03-01 09:52:57 +00:00 committed by GitHub
commit 109e28caeb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 225 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
QSB/Events/EventNames.cs
View File

@ -53,5 +53,6 @@
public static string QSBDropItem = "QSBDropItem";
public static string QSBSocketItem = "QSBSocketItem";
public static string QSBMoveToCarry = "QSBMoveToCarry";
public static string QSBStartStatue = "QSBStartStatue";
}
}

3
QSB/Events/EventType.cs
View File

@ -37,6 +37,7 @@
PlayerEntangle,
DropItem,
SocketItem,
MoveToCarry
MoveToCarry,
StartStatue
}
}

2
QSB/Events/QSBEventManager.cs
View File

@ -10,6 +10,7 @@ using QSB.LogSync.Events;
using QSB.OrbSync.Events;
using QSB.Player.Events;
using QSB.QuantumSync.Events;
using QSB.StatueSync.Events;
using QSB.TimeSync.Events;
using QSB.Tools.Events;
using QSB.TranslationSync.Events;
@ -60,6 +61,7 @@ namespace QSB.Events
new DropItemEvent(),
new SocketItemEvent(),
new MoveToCarryEvent(),
new StartStatueEvent(),
// Conversation/dialogue/exploration
new ConversationEvent(),
new ConversationStartEndEvent(),

2
QSB/OrbSync/Events/OrbUserEvent.cs
View File

@ -61,7 +61,7 @@ namespace QSB.OrbSync.Events
DebugLog.ToConsole("Error - FromPlayer is null!", MessageType.Error);
}
var orbSync = QSBWorldSync.OrbSyncList
.First(x => x.AttachedOrb == QSBWorldSync.OldOrbList[message.ObjectId]);
.FirstOrDefault(x => x.AttachedOrb == QSBWorldSync.OldOrbList[message.ObjectId]);
if (orbSync == null)
{
DebugLog.ToConsole($"Error - No orb found for user event. (ID {message.ObjectId})", MessageType.Error);

2
QSB/OrbSync/OrbManager.cs
View File

@ -17,8 +17,8 @@ namespace QSB.OrbSync
private void BuildOrbSlots()
{
QSBWorldSync.RemoveWorldObjects<QSBOrbSlot>();
QSBWorldSync.Init<QSBOrbSlot, NomaiInterfaceSlot>();
DebugLog.DebugWrite($"Finished slot build with {QSBWorldSync.GetWorldObjects<QSBOrbSlot>().Count()} slots.", MessageType.Success);
}
public void BuildOrbs()

4
QSB/Patches/QSBPatchManager.cs
View File

@ -7,6 +7,7 @@ using QSB.ItemSync.Patches;
using QSB.LogSync.Patches;
using QSB.OrbSync.Patches;
using QSB.QuantumSync.Patches;
using QSB.StatueSync.Patches;
using QSB.TimeSync.Patches;
using QSB.TranslationSync.Patches;
using QSB.Utility;
@ -39,7 +40,8 @@ namespace QSB.Patches
new FrequencyPatches(),
new SpiralPatches(),
new QuantumPatches(),
new ItemPatches()
new ItemPatches(),
new StatuePatches()
};
DebugLog.DebugWrite("Patch Manager ready.", MessageType.Success);

21
QSB/Player/QSBPlayerManager.cs
View File

@ -7,6 +7,7 @@ using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using UnityEngine;
namespace QSB.Player
{
@ -111,5 +112,25 @@ namespace QSB.Player
public static Tuple<Flashlight, IEnumerable<QSBFlashlight>> GetPlayerFlashlights()
=> new Tuple<Flashlight, IEnumerable<QSBFlashlight>>(Locator.GetFlashlight(), PlayerList.Where(x => x.FlashLight != null).Select(x => x.FlashLight));
public static void ShowAllPlayers()
=> PlayerList.Where(x => x != LocalPlayer).ToList().ForEach(x => ChangePlayerVisibility(x.PlayerId, true));
public static void HideAllPlayers()
=> PlayerList.Where(x => x != LocalPlayer).ToList().ForEach(x => ChangePlayerVisibility(x.PlayerId, false));
public static void ChangePlayerVisibility(uint playerId, bool visible)
{
var player = GetPlayer(playerId);
if (player.Body == null)
{
DebugLog.ToConsole($"Warning - Player {playerId} has a null body!", MessageType.Warning);
return;
}
foreach (var renderer in player.Body.GetComponentsInChildren<Renderer>())
{
renderer.enabled = visible;
}
}
}
}

4
QSB/QSB.csproj
View File

@ -198,6 +198,10 @@
<Compile Include="QuantumSync\QuantumManager.cs" />
<Compile Include="QuantumSync\Patches\QuantumVisibilityPatches.cs" />
<Compile Include="QuantumSync\Patches\ServerQuantumPatches.cs" />
<Compile Include="StatueSync\Events\StartStatueEvent.cs" />
<Compile Include="StatueSync\Events\StartStatueMessage.cs" />
<Compile Include="StatueSync\Patches\StatuePatches.cs" />
<Compile Include="StatueSync\StatueManager.cs" />
<Compile Include="TranslationSync\Events\SetAsTranslatedEvent.cs" />
<Compile Include="TranslationSync\Events\SetAsTranslatedMessage.cs" />
<Compile Include="TranslationSync\NomaiTextType.cs" />

2
QSB/QSBCore.cs
View File

@ -11,6 +11,7 @@ using QSB.Player;
using QSB.QuantumSync;
using QSB.QuantumSync.WorldObjects;
using QSB.SectorSync;
using QSB.StatueSync;
using QSB.TimeSync;
using QSB.TranslationSync;
using QSB.Utility;
@ -99,6 +100,7 @@ namespace QSB
gameObject.AddComponent<RepeatingManager>();
gameObject.AddComponent<PlayerEntanglementWatcher>();
gameObject.AddComponent<ItemManager>();
gameObject.AddComponent<StatueManager>();
DebugBoxManager.Init();

4
QSB/QuantumSync/Patches/QuantumVisibilityPatches.cs
View File

@ -31,10 +31,10 @@ namespace QSB.QuantumSync.Patches
QSBCore.Helper.HarmonyHelper.Unpatch<Shape>("OnDisable");
}
public static void Shape_OnEnable(Shape __instance)
public static void Shape_OnEnable(Shape __instance)
=> QSBWorldSync.RaiseEvent(__instance, "OnShapeActivated", __instance);
public static void Shape_OnDisable(Shape __instance)
public static void Shape_OnDisable(Shape __instance)
=> QSBWorldSync.RaiseEvent(__instance, "OnShapeDeactivated", __instance);
// ShapeVisibilityTracker patches

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

@ -1,4 +1,5 @@
using OWML.Utils;
using OWML.Common;
using OWML.Utils;
using QSB.Events;
using QSB.Player;
using QSB.Utility;
@ -39,15 +40,19 @@ namespace QSB.QuantumSync.WorldObjects
private List<Shape> GetAttachedShapes()
{
if (AttachedObject == null)
{
return new List<Shape>();
}
var visibilityTrackers = AttachedObject.GetValue<VisibilityTracker[]>("_visibilityTrackers");
if (visibilityTrackers == null || visibilityTrackers.Length == 0)
{
DebugLog.DebugWrite($"Error - {AttachedObject.name} has null visibility trackers!");
DebugLog.ToConsole($"Warning - {AttachedObject.name} has null visibility trackers!", MessageType.Warning);
return new List<Shape>();
}
if (visibilityTrackers.Any(x => x.GetType() == typeof(RendererVisibilityTracker)))
{
DebugLog.DebugWrite($"Error - {AttachedObject.name} has a renderervisibilitytracker!");
DebugLog.ToConsole($"Warning - {AttachedObject.name} has a RendererVisibilityTracker!", MessageType.Warning);
return new List<Shape>();
}
var totalShapes = new List<Shape>();

5
QSB/SectorSync/QSBSectorManager.cs
View File

@ -37,7 +37,6 @@ namespace QSB.SectorSync
public void RebuildSectors()
{
DebugLog.DebugWrite("Rebuilding sectors...", MessageType.Warning);
QSBWorldSync.RemoveWorldObjects<QSBSector>();
QSBWorldSync.Init<QSBSector, Sector>();
SectorList.Clear();
IsReady = QSBWorldSync.GetWorldObjects<QSBSector>().Any();
@ -48,7 +47,6 @@ namespace QSB.SectorSync
private void AddSector(Sector sector)
{
DebugLog.DebugWrite($"Add sector {sector.name}.");
var worldObject = QSBWorldSync.GetWorldFromUnity<QSBSector, Sector>(sector);
if (worldObject == null)
{
@ -64,7 +62,6 @@ namespace QSB.SectorSync
private void RemoveSector(Sector sector)
{
DebugLog.DebugWrite($"Remove sector {sector.name}.");
var worldObject = QSBWorldSync.GetWorldFromUnity<QSBSector, Sector>(sector);
if (worldObject == null)
{
@ -95,7 +92,7 @@ namespace QSB.SectorSync
&& !_sectorBlacklist.Contains(sector.Type)
&& sector.Transform.gameObject.activeInHierarchy)
.OrderBy(sector => Vector3.Distance(sector.Position, trans.position))
.First();
.FirstOrDefault();
}
}
}

4
QSB/SectorSync/SectorSync.cs
View File

@ -30,6 +30,10 @@ namespace QSB.SectorSync
return;
}
var closestSector = QSBSectorManager.Instance.GetClosestSector(syncedTransform);
if (closestSector == default(QSBSector))
{
return;
}
if (closestSector == transformSync.ReferenceSector)
{
return;

30
QSB/StatueSync/Events/StartStatueEvent.cs Normal file
View File

@ -0,0 +1,30 @@
using QSB.Events;
using UnityEngine;
namespace QSB.StatueSync.Events
{
internal class StartStatueEvent : QSBEvent<StartStatueMessage>
{
public override QSB.Events.EventType Type => QSB.Events.EventType.StartStatue;
public override void SetupListener()
=> GlobalMessenger<Vector3, Quaternion, float>.AddListener(EventNames.QSBStartStatue, Handler);
public override void CloseListener()
=> GlobalMessenger<Vector3, Quaternion, float>.RemoveListener(EventNames.QSBStartStatue, Handler);
private void Handler(Vector3 position, Quaternion rotation, float degrees)
=> SendEvent(CreateMessage(position, rotation, degrees));
private StartStatueMessage CreateMessage(Vector3 position, Quaternion rotation, float degrees) => new StartStatueMessage
{
AboutId = LocalPlayerId,
PlayerPosition = position,
PlayerRotation = rotation,
CameraDegrees = degrees
};
public override void OnReceiveRemote(bool server, StartStatueMessage message)
=> StatueManager.Instance.BeginSequence(message.PlayerPosition, message.PlayerRotation, message.CameraDegrees);
}
}

29
QSB/StatueSync/Events/StartStatueMessage.cs Normal file
View File

@ -0,0 +1,29 @@
using QSB.Messaging;
using QuantumUNET.Transport;
using UnityEngine;
namespace QSB.StatueSync.Events
{
public class StartStatueMessage : PlayerMessage
{
public Vector3 PlayerPosition { get; set; }
public Quaternion PlayerRotation { get; set; }
public float CameraDegrees { get; set; }
public override void Deserialize(QNetworkReader reader)
{
base.Deserialize(reader);
PlayerPosition = reader.ReadVector3();
PlayerRotation = reader.ReadQuaternion();
CameraDegrees = reader.ReadSingle();
}
public override void Serialize(QNetworkWriter writer)
{
base.Serialize(writer);
writer.Write(PlayerPosition);
writer.Write(PlayerRotation);
writer.Write(CameraDegrees);
}
}
}

39
QSB/StatueSync/Patches/StatuePatches.cs Normal file
View File

@ -0,0 +1,39 @@
using QSB.Events;
using QSB.Patches;
using QSB.Player;
using UnityEngine;
namespace QSB.StatueSync.Patches
{
internal class StatuePatches : QSBPatch
{
public override QSBPatchTypes Type => QSBPatchTypes.OnClientConnect;
public override void DoPatches()
=> QSBCore.Helper.HarmonyHelper.AddPrefix<MemoryUplinkTrigger>("Update", typeof(StatuePatches), nameof(Statue_Update));
public override void DoUnpatches()
=> QSBCore.Helper.HarmonyHelper.Unpatch<MemoryUplinkTrigger>("BeginUplinkSequence");
public static bool Statue_Update(bool ____waitForPlayerGrounded)
{
if (StatueManager.Instance.HasStartedStatueLocally)
{
return true;
}
if (!____waitForPlayerGrounded || !Locator.GetPlayerController().IsGrounded())
{
return true;
}
var playerBody = Locator.GetPlayerBody().transform;
var timberHearth = Locator.GetAstroObject(AstroObject.Name.TimberHearth).transform;
QSBEventManager.FireEvent(
EventNames.QSBStartStatue,
timberHearth.InverseTransformPoint(playerBody.position),
Quaternion.Inverse(timberHearth.rotation) * playerBody.rotation,
Locator.GetPlayerCamera().GetComponent<PlayerCameraController>().GetDegreesY());
QSBPlayerManager.HideAllPlayers();
return true;
}
}
}

46
QSB/StatueSync/StatueManager.cs Normal file
View File

@ -0,0 +1,46 @@
using QSB.Player;
using System.Collections;
using UnityEngine;
namespace QSB.StatueSync
{
internal class StatueManager : MonoBehaviour
{
public static StatueManager Instance { get; private set; }
public bool HasStartedStatueLocally;
private void Awake()
{
Instance = this;
QSBSceneManager.OnUniverseSceneLoaded += (OWScene scene) => QSBPlayerManager.ShowAllPlayers();
}
private void OnDestroy()
=> QSBSceneManager.OnUniverseSceneLoaded -= (OWScene scene) => QSBPlayerManager.ShowAllPlayers();
public void BeginSequence(Vector3 position, Quaternion rotation, float cameraDegrees)
=> StartCoroutine(BeginRemoteUplinkSequence(position, rotation, cameraDegrees));
private IEnumerator BeginRemoteUplinkSequence(Vector3 position, Quaternion rotation, float cameraDegrees)
{
HasStartedStatueLocally = true;
var cameraEffectController = Locator.GetPlayerCamera().GetComponent<PlayerCameraEffectController>();
cameraEffectController.CloseEyes(0.5f);
OWInput.ChangeInputMode(InputMode.None);
Locator.GetPauseCommandListener().AddPauseCommandLock();
Locator.GetToolModeSwapper().UnequipTool();
Locator.GetFlashlight().TurnOff(false);
yield return new WaitForSeconds(0.5f);
// go to position
QSBPlayerManager.HideAllPlayers();
var timberHearth = Locator.GetAstroObject(AstroObject.Name.TimberHearth).GetAttachedOWRigidbody();
Locator.GetPlayerBody().transform.position = timberHearth.transform.TransformPoint(position);
Locator.GetPlayerBody().transform.rotation = timberHearth.transform.rotation * rotation;
Locator.GetPlayerCamera().GetComponent<PlayerCameraController>().SetDegreesY(cameraDegrees);
cameraEffectController.OpenEyes(1f, true);
var uplinkTrigger = FindObjectOfType<MemoryUplinkTrigger>();
uplinkTrigger.StartCoroutine("BeginUplinkSequence");
yield break;
}
}
}

36
QSB/TimeSync/WakeUpSync.cs
View File

@ -28,6 +28,7 @@ namespace QSB.TimeSync
private bool _isFirstFastForward = true;
private int _localLoopCount;
private int _serverLoopCount;
private InputMode _storedMode;
public override void OnStartLocalPlayer() => LocalInstance = this;
@ -67,7 +68,6 @@ namespace QSB.TimeSync
private void OnSceneLoaded(OWScene scene, bool isInUniverse)
{
QSBCore.HasWokenUp = (scene == OWScene.EyeOfTheUniverse);
if (isInUniverse)
{
Init();
@ -134,10 +134,16 @@ namespace QSB.TimeSync
return;
}
DebugLog.DebugWrite($"START FASTFORWARD (Target:{_serverTime} Current:{Time.timeSinceLevelLoad})", MessageType.Info);
if (Locator.GetPlayerCamera() != null)
{
Locator.GetPlayerCamera().enabled = false;
}
_timeScale = MaxFastForwardSpeed;
_state = State.FastForwarding;
OWTime.SetMaxDeltaTime(0.033333335f);
TimeSyncUI.TargetTime = _serverTime;
TimeSyncUI.Start(TimeSyncType.Fastforwarding);
DisableInput();
}
private void StartPausing()
@ -147,15 +153,19 @@ namespace QSB.TimeSync
return;
}
DebugLog.DebugWrite($"START PAUSING (Target:{_serverTime} Current:{Time.timeSinceLevelLoad})", MessageType.Info);
Locator.GetPlayerCamera().enabled = false;
_timeScale = 0f;
_state = State.Pausing;
SpinnerUI.Show();
TimeSyncUI.Start(TimeSyncType.Pausing);
DisableInput();
}
private void ResetTimeScale()
{
_timeScale = 1f;
OWTime.SetMaxDeltaTime(0.06666667f);
Locator.GetPlayerCamera().enabled = true;
_state = State.Loaded;
if (!_isInputEnabled)
@ -174,14 +184,20 @@ namespace QSB.TimeSync
private void DisableInput()
{
DebugLog.DebugWrite($"disable input - current:{OWInput.GetInputMode()}");
_isInputEnabled = false;
_storedMode = OWInput.GetInputMode();
OWInput.ChangeInputMode(InputMode.None);
}
private void EnableInput()
{
DebugLog.DebugWrite($"enable input - stored:{_storedMode}");
_isInputEnabled = true;
OWInput.ChangeInputMode(InputMode.Character);
OWInput.ChangeInputMode(
_storedMode != InputMode.None
? _storedMode
: InputMode.Character);
}
public void Update()
@ -215,6 +231,11 @@ namespace QSB.TimeSync
{
_serverTime += Time.unscaledDeltaTime;
if (!_isInputEnabled && OWInput.GetInputMode() != InputMode.None)
{
DisableInput();
}
if (_state == State.NotLoaded)
{
return;
@ -222,8 +243,12 @@ namespace QSB.TimeSync
if (_state == State.FastForwarding)
{
if (Locator.GetPlayerCamera() != null && !Locator.GetPlayerCamera().enabled)
{
Locator.GetPlayerCamera().enabled = false;
}
var diff = _serverTime - Time.timeSinceLevelLoad;
Time.timeScale = Mathf.Lerp(MinFastForwardSpeed, MaxFastForwardSpeed, Mathf.Abs(diff) / MaxFastForwardDiff);
Time.timeScale = Mathf.SmoothStep(MinFastForwardSpeed, MaxFastForwardSpeed, Mathf.Abs(diff) / MaxFastForwardDiff);
if (QSBSceneManager.CurrentScene == OWScene.SolarSystem && _isFirstFastForward)
{
@ -245,11 +270,6 @@ namespace QSB.TimeSync
{
ResetTimeScale();
}
if (!_isInputEnabled && OWInput.GetInputMode() != InputMode.None)
{
DisableInput();
}
}
}
}

3
QSB/TransformSync/TransformSync.cs
View File

@ -28,7 +28,6 @@ namespace QSB.TransformSync
protected override void Start()
{
DebugLog.DebugWrite("start of " + GetType().Name);
base.Start();
var lowestBound = QSBPlayerManager.GetSyncObjects<PlayerTransformSync>()
.Where(x => x.NetId.Value <= NetId.Value).OrderBy(x => x.NetId.Value).Last();
@ -128,7 +127,7 @@ namespace QSB.TransformSync
public void SetReferenceSector(QSBSector sector)
{
if (sector == ReferenceSector || sector == null)
if (sector == ReferenceSector || sector == default(QSBSector))
{
return;
}