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

the rest of the player messages

Browse Source
This commit is contained in:
JohnCorby 2021-12-22 20:45:25 -08:00
parent 6922d3a481
commit 1634362018
7 changed files with 98 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
QSB/DeathSync/Events/PlayerDeathEvent.cs
View File

@ -1,42 +0,0 @@
using QSB.ClientServerStateSync;
using QSB.Events;
using QSB.Player;
using QSB.RespawnSync;
using QSB.Utility;
namespace QSB.DeathSync.Events
{
public class PlayerDeathEvent : QSBEvent<PlayerDeathMessage>
{
public override bool RequireWorldObjectsReady => false;
public override void SetupListener() => GlobalMessenger<DeathType>.AddListener(EventNames.QSBPlayerDeath, Handler);
public override void CloseListener() => GlobalMessenger<DeathType>.RemoveListener(EventNames.QSBPlayerDeath, Handler);
private void Handler(DeathType type) => SendEvent(CreateMessage(type));
private PlayerDeathMessage CreateMessage(DeathType type) => new()
{
AboutId = LocalPlayerId,
EnumValue = type,
NecronomiconIndex = Necronomicon.GetRandomIndex(type)
};
public override void OnReceiveLocal(bool server, PlayerDeathMessage message)
{
var player = QSBPlayerManager.GetPlayer(message.AboutId);
RespawnManager.Instance.OnPlayerDeath(player);
ClientStateManager.Instance.OnDeath();
}
public override void OnReceiveRemote(bool server, PlayerDeathMessage message)
{
var player = QSBPlayerManager.GetPlayer(message.AboutId);
var playerName = player.Name;
var deathMessage = Necronomicon.GetPhrase(message.EnumValue, message.NecronomiconIndex);
DebugLog.ToAll(string.Format(deathMessage, playerName));
RespawnManager.Instance.OnPlayerDeath(player);
}
}
}

45
QSB/DeathSync/Events/PlayerDeathMessage.cs
View File

@ -1,24 +1,47 @@
using QSB.Messaging;
using QSB.ClientServerStateSync;
using QSB.Messaging;
using QSB.Player;
using QSB.RespawnSync;
using QSB.Utility;
using QuantumUNET.Transport;
namespace QSB.DeathSync.Events
{
public class PlayerDeathMessage : EnumMessage<DeathType>
public class PlayerDeathMessage : QSBEnumMessage<DeathType>
{
public int NecronomiconIndex { get; set; }
private int NecronomiconIndex;
public override void Deserialize(QNetworkReader reader)
{
base.Deserialize(reader);
EnumValue = (DeathType)reader.ReadInt32();
NecronomiconIndex = reader.ReadInt32();
}
public PlayerDeathMessage(DeathType type) => NecronomiconIndex = Necronomicon.GetRandomIndex(type);
public PlayerDeathMessage() { }
public override void Serialize(QNetworkWriter writer)
{
base.Serialize(writer);
writer.Write((int)EnumValue);
writer.Write(NecronomiconIndex);
}
public override void Deserialize(QNetworkReader reader)
{
base.Deserialize(reader);
NecronomiconIndex = reader.ReadInt32();
}
public override void OnReceiveLocal()
{
var player = QSBPlayerManager.GetPlayer(From);
RespawnManager.Instance.OnPlayerDeath(player);
ClientStateManager.Instance.OnDeath();
}
public override void OnReceiveRemote()
{
var player = QSBPlayerManager.GetPlayer(From);
var playerName = player.Name;
var deathMessage = Necronomicon.GetPhrase(Value, NecronomiconIndex);
DebugLog.ToAll(string.Format(deathMessage, playerName));
RespawnManager.Instance.OnPlayerDeath(player);
}
}
}
}

4
QSB/DeathSync/Patches/DeathPatches.cs
View File

@ -5,6 +5,8 @@ using QSB.Player;
using QSB.ShipSync;
using QSB.Utility;
using System.Linq;
using QSB.DeathSync.Events;
using QSB.Messaging;
using UnityEngine;
namespace QSB.DeathSync.Patches
@ -195,7 +197,7 @@ namespace QSB.DeathSync.Patches
if (!QSBPlayerManager.LocalPlayer.IsDead)
{
QSBPlayerManager.LocalPlayer.IsDead = true;
QSBEventManager.FireEvent(EventNames.QSBPlayerDeath, deathType);
new PlayerDeathMessage(deathType).Send();
}
}

2
QSB/Events/EventNames.cs
View File

