public NetworkSerializer __beginSendServerRpc(ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery)
#endif
{
PooledNetworkWriter writer;
var rpcQueueContainer = NetworkManager.Singleton.RpcQueueContainer;
var isUsingBatching = rpcQueueContainer.IsUsingBatching();
var transportChannel = rpcDelivery == RpcDelivery.Reliable ? NetworkChannel.ReliableRpc : NetworkChannel.UnreliableRpc;
if (IsHost)
{
writer = rpcQueueContainer.BeginAddQueueItemToFrame(RpcQueueContainer.QueueItemType.ServerRpc, Time.realtimeSinceStartup, transportChannel,
NetworkManager.Singleton.ServerClientId, null, RpcQueueHistoryFrame.QueueFrameType.Inbound, serverRpcParams.Send.UpdateStage);
if (!isUsingBatching)
{
writer.WriteByte(NetworkConstants.SERVER_RPC); // MessageType
}
}
else
{
writer = rpcQueueContainer.BeginAddQueueItemToFrame(RpcQueueContainer.QueueItemType.ServerRpc, Time.realtimeSinceStartup, transportChannel,
NetworkManager.Singleton.ServerClientId, null, RpcQueueHistoryFrame.QueueFrameType.Outbound, NetworkUpdateStage.PostLateUpdate);
if (!isUsingBatching)
{
writer.WriteByte(NetworkConstants.SERVER_RPC); // MessageType
}
}
writer.WriteUInt64Packed(NetworkObjectId); // NetworkObjectId
writer.WriteUInt16Packed(NetworkBehaviourId); // NetworkBehaviourId
writer.WriteByte((byte)serverRpcParams.Send.UpdateStage); // NetworkUpdateStage
return(writer.Serializer);
}
public void UpdateHPServerRpc(int HPDiff, ServerRpcParams rpcParams = default)
{
HP.Value += HPDiff;
if (HP.Value > maxHp)
{
HP.Value = maxHp;
}
}
void ShuffleSpawnsServerRpc(ServerRpcParams rpcParams = default)
{
if (!HasBeenShuffled.Value)
{
HasBeenShuffled.Value = true;
spawnPositions = spawnPositions.OrderBy(x => Random.value).ToList();
}
Readies.Value++;
}
private void PingMySelfServerRpc(int currentCount, ServerRpcParams parameters = default)
{
Debug.Log($"{nameof(PingMySelfServerRpc)}: [HostClient][ServerRpc][{currentCount}] invoked during the {parameters.Receive.UpdateStage} stage.");
m_ClientParams.Send.UpdateStage = parameters.Receive.UpdateStage;
m_ServerStagesReceived.Add(parameters.Receive.UpdateStage);
PingMySelfClientRpc(currentCount, m_ClientParams);
}
private void OnSendCounterServerRpc(int counter, ServerRpcParams parameters = default)
{
//This is just for debug purposes so I can trap for "non-local" clients
if (IsHost && parameters.Receive.SenderClientId == 0)
{
m_ClientSpecificCounters[parameters.Receive.SenderClientId] = counter;
}
else if (m_ClientSpecificCounters.ContainsKey(parameters.Receive.SenderClientId))
{
m_ClientSpecificCounters[parameters.Receive.SenderClientId] = counter;
}
}
private void ToggleReadyServerRpc(ServerRpcParams serverRpcParams = default)
{
for (int i = 0; i < lobbyPlayers.Count; i++)
{
if (lobbyPlayers[i].ClientId == serverRpcParams.Receive.SenderClientId)
{
lobbyPlayers[i] = new LobbyPlayerState(
lobbyPlayers[i].ClientId,
lobbyPlayers[i].PlayerName,
!lobbyPlayers[i].IsReady
);
}
}
}
private void StartGameServerRpc(ServerRpcParams serverRpcParams = default)
{
if (serverRpcParams.Receive.SenderClientId != NetworkManager.Singleton.LocalClientId)
{
return;
}
if (!IsEveryoneReady())
{
return;
}
ServerGameNetPortal.Instance.StartGame();
}
private void TryGrabServerRpc(ServerRpcParams serverRpcParams = default)
{
if (!m_IsGrabbed.Value)
{
var senderClientId = serverRpcParams.Receive.SenderClientId;
var senderPlayerObject = NetworkManager.SpawnManager.GetPlayerNetworkObject(senderClientId);
if (senderPlayerObject != null)
{
NetworkObject.ChangeOwnership(senderClientId);
m_IsGrabbed.Value = true;
UpdateParentClientRpc(NetworkObject.OwnerClientId, false);
}
}
}
public void __endSendServerRpc(NetworkSerializer serializer, ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery)
#endif
{
if (serializer == null)
{
return;
}
var rpcQueueContainer = NetworkManager.Singleton.RpcQueueContainer;
if (IsHost)
{
rpcQueueContainer.EndAddQueueItemToFrame(serializer.Writer, RpcQueueHistoryFrame.QueueFrameType.Inbound, serverRpcParams.Send.UpdateStage);
}
else
{
rpcQueueContainer.EndAddQueueItemToFrame(serializer.Writer, RpcQueueHistoryFrame.QueueFrameType.Outbound, NetworkUpdateStage.PostLateUpdate);
}
}
public void __endSendServerRpc(NetworkSerializer serializer, ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery)
#endif
#pragma warning restore IDE1006 // restore naming rule violation check
{
if (serializer == null)
{
return;
}
var rpcQueueContainer = NetworkManager.RpcQueueContainer;
if (IsHost)
{
rpcQueueContainer.EndAddQueueItemToFrame(serializer.Writer, RpcQueueHistoryFrame.QueueFrameType.Inbound, serverRpcParams.Send.UpdateStage);
}
else
{
rpcQueueContainer.EndAddQueueItemToFrame(serializer.Writer, RpcQueueHistoryFrame.QueueFrameType.Outbound, NetworkUpdateStage.PostLateUpdate);
}
}
void SubmitPositionRequestServerRpc(ServerRpcParams rpcParams = default)
{
Position.Value = GetRandomPositionOnPlane();
}
private void OnSendMultiParametersServerRpc(int count, float floatValue, long longValue, ServerRpcParams parameters = default)
{
m_ClientRpcParamsMultiParameter.Send.TargetClientIds[0] = parameters.Receive.SenderClientId;
m_ClientRpcParamsMultiParameter.Send.UpdateStage = NetworkUpdateStage.EarlyUpdate;
OnSendMultiParametersClientRpc(count, floatValue, longValue, m_ClientRpcParamsMultiParameter);
}
private void OnSendNoParametersServerRpc(ServerRpcParams parameters = default)
{
m_ClientRpcParamsMultiParameter.Send.TargetClientIds[0] = parameters.Receive.SenderClientId;
m_ClientRpcParamsMultiParameter.Send.UpdateStage = NetworkUpdateStage.Update;
OnSendNoParametersClientRpc(m_ClientRpcParamsMultiParameter);
}
public void SetPlayerSpeedServerRpc(float speed, ServerRpcParams rpcParams = default)
{
variableSpeed.Value = speed;
}
// RuntimeAccessModifiersILPP will make this `protected` internal NetworkSerializer __beginSendServerRpc(ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery)
void UpdatePositionServerRpc(Vector3 d, ServerRpcParams rpcParams = default)
{
Position.Value = d;
}
// RuntimeAccessModifiersILPP will make this `protected` internal void __endSendServerRpc(NetworkSerializer serializer, ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery)
void SetTargetAngleServerRpc(Vector2 direction, ServerRpcParams rpcParams = default)
{
direction.Normalize();
TargetAngle.Value = Mathf.Atan2(direction.y, direction.x) * Mathf.Rad2Deg;
}
public void SetPlayerAttackDelayServerRpc(float delay, ServerRpcParams rpcParams = default)
{
variableAttackDelay.Value = delay;
}
public void SetPlayerDamageServerRpc(int dmg, ServerRpcParams rpcParams = default)
{
variableDamage.Value = dmg;
}
void InitializeHPServerRpc(int InitialHP, ServerRpcParams rpcParams = default)
{
HP.Value = InitialHP;
HPHasBeenSet.Value = true;
}
void UpdateAttackServerRpc(Vector3 a, ServerRpcParams rpcParams = default)
{
AttackDir.Value = a;
NAttacks.Value++;
}
private void SubmitTransformServerRpc(Vector3 position, Vector3 eulerAngles, ServerRpcParams rpcParams = default)
{
if (!enabled)
{
return;
}
if (IsMoveValidDelegate != null && !IsMoveValidDelegate(rpcParams.Receive.SenderClientId, m_LerpEndPos, position))
{
//Invalid move!
//TODO: Add rubber band (just a message telling them to go back)
return;
}
if (!IsClient)
{
// Dedicated server
ApplyTransformInternal(position, Quaternion.Euler(eulerAngles));
}
if (EnableRange)
{
for (int i = 0; i < NetworkManager.Singleton.ConnectedClientsList.Count; i++)
{
if (!m_ClientSendInfo.ContainsKey(NetworkManager.Singleton.ConnectedClientsList[i].ClientId))
{
m_ClientSendInfo.Add(NetworkManager.Singleton.ConnectedClientsList[i].ClientId, new ClientSendInfo()
{
LastMissedPosition = null,
LastMissedRotation = null,
LastSent = 0
});
}
ClientSendInfo info = m_ClientSendInfo[NetworkManager.Singleton.ConnectedClientsList[i].ClientId];
Vector3? receiverPosition = NetworkManager.Singleton.ConnectedClientsList[i].PlayerObject == null ? null : new Vector3?(NetworkManager.Singleton.ConnectedClientsList[i].PlayerObject.transform.position);
Vector3? senderPosition = NetworkManager.Singleton.ConnectedClients[OwnerClientId].PlayerObject == null ? null : new Vector3?(NetworkManager.Singleton.ConnectedClients[OwnerClientId].PlayerObject.transform.position);
if ((receiverPosition == null || senderPosition == null && NetworkManager.Singleton.NetworkTime - info.LastSent >= (1f / FixedSendsPerSecond)) || NetworkManager.Singleton.NetworkTime - info.LastSent >= GetTimeForLerp(receiverPosition.Value, senderPosition.Value))
{
info.LastSent = NetworkManager.Singleton.NetworkTime;
info.LastMissedPosition = null;
info.LastMissedRotation = null;
ApplyTransformClientRpc(position, eulerAngles,
new ClientRpcParams {
Send = new ClientRpcSendParams {
TargetClientIds = new[] { NetworkManager.Singleton.ConnectedClientsList[i].ClientId }
}
});
}
else
{
info.LastMissedPosition = position;
info.LastMissedRotation = Quaternion.Euler(eulerAngles);
}
}
}
else
{
ApplyTransformClientRpc(position, eulerAngles,
new ClientRpcParams {
Send = new ClientRpcSendParams {
TargetClientIds = NetworkManager.Singleton.ConnectedClientsList.Where(c => c.ClientId != OwnerClientId).Select(c => c.ClientId).ToArray()
}
});
}
}
public void PingServerRPC(int pingId, ServerRpcParams serverParams = default)
{
PongClientRPC(pingId, m_PongClientParams);
}
public void SetPlayerNameServerRpc(string name, ServerRpcParams rpcParams = default)
{
PlayerName.Value = name;
}
void IAmReadyServerRpc(ServerRpcParams rpcParams = default)
{
Readies.Value++;
}
void SubmitPositionRequestServerRpc(Vector2 direction, ServerRpcParams rpcParams = default)
{
ChangeVelocity(direction);
}
