+ init

1 files changed, 415 insertions, 0 deletions

diff --git a/GameCode/PlayerManager.cs b/GameCode/PlayerManager.cs
new file mode 100644
index 0000000..1c72689
--- /dev/null
+++ b/GameCode/PlayerManager.cs
@@ -0,0 +1,415 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Photon.Pun;
+using Sonigon;
+using UnityEngine;
+
+public class PlayerManager : MonoBehaviour
+{
+	[Header("Sounds")]
+	public SoundEvent[] soundCharacterSpawn;
+
+	public static PlayerManager instance;
+
+	public LayerMask canSeePlayerMask;
+
+	public List<Player> players = new List<Player>();
+
+	public PhotonView view;
+
+	private Action<Player, int> PlayerDiedAction;
+
+	private bool playersShouldBeActive;
+
+	public AnimationCurve playerMoveCurve;
+
+	public Action<Player> PlayerJoinedAction { get; internal set; }
+
+	private void Awake()
+	{
+		instance = this;
+		view = GetComponent<PhotonView>();
+	}
+
+	public Player GetOtherPlayer(Player asker)
+	{
+		return GetClosestPlayerInTeam(asker.transform.position, GetOtherTeam(asker.teamID));
+	}
+
+	public Player GetClosestPlayer(Vector2 refPos, bool needVision = false)
+	{
+		Player result = null;
+		float num = float.PositiveInfinity;
+		for (int i = 0; i < players.Count; i++)
+		{
+			if (!players[i].data.dead)
+			{
+				float num2 = Vector2.Distance(refPos, players[i].data.playerVel.position);
+				if ((!needVision || CanSeePlayer(refPos, players[i]).canSee) && num2 < num)
+				{
+					num = num2;
+					result = players[i];
+				}
+			}
+		}
+		return result;
+	}
+
+	internal Player GetPlayerWithActorID(int actorID)
+	{
+		for (int i = 0; i < players.Count; i++)
+		{
+			if (players[i].data.view.OwnerActorNr == actorID)
+			{
+				return players[i];
+			}
+		}
+		return null;
+	}
+
+	public Player GetClosestPlayerInTeam(Vector3 position, int team, bool needVision = false)
+	{
+		float num = float.MaxValue;
+		Player[] playersInTeam = GetPlayersInTeam(team);
+		Player result = null;
+		for (int i = 0; i < playersInTeam.Length; i++)
+		{
+			if (!players[i].data.dead)
+			{
+				float num2 = Vector2.Distance(position, playersInTeam[i].transform.position);
+				if ((!needVision || CanSeePlayer(position, playersInTeam[i]).canSee) && num2 < num)
+				{
+					num = num2;
+					result = playersInTeam[i];
+				}
+			}
+		}
+		return result;
+	}
+
+	public Player GetClosestPlayer(Vector2 refPos, Vector2 forward)
+	{
+		Player result = null;
+		float num = float.PositiveInfinity;
+		for (int i = 0; i < players.Count; i++)
+		{
+			if (!players[i].data.dead && CanSeePlayer(refPos, players[i]).canSee)
+			{
+				float num2 = Vector2.Distance(refPos, players[i].data.playerVel.position);
+				num2 += Vector2.Angle(forward, players[i].data.playerVel.position - refPos);
+				if (num2 < num)
+				{
+					num = num2;
+					result = players[i];
+				}
+			}
+		}
+		return result;
+	}
+
+	public CanSeeInfo CanSeePlayer(Vector2 from, Player player)
+	{
+		CanSeeInfo canSeeInfo = new CanSeeInfo();
+		canSeeInfo.canSee = true;
+		canSeeInfo.distance = float.PositiveInfinity;
+		if (!player)
+		{
+			canSeeInfo.canSee = false;
+			return canSeeInfo;
+		}
+		RaycastHit2D[] array = Physics2D.RaycastAll(from, (player.data.playerVel.position - from).normalized, Vector2.Distance(from, player.data.playerVel.position), canSeePlayerMask);
+		for (int i = 0; i < array.Length; i++)
+		{
+			if ((bool)array[i].transform && !array[i].transform.root.GetComponent<SpawnedAttack>() && !array[i].transform.root.GetComponent<Player>() && array[i].distance < canSeeInfo.distance)
+			{
+				canSeeInfo.canSee = false;
+				canSeeInfo.hitPoint = array[i].point;
+				canSeeInfo.distance = array[i].distance;
+			}
+		}
+		return canSeeInfo;
+	}
+
+	internal Player GetPlayerWithID(int playerID)
+	{
+		for (int i = 0; i < players.Count; i++)
+		{
+			if (players[i].playerID == playerID)
+			{
+				return players[i];
+			}
+		}
+		return null;
+	}
+
+	public Player GetLastPlayerAlive()
+	{
+		Player result = null;
+		for (int i = 0; i < players.Count; i++)
+		{
+			if (!players[i].data.dead)
+			{
+				result = players[i];
+				break;
+			}
+		}
+		return result;
+	}
+
+	public int GetLastTeamAlive()
+	{
+		return GetLastPlayerAlive().teamID;
+	}
+
+	public int TeamsAlive()
+	{
+		bool flag = false;
+		bool flag2 = false;
+		for (int i = 0; i < players.Count; i++)
+		{
+			if (players[i].teamID == 0 && !players[i].data.dead)
+			{
+				flag = true;
+			}
+			if (players[i].teamID == 1 && !players[i].data.dead)
+			{
+				flag2 = true;
+			}
+		}
+		int num = 0;
+		if (flag)
+		{
+			num++;
+		}
+		if (flag2)
+		{
+			num++;
+		}
+		return num;
+	}
+
+	public static void RegisterPlayer(Player player)
+	{
+		instance.players.Add(player);
+		if (instance.playersShouldBeActive)
+		{
+			player.data.isPlaying = true;
+		}
+	}
+
+	public void RemovePlayer(Player player)
+	{
+		players.Remove(player);
+		UnityEngine.Object.Destroy(player.gameObject);
+	}
+
+	public void RemovePlayers()
+	{
+		for (int num = players.Count - 1; num >= 0; num--)
+		{
+			if ((bool)players[num])
+			{
+				UnityEngine.Object.Destroy(players[num].gameObject);
+			}
+		}
+		players.Clear();
+		PlayerAssigner.instance.ClearPlayers();
+	}
+
+	public void RevivePlayers()
+	{
+		for (int i = 0; i < players.Count; i++)
+		{
+			players[i].data.healthHandler.Revive();
+			players[i].GetComponent<GeneralInput>().enabled = true;
+		}
+	}
+
+	[PunRPC]
+	public void RPCA_MovePlayers()
+	{
+		MovePlayers(MapManager.instance.GetSpawnPoints());
+	}
+
+	public void MovePlayers(SpawnPoint[] spawnPoints)
+	{
+		for (int i = 0; i < players.Count; i++)
+		{
+			StartCoroutine(Move(players[i].data.playerVel, spawnPoints[i].localStartPos));
+			int num;
+			for (num = i; num >= soundCharacterSpawn.Length; num -= soundCharacterSpawn.Length)
+			{
+			}
+			SoundManager.Instance.Play(soundCharacterSpawn[num], players[i].transform);
+		}
+	}
+
+	public void AddPlayerDiedAction(Action<Player, int> action)
+	{
+		PlayerDiedAction = (Action<Player, int>)Delegate.Combine(PlayerDiedAction, action);
+	}
+
+	public void PlayerDied(Player player)
+	{
+		int num = 0;
+		for (int i = 0; i < players.Count; i++)
+		{
+			if (!instance.players[i].data.dead)
+			{
+				num++;
+			}
+		}
+		if (PlayerDiedAction != null)
+		{
+			PlayerDiedAction(player, num);
+		}
+	}
+
+	public PlayerSkin GetColorFromTeam(int teamID)
+	{
+		return PlayerSkinBank.GetPlayerSkinColors(GetPlayersInTeam(teamID)[0].playerID);
+	}
+
+	public PlayerSkin GetColorFromPlayer(int playerID)
+	{
+		return PlayerSkinBank.GetPlayerSkinColors(playerID);
+	}
+
+	public Player[] GetPlayersInTeam(int teamID)
+	{
+		List<Player> list = new List<Player>();
+		for (int i = 0; i < players.Count; i++)
+		{
+			if (players[i].teamID == teamID)
+			{
+				list.Add(players[i]);
+			}
+		}
+		return list.ToArray();
+	}
+
+	internal Player GetFirstPlayerInTeam(int teamID)
+	{
+		return GetPlayersInTeam(teamID)[0];
+	}
+
+	public int GetOtherTeam(int team)
+	{
+		if (team == 0)
+		{
+			return 1;
+		}
+		return 0;
+	}
+
+	public void SetPlayersPlaying(bool playing)
+	{
+		playersShouldBeActive = playing;
+		for (int i = 0; i < players.Count; i++)
+		{
+			players[i].data.isPlaying = playing;
+		}
+	}
+
+	public void SetPlayersSimulated(bool simulated)
+	{
+		playersShouldBeActive = simulated;
+		for (int i = 0; i < players.Count; i++)
+		{
+			players[i].data.playerVel.simulated = simulated;
+		}
+	}
+
+	internal void SetPlayersVisible(bool visible)
+	{
+		for (int i = 0; i < players.Count; i++)
+		{
+			players[i].data.gameObject.transform.position = Vector3.up * 200f;
+		}
+	}
+
+	public void PlayerJoined(Player player)
+	{
+		if (PlayerJoinedAction != null)
+		{
+			PlayerJoinedAction(player);
+		}
+	}
+
+	private IEnumerator Move(PlayerVelocity player, Vector3 targetPos)
+	{
+		Debug.Log("MOVE PLAYERS START " + Time.unscaledTime);
+		player.GetComponent<Player>().data.isPlaying = false;
+		player.simulated = false;
+		player.isKinematic = true;
+		Vector3 distance = targetPos - player.transform.position;
+		Vector3 targetStartPos = player.transform.position;
+		PlayerCollision col = player.GetComponent<PlayerCollision>();
+		float t = playerMoveCurve.keys[playerMoveCurve.keys.Length - 1].time;
+		float c = 0f;
+		while (c < t)
+		{
+			col.IgnoreWallForFrames(2);
+			c += Mathf.Clamp(Time.unscaledDeltaTime, 0f, 0.02f);
+			player.transform.position = targetStartPos + distance * playerMoveCurve.Evaluate(c);
+			yield return null;
+		}
+		int frames = 0;
+		while (frames < 10)
+		{
+			player.transform.position = targetStartPos + distance;
+			frames++;
+			yield return null;
+		}
+		player.simulated = true;
+		player.isKinematic = false;
+		Debug.Log("MOVE PLAYERS END " + Time.unscaledTime);
+		player.GetComponent<Player>().data.isPlaying = true;
+		player.GetComponent<Player>().data.healthHandler.Revive();
+		CardChoiceVisuals.instance.Hide();
+	}
+
+	private void Update()
+	{
+		if (Input.GetKeyDown(KeyCode.R) && !DevConsole.isTyping && Application.isEditor)
+		{
+			ResetCharacters();
+		}
+	}
+
+	internal void ResetCharacters()
+	{
+		CardBarHandler.instance.ResetCardBards();
+		for (int i = 0; i < players.Count; i++)
+		{
+			players[i].FullReset();
+		}
+	}
+
+	public PlayerActions[] GetActionsFromTeam(int selectingTeamID)
+	{
+		List<PlayerActions> list = new List<PlayerActions>();
+		for (int i = 0; i < players.Count; i++)
+		{
+			if (players[i].teamID == selectingTeamID)
+			{
+				list.Add(players[i].data.playerActions);
+			}
+		}
+		return list.ToArray();
+	}
+
+	public PlayerActions[] GetActionsFromPlayer(int selectingPlayerID)
+	{
+		List<PlayerActions> list = new List<PlayerActions>();
+		for (int i = 0; i < players.Count; i++)
+		{
+			if (players[i].playerID == selectingPlayerID)
+			{
+				list.Add(players[i].data.playerActions);
+			}
+		}
+		return list.ToArray();
+	}
+}