private void FireGun(float angleToMouse)
{
int seed = Random.Range(0, 300);
if (ServerSettings.instance.playerId != 0)
{
var packet = new DataPacket.FromClient();
packet = DataPacket.GetFromClientHealthPacket(angleToMouse, seed, bulletSpawnPoint.position,
ServerSettings.instance.playerId);
StartCoroutine(ClientTCP.instance.SendData(packet));
}
else
{
var packet = new DataPacket.FromServer();
packet = DataPacket.GetFromServerPositionPacket(angleToMouse, seed, bulletSpawnPoint.position,
ServerSettings.instance.playerId);
StartCoroutine(ServerTCP.instance.Broadcast(packet));
}
isShooting = true;
KnockBack();
SpawnAndFireBullets(angleToMouse, seed, bulletSpawnPoint.position, ServerSettings.instance.playerId, true);
cameraController.MoveBasedOnAngle(angleToMouse);
nextFire = fireDelay;
storeTime = 0.0f;
}
public IEnumerator SendData(DataPacket.FromClient packet)
{
bool ready = false;
//Check if the socket is ready, if not wait a frame then check again
//Consider reducing socket wait time to help frame rate on higher ping
while (!ready)
{
ArrayList listenList = new ArrayList();
listenList.Add(client.Client);
//Second conversion to microseconds
int waitTime = (int)ServerSettings.instance.TimeBetweenUpdatesClient * 1000000;
Socket.Select(null, listenList, null, waitTime);
if (!listenList.Contains(client.Client))
{
yield return(new WaitForEndOfFrame());
}
else
{
ready = true;
}
}
StreamWriter writer = null;
NetworkStream tcpStream = client.GetStream();
while (!tcpStream.CanWrite)
{
yield return(new WaitForEndOfFrame());
}
try
{
if (tcpStream.CanWrite)
{
//Convert the object to binary data
Byte[] msg = Serializer.BinarySerialize(packet);
//Write the binary to the network stream, then dispose of unnecessary data
tcpStream.Write(msg, 0, msg.Length);
tcpStream.Flush();
}
}
catch (Exception e)
{
Debug.LogError(e);
throw;
}
finally
{
if (writer != null)
{
writer.Close();
}
}
}
//Sends data every tick to the server letting it know it's transform
private IEnumerator ReportPosition(float timeBetweenUpdates)
{
while (true)
{
yield return(new WaitForSeconds(timeBetweenUpdates));
DataPacket.FromClient packet = new DataPacket.FromClient();
SerializableVector pos = transform.position;
packet = DataPacket.GetFromClientPositionPacket(pos, ServerSettings.instance.playerId);
ClientTCP.instance.SendDataWithLoss(packet);
}
}
//Used for movement, we don't particularly care if a movememt packet is lost
//Doesn't wait for the socket to be writeable, just checks once
public void SendDataWithLoss(DataPacket.FromClient packet)
{
ArrayList listenList = new ArrayList();
listenList.Add(client.Client);
//Second conversion to microseconds
int waitTime = (int)ServerSettings.instance.TimeBetweenUpdatesClient * 1000000;
Socket.Select(null, listenList, null, waitTime);
//If that socket isn't writeable, return
if (!listenList.Contains(client.Client))
{
return;
}
StreamWriter writer = null;
try
{
NetworkStream tcpStream = client.GetStream();
if (tcpStream.CanWrite)
{
Byte[] msg = Serializer.BinarySerialize(packet);
tcpStream.Write(msg, 0, msg.Length);
tcpStream.Flush();
}
}
catch (Exception e)
{
Debug.LogError(e);
throw;
}
finally
{
if (writer != null)
{
writer.Close();
}
}
}
//If we get hit by a shotgun blast, wait a bit and see how many bullets hit us before reporting it
private IEnumerator WaitForDamagePacket()
{
yield return(new WaitForSeconds(ServerSettings.instance.TimeBetweenUpdatesClient));
//If this is on a client, let the server know this enemy has been hit
if (ServerSettings.instance.playerId != 0)
{
//Update the enemy's hp on this client
ReceivePacketDamage(damageOverTime, characterNumber, -1);
var packet = new DataPacket.FromClient();
packet = DataPacket.GetFromClientHealthPacket(damageOverTime, characterNumber, ServerSettings.instance.playerId);
StartCoroutine(ClientTCP.instance.SendData(packet));
}
else
{
//Update the enemy's hp on this client
ReceivePacketDamage(damageOverTime, characterNumber, -1);
var packet = new DataPacket.FromServer();
packet = DataPacket.GetFromServerHealthPacket(damageOverTime, characterNumber, 0);
//Let the clients know the host has hit someone
StartCoroutine(ServerTCP.instance.Broadcast(packet));
}
damaged = false;
}
private IEnumerator OnIncomingData(ServerClient client)
{
bool ready = false;
//Check if the socket's open for reading
while (!ready)
{
ArrayList listenList = new ArrayList();
listenList.Add(client.tcp.Client);
//Second conversion to microseconds
int waitTime = (int)ServerSettings.instance.TimeBetweenUpdatesClient * 1000000;
Socket.Select(listenList, null, null, waitTime);
if (!listenList.Contains(client.tcp.Client))
{
yield return(new WaitForEndOfFrame());
}
else
{
ready = true;
}
}
//Get the binary data from the stream
var stream = client.tcp.GetStream();
while (!stream.CanRead)
{
yield return(new WaitForEndOfFrame());
}
byte[] data = new byte[DataPacket.byteSize];
BinaryReader br = new BinaryReader(stream);
br.Read(data, 0, DataPacket.byteSize);
try
{
DataPacket.FromClient packet = (DataPacket.FromClient)Serializer.BinaryDeserialize(data);
var serverPacket = new DataPacket.FromServer();
switch (packet.packetType)
{
case ServerMessages.POSITION:
//Don't rebroadcast the position instantly, it can wait since we might get other client updates inbetween
DataPacket.RaiseUpdateClientPosition(packet.positionVector, true, packet.playerId);
foreach (var serverClient in clients)
{
if (serverClient.clientId == packet.playerId)
{
serverClient.position = packet.positionVector;
serverClient.positionUpdated = true;
}
}
break;
case ServerMessages.FIREGUN:
DataPacket.RaiseClientFiredGun(packet.angle, packet.seed, packet.gunPosition, packet.playerId);
//Instantly send this packet out as it's important
serverPacket =
DataPacket.GetFromServerPositionPacket(packet.angle, packet.seed, packet.gunPosition,
packet.playerId);
StartCoroutine(Broadcast(serverPacket));
break;
case ServerMessages.HEALTH:
DataPacket.RaiseClientHit(packet.damage, packet.damageId, packet.shooterId);
//Instantly send this packet out as it's important
serverPacket = DataPacket.GetFromServerHealthPacket(packet.damage, packet.damageId, packet.shooterId);
StartCoroutine(Broadcast(serverPacket));
break;
default:
break;
}
}
catch (Exception e)
{
Debug.LogWarning(e);
}
}
