quakeball/Assets/Scripts/Networking/Instances/Client.cs

183 lines
6.9 KiB
C#
Raw Normal View History

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
2020-08-07 20:24:43 +02:00
using NeonTea.Quakeball.Players;
using NeonTea.Quakeball.Networking.Packets;
2020-08-07 05:24:46 +02:00
using NeonTea.Quakeball.Interface;
using NeonTea.Quakeball.TeaNet.Peers;
using NeonTea.Quakeball.TeaNet.Packets;
namespace NeonTea.Quakeball.Networking.Instances {
public class Client : NetInstance {
private NetChaperone Net;
private Connection Server;
private Dictionary<ulong, NetPlayer> Players = new Dictionary<ulong, NetPlayer>();
private NetPlayer LocalPlayer;
2020-08-07 05:24:46 +02:00
private bool SelfIdentified = false;
2020-08-08 02:35:19 +02:00
public float Ping { get; private set; }
private float LastPingReceived;
private byte LastPingIdent;
public override void Start(string address, int port, PeerMessageListener listener) {
if (Peer.Running) {
return;
}
Peer = new Peer(Fingerprint);
Peer.MessageListener = listener;
Peer.Start(0);
byte ident = Peer.RegisterProtocol(new GameProtocol(this));
Peer.Connect(address, port, ident);
Net = GameObject.FindGameObjectWithTag("Net").GetComponent<NetChaperone>();
LocalPlayer = new NetPlayer(ulong.MaxValue - 1);
LocalPlayer.Controlled = GameObject.FindGameObjectWithTag("Player").GetComponent<Player>();
}
public override void OnStop() {
Peer.Disconnect(Server.uid);
Server = null;
foreach (NetPlayer p in Players.Values) {
if (p.Id != LocalPlayer.Id) {
GameObject.Destroy(p.Controlled.gameObject);
}
}
Players.Clear();
Ping = 0;
}
public override void Connected(Connection conn) {
2020-08-07 05:24:46 +02:00
Terminal.Singleton.Println($"{conn.uid} Connected");
if (Server == null) {
Server = conn;
} else {
Peer.Disconnect(conn.uid);
}
}
public override void Disconnected(Connection conn) {
2020-08-07 05:24:46 +02:00
Terminal.Singleton.Println($"{conn.uid} Disconnected: {conn.ClosingReason}");
if (Server == conn) {
Server = null;
foreach (NetPlayer p in Players.Values) {
if (p.Id != LocalPlayer.Id) {
GameObject.Destroy(p.Controlled.gameObject);
}
}
Players.Clear();
Peer.Stop();
Ping = 0;
}
}
public override void Handle(Connection conn, Packet packet) {
if (packet is SelfIdentPckt) {
SelfIdentPckt ident = (SelfIdentPckt)packet;
LocalPlayer.Id = ident.PlayerId;
Players.Add(LocalPlayer.Id, LocalPlayer);
2020-08-07 05:24:46 +02:00
SelfIdentified = true;
SpawnPckt spawn = new SpawnPckt();
spawn.Location = LocalPlayer.Controlled.transform.position;
Peer.SendReliable(Server.uid, spawn);
} else if (packet is SpawnPckt) {
SpawnPckt spawn = (SpawnPckt)packet;
if (spawn.PlayerId == LocalPlayer.Id) {
return; // Ignore, it's their own.
}
Player obj = Net.SpawnPlayer(spawn.Location).GetComponent<Player>();
NetPlayer player = new NetPlayer(spawn.PlayerId, obj);
2020-08-07 05:24:46 +02:00
Players.Add(spawn.PlayerId, player);
} else if (packet is MultiplePlayerUpdatesPckt) {
MultiplePlayerUpdatesPckt multiple = (MultiplePlayerUpdatesPckt)packet;
foreach (PlayerUpdatePckt pckt in multiple.Updates) {
HandleUpdatePlayer(pckt);
2020-08-07 05:24:46 +02:00
}
} else if (packet is MultipleSyncsPckt) {
MultipleSyncsPckt multiple = (MultipleSyncsPckt)packet;
foreach (PlayerSyncPacket pckt in multiple.Syncs) {
HandleSyncPckt(pckt);
}
2020-08-08 03:21:02 +02:00
} else if (packet is PlayerActionPckt) {
PlayerActionPckt action = (PlayerActionPckt)packet;
HandleAction(action);
2020-08-08 02:35:19 +02:00
} else if (packet is PingPckt) {
PingPckt ping = (PingPckt)packet;
ping.ClientReceived = true;
if (!ping.ServerReceived) {
Peer.SendReliable(Server.uid, ping);
LastPingIdent = ping.Identifier;
LastPingReceived = Time.time;
} else {
if (LastPingIdent == ping.Identifier) {
Ping = Time.time - LastPingReceived;
} else {
Ping = Instances.Server.PingInterval + 0.001f;
}
2020-08-08 03:44:45 +02:00
UpdatePingBias();
2020-08-08 02:35:19 +02:00
}
2020-08-07 05:24:46 +02:00
}
}
2020-08-07 22:09:31 +02:00
private void HandleUpdatePlayer(PlayerUpdatePckt pckt) {
if (pckt.PlayerId == LocalPlayer.Id) {
return; // Ignore, again.
}
Players[pckt.PlayerId].Controlled.ProcessUpdatePacket(pckt);
2020-08-07 22:09:31 +02:00
}
private void HandleSyncPckt(PlayerSyncPacket syncPckt) {
if (syncPckt.Unsynced || syncPckt.PlayerId != LocalPlayer.Id) {
Players[syncPckt.PlayerId].Controlled.ProcessSyncPacket(syncPckt);
}
}
2020-08-08 03:21:02 +02:00
private void HandleAction(PlayerActionPckt action) {
switch (action.Action) {
case PlayerAction.Jump:
Players[action.PlayerId].Controlled.Jump();
break;
2020-08-08 04:26:17 +02:00
case PlayerAction.Shoot:
ShootData shootData = (ShootData)action.Serializable;
HandleSyncPckt(shootData.SyncPckt);
Players[action.PlayerId].Controlled.Shoot();
break;
2020-08-08 03:21:02 +02:00
}
}
2020-08-08 03:44:45 +02:00
private void UpdatePingBias() {
foreach (NetPlayer p in Players.Values) {
if (p.Id != LocalPlayer.Id) {
p.Controlled.PingBias = Ping;
}
}
}
public override void UpdateLocalPlayer() {
if (SelfIdentified && Server != null) {
2020-08-07 23:59:51 +02:00
PlayerUpdatePckt pckt = LocalPlayer.Controlled.CreateUpdatePacket();
2020-08-07 05:24:46 +02:00
Peer.SendUnreliable(Server.uid, pckt);
}
}
2020-08-08 04:26:17 +02:00
public override void LocalPlayerAction(PlayerAction action, Serializable serializable = null) {
2020-08-07 22:09:31 +02:00
if (SelfIdentified && Server != null) {
2020-08-08 04:26:17 +02:00
PlayerActionPckt actionPckt = new PlayerActionPckt(action, serializable);
Peer.SendReliable(Server.uid, actionPckt);
}
}
2020-08-07 23:57:11 +02:00
public override void SendPlayerSync() {
if (SelfIdentified && Server != null) {
PlayerSyncPacket packet = LocalPlayer.Controlled.CreateSyncPacket();
Peer.SendUnreliable(Server.uid, packet);
2020-08-07 23:57:11 +02:00
}
}
}
}