412 lines
9.5 KiB
C#
412 lines
9.5 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
public class TournamentManager : MonoBehaviour
|
|
{
|
|
[Serializable]
|
|
public class TournamentFish
|
|
{
|
|
public Fish.Species species = Fish.Species.COUNT;
|
|
|
|
public float weight = 1f;
|
|
|
|
public Vector2 weightMinMax = new Vector2(4f, 6f);
|
|
}
|
|
|
|
[Serializable]
|
|
public class TournamentDefinition
|
|
{
|
|
public enum FinishCondition
|
|
{
|
|
TIME = 0,
|
|
GOAL_FIRST = 1,
|
|
COUNT = 2
|
|
}
|
|
|
|
public enum GoalType
|
|
{
|
|
AMOUNT = 0,
|
|
WEIGHT_SUM = 1,
|
|
WEIGHT_MAX = 2,
|
|
COUNT = 3
|
|
}
|
|
|
|
public FinishCondition finishCondition;
|
|
|
|
public GoalType goalType;
|
|
|
|
public int nrOfPlayers = 4;
|
|
|
|
public float duration = 60f;
|
|
|
|
public float goalAmount = 10f;
|
|
|
|
public static string FinishConditionToString(FinishCondition enumValue)
|
|
{
|
|
switch (enumValue)
|
|
{
|
|
case FinishCondition.TIME:
|
|
return Utilities.GetTranslation("GUI/TOURNAMENTS_TIME");
|
|
case FinishCondition.GOAL_FIRST:
|
|
return Utilities.GetTranslation("GUI/TOURNAMENTS_GOAL");
|
|
default:
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
public static string GoalTypeToString(GoalType enumValue)
|
|
{
|
|
switch (enumValue)
|
|
{
|
|
case GoalType.AMOUNT:
|
|
return Utilities.GetTranslation("GUI/TOURNAMENTS_FISH_AMOUNT");
|
|
case GoalType.WEIGHT_SUM:
|
|
return Utilities.GetTranslation("GUI/TOURNAMENTS_WEIGHT_SUM");
|
|
case GoalType.WEIGHT_MAX:
|
|
return Utilities.GetTranslation("GUI/TOURNAMENTS_WEIGHT_MAX");
|
|
default:
|
|
return string.Empty;
|
|
}
|
|
}
|
|
}
|
|
|
|
[HideInInspector]
|
|
public HUDTournament hudTournament;
|
|
|
|
[HideInInspector]
|
|
public GameController gameController;
|
|
|
|
public bool tournamentActive;
|
|
|
|
public bool tournamentStarted = true;
|
|
|
|
public float currentTime;
|
|
|
|
public TournamentPlayer tournamentPlayerPrefab;
|
|
|
|
public List<TournamentPlayer> players = new List<TournamentPlayer>();
|
|
|
|
public List<TournamentPlayer> sortedPlayers = new List<TournamentPlayer>();
|
|
|
|
public TournamentDefinition tournamentDefinition = new TournamentDefinition();
|
|
|
|
public List<TournamentFish> tournamentSpecies = new List<TournamentFish>();
|
|
|
|
public int currentPlayerPosition;
|
|
|
|
public float networkTimeUpdateTimer = 15f;
|
|
|
|
public void Awake()
|
|
{
|
|
}
|
|
|
|
public void Initialize()
|
|
{
|
|
gameController = GameController.Instance;
|
|
if ((bool)GlobalSettings.Instance)
|
|
{
|
|
tournamentDefinition = GlobalSettings.Instance.tournamentDefinition;
|
|
}
|
|
currentTime = tournamentDefinition.duration * 60f;
|
|
for (int i = 0; i < (gameController.isMultiplayer ? 1 : tournamentDefinition.nrOfPlayers); i++)
|
|
{
|
|
TournamentPlayer tournamentPlayer = UnityEngine.Object.Instantiate(tournamentPlayerPrefab);
|
|
tournamentPlayer.transform.parent = base.transform;
|
|
tournamentPlayer.isAi = true;
|
|
tournamentPlayer.playerId = i;
|
|
tournamentPlayer.playerName = "AI Player " + i;
|
|
tournamentPlayer.aiLevel = Mathf.FloorToInt((float)i / (float)tournamentDefinition.nrOfPlayers * 10f);
|
|
AddPlayer(tournamentPlayer, false);
|
|
tournamentPlayer.Initialize();
|
|
}
|
|
gameController.fishingPlayer.SetTournamentPlayer(players[0]);
|
|
UpdateSortedPlayers();
|
|
tournamentSpecies = gameController.GetAvailableSpecies();
|
|
hudTournament = HUDManager.Instance.hudTournament;
|
|
hudTournament.Initialize();
|
|
hudTournament.UpdateTime(currentTime);
|
|
hudTournament.UpdateGoal((int)tournamentDefinition.goalAmount);
|
|
hudTournament.UpdatePlayerWidgets();
|
|
tournamentActive = true;
|
|
}
|
|
|
|
public void UpdateMultiplayerSettings()
|
|
{
|
|
hudTournament.UpdateMultiplayerSettings();
|
|
hudTournament.UpdateTime(currentTime);
|
|
hudTournament.UpdateGoal((int)tournamentDefinition.goalAmount);
|
|
hudTournament.UpdatePlayerWidgets();
|
|
}
|
|
|
|
public void MakeUpdate()
|
|
{
|
|
hudTournament.UpdateStartInfo();
|
|
if (!tournamentActive || !tournamentStarted)
|
|
{
|
|
return;
|
|
}
|
|
if (!gameController.isMultiplayer)
|
|
{
|
|
for (int i = 0; i < players.Count; i++)
|
|
{
|
|
players[i].MakeUpdate();
|
|
}
|
|
}
|
|
if (tournamentDefinition.finishCondition != TournamentDefinition.FinishCondition.TIME || !(currentTime > 0f))
|
|
{
|
|
return;
|
|
}
|
|
UpdateNetworkTime();
|
|
currentTime -= Time.deltaTime;
|
|
hudTournament.UpdateTime(currentTime);
|
|
if (currentTime < 0.8f)
|
|
{
|
|
currentTime = 0f;
|
|
hudTournament.UpdateTime(currentTime);
|
|
if (!gameController.isMultiplayer || PhotonNetwork.isMasterClient)
|
|
{
|
|
FinishTournament();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void UpdateNetworkTime()
|
|
{
|
|
if (gameController.isMultiplayer && PhotonNetwork.isMasterClient)
|
|
{
|
|
networkTimeUpdateTimer -= Time.deltaTime;
|
|
if (networkTimeUpdateTimer <= 0f)
|
|
{
|
|
networkTimeUpdateTimer = 15f;
|
|
gameController.multiplayerManager.UpdateMyTime();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void AddPlayer(TournamentPlayer tournamentPlayer, bool sort = true)
|
|
{
|
|
players.Add(tournamentPlayer);
|
|
if (sort)
|
|
{
|
|
UpdateSortedPlayers();
|
|
}
|
|
}
|
|
|
|
public void AddNetworkPlayer(PhotonPlayer photonPlayer, bool sort = true)
|
|
{
|
|
TournamentPlayer tournamentPlayer = UnityEngine.Object.Instantiate(tournamentPlayerPrefab);
|
|
tournamentPlayer.transform.parent = base.transform;
|
|
tournamentPlayer.isAi = false;
|
|
tournamentPlayer.playerId = photonPlayer.ID;
|
|
tournamentPlayer.playerName = photonPlayer.name;
|
|
tournamentPlayer.Initialize();
|
|
players.Add(tournamentPlayer);
|
|
if (sort)
|
|
{
|
|
UpdateSortedPlayers();
|
|
}
|
|
hudTournament.UpdatePlayerWidgets();
|
|
}
|
|
|
|
public TournamentPlayer GetPlayer(int playerId)
|
|
{
|
|
for (int i = 0; i < players.Count; i++)
|
|
{
|
|
if (players[i].playerId == playerId)
|
|
{
|
|
return players[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public TournamentPlayer GetMyPlayer()
|
|
{
|
|
return gameController.fishingPlayer.tournamentPlayer;
|
|
}
|
|
|
|
public void RemoveAllPlayers(bool alsoMe)
|
|
{
|
|
players.Clear();
|
|
sortedPlayers.Clear();
|
|
players.Add(GetMyPlayer());
|
|
UpdateSortedPlayers();
|
|
hudTournament.UpdatePlayerWidgets();
|
|
}
|
|
|
|
public void RemovePlayer(int playerId)
|
|
{
|
|
int num = -1;
|
|
for (int i = 0; i < players.Count; i++)
|
|
{
|
|
if (players[i].playerId == playerId)
|
|
{
|
|
num = i;
|
|
break;
|
|
}
|
|
}
|
|
if (players.Count > num)
|
|
{
|
|
players.RemoveAt(num);
|
|
}
|
|
UpdateSortedPlayers();
|
|
hudTournament.UpdatePlayerWidgets();
|
|
}
|
|
|
|
public void UpdateSortedPlayers()
|
|
{
|
|
sortedPlayers.Clear();
|
|
sortedPlayers.AddRange(players);
|
|
SortPlayers();
|
|
}
|
|
|
|
public void SortPlayers()
|
|
{
|
|
sortedPlayers.Sort((TournamentPlayer p1, TournamentPlayer p2) => p2.GetScore().CompareTo(p1.GetScore()));
|
|
int sortedPosition = 0;
|
|
float num = -1f;
|
|
for (int num2 = 0; num2 < sortedPlayers.Count; num2++)
|
|
{
|
|
if (sortedPlayers[num2].GetScore() != num)
|
|
{
|
|
sortedPosition = num2 + 1;
|
|
num = sortedPlayers[num2].GetScore();
|
|
}
|
|
sortedPlayers[num2].sortedPosition = sortedPosition;
|
|
}
|
|
float score = players[0].GetScore();
|
|
int num3 = -1;
|
|
for (int num4 = 0; num4 < sortedPlayers.Count; num4++)
|
|
{
|
|
if (sortedPlayers[num4].GetScore() == score && num3 == -1)
|
|
{
|
|
num3 = num4;
|
|
}
|
|
if (sortedPlayers[num4].isLocalPlayer)
|
|
{
|
|
currentPlayerPosition = num4;
|
|
break;
|
|
}
|
|
}
|
|
if (num3 != -1 && currentPlayerPosition != num3)
|
|
{
|
|
TournamentPlayer value = sortedPlayers[num3];
|
|
sortedPlayers[num3] = sortedPlayers[currentPlayerPosition];
|
|
sortedPlayers[currentPlayerPosition] = value;
|
|
currentPlayerPosition = num3;
|
|
}
|
|
}
|
|
|
|
public void FinalSortPlayers(float[] sendTable)
|
|
{
|
|
sortedPlayers.Clear();
|
|
for (int i = 0; i < sendTable.Length; i += 2)
|
|
{
|
|
TournamentPlayer player = GetPlayer((int)sendTable[i]);
|
|
if ((bool)player)
|
|
{
|
|
player.SetScore(tournamentDefinition.goalType, sendTable[i + 1]);
|
|
sortedPlayers.Add(player);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static TournamentFish FishToTournamentFish(Fish fish)
|
|
{
|
|
TournamentFish tournamentFish = new TournamentFish();
|
|
tournamentFish.species = fish.species;
|
|
tournamentFish.weight = fish.Weight;
|
|
tournamentFish.weightMinMax = fish.WeightMinMax;
|
|
return tournamentFish;
|
|
}
|
|
|
|
public void PlayerCatchFish(int playerId, TournamentFish fish)
|
|
{
|
|
Debug.Log("Tournament Catch Fish: " + ((!GetPlayer(playerId)) ? "null" : GetPlayer(playerId).playerName) + " " + fish.species.ToString() + " " + fish.weight);
|
|
SortPlayers();
|
|
hudTournament.UpdatePlayerWidgets();
|
|
if (gameController.isMultiplayer)
|
|
{
|
|
gameController.multiplayerManager.UpdateMyScore();
|
|
}
|
|
if (CheckFinishCondition())
|
|
{
|
|
FinishTournament();
|
|
}
|
|
}
|
|
|
|
public bool CheckFinishCondition()
|
|
{
|
|
if (!PhotonNetwork.isMasterClient)
|
|
{
|
|
return false;
|
|
}
|
|
if (tournamentDefinition.finishCondition == TournamentDefinition.FinishCondition.TIME)
|
|
{
|
|
return false;
|
|
}
|
|
if (tournamentDefinition.goalType == TournamentDefinition.GoalType.AMOUNT)
|
|
{
|
|
for (int i = 0; i < players.Count; i++)
|
|
{
|
|
if (players[i].GetScore() >= tournamentDefinition.goalAmount)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else if (tournamentDefinition.goalType == TournamentDefinition.GoalType.WEIGHT_SUM)
|
|
{
|
|
for (int j = 0; j < players.Count; j++)
|
|
{
|
|
if (players[j].GetScore() >= tournamentDefinition.goalAmount)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else if (tournamentDefinition.goalType == TournamentDefinition.GoalType.WEIGHT_MAX)
|
|
{
|
|
for (int k = 0; k < players.Count; k++)
|
|
{
|
|
if (players[k].GetScore() >= tournamentDefinition.goalAmount)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void StartTournament()
|
|
{
|
|
tournamentStarted = true;
|
|
hudTournament.UpdatePlayerWidgets();
|
|
}
|
|
|
|
public void FinishTournament()
|
|
{
|
|
Debug.Log("Tournament Finished");
|
|
tournamentActive = false;
|
|
if (PhotonNetwork.isMasterClient)
|
|
{
|
|
LeanTween.delayedCall(4f, ShowFinishScreen);
|
|
}
|
|
else
|
|
{
|
|
ShowFinishScreen();
|
|
}
|
|
if (gameController.isMultiplayer)
|
|
{
|
|
gameController.multiplayerManager.FinishTournament();
|
|
}
|
|
}
|
|
|
|
private void ShowFinishScreen()
|
|
{
|
|
gameController.hudManager.ShowTournamentFinishScreen(true);
|
|
hudTournament.UpdateFinishWidgets();
|
|
}
|
|
}
|