@ -26,7 +26,6 @@
// Custom event names -- change if you want! These can be anything, as long as both
// sides of the GlobalMessenger (fireevent and addlistener) reference the same thing.
public const string QSBPlayerDeath = nameof(QSBPlayerDeath);
public const string QSBServerTime = nameof(QSBServerTime);
public const string QSBStartLift = nameof(QSBStartLift);
public const string QSBGeyserState = nameof(QSBGeyserState);
@ -45,7 +44,6 @@
public const string QSBTextTranslated = nameof(QSBTextTranslated);
public const string QSBEnterShrine = nameof(QSBEnterShrine);
public const string QSBExitShrine = nameof(QSBExitShrine);
public const string QSBPlayerEntangle = nameof(QSBPlayerEntangle);
public const string QSBDropItem = nameof(QSBDropItem);
public const string QSBSocketItem = nameof(QSBSocketItem);
public const string QSBMoveToCarry = nameof(QSBMoveToCarry);

50
QSB/Player/Events/PlayerEntangledEvent.cs
View File

@ -1,50 +0,0 @@
using QSB.Events;
using QSB.QuantumSync;
using QSB.QuantumSync.WorldObjects;
using QSB.WorldSync;
using QSB.WorldSync.Events;
namespace QSB.Player.Events
{
internal class PlayerEntangledEvent : QSBEvent<WorldObjectMessage>
{
public override bool RequireWorldObjectsReady => true;
public override void SetupListener() => GlobalMessenger<int>.AddListener(EventNames.QSBPlayerEntangle, Handler);
public override void CloseListener() => GlobalMessenger<int>.RemoveListener(EventNames.QSBPlayerEntangle, Handler);
private void Handler(int id) => SendEvent(CreateMessage(id));
private WorldObjectMessage CreateMessage(int id) => new()
{
AboutId = LocalPlayerId,
ObjectId = id
};
public override void OnReceiveLocal(bool server, WorldObjectMessage message)
{
var player = QSBPlayerManager.LocalPlayer;
if (message.ObjectId == -1)
{
player.EntangledObject = null;
return;
}
var quantumObject = QSBWorldSync.GetWorldFromId<IQSBQuantumObject>(message.ObjectId);
player.EntangledObject = quantumObject;
}
public override void OnReceiveRemote(bool server, WorldObjectMessage message)
{
var player = QSBPlayerManager.GetPlayer(message.AboutId);
if (message.ObjectId == -1)
{
player.EntangledObject = null;
return;
}
var quantumObject = QSBWorldSync.GetWorldFromId<IQSBQuantumObject>(message.ObjectId);
player.EntangledObject = quantumObject;
}
}
}

57
QSB/Player/Events/PlayerEntangledMessage.cs Normal file
View File

@ -0,0 +1,57 @@
using QSB.Messaging;
using QSB.QuantumSync.WorldObjects;
using QSB.WorldSync;
using QuantumUNET.Transport;
namespace QSB.Player.Events
{
// almost a world object message, but supports null (-1) as well
internal class PlayerEntangledMessage : QSBMessage
{
private int ObjectId;
public PlayerEntangledMessage(int objectId) => ObjectId = objectId;
public PlayerEntangledMessage() { }
public override bool ShouldReceive => WorldObjectManager.AllObjectsReady;
public override void OnReceiveLocal()
{
var player = QSBPlayerManager.LocalPlayer;
if (ObjectId == -1)
{
player.EntangledObject = null;
return;
}
var quantumObject = QSBWorldSync.GetWorldFromId<IQSBQuantumObject>(ObjectId);
player.EntangledObject = quantumObject;
}
public override void OnReceiveRemote()
{
var player = QSBPlayerManager.GetPlayer(From);
if (ObjectId == -1)
{
player.EntangledObject = null;
return;
}
var quantumObject = QSBWorldSync.GetWorldFromId<IQSBQuantumObject>(ObjectId);
player.EntangledObject = quantumObject;
}
public override void Serialize(QNetworkWriter writer)
{
base.Serialize(writer);
writer.Write(ObjectId);
}
public override void Deserialize(QNetworkReader reader)
{
base.Deserialize(reader);
ObjectId = reader.ReadInt32();
}
}
}

8
QSB/Player/PlayerEntanglementWatcher.cs
View File

@ -1,5 +1,7 @@
using OWML.Utils;
using QSB.Events;
using QSB.Messaging;
using QSB.Player.Events;
using QSB.QuantumSync;
using QSB.QuantumSync.WorldObjects;
using QSB.WorldSync;
@ -32,13 +34,11 @@ namespace QSB.Player
var collidingQuantumObject = controller._collidingQuantumObject;
if (_previousCollidingQuantumObject != collidingQuantumObject)
{
var objectIndex = (collidingQuantumObject != null)
var objectId = collidingQuantumObject != null
? QSBWorldSync.GetWorldFromUnity<IQSBQuantumObject>(collidingQuantumObject).ObjectId
: -1;
QSBEventManager.FireEvent(
EventNames.QSBPlayerEntangle,
objectIndex);
new PlayerEntangledMessage(objectId).Send();
_previousCollidingQuantumObject = collidingQuantumObject;
}
}