private GameObject OnSpawnEntity(Vector3 position, NetworkHash128 assetId)
{
var networkEntity = Instantiate <NetworkIdentity>(_networkStateEntityProtoType);
networkEntity.transform.SetParent(this.transform);
return(networkEntity.gameObject);
}
public override void Deserialize(NetworkReader reader)
{
this.netId = reader.ReadNetworkId();
this.assetId = reader.ReadNetworkHash128();
this.position = reader.ReadVector3();
this.payload = reader.ReadBytesAndSize();
}
public static void SpawnObject(GameObject otherObject, NetworkHash128 hash128)
{
//F*****g reflect:
var view = otherObject.GetComponent <NetworkIdentity>();
var assetId = view
.GetType()
.GetField("m_AssetId", BindingFlags.NonPublic | BindingFlags.Instance);
assetId.SetValue(view, hash128);
Debug.Log("BURN ASSET ID");
//F*****g network server:
var type = typeof(NetworkServer);
var info = type.GetProperty("instance", BindingFlags.NonPublic | BindingFlags.Static);
var networkServer = info.GetValue(null, null) as NetworkServer;
Debug.Log("BURN SERVER INSTANCE");
//F*****g spawn:
type.GetMethod("SpawnObject", BindingFlags.NonPublic | BindingFlags.Instance)
.Invoke(networkServer,
new object[]
{
otherObject
});
Debug.Log("BURN SPAWN OBJECT");
}
/**
* Network stuff
* Cuffently don't know what this is for
*/
GameObject ClientSpawnHandler(Vector3 position, NetworkHash128 assetId)
{
var go = CreateObject();
go.GetComponent <PoolMember>().SetObjectInactive();
return(go);
}
public Projectile GetProjectileInstance(out NetworkHash128 assetId)
{
assetId = _projectilePool.assetId;
var projectileInst = _projectilePool.GetInstance();
return(projectileInst.GetComponent <Projectile>());
}
public ResourcePickup GetResourceInstance(out NetworkHash128 assetId)
{
assetId = _resourcePickupPool.assetId;
var projectileInst = _resourcePickupPool.GetInstance();
return(projectileInst.GetComponent <ResourcePickup>());
}
private void Start()
{
pSender = this.GetComponent <PlayerMessageSender>();
mConnection = this.GetComponent <NetworkIdentity>().connectionToClient;
ClientScene.RegisterPrefab(bulletPrefab, NetworkHash128.Parse(bulletPrefab.name));
ClientScene.RegisterPrefab(_lineRenderer.gameObject, NetworkHash128.Parse(_lineRenderer.gameObject.name));
//FindObjectOfType<customNetworkManager>().OnClientConnect(mConnection);
if (isLocalPlayer) //If I'm the local player
{
Cursor.lockState = CursorLockMode.Locked;
_transform = this.transform; //get my transform and keep a reference to it.
_rigidbody = this.GetComponent <Rigidbody>();
_camera = this.GetComponentInChildren <Camera>();
_cameraTransform = _camera.transform;
mainCamera = Camera.main; //get the main camera and disable it
mainCamera.gameObject.SetActive(false);
}
else //If im not the local player
{
_transform = this.transform;
_rigidbody = this.GetComponent <Rigidbody>();
_camera = this.GetComponentInChildren <Camera>();
_camera.enabled = false; //turn the camera off.
_camera.GetComponent <AudioListener>().enabled = false; //disable the camera
}
}
public void Init()
{
assetId = m_Prefab.GetComponent <NetworkIdentity>().assetId;
for (int i = 0; i < poolSize; ++i)
{
GameObject obj = (GameObject)Instantiate(m_Prefab);
obj.transform.parent = this.transform;
obj.name = m_Prefab.name;
m_Pool.Add(obj);
obj.SetActive(false);
}
if (m_Prefab.GetComponent <Unit>() != null)
{
if (m_Prefab.GetComponent <Unit>().unitData != null)
{
foreach (GameObject go in m_Prefab.GetComponent <Unit>().unitData.objectToPool)
{
if (PoolManager.Instance.poolDictionnary[go.name] != null)
{
Debug.Log("poolDictionary[agent] != null");
PoolManager.Instance.poolDictionnary[go.name].poolSize = 23;
PoolManager.Instance.poolDictionnary[go.name].Init();
}
}
}
}
ClientScene.RegisterSpawnHandler(assetId, SpawnObject, UnSpawnObject);
}
public void SelectCharacter(NetworkHash128 characterHash)
{
if (characterHash.IsValid())
{
manager.client.Send(MsgType.Highest + 1 + (short)NetMsgType.SelectCharacter, new HashMessage(characterHash));
}
}
public void TestToString()
{
string guid = "0123456789abcdef9876543210fedcba";
NetworkHash128 hash = NetworkHash128.Parse(guid);
Assert.That(hash.ToString(), Is.EqualTo(guid));
}
public void sendAssetId(NetworkHash128 assetId)
{
AssetsMessage msg = new AssetsMessage();
msg.assetId = assetId;
NetworkServer.SendToAll(AssetMessage.assetMessage, msg);
}
public GameObject SpawnStick(Vector3 position, NetworkHash128 assetId)
{
Debug.Log("spawn object>>>>>>>>>>>>>>>>>>> " + position);
cue.transform.position = position;
cue.SetActive(true);
return(cue);
}
private static GameObject NetworkSpawnItemHandler(Vector3 pos, NetworkHash128 asset_id)
{
//Debug.Log("CTF: client " + NetworkMatch.m_my_lobby_id + " flag spawning " + asset_id);
GameObject prefabFromAssetId = m_registered_prefabs[asset_id];
if (prefabFromAssetId == null)
{
Debug.LogErrorFormat("CTF: Error looking up item prefab with asset_id {0}", asset_id.ToString());
return(null);
}
GameObject gameObject = UnityEngine.Object.Instantiate(prefabFromAssetId, pos, Quaternion.identity);
if (gameObject == null)
{
Debug.LogErrorFormat("CTF: Error instantiating item prefab {0}", prefabFromAssetId.name);
return(null);
}
gameObject.SetActive(true);
//Debug.Log("Spawning flag " + asset_id + " active " + gameObject.activeSelf + " seg " + gameObject.GetComponent<Item>().m_current_segment);
var netId = gameObject.GetComponent <NetworkIdentity>();
netId.GetType().GetField("m_AssetId", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(netId, asset_id);
//Debug.Log("post spawn assetid " + gameObject.GetComponent<NetworkIdentity>().assetId);
return(gameObject);
}
public override void Deserialize(NetworkReader reader)
{
netId = reader.ReadNetworkId();
assetId = reader.ReadNetworkHash128();
position = reader.ReadVector3();
payload = reader.ReadBytesAndSize();
}
public GameObject SpawnCard(Vector3 position, NetworkHash128 assetId)
{
GameObject newCardGO = Instantiate(cardModelPrefab, playController.playAreaContent);
playController.SetPlayActions(playController.playAreaContent.GetComponent <CardStack>(), newCardGO.GetComponent <CardModel>());
return(newCardGO);
}
GameObject ClientSpawnHandler(Vector3 position, NetworkHash128 assetId)
{
var go = Instantiate(Bullet);
go.GetComponent <PoolBullet>().SetBulletInactive();
return(go);
}
void RpcSpawnObject(Vector3 objPosition, int option)
{
currPrefab = new GameObject();
if (option > 0)
{
Debug.Log("Select option value is:");
Debug.Log(option);
ClientScene.RegisterPrefab(lstPrefabs[option]);
modelPrefab = (GameObject)GameObject.Instantiate(
lstPrefabs[option],
objPosition,
Quaternion.identity);
assetId = modelPrefab.GetComponent <NetworkIdentity>().assetId;
modelPrefab.AddComponent <PersistentObjectData>();
consecID++;
modelPrefab.GetComponent <InstanceID>().SetID(consecID);
objsSpawnPool.Add(modelPrefab);
NetworkServer.Spawn(modelPrefab, assetId);
currObjCount++;
creatOrdr++;
}
}
public GameObject SpawnObject(Vector3 position, NetworkHash128 assetId)
{
GameObject serverObj = m_prefabs[assetId];
GameObject obj = InstantiatePool(serverObj.name + "Client", position, Quaternion.identity);
ClientScene.RegisterSpawnHandler(obj.GetComponent <NetworkIdentity>().assetId, SpawnObject, DestroyPool);
return(obj);
}
public GameObject OnClientSpawn(Vector3 position, NetworkHash128 assetid)
{
var gameObject = this.NextClientObject();
gameObject.SetPosition(position);
this.OnConfigure(gameObject);
return(gameObject);
}
public GameObject OnClientSpawn(Vector3 position, NetworkHash128 assetid)
{
//Create game object:
var gameObject = base.Create();
gameObject.SetPosition(position);
return(gameObject);
}
public void SpawnSubObject(Vector3 pos)
{
Debug.Log("Value on call is:");
Debug.Log(selectedOption);
assetId = lstPrefabs[selectedOption].GetComponent <NetworkIdentity>().assetId;
RpcSpawnObject(pos, selectedOption);
}
public GameObject Spawn(Vector3 position, NetworkHash128 assetId)
{
var obj = _pool.Rent().gameObject;
obj.transform.position = position;
return(obj);
}
private GameObject Spawn(Vector3 position, NetworkHash128 assetId)
{
//Debug.Log("Spawn object");
var inst = GetInstance();
return(inst ? inst.gameObject : null);
}
public GameObject AddPools(Vector3 v)
{
assetId = unitPrefab.GetComponent <NetworkIdentity>().assetId;
GameObject worm = (GameObject)MonoBehaviour.Instantiate(unitPrefab, v, Quaternion.identity);
waypoints.Insert(0, worm.transform);
ClientScene.RegisterSpawnHandler(assetId, SpawnObject, UnSpawnObject);
return(worm);
}
void RpcRegisterWeapon()
{
if (currWeapon.GetComponent <NetworkIdentity>() == null)
{
currWeapon.AddComponent <NetworkIdentity>();
}
ClientScene.RegisterPrefab(currWeapon, NetworkHash128.Parse(currWeapon.name));
CmdSpawnFix(currWeapon);
}
private void CmdDestroyCandy(NetworkHash128 assetID)
{
//Debug.Log("dentro la seconda");
//Debug.Log("candy e' null per caso?" + (candy==null).ToString());
//NetworkServer.Destroy(candy.GetComponent);
// forward the change also to all clients
//RpcDestroyCandy(candy);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
// Registers an asset on the clientside, given by the assetID.
/// </summary>
// <param name="assetID"></param>
private void RegisterAsset(NetworkHash128 assetID)
{
if (NetworkServer.active)
{
return;
}
ClientScene.RegisterSpawnHandler(_AssetID, ClientSpawn, ClientDespawn);
}
// Use this for initialization
void Start()
{
//if (isServer)
{
Init();
NetworkHash128 cueAssetId = cue.GetComponent <NetworkIdentity>().assetId;
ClientScene.RegisterSpawnHandler(cueAssetId, SpawnStick, UnspawnStick);
}
}
// Handles requests to spawn objects on the client
public GameObject SpawnSychronizer(Vector3 position, NetworkHash128 assetId)
{
var sync = (GameObject)Instantiate(
SynchronizerPrefab,
position,
Quaternion.identity);
return(sync);
}
private GameObject SpawnSphere(Vector3 position, NetworkHash128 assetId)
{
GameObject clientObject = Instantiate(clientPrefab, position, Quaternion.identity);
//clientObject.transform.SetParent(SceneRoot.transform);
clientObject.AddComponent <NetworkIdentity>();
clientObject.AddComponent <NetworkTransform>();
return(clientObject);
}
public void Register()
{
var hash128 = NetworkHash128.Parse(this.SpawnId);
ClientScene.RegisterSpawnHandler(
hash128,
this.OnClientSpawn,
this.OnClientUnSpawn
);
}
