mirror/quantum-space-buddies
1
0
Fork 0
mirror of https://github.com/misternebula/quantum-space-buddies.git synced 2025-03-11 10:14:17 +00:00
Code Issues Projects Releases Wiki Activity

split out sector stuff

Browse Source
This commit is contained in:
Mister_Nebula 2021-04-28 00:22:08 +01:00
parent aa7402b095
commit 0eb8ac89af
14 changed files with 346 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -78,6 +78,7 @@ namespace QSB.OrbSync.Events
DebugLog.ToConsole($"Error - Orb identity is null. (ID {message.ObjectId})", MessageType.Error);
return;
}
DebugLog.DebugWrite($"Orb {message.ObjectId} to owner {message.FromId}");
if (orbIdentity.ClientAuthorityOwner != null && orbIdentity.ClientAuthorityOwner != fromPlayer)
{
orbIdentity.RemoveClientAuthority(orbIdentity.ClientAuthorityOwner);
@ -103,6 +104,7 @@ namespace QSB.OrbSync.Events
DebugLog.ToConsole($"Error - No NomaiOrbTransformSync has AttachedOrb with objectId {message.ObjectId}!");
return;
}
DebugLog.DebugWrite($"Orb {message.ObjectId} to owner {message.FromId}");
var orb = QSBWorldSync.OrbSyncList
.First(x => x.AttachedOrb == QSBWorldSync.OldOrbList[message.ObjectId]);
orb.enabled = true;

12
QSB/OrbSync/TransformSync/NomaiOrbTransformSync.cs
View File

@ -43,7 +43,6 @@ namespace QSB.OrbSync.TransformSync
protected void Init()
{
DebugLog.DebugWrite($"Init");
OrbTransform = AttachedOrb.transform;
_orbParent = AttachedOrb.GetAttachedOWRigidbody().GetOrigParent();
_isInitialized = true;
@ -82,5 +81,16 @@ namespace QSB.OrbSync.TransformSync
OrbTransform.rotation = transform.rotation;
}
}
private void OnRenderObject()
{
if (!QSBCore.HasWokenUp || !QSBCore.DebugMode || !QSBCore.ShowLinesInDebug)
{
return;
}
Popcron.Gizmos.Cube(OrbTransform.position, OrbTransform.rotation, Vector3.one / 2, Color.blue);
Popcron.Gizmos.Cube(_orbParent.TransformPoint(transform.position), transform.rotation, Vector3.one / 2, Color.red);
}
}
}

2
QSB/Player/TransformSync/PlayerCameraSync.cs
View File

