public void ServerDestroyID(NetIdentity identity)
{
if (!isServer())
{
return;
}
ServerSend.DestroyID(identity);
}
public void Start()
{
identity = GetComponentInParent <NetIdentity>();
if (identity != null)
{
evtCollision = identity.RegisterEvent(OnReportCollision);
}
}
public void Start()
{
identity = GetComponent <NetIdentity>();
if (identity != null)
{
evtCollision = identity.RegisterEvent(OnTriggerMusic);
}
}
public void StartNetwork(NetIdentity identity)
{
if (showDebug)
{
Debug.Log(base.name + " Start Network ");
}
this.identity = identity;
}
private void Start()
{
identity = GetComponentInParent <NetIdentity>();
if (identity != null)
{
evtCollisionAudio = identity.RegisterEvent(OnReceiveCollisionAudio);
}
}
public void StartNetwork(NetIdentity identity)
{
if (showDebug)
{
Debug.Log(base.name + " Start Network ");
}
this.identity = identity;
evtPlug = identity.RegisterEvent(OnPlug);
}
protected override void Awake()
{
base.Awake();
cMeshRender = GetComponent <MeshRenderer>();
rbody = GetComponent <Rigidbody>();
NetIdentity.RegisterEventHandler(TinyNetIdentity.TinyNetComponentEvents.OnStartClient, OnStartClient);
}
/// <summary>
/// Connect to a relay server
/// </summary>
public static T ConnectRelay <T>(SteamId serverId, int virtualport = 0) where T : ConnectionInterface, new()
{
var t = new T();
NetIdentity identity = serverId;
t.Connection = Internal.ConnectP2P(ref identity, virtualport);
SetConnectionInterface(t.Connection.Id, t);
return(t);
}
public void Start()
{
audioSource = GetComponent <AudioSource>();
identity = GetComponent <NetIdentity>();
if (identity != null)
{
evtCollision = identity.RegisterEvent(OnPlayEasterEggAudio);
}
}
private void Start()
{
if (showDebug)
{
Debug.Log(base.name + " Started ");
}
identity = GetComponent <NetIdentity>();
evtHit = identity.RegisterEvent(OnHit);
}
public static T ConnectRelay <T>(SteamId serverId, int virtualport = 0)
where T : ConnectionInterface, new()
{
T t = Activator.CreateInstance <T>();
NetIdentity netIdentity = serverId;
t.Connection = SteamNetworkingSockets.Internal.ConnectP2P(ref netIdentity, virtualport);
SteamNetworkingSockets.SetConnectionInterface(t.Connection.Id, t);
return(t);
}
/// <summary>
/// Connect to a relay server
/// </summary>
public static T ConnectRelay <T>(SteamId serverId, int virtualport = 0) where T : ConnectionManager, new()
{
var t = new T();
NetIdentity identity = serverId;
var options = Array.Empty <NetKeyValue>();
t.Connection = Internal.ConnectP2P(ref identity, virtualport, options.Length, options);
SetConnectionManager(t.Connection.Id, t);
return(t);
}
public override void OnMessage(Connection connection, NetIdentity identity, IntPtr data, int size, long messageNum, long recvTime,
int channel)
{
base.OnMessage(connection, identity, data, size, messageNum, recvTime, channel);
foreach (var connected in Connected.Where(connected => connected != connection))
{
connected.SendMessage(data, size);
}
NetworkManager.NetworkServerListener.OnMessageReceived(connection, identity, data, size, messageNum, recvTime, channel);
}
public void RpcTakeDamage(string inNetId)
{
NetworkIdentity[] netArry = FindObjectsOfType <NetworkIdentity>();
foreach (NetworkIdentity NetIdentity in netArry)
{
if (NetIdentity.netId.ToString() == inNetId)
{
//Take Damage SyncVar?
NetIdentity.GetComponent <PlayerAnimationController>().TakeDamage();
}
}
}
private void Start()
{
if (showDebug)
{
Debug.Log(base.name + " Started ");
}
identity = GetComponentInParent <NetIdentity>();
if (identity != null)
{
evtImpact = identity.RegisterEvent(OnImpact);
}
}
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;
}
void Update()
{
if (!Server.active)
{
return;
}
if (Time.time - lastUpdateTime > VisibilityUpdateInterval)
{
NetIdentity.RebuildObservers(false);
lastUpdateTime = Time.time;
}
}
protected override void Awake()
{
rbody = GetComponent <Rigidbody>();
movespeedPow = movementSpeed * movementSpeed;
NetIdentity.RegisterEventHandler(TinyNetIdentity.TinyNetComponentEvents.OnNetworkCreate, OnNetworkCreate);
NetIdentity.RegisterEventHandler(TinyNetIdentity.TinyNetComponentEvents.OnStartServer, OnStartServer);
NetIdentity.RegisterEventHandler(TinyNetIdentity.TinyNetComponentEvents.OnStartAuthority, OnStartAuthority);
NetIdentity.RegisterEventHandler(TinyNetIdentity.TinyNetComponentEvents.OnGiveAuthority, OnGiveAuthority);
NetIdentity.RegisterEventHandler(TinyNetIdentity.TinyNetComponentEvents.OnStartClient, OnStartClient);
NetIdentity.RegisterEventHandler(TinyNetIdentity.TinyNetComponentEvents.OnStateUpdate, OnStateUpdate);
NetIdentity.RegisterEventHandler(TinyNetIdentity.TinyNetComponentEvents.OnNetworkDestroy, OnNetworkDestroy);
}
/// <summary>
/// Connect to a relay server.
/// </summary>
public static ConnectionManager ConnectRelay(SteamId serverId, int virtualport, IConnectionManager iface)
{
NetIdentity identity = serverId;
var options = Array.Empty <NetKeyValue>();
var connection = Internal.ConnectP2P(ref identity, virtualport, options.Length, options);
var t = new ConnectionManager
{
Connection = connection,
Interface = iface
};
SetConnectionManager(t.Connection.Id, t);
return(t);
}
public static void Spawn(NetIdentity id)
{
using (Packet packet = new Packet((int)ServerPackets.Spawn)){
packet.Write(id.prefabID);
packet.Write(id.id);
packet.Write(id.ownerId);
packet.Write(id.transform.position);
packet.Write(id.behaviours.Length);
for (int i = 0; i < id.behaviours.Length; i++)
{
packet.Write(id.behaviours[i].id);
}
SendTcpDataToAll(packet);
}
}
public void OnMessageReceived(Connection connection, NetIdentity identity, IntPtr data, int size, long messageNum,
long recvTime, int channel)
{
var received = _messagePackager.Unpack(data, size);
var receivedType = received.GetType();
if (!_packetConsumers.ContainsKey(receivedType))
{
return;
}
var consumer = _packetConsumers[receivedType];
consumer.Consume(connection, received);
_networkManager.RelayMessage(data, size, connection);
}
public override void OnMessage(Connection connection, NetIdentity identity, IntPtr data, int size, long messageNum, long recvTime, int channel)
{
byte[] bytes = new byte[size];
Marshal.Copy(data, bytes, 0, size);
using (MemoryStream stream = new MemoryStream())
{
stream.Write(bytes, 0, size);
stream.Position = 0;
if (_binaryFormatter.Deserialize(stream) is PlayerMessage message)
{
message.Sender.Connection = connection;
OnMessageReceived?.Invoke(message);
}
}
}
/// <summary>
/// Connect to a relay server
/// </summary>
public static T ConnectRelay <T>(SteamId serverId, int virtualport = 0) where T : ConnectionManager, new()
{
var t = new T();
NetIdentity identity = serverId;
var options = new NetKeyValue[]
{
new NetKeyValue()
{
Value = NetConfig.IP_AllowWithoutAuth,
DataType = NetConfigType.Int32,
Int32Value = SteamNetworkingUtils.AllowWithoutAuth
}
};
t.Connection = Internal.ConnectP2P(ref identity, virtualport, options.Length, options);
SetConnectionManager(t.Connection.Id, t);
return(t);
}
private void OnEnable()
{
identity = GetComponentInParent <NetIdentity>();
evtPull = identity.RegisterEvent(OnPull);
if (NetGame.isServer)
{
if (joint == null)
{
joint = CreateJoint();
}
anchor = axis.TransformPoint(Vector3.forward);
totalTravel = 0f;
if (groundedIgnoreCollider != null)
{
IgnoreCollision.Ignore(base.transform, groundedIgnoreCollider);
}
}
}
public override unsafe void OnMessage(Connection connection, NetIdentity identity, IntPtr data, int size, long messageNum, long recvTime, int channel)
{
// We're only sending strings, so it's fine to read this like this
var str = UTF8Encoding.UTF8.GetString((byte *)data, size);
Console.WriteLine($"[SOCKET][{connection}[{identity}][{messageNum}][{recvTime}][{channel}] \"{str}\"");
if (str.Contains("Hello, How are you"))
{
connection.SendMessage("I'm great thanks, how about yourself?");
}
if (str.Contains("bye"))
{
connection.SendMessage("See you later, hater.");
connection.Flush();
connection.Close(true, 10, "Said Bye");
}
}
public override void OnMessage(Connection connection, NetIdentity identity, IntPtr data, int size, long messageNum, long recvTime, int channel)
{
if (steamToMirrorIds.TryGetValue(connection.Id, out int connectionId))
{
if (transport.debug)
{
Debug.Log($"We got a message from {identity} / connectionId: {connectionId}");
}
base.OnMessage(connection, identity, data, size, messageNum, recvTime, channel);
byte[] mIn = new byte[size];
Marshal.Copy(data, mIn, 0, size);
ArraySegment <byte> mOut = new ArraySegment <byte>(mIn);
transport.OnServerDataReceived.Invoke(connectionId, mOut, channel);
}
else
{
Debug.Log($"Server.OnMessage: Unable to get steam connection.Id to mirror id mapping: connection.Id: {connection.Id}");
}
}
public void Start()
{
Human componentInParent = GetComponentInParent <Human>();
Ragdoll ragdoll = componentInParent.ragdoll;
CollisionAudioSensor component = ragdoll.partLeftFoot.transform.GetComponent <CollisionAudioSensor>();
CollisionAudioSensor component2 = ragdoll.partRightFoot.transform.GetComponent <CollisionAudioSensor>();
leftHand = ragdoll.partLeftHand.transform;
rightHand = ragdoll.partRightHand.transform;
ragdoll.partLeftHand.sensor.onGrabTap = HandGrabLeft;
ragdoll.partRightHand.sensor.onGrabTap = HandGrabRight;
CollisionAudioSensor[] componentsInChildren = GetComponentsInChildren <CollisionAudioSensor>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
componentsInChildren[i].id = -i;
}
identity = GetComponentInParent <NetIdentity>();
if (identity != null)
{
evtHandGrab = identity.RegisterEvent(OnHandGrab);
}
}
/// <summary>
/// Connect to a relay server
/// </summary>
public static ConnectionManager ConnectRelay(SteamId serverId, int virtualport, IConnectionManager iface)
{
NetIdentity identity = serverId;
var options = new NetKeyValue[]
{
new NetKeyValue()
{
Value = NetConfig.IP_AllowWithoutAuth,
DataType = NetConfigType.Int32,
Int32Value = SteamNetworkingUtils.AllowWithoutAuth
}
};
var connection = Internal.ConnectP2P(ref identity, virtualport, options.Length, options);
var t = new ConnectionManager
{
Connection = connection,
Interface = iface
};
SetConnectionManager(t.Connection.Id, t);
return(t);
}
public void StartNetwork(NetIdentity identity)
{
}
private void Awake()
{
identity = GetComponentInParent <NetIdentity>();
evtBeep = identity.RegisterEvent(OnBeep);
}
