public virtual void GetShooter(GameObject shooter, GameObject shooterShield)
{
_shooter = shooter;
_Shield = shooterShield;
myStats = shooter.GetComponent <PlayerStats>();
myPlayer = _shooter.GetComponent <NetworkedPlayerController>();
}
// Use this for initialization
void Start()
{
nPlayerController = GetComponent <NetworkedPlayerController>();
myHealth = GetComponent <PlayerHealth>();
if (!nPlayerController.isLocalOwner)
{
return;
}
}
public override void tileEffect(NetworkedPlayerController player)
{
if (FlagStatus.FlagAvaliable)
{
player.playersStats.grabFlag();
FlagStatus.FlagAvaliable = false;
}
else
{
return;
}
}
public override void tileEffect(NetworkedPlayerController player)
{
//homePanel.SetActive(true);
//if (player.hp >= player.maxHp)
//{
// healButton.enabled = false;
//}
//else
//{
// healButton.enabled = true;
//}
}
public override void tileEffect(NetworkedPlayerController player)
{
player.msPromptPanel.SetActive(true);
if (player.playersStats.movement < player.playersStats.maxMove)
{
//buffPanel.SetActive(true);
//player.msPromptPanel.SetActive(true);
}
else
{
//gm.Pass();
}
}
public override void tileEffect(NetworkedPlayerController player)
{
print("tile activated");
player.adPromptPanel.SetActive(true);
if (player.playersStats.def >= player.playersStats.maxDef)
{
//defButton.enabled = false;
}
else
{
//defButton.enabled = true;
}
}
public void SetOwner(NetworkedPlayerController owner, Vector3 pos, Quaternion rot)
{
this.owner = owner;
Physics.IgnoreCollision(owner.GetComponent <Collider>(), GetComponent <Collider>(), true);
if (networkObject.IsOwner)
{
networkObject.Position = pos;
networkObject.Rotation = rot;
}
networkObject.SendRpc(RPC_INIT, Receivers.All, pos, rot);
initialized = true;
}
private void Start()
{
myRigi = GetComponent <Rigidbody>();
myTransform = transform;
networkedPlayer = GetComponent <NetworkedPlayerController>();
combatHandler = GetComponent <PlayerCombatHandler>();
Debug.Log(" PLAYER CONTROLLER : " + networkedPlayer.networkObject.IsOwner);
if (networkedPlayer.isLocalOwner)
{
myCam = FindObjectOfType <CinemachineFreeLook>();
myCam.Follow = transform.Find("CamFollow");
myCam.LookAt = transform;
}
}
private void Update()
{
if (photonView.isMine)
{
if (Input.GetButton("LSelectTrigger"))
{
reflectID = 0;
if (reflectID == 0)
{
reflect = false;
}
if (photonView.isMine)
{
photonView.RPC("ReflectFalse", PhotonTargets.Others);
}
}
else
{
reflectID = 1;
if (reflectID == 1)
{
reflect = true;
}
if (photonView.isMine)
{
photonView.RPC("ReflectTrue", PhotonTargets.Others);
}
}
}
else
{
}
if (photonView.isMine)
{
player = GameObject.Find("NewLobbyPlayer(Clone)");
playerScript = player.GetComponent <NetworkedPlayerController>();
}
}
public override void tileEffect(NetworkedPlayerController player)
{
return;
}
IEnumerator movePlayer(int playerIndex)
{
print(currentState + " - Player" + (playerIndex + 1) + " Moving: " + numberedRolled);
//int netPlayerIndex = 0;///TODO: GET RID OF AND MAKE JUST FLAT OUT playerIndex
//if (playerIndex == 1 || playerIndex == 3)///
// netPlayerIndex = 1;///
//NetworkedPlayerController currentPlayerController = networkedPlayers[netPlayerIndex].GetComponent<NetworkedPlayerController>();
NetworkedPlayerController currentPlayerController = networkedPlayers[playerIndex].GetComponent <NetworkedPlayerController>();
coroutineStarted = true;
for (int i = 0; i < numberedRolled; i++)
{
BoardTileNetworked currentTile = playersCurrentTile[playerIndex].GetComponent <BoardTileNetworked>();
print(currentTile);
//currentPlayerController.responded = false;
//currentPlayerController.left = false;
//currentPlayerController.fightAccepted = false;
//currentPlayerController.tileEffectPassed = false;
if (currentTile.NextBoardTiles.Length > 1)
{
print("Dealing w/ a Switch Tile");
if (!currentPlayerController.isLocalPlayer)
{
while (!currentPlayerController.responded)
{
yield return(null);
}
//break;
}
if (currentPlayerController.isLocalPlayer)
{
currentTile.tileEffect(currentPlayerController);
}
while (!currentPlayerController.responded)
{
yield return(null);
}
if (currentPlayerController.left)
{
playersCurrentTile[playerIndex] = currentTile.NextBoardTiles[0];
}
else
{
playersCurrentTile[playerIndex] = currentTile.NextBoardTiles[1];
}
currentPlayerController.responded = false;
print("Reponded Reset to: " + currentPlayerController.responded);
currentPlayerController.luPromptPanel.SetActive(false);
currentPlayerController.lrPromptPanel.SetActive(false);
}
else
{
playersCurrentTile[playerIndex] = currentTile.NextBoardTiles[0];
}
print("1");
players[playerIndex].transform.position = playersCurrentTile[playerIndex].transform.position;
foreach (GameObject player in players)
{
if (players[playerIndex].transform.position == player.transform.position && players[playerIndex] != player)
{
if (currentPlayerController.isLocalPlayer)
{
currentPlayerController.combatPromptPanel.SetActive(true);
currentPlayerController.combatPromptText.text = "fight " + player.name + "?";
}
while (!currentPlayerController.responded)
{
yield return(null);
}
currentPlayerController.responded = false;
currentPlayerController.combatPromptPanel.SetActive(false);
if (currentPlayerController.fightAccepted)
{
NetworkedPlayerStats defenderStats = player.GetComponent <NetworkedPlayerController>().playersStats;
defenderStats.takeDamage(calculateDamage(currentPlayerController.playersStats, defenderStats));
if (defenderStats.hp >= 0)
{
currentPlayerController.playersStats.takeDamage(calculateDamage(defenderStats, currentPlayerController.playersStats));
}
}
}
}
print("2");
if (currentPlayerController.fightAccepted)
{
print("fightAccepted");
coroutineStarted = false;
break;
}
print("3");
BoardTileNetworked newCurrentTile = playersCurrentTile[playerIndex].GetComponent <BoardTileNetworked>();
print("4");
if (!(newCurrentTile is LUTileNetworked) && !(newCurrentTile is LRTileNetworked) && !(newCurrentTile is BlankTileNetworked))
{
print("Current Player isLocal: " + currentPlayerController.isLocalPlayer);
if (!currentPlayerController.isLocalPlayer)
{
while (!currentPlayerController.responded)
{
yield return(null);
}
}
if (currentPlayerController.isLocalPlayer)
{
newCurrentTile.tileEffect(currentPlayerController);
}
while (!currentPlayerController.responded)
{
yield return(null);
}
currentPlayerController.adPromptPanel.SetActive(false);
currentPlayerController.msPromptPanel.SetActive(false);
print("tile effect passed: " + currentPlayerController.tileEffectPassed);
if (!currentPlayerController.tileEffectPassed)
{
print("Breaking...");
coroutineStarted = false;
break;
}
}
print("5");
yield return(new WaitForSeconds(0.2f));
}
coroutineStarted = false;
currentPlayerController.responded = false;
if (currentState == GameStates.Player1Move)
{
coroutineStarted = false;
currentPlayerController.responded = false;
currentState = GameStates.Player2Turn;
}
else if (currentState == GameStates.Player2Move)
{
print("ok....");
coroutineStarted = false;
currentPlayerController.responded = false;
currentState = GameStates.Player3Turn;
}
else if (currentState == GameStates.Player3Move)
{
coroutineStarted = false;
currentPlayerController.responded = false;
currentState = GameStates.Player4Turn;
}
else if (currentState == GameStates.Player4Move)
{
coroutineStarted = false;
currentPlayerController.responded = false;
currentState = GameStates.Player1Turn;
}
}
public abstract void tileEffect(NetworkedPlayerController player);
public override void tileEffect(NetworkedPlayerController player)
{
print("LUTile");
player.luPromptPanel.SetActive(true);
}
// Update is called once per frame
void Update()
{
PhotonNetwork.automaticallySyncScene = true;
currentScene = SceneManager.GetActiveScene();
if (currentScene.name == "Arena")
{
players = (GameObject.FindGameObjectsWithTag("Player"));
foreach (GameObject p in players)
{
if (PhotonNetwork.isMasterClient)
{
master = p;
masterCon = p.GetComponent <NetworkedPlayerController>();
masterStats = p.GetComponent <PlayerStats>();
if (p.GetPhotonView().isMine == false)
{
notMaster = p;
notMasterCon = p.GetComponent <NetworkedPlayerController>();
notMasterStats = p.GetComponent <PlayerStats>();
}
}
}
if (masterDead == true || nonMasterDead == true)
{
if (masterDead == true)
{
winnerName = "Player 2";
}
else if (nonMasterDead == true)
{
winnerName = "Player 1";
}
GameOver();
}
}
else if (currentScene.name == "GameOverScene")
{
winText = GameObject.Find("EndUI/Text").GetComponent <Text>();
winText.text = "Winner" + Environment.NewLine + winnerName;
if (spawnable)
{
MasterSpawn = GameObject.Find("SpawnMaster");
Spawn = GameObject.Find("Spawn");
if (PhotonNetwork.isMasterClient)
{
Instantiate(player, MasterSpawn.transform.position, MasterSpawn.transform.rotation * Quaternion.Euler(0, 180, 0));
GameObject theplayer = PhotonNetwork.Instantiate("NewLobbyPlayer", MasterSpawn.transform.position, MasterSpawn.transform.rotation * Quaternion.Euler(0, 180, 0), 0);
PhotonNetwork.Instantiate("ControllerLeft", player.transform.position, player.transform.rotation * Quaternion.Euler(0, 180, 0), 0);
PhotonNetwork.Instantiate("ControllerRight", player.transform.position, player.transform.rotation * Quaternion.Euler(0, 180, 0), 0);
PhotonNetwork.Instantiate("GameHead", player.transform.position, player.transform.rotation * Quaternion.Euler(0, 180, 0), 0);
}
else
{
Instantiate(player, Spawn.transform.position, Spawn.transform.rotation * Quaternion.Euler(0, 0, 0));
GameObject theplayer = PhotonNetwork.Instantiate("NewLobbyPlayer", Spawn.transform.position, Spawn.transform.rotation * Quaternion.Euler(0, 0, 0), 0);
PhotonNetwork.Instantiate("ControllerLeft", player.transform.position, player.transform.rotation * Quaternion.Euler(0, 180, 0), 0);
PhotonNetwork.Instantiate("ControllerRight", player.transform.position, player.transform.rotation * Quaternion.Euler(0, 180, 0), 0);
PhotonNetwork.Instantiate("GameHead", player.transform.position, player.transform.rotation * Quaternion.Euler(0, 0, 0), 0);
// Instantiate(player, Spawn.transform.position, Spawn.transform.rotation * Quaternion.Euler(0, 0, 0));
}
spawnable = false;
}
}
if (masterStart == true && playerStart == true)
{
if (PhotonNetwork.isMasterClient)
{
PhotonNetwork.LoadLevel(2);
}
}
}
