void SendTransform()
{
if ((timeLastBuffering >= bufferingPeriod)&&((lastAnimation!="idle")||(currentAnimation!="idle"))) {//&&(lastAnimation.Equals("idle"))
lastState = NetworkTransform.FromTransform(thisTransform);
SFSObject data=new SFSObject();
if (!currentAnimation.Equals(lastAnimation))
data.PutUtfString("anim",currentAnimation);
lastState.ToSFSObject(data);
buffer.AddSFSObject(data);
timeLastSending += bufferingPeriod;
packageSize+=1;
timeLastBuffering = 0.0f;
lastAnimation=currentAnimation;
//return;
} else if (!packageSize.Equals(0)){
sendBuffer();
packageSize=0;
}
if (packageSize.Equals(packageMaxSize)){
sendBuffer();
packageSize=0;
//timeLastSending = 0.0f;
}
timeLastBuffering += Time.deltaTime;
}
// Creating NetworkTransform from SFS object
public static NetworkTransform FromSFSObject(ISFSObject data)
{
NetworkTransform trans = new NetworkTransform();
ISFSObject transformData = data.GetSFSObject("transform");
float x = Convert.ToSingle(transformData.GetDouble("x"));
float y = Convert.ToSingle(transformData.GetDouble("y"));
float z = Convert.ToSingle(transformData.GetDouble("z"));
float rx = Convert.ToSingle(transformData.GetDouble("rx"));
float ry = Convert.ToSingle(transformData.GetDouble("ry"));
float rz = Convert.ToSingle(transformData.GetDouble("rz"));
trans.position = new Vector3(x, y, z);
trans.angleRotation = new Vector3(rx, ry, rz);
if (transformData.ContainsKey("t"))
{
trans.TimeStamp = Convert.ToDouble(transformData.GetLong("t"));
}
else
{
trans.TimeStamp = 0;
}
return(trans);
}
private void SpawnLocalPlayer(int numModel, NetworkTransform trans)
{
Vector3 pos;
Vector3 rot;
// See if there already exists a model - if so, take its pos+rot before destroying it
if (localPlayer != null)
{
pos = localPlayer.transform.position;
rot = localPlayer.transform.localEulerAngles;
// Camera.main.transform.parent = null;
Destroy(localPlayer);
}
else
{
pos = trans.Position;
rot = trans.AngleRotationFPS;
}
// Lets spawn our local player model
localPlayer = GameObject.Instantiate(playerModels[0]) as GameObject;
localPlayer.transform.position = pos;
localPlayer.transform.localEulerAngles = rot;
localPlayer.AddComponent <NetworkTransformSender>();
//localPlayer.SendMessage ("StratSendTransform");
NetworkTransformSender.Instance.StartSendTransform();
SendCheckAuctionStart(); //
}
public void ReceivedTransform(NetworkTransform ntransform)
{
if (!running)
{
return;
}
// When receiving, buffer the information
// Receive latest state information
//Vector3 pos = ntransform.Position;
// Quaternion rot = ntransform.Rotation;
// Shift buffer contents, oldest data erased, 18 becomes 19, ... , 0 becomes 1
for (int i = bufferedStates.Length - 1; i >= 1; i--)
{
bufferedStates[i] = bufferedStates[i - 1];
}
// Save currect received state as 0 in the buffer, safe to overwrite after shifting
bufferedStates[0] = ntransform;
// Increment state count but never exceed buffer size
statesCount = Mathf.Min(statesCount + 1, bufferedStates.Length);
// Check integrity, lowest numbered state in the buffer is newest and so on
for (int i = 0; i < statesCount - 1; i++)
{
if (bufferedStates[i].TimeStamp < bufferedStates[i + 1].TimeStamp)
{
Debug.Log("State inconsistent");
}
}
}
void Start()
{
rb = GetComponent <Rigidbody2D>();
networkTransform = GetComponent <NetworkTransform>();
spawner = FindObjectOfType <WaterBalloonSpawner>();
rb.AddForce(movePosition);
}
void Start()
{
if (this.GetComponent <NetworkIdentity>() == null)
{
networkIdentity = this.gameObject.AddComponent <NetworkIdentity>();
}
else
{
networkIdentity = this.gameObject.GetComponent <NetworkIdentity>();
}
networkIdentity.localPlayerAuthority = false;
if (this.GetComponent <NetworkTransform>() == null)
{
networkTransform = this.gameObject.AddComponent <NetworkTransform>();
}
else
{
networkTransform = this.gameObject.GetComponent <NetworkTransform>();
}
networkTransform.sendInterval = 0.005f;
this.tag = TAG;
if (_typeInt != 0)
{
SetAsteroidType(Type);
}
}
void GetNetworkInformation(GameObject gameObject)
{
m_Transform = gameObject.GetComponent <NetworkTransform>();
m_Rigidbody3D = gameObject.GetComponent <Rigidbody>();
m_Rigidbody2D = gameObject.GetComponent <Rigidbody2D>();
}
public void ReceiveTransform(NetworkTransform nTransform)
{
//if (interpolator!=null)
{
// interpolating received transform
interpolator.ReceivedTransform(nTransform);
//lastBoneTransformRotation = boneTransformRotation;
//boneTransformRotation = nTransform.rotationBone;
//lastMovementTransformRotation = movementTransformRotation;
//movementTransformRotation = nTransform.rotationMovement;
}
/*else
* {
* //lastMovementTransformRotation = movementTransformRotation;
* movementTransformRotation = nTransform.rotationMovement;
*
* //lastBoneTransformRotation = boneTransformRotation;
* boneTransformRotation = nTransform.rotationBone;
*
* myTransform.position = nTransform.position;
* myTransform.localRotation = nTransform.rotation;
* movementTransform.localRotation = nTransform.rotationMovement;
* boneTransform.localRotation = nTransform.rotationBone;
* }*/
}
public void ReceivedTransform(NetworkTransform ntransform)
{
if (!running) return;
// Shift the buffer sideways, deleting state 20
for (int i=m_BufferedState.Length-1;i>=1;i--)
{
m_BufferedState[i] = m_BufferedState[i-1];
}
// Record current state in slot 0
m_BufferedState[0] = ntransform;
// Update used slot count, however never exceed the buffer size
// Slots aren't actually freed so this just makes sure the buffer is
// filled up and that uninitalized slots aren't used.
m_TimestampCount = Mathf.Min(m_TimestampCount + 1, m_BufferedState.Length);
// Check if states are in order, if it is inconsistent you could reshuffel or
// drop the out-of-order state. Nothing is done here
for (int i=0;i<m_TimestampCount-1;i++)
{
if (m_BufferedState[i].TimeStamp < m_BufferedState[i+1].TimeStamp)
Debug.Log("State inconsistent");
}
}
public static NetworkTransform FromSFSObject(ISFSObject data)
{
NetworkTransform trans = new NetworkTransform();
ISFSObject transformData = data.GetSFSObject("transform");
float x = Convert.ToSingle(transformData.GetDouble("x"));
float y = Convert.ToSingle(transformData.GetDouble("y"));
float z = Convert.ToSingle(transformData.GetDouble("z"));
float rx = Convert.ToSingle(transformData.GetDouble("rx"));
float ry = Convert.ToSingle(transformData.GetDouble("ry"));
float rz = Convert.ToSingle(transformData.GetDouble("rz"));
trans.position = new Vector3(x, y, z);
trans.angleRotation = new Vector3(rx, ry, rz);
if (transformData.ContainsKey("t")) {
trans.TimeStamp = Convert.ToDouble(transformData.GetLong("t"));
}
else {
trans.TimeStamp = 0;
}
return trans;
}
private void Awake()
{
SpriteRenderer = GetComponent <SpriteRenderer>();
Body = GetComponent <Rigidbody2D>();
OwnCollider = GetComponent <Collider2D>();
NetworkTransform = GetComponent <NetworkTransform>();
}
public void ReceivedTransform(NetworkTransform ntransform)
{
if (!running) return;
// When receiving, buffer the information
// Receive latest state information
Vector3 pos = ntransform.Position;
Quaternion rot = ntransform.Rotation;
// Shift buffer contents, oldest data erased, 18 becomes 19, ... , 0 becomes 1
for ( int i=bufferedStates.Length-1;i>=1;i-- ) {
bufferedStates[i] = bufferedStates[i-1];
}
// Save currect received state as 0 in the buffer, safe to overwrite after shifting
bufferedStates[0] = ntransform;
// Increment state count but never exceed buffer size
statesCount = Mathf.Min(statesCount + 1, bufferedStates.Length);
// Check integrity, lowest numbered state in the buffer is newest and so on
for (int i=0; i<statesCount-1; i++) {
if (bufferedStates[i].TimeStamp < bufferedStates[i+1].TimeStamp) {
Debug.Log("State inconsistent");
}
}
}
public void Init()
{
if (m_Initialized)
{
return;
}
m_Initialized = true;
m_SyncTransform = target as NetworkTransform;
if (m_SyncTransform.transformSyncMode == NetworkTransform.TransformSyncMode.SyncNone)
{
if (m_SyncTransform.GetComponent <Rigidbody>() != null)
{
m_SyncTransform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncRigidbody3D;
m_SyncTransform.syncRotationAxis = NetworkTransform.AxisSyncMode.AxisXYZ;
EditorUtility.SetDirty(m_SyncTransform);
}
else if (m_SyncTransform.GetComponent <Rigidbody2D>() != null)
{
m_SyncTransform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncRigidbody2D;
m_SyncTransform.syncRotationAxis = NetworkTransform.AxisSyncMode.AxisZ;
EditorUtility.SetDirty(m_SyncTransform);
}
else if (m_SyncTransform.GetComponent <CharacterController>() != null)
{
m_SyncTransform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncCharacterController;
m_SyncTransform.syncRotationAxis = NetworkTransform.AxisSyncMode.AxisXYZ;
EditorUtility.SetDirty(m_SyncTransform);
}
else
{
m_SyncTransform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncTransform;
m_SyncTransform.syncRotationAxis = NetworkTransform.AxisSyncMode.AxisXYZ;
EditorUtility.SetDirty(m_SyncTransform);
}
}
m_TransformSyncMode = serializedObject.FindProperty("m_TransformSyncMode");
m_MovementTheshold = serializedObject.FindProperty("m_MovementTheshold");
m_VelocityThreshold = serializedObject.FindProperty("m_VelocityThreshold");
m_SnapThreshold = serializedObject.FindProperty("m_SnapThreshold");
m_InterpolateRotation = serializedObject.FindProperty("m_InterpolateRotation");
m_InterpolateMovement = serializedObject.FindProperty("m_InterpolateMovement");
m_RotationSyncCompression = serializedObject.FindProperty("m_RotationSyncCompression");
m_SyncSpin = serializedObject.FindProperty("m_SyncSpin");
m_NetworkSendIntervalProperty = serializedObject.FindProperty("m_SendInterval");
m_NetworkSendIntervalLabel = new GUIContent("Network Send Rate (seconds)", "Number of network updates per second");
EditorGUI.indentLevel += 1;
m_MovementThesholdLabel = new GUIContent("Movement Threshold");
m_VelocityThresholdLabel = new GUIContent("Velocity Threshold");
m_SnapThresholdLabel = new GUIContent("Snap Threshold");
m_InterpolateRotationLabel = new GUIContent("Interpolate Rotation Factor");
m_InterpolateMovementLabel = new GUIContent("Interpolate Movement Factor");
m_RotationSyncCompressionLabel = new GUIContent("Compress Rotation");
m_SyncSpinLabel = new GUIContent("Sync Angular Velocity");
EditorGUI.indentLevel -= 1;
}
public void Stop()
{
NavMeshAgent agent = this.ownerUnit.GetComponent <NavMeshAgent>();
if (agent != null)
{
agent.Stop();
agent.ResetPath();
}
agent = this.mergingUnit.GetComponent <NavMeshAgent>();
if (agent != null)
{
agent.Stop();
agent.ResetPath();
}
Collider collider = this.ownerUnit.GetComponent <Collider>();
if (collider != null)
{
collider.enabled = false;
}
NetworkTransform transform = this.ownerUnit.GetComponent <NetworkTransform>();
if (transform != null)
{
transform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncNone;
}
transform = this.mergingUnit.GetComponent <NetworkTransform>();
if (transform != null)
{
transform.transformSyncMode = NetworkTransform.TransformSyncMode.SyncNone;
}
}
// Clone itself
public static NetworkTransform Clone(NetworkTransform ntransform)
{
NetworkTransform trans = new NetworkTransform();
trans.Load(ntransform);
return(trans);
}
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");
}
public override void OnEnter()
{
base.OnEnter();
NetworkTransform mTransform = entity.GetState <IState> ().GetDynamic(propertyName.Value) as NetworkTransform;
mTransform.SetTransforms(value.Value.transform);
Finish();
}
/// <summary>
/// Send local transform to the server
/// </summary>
/// <param name="ntransform">
/// A <see cref="NetworkTransform"/>
/// </param>
public void SendTransform(NetworkTransform ntransform)
{
Room room = sfs.LastJoinedRoom;
ISFSObject data = new SFSObject();
ntransform.ToSFSObject(data);
ExtensionRequest request = new ExtensionRequest("sendTransform", data, room, true); // True flag = UDP
sfs.Send(request);
}
void Start()
{
agent = GetComponent <NavMeshAgent>();
// Don’t update position automatically
agent.updatePosition = false;
networkTransform = GetComponent <NetworkTransform>();
}
private void HandleProjectileTransformReceived(ISFSObject data)
{
//Not my own projectiles
if (data.GetInt("o") != SmartFoxConnection.Connection.MySelf.Id)
{
NetworkProjectileManager.Instance.MoveProjectile(data.GetInt("id"), NetworkTransform.fromSFSObject(data));
}
}
public override void LoadServer(NetSceneDeltaState deltaScene)
{
float startOffset = 30;
float ballSize = 18;
var defaultPaddleSize = new Vector2(18, 70);
Vector2 worldSize = Engine.Configuration.RenderSize;
NetworkPlayer p1 = ServerGame?.Players[0];
NetworkPlayer p2 = ServerGame?.Players[1];
_pad1StartingPos = new Vector3(startOffset, worldSize.Y / 2 - defaultPaddleSize.Y / 2, 0);
_pad1 = new PongPaddle("PaddleOne")
{
Position = _pad1StartingPos,
Size = defaultPaddleSize,
Owner = new NetworkPlayerHandle(p1?.Id),
};
AddObject(_pad1);
_pad2StartingPos = new Vector3(worldSize.X - startOffset - defaultPaddleSize.X, worldSize.Y / 2 - defaultPaddleSize.Y / 2, 0);
_pad2 = new PongPaddle("PaddleTwo")
{
Position = _pad2StartingPos,
Size = defaultPaddleSize,
Owner = new NetworkPlayerHandle(p2?.Id),
};
AddObject(_pad2);
_ballStartingPos = new Vector3(worldSize.X / 2 - ballSize / 2, worldSize.Y / 2 - ballSize / 2, 0);
var ball = new PongBall("Ball")
{
Position = _ballStartingPos,
Size = new Vector2(ballSize)
};
AddObject(ball);
var upperWall = new NetworkTransform("UpperWall")
{
Position = new Vector3(-100, 0, 0),
Size = new Vector2(worldSize.X + 200, 10)
};
var lowerWall = new NetworkTransform("LowerWall")
{
Position = new Vector3(-100, worldSize.Y - 10, 0),
Size = new Vector2(worldSize.X + 200, 10)
};
AddObject(upperWall);
AddObject(lowerWall);
_betweenMatchTimer = new After(250);
_betweenMatchTimer.End();
_collisionSystem = new PongCollisionProvider(this);
base.LoadServer(deltaScene);
}
// New item spawned message. Instantiating the item object.
private void HandleItem(ISFSObject dt)
{
ISFSObject item = dt.GetSFSObject("item");
int id = item.GetInt("id");
string itemType = item.GetUtfString("type");
NetworkTransform ntransform = NetworkTransform.FromSFSObject(item);
PlayerManager.Instance.SpawnItem(id, ntransform, itemType);
}
public IEnumerator SetupComponent()
{
var gameObject = new GameObject();
m_networkTransform = gameObject.AddComponent <NetworkTransform>();
m_networkTransform.Entity.HasLocalAuthority = true;
yield return(null);
}
public override void OnStartClient()
{
if (m_VisualizerPrefab != null)
{
m_NetworkTransform = GetComponent <NetworkTransform>();
CreateLineMaterial();
m_Visualizer = (GameObject)Instantiate(m_VisualizerPrefab, transform.position, Quaternion.identity);
}
}
public void AddTransform(NetworkTransform networkTransform)
{
if (networkTransforms.Count >= maxNetworkTransforms)
{
networkTransforms.Dequeue();
}
networkTransforms.Enqueue(networkTransform);
}
public override void OnAwake()
{
ragdollSync = gameObject.AddComponent <NetworkTransform>();
NetworkIdentity c = gameObject.GetComponent <NetworkIdentity>();
gameObject.SetComponentIndex(c, 0xfffffff); // Ensure network writer is last
OriginalMaterials = gameObject.GetComponent <RenderSkinnedComponent>().materials;
}
public override void OnStartLocalPlayer()
{
base.OnStartLocalPlayer();
body = GetComponent<Rigidbody2D>();
anim = GetComponent<Animator>();
netTransform = GetComponent<NetworkTransform>();
groundCheck = transform.Find("groundCheck");
heroAudSrc = body.GetComponent<AudioSource>();
}
// Use this for initialization
void Start()
{
sc = GameObject.Find("Synchronize Manager").GetComponent <StrategyController>();
strategy = sc.strategy;
trans = this.gameObject.GetComponent <NetworkTransform>();
ResetStrategy();
}
// Creating NetworkTransform from Unity transform
public static NetworkTransform FromTransform(Transform transform)
{
NetworkTransform trans = new NetworkTransform();
trans.position = transform.position;
trans.angleRotation = transform.localEulerAngles;
return(trans);
}
void Update()
{
if (networkTransforms.Count > 0)
{
NetworkTransform networkTransform = networkTransforms.Dequeue();
gameObject.transform.localPosition = networkTransform.Position;
gameObject.transform.localRotation = networkTransform.Rotation;
}
}
// Use this for initialization
void Start()
{
player_rb = GetComponent <Rigidbody2D>();
nTrans = GetComponent <NetworkTransform>();
player_render = GetComponent <Renderer>();
last_position = player_rb.transform.position;
spinning = false;
}
void IHumanoidNetworking.DisableNetworkSync(GameObject obj)
{
NetworkTransform networkTransform = obj.GetComponent <NetworkTransform>();
if (networkTransform != null)
{
networkTransform.enabled = false;
}
}
void Start()
{
_netTransform = GetComponent<NetworkTransform>();
Rigidbody asteroidRB = GetComponent<Rigidbody>();
asteroidRB.AddForce(originalForce);
asteroidRB.AddTorque(originalTorque);
}
void Start()
{
_netTransform = GetComponent <NetworkTransform>();
Rigidbody asteroidRB = GetComponent <Rigidbody>();
asteroidRB.AddForce(originalForce);
asteroidRB.AddTorque(originalTorque);
}
private void Awake()
{
// Setting up references.
m_GroundCheck = transform.Find("GroundCheck");
m_CeilingCheck = transform.Find("CeilingCheck");
m_Anim = GetComponent <Animator>();
m_Rigidbody2D = GetComponent <Rigidbody2D>();
_networkTransform = GetComponent <NetworkTransform>();
}
public static NetworkTransform fromTransform(Transform sendTransform)
{
NetworkTransform nTransform = new NetworkTransform();
nTransform.position = sendTransform.position;
nTransform.rotation = sendTransform.rotation;
return(nTransform);
}
// calculate what position and velocity we should send to peers who do not own the characters
public void CalculatePositionAndVelocityToSend(ref Vector2 position, ref Vector2 velocity, ref float distToDestination)
{
// to save some bandwidth we're sending 2d vectors. y is calculated procedurally based on the ground height at the point you are standing on so isn't needed to be sent
position.x = transform.position.x;
position.y = transform.position.z;
Vector3 velocity3d = new Vector3(_rvoController.newVelocity.x, 0f, _rvoController.newVelocity.z);
Vector3 positionToDestinationXZ = GameUtils.SubXZ(_locomotion.Destination, transform.position);
distToDestination = Mathf.Max(positionToDestinationXZ.magnitude - _locomotion.ArrivalThreshold, 0f);
// check if our current rvo controller velocity is gonna make us overshoot the target
if (velocity3d.magnitude * GetNetworkUpdateInterval() > distToDestination)
{ // set our speed so we do not overshoot
velocity3d = velocity3d.normalized * (distToDestination / GetNetworkUpdateInterval());
}
const float DirectionTolerance = 0.819f; // 0.819f == cos(35 degrees)
const float StoppingTime = 4f; // seconds
// if the character is not heading towards the destination, or the destination is far away then it's not gonna stop soon and the distance can be unlimited
if (GameUtils.DotXZ(velocity3d.normalized, positionToDestinationXZ.normalized) < DirectionTolerance || // character is not traveling towards target (probably RVO related)
distToDestination > velocity3d.magnitude * GetNetworkUpdateInterval() * StoppingTime) // the destination is far away, so no stop is imminent
{
distToDestination = NetworkTransform.DistanceUnlimited;
}
// this section makes sure our velocity would not take us off the nav mesh
Vector3 from = transform.position;
Vector3 targetPosition = AStarPathfindingUtils.CalculateExitPoint(ref from, from + velocity3d, _locomotion.Simulator, true); // see if the target poition would cause us to exit the nav mesh
float distToOriginalTargetSqr = GameUtils.GetDistSqXZ(from, from + velocity3d);
float distToNewTargetSqr = GameUtils.GetDistSqXZ(from, targetPosition);
if (distToNewTargetSqr < distToOriginalTargetSqr) // if the returned length is nearer, it means we hit an edge
{
const float NudgeIntoNavMeshDist = 0.1f;
if (distToNewTargetSqr > NudgeIntoNavMeshDist * NudgeIntoNavMeshDist)
{
float distToNewTarget = Mathf.Sqrt(distToNewTargetSqr);
// here we're moving targetPosition slightly back onto the nav mesh away from the nav mesh perimeter, this is to stop the character being moved slightly off mesh
targetPosition = from + (((targetPosition - from) / distToNewTarget) * (distToNewTarget - NudgeIntoNavMeshDist));
}
else
{
targetPosition = from; // edge is very close, so just use the from position as the target position
}
velocity3d = targetPosition - transform.position;
}
velocity.x = velocity3d.x;
velocity.y = velocity3d.z;
if (!NetworkTransform.IsMovement(new Vector3(velocity3d.x, 0f, velocity3d.z))) // is no movement being sent
{ // if we're sending a velocity of zero, we can have distance unlimited because there will be no movement anyway, so having distance unlimited means it can start moving quickly when a movement begins
distToDestination = NetworkTransform.DistanceUnlimited;
}
}
public static NetworkTransform CreaOggettoNetworktransform(Vector3 posizione, Vector3 rotazione)
{
NetworkTransform trans = new NetworkTransform();
trans.position = posizione;
trans.rotation = rotazione;
trans.timeStamp = Time.time;
return trans;
}
public void ReceiveTransform(NetworkTransform nTransform)
{
if (interpolater != null) {
interpolater.ReceivedTransform (nTransform);
} else {
//No interpolation - updating transform directly
thisTransform.position = nTransform.Position;
// Ignoring x and z rotation angles
thisTransform.localEulerAngles = nTransform.AngleRotationFPS;
}
}
void SendTransform()
{
//if (lastState.IsDifferent(thisTransform, accuracy)) {
if (timeLastSending >= sendingPeriod) {
lastState = NetworkTransform.FromTransform(thisTransform);
NetworkManager.Instance.SendTransform(lastState);
timeLastSending = 0;
return;
}
//}
timeLastSending += Time.deltaTime;
}
//MODIFICA BY LUCA
/*
private void InviaTransformLocali()
{
ISFSObject objOut = new SFSObject();
objOut.PutFloat("x", Statici.playerLocaleGO.transform.position.x);
objOut.PutFloat("y", Statici.playerLocaleGO.transform.position.y);
objOut.PutFloat("z", Statici.playerLocaleGO.transform.position.z);
objOut.PutFloat("rot", Statici.playerLocaleGO.transform.rotation.eulerAngles.y);
sfs.Send(new ExtensionRequest("regT", objOut, sfs.LastJoinedRoom));
controllerPlayer.MovementDirty = false;
}
*/
public static void InviaTransformLocali(NetworkTransform ne)
{
ISFSObject objOut = new SFSObject();
objOut.PutFloat("x", ne.position.x);
objOut.PutFloat("y", ne.position.y);
objOut.PutFloat("z", ne.position.z);
objOut.PutFloat("rx", ne.rotation.x);
objOut.PutFloat("ry", ne.rotation.y);
objOut.PutFloat("rz", ne.rotation.z);
me.sfs.Send(new ExtensionRequest("regT", objOut, me.sfs.LastJoinedRoom));
// me.controllerPlayer.MovementDirty = false;
}
//QUESTO METODO E' PER I PLAYER REMOTI
public void ricevitransform(NetworkTransform net, int netUser)
{
if (playerLocale || user != netUser) return;
if (inter == null)
{
transform.position = net.position;
transform.rotation = Quaternion.Euler(net.rotation.x, net.rotation.y, net.rotation.z);
}
else
{
inter.ReceivedTransform(net);
}
}
//This method is called when receiving remote transform
// We update lastState here to know last received transform state
void ReceiveTransform(EsObject data) {
Debug.Log("ReceiveTransform. receiveMode = " + receiveMode.ToString());
if (receiveMode) {
Vector3 pos = NetworkTransform.getPlayerPosition(data);
Quaternion rot = NetworkTransform.getPlayerRotation(data);
lastState.InitFromValues(pos, rot);
// Adding next received state to the queue
NetworkTransform nextState = new NetworkTransform(this.gameObject);
nextState.InitFromValues(pos, rot);
queue.Enqueue(nextState);
}
}
public void SpawnPlayer(NetworkTransform ntransform, string name, int score)
{
Debug.Log ("SpawnPlayer");
if (Camera.main!=null) {
//Destroy(Camera.main.gameObject);
}
// GameHUD.Instance.UpdateHealth(100);
playerObj = GameObject.Instantiate(playerPrefab) as GameObject;
playerObj.transform.position = ntransform.Position;
playerObj.transform.localEulerAngles = ntransform.AngleRotationFPS;
playerObj.SendMessage("StartSendTransform");
// PlayerScore.Instance.SetScore(name, score);
}
public void SpawnRemotePlayer(int id, NetworkTransform ntransform, string name, int score)
{
GameObject playerObj = GameObject.Instantiate(enemyPrefab) as GameObject;
playerObj.transform.position = ntransform.Position;
playerObj.transform.localEulerAngles = ntransform.AngleRotationFPS;
//AnimationSynchronizer animator = playerObj.GetComponent<AnimationSynchronizer>();
//animator.StartReceivingAnimation();
//PlayerScore.Instance.SetScore(name, score);
RemotePlayer remotePlayer = playerObj.GetComponent<RemotePlayer>();
remotePlayer.Init(name);
recipients[id] = playerObj.GetComponent<NetworkTransformReceiver>();
}
// This method is called in every Fixed Update in receiving mode. And it does transform interpolation to the latest state.
void InterpolateTransform()
{
// If interpolationg
if (interpolationPoint < maxInterpolationPoints) {
interpolationPoint++;
float t = interpolationPoint*interpolationDelta;
if (t>1) t=1;
transform.position = Vector3.Lerp(interpolateFrom.position, interpolateTo.position, t);
transform.rotation = Quaternion.Slerp(interpolateFrom.rotation, interpolateTo.rotation, t);
}
else {
// Finished interpolating to the next point
if (interpolateTo!=null) {
// Fixing interpolation result to set transform right to the next point
transform.position = interpolateTo.position;
transform.rotation = interpolateTo.rotation;
}
// Take new value from queue
if (queue.Count!=0) {
NetworkTransform nextTransform = queue.Dequeue() as NetworkTransform;
//Start interpolation to the next transform
// Set new final interpolation state and reset interpolationPoint
interpolateTo = nextTransform;
// Set new point from which to start interpolation as current transform
interpolateFrom = new NetworkTransform(this.gameObject);
interpolationPoint = 0;
float frameRate = fpsStorage.GetCurrentFPS();
// Calculate the total number of interpolation points as number of frames during interpolationPriod
maxInterpolationPoints = Convert.ToInt32(Math.Round(frameRate * interpolationPeriod));
// Reset interpolation deltaTime
interpolationDelta = 1.0f / Convert.ToSingle(maxInterpolationPoints);
}
else {
// If queue is empty just setting the transform to the last received state
transform.position = lastState.position;
transform.rotation = lastState.rotation;
}
}
}
public void SpawnEnemy(int id, NetworkTransform ntransform, string name, int score, string avatar,string anim)
{
if (recipients.ContainsKey (id))
return;
if (avatar.Equals("") || avatar.Equals(null))
avatar = "Jane-00";
string datos = avatar;
string nameAvatar = datos.Substring(0,datos.IndexOf("-"));
string textura = datos.Substring(datos.IndexOf("-")+1);
// Debug.Log("id " + id);
// Debug.Log("name avatar = "+ nameAvatar);
// Debug.Log("textura = "+ textura);
int currentAvatar = getAvatarInstance(nameAvatar);
GameObject playerObj = GameObject.Instantiate(PlayersRemotes[currentAvatar]) as GameObject;
ChangeAvatarTexture.Instance.changeTexture(playerObj, textura);
Transform spawnTransform = GameObject.FindGameObjectWithTag("Respawn").transform;
playerObj.transform.position = ntransform.Position;//spawnTransform.position;
playerObj.transform.localEulerAngles = ntransform.AngleRotation;//spawnTransform.eulerAngles;
AnimationSynchronizer animator = playerObj.GetComponent<AnimationSynchronizer>();
animator.setAnimation(anim,false);
animator.StartReceivingAnimation();
PlayerScore.Instance.SetScore(name, score);
PlayerInfo playerInfo = playerObj.GetComponent<PlayerInfo>();
playerInfo.Init(name);
playerInfo.ShowInfo();
recipients[id] = playerObj.GetComponent<NetworkTransformReceiver>();
//controllers[id] = (CharacterController) playerObj.AddComponent("CharacterController");
playerObj.AddComponent<CharacterController>();
}
void Start()
{
Debug.Log ("sender start");
thisTransform = this.transform;
lastState = NetworkTransform.FromTransform(thisTransform);
}
// We call it on remote player to start receiving his transform
void StartReceiving()
{
lastState = new NetworkTransform(this.gameObject);
fpsStorage = GameObject.Find(" FPS").GetComponent(typeof(FPSStorage)) as FPSStorage;
receiveMode = true;
}
//This method is called when receiving remote transform
// We update lastState here to know last received transform state
void ReceiveTransform(SFSObject data)
{
if (receiveMode) {
Vector3 pos = new Vector3(Convert.ToSingle(data.GetNumber("x")),
Convert.ToSingle(data.GetNumber("y"))+yAdjust,
Convert.ToSingle(data.GetNumber("z"))
);
Quaternion rot = new Quaternion(Convert.ToSingle(data.GetNumber("rx")),
Convert.ToSingle(data.GetNumber("ry")),
Convert.ToSingle(data.GetNumber("rz")),
Convert.ToSingle(data.GetNumber("w"))
);
lastState.InitFromValues(pos, rot);
// Adding next received state to the queue
NetworkTransform nextState = new NetworkTransform(this.gameObject);
nextState.InitFromValues(pos, rot);
queue.Enqueue(nextState);
}
}
// Creating NetworkTransform from Unity transform
public static NetworkTransform FromTransform(Transform transform)
{
NetworkTransform trans = new NetworkTransform();
trans.position = transform.position;
trans.angleRotation = transform.localEulerAngles;
return trans;
}
public void SpawnItem(int id, NetworkTransform ntransform, string itemType)
{
GameObject itemPrefab = null;
return;
if (itemType == "Ammo") {
itemPrefab = ammoPrefab;
}
else {
itemPrefab = healthPrefab;
}
GameObject itemObj = GameObject.Instantiate(itemPrefab) as GameObject;
itemObj.transform.position = ntransform.Position;
itemObj.transform.localEulerAngles = ntransform.AngleRotationFPS;
items[id] = itemObj;
}
// Copies another NetworkTransform to itself
public void Load(NetworkTransform ntransform)
{
this.position = ntransform.position;
this.angleRotation = ntransform.angleRotation;
this.timeStamp = ntransform.timeStamp;
}
void Start()
{
instance=this;
buffer = new SFSArray();
thisTransform = this.transform;
lastState = NetworkTransform.FromTransform(thisTransform);
}
public void SpawnPlayer(NetworkTransform ntransform, string name, int score, string avatar)
{
if (Camera.main!=null) {
Destroy(Camera.main.gameObject);
}
if (avatar.Equals("") || avatar.Equals(null) || avatar.Equals("femenimo") || avatar.Equals("masculino"))
avatar = "Jane-00";
//Debug.Log("avatar vacio");
string datos = avatar;
string nameAvatar = datos.Substring(0,datos.IndexOf("-"));
string textura = datos.Substring(datos.IndexOf("-")+1);
// Debug.Log("name avatar = "+ nameAvatar);
// Debug.Log("textura = "+ textura);
int currentAvatar = getAvatarInstance(nameAvatar);
/*GameObject*/ playerObj = GameObject.Instantiate(PlayersPrefabs[currentAvatar]) as GameObject;
ChangeAvatarTexture.Instance.changeTexture(playerObj, textura);
//
smartFox=SmartFoxConnection.Connection;
Vector3 pos=new Vector3();
float rot;
if (!doorManager.firstTime){
string nextDoor= doorManager.doorBack;
pos.x=(float)((Double)((Sfs2X.Entities.Data.SFSArray)smartFox.LastJoinedRoom.GetVariable(nextDoor).Value).GetElementAt(0));
pos.y=(float)((Double)((Sfs2X.Entities.Data.SFSArray)smartFox.LastJoinedRoom.GetVariable(nextDoor).Value).GetElementAt(1));
pos.z=(float)((Double)((Sfs2X.Entities.Data.SFSArray)smartFox.LastJoinedRoom.GetVariable(nextDoor).Value).GetElementAt(2));
int a=((int)((Sfs2X.Entities.Data.SFSArray)smartFox.LastJoinedRoom.GetVariable(nextDoor).Value).GetElementAt(3));
rot=(float)a;
}
else{
Transform spawnTransform = GameObject.FindGameObjectWithTag("Respawn").transform;
doorManager.firstTime=false;
pos=spawnTransform.position;
rot=spawnTransform.rotation.y;
}
playerObj.transform.position = pos;
playerObj.transform.Rotate(0,rot,0);
playerObj.SendMessage("StartSendTransform");
((PlayerSoundManager)playerObj.GetComponent("PlayerSoundManager")).PlaySpawn();
PlayerScore.Instance.SetScore(name, score);
}
public void SpawnPlayer(NetworkTransform ntransform, string name, int score)
{
if (Camera.main!=null) {
Destroy(Camera.main.gameObject);
}
playerName = name;
playerObj = GameObject.Instantiate(playerPrefab) as GameObject;
playerObj.transform.position = ntransform.Position;
playerObj.transform.localEulerAngles = ntransform.AngleRotationFPS;
playerObj.SendMessage("StartSendTransform");
}
//This method is called when receiving remote transform
// We update lastState here to know last received transform state
void ReceiveTransform(SFSObject data)
{
Debug.Log("ReceiveTransform()");
if (receiveMode) {
Vector3 pos = new Vector3(Convert.ToSingle(data.GetNumber("x")),
Convert.ToSingle(data.GetNumber("y")),
Convert.ToSingle(data.GetNumber("z"))
);
Quaternion rot = new Quaternion(
Convert.ToSingle(0.0),
Convert.ToSingle(data.GetNumber("ry")),
Convert.ToSingle(0.0),
Convert.ToSingle(data.GetNumber("w"))
);
lastState.InitFromValues(pos, rot);
// Adding next received state to the queue
NetworkTransform nextState = new NetworkTransform(this.gameObject);
nextState.InitFromValues(pos, rot);
queue.Enqueue(nextState);
Debug.Log("queue length: "+Convert.ToString(queue.Count));
}
}
// Clone itself
public static NetworkTransform Clone(NetworkTransform ntransform)
{
NetworkTransform trans = new NetworkTransform();
trans.Load(ntransform);
return trans;
}
void Start()
{
thisTransform = this.transform;
lastState = NetworkTransform.FromTransform(thisTransform);
}
void Start()
{
lastState = new NetworkTransform(this.gameObject);
}
