354 lines
11 KiB
C#
354 lines
11 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using System;
|
|
using UnityEngine.SceneManagement;
|
|
|
|
|
|
|
|
/*
|
|
***** LOAD ALL PLAYERPREFS FOR DIFFERENT ASPECTS OF THE GAME
|
|
5 PlayerPrefs:
|
|
1. Announcements
|
|
2. Animate Completed Missions
|
|
3. Mission
|
|
4. Rewards
|
|
5. Settings
|
|
*/
|
|
|
|
|
|
//PLAYERPREFS for Animate Completed Missions, Missions, Rewards, and Settings
|
|
#region
|
|
//PlayerPrefs to handle Animation of Completed Missions
|
|
[System.Serializable]
|
|
public class Completed_Missions_toAnimate{
|
|
public int current_week; //records the week the player is at
|
|
public List<int> completed_missions_toAnimate_data; //records ID's of completed missions
|
|
public int animation_status;
|
|
}
|
|
|
|
|
|
//MISSIONS PlayerPrefs
|
|
#region
|
|
//Progress of missions
|
|
[System.Serializable]
|
|
public class MissionProgress{
|
|
public string start_date; //The first date when the game was first opened by user
|
|
public int current_week; //records the week the player is at
|
|
public int current_month; //records the week the player is at
|
|
public List<int> completed_missions; //records ID's of completed missions
|
|
public List<string> completed_missions_inprogress; //For missions that span for more than 1 match, e.g Win 2 matches in a row
|
|
}
|
|
|
|
//Information about Individual missions, Weekly missions
|
|
[System.Serializable]
|
|
public class MissionInfo{
|
|
public int missionID;
|
|
public string missionTitle;
|
|
public string missionDescription;
|
|
public int missionXP;
|
|
public int missionProgressCount; //Keeps track of missions that requires count, such as Ads
|
|
public int month;
|
|
public int week;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
//REWARDS PlayerPrefs
|
|
#region
|
|
//Player Details for the Game
|
|
[System.Serializable]
|
|
public class PlayerData{
|
|
public int xp; //Player's XP
|
|
public string rank; //Player's rank
|
|
public string prevRank; //Records Player's rank to compare if it changes/Player ranks up
|
|
public int overall_matches; //Match played
|
|
public int win_streak; //Number of win streaks, streaks cause rank to level up
|
|
public int loss_streak; //Number of loss streaks, streaks cause rank to level down
|
|
public int overall_wins; //Number of overall wins
|
|
public int overall_losses; //Number of overall losses
|
|
public int rank_level; //Player's rank level, such as Level 1 Bronze, Level 2 Bronze etc.
|
|
public int prevrank_level; //Records Player's rank level to compare if it changes/Player ranks up
|
|
public int rank_game; //Keeps count of rank level, if reaches certain limit, then increments rank_level
|
|
public int eliminations;
|
|
public int deaths;
|
|
public int revives;
|
|
}
|
|
#endregion
|
|
|
|
|
|
|
|
//SETTINGS PlayerPrefs Data Details
|
|
#region
|
|
// Details on GameObject position in the UI
|
|
[System.Serializable]
|
|
public class ControlSettings{
|
|
public float positionX;
|
|
public float positionY;
|
|
public float scaleWidth;
|
|
public float scaleHeight;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class GameSettings{
|
|
public ControlSettings leftControl;
|
|
public ControlSettings blockControl;
|
|
public ControlSettings dodgeControl;
|
|
|
|
public ControlSettings rightControl;
|
|
public ControlSettings punchControl;
|
|
public ControlSettings kickControl;
|
|
|
|
// New controls/buttons
|
|
public ControlSettings weaponPickupButton;
|
|
public ControlSettings specialMoveButton;
|
|
public ControlSettings shieldButton;
|
|
public ControlSettings splintButton;
|
|
|
|
public float leftControlScaleValue;
|
|
public float rightControlScaleValue;
|
|
public float kickControlScaleValue;
|
|
public float punchControlScaleValue;
|
|
|
|
public float GameplayVolume_value;
|
|
public float UIVolume_value;
|
|
public float MusicVolume_value;
|
|
public float SFXVolume_value;
|
|
|
|
public string[] audioVolumes; //0. GameplayVolume, 1. UIVolume, 2. MusicVolume, 3. SFXVolume
|
|
}
|
|
#endregion
|
|
#endregion
|
|
|
|
|
|
|
|
public class GameInitialize : MonoBehaviour{
|
|
private static bool isInitialized = false;
|
|
public static GameInitialize Instance { get; private set; }
|
|
[SerializeField] private string authSceneName = "AuthenticationScene";
|
|
[SerializeField] private string menuSceneName = "MenuScene";
|
|
[Tooltip("Force skip auth and go straight to menu after splash")] [SerializeField]
|
|
private bool forceMenuDuringDevelopment = true;
|
|
|
|
private Coroutine authRoutine;
|
|
private bool subscribedToSplash;
|
|
private bool waitingForGameManager;
|
|
|
|
private void Awake()
|
|
{
|
|
if (Instance != null && Instance != this)
|
|
{
|
|
Destroy(gameObject);
|
|
return;
|
|
}
|
|
|
|
if (!isInitialized)
|
|
{
|
|
isInitialized = true;
|
|
Instance = this;
|
|
// Move to root before DontDestroyOnLoad (required for it to work)
|
|
transform.SetParent(null);
|
|
DontDestroyOnLoad(gameObject);
|
|
TryStartAuthFlow();
|
|
}
|
|
else
|
|
{
|
|
Destroy(gameObject);
|
|
}
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
if (GameManager.Instance == null && !waitingForGameManager)
|
|
{
|
|
waitingForGameManager = true;
|
|
StartCoroutine(WaitForGameManagerAndStart());
|
|
}
|
|
}
|
|
|
|
private void TryStartAuthFlow()
|
|
{
|
|
var gm = GameManager.Instance;
|
|
if (gm == null)
|
|
{
|
|
if (!waitingForGameManager)
|
|
{
|
|
waitingForGameManager = true;
|
|
StartCoroutine(WaitForGameManagerAndStart());
|
|
}
|
|
return;
|
|
}
|
|
|
|
waitingForGameManager = false;
|
|
|
|
// Development override: skip subscribing & auth checks entirely.
|
|
if (forceMenuDuringDevelopment)
|
|
{
|
|
Debug.Log("[GameInitialize] forceMenuDuringDevelopment active: skipping auth flow & loading menu when splash ends (or immediately if already finished).");
|
|
if (gm.HasSplashFinished)
|
|
{
|
|
TriggerSceneLoad(menuSceneName);
|
|
}
|
|
else if (!subscribedToSplash)
|
|
{
|
|
gm.SplashSequenceCompleted += () => TriggerSceneLoad(menuSceneName);
|
|
subscribedToSplash = true; // still mark to avoid duplicate subscription
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (gm.HasSplashFinished)
|
|
{
|
|
BeginAuthCheck();
|
|
}
|
|
else if (!subscribedToSplash)
|
|
{
|
|
gm.SplashSequenceCompleted += HandleSplashSequenceCompleted;
|
|
subscribedToSplash = true;
|
|
}
|
|
}
|
|
|
|
private IEnumerator WaitForGameManagerAndStart()
|
|
{
|
|
while (GameManager.Instance == null)
|
|
{
|
|
yield return null;
|
|
}
|
|
|
|
waitingForGameManager = false;
|
|
TryStartAuthFlow();
|
|
}
|
|
|
|
private void HandleSplashSequenceCompleted()
|
|
{
|
|
if (GameManager.Instance != null && subscribedToSplash)
|
|
{
|
|
GameManager.Instance.SplashSequenceCompleted -= HandleSplashSequenceCompleted;
|
|
}
|
|
|
|
subscribedToSplash = false;
|
|
BeginAuthCheck();
|
|
}
|
|
|
|
public void BeginAuthCheck()
|
|
{
|
|
if (authRoutine != null)
|
|
{
|
|
StopCoroutine(authRoutine);
|
|
}
|
|
|
|
authRoutine = StartCoroutine(CheckAuthAndRedirectRoutine());
|
|
}
|
|
|
|
private IEnumerator CheckAuthAndRedirectRoutine()
|
|
{
|
|
string targetScene = forceMenuDuringDevelopment ? menuSceneName : authSceneName; // still computed (kept for future toggle at runtime)
|
|
string token = PlayerPrefs.GetString("AuthToken", null);
|
|
|
|
if (!forceMenuDuringDevelopment && !string.IsNullOrEmpty(token))
|
|
{
|
|
var walletSystem = CoinWalletSystem.Instance;
|
|
if (walletSystem != null)
|
|
{
|
|
var initTask = walletSystem.InitializeWallet();
|
|
while (!initTask.IsCompleted)
|
|
{
|
|
yield return null;
|
|
}
|
|
|
|
if (initTask.Status == System.Threading.Tasks.TaskStatus.RanToCompletion && initTask.Result)
|
|
{
|
|
Debug.Log("Authentication successful. Loading menu.");
|
|
targetScene = menuSceneName;
|
|
}
|
|
else
|
|
{
|
|
string reason = initTask.IsFaulted ? initTask.Exception?.GetBaseException()?.Message ?? "Wallet initialization faulted." : "Failed to initialize wallet.";
|
|
RedirectToAuth(reason);
|
|
authRoutine = null;
|
|
yield break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("CoinWalletSystem instance not found. Proceeding to menu.");
|
|
targetScene = menuSceneName;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("No auth token found. Redirecting to authentication.");
|
|
RedirectToAuth("No auth token found.");
|
|
authRoutine = null;
|
|
yield break;
|
|
}
|
|
|
|
if (forceMenuDuringDevelopment)
|
|
{
|
|
// Should have been short-circuited earlier, but safeguard here.
|
|
Debug.Log("[GameInitialize] (Late) development override still active; forcing menu.");
|
|
targetScene = menuSceneName;
|
|
}
|
|
TriggerSceneLoad(targetScene);
|
|
authRoutine = null;
|
|
}
|
|
|
|
private void RedirectToAuth(string reason)
|
|
{
|
|
Debug.Log($"Redirecting to auth: {reason}");
|
|
ClearStoredToken();
|
|
TriggerSceneLoad(authSceneName);
|
|
}
|
|
|
|
private void TriggerSceneLoad(string sceneName)
|
|
{
|
|
if (GameManager.Instance != null)
|
|
{
|
|
GameManager.Instance.LoadSceneWithLoading(sceneName);
|
|
}
|
|
else
|
|
{
|
|
SceneManager.LoadScene(sceneName);
|
|
}
|
|
}
|
|
|
|
private void ClearStoredToken()
|
|
{
|
|
PlayerPrefs.DeleteKey("AuthToken");
|
|
PlayerPrefs.Save();
|
|
}
|
|
|
|
public void OnSuccessfulAuthentication(string token)
|
|
{
|
|
PlayerPrefs.SetString("AuthToken", token);
|
|
PlayerPrefs.Save();
|
|
BeginAuthCheck();
|
|
}
|
|
|
|
public void SetUserAuthenticated(bool authenticated)
|
|
{
|
|
if (forceMenuDuringDevelopment)
|
|
{
|
|
Debug.Log("[GameInitialize] Ignoring SetUserAuthenticated call because forceMenuDuringDevelopment is TRUE.");
|
|
return;
|
|
}
|
|
if (!authenticated) RedirectToAuth("User logged out.");
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if (GameManager.Instance != null && subscribedToSplash)
|
|
{
|
|
GameManager.Instance.SplashSequenceCompleted -= HandleSplashSequenceCompleted;
|
|
}
|
|
|
|
if (Instance == this)
|
|
{
|
|
Instance = null;
|
|
isInitialized = false;
|
|
}
|
|
}
|
|
}
|