mirror/quantum-space-buddies
1
0
Fork 0
mirror of https://github.com/misternebula/quantum-space-buddies.git synced 2025-02-20 15:41:01 +00:00
Code Issues Projects Releases Wiki Activity

this is broken but its getting there???

Browse Source
This commit is contained in:
Mister_Nebula 2020-08-29 22:49:29 +01:00
parent 19e1615a57
commit 37e7a64c9c
26 changed files with 305 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
AssetBundles/debug.manifest
View File

@ -3,7 +3,7 @@ CRC: 2815158869
Hashes:
AssetFileHash:
serializedVersion: 2
Hash: 81bbcd8775249928cc67d7ff90ff9047
Hash: 5677b7876f2afae05c0920067ef29e8a
TypeTreeHash:
serializedVersion: 2
Hash: 4d6a73cb377370ba69c96eb5da1b5028

BIN
AssetBundles/network
View File

Binary file not shown.

4
AssetBundles/network.manifest
View File

@ -1,9 +1,9 @@
ManifestFileVersion: 0
CRC: 3775067745
CRC: 2522957964
Hashes:
AssetFileHash:
serializedVersion: 2
Hash: 3a9598581da083f242daab94ed0741fb
Hash: fb956af412c243bc7fa631660dc4d343
TypeTreeHash:
serializedVersion: 2
Hash: 47ee499ae8022a6b96ca6a5fd541f154

6
QSB/Events/EventList.cs
View File

@ -39,9 +39,9 @@ namespace QSB.Events
new GeyserEvent(),
new ServerTimeEvent(),
new AnimTriggerEvent(),
new OrbSlotEvent(),
new OrbUserEvent(),
new OrbStatusEvent()
new OrbSlotEvent()
//new OrbUserEvent()
//new OrbStatusEvent()
};
_eventList.ForEach(ev => ev.SetupListener());

2
QSB/Events/PlayerReadyEvent.cs
View File

