public void ApplyTransform(TransformMessage msg)
{
newPosition = new Vector3(msg.position[0], msg.position[1], msg.position[2]);
newRotation = new Quaternion(msg.rotation[0], msg.rotation[1], msg.rotation[2], msg.rotation[3]);
lastPosition = transform.position;
lastRotation = transform.rotation;
animator = transform.GetComponent <Animator>();
if (animator != null)
{
UpdateAnimator(animator, lastPosition, newPosition);
}
else
{
Debug.Log("No animator found");
}
Vector3 movmntVec = newPosition - lastPosition;
if (movmntVec.sqrMagnitude > maxMovement * maxMovement)
{
lastReception = 0;
}
else
{
lastReception = Time.realtimeSinceStartup;
}
}
private void SendCharPosition(Vector3 playerCharPos, int clientId)
{
TransformMessage m = new TransformMessage(clientId);
m.Position.Vect3 = playerCharPos;
SendUnreliableMessage(m, connectionId);
}
public void HandleIncomingMessage(Message msg)
{
switch (msg.GetNetworkMessageType())
{
case NetworkMessageType.Authenticate:
AuthenticateMessage mA = msg as AuthenticateMessage;
client.InitClient(mA.ClientId, "This is Client \n Id:" + mA.ClientId);
break;
case NetworkMessageType.Transform:
TransformMessage transformMsg = msg as TransformMessage;
if (!client.IsClientsCharacterCreated)
{
client.CreateClientsCharacter(transformMsg);
}
else
{
if (transformMsg.AcknowledgmentId != -1)
{
int acknoledgmentIdx = unAcknowledgedInputRequests.
FindIndex(it => it.RequestId == transformMsg.AcknowledgmentId);
if (acknoledgmentIdx != -1)
{
/* Removes this unacknowledged message and all that came before */
unAcknowledgedInputRequests.RemoveRange(0, acknoledgmentIdx + 1);
/* Peform position prediction based on last acknowledged position */
lastAcknowledgedPosition = transformMsg.Position.Vect3;
Vector3 newPosBasedOnAck = new Vector3(lastAcknowledgedPosition.x,
lastAcknowledgedPosition.y, lastAcknowledgedPosition.z);
foreach (InputMessage inputMsg in unAcknowledgedInputRequests)
{
newPosBasedOnAck += client.GetPositionChangeBasedOnInput(inputMsg);
}
client.SlowlyUpdateCharactersPosition(newPosBasedOnAck);
}
}
else
{
client.UpdateCharactersTransform(transformMsg);
}
}
break;
case NetworkMessageType.MultipleTransforms:
MultipleTranformMessage multipleTransfMsg = msg as MultipleTranformMessage;
/* Update other player characters */
otherPlayerCharManager.UpdateOtherCharPosition(multipleTransfMsg);
break;
case NetworkMessageType.Disconnect:
otherPlayerCharManager.DespawnDisconnectedPlayer(msg as DisconnectMessage);
break;
}
}
public void SetTarget(TransformMessage t)
{
targetPosition.x = t.x;
targetPosition.y = t.y;
targetPosition.z = t.z;
targetRotation = new Vector3(0, t.angle, 0);
gunTarget = t.gunAngle;
}
protected void OnTransformMsg(NetworkMessage msg)
{
TransformMessage transformMsg = msg.ReadMessage <TransformMessage>();
Debug.Log("OnTransformMsg: NetId: " + netId);
Debug.Log("OnTransformMsg: MsgNetId: " + transformMsg.netId);
Debug.Log("OnTransformMsg: Position: " + transformMsg.position);
}
public void SendPosition(Character p)
{
TransformMessage m = new TransformMessage(p.ClientId);
m.Position.Vect3 = p.CharacterObj.transform.position;
m.Scale.Vect3 = p.CharacterObj.transform.localScale;
m.Rotation.Quaternion = p.CharacterObj.transform.rotation;
SendNetworkUnreliableMessage(m, p.ClientId);
}
private void SendPositionToNewelyCreatedCharacter(Server server, Vector3 characterPos, int connectionId)
{
TransformMessage mP = new TransformMessage(connectionId);
mP.Position.Vect3 = characterPos;
mP.Scale.Vect3 = new Vector3(1f, 1f, 1f);
mP.Rotation.Quaternion = server.transform.rotation;
SendNetworkReliableMessage(mP, connectionId);
}
public void OnTransformReceived(NetworkMessage networkMessage)
{
TransformMessage message = networkMessage.ReadMessage <TransformMessage>();
if (message.netID == this.netId.Value)
{
this.transform.position = message.position;
this.transform.rotation = message.rotation;
}
}
// Start is called before the first frame update
void Start()
{
TransformMessage transformMsg = new TransformMessage(transformToUpdate);
server.sendMessage(transformMsg);
DisableMessage enableMsg = new DisableMessage();
enableMsg.objToEnable = "Cube";
server.sendMessage(enableMsg);
}
private void CreateOtherPlayerCharacter(TransformMessage transformMsg)
{
GameObject other = client.SpawnCharacter();
other.transform.parent = client.transform;
other.transform.position = transformMsg.Position.Vect3;
other.transform.localScale = transformMsg.Scale.Vect3;
other.transform.rotation = transformMsg.Rotation.Quaternion;
OtherPlayerCharacter otherPlayerChar = new OtherPlayerCharacter(other, transformMsg.ReceiverId);
allOtherCharacters.Add(otherPlayerChar);
}
private void UpdateOtherCharacterPosition(TransformMessage transformMsg)
{
foreach (OtherPlayerCharacter other in allOtherCharacters)
{
if (transformMsg.ReceiverId == other.ClientId)
{
other.AddInterpolationPos(transformMsg.Position.Vect3);
other.CharacterObj.transform.localScale = transformMsg.Scale.Vect3;
other.CharacterObj.transform.rotation = transformMsg.Rotation.Quaternion;
}
}
}
public void CreateClientsCharacter(TransformMessage mT)
{
GameObject characterObject = Instantiate(clientsCharPrefab) as GameObject;
playerChar = new Character(characterObject, mT.ReceiverId);
playerChar.CharacterObj.transform.parent = transform;
inputHandler.InitInputHandler(characterObject.GetComponent <Transform>());
characterObject.GetComponent <Renderer>().material.color = Color.red;
isClientsCharacterCreated = true;
UpdateCharactersTransform(mT);
cameraFollow.InitCharacterToFollow(characterObject.transform);
}
protected void SendTransformMsg()
{
TransformMessage transformMsg = new TransformMessage();
transformMsg.netId = netId;
transformMsg.position = transform.position;
bool isSuccess = false;
if (isServer) //If connected to server successfully, send messaage
{
isSuccess = NetworkServer.SendToAll(TransformMessage.MsgId, transformMsg);
}
Debug.Log("SendTransformMsg: netId: " + netId + " isSuccess: " + isSuccess);
}
// Update is called once per frame
void Update()
{
if (netId.connectionToServer != null && netId.hasAuthority && updatePerSec != 0 && Time.realtimeSinceStartup - lastUpdate > 1 / updatePerSec)
{
lastUpdate = Time.realtimeSinceStartup;
TransformMessage message = new TransformMessage(transform);
netId.connectionToServer.Send(message);
}
if (!netId.hasAuthority)
{
float lerpValue = Mathf.Clamp01((Time.realtimeSinceStartup - lastReception) / (1 / updatePerSec));
transform.position = Vector3.Lerp(lastPosition, newPosition, lerpValue);
transform.rotation = Quaternion.Lerp(lastRotation, newRotation, lerpValue);
}
}
public void OnTransformReceived(NetworkMessage netMsg)
{
TransformMessage msg = netMsg.ReadMessage <TransformMessage>();
//Debug.Log("OnTransformReceived: IsLocalPlayer:" + isLocalPlayer);
//Debug.Log("NetID: " + msg.netID);
//Debug.Log("MSGPOS: " + msg.position);
//Debug.Log("OURNETID: " + this.netId.Value);
//we are the replica of a an object on another machine
//that object sent out a msg to update our position
if (msg.netID == this.netId.Value)
{
this.transform.position = msg.position;
this.transform.rotation = msg.rotation;
}
}
public void SendClientPosInfoOfAllOtherPlayers(ServerNetworkManager servNetworkManager, int connectionId)
{
/* Send client all TransformMessages about all other player characters */
List <TransformMessage> allCharcterPositions = new List <TransformMessage>();
foreach (Character playerCharacter in allCharacters)
{
if (playerCharacter.ClientId != connectionId)
{
TransformMessage msg = new TransformMessage(playerCharacter.ClientId);
msg.Position.Vect3 = playerCharacter.CharacterObj.transform.position;
msg.Rotation.Quaternion = playerCharacter.CharacterObj.transform.rotation;
msg.Scale.Vect3 = playerCharacter.CharacterObj.transform.localScale;
allCharcterPositions.Add(msg);
}
}
MultipleTranformMessage multipleTransfMsg = new MultipleTranformMessage(allCharcterPositions.ToArray());
servNetworkManager.SendNetworkReliableMessage(multipleTransfMsg, connectionId);
}
void Update()
{
m_currentUpdateTransformTime += Time.deltaTime;
if (m_currentUpdateTransformTime > m_updateTransformTime)
{
TransformMessage Message = new TransformMessage();
Message.position = this.transform.position;
Message.rotation = this.transform.rotation;
Message.netID = this.netId.Value;
if (isServer)
{
// NetworkServer.SendToAll(CustomMsgType.Transform, Message);
}
else
{
// m_client.Send(CustomMsgType.Transform, Message);
}
m_currentUpdateTransformTime = 0.0f;
}
}
private void UpdatePlayers(ServerNetworkManager servNetworkManager)
{
foreach (Character p in allCharacters)
{
/* Check for players pushing other off the ledge */
int winnerId = p.Update();
if (winnerId != -1)
{
Character winner = allCharacters.Find(it => it.ClientId == winnerId);
winner.CharacterObj.GetComponent <Transform>().localScale += new Vector3(0.5f, 0.5f, 0.5f);
winner.CharacterObj.GetComponent <Rigidbody>().mass += 0.5f;
/* Update winner player */
TransformMessage transfMsg = new TransformMessage(winner.ClientId);
transfMsg.Position.Vect3 = winner.CharacterObj.transform.position;
transfMsg.Scale.Vect3 = winner.CharacterObj.transform.localScale;
transfMsg.Rotation.Quaternion = winner.CharacterObj.transform.rotation;
servNetworkManager.SendNetworkReliableMessage(transfMsg, winner.ClientId);
}
}
}
// Update is called once per frame
void Update()
{
m_currentUpdateTransformTime += Time.deltaTime;
if (m_currentUpdateTransformTime > m_updateTransformTime)
{
//send msg
TransformMessage msg = new TransformMessage();
msg.position = this.transform.position;
msg.rotation = this.transform.rotation;
msg.netID = this.netId.Value;
if (isServer)
{
NetworkServer.SendToAll(CustomMsgType.Transform, msg);
}
else
{
m_client.Send(CustomMsgType.Transform, msg);
}
m_currentUpdateTransformTime = 0.0f;
}
}
void FixedUpdate()
{
if (!networkEntity.isAuth)
{
return;
}
TransformMessage transformMessage = new TransformMessage(
positionTransform.position.x,
positionTransform.position.y,
positionTransform.position.z,
rotationTransform.localEulerAngles.x,
positionTransform.eulerAngles.y,
0
);
if (Time.time > nextActionTime)
{
nextActionTime += period;
UDPConnection.Send(transformMessage);
}
}
public void HandlePlayerInput(ServerNetworkManager servNetworkManager, InputMessage msgInput)
{
Transform characterTransf = allCharacters.Find(it => it.ClientId == msgInput.ReceiverId)
.CharacterObj.GetComponent <Transform>();
float deltaTime = Time.deltaTime + (System.DateTime.Now.Subtract(msgInput.TimeStamp).Milliseconds / 1000f);
foreach (InputType type in msgInput.InputTypeMsg)
{
switch (type)
{
case InputType.MoveBack:
characterTransf.position += GetVelocityToMoveBack(deltaTime);
break;
case InputType.MoveForward:
characterTransf.position += GetVelocityToMoveForward(deltaTime);
break;
case InputType.MoveLeft:
characterTransf.position += GetVelocityToMoveLeft(deltaTime);
break;
case InputType.MoveRight:
characterTransf.position += GetVelocityToMoveRight(deltaTime);
break;
}
}
TransformMessage tranformMsg = new TransformMessage(msgInput.ReceiverId);
tranformMsg.AcknowledgmentId = msgInput.RequestId;
tranformMsg.Position.Vect3 = characterTransf.position;
servNetworkManager.SendNetworkUnreliableMessage(tranformMsg, msgInput.ReceiverId);
}
public void SendAllPlayersAllOtherPlayerPostions(ServerNetworkManager servNetworkManger)
{
foreach (Character character in allCharacters)
{
Vector3 playerPos = character.CharacterObj.transform.position;
character.LastSentPosition = new Vector3(playerPos.x, playerPos.y, playerPos.z);
/* Send inform this characters client about all other characters positions */
List <Character> allOtherCharacters = allCharacters.FindAll(it => it.ClientId != character.ClientId);
List <TransformMessage> allTranformMsg = new List <TransformMessage>();
foreach (Character otherCharacter in allOtherCharacters)
{
TransformMessage transfMsg = new TransformMessage(otherCharacter.ClientId);
transfMsg.Position.Vect3 = otherCharacter.CharacterObj.transform.position;
transfMsg.Scale.Vect3 = otherCharacter.CharacterObj.transform.localScale;
transfMsg.Rotation.Quaternion = otherCharacter.CharacterObj.transform.rotation;
allTranformMsg.Add(transfMsg);
otherCharacter.LastSentPosition = new Vector3(transfMsg.Position.X, transfMsg.Position.Y, transfMsg.Position.Z);
}
MultipleTranformMessage multipleTransfMsg = new MultipleTranformMessage(allTranformMsg.ToArray());
servNetworkManger.SendNetworkUnreliableMessage(multipleTransfMsg, character.ClientId);
}
}
IEnumerator MsgHandling()
{
while (true)
{
if (messageQueue.Count <= 0)
{
yield return(null);
continue;
}
byte[] buffer = messageQueue.Dequeue();
if ((MessageId)buffer[0] == MessageId.Transform)
{
TransformMessage msg = new TransformMessage();
msg.Deserialize(ref buffer);
if (!netComps.ContainsKey(msg.sourceId))
{
Debug.LogWarning("[" + sceneName + "] Object with netId " + msg.sourceId + " not found!");
continue;
}
NetworkIdentity netId = netComps[msg.sourceId];
netId.SendMessage("ApplyTransform", msg, SendMessageOptions.DontRequireReceiver);
}
else if ((MessageId)buffer[0] == MessageId.Spawn)
{
SpawnMessage msg = new SpawnMessage();
msg.Deserialize(ref buffer);
if (netComps.ContainsKey(msg.objectId))
{
continue;
}
GameObject spawned = Instantiate(spawnablePrefabs[msg.prefabId].gameObject, transform.position, transform.rotation);
SceneManager.MoveGameObjectToScene(spawned, gameObject.scene);
spawned.SetActive(msg.hasAuthority);
NetworkIdentity netId = spawned.GetComponent <NetworkIdentity>();
netComps.Add(msg.objectId, netId);
netId.id = msg.objectId;
netId.spawned = true;
netId.connectionToServer = this;
netId.hasAuthority = msg.hasAuthority;
}
else if ((MessageId)buffer[0] == MessageId.Despawn)
{
DespawnMessage msg = new DespawnMessage();
msg.Deserialize(ref buffer);
if (netComps.ContainsKey(msg.objectId))
{
NetworkIdentity netComp = netComps[msg.objectId];
netComps.Remove(msg.objectId);
Destroy(netComp.gameObject);
}
}
else if ((MessageId)buffer[0] == MessageId.Enable)
{
EnableMessage msg = new EnableMessage();
msg.Deserialize(ref buffer);
if (netComps.ContainsKey(msg.objectId))
{
NetworkIdentity netComp = netComps[msg.objectId];
netComp.transform.position = new Vector3(msg.position[0], msg.position[1], msg.position[2]);
netComp.transform.rotation = new Quaternion(msg.rotation[0], msg.rotation[1], msg.rotation[2], msg.rotation[3]);
netComp.gameObject.SetActive(msg.toEnable);
}
}
yield return(null);
}
}
public static void FromTransformMessage(this Transform transform, TransformMessage msg)
{
transform.localPosition = msg.Position.ToVector3();
transform.localRotation = msg.Quaternion.ToQuaternion();
//transform.SetPositionAndRotation(msg.Position.ToVector3(), msg.Quaternion.ToQuaternion());
}
public Message(Transform transform, bool fired)
{
this.transform = new TransformMessage(transform);
this.fired = fired;
}
public void UpdateCharactersTransform(TransformMessage transformMsg)
{
playerChar.CharacterObj.transform.position = transformMsg.Position.Vect3;
playerChar.CharacterObj.transform.localScale = transformMsg.Scale.Vect3;
playerChar.CharacterObj.transform.rotation = transformMsg.Rotation.Quaternion;
}
