InnoLab/com.unity.netcode.gameobjects
Archived
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

com.unity.netcode.gameobjects@1.0.0-pre.7

Browse Source 
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).

## [1.0.0-pre.7] - 2022-04-01

### Added

- Added editor only check prior to entering into play mode if the currently open and active scene is in the build list and if not displays a dialog box asking the user if they would like to automatically add it prior to entering into play mode. (#1828)
- Added `UnityTransport` implementation and `com.unity.transport` package dependency (#1823)
- Added `NetworkVariableWritePermission` to `NetworkVariableBase` and implemented `Owner` client writable netvars. (#1762)
- `UnityTransport` settings can now be set programmatically. (#1845)
- `FastBufferWriter` and Reader IsInitialized property. (#1859)

### Changed

- Updated `UnityTransport` dependency on `com.unity.transport` to 1.0.0 (#1849)

### Removed

- Removed `SnapshotSystem` (#1852)
- Removed `com.unity.modules.animation`, `com.unity.modules.physics` and `com.unity.modules.physics2d` dependencies from the package (#1812)
- Removed `com.unity.collections` dependency from the package (#1849)

### Fixed
- Fixed in-scene placed NetworkObjects not being found/ignored after a client disconnects and then reconnects. (#1850)
- Fixed issue where `UnityTransport` send queues were not flushed when calling `DisconnectLocalClient` or `DisconnectRemoteClient`. (#1847)
- Fixed NetworkBehaviour dependency verification check for an existing NetworkObject not searching from root parent transform relative GameObject. (#1841)
- Fixed issue where entries were not being removed from the NetworkSpawnManager.OwnershipToObjectsTable. (#1838)
- Fixed ClientRpcs would always send to all connected clients by default as opposed to only sending to the NetworkObject's Observers list by default. (#1836)
- Fixed clarity for NetworkSceneManager client side notification when it receives a scene hash value that does not exist in its local hash table. (#1828)
- Fixed client throws a key not found exception when it times out using UNet or UTP. (#1821)
- Fixed network variable updates are no longer limited to 32,768 bytes when NetworkConfig.EnsureNetworkVariableLengthSafety is enabled. The limits are now determined by what the transport can send in a message. (#1811)
- Fixed in-scene NetworkObjects get destroyed if a client fails to connect and shuts down the NetworkManager. (#1809)
- Fixed user never being notified in the editor that a NetworkBehaviour requires a NetworkObject to function properly. (#1808)
- Fixed PlayerObjects and dynamically spawned NetworkObjects not being added to the NetworkClient's OwnedObjects (#1801)
- Fixed issue where NetworkManager would continue starting even if the NetworkTransport selected failed. (#1780)
- Fixed issue when spawning new player if an already existing player exists it does not remove IsPlayer from the previous player (#1779)
- Fixed lack of notification that NetworkManager and NetworkObject cannot be added to the same GameObject with in-editor notifications (#1777)
- Fixed parenting warning printing for false positives (#1855)
This commit is contained in:
Unity Technologies
2022-04-01 00:00:00 +00:00
parent 5b4aaa8b59
commit 60e2dabef4
123 changed files with 5751 additions and 3419 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
Runtime/NetworkVariable/Collections/NetworkList.cs
View File

@@ -24,17 +24,12 @@ namespace Unity.Netcode
/// </summary>
public event OnListChangedDelegate OnListChanged;
/// <summary>
/// Creates a NetworkList with the default value and settings
/// </summary>
public NetworkList() { }
/// <summary>
/// Creates a NetworkList with the default value and custom settings
/// </summary>
/// <param name="readPerm">The read permission to use for the NetworkList</param>
/// <param name="values">The initial value to use for the NetworkList</param>
public NetworkList(NetworkVariableReadPermission readPerm, IEnumerable<T> values) : base(readPerm)
public NetworkList(IEnumerable<T> values = default,
NetworkVariableReadPermission readPerm = DefaultReadPerm,
NetworkVariableWritePermission writePerm = DefaultWritePerm)
: base(readPerm, writePerm)
{
foreach (var value in values)
{
@@ -42,19 +37,6 @@ namespace Unity.Netcode
}
}
/// <summary>
/// Creates a NetworkList with a custom value and the default settings
/// </summary>
/// <param name="values">The initial value to use for the NetworkList</param>
public NetworkList(IEnumerable<T> values)
{
foreach (var value in values)
{
m_List.Add(value);
}
}
/// <inheritdoc />
public override void ResetDirty()
{

79
Runtime/NetworkVariable/NetworkVariable.cs
View File

@@ -1,5 +1,7 @@
using UnityEngine;
using System;
using System.Runtime.CompilerServices;
using Unity.Collections.LowLevel.Unsafe;
namespace Unity.Netcode
{
@@ -22,7 +24,8 @@ namespace Unity.Netcode
}
// Functions that serialize other types
private static void WriteValue<TForMethod>(FastBufferWriter writer, in TForMethod value) where TForMethod : unmanaged
private static void WriteValue<TForMethod>(FastBufferWriter writer, in TForMethod value)
where TForMethod : unmanaged
{
writer.WriteValueSafe(value);
}
@@ -37,16 +40,13 @@ namespace Unity.Netcode
internal delegate void ReadDelegate<TForMethod>(FastBufferReader reader, out TForMethod value);
// These static delegates provide the right implementation for writing and reading a particular network variable
// type.
//
// These static delegates provide the right implementation for writing and reading a particular network variable type.
// For most types, these default to WriteValue() and ReadValue(), which perform simple memcpy operations.
//
// INetworkSerializableILPP will generate startup code that will set it to WriteNetworkSerializable()
// and ReadNetworkSerializable() for INetworkSerializable types, which will call NetworkSerialize().
//
// In the future we may be able to use this to provide packing implementations for floats and integers to
// optimize bandwidth usage.
// In the future we may be able to use this to provide packing implementations for floats and integers to optimize bandwidth usage.
//
// The reason this is done is to avoid runtime reflection and boxing in NetworkVariable - without this,
// NetworkVariable would need to do a `var is INetworkSerializable` check, and then cast to INetworkSerializable,
@@ -69,38 +69,11 @@ namespace Unity.Netcode
/// </summary>
public OnValueChangedDelegate OnValueChanged;
/// <summary>
/// Creates a NetworkVariable with the default value and custom read permission
/// </summary>
/// <param name="readPerm">The read permission for the NetworkVariable</param>
public NetworkVariable()
{
}
/// <summary>
/// Creates a NetworkVariable with the default value and custom read permission
/// </summary>
/// <param name="readPerm">The read permission for the NetworkVariable</param>
public NetworkVariable(NetworkVariableReadPermission readPerm) : base(readPerm)
{
}
/// <summary>
/// Creates a NetworkVariable with a custom value and custom settings
/// </summary>
/// <param name="readPerm">The read permission for the NetworkVariable</param>
/// <param name="value">The initial value to use for the NetworkVariable</param>
public NetworkVariable(NetworkVariableReadPermission readPerm, T value) : base(readPerm)
{
m_InternalValue = value;
}
/// <summary>
/// Creates a NetworkVariable with a custom value and the default read permission
/// </summary>
/// <param name="value">The initial value to use for the NetworkVariable</param>
public NetworkVariable(T value)
public NetworkVariable(T value = default,
NetworkVariableReadPermission readPerm = DefaultReadPerm,
NetworkVariableWritePermission writePerm = DefaultWritePerm)
: base(readPerm, writePerm)
{
m_InternalValue = value;
}
@@ -116,19 +89,36 @@ namespace Unity.Netcode
get => m_InternalValue;
set
{
// this could be improved. The Networking Manager is not always initialized here
// Good place to decouple network manager from the network variable
// Also, note this is not really very water-tight, if you are running as a host
// we cannot tell if a NetworkVariable write is happening inside client-ish code
if (m_NetworkBehaviour && (m_NetworkBehaviour.NetworkManager.IsClient && !m_NetworkBehaviour.NetworkManager.IsHost))
// Compare bitwise
if (ValueEquals(ref m_InternalValue, ref value))
{
throw new InvalidOperationException("Client can't write to NetworkVariables");
return;
}
if (m_NetworkBehaviour && !CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
{
throw new InvalidOperationException("Client is not allowed to write to this NetworkVariable");
}
Set(value);
}
}
// Compares two values of the same unmanaged type by underlying memory
// Ignoring any overriden value checks
// Size is fixed
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static unsafe bool ValueEquals(ref T a, ref T b)
{
// get unmanaged pointers
var aptr = UnsafeUtility.AddressOf(ref a);
var bptr = UnsafeUtility.AddressOf(ref b);
// compare addresses
return UnsafeUtility.MemCmp(aptr, bptr, sizeof(T)) == 0;
}
private protected void Set(T value)
{
m_IsDirty = true;
@@ -146,7 +136,6 @@ namespace Unity.Netcode
WriteField(writer);
}
/// <summary>
/// Reads value from the reader and applies it
/// </summary>

41
Runtime/NetworkVariable/NetworkVariableBase.cs
View File

@@ -19,9 +19,15 @@ namespace Unity.Netcode
m_NetworkBehaviour = networkBehaviour;
}
protected NetworkVariableBase(NetworkVariableReadPermission readPermIn = NetworkVariableReadPermission.Everyone)
public const NetworkVariableReadPermission DefaultReadPerm = NetworkVariableReadPermission.Everyone;
public const NetworkVariableWritePermission DefaultWritePerm = NetworkVariableWritePermission.Server;
protected NetworkVariableBase(
NetworkVariableReadPermission readPerm = DefaultReadPerm,
NetworkVariableWritePermission writePerm = DefaultWritePerm)
{
ReadPerm = readPermIn;
ReadPerm = readPerm;
WritePerm = writePerm;
}
private protected bool m_IsDirty;
@@ -37,6 +43,8 @@ namespace Unity.Netcode
/// </summary>
public readonly NetworkVariableReadPermission ReadPerm;
public readonly NetworkVariableWritePermission WritePerm;
/// <summary>
/// Sets whether or not the variable needs to be delta synced
/// </summary>
@@ -62,26 +70,28 @@ namespace Unity.Netcode
return m_IsDirty;
}
public virtual bool ShouldWrite(ulong clientId, bool isServer)
{
return IsDirty() && isServer && CanClientRead(clientId);
}
/// <summary>
/// Gets Whether or not a specific client can read to the varaible
/// </summary>
/// <param name="clientId">The clientId of the remote client</param>
/// <returns>Whether or not the client can read to the variable</returns>
public bool CanClientRead(ulong clientId)
{
switch (ReadPerm)
{
default:
case NetworkVariableReadPermission.Everyone:
return true;
case NetworkVariableReadPermission.OwnerOnly:
return m_NetworkBehaviour.OwnerClientId == clientId;
case NetworkVariableReadPermission.Owner:
return clientId == m_NetworkBehaviour.NetworkObject.OwnerClientId;
}
}
public bool CanClientWrite(ulong clientId)
{
switch (WritePerm)
{
default:
case NetworkVariableWritePermission.Server:
return clientId == NetworkManager.ServerClientId;
case NetworkVariableWritePermission.Owner:
return clientId == m_NetworkBehaviour.NetworkObject.OwnerClientId;
}
return true;
}
/// <summary>
@@ -107,7 +117,6 @@ namespace Unity.Netcode
/// </summary>
/// <param name="reader">The stream to read the delta from</param>
/// <param name="keepDirtyDelta">Whether or not the delta should be kept as dirty or consumed</param>
public abstract void ReadDelta(FastBufferReader reader, bool keepDirtyDelta);
public virtual void Dispose()

16
Runtime/NetworkVariable/NetworkVariablePermission.cs
View File

@@ -1,18 +1,14 @@
namespace Unity.Netcode
{
/// <summary>
/// Permission type
/// </summary>
public enum NetworkVariableReadPermission
{
/// <summary>
/// Everyone
/// </summary>
Everyone,
Owner,
}
/// <summary>
/// Owner-ownly
/// </summary>
OwnerOnly,
public enum NetworkVariableWritePermission
{
Server,
Owner
}
}