@ -42,7 +42,7 @@ namespace QSB.Events
public override void OnReceiveRemote(ToggleMessage message)
{
DebugLog.DebugWrite($"Get ready event from {message.FromId}", MessageType.Success);
foreach (var item in PlayerRegistry.GetSyncObjects<TransformSync.TransformSync>()
foreach (var item in PlayerRegistry.GetSyncObjects<TransformSync.QSBTransformSync>()
.Where(x => x != null && x.IsReady && x.ReferenceSector != null && x.PlayerId == LocalPlayerId))
{
DebugLog.DebugWrite($"* Sending sector for netid {item.netId.Value}...");

2
QSB/Events/PlayerState.cs
View File

@ -24,7 +24,7 @@ namespace QSB.Events
return;
}
QSB.Helper.Events.Unity.RunWhen(
() => PlayerRegistry.GetSyncObject<TransformSync.TransformSync>(message.AboutId) != null,
() => PlayerRegistry.GetSyncObject<TransformSync.QSBTransformSync>(message.AboutId) != null,
() => PlayerRegistry.HandleFullStateMessage(message));
}

2
QSB/Events/PlayerStatesRequestEvent.cs
View File

@ -30,7 +30,7 @@ namespace QSB.Events
{
DebugLog.DebugWrite($"[S] Get state request from {message.FromId}");
PlayerState.LocalInstance.Send();
foreach (var item in PlayerRegistry.GetSyncObjects<TransformSync.TransformSync>()
foreach (var item in PlayerRegistry.GetSyncObjects<TransformSync.QSBTransformSync>()
.Where(x => x != null && x.IsReady && x.ReferenceSector != null))
{
DebugLog.DebugWrite($"* Sending sector for netid {item.netId.Value}...");

1
QSB/GeyserSync/GeyserEvent.cs
View File

@ -1,6 +1,5 @@
using QSB.Events;
using QSB.Messaging;
using QSB.Utility;
using QSB.WorldSync;
namespace QSB.GeyserSync

3
QSB/Messaging/EventType.cs
View File

@ -22,6 +22,7 @@
Geyser,
OrbSlot,
OrbUser,
OrbStatus
OrbStatus,
QSBPositionMessage
}
}

2
QSB/OrbSync/OrbSlotEvent.cs
View File

@ -30,7 +30,7 @@ namespace QSB.OrbSync
public override void OnReceiveRemote(BoolWorldObjectMessage message)
{
var orbSlot = WorldRegistry.GetObject<QSBOrbSlot>(message.ObjectId);
DebugLog.ToConsole($"GET ORB MESSAGE {message.ObjectId} : {message.State}");
orbSlot?.SetState(message.State);

9
QSB/OrbSync/OrbSlotPatches.cs
View File

@ -1,9 +1,4 @@
using OWML.ModHelper.Events;
using QSB.Events;
using QSB.Utility;
using QSB.WorldSync;
namespace QSB.OrbSync
namespace QSB.OrbSync
{
public static class OrbSlotPatches
{
@ -12,6 +7,7 @@ namespace QSB.OrbSync
return false;
}
/*
public static void StartDragCallEvent(bool __result, NomaiInterfaceOrb __instance)
{
if (__result)
@ -36,5 +32,6 @@ namespace QSB.OrbSync
{
return WorldRegistry.IsOrbControlledLocally(__instance);
}
*/
}
}

1
QSB/OrbSync/OrbStatusEvent.cs
View File

@ -1,7 +1,6 @@
using OWML.ModHelper.Events;
using QSB.Events;
using QSB.Messaging;
using QSB.Utility;
using QSB.WorldSync;
namespace QSB.OrbSync

4
QSB/OrbSync/QSBOrbSlot.cs
View File

@ -1,10 +1,8 @@
using OWML.ModHelper.Events;
using QSB.Events;
using QSB.Events;
using QSB.Utility;
using QSB.WorldSync;
using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using UnityEngine.Networking;
namespace QSB.OrbSync

2
QSB/QSB.csproj
View File

@ -169,6 +169,7 @@
<Compile Include="Messaging\ToggleMessage.cs" />
<Compile Include="TransformSync\QSBSector.cs" />
<Compile Include="TransformSync\QSBSectorManager.cs" />
<Compile Include="TransformSync\QSBTransformSync.cs" />
<Compile Include="Utility\GOExtensions.cs" />
<Compile Include="WorldSync\BoolWorldObjectMessage.cs" />
<Compile Include="WorldSync\WorldObjectMessage.cs" />
@ -199,7 +200,6 @@
<Compile Include="Utility\QuaternionHelper.cs" />
<Compile Include="TimeSync\PreserveTimeScale.cs" />
<Compile Include="TransformSync\ShipTransformSync.cs" />
<Compile Include="TransformSync\TransformSync.cs" />
<Compile Include="TransformSync\SectorSync.cs" />
<Compile Include="TimeSync\ServerTimeMessage.cs" />
<Compile Include="TimeSync\WakeUpSync.cs" />

18
QSB/QSBNetworkManager.cs
View File

@ -39,6 +39,7 @@ namespace QSB
_assetBundle = QSB.NetworkAssetBundle;
playerPrefab = _assetBundle.LoadAsset<GameObject>("assets/networkplayer.prefab");
playerPrefab.AddComponent<QSBTransformSync>();
playerPrefab.AddComponent<PlayerTransformSync>();
playerPrefab.AddComponent<AnimationSync>();
playerPrefab.AddComponent<WakeUpSync>();
@ -73,7 +74,6 @@ namespace QSB
WorldRegistry.OldOrbList = Resources.FindObjectsOfTypeAll<NomaiInterfaceOrb>().ToList();
foreach (var orb in WorldRegistry.OldOrbList)
{
if (NetworkServer.active)
{
WorldRegistry.OrbUserList.Add(orb, PlayerRegistry.LocalPlayerId);
@ -127,16 +127,18 @@ namespace QSB
WakeUpPatches.AddPatches();
}
QSB.Helper.HarmonyHelper.AddPostfix<NomaiInterfaceOrb>("StartDragFromPosition", typeof(OrbSlotPatches), nameof(OrbSlotPatches.StartDragCallEvent));
QSB.Helper.HarmonyHelper.AddPostfix<NomaiInterfaceOrb>("CancelDrag", typeof(OrbSlotPatches), nameof(OrbSlotPatches.CancelDrag));
QSB.Helper.HarmonyHelper.AddPostfix<NomaiInterfaceOrb>("SetOrbPosition", typeof(OrbSlotPatches), nameof(OrbSlotPatches.SetPosition));
QSB.Helper.HarmonyHelper.AddPrefix<NomaiInterfaceOrb>("SetOrbPosition", typeof(OrbSlotPatches), nameof(OrbSlotPatches.SetOrbPosition));
//QSB.Helper.HarmonyHelper.AddPostfix<NomaiInterfaceOrb>("StartDragFromPosition", typeof(OrbSlotPatches), nameof(OrbSlotPatches.StartDragCallEvent));
//QSB.Helper.HarmonyHelper.AddPostfix<NomaiInterfaceOrb>("CancelDrag", typeof(OrbSlotPatches), nameof(OrbSlotPatches.CancelDrag));
//QSB.Helper.HarmonyHelper.AddPostfix<NomaiInterfaceOrb>("SetOrbPosition", typeof(OrbSlotPatches), nameof(OrbSlotPatches.SetPosition));
//QSB.Helper.HarmonyHelper.AddPrefix<NomaiInterfaceOrb>("SetOrbPosition", typeof(OrbSlotPatches), nameof(OrbSlotPatches.SetOrbPosition));
_lobby.CanEditName = false;
OnNetworkManagerReady?.Invoke();
IsReady = true;
NetworkServer.RegisterHandler((short)Messaging.EventType.QSBPositionMessage + MsgType.Highest + 1, new NetworkMessageDelegate(QSBTransformSync.HandleTransform));
QSB.Helper.Events.Unity.RunWhen(() => PlayerTransformSync.LocalInstance != null, EventList.Init);
QSB.Helper.Events.Unity.RunWhen(() => EventList.Ready,
@ -217,14 +219,14 @@ namespace QSB
.Where(x => x != null && x.netId.Value == netId);
foreach (var networkBehaviour in networkBehaviours)
{
var transformSync = networkBehaviour.GetComponent<TransformSync.TransformSync>();
var transformSync = networkBehaviour.GetComponent<TransformSync.QSBTransformSync>();
if (transformSync != null)
{
PlayerRegistry.PlayerSyncObjects.Remove(transformSync);
if (transformSync.SyncedTransform != null)
if (transformSync.AttachedObject != null)
{
Destroy(transformSync.SyncedTransform.gameObject);
Destroy(transformSync.AttachedObject.gameObject);
}
}
Destroy(networkBehaviour.gameObject);

15
QSB/TransformSync/NomaiOrbTransformSync.cs
View File

@ -1,5 +1,4 @@
using OWML.Common;
using QSB.Utility;
using QSB.Utility;
using QSB.WorldSync;
using UnityEngine;
using UnityEngine.Networking;
@ -9,7 +8,7 @@ namespace QSB.TransformSync
public class NomaiOrbTransformSync : NetworkBehaviour
{
private NomaiInterfaceOrb _attachedOrb;
private int _index => WorldRegistry.OrbList.FindIndex(x => x == this);
private int Index => WorldRegistry.OrbList.FindIndex(x => x == this);
public Transform SyncedTransform { get; private set; }
private bool _isInitialized;
@ -27,8 +26,8 @@ namespace QSB.TransformSync
private void OnReady()
{
_attachedOrb = WorldRegistry.OldOrbList[_index];
DebugLog.DebugWrite($"orb index {_index} is attached to orb {_attachedOrb.GetInstanceID()}!");
_attachedOrb = WorldRegistry.OldOrbList[Index];
DebugLog.DebugWrite($"orb index {Index} is attached to orb {_attachedOrb.GetInstanceID()}!");
_isReady = true;
}
@ -71,11 +70,7 @@ namespace QSB.TransformSync
protected virtual void UpdateTransform()
{
if (WorldRegistry.OldOrbList.FindIndex(x => x == _attachedOrb) == 31)
{
DebugLog.DebugWrite("31 is local? : " + WorldRegistry.IsOrbControlledLocally(_attachedOrb));
}
if (WorldRegistry.IsOrbControlledLocally(_attachedOrb))
if (isServer)
{
transform.position = ReferenceTransform.InverseTransformPoint(SyncedTransform.position);
transform.rotation = ReferenceTransform.InverseTransformRotation(SyncedTransform.rotation);

2
QSB/TransformSync/PlayerCameraSync.cs
View File

@ -5,7 +5,7 @@ using UnityEngine;
namespace QSB.TransformSync
{
public class PlayerCameraSync : TransformSync
public class PlayerCameraSync : QSBTransformSync
{
public static PlayerCameraSync LocalInstance { get; private set; }

4
QSB/TransformSync/PlayerProbeSync.cs
View File

@ -4,7 +4,7 @@ using UnityEngine;
namespace QSB.TransformSync
{
public class PlayerProbeSync : TransformSync
public class PlayerProbeSync : QSBTransformSync
{
public static PlayerProbeSync LocalInstance { get; private set; }
@ -48,6 +48,7 @@ namespace QSB.TransformSync
return body;
}
/*
protected override void UpdateTransform()
{
base.UpdateTransform();
@ -67,6 +68,7 @@ namespace QSB.TransformSync
}
SyncedTransform.localPosition = ReferenceSector.Transform.InverseTransformPoint(_disabledSocket.position);
}
*/
public override bool IsReady => Locator.GetProbe() != null && PlayerRegistry.PlayerExists(PlayerId) && Player.IsReady;
}

4
QSB/TransformSync/PlayerSectorEvent.cs
View File

@ -42,9 +42,9 @@ namespace QSB.TransformSync
return;
}
var transformSync = PlayerRegistry.GetSyncObject<TransformSync>(message.AboutId);
var transformSync = PlayerRegistry.GetSyncObject<QSBTransformSync>(message.AboutId);
QSB.Helper.Events.Unity.RunWhen(() => transformSync.SyncedTransform != null,
QSB.Helper.Events.Unity.RunWhen(() => transformSync.AttachedObject != null,
() => transformSync.SetReferenceSector(sector));
}

4
QSB/TransformSync/PlayerTransformSync.cs
View File

@ -1,9 +1,10 @@
using QSB.Animation;
using QSB.Utility;
using UnityEngine;
namespace QSB.TransformSync
{
public class PlayerTransformSync : TransformSync
public class PlayerTransformSync : QSBTransformSync
{
public static PlayerTransformSync LocalInstance { get; private set; }
@ -16,6 +17,7 @@ namespace QSB.TransformSync
public override void OnStartLocalPlayer()
{
DebugLog.DebugWrite("OnStartLocalPlayer " + PlayerId);
LocalInstance = this;
}

260
QSB/TransformSync/QSBTransformSync.cs Normal file
View File

@ -0,0 +1,260 @@
using OWML.Common;
using QSB.Utility;
using UnityEngine;
using UnityEngine.Networking;
namespace QSB.TransformSync
{
public abstract class QSBTransformSync : PlayerSyncObject
{
private readonly float sendInterval = 0.1f;
private readonly float movementTheshold = 1f / 1000f;
private float lastClientSendTime;
private Vector3 prevPosition;
private Quaternion prevRotation;
private NetworkWriter localTransformWriter;
private Vector3 _positionSmoothVelocity;
private bool _isInitialized;
public QSBSector ReferenceSector { get; set; }
public Transform AttachedObject { get; private set; }
public abstract bool IsReady { get; }
protected abstract Transform InitLocalTransform();
protected abstract Transform InitRemoteTransform();
private void Awake()
{
prevPosition = transform.localPosition;
prevRotation = transform.localRotation;
if (!localPlayerAuthority)
{
return;
}
localTransformWriter = new NetworkWriter();
PlayerRegistry.PlayerSyncObjects.Add(this);
DontDestroyOnLoad(gameObject);
QSBSceneManager.OnSceneLoaded += OnSceneLoaded;
}
private void OnSceneLoaded(OWScene scene, bool isInUniverse)
{
_isInitialized = false;
}
public void SetReferenceSector(QSBSector sector)
{
DebugLog.DebugWrite("set reference sector of " + NetId + " to " + sector.Sector.name);
_positionSmoothVelocity = Vector3.zero;
ReferenceSector = sector;
transform.SetParent(sector.Transform, true);
transform.position = sector.Transform.InverseTransformPoint(transform.position);
transform.rotation = sector.Transform.InverseTransformRotation(transform.rotation);
}
public override bool OnSerialize(NetworkWriter writer, bool initialState)
{
DebugLog.DebugWrite("On serialize");
if (!initialState)
{
if (syncVarDirtyBits == 0)
{
writer.WritePackedUInt32(0U);
return false;
}
writer.WritePackedUInt32(1U);
}
SerializeModeTransform(writer);
return true;
}
public override void OnDeserialize(NetworkReader reader, bool initialState)
{
if (isServer && NetworkServer.localClientActive || !initialState && (int)reader.ReadPackedUInt32() == 0)
{
return;
}
UnserializeModeTransform(reader);
}
private void SerializeModeTransform(NetworkWriter writer)
{
if (transform.parent != null)
{
DebugLog.DebugWrite("* writing " + transform.localPosition + " with respect to " + transform.parent.name + ", using a reference of " + ReferenceSector.Name);
DebugLog.DebugWrite("* attached object is " + AttachedObject.name + " and it's localposition is " + ReferenceSector.Transform.InverseTransformPoint(AttachedObject.position));
}
else
{
DebugLog.DebugWrite("* writing " + transform.localPosition + " with respect to NULL PARENT");
}
writer.Write(transform.localPosition);
SerializeRotation3D(writer, transform.localRotation);
prevPosition = transform.localPosition;
prevRotation = transform.localRotation;
}
private void UnserializeModeTransform(NetworkReader reader)
{
if (hasAuthority)
{
reader.ReadVector3();
UnserializeRotation3D(reader);
}
else
{
transform.localPosition = reader.ReadVector3();
transform.localRotation = UnserializeRotation3D(reader);
}
}
private void FixedUpdate()
{
if (isServer)
{
FixedUpdateServer();
}
}
private void FixedUpdateServer()
{
if (syncVarDirtyBits != 0 || !NetworkServer.active || (!isServer || GetNetworkSendInterval() == 0.0) || (transform.localPosition - prevPosition).magnitude < movementTheshold && Quaternion.Angle(prevRotation, transform.localRotation) < movementTheshold)
{
return;
}
SetDirtyBit(1U);
}
protected void Init()
{
DebugLog.DebugWrite("init of " + NetId);
ReferenceSector = QSBSectorManager.Instance.GetStartPlanetSector();
AttachedObject = hasAuthority ? InitLocalTransform() : InitRemoteTransform();
if (!hasAuthority)
{
AttachedObject.parent = transform;
AttachedObject.localPosition = Vector3.zero;
transform.localPosition = ReferenceSector.Position;
}
_isInitialized = true;
}
private void Update()
{
if (!_isInitialized && IsReady)
{
Init();
}
else if (_isInitialized && !IsReady)
{
DebugLog.DebugWrite("deinitialise " + PlayerId);
_isInitialized = false;
}
if (!hasAuthority || !localPlayerAuthority || (NetworkServer.active || Time.time - lastClientSendTime <= GetNetworkSendInterval()))
{
return;
}
SendTransform();
lastClientSendTime = Time.time;
}
private bool HasMoved()
{
if ((transform.localPosition - prevPosition).magnitude > 9.99999974737875E-06)
{
return true;
}
float num = Quaternion.Angle(transform.localRotation, prevRotation);
return num > 9.99999974737875E-06;
}
[Client]
private void SendTransform()
{
DebugLog.DebugWrite("send transform");
if (!HasMoved() || ClientScene.readyConnection == null)
{
return;
}
localTransformWriter.StartMessage((short)Messaging.EventType.QSBPositionMessage + MsgType.Highest + 1);
localTransformWriter.Write(netId);
SerializeModeTransform(localTransformWriter);
prevPosition = transform.localPosition;
prevRotation = transform.localRotation;
localTransformWriter.FinishMessage();
ClientScene.readyConnection.SendWriter(localTransformWriter, GetNetworkChannel());
}
public static void HandleTransform(NetworkMessage netMsg)
{
var netId = netMsg.reader.ReadNetworkId();
var localObject = NetworkServer.FindLocalObject(netId);
if (localObject == null)
{
DebugLog.ToConsole("Error - LocalObject not found!", MessageType.Error);
}
else
{
var component = localObject.GetComponent<QSBTransformSync>();
if (component == null)
{
DebugLog.ToConsole("Error - LocalObject doesn't have a QSBTransformSync!", MessageType.Error);
}
else if (!component.localPlayerAuthority)
{
DebugLog.ToConsole("Error - LocalObject doesn't have localPlayerAuthority!", MessageType.Error);
}
else if (netMsg.conn.clientOwnedObjects == null)
{
DebugLog.ToConsole("Error - LocalObject not owned by connection!", MessageType.Error);
}
else if (netMsg.conn.clientOwnedObjects.Contains(netId))
{
component.UnserializeModeTransform(netMsg.reader);
}
else
{
DebugLog.ToConsole("Warning - HandleTransform netId:" + netId + " is not for a valid player", MessageType.Warning);
}
}
}
private static void WriteAngle(NetworkWriter writer, float angle)
{
writer.Write(angle);
}
private static float ReadAngle(NetworkReader reader)
{
return reader.ReadSingle();
}
public static void SerializeRotation3D(NetworkWriter writer, Quaternion rot)
{
WriteAngle(writer, rot.eulerAngles.x);
WriteAngle(writer, rot.eulerAngles.y);
WriteAngle(writer, rot.eulerAngles.z);
}
public static Quaternion UnserializeRotation3D(NetworkReader reader)
{
var identity = Quaternion.identity;
var zero = Vector3.zero;
zero.Set(ReadAngle(reader), ReadAngle(reader), ReadAngle(reader));
identity.eulerAngles = zero;
return identity;
}
public override int GetNetworkChannel()
{
return 1;
}
public override float GetNetworkSendInterval()
{
return sendInterval;
}
}
}

6
QSB/TransformSync/SectorSync.cs
View File

@ -21,13 +21,13 @@ namespace QSB.TransformSync
{
return;
}
PlayerRegistry.GetSyncObjects<TransformSync>().Where(x => x.IsLocal).ToList().ForEach(CheckTransformSyncSector);
PlayerRegistry.GetSyncObjects<QSBTransformSync>().Where(x => x.IsLocal).ToList().ForEach(CheckTransformSyncSector);
_checkTimer = 0;
}
private void CheckTransformSyncSector(TransformSync transformSync)
private void CheckTransformSyncSector(QSBTransformSync transformSync)
{
var syncedTransform = transformSync.SyncedTransform;
var syncedTransform = transformSync.AttachedObject;
if (syncedTransform == null || syncedTransform.position == Vector3.zero)
{
return;

2
QSB/TransformSync/ShipTransformSync.cs
View File

@ -2,7 +2,7 @@
namespace QSB.TransformSync
{
public class ShipTransformSync : TransformSync
public class ShipTransformSync : QSBTransformSync
{
public static ShipTransformSync LocalInstance { get; private set; }

127
QSB/TransformSync/TransformSync.cs
View File

@ -1,127 +0,0 @@
using OWML.Common;
using QSB.Utility;
using UnityEngine;
namespace QSB.TransformSync
{
public abstract class TransformSync : PlayerSyncObject
{
public abstract bool IsReady { get; }
protected abstract Transform InitLocalTransform();
protected abstract Transform InitRemoteTransform();
public Transform SyncedTransform { get; private set; }
public QSBSector ReferenceSector { get; set; }
private const float SmoothTime = 0.1f;
private bool _isInitialized;
private Vector3 _positionSmoothVelocity;
private Quaternion _rotationSmoothVelocity;
private bool _isVisible;
protected virtual void Awake()
{
PlayerRegistry.PlayerSyncObjects.Add(this);
DontDestroyOnLoad(gameObject);
QSBSceneManager.OnSceneLoaded += OnSceneLoaded;
}
private void OnSceneLoaded(OWScene scene, bool isInUniverse)
{
_isInitialized = false;
}
protected void Init()
{
ReferenceSector = QSBSectorManager.Instance.GetStartPlanetSector();
SyncedTransform = hasAuthority ? InitLocalTransform() : InitRemoteTransform();
if (!hasAuthority)
{
SyncedTransform.position = ReferenceSector.Position;
}
_isInitialized = true;
_isVisible = true;
}
private void Update()
{
if (!_isInitialized && IsReady)
{
Init();
}
else if (_isInitialized && !IsReady)
{
_isInitialized = false;
}
if (SyncedTransform == null || !_isInitialized)
{
return;
}
// Get which sector should be used as a reference point
if (ReferenceSector == null)
{
DebugLog.ToConsole($"Error - TransformSync with id {netId.Value} doesn't have a reference sector", MessageType.Error);
}
UpdateTransform();
}
protected virtual void UpdateTransform()
{
if (hasAuthority) // If this script is attached to the client's own body on the client's side.
{
if (ReferenceSector.Sector == null)
{
DebugLog.ToConsole($"Sector is null for referencesector for {GetType().Name}!", MessageType.Error);
}
transform.position = ReferenceSector.Transform.InverseTransformPoint(SyncedTransform.position);
transform.rotation = ReferenceSector.Transform.InverseTransformRotation(SyncedTransform.rotation);
return;
}
// If this script is attached to any other body, eg the representations of other players
if (SyncedTransform.position == Vector3.zero)
{
Hide();
}
else
{
Show();
}
SyncedTransform.localPosition = Vector3.SmoothDamp(SyncedTransform.localPosition, transform.position, ref _positionSmoothVelocity, SmoothTime);
SyncedTransform.localRotation = QuaternionHelper.SmoothDamp(SyncedTransform.localRotation, transform.rotation, ref _rotationSmoothVelocity, Time.deltaTime);
}
public void SetReferenceSector(QSBSector sector)
{
_positionSmoothVelocity = Vector3.zero;
ReferenceSector = sector;
SyncedTransform.SetParent(sector.Transform, true);
transform.position = sector.Transform.InverseTransformPoint(SyncedTransform.position);
transform.rotation = sector.Transform.InverseTransformRotation(SyncedTransform.rotation);
}
private void Show()
{
if (!_isVisible)
{
SyncedTransform.gameObject.Show();
_isVisible = true;
}
}
private void Hide()
{
if (_isVisible)
{
SyncedTransform.gameObject.Hide();
_isVisible = false;
}
}
}
}

1
QSB/WorldSync/WorldRegistry.cs
View File

@ -1,7 +1,6 @@
using QSB.TransformSync;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
namespace QSB.WorldSync
{

22
UnityProject/Assets/NetworkPlayer.prefab
View File

@ -20,7 +20,6 @@ GameObject:
m_Component:
- component: {fileID: 4562567225116386}
- component: {fileID: 114951036537616502}
- component: {fileID: 114833759961836714}
m_Layer: 0
m_Name: NetworkPlayer
m_TagString: Untagged
@ -41,27 +40,6 @@ Transform:
m_Father: {fileID: 0}
m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &114833759961836714
MonoBehaviour:
m_ObjectHideFlags: 1
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 100100000}
m_GameObject: {fileID: 1211347487444314}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: -1768714887, guid: dc443db3e92b4983b9738c1131f555cb, type: 3}
m_Name:
m_EditorClassIdentifier:
m_TransformSyncMode: 1
m_SendInterval: 0.09090909
m_SyncRotationAxis: 7
m_RotationSyncCompression: 0
m_SyncSpin: 0
m_MovementTheshold: 0.001
m_VelocityThreshold: 0.0001
m_SnapThreshold: 5
m_InterpolateRotation: 1
m_InterpolateMovement: 1
--- !u!114 &114951036537616502
MonoBehaviour:
m_ObjectHideFlags: 1