mirror of
https://github.com/misternebula/quantum-space-buddies.git
synced 2025-02-21 00:39:53 +00:00
Merge pull request #282 from misternebula/probe-sync-tweak
network transform rewrite aaaaaaa
This commit is contained in:
_nebula
GitHub
commit
88119389d0
@ -12,7 +12,6 @@ namespace QSB.Animation
|
||||
public class AnimationSync : PlayerSyncObject
|
||||
{
|
||||
private Animator _anim;
|
||||
private Animator _bodyAnim;
|
||||
private QNetworkAnimator _netAnim;
|
||||
|
||||
private RuntimeAnimatorController _suitedAnimController;
|
||||
@ -30,7 +29,7 @@ namespace QSB.Animation
|
||||
|
||||
public AnimatorMirror Mirror { get; private set; }
|
||||
public AnimationType CurrentType { get; set; }
|
||||
public Animator VisibleAnimator => _bodyAnim;
|
||||
public Animator VisibleAnimator { get; private set; }
|
||||
|
||||
protected void Awake()
|
||||
{
|
||||
@ -73,15 +72,15 @@ namespace QSB.Animation
|
||||
LoadControllers();
|
||||
}
|
||||
_netAnim.enabled = true;
|
||||
_bodyAnim = body.GetComponent<Animator>();
|
||||
VisibleAnimator = body.GetComponent<Animator>();
|
||||
Mirror = body.gameObject.AddComponent<AnimatorMirror>();
|
||||
if (IsLocalPlayer)
|
||||
{
|
||||
Mirror.Init(_bodyAnim, _anim);
|
||||
Mirror.Init(VisibleAnimator, _anim);
|
||||
}
|
||||
else
|
||||
{
|
||||
Mirror.Init(_anim, _bodyAnim);
|
||||
Mirror.Init(_anim, VisibleAnimator);
|
||||
}
|
||||
|
||||
for (var i = 0; i < _anim.parameterCount; i++)
|
||||
@ -138,7 +137,7 @@ namespace QSB.Animation
|
||||
private void InitCrouchSync()
|
||||
{
|
||||
_crouchSync = gameObject.AddComponent<CrouchSync>();
|
||||
_crouchSync.Init(this, _playerController, _bodyAnim);
|
||||
_crouchSync.Init(this, _playerController, VisibleAnimator);
|
||||
}
|
||||
|
||||
private void OnJump() => _netAnim.SetTrigger("Jump");
|
||||
@ -228,16 +227,16 @@ namespace QSB.Animation
|
||||
break;
|
||||
}
|
||||
_anim.runtimeAnimatorController = controller;
|
||||
_bodyAnim.runtimeAnimatorController = controller;
|
||||
VisibleAnimator.runtimeAnimatorController = controller;
|
||||
if (type != AnimationType.PlayerSuited && type != AnimationType.PlayerUnsuited)
|
||||
{
|
||||
_bodyAnim.SetTrigger("Playing");
|
||||
VisibleAnimator.SetTrigger("Playing");
|
||||
_anim.SetTrigger("Playing");
|
||||
}
|
||||
else
|
||||
{
|
||||
// Avoids "jumping" when exiting instrument and putting on suit
|
||||
_bodyAnim.SetTrigger("Grounded");
|
||||
VisibleAnimator.SetTrigger("Grounded");
|
||||
_anim.SetTrigger("Grounded");
|
||||
}
|
||||
_netAnim.animator = _anim; // Probably not needed.
|
||||
|
||||
@ -28,7 +28,6 @@
|
||||
public static string QSBPlayerDeath = "QSBPlayerDeath";
|
||||
public static string QSBPlayerJoin = "QSBPlayerJoin";
|
||||
public static string QSBPlayerReady = "QSBPlayerReady";
|
||||
public static string QSBSectorChange = "QSBSectorChange";
|
||||
public static string QSBPlayerStatesRequest = "QSBPlayerStatesRequest";
|
||||
public static string QSBServerTime = "QSBServerTime";
|
||||
public static string QSBStartLift = "QSBStartLift";
|
||||
|
||||
@ -13,7 +13,6 @@
|
||||
SuitActiveChange,
|
||||
PlayerJoin,
|
||||
PlayerDeath,
|
||||
PlayerSectorChange,
|
||||
PlayerReady,
|
||||
ProbeActiveChange,
|
||||
Elevator,
|
||||
|
||||
@ -41,7 +41,6 @@ namespace QSB.Events
|
||||
new PlayerTranslatorEvent(),
|
||||
new PlayerProbeLauncherEvent(),
|
||||
new PlayerProbeEvent(),
|
||||
new PlayerSectorEvent(),
|
||||
new PlayerDeathEvent(),
|
||||
new PlayerStatesRequestEvent(),
|
||||
new ServerSendPlayerStatesEvent(),
|
||||
|
||||
@ -38,7 +38,7 @@ namespace QSB.Instruments.QSBCamera
|
||||
_cameraObj.transform.localPosition = new Vector3(0, 0, -5f);
|
||||
_cameraObj.transform.localRotation = Quaternion.Euler(0, 0, 0);
|
||||
_camera = _cameraObj.AddComponent<Camera>();
|
||||
_camera.cullingMask = Locator.GetPlayerCamera().mainCamera.cullingMask & ~(1 << 27) | (1 << 22);
|
||||
_camera.cullingMask = (Locator.GetPlayerCamera().mainCamera.cullingMask & ~(1 << 27)) | (1 << 22);
|
||||
_camera.clearFlags = CameraClearFlags.Color;
|
||||
_camera.backgroundColor = Color.black;
|
||||
_camera.fieldOfView = 90f;
|
||||
|
||||
@ -1,46 +0,0 @@
|
||||
using OWML.Common;
|
||||
using QSB.Events;
|
||||
using QSB.SectorSync.WorldObjects;
|
||||
using QSB.TransformSync;
|
||||
using QSB.Utility;
|
||||
using QSB.WorldSync;
|
||||
using QSB.WorldSync.Events;
|
||||
|
||||
namespace QSB.Player.Events
|
||||
{
|
||||
public class PlayerSectorEvent : QSBEvent<WorldObjectMessage>
|
||||
{
|
||||
public override EventType Type => EventType.PlayerSectorChange;
|
||||
|
||||
public override void SetupListener() => GlobalMessenger<uint, QSBSector>.AddListener(EventNames.QSBSectorChange, Handler);
|
||||
public override void CloseListener() => GlobalMessenger<uint, QSBSector>.RemoveListener(EventNames.QSBSectorChange, Handler);
|
||||
|
||||
private void Handler(uint netId, QSBSector sector) => SendEvent(CreateMessage(netId, sector));
|
||||
|
||||
private WorldObjectMessage CreateMessage(uint netId, QSBSector sector) => new WorldObjectMessage
|
||||
{
|
||||
AboutId = netId,
|
||||
ObjectId = sector.ObjectId
|
||||
};
|
||||
|
||||
public override void OnReceiveRemote(bool server, WorldObjectMessage message)
|
||||
{
|
||||
if (!QSBSceneManager.IsInUniverse)
|
||||
{
|
||||
return;
|
||||
}
|
||||
var sector = QSBWorldSync.GetWorldFromId<QSBSector>(message.ObjectId);
|
||||
|
||||
if (sector == null)
|
||||
{
|
||||
DebugLog.ToConsole($"Sector with index id {message.ObjectId} not found!", MessageType.Warning);
|
||||
return;
|
||||
}
|
||||
|
||||
var transformSync = QSBPlayerManager.GetSyncObject<SyncObjectTransformSync>(message.AboutId);
|
||||
|
||||
QSBCore.UnityEvents.RunWhen(() => transformSync?.SyncedTransform != null,
|
||||
() => transformSync?.SetReferenceSector(sector));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -3,7 +3,6 @@ using QSB.CampfireSync.WorldObjects;
|
||||
using QSB.Events;
|
||||
using QSB.Messaging;
|
||||
using QSB.QuantumSync;
|
||||
using QSB.TransformSync;
|
||||
using QSB.TranslationSync;
|
||||
using QSB.TranslationSync.WorldObjects;
|
||||
using QSB.Utility;
|
||||
@ -31,11 +30,6 @@ namespace QSB.Player.Events
|
||||
{
|
||||
DebugLog.DebugWrite($"Get state request from {message.FromId} - isServer?{server}");
|
||||
QSBEventManager.FireEvent(EventNames.QSBServerSendPlayerStates);
|
||||
foreach (var item in QSBPlayerManager.GetSyncObjects<SyncObjectTransformSync>()
|
||||
.Where(x => x != null && x.IsReady && x.ReferenceSector != null))
|
||||
{
|
||||
QSBEventManager.FireEvent(EventNames.QSBSectorChange, item.NetId.Value, item.ReferenceSector);
|
||||
}
|
||||
|
||||
if (!server)
|
||||
{
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
using OWML.Common;
|
||||
using QSB.Events;
|
||||
using QSB.TransformSync;
|
||||
using QSB.Utility;
|
||||
|
||||
namespace QSB.Player.Events
|
||||
@ -31,9 +30,10 @@ namespace QSB.Player.Events
|
||||
public override void OnReceiveRemote(bool server, PlayerStateMessage message)
|
||||
{
|
||||
DebugLog.DebugWrite($"Received playerstate of player ID {message.AboutId}", MessageType.Info);
|
||||
QSBCore.UnityEvents.RunWhen(
|
||||
() => QSBPlayerManager.GetSyncObject<SyncObjectTransformSync>(message.AboutId) != null,
|
||||
() => QSBPlayerManager.HandleFullStateMessage(message));
|
||||
if (QSBPlayerManager.PlayerExists(message.AboutId))
|
||||
{
|
||||
QSBPlayerManager.HandleFullStateMessage(message);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,5 +1,6 @@
|
||||
using QSB.Animation;
|
||||
using QSB.CampfireSync.WorldObjects;
|
||||
using QSB.Player.TransformSync;
|
||||
using QSB.ProbeSync;
|
||||
using QSB.QuantumSync;
|
||||
using QSB.RoastingSync;
|
||||
@ -15,6 +16,7 @@ namespace QSB.Player
|
||||
public string Name { get; set; }
|
||||
public PlayerHUDMarker HudMarker { get; set; }
|
||||
public PlayerState PlayerStates { get; set; } = new PlayerState();
|
||||
public PlayerTransformSync TransformSync { get; set; }
|
||||
|
||||
// Body Objects
|
||||
public OWCamera Camera { get; set; }
|
||||
|
||||
@ -6,9 +6,9 @@ using UnityEngine;
|
||||
|
||||
namespace QSB.Player.TransformSync
|
||||
{
|
||||
public class PlayerCameraSync : SyncObjectTransformSync
|
||||
public class PlayerCameraSync : QSBNetworkTransform
|
||||
{
|
||||
protected override Transform InitLocalTransform()
|
||||
protected override GameObject InitLocalTransform()
|
||||
{
|
||||
SectorSync.SetSectorDetector(Locator.GetPlayerSectorDetector());
|
||||
var body = Locator.GetPlayerCamera().gameObject.transform;
|
||||
@ -21,10 +21,10 @@ namespace QSB.Player.TransformSync
|
||||
DebugLog.DebugWrite("PlayerCameraSync init done - Request state!");
|
||||
QSBEventManager.FireEvent(EventNames.QSBPlayerStatesRequest);
|
||||
|
||||
return body;
|
||||
return body.gameObject;
|
||||
}
|
||||
|
||||
protected override Transform InitRemoteTransform()
|
||||
protected override GameObject InitRemoteTransform()
|
||||
{
|
||||
var body = new GameObject("RemotePlayerCamera");
|
||||
|
||||
@ -39,16 +39,7 @@ namespace QSB.Player.TransformSync
|
||||
Player.Camera = owcamera;
|
||||
Player.CameraBody = body;
|
||||
|
||||
return body.transform;
|
||||
}
|
||||
|
||||
private void OnRenderObject()
|
||||
{
|
||||
if (!QSBCore.HasWokenUp || !Player.PlayerStates.IsReady || !QSBCore.DebugMode || !QSBCore.ShowLinesInDebug)
|
||||
{
|
||||
return;
|
||||
}
|
||||
Popcron.Gizmos.Frustum(Player.Camera);
|
||||
return body;
|
||||
}
|
||||
|
||||
public override bool IsReady => Locator.GetPlayerTransform() != null
|
||||
|
||||
@ -5,7 +5,7 @@ using UnityEngine;
|
||||
|
||||
namespace QSB.Player.TransformSync
|
||||
{
|
||||
public class PlayerTransformSync : SyncObjectTransformSync
|
||||
public class PlayerTransformSync : QSBNetworkTransform
|
||||
{
|
||||
public static PlayerTransformSync LocalInstance { get; private set; }
|
||||
|
||||
@ -14,10 +14,15 @@ namespace QSB.Player.TransformSync
|
||||
public override void OnStartLocalPlayer()
|
||||
=> LocalInstance = this;
|
||||
|
||||
protected override void OnDestroy()
|
||||
public override void Start()
|
||||
{
|
||||
base.Start();
|
||||
Player.TransformSync = this;
|
||||
}
|
||||
|
||||
protected void OnDestroy()
|
||||
{
|
||||
QSBPlayerManager.OnRemovePlayer?.Invoke(PlayerId);
|
||||
base.OnDestroy();
|
||||
if (QSBPlayerManager.PlayerExists(PlayerId))
|
||||
{
|
||||
Player.HudMarker?.Remove();
|
||||
@ -28,7 +33,7 @@ namespace QSB.Player.TransformSync
|
||||
private Transform GetPlayerModel() =>
|
||||
Locator.GetPlayerTransform().Find("Traveller_HEA_Player_v2");
|
||||
|
||||
protected override Transform InitLocalTransform()
|
||||
protected override GameObject InitLocalTransform()
|
||||
{
|
||||
SectorSync.SetSectorDetector(Locator.GetPlayerSectorDetector());
|
||||
var body = GetPlayerModel();
|
||||
@ -38,10 +43,10 @@ namespace QSB.Player.TransformSync
|
||||
|
||||
Player.Body = body.gameObject;
|
||||
|
||||
return body;
|
||||
return body.gameObject;
|
||||
}
|
||||
|
||||
protected override Transform InitRemoteTransform()
|
||||
protected override GameObject InitRemoteTransform()
|
||||
{
|
||||
var body = Instantiate(GetPlayerModel());
|
||||
|
||||
@ -55,17 +60,7 @@ namespace QSB.Player.TransformSync
|
||||
|
||||
Player.Body = body.gameObject;
|
||||
|
||||
return body;
|
||||
}
|
||||
|
||||
private void OnRenderObject()
|
||||
{
|
||||
if (!QSBCore.HasWokenUp || !Player.PlayerStates.IsReady || !QSBCore.DebugMode || !QSBCore.ShowLinesInDebug)
|
||||
{
|
||||
return;
|
||||
}
|
||||
Popcron.Gizmos.Line(ReferenceSector.Position, Player.Body.transform.position, Color.blue, true);
|
||||
Popcron.Gizmos.Sphere(ReferenceSector.Position, 5f, Color.cyan);
|
||||
return body.gameObject;
|
||||
}
|
||||
|
||||
public override bool IsReady => Locator.GetPlayerTransform() != null
|
||||
|
||||
@ -7,25 +7,29 @@ using UnityEngine;
|
||||
|
||||
namespace QSB.ProbeSync.TransformSync
|
||||
{
|
||||
public class PlayerProbeSync : SyncObjectTransformSync
|
||||
public class PlayerProbeSync : QSBNetworkTransform
|
||||
{
|
||||
private Transform _disabledSocket;
|
||||
public static PlayerProbeSync LocalInstance { get; private set; }
|
||||
|
||||
protected override float DistanceLeeway => 10f;
|
||||
|
||||
public override void OnStartAuthority()
|
||||
=> LocalInstance = this;
|
||||
|
||||
private Transform GetProbe() =>
|
||||
Locator.GetProbe().transform.Find("CameraPivot").Find("Geometry");
|
||||
|
||||
protected override Transform InitLocalTransform()
|
||||
protected override GameObject InitLocalTransform()
|
||||
{
|
||||
SectorSync.SetSectorDetector(Locator.GetProbe().GetSectorDetector());
|
||||
var body = GetProbe();
|
||||
|
||||
SetSocket(Player.CameraBody.transform);
|
||||
Player.ProbeBody = body.gameObject;
|
||||
|
||||
return body;
|
||||
return body.gameObject;
|
||||
}
|
||||
|
||||
protected override Transform InitRemoteTransform()
|
||||
protected override GameObject InitRemoteTransform()
|
||||
{
|
||||
var probe = GetProbe();
|
||||
|
||||
@ -42,51 +46,11 @@ namespace QSB.ProbeSync.TransformSync
|
||||
|
||||
PlayerToolsManager.CreateProbe(body, Player);
|
||||
|
||||
QSBCore.UnityEvents.RunWhen(
|
||||
() => Player.ProbeLauncher != null,
|
||||
() => SetSocket(Player.ProbeLauncher.ToolGameObject.transform));
|
||||
Player.ProbeBody = body.gameObject;
|
||||
|
||||
return body;
|
||||
return body.gameObject;
|
||||
}
|
||||
|
||||
private void SetSocket(Transform socket)
|
||||
{
|
||||
DebugLog.DebugWrite($"Set DisabledSocket of id:{PlayerId}.");
|
||||
_disabledSocket = socket;
|
||||
}
|
||||
|
||||
/*
|
||||
protected override void UpdateTransform()
|
||||
{
|
||||
base.UpdateTransform();
|
||||
if (Player == null)
|
||||
{
|
||||
DebugLog.ToConsole($"Player is null for {AttachedNetId}!", MessageType.Error);
|
||||
return;
|
||||
}
|
||||
if (_disabledSocket == null)
|
||||
{
|
||||
DebugLog.ToConsole($"DisabledSocket is null for {PlayerId}! (ProbeLauncher null? : {Player.ProbeLauncher == null})", MessageType.Error);
|
||||
return;
|
||||
}
|
||||
if (Player.PlayerStates.ProbeActive || ReferenceSector?.AttachedObject == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if (HasAuthority)
|
||||
{
|
||||
transform.position = ReferenceSector.Transform.InverseTransformPoint(_disabledSocket.position);
|
||||
return;
|
||||
}
|
||||
if (SyncedTransform.position == Vector3.zero)
|
||||
{
|
||||
return;
|
||||
}
|
||||
SyncedTransform.localPosition = ReferenceSector.Transform.InverseTransformPoint(_disabledSocket.position);
|
||||
}
|
||||
*/
|
||||
|
||||
public override bool IsReady => Locator.GetProbe() != null
|
||||
&& Player != null
|
||||
&& QSBPlayerManager.PlayerExists(Player.PlayerId)
|
||||
|
||||
@ -231,6 +231,7 @@
|
||||
<Compile Include="StatueSync\Patches\StatuePatches.cs" />
|
||||
<Compile Include="StatueSync\StatueManager.cs" />
|
||||
<Compile Include="RoastingSync\TransformSync\RoastingStickTransformSync.cs" />
|
||||
<Compile Include="TransformSync\QSBNetworkTransform.cs" />
|
||||
<Compile Include="TranslationSync\Events\SetAsTranslatedEvent.cs" />
|
||||
<Compile Include="TranslationSync\Events\SetAsTranslatedMessage.cs" />
|
||||
<Compile Include="TranslationSync\NomaiTextType.cs" />
|
||||
@ -247,7 +248,6 @@
|
||||
<Compile Include="ProbeSync\Events\PlayerProbeEvent.cs" />
|
||||
<Compile Include="Player\Events\PlayerReadyEvent.cs" />
|
||||
<Compile Include="OrbSync\TransformSync\NomaiOrbTransformSync.cs" />
|
||||
<Compile Include="Player\Events\PlayerSectorEvent.cs" />
|
||||
<Compile Include="Player\Events\PlayerStatesRequestEvent.cs" />
|
||||
<Compile Include="Animation\Events\PlayerSuitEvent.cs" />
|
||||
<Compile Include="TimeSync\Events\ServerTimeEvent.cs" />
|
||||
@ -262,7 +262,6 @@
|
||||
<Compile Include="Messaging\ToggleMessage.cs" />
|
||||
<Compile Include="SectorSync\WorldObjects\QSBSector.cs" />
|
||||
<Compile Include="SectorSync\SectorSync.cs" />
|
||||
<Compile Include="TransformSync\SyncObjectTransformSync.cs" />
|
||||
<Compile Include="Utility\CustomCallbacks.cs" />
|
||||
<Compile Include="Utility\DebugBoxManager.cs" />
|
||||
<Compile Include="Utility\DebugZOverride.cs" />
|
||||
|
||||
@ -11,6 +11,7 @@ using QSB.Patches;
|
||||
using QSB.Player;
|
||||
using QSB.Player.TransformSync;
|
||||
using QSB.PoolSync;
|
||||
using QSB.ProbeSync.TransformSync;
|
||||
using QSB.QuantumSync;
|
||||
using QSB.QuantumSync.WorldObjects;
|
||||
using QSB.SectorSync;
|
||||
@ -146,13 +147,9 @@ namespace QSB
|
||||
}
|
||||
|
||||
var offset3 = 10f;
|
||||
GUI.Label(new Rect(420, offset3, 200f, 20f), $"Current synced sector :");
|
||||
GUI.Label(new Rect(420, offset3, 400f, 20f), $"Current sector : {PlayerTransformSync.LocalInstance.ReferenceSector.Name}");
|
||||
offset3 += _debugLineSpacing;
|
||||
var sector = PlayerTransformSync.LocalInstance.ReferenceSector;
|
||||
var text = sector == null
|
||||
? "NULL SECTOR"
|
||||
: $"{sector.AttachedObject.name} : {sector.IsFakeSector}";
|
||||
GUI.Label(new Rect(420, offset3, 400f, 20f), $"- {text}");
|
||||
GUI.Label(new Rect(420, offset3, 400f, 20f), $"Probe sector : {PlayerProbeSync.LocalInstance.ReferenceSector.Name}");
|
||||
offset3 += _debugLineSpacing;
|
||||
|
||||
var offset2 = 10f;
|
||||
@ -169,16 +166,14 @@ namespace QSB
|
||||
return;
|
||||
}
|
||||
|
||||
GUI.Label(new Rect(220, offset, 200f, 20f), $"QM Illuminated : {Locator.GetQuantumMoon().IsIlluminated()}");
|
||||
GUI.Label(new Rect(220, offset, 200f, 20f), $"Probe Active : {Locator.GetProbe().gameObject.activeInHierarchy}");
|
||||
offset += _debugLineSpacing;
|
||||
GUI.Label(new Rect(220, offset, 200f, 20f), $"Shrine player in dark? : {QuantumManager.Instance.Shrine.IsPlayerInDarkness()}");
|
||||
GUI.Label(new Rect(220, offset, 200f, 20f), $"Player positions :");
|
||||
offset += _debugLineSpacing;
|
||||
GUI.Label(new Rect(220, offset, 200f, 20f), $"QM Visible by :");
|
||||
offset += _debugLineSpacing;
|
||||
var tracker = Locator.GetQuantumMoon().GetValue<ShapeVisibilityTracker>("_visibilityTracker");
|
||||
foreach (var player in QSBPlayerManager.GetPlayersWithCameras())
|
||||
foreach (var player in QSBPlayerManager.PlayerList.Where(x => x.PlayerStates.IsReady))
|
||||
{
|
||||
GUI.Label(new Rect(220, offset, 200f, 20f), $" - {player.PlayerId} : {tracker.GetType().GetMethod("IsInFrustum", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(tracker, new object[] { player.Camera.GetFrustumPlanes() })}");
|
||||
var networkTransform = player.TransformSync;
|
||||
GUI.Label(new Rect(220, offset, 400f, 20f), $"- {player.PlayerId} : {networkTransform.transform.localPosition} from {networkTransform.ReferenceSector.Name}");
|
||||
offset += _debugLineSpacing;
|
||||
}
|
||||
|
||||
|
||||
@ -104,8 +104,6 @@ namespace QSB
|
||||
|
||||
private void SetupNetworkTransform(GameObject go)
|
||||
{
|
||||
var trans = go.AddComponent<QNetworkTransform>();
|
||||
trans.SyncRotationAxis = QNetworkTransform.AxisSyncMode.AxisXYZ;
|
||||
foreach (var item in go.GetComponents<NetworkTransformChild>())
|
||||
{
|
||||
var child = go.AddComponent<QNetworkTransformChild>();
|
||||
|
||||
@ -1,13 +1,12 @@
|
||||
using OWML.Utils;
|
||||
using QSB.Player;
|
||||
using QSB.TransformSync;
|
||||
using QSB.Utility;
|
||||
using System.Linq;
|
||||
using UnityEngine;
|
||||
|
||||
namespace QSB.RoastingSync.TransformSync
|
||||
{
|
||||
internal class RoastingStickTransformSync : SyncObjectTransformSync
|
||||
internal class RoastingStickTransformSync : QSBNetworkTransform
|
||||
{
|
||||
private Transform _stickTip;
|
||||
private Transform _networkStickTip => gameObject.transform.GetChild(0);
|
||||
@ -18,15 +17,15 @@ namespace QSB.RoastingSync.TransformSync
|
||||
private Transform GetPivot()
|
||||
=> Resources.FindObjectsOfTypeAll<RoastingStickController>().First().transform.Find("Stick_Root/Stick_Pivot");
|
||||
|
||||
protected override Transform InitLocalTransform()
|
||||
protected override GameObject InitLocalTransform()
|
||||
{
|
||||
var pivot = GetPivot();
|
||||
Player.RoastingStick = pivot.gameObject;
|
||||
_stickTip = pivot.Find("Stick_Tip");
|
||||
return pivot;
|
||||
return pivot.gameObject;
|
||||
}
|
||||
|
||||
protected override Transform InitRemoteTransform()
|
||||
protected override GameObject InitRemoteTransform()
|
||||
{
|
||||
var newPivot = Instantiate(GetPivot());
|
||||
newPivot.parent = null;
|
||||
@ -56,9 +55,10 @@ namespace QSB.RoastingSync.TransformSync
|
||||
Player.Marshmallow = newMarshmallow;
|
||||
mallowRoot.gameObject.SetActive(true);
|
||||
_stickTip = newPivot.Find("Stick_Tip");
|
||||
return newPivot;
|
||||
return newPivot.gameObject;
|
||||
}
|
||||
|
||||
/*
|
||||
protected override void UpdateTransform()
|
||||
{
|
||||
base.UpdateTransform();
|
||||
@ -78,6 +78,7 @@ namespace QSB.RoastingSync.TransformSync
|
||||
_stickTip.localPosition = Vector3.SmoothDamp(_stickTip.localPosition, _networkStickTip.localPosition, ref _positionSmoothVelocity, SmoothTime);
|
||||
_stickTip.localRotation = QuaternionHelper.SmoothDamp(_stickTip.localRotation, _networkStickTip.localRotation, ref _rotationSmoothVelocity, SmoothTime);
|
||||
}
|
||||
*/
|
||||
|
||||
public override bool IsReady => Locator.GetPlayerTransform() != null
|
||||
&& Player != null
|
||||
|
||||
@ -1,7 +1,6 @@
|
||||
using OWML.Common;
|
||||
using QSB.Events;
|
||||
using QSB.Player;
|
||||
using QSB.SectorSync.WorldObjects;
|
||||
using QSB.TransformSync;
|
||||
using QSB.Utility;
|
||||
using QSB.WorldSync;
|
||||
using System.Collections.Generic;
|
||||
@ -21,8 +20,17 @@ namespace QSB.SectorSync
|
||||
|
||||
public void Invoke()
|
||||
{
|
||||
QSBPlayerManager.GetSyncObjects<TransformSync.SyncObjectTransformSync>()
|
||||
.Where(x => x.HasAuthority).ToList().ForEach(CheckTransformSyncSector);
|
||||
foreach (var sync in Resources.FindObjectsOfTypeAll<QSBNetworkTransform>()) // todo : cache these!
|
||||
{
|
||||
if (sync.AttachedObject == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (sync.HasAuthority && sync.AttachedObject.activeInHierarchy)
|
||||
{
|
||||
CheckTransformSyncSector(sync);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public override void Awake()
|
||||
@ -54,14 +62,14 @@ namespace QSB.SectorSync
|
||||
IsReady = QSBWorldSync.GetWorldObjects<QSBSector>().Any();
|
||||
}
|
||||
|
||||
private void CheckTransformSyncSector(TransformSync.SyncObjectTransformSync transformSync)
|
||||
private void CheckTransformSyncSector(QSBNetworkTransform transformSync)
|
||||
{
|
||||
var syncedTransform = transformSync.SyncedTransform;
|
||||
if (syncedTransform == null || syncedTransform.position == Vector3.zero)
|
||||
var syncedTransform = transformSync.AttachedObject;
|
||||
if (syncedTransform == null || syncedTransform.transform.position == Vector3.zero)
|
||||
{
|
||||
return;
|
||||
}
|
||||
var closestSector = transformSync.SectorSync.GetClosestSector(syncedTransform);
|
||||
var closestSector = transformSync.SectorSync.GetClosestSector(syncedTransform.transform);
|
||||
if (closestSector == default(QSBSector))
|
||||
{
|
||||
return;
|
||||
@ -71,10 +79,6 @@ namespace QSB.SectorSync
|
||||
return;
|
||||
}
|
||||
transformSync.SetReferenceSector(closestSector);
|
||||
SendSector(transformSync.NetId.Value, closestSector);
|
||||
}
|
||||
|
||||
private void SendSector(uint id, QSBSector sector) =>
|
||||
QSBEventManager.FireEvent(EventNames.QSBSectorChange, id, sector);
|
||||
}
|
||||
}
|
||||
@ -1,4 +1,5 @@
|
||||
using OWML.Common;
|
||||
using OWML.Utils;
|
||||
using QSB.SectorSync.WorldObjects;
|
||||
using QSB.Utility;
|
||||
using QSB.WorldSync;
|
||||
@ -12,6 +13,7 @@ namespace QSB.SectorSync
|
||||
{
|
||||
public List<QSBSector> SectorList = new List<QSBSector>();
|
||||
|
||||
private OWRigidbody _attachedOWRigidbody;
|
||||
private SectorDetector _sectorDetector;
|
||||
|
||||
private void OnDestroy()
|
||||
@ -33,6 +35,12 @@ namespace QSB.SectorSync
|
||||
_sectorDetector = detector;
|
||||
_sectorDetector.OnEnterSector += AddSector;
|
||||
_sectorDetector.OnExitSector += RemoveSector;
|
||||
|
||||
_attachedOWRigidbody = _sectorDetector.GetValue<OWRigidbody>("_attachedRigidbody");
|
||||
if (_attachedOWRigidbody == null)
|
||||
{
|
||||
DebugLog.ToConsole($"Warning - OWRigidbody for {_sectorDetector.name} is null!", MessageType.Warning);
|
||||
}
|
||||
}
|
||||
|
||||
private void AddSector(Sector sector)
|
||||
@ -94,9 +102,12 @@ namespace QSB.SectorSync
|
||||
{
|
||||
return default;
|
||||
}
|
||||
//var ordered = activeNotNullNotBlacklisted
|
||||
//.OrderBy(sector => Vector3.Distance(sector.Position, trans.position))
|
||||
//.ThenBy(sector => GetRelativeVelocity(sector, _attachedOWRigidbody))
|
||||
//.ThenBy(sector => GetRadius(sector));
|
||||
var ordered = activeNotNullNotBlacklisted
|
||||
.OrderBy(sector => Vector3.Distance(sector.Position, trans.position))
|
||||
.ThenBy(sector => GetRadius(sector));
|
||||
.OrderBy(sector => CalculateSectorScore(sector, trans, _attachedOWRigidbody));
|
||||
|
||||
if (
|
||||
// if any fake sectors are *roughly* in the same place as other sectors - we want fake sectors to override other sectors
|
||||
@ -111,7 +122,16 @@ namespace QSB.SectorSync
|
||||
return ordered.FirstOrDefault();
|
||||
}
|
||||
|
||||
private float GetRadius(QSBSector sector)
|
||||
public static float CalculateSectorScore(QSBSector sector, Transform trans, OWRigidbody rigidbody)
|
||||
{
|
||||
var distance = Vector3.Distance(sector.Position, trans.position); // want to be small
|
||||
var radius = GetRadius(sector); // want to be small
|
||||
var velocity = GetRelativeVelocity(sector, rigidbody); // want to be small
|
||||
|
||||
return (distance * distance) + (radius * radius) + (velocity * velocity);
|
||||
}
|
||||
|
||||
public static float GetRadius(QSBSector sector)
|
||||
{
|
||||
if (sector == null)
|
||||
{
|
||||
@ -128,5 +148,17 @@ namespace QSB.SectorSync
|
||||
}
|
||||
return 0f;
|
||||
}
|
||||
|
||||
public static float GetRelativeVelocity(QSBSector sector, OWRigidbody rigidbody)
|
||||
{
|
||||
var sectorRigidBody = sector.AttachedObject.GetOWRigidbody();
|
||||
if (sectorRigidBody != null && rigidbody != null)
|
||||
{
|
||||
var relativeVelocity = sectorRigidBody.GetRelativeVelocity(rigidbody);
|
||||
var relativeVelocityMagnitude = relativeVelocity.sqrMagnitude; // Remember this is squared for efficiency!
|
||||
return relativeVelocityMagnitude;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -49,6 +49,7 @@ namespace QSB.SectorSync.WorldObjects
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (AttachedObject.name == "Sector_Shuttle" || AttachedObject.name == "Sector_NomaiShuttleInterior")
|
||||
{
|
||||
if (QSBSceneManager.CurrentScene == OWScene.SolarSystem)
|
||||
|
||||
@ -4,17 +4,19 @@ using UnityEngine;
|
||||
|
||||
namespace QSB.ShipSync.TransformSync
|
||||
{
|
||||
public class ShipTransformSync : SyncObjectTransformSync
|
||||
public class ShipTransformSync : QSBNetworkTransform
|
||||
{
|
||||
protected override float DistanceLeeway => 20f;
|
||||
|
||||
private Transform GetShipModel() => Locator.GetShipTransform();
|
||||
|
||||
protected override Transform InitLocalTransform()
|
||||
protected override GameObject InitLocalTransform()
|
||||
{
|
||||
SectorSync.SetSectorDetector(Locator.GetShipDetector().GetComponent<SectorDetector>());
|
||||
return GetShipModel().Find("Module_Cockpit/Geo_Cockpit/Cockpit_Geometry/Cockpit_Exterior");
|
||||
return GetShipModel().Find("Module_Cockpit/Geo_Cockpit/Cockpit_Geometry/Cockpit_Exterior").gameObject;
|
||||
}
|
||||
|
||||
protected override Transform InitRemoteTransform()
|
||||
protected override GameObject InitRemoteTransform()
|
||||
{
|
||||
var shipModel = GetShipModel();
|
||||
|
||||
@ -39,7 +41,7 @@ namespace QSB.ShipSync.TransformSync
|
||||
= landingGearRight.localPosition
|
||||
+= Vector3.up * 3.762f;
|
||||
|
||||
return remoteTransform;
|
||||
return remoteTransform.gameObject;
|
||||
}
|
||||
|
||||
public override bool IsReady => GetShipModel() != null
|
||||
|
||||
201
QSB/TransformSync/QSBNetworkTransform.cs
Normal file
201
QSB/TransformSync/QSBNetworkTransform.cs
Normal file
@ -0,0 +1,201 @@
|
||||
using OWML.Common;
|
||||
using QSB.Player;
|
||||
using QSB.Player.TransformSync;
|
||||
using QSB.SectorSync.WorldObjects;
|
||||
using QSB.Utility;
|
||||
using QSB.WorldSync;
|
||||
using QuantumUNET.Components;
|
||||
using QuantumUNET.Transport;
|
||||
using System.Linq;
|
||||
using UnityEngine;
|
||||
|
||||
namespace QSB.TransformSync
|
||||
{
|
||||
public abstract class QSBNetworkTransform : 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 QSBSector ReferenceSector { get; set; }
|
||||
public GameObject AttachedObject { get; set; }
|
||||
public SectorSync.SectorSync SectorSync { get; private 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;
|
||||
|
||||
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);
|
||||
|
||||
SectorSync = gameObject.AddComponent<SectorSync.SectorSync>();
|
||||
|
||||
DontDestroyOnLoad(gameObject);
|
||||
}
|
||||
|
||||
protected void Init()
|
||||
{
|
||||
AttachedObject = HasAuthority ? InitLocalTransform() : InitRemoteTransform();
|
||||
SetReferenceSector(SectorSync.GetClosestSector(AttachedObject.transform));
|
||||
_isInitialized = true;
|
||||
}
|
||||
|
||||
public override void SerializeTransform(QNetworkWriter writer)
|
||||
{
|
||||
if (ReferenceSector != null)
|
||||
{
|
||||
writer.Write(ReferenceSector.ObjectId);
|
||||
}
|
||||
else
|
||||
{
|
||||
writer.Write(-1);
|
||||
}
|
||||
|
||||
writer.Write(transform.localPosition);
|
||||
SerializeRotation(writer, transform.localRotation);
|
||||
_prevPosition = transform.localPosition;
|
||||
_prevRotation = transform.localRotation;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
var localPosition = reader.ReadVector3();
|
||||
var localRotation = DeserializeRotation(reader);
|
||||
|
||||
if (HasAuthority)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
transform.localPosition = localPosition;
|
||||
transform.localRotation = localRotation;
|
||||
|
||||
if (transform.position == Vector3.zero)
|
||||
{
|
||||
DebugLog.ToConsole($"Warning - {PlayerId}.{GetType().Name} at (0,0,0)! - Given localPosition was {localPosition} at sector {sector?.Name}", MessageType.Warning);
|
||||
}
|
||||
}
|
||||
|
||||
public override void Update()
|
||||
{
|
||||
if (!_isInitialized && IsReady)
|
||||
{
|
||||
DebugLog.ToConsole($"Warning - {PlayerId}.{GetType().Name} is not initialized and ready.", MessageType.Warning);
|
||||
Init();
|
||||
}
|
||||
else if (_isInitialized && !IsReady)
|
||||
{
|
||||
DebugLog.ToConsole($"Warning - {PlayerId}.{GetType().Name} is initialized and not ready.", MessageType.Warning);
|
||||
_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)
|
||||
{
|
||||
transform.position = AttachedObject.transform.position;
|
||||
transform.rotation = AttachedObject.transform.rotation;
|
||||
}
|
||||
else
|
||||
{
|
||||
AttachedObject.transform.localPosition = SmartSmoothDamp(AttachedObject.transform.localPosition, transform.localPosition);
|
||||
AttachedObject.transform.localRotation = QuaternionHelper.SmoothDamp(AttachedObject.transform.localRotation, transform.localRotation, ref _rotationSmoothVelocity, SmoothTime);
|
||||
}
|
||||
}
|
||||
|
||||
public override bool HasMoved()
|
||||
{
|
||||
var displacementMagnitude = (transform.localPosition - _prevPosition).magnitude;
|
||||
return displacementMagnitude > 1E-05f
|
||||
|| Quaternion.Angle(transform.localRotation, _prevRotation) > 1E-05f;
|
||||
}
|
||||
|
||||
public void SetReferenceSector(QSBSector sector)
|
||||
{
|
||||
if (ReferenceSector == sector)
|
||||
{
|
||||
return;
|
||||
}
|
||||
ReferenceSector = sector;
|
||||
transform.SetParent(sector.Transform, true);
|
||||
if (!HasAuthority && AttachedObject != null)
|
||||
{
|
||||
AttachedObject.transform.SetParent(sector.Transform, 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)
|
||||
{
|
||||
// moved too far! assume sector sync warp / actual warp
|
||||
_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(transform.position, transform.rotation, Vector3.one / 2, Color.red);
|
||||
Popcron.Gizmos.Cube(AttachedObject.transform.position, AttachedObject.transform.rotation, Vector3.one / 2, Color.green);
|
||||
Popcron.Gizmos.Line(AttachedObject.transform.position, ReferenceSector.Transform.position, Color.cyan);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,183 +0,0 @@
|
||||
using OWML.Common;
|
||||
using QSB.Player;
|
||||
using QSB.Player.TransformSync;
|
||||
using QSB.SectorSync.WorldObjects;
|
||||
using QSB.Utility;
|
||||
using System.Linq;
|
||||
using UnityEngine;
|
||||
|
||||
namespace QSB.TransformSync
|
||||
{
|
||||
public abstract class SyncObjectTransformSync : 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; }
|
||||
public SectorSync.SectorSync SectorSync { get; private set; }
|
||||
|
||||
private const float SmoothTime = 0.1f;
|
||||
private const float DistanceLeeway = 5f;
|
||||
private bool _isInitialized;
|
||||
private Vector3 _positionSmoothVelocity;
|
||||
private Quaternion _rotationSmoothVelocity;
|
||||
private bool _isVisible;
|
||||
private float _previousDistance;
|
||||
|
||||
protected override void Start()
|
||||
{
|
||||
base.Start();
|
||||
var lowestBound = QSBPlayerManager.GetSyncObjects<PlayerTransformSync>()
|
||||
.Where(x => x.NetId.Value <= NetId.Value).OrderBy(x => x.NetId.Value).Last();
|
||||
NetIdentity.SetRootIdentity(lowestBound.NetIdentity);
|
||||
|
||||
SectorSync = gameObject.AddComponent<SectorSync.SectorSync>();
|
||||
|
||||
DontDestroyOnLoad(gameObject);
|
||||
QSBSceneManager.OnSceneLoaded += OnSceneLoaded;
|
||||
}
|
||||
|
||||
protected override void OnDestroy()
|
||||
{
|
||||
base.OnDestroy();
|
||||
if (!HasAuthority && SyncedTransform != null)
|
||||
{
|
||||
Destroy(SyncedTransform.gameObject);
|
||||
}
|
||||
QSBSceneManager.OnSceneLoaded -= OnSceneLoaded;
|
||||
if (SectorSync != null)
|
||||
{
|
||||
Destroy(SectorSync);
|
||||
}
|
||||
}
|
||||
|
||||
private void OnSceneLoaded(OWScene scene, bool isInUniverse) =>
|
||||
_isInitialized = false;
|
||||
|
||||
protected void Init()
|
||||
{
|
||||
SyncedTransform = HasAuthority ? InitLocalTransform() : InitRemoteTransform();
|
||||
SetReferenceSector(SectorSync.GetClosestSector(SyncedTransform));
|
||||
_isInitialized = true;
|
||||
_isVisible = true;
|
||||
}
|
||||
|
||||
public void OnRenderObject()
|
||||
{
|
||||
if (!QSBCore.HasWokenUp || !QSBCore.DebugMode || !QSBCore.ShowLinesInDebug || !IsReady)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Popcron.Gizmos.Cube(SyncedTransform.position, SyncedTransform.rotation, Vector3.one / 2, Color.green);
|
||||
Popcron.Gizmos.Cube(transform.position, transform.rotation, Vector3.one / 2, Color.red);
|
||||
Popcron.Gizmos.Line(SyncedTransform.position, transform.position, Color.magenta);
|
||||
Popcron.Gizmos.Cube(ReferenceSector.Position, ReferenceSector.Transform.rotation, Vector3.one, Color.cyan);
|
||||
Popcron.Gizmos.Line(SyncedTransform.position, ReferenceSector.Position, Color.blue);
|
||||
}
|
||||
|
||||
public void Update()
|
||||
{
|
||||
if (!_isInitialized && IsReady)
|
||||
{
|
||||
Init();
|
||||
}
|
||||
else if (_isInitialized && !IsReady)
|
||||
{
|
||||
_isInitialized = false;
|
||||
return;
|
||||
}
|
||||
|
||||
if (!_isInitialized)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (SyncedTransform == null)
|
||||
{
|
||||
DebugLog.ToConsole($"Warning - SyncedTransform {Player.PlayerId}.{GetType().Name} is null.", MessageType.Warning);
|
||||
return;
|
||||
}
|
||||
|
||||
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 == null || ReferenceSector.AttachedObject == null)
|
||||
{
|
||||
DebugLog.ToConsole($"Error - ReferenceSector has null value for {Player.PlayerId}.{GetType().Name}", MessageType.Error);
|
||||
return;
|
||||
}
|
||||
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 = SmartSmoothDamp(SyncedTransform.localPosition, transform.position);
|
||||
SyncedTransform.localRotation = QuaternionHelper.SmoothDamp(SyncedTransform.localRotation, transform.rotation, ref _rotationSmoothVelocity, SmoothTime);
|
||||
}
|
||||
|
||||
private Vector3 SmartSmoothDamp(Vector3 currentPosition, Vector3 targetPosition)
|
||||
{
|
||||
var distance = Vector3.Distance(currentPosition, targetPosition);
|
||||
if (distance > _previousDistance + DistanceLeeway)
|
||||
{
|
||||
// moved too far! assume sector sync warp / actual warp
|
||||
_previousDistance = distance;
|
||||
return targetPosition;
|
||||
}
|
||||
_previousDistance = distance;
|
||||
return Vector3.SmoothDamp(currentPosition, targetPosition, ref _positionSmoothVelocity, SmoothTime);
|
||||
}
|
||||
|
||||
public void SetReferenceSector(QSBSector sector)
|
||||
{
|
||||
if (sector == ReferenceSector || sector == default(QSBSector))
|
||||
{
|
||||
return;
|
||||
}
|
||||
_positionSmoothVelocity = Vector3.zero;
|
||||
ReferenceSector = sector;
|
||||
if (!HasAuthority)
|
||||
{
|
||||
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,7 +1,4 @@
|
||||
using OWML.Utils;
|
||||
using QSB.Player;
|
||||
using QSB.Player.TransformSync;
|
||||
using System.Linq;
|
||||
using UnityEngine;
|
||||
|
||||
namespace QSB.Utility
|
||||
@ -27,35 +24,12 @@ namespace QSB.Utility
|
||||
bridgeVolume.AddObjectToVolume(Locator.GetPlayerCameraDetector());
|
||||
}
|
||||
|
||||
private void DebugWarpToPlayer(int index)
|
||||
{
|
||||
var allPlayers = QSBPlayerManager.PlayerList.Where(x => x != QSBPlayerManager.LocalPlayer).ToList();
|
||||
if (allPlayers.Count <= index)
|
||||
{
|
||||
return;
|
||||
}
|
||||
var player = allPlayers[index];
|
||||
var localPlayer = Locator.GetPlayerBody();
|
||||
localPlayer.WarpToPositionRotation(player.CameraBody.transform.position, player.CameraBody.transform.rotation);
|
||||
var playerTransformSync = QSBPlayerManager.GetSyncObject<PlayerTransformSync>(player.PlayerId);
|
||||
var syncedRigidbody = playerTransformSync.ReferenceSector.AttachedObject.GetOWRigidbody();
|
||||
localPlayer.SetVelocity(syncedRigidbody.GetPointVelocity(player.Body.transform.position));
|
||||
}
|
||||
|
||||
public void Update()
|
||||
{
|
||||
if (!QSBCore.DebugMode)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if (Input.GetKeyDown(KeyCode.Keypad0))
|
||||
{
|
||||
DebugWarpToPlayer(0);
|
||||
}
|
||||
if (Input.GetKeyDown(KeyCode.Keypad1))
|
||||
{
|
||||
DebugWarpToPlayer(1);
|
||||
}
|
||||
if (Input.GetKeyDown(KeyCode.Keypad7))
|
||||
{
|
||||
GoToVessel();
|
||||
|
||||
@ -23,6 +23,9 @@ namespace QSB.Utility
|
||||
}
|
||||
}
|
||||
|
||||
public static Quaternion TransformRotation(this Transform transform, Quaternion localRotation)
|
||||
=> transform.rotation * localRotation;
|
||||
|
||||
public static GameObject InstantiateInactive(this GameObject original)
|
||||
{
|
||||
original.SetActive(false);
|
||||
|
||||
@ -8,23 +8,26 @@ namespace QuantumUNET.Components
|
||||
{
|
||||
public class QNetworkTransform : QNetworkBehaviour
|
||||
{
|
||||
public float SendInterval { get; set; } = 0.1f;
|
||||
public AxisSyncMode SyncRotationAxis { get; set; } = AxisSyncMode.AxisXYZ;
|
||||
public CompressionSyncMode RotationSyncCompression { get; set; } = CompressionSyncMode.None;
|
||||
public ClientMoveCallback3D clientMoveCallback3D { get; set; }
|
||||
public float SendInterval { get; set; } = 0.05f;
|
||||
public float LastSyncTime { get; private set; }
|
||||
|
||||
private float _lastClientSendTime;
|
||||
protected Vector3 _prevPosition;
|
||||
protected Quaternion _prevRotation;
|
||||
private QNetworkWriter _localTransformWriter;
|
||||
|
||||
public void Awake()
|
||||
{
|
||||
m_PrevPosition = transform.position;
|
||||
m_PrevRotation = transform.rotation;
|
||||
_prevPosition = transform.position;
|
||||
_prevRotation = transform.rotation;
|
||||
if (LocalPlayerAuthority)
|
||||
{
|
||||
m_LocalTransformWriter = new QNetworkWriter();
|
||||
_localTransformWriter = new QNetworkWriter();
|
||||
}
|
||||
}
|
||||
|
||||
public override void OnStartServer() => LastSyncTime = 0f;
|
||||
public override void OnStartServer()
|
||||
=> LastSyncTime = 0f;
|
||||
|
||||
public override bool OnSerialize(QNetworkWriter writer, bool initialState)
|
||||
{
|
||||
@ -37,21 +40,10 @@ namespace QuantumUNET.Components
|
||||
}
|
||||
writer.WritePackedUInt32(1U);
|
||||
}
|
||||
SerializeModeTransform(writer);
|
||||
SerializeTransform(writer);
|
||||
return true;
|
||||
}
|
||||
|
||||
private void SerializeModeTransform(QNetworkWriter writer)
|
||||
{
|
||||
writer.Write(transform.position);
|
||||
if (SyncRotationAxis != AxisSyncMode.None)
|
||||
{
|
||||
SerializeRotation3D(writer, transform.rotation, SyncRotationAxis, RotationSyncCompression);
|
||||
}
|
||||
m_PrevPosition = transform.position;
|
||||
m_PrevRotation = transform.rotation;
|
||||
}
|
||||
|
||||
public override void OnDeserialize(QNetworkReader reader, bool initialState)
|
||||
{
|
||||
if (!IsServer || !QNetworkServer.localClientActive)
|
||||
@ -63,116 +55,78 @@ namespace QuantumUNET.Components
|
||||
return;
|
||||
}
|
||||
}
|
||||
UnserializeModeTransform(reader, initialState);
|
||||
DeserializeTransform(reader);
|
||||
LastSyncTime = Time.time;
|
||||
}
|
||||
}
|
||||
|
||||
private void UnserializeModeTransform(QNetworkReader reader, bool initialState)
|
||||
public virtual void SerializeTransform(QNetworkWriter writer)
|
||||
{
|
||||
writer.Write(transform.position);
|
||||
SerializeRotation(writer, transform.rotation);
|
||||
_prevPosition = transform.position;
|
||||
_prevRotation = transform.rotation;
|
||||
}
|
||||
|
||||
public virtual void DeserializeTransform(QNetworkReader reader)
|
||||
{
|
||||
if (HasAuthority)
|
||||
{
|
||||
reader.ReadVector3();
|
||||
if (SyncRotationAxis != AxisSyncMode.None)
|
||||
{
|
||||
UnserializeRotation3D(reader, SyncRotationAxis, RotationSyncCompression);
|
||||
}
|
||||
}
|
||||
else if (IsServer && clientMoveCallback3D != null)
|
||||
{
|
||||
var position = reader.ReadVector3();
|
||||
var zero = Vector3.zero;
|
||||
var rotation = Quaternion.identity;
|
||||
if (SyncRotationAxis != AxisSyncMode.None)
|
||||
{
|
||||
rotation = UnserializeRotation3D(reader, SyncRotationAxis, RotationSyncCompression);
|
||||
}
|
||||
if (clientMoveCallback3D(ref position, ref zero, ref rotation))
|
||||
{
|
||||
transform.position = position;
|
||||
if (SyncRotationAxis != AxisSyncMode.None)
|
||||
{
|
||||
transform.rotation = rotation;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
transform.position = reader.ReadVector3();
|
||||
if (SyncRotationAxis != AxisSyncMode.None)
|
||||
{
|
||||
transform.rotation = UnserializeRotation3D(reader, SyncRotationAxis, RotationSyncCompression);
|
||||
}
|
||||
DeserializeRotation(reader);
|
||||
return;
|
||||
}
|
||||
transform.position = reader.ReadVector3();
|
||||
transform.rotation = DeserializeRotation(reader);
|
||||
}
|
||||
|
||||
private void FixedUpdate()
|
||||
{
|
||||
if (IsServer)
|
||||
if (!IsServer)
|
||||
{
|
||||
FixedUpdateServer();
|
||||
return;
|
||||
}
|
||||
|
||||
if (SyncVarDirtyBits != 0U)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (!QNetworkServer.active)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (GetNetworkSendInterval() != 0f && HasMoved())
|
||||
{
|
||||
SetDirtyBit(1U);
|
||||
}
|
||||
}
|
||||
|
||||
private void FixedUpdateServer()
|
||||
public virtual void Update()
|
||||
{
|
||||
if (SyncVarDirtyBits == 0U)
|
||||
if (!HasAuthority || !LocalPlayerAuthority)
|
||||
{
|
||||
if (QNetworkServer.active)
|
||||
{
|
||||
if (IsServer)
|
||||
{
|
||||
if (GetNetworkSendInterval() != 0f)
|
||||
{
|
||||
if (HasMoved())
|
||||
{
|
||||
SetDirtyBit(1U);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (QNetworkServer.active)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (Time.time - _lastClientSendTime > GetNetworkSendInterval())
|
||||
{
|
||||
SendTransform();
|
||||
_lastClientSendTime = Time.time;
|
||||
}
|
||||
}
|
||||
|
||||
private void Update()
|
||||
public virtual bool HasMoved()
|
||||
{
|
||||
if (HasAuthority)
|
||||
{
|
||||
if (LocalPlayerAuthority)
|
||||
{
|
||||
if (!QNetworkServer.active)
|
||||
{
|
||||
if (Time.time - m_LastClientSendTime > GetNetworkSendInterval())
|
||||
{
|
||||
SendTransform();
|
||||
m_LastClientSendTime = Time.time;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private bool HasMoved()
|
||||
{
|
||||
var num = (transform.position - m_PrevPosition).magnitude;
|
||||
bool result;
|
||||
if (num > 1E-05f)
|
||||
{
|
||||
result = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
num = Quaternion.Angle(transform.rotation, m_PrevRotation);
|
||||
if (num > 1E-05f)
|
||||
{
|
||||
result = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = num > 1E-05f;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
var displacementMagnitude = (transform.position - _prevPosition).magnitude;
|
||||
return displacementMagnitude > 1E-05f
|
||||
|| Quaternion.Angle(transform.rotation, _prevRotation) > 1E-05f;
|
||||
}
|
||||
|
||||
[Client]
|
||||
@ -180,13 +134,14 @@ namespace QuantumUNET.Components
|
||||
{
|
||||
if (HasMoved() && QClientScene.readyConnection != null)
|
||||
{
|
||||
m_LocalTransformWriter.StartMessage(6);
|
||||
m_LocalTransformWriter.Write(NetId);
|
||||
SerializeModeTransform(m_LocalTransformWriter);
|
||||
m_PrevPosition = transform.position;
|
||||
m_PrevRotation = transform.rotation;
|
||||
m_LocalTransformWriter.FinishMessage();
|
||||
QClientScene.readyConnection.SendWriter(m_LocalTransformWriter, GetNetworkChannel());
|
||||
_localTransformWriter.StartMessage(QMsgType.LocalPlayerTransform);
|
||||
_localTransformWriter.Write(NetId);
|
||||
SerializeTransform(_localTransformWriter);
|
||||
_prevPosition = transform.position;
|
||||
_prevRotation = transform.rotation;
|
||||
_localTransformWriter.FinishMessage();
|
||||
|
||||
QClientScene.readyConnection.SendWriter(_localTransformWriter, GetNetworkChannel());
|
||||
}
|
||||
}
|
||||
|
||||
@ -197,281 +152,63 @@ namespace QuantumUNET.Components
|
||||
if (gameObject == null)
|
||||
{
|
||||
QLog.Warning("Received NetworkTransform data for GameObject that doesn't exist");
|
||||
return;
|
||||
}
|
||||
|
||||
var component = gameObject.GetComponent<QNetworkTransform>();
|
||||
if (component == null)
|
||||
{
|
||||
QLog.Warning("HandleTransform null target");
|
||||
return;
|
||||
}
|
||||
|
||||
if (!component.LocalPlayerAuthority)
|
||||
{
|
||||
QLog.Warning("HandleTransform no localPlayerAuthority");
|
||||
return;
|
||||
}
|
||||
|
||||
if (netMsg.Connection.ClientOwnedObjects == null)
|
||||
{
|
||||
QLog.Warning("HandleTransform object not owned by connection");
|
||||
return;
|
||||
}
|
||||
|
||||
if (netMsg.Connection.ClientOwnedObjects.Contains(networkInstanceId))
|
||||
{
|
||||
component.DeserializeTransform(netMsg.Reader);
|
||||
component.LastSyncTime = Time.time;
|
||||
}
|
||||
else
|
||||
{
|
||||
var component = gameObject.GetComponent<QNetworkTransform>();
|
||||
if (component == null)
|
||||
{
|
||||
QLog.Warning("HandleTransform null target");
|
||||
}
|
||||
else if (!component.LocalPlayerAuthority)
|
||||
{
|
||||
QLog.Warning("HandleTransform no localPlayerAuthority");
|
||||
}
|
||||
else if (netMsg.Connection.ClientOwnedObjects == null)
|
||||
{
|
||||
QLog.Warning("HandleTransform object not owned by connection");
|
||||
}
|
||||
else if (netMsg.Connection.ClientOwnedObjects.Contains(networkInstanceId))
|
||||
{
|
||||
component.UnserializeModeTransform(netMsg.Reader, false);
|
||||
component.LastSyncTime = Time.time;
|
||||
}
|
||||
else
|
||||
{
|
||||
QLog.Warning(
|
||||
$"HandleTransform netId:{networkInstanceId} is not for a valid player");
|
||||
}
|
||||
QLog.Warning(
|
||||
$"HandleTransform netId:{networkInstanceId} is not for a valid player");
|
||||
}
|
||||
}
|
||||
|
||||
private static void WriteAngle(QNetworkWriter writer, float angle, CompressionSyncMode compression)
|
||||
public static void SerializeRotation(QNetworkWriter writer, Quaternion rot)
|
||||
{
|
||||
if (compression != CompressionSyncMode.None)
|
||||
{
|
||||
if (compression != CompressionSyncMode.Low)
|
||||
{
|
||||
if (compression == CompressionSyncMode.High)
|
||||
{
|
||||
writer.Write((short)angle);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
writer.Write((short)angle);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
writer.Write(angle);
|
||||
}
|
||||
writer.Write(rot.eulerAngles.x);
|
||||
writer.Write(rot.eulerAngles.y);
|
||||
writer.Write(rot.eulerAngles.z);
|
||||
}
|
||||
|
||||
private static float ReadAngle(QNetworkReader reader, CompressionSyncMode compression)
|
||||
public static Quaternion DeserializeRotation(QNetworkReader reader)
|
||||
{
|
||||
float result;
|
||||
if (compression != CompressionSyncMode.None)
|
||||
{
|
||||
if (compression != CompressionSyncMode.Low)
|
||||
{
|
||||
if (compression != CompressionSyncMode.High)
|
||||
{
|
||||
result = 0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = reader.ReadInt16();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
result = reader.ReadInt16();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
result = reader.ReadSingle();
|
||||
}
|
||||
return result;
|
||||
var rotation = Quaternion.identity;
|
||||
var eulerAngles = Vector3.zero;
|
||||
eulerAngles.Set(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
|
||||
rotation.eulerAngles = eulerAngles;
|
||||
return rotation;
|
||||
}
|
||||
|
||||
public static void SerializeVelocity3D(QNetworkWriter writer, Vector3 velocity, CompressionSyncMode compression) =>
|
||||
writer.Write(velocity);
|
||||
public override int GetNetworkChannel()
|
||||
=> 1;
|
||||
|
||||
public static void SerializeRotation3D(QNetworkWriter writer, Quaternion rot, AxisSyncMode mode, CompressionSyncMode compression)
|
||||
{
|
||||
switch (mode)
|
||||
{
|
||||
case AxisSyncMode.AxisX:
|
||||
WriteAngle(writer, rot.eulerAngles.x, compression);
|
||||
break;
|
||||
public override float GetNetworkSendInterval()
|
||||
=> SendInterval;
|
||||
|
||||
case AxisSyncMode.AxisY:
|
||||
WriteAngle(writer, rot.eulerAngles.y, compression);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisZ:
|
||||
WriteAngle(writer, rot.eulerAngles.z, compression);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXY:
|
||||
WriteAngle(writer, rot.eulerAngles.x, compression);
|
||||
WriteAngle(writer, rot.eulerAngles.y, compression);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXZ:
|
||||
WriteAngle(writer, rot.eulerAngles.x, compression);
|
||||
WriteAngle(writer, rot.eulerAngles.z, compression);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisYZ:
|
||||
WriteAngle(writer, rot.eulerAngles.y, compression);
|
||||
WriteAngle(writer, rot.eulerAngles.z, compression);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXYZ:
|
||||
WriteAngle(writer, rot.eulerAngles.x, compression);
|
||||
WriteAngle(writer, rot.eulerAngles.y, compression);
|
||||
WriteAngle(writer, rot.eulerAngles.z, compression);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
public static void SerializeSpin3D(QNetworkWriter writer, Vector3 angularVelocity, AxisSyncMode mode, CompressionSyncMode compression)
|
||||
{
|
||||
switch (mode)
|
||||
{
|
||||
case AxisSyncMode.AxisX:
|
||||
WriteAngle(writer, angularVelocity.x, compression);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisY:
|
||||
WriteAngle(writer, angularVelocity.y, compression);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisZ:
|
||||
WriteAngle(writer, angularVelocity.z, compression);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXY:
|
||||
WriteAngle(writer, angularVelocity.x, compression);
|
||||
WriteAngle(writer, angularVelocity.y, compression);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXZ:
|
||||
WriteAngle(writer, angularVelocity.x, compression);
|
||||
WriteAngle(writer, angularVelocity.z, compression);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisYZ:
|
||||
WriteAngle(writer, angularVelocity.y, compression);
|
||||
WriteAngle(writer, angularVelocity.z, compression);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXYZ:
|
||||
WriteAngle(writer, angularVelocity.x, compression);
|
||||
WriteAngle(writer, angularVelocity.y, compression);
|
||||
WriteAngle(writer, angularVelocity.z, compression);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
public static Vector3 UnserializeVelocity3D(QNetworkReader reader, CompressionSyncMode compression) => reader.ReadVector3();
|
||||
|
||||
public static Quaternion UnserializeRotation3D(QNetworkReader reader, AxisSyncMode mode, CompressionSyncMode compression)
|
||||
{
|
||||
var identity = Quaternion.identity;
|
||||
var zero = Vector3.zero;
|
||||
switch (mode)
|
||||
{
|
||||
case AxisSyncMode.AxisX:
|
||||
zero.Set(ReadAngle(reader, compression), 0f, 0f);
|
||||
identity.eulerAngles = zero;
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisY:
|
||||
zero.Set(0f, ReadAngle(reader, compression), 0f);
|
||||
identity.eulerAngles = zero;
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisZ:
|
||||
zero.Set(0f, 0f, ReadAngle(reader, compression));
|
||||
identity.eulerAngles = zero;
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXY:
|
||||
zero.Set(ReadAngle(reader, compression), ReadAngle(reader, compression), 0f);
|
||||
identity.eulerAngles = zero;
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXZ:
|
||||
zero.Set(ReadAngle(reader, compression), 0f, ReadAngle(reader, compression));
|
||||
identity.eulerAngles = zero;
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisYZ:
|
||||
zero.Set(0f, ReadAngle(reader, compression), ReadAngle(reader, compression));
|
||||
identity.eulerAngles = zero;
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXYZ:
|
||||
zero.Set(ReadAngle(reader, compression), ReadAngle(reader, compression), ReadAngle(reader, compression));
|
||||
identity.eulerAngles = zero;
|
||||
break;
|
||||
}
|
||||
return identity;
|
||||
}
|
||||
|
||||
public static Vector3 UnserializeSpin3D(QNetworkReader reader, AxisSyncMode mode, CompressionSyncMode compression)
|
||||
{
|
||||
var zero = Vector3.zero;
|
||||
switch (mode)
|
||||
{
|
||||
case AxisSyncMode.AxisX:
|
||||
zero.Set(ReadAngle(reader, compression), 0f, 0f);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisY:
|
||||
zero.Set(0f, ReadAngle(reader, compression), 0f);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisZ:
|
||||
zero.Set(0f, 0f, ReadAngle(reader, compression));
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXY:
|
||||
zero.Set(ReadAngle(reader, compression), ReadAngle(reader, compression), 0f);
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXZ:
|
||||
zero.Set(ReadAngle(reader, compression), 0f, ReadAngle(reader, compression));
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisYZ:
|
||||
zero.Set(0f, ReadAngle(reader, compression), ReadAngle(reader, compression));
|
||||
break;
|
||||
|
||||
case AxisSyncMode.AxisXYZ:
|
||||
zero.Set(ReadAngle(reader, compression), ReadAngle(reader, compression), ReadAngle(reader, compression));
|
||||
break;
|
||||
}
|
||||
return zero;
|
||||
}
|
||||
|
||||
public override int GetNetworkChannel() => 1;
|
||||
|
||||
public override float GetNetworkSendInterval() => SendInterval;
|
||||
|
||||
public override void OnStartAuthority() => LastSyncTime = 0f;
|
||||
|
||||
private float m_LastClientSendTime;
|
||||
|
||||
private Vector3 m_PrevPosition;
|
||||
|
||||
private Quaternion m_PrevRotation;
|
||||
|
||||
private QNetworkWriter m_LocalTransformWriter;
|
||||
|
||||
public enum AxisSyncMode
|
||||
{
|
||||
None,
|
||||
AxisX,
|
||||
AxisY,
|
||||
AxisZ,
|
||||
AxisXY,
|
||||
AxisXZ,
|
||||
AxisYZ,
|
||||
AxisXYZ
|
||||
}
|
||||
|
||||
public enum CompressionSyncMode
|
||||
{
|
||||
None,
|
||||
Low,
|
||||
High
|
||||
}
|
||||
|
||||
public delegate bool ClientMoveCallback3D(ref Vector3 position, ref Vector3 velocity, ref Quaternion rotation);
|
||||
public override void OnStartAuthority()
|
||||
=> LastSyncTime = 0f;
|
||||
}
|
||||
}
|
||||
@ -11,11 +11,7 @@ namespace QuantumUNET.Components
|
||||
public Transform Target
|
||||
{
|
||||
get => m_Target;
|
||||
set
|
||||
{
|
||||
m_Target = value;
|
||||
OnValidate();
|
||||
}
|
||||
set => m_Target = value;
|
||||
}
|
||||
|
||||
public uint ChildIndex => m_ChildIndex;
|
||||
@ -26,18 +22,6 @@ namespace QuantumUNET.Components
|
||||
set => m_SendInterval = value;
|
||||
}
|
||||
|
||||
public QNetworkTransform.AxisSyncMode SyncRotationAxis
|
||||
{
|
||||
get => m_SyncRotationAxis;
|
||||
set => m_SyncRotationAxis = value;
|
||||
}
|
||||
|
||||
public QNetworkTransform.CompressionSyncMode RotationSyncCompression
|
||||
{
|
||||
get => m_RotationSyncCompression;
|
||||
set => m_RotationSyncCompression = value;
|
||||
}
|
||||
|
||||
public float MovementThreshold
|
||||
{
|
||||
get => m_MovementThreshold;
|
||||
@ -56,89 +40,10 @@ namespace QuantumUNET.Components
|
||||
set => m_InterpolateMovement = value;
|
||||
}
|
||||
|
||||
public QNetworkTransform.ClientMoveCallback3D ClientMoveCallback3D
|
||||
{
|
||||
get => m_ClientMoveCallback3D;
|
||||
set => m_ClientMoveCallback3D = value;
|
||||
}
|
||||
|
||||
public float LastSyncTime { get; private set; }
|
||||
public Vector3 TargetSyncPosition => m_TargetSyncPosition;
|
||||
public Quaternion TargetSyncRotation3D => m_TargetSyncRotation3D;
|
||||
|
||||
private void OnValidate()
|
||||
{
|
||||
if (m_Target != null)
|
||||
{
|
||||
var parent = m_Target.parent;
|
||||
if (parent == null)
|
||||
{
|
||||
Debug.LogError("NetworkTransformChild target cannot be the root transform.");
|
||||
m_Target = null;
|
||||
return;
|
||||
}
|
||||
while (parent.parent != null)
|
||||
{
|
||||
parent = parent.parent;
|
||||
}
|
||||
m_Root = parent.gameObject.GetComponent<QNetworkTransform>();
|
||||
if (m_Root == null)
|
||||
{
|
||||
Debug.LogError("NetworkTransformChild root must have NetworkTransform");
|
||||
m_Target = null;
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (m_Root != null)
|
||||
{
|
||||
m_ChildIndex = uint.MaxValue;
|
||||
var components = m_Root.GetComponents<QNetworkTransformChild>();
|
||||
var num = 0U;
|
||||
while (num < (ulong)components.Length)
|
||||
{
|
||||
if (components[(int)(UIntPtr)num] == this)
|
||||
{
|
||||
m_ChildIndex = num;
|
||||
break;
|
||||
}
|
||||
num += 1U;
|
||||
}
|
||||
if (m_ChildIndex == 4294967295U)
|
||||
{
|
||||
Debug.LogError("QNetworkTransformChild component must be a child in the same hierarchy");
|
||||
m_Target = null;
|
||||
}
|
||||
}
|
||||
if (m_SendInterval < 0f)
|
||||
{
|
||||
m_SendInterval = 0f;
|
||||
}
|
||||
if (m_SyncRotationAxis < QNetworkTransform.AxisSyncMode.None || m_SyncRotationAxis > QNetworkTransform.AxisSyncMode.AxisXYZ)
|
||||
{
|
||||
m_SyncRotationAxis = QNetworkTransform.AxisSyncMode.None;
|
||||
}
|
||||
if (MovementThreshold < 0f)
|
||||
{
|
||||
MovementThreshold = 0f;
|
||||
}
|
||||
if (InterpolateRotation < 0f)
|
||||
{
|
||||
InterpolateRotation = 0.01f;
|
||||
}
|
||||
if (InterpolateRotation > 1f)
|
||||
{
|
||||
InterpolateRotation = 1f;
|
||||
}
|
||||
if (InterpolateMovement < 0f)
|
||||
{
|
||||
InterpolateMovement = 0.01f;
|
||||
}
|
||||
if (InterpolateMovement > 1f)
|
||||
{
|
||||
InterpolateMovement = 1f;
|
||||
}
|
||||
}
|
||||
|
||||
private void Awake()
|
||||
{
|
||||
m_PrevPosition = m_Target.localPosition;
|
||||
@ -167,10 +72,7 @@ namespace QuantumUNET.Components
|
||||
private void SerializeModeTransform(QNetworkWriter writer)
|
||||
{
|
||||
writer.Write(m_Target.localPosition);
|
||||
if (m_SyncRotationAxis != QNetworkTransform.AxisSyncMode.None)
|
||||
{
|
||||
QNetworkTransform.SerializeRotation3D(writer, m_Target.localRotation, SyncRotationAxis, RotationSyncCompression);
|
||||
}
|
||||
QNetworkTransform.SerializeRotation(writer, m_Target.localRotation);
|
||||
m_PrevPosition = m_Target.localPosition;
|
||||
m_PrevRotation = m_Target.localRotation;
|
||||
}
|
||||
@ -197,36 +99,12 @@ namespace QuantumUNET.Components
|
||||
if (HasAuthority)
|
||||
{
|
||||
reader.ReadVector3();
|
||||
if (SyncRotationAxis != QNetworkTransform.AxisSyncMode.None)
|
||||
{
|
||||
QNetworkTransform.UnserializeRotation3D(reader, SyncRotationAxis, RotationSyncCompression);
|
||||
}
|
||||
}
|
||||
else if (IsServer && m_ClientMoveCallback3D != null)
|
||||
{
|
||||
var targetSyncPosition = reader.ReadVector3();
|
||||
var zero = Vector3.zero;
|
||||
var targetSyncRotation3D = Quaternion.identity;
|
||||
if (SyncRotationAxis != QNetworkTransform.AxisSyncMode.None)
|
||||
{
|
||||
targetSyncRotation3D = QNetworkTransform.UnserializeRotation3D(reader, SyncRotationAxis, RotationSyncCompression);
|
||||
}
|
||||
if (m_ClientMoveCallback3D(ref targetSyncPosition, ref zero, ref targetSyncRotation3D))
|
||||
{
|
||||
m_TargetSyncPosition = targetSyncPosition;
|
||||
if (SyncRotationAxis != QNetworkTransform.AxisSyncMode.None)
|
||||
{
|
||||
m_TargetSyncRotation3D = targetSyncRotation3D;
|
||||
}
|
||||
}
|
||||
QNetworkTransform.DeserializeRotation(reader);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_TargetSyncPosition = reader.ReadVector3();
|
||||
if (SyncRotationAxis != QNetworkTransform.AxisSyncMode.None)
|
||||
{
|
||||
m_TargetSyncRotation3D = QNetworkTransform.UnserializeRotation3D(reader, SyncRotationAxis, RotationSyncCompression);
|
||||
}
|
||||
m_TargetSyncRotation3D = QNetworkTransform.DeserializeRotation(reader);
|
||||
}
|
||||
}
|
||||
|
||||
@ -404,12 +282,9 @@ namespace QuantumUNET.Components
|
||||
public uint m_ChildIndex;
|
||||
public QNetworkTransform m_Root;
|
||||
public float m_SendInterval = 0.1f;
|
||||
public QNetworkTransform.AxisSyncMode m_SyncRotationAxis = QNetworkTransform.AxisSyncMode.AxisXYZ;
|
||||
public QNetworkTransform.CompressionSyncMode m_RotationSyncCompression = QNetworkTransform.CompressionSyncMode.None;
|
||||
public float m_MovementThreshold = 0.001f;
|
||||
public float m_InterpolateRotation = 0.5f;
|
||||
public float m_InterpolateMovement = 0.5f;
|
||||
public QNetworkTransform.ClientMoveCallback3D m_ClientMoveCallback3D;
|
||||
private Vector3 m_TargetSyncPosition;
|
||||
private Quaternion m_TargetSyncRotation3D;
|
||||
private float m_LastClientSendTime;
|
||||
|
||||
49
README.md
49
README.md
@ -1,5 +1,11 @@
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Quantum Space Buddies (QSB) is a multiplayer mod for Outer Wilds. The mod uses the OWML mod loader and customized UNET code (internally referred to as QNet or QuantumUNET) for networking.
|
||||
|
||||
## License
|
||||
@ -56,19 +62,36 @@ QSB relies on exact orders of objects found using Resources.FindObjectsOfTypeAll
|
||||
**NomaiVR compatibility is currently not planned and likely will never happen, due to extensive changes needed to both mods for it to work.**
|
||||
|
||||
### What is currently synced?
|
||||
QSB does not operate on a strict server-client relationship. Each player's game is left as a completely seperate game, and individual elemets are synced or patched so they can be controlled though network messages. Right now, the list of synced objects are :
|
||||
- Geysers
|
||||
- Elevators
|
||||
- Nomai interface orbs
|
||||
- Player animations
|
||||
- Player tools
|
||||
- Player ships
|
||||
- Player probes
|
||||
- NPC heads in conversations
|
||||
- Ship log
|
||||
- Discovering frequencies / signals
|
||||
- Nomai text (Spirals + Computers)
|
||||
- Picking up/dropping/socketing items
|
||||
|
||||
| System / Mechanic | Synced? |
|
||||
| :---: | :---: |
|
||||
| Anglerfish | No |
|
||||
| Brittle Hollow fragments | No |
|
||||
| Campfires | Yes |
|
||||
| Conversations with NPCs | Yes |
|
||||
| Discovering signals/frequencies | Yes |
|
||||
| Eye of the Universe ancient glade | No |
|
||||
| Eye of the Universe instrument hunt | No |
|
||||
| Eye of the Universe jam session | No |
|
||||
| Eye of the Universe quantum lightning | No |
|
||||
| Geysers | Yes |
|
||||
| Items | Yes |
|
||||
| Jellyfish | No |
|
||||
| Marshmallow roasting | Yes |
|
||||
| Meteors | No |
|
||||
| Museum statue | Yes |
|
||||
| NPC animations | Kind of |
|
||||
| Nomai orbs | Yes |
|
||||
| Nomai shuttle | Kind of |
|
||||
| Orbital Probe Cannon (direction) | No |
|
||||
| Player animation | Kind of |
|
||||
| Player position | Yes |
|
||||
| Player tools | Yes |
|
||||
| Projection pools | Yes |
|
||||
| Quantum objects | Yes |
|
||||
| Ship log | Yes |
|
||||
| Timber Hearth satellite | No |
|
||||
| Tornadoes | No |
|
||||
|
||||
QSB also changes some mechanics of the base game, to better fit a multiplayer experience. These include :
|
||||
- Adding dialogue boxes above NPC and player heads, so other players can "listen in" on conversations.
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user