private Vector3 GetRandomSpawnPoint()
{
if (spawnPoints != null)
{
if (spawnPoints.Length > 0)
{
bool isFreeSpawner = false;
Vector3 newStartPos = originalPosition;
float timeOut = Time.time + 2f;
while (!isFreeSpawner && Time.time < timeOut)
{
NetworkStartPosition startPoint = spawnPoints[Random.Range(0, spawnPoints.Length)];
SpawnPoint spawnPoint = startPoint.GetComponent <SpawnPoint>();
if (spawnPoint.IsOccupied == false)
{
isFreeSpawner = true;
newStartPos = startPoint.transform.position;
}
}
return(newStartPos);
}
}
return(originalPosition);
}
public void RpcRespawn()
{
if (!isLocalPlayer)
{
return;
}
Vector3 spawnPoint = Vector3.zero;
if (spawnPoints != null && spawnPoints.Length > 0)
{
//Shuffle the spawnpoint array so that we can have a random one.
//Knuth shuffle algorithm, posted by harvesteR on unity forums.
for (int t = 0; t < spawnPoints.Length; t++)
{
NetworkStartPosition tmp = spawnPoints[t];
int r = Random.Range(t, spawnPoints.Length);
spawnPoints[t] = spawnPoints[r];
spawnPoints[r] = tmp;
}
foreach (NetworkStartPosition point in spawnPoints)
{
if (CheckSpawnPoint(point))
{
spawnPoint = point.transform.position;
break;
}
}
}
transform.position = spawnPoint;
}
public Vector3 GetRandomSpawnPosition()
{
if (spawnPoints != null)
{
bool foundSpawner = false;
Vector3 newStartPosition = new Vector3();
float timeOut = Time.time + 2f;
while (!foundSpawner)
{
NetworkStartPosition startPoint = spawnPoints[Random.Range(0, spawnPoints.Length)];
SpawnPoint spawnPoint = startPoint.GetComponent <SpawnPoint>();
if (spawnPoint.isOcupied == false)
{
newStartPosition = startPoint.transform.position;
foundSpawner = true;
}
if (Time.time > timeOut)
{
foundSpawner = true;
newStartPosition = originalPosition;
}
}
return(newStartPosition);
}
return(originalPosition);
}
// client-side
void RespawnAtOrigin()
{
NetworkStartPosition[] spawnPoints = FindObjectsOfType <NetworkStartPosition>().ToArray();
int randomSpawnPointIndex = (int)Mathf.Round(UnityEngine.Random.Range(0, spawnPoints.Length - 1));
NetworkStartPosition spawnPoint = spawnPoints[randomSpawnPointIndex];
transform.position = spawnPoint.transform.position;
}
Vector3 GetRandomSpawnPosition()
{
if (m_spawnPoints != null)
{
NetworkStartPosition startPos = m_spawnPoints[Random.Range(0, m_spawnPoints.Length)];
return(startPos.transform.position);
}
return(m_originalPosition);
}
Vector3 GetSpawnPosition()
{
if (m_spawnPosArray != null && m_spawnPosArray.Length > 0)
{
NetworkStartPosition pos = m_spawnPosArray[UnityEngine.Random.Range(0, m_spawnPosArray.Length)];
return(pos.transform.position);
}
return(m_originalSpawnPos);
}
public void respawnPlayer(Player player)
{
int index = Random.Range(0, players.Count - 1);
NetworkStartPosition startPosition = startPositions[index];
player.transform.rotation = startPosition.transform.rotation;
player.setPosition(startPosition.transform.position);
}
//is called when the local client's scene starts
public override void OnStartLocalPlayer()
{
float minDistance = 0.0f;
NetworkStartPosition closestPosition = null;
foreach (var point in FindObjectsOfType <NetworkStartPosition>())
{
float dist = Vector3.Distance(point.transform.position, transform.position);
if (closestPosition == null || dist < minDistance)
{
minDistance = dist;
closestPosition = point;
}
}
// CANNOT ROTATE CAMERA WITH THE PLAYER.
// transform.rotation = closestPosition.transform.rotation;
if (GetComponent <NavMeshAgent>())
{
GetComponent <NavMeshAgent>().enabled = true;
}
/*if this is the VR Master, do:
* enable VR if not done already
* disable the default camera
* enable the OpenVR cam rig
* move transform up a bit (to compensate for the scale increase in Start()) [this is a temporary visualisation, to be removed once a proper Master representation is done]
* append (VR MASTER) to the player name */
if (isMonster)
{
/*UnityEngine.XR.XRSettings.enabled = true;
* QualitySettings.vSyncCount = 0; //this is an ugly fix, proper fix would be to globally save the player-set vsync state and recover it after the match is done.
* FindObjectOfType<CameraManager>().nonVRCamera.SetActive(false);
* FindObjectOfType<CameraManager>().vrCamera.SetActive(true);*/
//transform.position += Vector3.up;
pName = pName + " (MONSTER)";
gameObject.tag = "Crawler_Monster";
}
/*if not, do:
* disable VR if not done already
* enable the default camera
* disable the OpenVR cam rig
* set this gameObject as the main cam target */
//else
//{
UnityEngine.XR.XRSettings.enabled = false;
//FindObjectOfType<CameraManager>().vrCamera.SetActive(false);
FindObjectOfType <CameraManager>().nonVRCamera.SetActive(true);
Camera.main.GetComponent <DungeonCamera>().target = this.gameObject;
Camera.main.GetComponent <DungeonCamera>().shakeDistanceTarget = transform;
//}
}
private bool CheckSpawnPoint(NetworkStartPosition point)
{
foreach (Collider coll in Physics.OverlapSphere(point.transform.position, 5f))
{
if (coll.tag == "Player")
{
return(false);
}
}
return(true);
}
public void respawnPlayer(Player player, bool isLocal)
{
int index = Random.Range(0, startPositions.Length);
NetworkStartPosition startPosition = startPositions[index];
player.spawnInitialization();
player.transform.rotation = startPosition.transform.rotation;
player.setPosition(startPosition.transform.position);
}
public override void Awake()
{
base.Awake();
NetworkStartPosition startPos = GetComponentInChildren <NetworkStartPosition>();
if (!startPos)
{
return;
}
startPos.Register(teamIndex);
}
private NetworkStartPosition[] removeSpawnPoint(NetworkStartPosition start_pos, NetworkStartPosition[] spawn_points)
{
List <NetworkStartPosition> startArray = new List <NetworkStartPosition>();
foreach (var item in spawn_points)
{
if (item != start_pos)
{
startArray.Add(item);
}
}
return(startArray.ToArray());
}
public void spawnPlayers()
{
// respawn players (round robin, for now)
for (int i = 0; i < players.Count; i++)
{
Player player = players[i];
int startIndex = i % startPositions.Length;
NetworkStartPosition startPosition = startPositions[startIndex];
player.transform.rotation = startPosition.transform.rotation;
player.setPosition(startPosition.transform.position);
player.spawnInitialization();
}
}
void Awake()
{
barInside = healthBar.transform.Find("HealthColor").GetComponent <Image>();
currentHealth = maxHealth;
if (gameObject.tag == "Player")
{
player = GetComponent <PlayerController>();
}
NetworkStartPosition[] spawnPoints = FindObjectsOfType <NetworkStartPosition>();
for (int i = 0; i < spawnPoints.Length; i++)
{
if (i == 0)
{
spawnPoint1 = spawnPoints[i];
}
else
{
spawnPoint2 = spawnPoints[i];
}
}
}
public NetworkStartPosition GetNetworkStartPosition(int connectionId)
{
List <NetworkStartPosition> startPositions = new List <NetworkStartPosition>();
GameObject[] gameObjects = SceneManager.GetSceneByName(playScene).GetRootGameObjects();
foreach (GameObject obj in gameObjects)
{
NetworkStartPosition strPos = obj.GetComponent <NetworkStartPosition>();
if (strPos != null)
{
startPositions.Add(strPos);
}
else if (obj.name.Contains("4PlayersStartPositions"))
{
foreach (NetworkStartPosition pos in obj.GetComponentsInChildren <NetworkStartPosition>(true))
{
startPositions.Add(pos);
}
}
}
return(startPositions[connectionId]);
}
// Use this for initialization
void Start()
{
NetworkStartPosition[] allPos = FindObjectsOfType <NetworkStartPosition>();
NetworkStartPosition myPos = allPos[0];
foreach (NetworkStartPosition p in allPos)
{
if (p.gameObject.transform.position == transform.position)
{
myPos = p;
}
}
// Set Despawnpoint
myPos.GetComponentInChildren <EndzoneDespawn>().gameObject.transform.SetParent(this.transform);
// Set Grid
GridMaker gm = myPos.GetComponentInChildren <GridMaker>();
gm.gameObject.transform.SetParent(this.transform);
gm.transform.position.Set(transform.position.x, 0.0f, transform.position.z);
GetComponent <PlayerController>().Init();
GetComponentInChildren <AlgorithmBot>(true).gridMaker = gm.gameObject;
}
private void OnEnable()
{
networkStartPosition = (NetworkStartPosition)target;
lastPosition = networkStartPosition.transform.position;
}