@ -6,7 +6,7 @@ using UnityEngine;
namespace QSB.Player.TransformSync
{
public class PlayerCameraSync : QSBNetworkTransform
public class PlayerCameraSync : SectoredTransformSync
{
protected override GameObject InitLocalTransform()
{

2
QSB/Player/TransformSync/PlayerTransformSync.cs
View File

@ -5,7 +5,7 @@ using UnityEngine;
namespace QSB.Player.TransformSync
{
public class PlayerTransformSync : QSBNetworkTransform
public class PlayerTransformSync : SectoredTransformSync
{
public static PlayerTransformSync LocalInstance { get; private set; }

7
QSB/ProbeSync/TransformSync/PlayerProbeSync.cs
View File

@ -7,14 +7,17 @@ using UnityEngine;
namespace QSB.ProbeSync.TransformSync
{
public class PlayerProbeSync : QSBNetworkTransform
public class PlayerProbeSync : SectoredTransformSync
{
public static PlayerProbeSync LocalInstance { get; private set; }
protected override float DistanceLeeway => 10f;
public override void OnStartAuthority()
=> LocalInstance = this;
{
DebugLog.DebugWrite($"OnStartAuthority probe");
LocalInstance = this;
}
private Transform GetProbe() =>
Locator.GetProbe().transform.Find("CameraPivot").Find("Geometry");

2
QSB/QSB.csproj
View File

@ -237,9 +237,11 @@
<Compile Include="StatueSync\Patches\StatuePatches.cs" />
<Compile Include="StatueSync\StatueManager.cs" />
<Compile Include="RoastingSync\TransformSync\RoastingStickTransformSync.cs" />
<Compile Include="TransformSync\BaseTransformSync.cs" />
<Compile Include="TransformSync\IntermediaryTransform.cs" />
<Compile Include="TransformSync\Patches\TransformSyncPatches.cs" />
<Compile Include="TransformSync\QSBNetworkTransform.cs" />
<Compile Include="TransformSync\SectoredTransformSync.cs" />
<Compile Include="TranslationSync\Events\SetAsTranslatedEvent.cs" />
<Compile Include="TranslationSync\Events\SetAsTranslatedMessage.cs" />
<Compile Include="TranslationSync\NomaiTextType.cs" />

8
QSB/QSBCore.cs
View File

@ -149,9 +149,13 @@ namespace QSB
}
var offset3 = 10f;
GUI.Label(new Rect(420, offset3, 400f, 20f), $"Current sector : {PlayerTransformSync.LocalInstance.ReferenceSector.Name}");
var playerSector = PlayerTransformSync.LocalInstance.ReferenceSector;
var playerText = playerSector == null ? "NULL" : playerSector.Name;
GUI.Label(new Rect(420, offset3, 400f, 20f), $"Current sector : {playerText}");
offset3 += _debugLineSpacing;
GUI.Label(new Rect(420, offset3, 400f, 20f), $"Probe sector : {PlayerProbeSync.LocalInstance.ReferenceSector.Name}");
var probeSector = PlayerProbeSync.LocalInstance.ReferenceSector;
var probeText = probeSector == null ? "NULL" : probeSector.Name;
GUI.Label(new Rect(420, offset3, 400f, 20f), $"Probe sector : {probeText}");
offset3 += _debugLineSpacing;
var offset2 = 10f;

2
QSB/RoastingSync/TransformSync/RoastingStickTransformSync.cs
View File

@ -7,7 +7,7 @@ using UnityEngine;
namespace QSB.RoastingSync.TransformSync
{
internal class RoastingStickTransformSync : QSBNetworkTransform
internal class RoastingStickTransformSync : SectoredTransformSync
{
private Transform _stickTip;
private Transform _networkStickTip => gameObject.transform.GetChild(0);

4
QSB/SectorSync/QSBSectorManager.cs
View File

@ -20,7 +20,7 @@ namespace QSB.SectorSync
public void Invoke()
{
foreach (var sync in QSBNetworkTransform.NetworkTransformList)
foreach (var sync in SectoredTransformSync.SectoredNetworkTransformList)
{
if (sync.AttachedObject == null)
{
@ -64,7 +64,7 @@ namespace QSB.SectorSync
IsReady = QSBWorldSync.GetWorldObjects<QSBSector>().Any();
}
private void CheckTransformSyncSector(QSBNetworkTransform transformSync)
private void CheckTransformSyncSector(SectoredTransformSync transformSync)
{
var attachedObject = transformSync.AttachedObject;
var closestSector = transformSync.SectorSync.GetClosestSector(attachedObject.transform);

2
QSB/ShipSync/TransformSync/ShipTransformSync.cs
View File

@ -4,7 +4,7 @@ using UnityEngine;
namespace QSB.ShipSync.TransformSync
{
public class ShipTransformSync : QSBNetworkTransform
public class ShipTransformSync : SectoredTransformSync
{
protected override float DistanceLeeway => 20f;

218
QSB/TransformSync/BaseTransformSync.cs Normal file
View File

@ -0,0 +1,218 @@
using OWML.Common;
using QSB.Player;
using QSB.Player.TransformSync;
using QSB.Utility;
using QuantumUNET.Components;
using QuantumUNET.Transport;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;
namespace QSB.TransformSync
{
public abstract class BaseTransformSync : QNetworkTransform
{
public uint AttachedNetId => NetIdentity?.NetId.Value ?? uint.MaxValue;
public uint PlayerId => NetIdentity.RootIdentity?.NetId.Value ?? NetIdentity.NetId.Value;
public PlayerInfo Player => QSBPlayerManager.GetPlayer(PlayerId);
public Transform ReferenceTransform { get; set; }
public GameObject AttachedObject { get; set; }
public abstract bool IsReady { get; }
protected abstract GameObject InitLocalTransform();
protected abstract GameObject InitRemoteTransform();
private bool _isInitialized;
private const float SmoothTime = 0.1f;
protected virtual float DistanceLeeway { get; } = 5f;
private float _previousDistance;
private Vector3 _positionSmoothVelocity;
private Quaternion _rotationSmoothVelocity;
protected IntermediaryTransform _intermediaryTransform;
public virtual void Start()
{
var lowestBound = Resources.FindObjectsOfTypeAll<PlayerTransformSync>()
.Where(x => x.NetId.Value <= NetId.Value).OrderBy(x => x.NetId.Value).Last();
NetIdentity.SetRootIdentity(lowestBound.NetIdentity);
DontDestroyOnLoad(gameObject);
_intermediaryTransform = new IntermediaryTransform(transform);
QSBSceneManager.OnSceneLoaded += OnSceneLoaded;
}
protected virtual void OnDestroy()
{
if (!HasAuthority && AttachedObject != null)
{
Destroy(AttachedObject);
}
QSBSceneManager.OnSceneLoaded -= OnSceneLoaded;
}
private void OnSceneLoaded(OWScene scene, bool isInUniverse) =>
_isInitialized = false;
protected virtual void Init()
{
AttachedObject = HasAuthority ? InitLocalTransform() : InitRemoteTransform();
_isInitialized = true;
}
public override void SerializeTransform(QNetworkWriter writer)
{
if (_intermediaryTransform == null)
{
_intermediaryTransform = new IntermediaryTransform(transform);
}
var worldPos = _intermediaryTransform.GetPosition();
var worldRot = _intermediaryTransform.GetRotation();
writer.Write(worldPos);
SerializeRotation(writer, worldRot);
_prevPosition = worldPos;
_prevRotation = worldRot;
}
public override void DeserializeTransform(QNetworkReader reader)
{
if (!QSBCore.HasWokenUp)
{
reader.ReadVector3();
DeserializeRotation(reader);
return;
}
var pos = reader.ReadVector3();
var rot = DeserializeRotation(reader);
if (HasAuthority)
{
return;
}
_intermediaryTransform.SetPosition(pos);
_intermediaryTransform.SetRotation(rot);
if (_intermediaryTransform.GetPosition() == Vector3.zero)
{
DebugLog.ToConsole($"Warning - {PlayerId}.{GetType().Name} at (0,0,0)! - Given position was {pos}", MessageType.Warning);
}
}
public override void Update()
{
if (!_isInitialized && IsReady)
{
Init();
}
else if (_isInitialized && !IsReady)
{
_isInitialized = false;
return;
}
if (!_isInitialized)
{
return;
}
if (AttachedObject == null)
{
DebugLog.ToConsole($"Warning - AttachedObject {Player.PlayerId}.{GetType().Name} is null.", MessageType.Warning);
return;
}
UpdateTransform();
base.Update();
}
protected virtual void UpdateTransform()
{
if (HasAuthority)
{
_intermediaryTransform.EncodePosition(AttachedObject.transform.position);
_intermediaryTransform.EncodeRotation(AttachedObject.transform.rotation);
}
else
{
var targetPos = _intermediaryTransform.GetTargetPosition();
var targetRot = _intermediaryTransform.GetTargetRotation();
AttachedObject.transform.localPosition = SmartSmoothDamp(AttachedObject.transform.localPosition, targetPos);
AttachedObject.transform.localRotation = QuaternionHelper.SmoothDamp(AttachedObject.transform.localRotation, targetRot, ref _rotationSmoothVelocity, SmoothTime);
}
}
public override bool HasMoved()
{
var displacementMagnitude = (_intermediaryTransform.GetPosition() - _prevPosition).magnitude;
return displacementMagnitude > 1E-03f
|| Quaternion.Angle(_intermediaryTransform.GetRotation(), _prevRotation) > 1E-03f;
}
public void SetReferenceTransform(Transform transform)
{
if (ReferenceTransform == transform)
{
return;
}
ReferenceTransform = transform;
_intermediaryTransform.SetReferenceTransform(transform);
if (AttachedObject == null)
{
DebugLog.ToConsole($"Warning - AttachedObject was null for {PlayerId}.{GetType().Name} when trying to set reference transform to {transform.name}. Waiting until not null...", MessageType.Warning);
QSBCore.UnityEvents.RunWhen(
() => AttachedObject != null,
() => ReparentAttachedObject(transform));
return;
}
if (!HasAuthority)
{
ReparentAttachedObject(transform);
}
}
private void ReparentAttachedObject(Transform sectorTransform)
{
if (AttachedObject.transform.parent != null && AttachedObject.transform.parent.GetComponent<Sector>() == null)
{
DebugLog.ToConsole($" - ERROR - Trying to reparent attachedObject which wasnt attached to sector!", MessageType.Error);
return;
}
AttachedObject.transform.SetParent(sectorTransform, true);
AttachedObject.transform.localScale = GetType() == typeof(PlayerTransformSync)
? Vector3.one / 10
: Vector3.one;
}
private Vector3 SmartSmoothDamp(Vector3 currentPosition, Vector3 targetPosition)
{
var distance = Vector3.Distance(currentPosition, targetPosition);
if (distance > _previousDistance + DistanceLeeway)
{
_previousDistance = distance;
return targetPosition;
}
_previousDistance = distance;
return Vector3.SmoothDamp(currentPosition, targetPosition, ref _positionSmoothVelocity, SmoothTime);
}
private void OnRenderObject()
{
if (!QSBCore.HasWokenUp || !QSBCore.DebugMode || !QSBCore.ShowLinesInDebug || !IsReady)
{
return;
}
Popcron.Gizmos.Cube(_intermediaryTransform.GetTargetPosition(), _intermediaryTransform.GetTargetRotation(), Vector3.one / 2, Color.red);
var color = HasMoved() ? Color.green : Color.yellow;
Popcron.Gizmos.Cube(AttachedObject.transform.position, AttachedObject.transform.rotation, Vector3.one / 2, color);
Popcron.Gizmos.Line(AttachedObject.transform.position, ReferenceTransform.position, Color.cyan);
}
}
}

14
QSB/TransformSync/IntermediaryTransform.cs
View File

@ -3,10 +3,10 @@ using UnityEngine;
namespace QSB.TransformSync
{
internal class IntermediaryTransform
public class IntermediaryTransform
{
private Transform _attachedTransform;
private QSBSector _referenceSector;
private Transform _referenceTransform;
public IntermediaryTransform(Transform transform) => _attachedTransform = transform;
/// <summary>
@ -34,25 +34,25 @@ namespace QSB.TransformSync
=> _attachedTransform.rotation = worldRot;
/// <summary>
/// Sets the reference sector - what sector this transform is syncing to.
/// Sets the reference transform - what transform this transform is syncing to.
/// </summary>
/// <param name="sector">The new reference sector.</param>
public void SetReferenceSector(QSBSector sector)
=> _referenceSector = sector;
public void SetReferenceTransform(Transform transform)
=> _referenceTransform = transform;
/// <summary>
/// Sets the position of the INVISIBLE transform to be correct, according to the reference sector and the position of the VISIBLE transform.
/// </summary>
/// <param name="worldPosition">The world position of the VISIBLE transform.</param>
public void EncodePosition(Vector3 worldPosition)
=> SetPosition(_referenceSector.Transform.InverseTransformPoint(worldPosition));
=> SetPosition(_referenceTransform.InverseTransformPoint(worldPosition));
/// <summary>
/// Sets the rotation of the INVISIBLE transform to be correct, according to the reference sector and the rotation of the VISIBLE transform.
/// </summary>
/// <param name="worldPosition">The world rotation of the VISIBLE transform.</param>
public void EncodeRotation(Quaternion worldRotation)
=> SetRotation(_referenceSector.Transform.InverseTransformRotation(worldRotation));
=> SetRotation(_referenceTransform.InverseTransformRotation(worldRotation));
/// <summary>
/// Gets what the VISIBLE transform's position should be, from the reference sector and the position of the INVISIBLE transform.

2
QSB/TransformSync/QSBNetworkTransform.cs
View File

@ -12,6 +12,7 @@ using UnityEngine;
namespace QSB.TransformSync
{
/*
public abstract class QSBNetworkTransform : QNetworkTransform
{
public uint AttachedNetId => NetIdentity?.NetId.Value ?? uint.MaxValue;
@ -246,4 +247,5 @@ namespace QSB.TransformSync
Popcron.Gizmos.Line(AttachedObject.transform.position, ReferenceSector.Transform.position, Color.cyan);
}
}
*/
}

87
QSB/TransformSync/SectoredTransformSync.cs Normal file
View File

@ -0,0 +1,87 @@
using QSB.SectorSync.WorldObjects;
using QSB.Utility;
using QSB.WorldSync;
using QuantumUNET.Transport;
using System.Collections.Generic;
namespace QSB.TransformSync
{
public abstract class SectoredTransformSync : BaseTransformSync
{
public QSBSector ReferenceSector { get; set; }
public SectorSync.SectorSync SectorSync { get; private set; }
public static List<SectoredTransformSync> SectoredNetworkTransformList = new List<SectoredTransformSync>();
public override void Start()
{
DebugLog.DebugWrite($"Start of {GetType().Name}");
SectorSync = gameObject.AddComponent<SectorSync.SectorSync>();
SectoredNetworkTransformList.Add(this);
base.Start();
}
protected override void OnDestroy()
{
DebugLog.DebugWrite($"OnDestroy of {GetType().Name}");
base.OnDestroy();
SectoredNetworkTransformList.Remove(this);
if (SectorSync != null)
{
Destroy(SectorSync);
}
}
protected override void Init()
{
DebugLog.DebugWrite($"Init of {GetType().Name}");
base.Init();
SetReferenceTransform(SectorSync.GetClosestSector(AttachedObject.transform).Transform);
}
public override void SerializeTransform(QNetworkWriter writer)
{
if (_intermediaryTransform == null)
{
_intermediaryTransform = new IntermediaryTransform(transform);
}
if (ReferenceSector != null)
{
writer.Write(ReferenceSector.ObjectId);
}
else
{
writer.Write(-1);
}
base.SerializeTransform(writer);
}
public override void DeserializeTransform(QNetworkReader reader)
{
if (!QSBCore.HasWokenUp)
{
reader.ReadInt32();
reader.ReadVector3();
DeserializeRotation(reader);
return;
}
var sectorId = reader.ReadInt32();
var sector = sectorId == -1
? null
: QSBWorldSync.GetWorldFromId<QSBSector>(sectorId);
if (sector != ReferenceSector)
{
SetReferenceSector(sector);
}
base.DeserializeTransform(reader);
}
public void SetReferenceSector(QSBSector sector)
{
ReferenceSector = sector;
SetReferenceTransform(sector.Transform);
}
}
}