public void RevokeSyncToken(InstantiationData insData)
{
if (insData.TryGetValue(InstantiationData.InstantiationKey.sceneid, out object sceneid))
{
RevokeSyncToken((int)sceneid);
}
}
public override void OnEnable()
{
base.OnEnable();
var targets = GetComponents <ICoreAdditive>();
foreach (var tar in targets)
{
switch (tar.AdditiveType)
{
case SyncTokenType.Player:
playerCoreAdditive = tar;
break;
case SyncTokenType.General:
roomCoreAdditive = tar;
break;
default:
Debug.LogWarning($"Unprepared Detected {tar.AdditiveType}");
break;
}
}
if (photonView.InstantiationData == null)
{
return;
}
InstantiationData data = new InstantiationData(photonView.InstantiationData);
Debug.Log($"TransmissionBase Start REMOTEly.");
Setup(data);
}
public virtual void OnJoinedOnlineRoomAct()
{
if (HavingToken())
{
Debug.LogWarning($"[TokenHandler] OnJoinedOnlineRoomAct Having Token");
return;
}
Debug.Log($"[TokenHandler] OnJoinedOnlineRoomAct");
//// Online InRoom Load InstaData from TokenUser
InstantiationData datatoSend = tokenUser?.SupplyInstantiationData;
OnJoinedOnlineRoomEventBeforeTokenCreation?.Invoke(datatoSend);
//// InRoom RequestSyncToken
trasnTokenGO = tokenProvider.RequestSyncToken(datatoSend) as GameObject;
if (!HavingToken())
{
Debug.LogWarning($"Not Yet InRoom for Register");
return;
}
trasnTokenGO.GetComponent <ITransmissionBase>()?.Setup(datatoSend);
}
/// <summary>
/// Setup by
/// TokenHandler LOCALly
/// or
/// using data received from TransmissionBase.OnEnable
/// </summary>
/// <param name="insData"></param>
public void Setup(InstantiationData insData)
{
tType = insData.tokenType;
Debug.Log($"TransmissionBase {gameObject.name} Setup. photonView.IsMine:{photonView.IsMine} {insData}");
// get tokenUser from ObjectSupplier
switch (tType)
{
case SyncTokenType.Player:
playerCoreAdditive.Init(insData, photonView.IsMine);
break;
default:
case SyncTokenType.General:
Debug.LogWarning("TransmissionBase Setup General");
roomCoreAdditive.Init(insData, photonView.IsMine);
break;
}
// Setup SerializableReadWrite
var sData = refObj?.GetComponent <ISyncHandlerUser>()?.SerializableReadWrite;
if (sData != null)
{
Register(sData);
}
else
{
Debug.LogWarning($"TransmissionBase {gameObject.name}: No TokenUser/ no SerializableReadWrite for Sync!");
}
started = true;
}
public GameObject ManualBuildSyncToken(InstantiationData dataToSend)
{
var go = PrefabPoolManager.Instance.Instantiate("TransmissionToken", Vector3.zero, Quaternion.identity);//Instantiate(transmissionTokenPrefab);
var pView = go.GetComponent <PhotonView>();
if (PhotonNetwork.AllocateViewID(photonView))
{
var raiseEventOptions = new RaiseEventOptions
{
Receivers = ReceiverGroup.Others,
CachingOption = EventCaching.AddToRoomCache
};
var sendOptions = new SendOptions {
Reliability = true
};
dataToSend.Add("viewID", photonView.ViewID.ToString());
PhotonNetwork.RaiseEvent(
(byte)RaiseEvnetCode.CustomManualInstantiationEventCode,
dataToSend.ToData(),
raiseEventOptions,
sendOptions);
return(go);
}
Debug.LogError("Failed to allocate a ViewId.");
Destroy(go);
return(null);
}
public GameObject InstantiateObject()
{
if (hostPlayer != null)
{
Debug.LogWarning($"Player Exist!");
return(GetMine());
}
Debug.LogWarning($"InstantiatePlayerObject Start");
var go = Instantiate(playerCorePref, transform);
go.name = "HostPlayer";
var playerScript = go.GetComponent <Player>();
if (playerScript != null)
{
hostPlayer = playerScript;
playerScript.isHost = true;
var insData = InstantiationData.Build(SyncTokenType.Player);
insData[InstantiationData.InstantiationKey.objectname.ToString()] = playerCorePref.name;
insData[InstantiationData.InstantiationKey.objectuuid.ToString()] = randomID;
insData[InstantiationData.InstantiationKey.objectpersist.ToString()] = 30;
insData["ablePlayerEcho"] = true;
insData["timestamp"] = Time.time;
playerScript.Init(insData, true, null);
playerScript.creator = this;
}
Debug.LogWarning($"InstantiatePlayerObject HostPlayer Created");
return(go);
}
public void Init(InstantiationData data, bool isMine, ITransmissionBase itb)
{
instData = data;
if (data.TryGetValue(InstantiationData.InstantiationKey.objectuuid, out object uuid))
{
objectUUID = (string)uuid;
}
}
public object RequestSyncToken(InstantiationData datatoSend)
{
var go = INetworkConnectGO.GetComponent <ITokenProvider>().RequestSyncToken(datatoSend);
(go as GameObject).transform.SetParent(transform.root);
return(go);
}
public void DestroyRoomObject(InstantiationData insData)
{
if (!inc.IsInRoom())
{
Debug.LogWarning("[InstantiateRoomObject] Only InRoom can Destroy RoomObject!");
return;
}
roh.DestroyRoomObject(insData);
}
public InstantiationData GetClone()
{
InstantiationData clone = new InstantiationData();
clone.RandomSphereUnit = this.RandomSphereUnit;
clone.RandomPositionInsideSphere = this.RandomPositionInsideSphere;
clone.WorldOffset = this.WorldOffset;
clone.rotationOfInstance = this.rotationOfInstance;
clone.specifiedQuaterion = this.specifiedQuaterion;
return(clone);
}
public static GameObject PhotonRpcInstantiateAsSibling(string prefabPath, Vector3 position, Quaternion rotation, object[] data, int siblingTokenId)
{
InstantiationData i = InstantiationData(prefabPath, position, rotation, data);
i.PoolType = PoolType.RPC;
var g = ObjectPoolManager.InstantiateAsSibling(i, siblingTokenId);
ObjectPoolRpcManager.InstantiateAsSibling(i, siblingTokenId);
return(g);
}
public static GameObject PhotonRpcInstantiateAsChild(string prefabPath, Vector3 position, Quaternion rotation, object[] data, int parentTokenId)
{
InstantiationData i = InstantiationData(prefabPath, position, rotation, data);
i.PoolType = PoolType.RPC;
var g = ObjectPoolManager.Instantiate(i);
g.transform.parent = ManagedObjects.Find(parentTokenId).transform;
ObjectPoolRpcManager.InstantiateAsChild(i, parentTokenId);
return(g);
}
private static InstantiationData InstantiationData(string prefabPath, Vector3 position, Quaternion rotation, object[] data)
{
InstantiationData i = new InstantiationData();
i.PrefabPath = prefabPath;
i.Position = position;
i.Rotation = rotation;
i.TokenId = AllocateObjectId();
i.OwnerId = PhotonNetwork.player.ID;
i.ViewIds = null;
i.Data = data;
return(i);
}
//Instantiation for networked objects
public void NetInstantiate(string prefabName, int type, Vector3 position, Quaternion rotation, Vector3 localScale)
{
//tell the server to tell the other clients to do the same
InstantiationData data = new InstantiationData();
data.prefabName = prefabName;
data.position = position;
data.localScale = localScale;
data.rotation = rotation;
data.type = type;
socket.Emit("instantiate", JsonUtility.ToJson(data));
}
public void Init(InstantiationData data, bool isMine)
{
Debug.LogWarning($"[PlayerCoreAdditive] Init isMine?{isMine}");
this.parent = GetComponent <ITransmissionBase>() as TransmissionBase;
if (isMine)
{
InitLocal();
}
else
{
InitRemote(data);
}
}
public static GameObject LocalInstantiate(string prefabPath, Vector3 position, Quaternion rotation, object[] data)
{
InstantiationData i = new InstantiationData();
i.PrefabPath = prefabPath;
i.Position = position;
i.Rotation = rotation;
i.PoolType = PoolType.Local;
i.TokenId = AllocateObjectId();
i.OwnerId = PhotonNetwork.player.ID;
i.ViewIds = null;
i.Data = data;
return(ObjectPoolManager.Instantiate(i));
}
public void RequestRoomObjectManipulation(object data, PhotonMessageInfo info)
{
if (!PhotonNetwork.IsMasterClient)
{
Debug.LogWarning("[RequestRoomObjectManipulation] Only Master Client can Manipulate RoomObject!");
return;
}
var insData = new InstantiationData(data as object[]);
//TODO: MC Verify data
if (insData.tokenType != SyncTokenType.General)
{
Debug.LogWarning("[RequestRoomObjectManipulation] Only For Manipulate RoomObject!");
return;
}
if (insData.TryGetValue(InstantiationData.InstantiationKey.objectname, out object objName))
{
// Object UUID
if (!insData.ContainsKey(InstantiationData.InstantiationKey.objectuuid))
{
var tokenID = $"ro_{Random.Range(1000, 9999).ToString()}";
insData[InstantiationData.InstantiationKey.objectuuid.ToString()] = tokenID;
}
if (insData.TryGetValue(InstantiationData.InstantiationKey.sceneobject, out object soModification))
{
switch ((string)soModification)
{
case "create":
Debug.LogWarning("[RequestRoomObjectManipulation] Create");
itp.RequestSyncToken(insData);
break;
case "destroy":
photonView.RPC("RequestLocalObjectManipulation", RpcTarget.Others, insData.ToData() as object);
itp.RevokeSyncToken(insData);
iosManager.DestroyObject((string)objName, (string)insData["objectuuid"]);
Debug.LogWarning($"[RequestRoomObjectManipulation] MC Destroy {insData}");
break;
}
}
}
}
public void Init(InstantiationData data)
{
if (photonView.Owner == null)
{
Debug.Log($"InRoomObject:{photonView.ViewID} OwnedByRoom");
}
else if (photonView.IsMine)
{
Debug.Log($"I({PhotonNetwork.LocalPlayer.UserId}) Own {photonView.ViewID}" + photonView.Owner.ToStringFull());
}
else
{
// deal with photonView.InstantiationData
Debug.Log($"{photonView.ViewID} TryLoadData with data {data.ToString()}");
}
}
void InitRemote(InstantiationData data)
{
Debug.LogWarning($"[PlayerCoreAdditive] InitRemote");
gameObject.name = "RemotePlayerToken";
//Based on objName/ objUUID we received...
if (data.TryGetValue(InstantiationData.InstantiationKey.objectuuid, out object objuuid) &&
data.TryGetValue(InstantiationData.InstantiationKey.objectname, out object objname))
{
// remote one, Create based on ObjectName
var go = ObjectSupplyManager.Instance.BuildObject((string)objname, (string)objuuid) as GameObject;
this.parent.RefObject = go;
go.GetComponent <Player>().Init(data, false, parent);
}
}
//[Header("RoomObject")]
void CreateRoomObject(UnityEngine.InputSystem.InputAction.CallbackContext ctx)
{
if (ctx.ReadValue <float>() < 0.5)
{
return;
}
Debug.Log("TryCreateRoomObject");
var data = new InstantiationData()
{
tokenType = SyncTokenType.General
};
data[InstantiationData.InstantiationKey.objectname.ToString()] = "RoomObject";
data[InstantiationData.InstantiationKey.sceneobject.ToString()] = "create";
ServiceManager.Instance.networkSystem.InstantiateRoomObject(data);
}
public static GameObject PhotonViewInstantiate(string prefabPath, Vector3 position, Quaternion rotation, object[] data)
{
InstantiationData i = InstantiationData(prefabPath, position, rotation, data);
i.PoolType = PoolType.PhotonView;
var g = ObjectPoolManager.Instantiate(i);
PhotonView[] pvs = g.GetComponents <PhotonView>();
List <int> viewIds = new List <int>();
foreach (PhotonView pv in pvs)
{
viewIds.Add(pv.viewID);
}
i.ViewIds = viewIds.ToArray();
ObjectPoolRpcManager.Instantiate(i);
return(g);
}
public void Init(InstantiationData data, bool isMine, ITransmissionBase tb = null)
{
Debug.LogWarning($"ISyncHandlerUser Init isMine?{isMine}");
insdata = data;
var pa = GetComponent <PersistenceHelper>();
string uuid = null;
if (data.TryGetValue(InstantiationData.InstantiationKey.objectuuid, out object val))
{
uuid = (string)val;
}
//// Local HostPlayer Ask for a TokenHandler
if (isMine)
{
SetupTokenHandler();
pa.Init(uuid);
}
else
{
pa.Init(
uuid,
() => { creator.RemoveFromDict(uuid); },
tb as TransmissionBase
);
if (data.TryGetValue(InstantiationData.InstantiationKey.objectpersist, out val))
{
pa.Setup((int)val);
}
}
//RaiseEventHelper.instance.Register(new NetworkLayer.RoomEventRegistration()
//{
// key = "Emit",
// OnRoomEvent = EmitPropToLocal,
// cachingOption = NetworkLayer.EventCaching.DoNotCache,
// receivers = NetworkLayer.EventTarget.All
//});
}
public void TestInstantiationDataSerialzation()
{
var data = new InstantiationData(
new object[2] {
SyncTokenType.Player,
new List <string> {
"syncPos", "True", "syncRot", "False"
}
});
Debug.Log($"data:{data.ToString()} {data.Count} {data.ToData().Length}");
var ty = (SyncTokenType)data.ToData()[0];
Debug.Log($"data SyncTokenType:{ty}");
var li = (List <string>)data.ToData()[1];
Debug.Log($"data List<string>:{li}");
foreach (var ll in li)
{
Debug.Log($"<string>:{ll}");
}
var data2 = new InstantiationData(data.ToData());
Debug.Log($"data2 Objectify:{data2.ToString()} {data2.Count} {data2.ToData().Length}");
var data3 = InstantiationData.Build(data.ToString());
data3.Add("k3", "v3");
Debug.Log($"data3 Stringify:{data3.ToString()} {data3.Count} {data3.ToData().Length}");
var data4 = InstantiationData.Build(SyncTokenType.Player);
data4.Add("k1", "v1");
data4.Add("k2", "v2");
data4.Add("k3", "v3");
data4.Add("k4", "v4");
Debug.Log($"data4 Stringify:{data4.ToString()} {data4.Count} {data4.ToData().Length}");
}
public void ManualBuildSyncTokenOnEvent(EventData photonEvent)
{
byte eventCode = photonEvent.Code;
if ((RaiseEvnetCode)eventCode == RaiseEvnetCode.CustomManualInstantiationEventCode)
{
var instData = new InstantiationData((object[])photonEvent.CustomData);
var tok = PrefabPoolManager.Instance.Instantiate("TransmissionToken", Vector3.zero, Quaternion.identity);//Instantiate(transmissionTokenPrefab);
//setup based on InstantiationData
PhotonView photonView = tok.GetComponent <PhotonView>();
if (instData.TryGetValue("viewID", out object vid))
{
photonView.ViewID = (int)vid;
}
else
{
Debug.LogWarning($"ViewID Missing!");
}
}
}
//from the server: a networked game object has been instantiated
public void OnNetInstantiate(SocketIOEvent e)
{
//this is the data coming from the server as JSON, it needs to be parses into
//usable variables according to a serializable class defined at the bottom of this script
InstantiationData data = JsonUtility.FromJson<InstantiationData>(e.data.ToString());
//print("Net instantiate " + data.uniqueId+" "+ data.position);
//see if there is already an object with that id
GameObject o = GameObject.Find(data.uniqueId);
//if not instantiate on the scene
if(o == null)
o = Instantiate(Resources.Load(data.prefabName) as GameObject);
o.transform.position = data.position;
o.transform.localScale = data.localScale;
o.transform.rotation = data.rotation;
o.name = data.uniqueId;
//fetch or add the netcomponent object
NetObject netObj = o.GetComponent<NetObject>();
if (netObj == null)
{
netObj = o.AddComponent<NetObject>();
}
netObj.type = data.type;
netObj.owner = data.owner;
netObj.prefabName = data.prefabName;
Net.objects[data.uniqueId] = netObj;
netObj.OnVariableInit();
}
public void RequestLocalObjectManipulation(object data, PhotonMessageInfo info)
{
var insData = new InstantiationData(data as object[]);
if (insData.tokenType != SyncTokenType.General)
{
Debug.LogWarning("[RequestLocalObjectManipulation] Only For Manipulate Local RoomObject!");
return;
}
if (insData.TryGetValue("localobject", out object objName))
{
if (!insData.ContainsKey("objectuuid"))
{
return;
}
if (insData.TryGetValue("sceneobject", out object modifyword) && (string)modifyword == "Destroy")
{
iosManager.DestroyObject((string)objName, (string)insData["objectuuid"]);
}
}
}
public void Init(InstantiationData data, bool isMine)
{
Debug.LogWarning("[RoomCoreAdditive] Init");
this.parent = GetComponent <TransmissionBase>();
if (!osa)
{
osa = GetComponent <OwnershipSubAdditive>();
}
osa.Init(data);
//
if (data.TryGetValue(InstantiationData.InstantiationKey.objectuuid, out object objUUID) &&
data.TryGetValue(InstantiationData.InstantiationKey.objectname, out object objName))
{
var obj = ObjectSupplyManager.Instance.BuildObject((string)objName, (string)objUUID);
if (obj == null)
{
Debug.LogError("[Init] Fail to BuildObject");
return;
}
var go = obj as GameObject;
parent.RefObject = go;
go.transform.SetParent(ServiceManager.Instance.networkSystem.RoomObjectParent);
// link between Token and TokenUser
var tu = go.GetComponent <ISyncHandlerUser>();
tu?.Init(data, false, parent);
Debug.LogWarning("[Init] IOwnershipInteractable");
var oi = go.GetComponent <IOwnershipInteractable>();
oi.TargetObject = gameObject as object;
}
}
public object RequestSyncToken(InstantiationData dataToSend)
{
if (!PhotonNetwork.InRoom)
{
Debug.LogWarning($"RequestSyncToken NotInRoom");
return(null);
}
GameObject go = null;
switch (dataToSend.tokenType)
{
case SyncTokenType.Player:
Debug.Log($"PhotonNetwork.Instantiate RequestSyncToken");
go = PhotonNetwork.Instantiate("Token/TransmissionToken", Vector3.zero, Quaternion.identity, 0, dataToSend.ToData());
break;
default:
if (PhotonNetwork.IsMasterClient)
{
go = PhotonNetwork.InstantiateRoomObject("Token/TransmissionToken", Vector3.zero, Quaternion.identity, 0, dataToSend.ToData());
}
else
{
Debug.LogWarning($"Non MC Cannot InstantiateRoomObject");
}
break;
}
if (go == null)
{
Debug.LogWarning($"Issuing Null GameObject");
}
return(go);
}
public InstantiationData GetClone()
{
InstantiationData clone = new InstantiationData();
clone.RandomSphereUnit = this.RandomSphereUnit;
clone.RandomPositionInsideSphere = this.RandomPositionInsideSphere;
clone.WorldOffset = this.WorldOffset;
clone.rotationOfInstance = this.rotationOfInstance;
clone.specifiedQuaterion = this.specifiedQuaterion;
return clone;
}
// PhotonNetwork.OnEvent
public override void OnRaiseEvent(IRaiseEventCallInfo info)
{
var tickCount = Environment.TickCount;
#if true
switch (info.Request.EvCode)
{
case PunEvent.Instantiation: {
var data = new InstantiationData();
if (!data.Deserialize(info.Request))
{
break;
}
this.PrefabHolder.Instantiate(info.ActorNr, data);
break;
}
case PunEvent.Destroy: {
if (!(info.Request.Data is Hashtable data))
{
break;
}
if (!data.TryGetValue((byte)0, out int viewId))
{
break;
}
this.PrefabHolder.Destroy(viewId);
break;
}
case PunEvent.DestroyPlayer:
case EventCode.Leave: // ???
// TODO
break;
case PunEvent.RPC: {
if (!(info.Request.Data is Hashtable data))
{
break;
}
if (!data.TryGetValue((byte)0, out int viewId))
{
break;
}
var prefix = data.TryGetValue <short>((byte)1) ?? 0;
if (!data.TryGetValue((byte)2, out int timeStamp))
{
break;
}
var idx = data.TryGetValue <byte>((byte)5);
if (!idx.HasValue)
{
if (!data.TryGetValue((byte)3, out string methodName))
{
break;
}
}
var args = data.TryGetValue <object[]>((byte)4) ?? null;
// skillRPCAsync
if (idx != 6)
{
break;
}
var i = 0;
if (!args.TryRead(out byte beam, ref i))
{
break;
}
if (!args.TryRead(out Vector2 pos_xz, ref i))
{
break;
}
if (!args.TryRead(out float angle_y, ref i))
{
break;
}
if (!this.Master.Skill.TryGetValue(beam, out var skill))
{
break;
}
if (beam == 0 && this.PrefabHolder.TryGetValue(viewId, out var pv))
{
pv.IsDash = true;
var rad = angle_y * Math.PI / 180;
pv.DashDestPos = pos_xz + (skill.Radius * new Vector2((float)Math.Sin(rad), (float)Math.Cos(rad)));
this.PluginHost.CreateOneTimeTimer(() => {
pv.IsDash = false;
}, skill.DelayTime);
break;
}
this.PluginHost.CreateOneTimeTimer(() => {
var hitTarget = this.PrefabHolder.Where(e => e.Key != viewId)
.Where(e => !e.Value.IsDash && Collider.IsHit(skill, pos_xz, angle_y, e.Value.GetCurrentPosition()));
foreach (var target in hitTarget)
{
var table = new Hashtable {
{ (byte)0, target.Key },
{ (byte)2, Environment.TickCount },
{ (byte)5, (byte)5 },
};
this.PluginHost.RaiseEvent(PunEvent.RPC, table, sendParams: new SendParameters {
Unreliable = false
});
}
}, skill.DelayTime);
break;
}
case PunEvent.SendSerialize:
case PunEvent.SendSerializeReliable: {
var data = new PhotonSerializeViewData(this.PrefabHolder);
if (!data.Deserialize(info.Request))
{
this.PluginHost.LogError("Deserialize ERROR");
break;
}
this.PluginHost.LogInfo($"TIME: SV {tickCount}, PKT {data.ServerTimestamp}");
foreach (var e in data.PhotonViews)
{
if (!this.PrefabHolder.TryGetValue(e.ViewID, out var value))
{
continue;
}
value.Add(e);
}
break;
}
case PunEvent.OwnershipTransfer: {
if (!(info.Request.Data is int[] data))
{
break;
}
var viewID = data[0];
var playerID = data[1];
break;
}
}
#endif
base.OnRaiseEvent(info);
}
//somebody joined (including me)
public void OnPlayerJoin(SocketIOEvent e)
{
//read the data (just the id)
AvatarData data = JsonUtility.FromJson<AvatarData>(e.data.ToString());
Debug.Log("[SocketIO] Player Connected: " + data.id + " " + data.nickName);
//add a player object to my dictionary
Player p = new Player();
p.id = data.id;
p.nickName = data.nickName;
p.DNA = data.DNA;
//is it me?
if (data.id == socket.SocketID)
{
//close the menu, change the camera
if(gameMenu != null)
{
gameMenu.CloseMenu();
}
if (MyAvatarPrefabName != "")
{
print("I officially join the game as " + data.nickName);
Net.playing = true;
//do I have to create an avatar?
Net.myId = socket.SocketID;
//just in case
if (myAvatar != null)
Destroy(myAvatar);
//instantiate on the scene
myAvatar = Instantiate(Resources.Load(MyAvatarPrefabName) as GameObject);
myAvatar.name = socket.SocketID;
//fetch or add the netcomponent object
NetObject netObj = myAvatar.GetComponent<NetObject>();
if (netObj == null)
netObj = myAvatar.AddComponent<NetObject>();
Net.objects[socket.SocketID] = netObj;
netObj.owner = socket.SocketID;
netObj.type = Net.TEMPORARY;
netObj.prefabName = MyAvatarPrefabName;
//other client should instantiate a different avatar without controls
//and camera but if it's not provided that's fine too
if (OtherAvatarPrefabName == "")
OtherAvatarPrefabName = MyAvatarPrefabName;
//tell the server to tell the other clients to make a puppet avatar
InstantiationData iData = new InstantiationData();
iData.prefabName = OtherAvatarPrefabName;
iData.uniqueId = socket.SocketID;
iData.type = Net.TEMPORARY;
//instantiate all avatars around 0,0 by default
//this is game logic and can be changed here on the server or on the netObject upon instantiation
Vector2 spawnRange = UnityEngine.Random.insideUnitCircle * spawnRadius;
myAvatar.transform.position = iData.position = new Vector3(spawnPoint.x + spawnRange.x, spawnPoint.y, spawnPoint.z + spawnRange.y);
myAvatar.transform.localScale = iData.localScale = Vector3.one;
myAvatar.transform.rotation = iData.rotation = Quaternion.identity;
print("Instantiation " + myAvatar.transform.position);
socket.Emit("instantiateAvatar", JsonUtility.ToJson(iData));
}//end avatar creation
//find all the static netObjects - they are the ones in the Unity scene with a netObject attached
//their uniqueId is their gameObject name
NetObject[] sceneObjects = FindObjectsOfType(typeof(NetObject)) as NetObject[];
foreach (NetObject item in sceneObjects)
{
if (item.owner == "")
{
Debug.Log(item.gameObject.name + " is a netObject without an owner in the scene, make sure the server knows about it");
//if the object is orphan assign ownership to me and make sure the server knows about it
//this should happen only to the first user logging after the server starts
InstantiationData iData = new InstantiationData();
iData.prefabName = item.gameObject.name;
iData.uniqueId = item.gameObject.name;
iData.position = item.transform.position;
iData.localScale = item.transform.localScale;
iData.rotation = item.transform.rotation;
iData.netVariables = item.netVariables;
iData.type = Net.PERSISTENT;
//item.OnVariableInit();
//if the server knows about it there will be no followup
socket.Emit("registerObject", JsonUtility.ToJson(iData));
}
}
}//is it me?
//add the player object to the players dictionary
Net.players[p.id] = p;
}
