659 lines
21 KiB
C#
659 lines
21 KiB
C#
using UnityEngine;
|
|
using DG.Tweening;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using TMPro;
|
|
using UnityEngine.Networking;
|
|
using UnityEngine.UI;
|
|
public class GameOverCanvas : MonoBehaviour
|
|
{
|
|
public bool showOnLoad = false;
|
|
CanvasGroup canvasGroup;
|
|
[Header("Intro items")]
|
|
public RectTransform[] middleScalingItems;
|
|
public RectTransform[] comingFromMiddle;
|
|
public RectTransform[] prizeFrames;
|
|
public RectTransform[] comingDown;
|
|
|
|
Dictionary<RectTransform, Vector3> OriginalPositions;
|
|
Dictionary<RectTransform, Vector3> OriginalScales;
|
|
|
|
[Header("Values")]
|
|
public TMP_Text p1_name;
|
|
public TMP_Text p1_l10;
|
|
public TMP_Text p2_name;
|
|
public TMP_Text p2_l10;
|
|
|
|
public GameObject p1_red,p2_red,p1_blue,p2_blue;
|
|
public Image p1_icon, p2_icon;
|
|
public Sprite redIcon, blueIcon;
|
|
|
|
public RectTransform p1_winner, p2_winner;
|
|
[Header("Game Over Data")]
|
|
public Button btnRematch;
|
|
public Button btnLeave;
|
|
public TMP_Text rematchWarningLoser;
|
|
public TMP_Text txtBetRC;
|
|
public TMP_Text txtRewardRC;
|
|
public TMP_Text txtRewardCC;
|
|
public TMP_Text countdownTxt;
|
|
string returningToMenuText;
|
|
|
|
public float returnToMenuCountdown = 15f;
|
|
|
|
/// <summary>Each player needs at least 2.0 RC (20 coin units) to rematch.</summary>
|
|
const int MinimumRematchRcCoins = 20;
|
|
|
|
[Header("Bet Limit")]
|
|
public TMP_Text txtRcBalance;
|
|
public TMP_Text txtBetLimitWarning;
|
|
public CanvasGroup betLimitAdjustPanel;
|
|
//minVal: 2, max Val 500, when its 500, show ∞ on the text
|
|
public Slider betLimitSlider;
|
|
public TMP_Text txtBetLimitSliderValue;
|
|
public Button btnBetLimitAdjustAccept;
|
|
public Button btnBetLimitAdjustCancel;
|
|
|
|
const string PersonalBetLimitPrefsKey = "WalkInvest.PersonalBetLimit";
|
|
const int BetLimitMin = 2;
|
|
const int BetLimitMax = 500;
|
|
const int BetLimitUnlimited = 500;
|
|
|
|
int rematchOpponentBetLimitCoins = BetLimitUnlimited;
|
|
|
|
[Header("Rematch panel")]
|
|
public CanvasGroup rematchPanel;
|
|
public RectTransform rematchPopup;
|
|
public TMP_Text txtMyRCBalance, txtOpponentRCBalance;
|
|
public TMP_Text txtSelectedBet;
|
|
public Slider betSlider;
|
|
public Button btnConfirmBet;
|
|
public Button btnCancelBet;
|
|
|
|
|
|
public static GameOverCanvas instance;
|
|
|
|
void Awake()
|
|
{
|
|
instance = this;
|
|
canvasGroup = GetComponent<CanvasGroup>();
|
|
Hide();
|
|
|
|
CollectOriginalPositionsAndScales();
|
|
|
|
returningToMenuText = countdownTxt.text;
|
|
}
|
|
|
|
void Start()
|
|
{
|
|
if(showOnLoad){
|
|
if(LevelLoadManager.instance == null){ //Load dummy data for testing
|
|
LevelLoadManager.myPlayer = new MatchmadePlayer(){Name = "test p1", l10_wins = 3, l10_losses = 1};
|
|
LevelLoadManager.opponentPlayer = new MatchmadePlayer(){Name = "test p2", l10_wins = 1, l10_losses = 3};
|
|
}
|
|
Show(Team.Red, Team.Red, 3, 1);
|
|
}
|
|
|
|
btnRematch.onClick.AddListener(OnBtnRematchClicked);
|
|
btnLeave.onClick.AddListener(OnBtnLeaveGameClicked);
|
|
|
|
betSlider.onValueChanged.AddListener(OnBetSliderValueChanged);
|
|
|
|
btnConfirmBet.onClick.AddListener(OnBetAccepted);
|
|
btnCancelBet.onClick.AddListener(OnBetCancelled);
|
|
|
|
SetupBetLimitUi();
|
|
}
|
|
|
|
void SetupBetLimitUi()
|
|
{
|
|
if (betLimitSlider != null)
|
|
{
|
|
betLimitSlider.minValue = BetLimitMin;
|
|
betLimitSlider.maxValue = BetLimitMax;
|
|
betLimitSlider.wholeNumbers = true;
|
|
betLimitSlider.onValueChanged.AddListener(OnBetLimitSliderValueChanged);
|
|
}
|
|
|
|
if (btnBetLimitAdjustAccept != null)
|
|
btnBetLimitAdjustAccept.onClick.AddListener(OnBetLimitAdjustAccepted);
|
|
if (btnBetLimitAdjustCancel != null)
|
|
btnBetLimitAdjustCancel.onClick.AddListener(CloseBetLimitAdjuster);
|
|
|
|
var warningButton = txtBetLimitWarning != null
|
|
? txtBetLimitWarning.GetComponentInChildren<Button>()
|
|
: null;
|
|
if (warningButton != null)
|
|
warningButton.onClick.AddListener(OpenBetLimitAdjuster);
|
|
}
|
|
|
|
public static int GetPersonalBetLimit()
|
|
{
|
|
return PlayerPrefs.GetInt(PersonalBetLimitPrefsKey, BetLimitUnlimited);
|
|
}
|
|
|
|
static int EffectiveBetLimitCap(int limitCoins) =>
|
|
limitCoins >= BetLimitUnlimited ? int.MaxValue : limitCoins;
|
|
|
|
int GetRematchMaxBetCoins()
|
|
{
|
|
int maxBet = Mathf.Min(
|
|
EffectiveBetLimitCap(rematchOpponentBetLimitCoins),
|
|
GetRcCoins(LevelLoadManager.myPlayer),
|
|
GetRcCoins(LevelLoadManager.opponentPlayer));
|
|
return Mathf.Max(0, maxBet);
|
|
}
|
|
|
|
void ApplyRematchBetSliderLimits()
|
|
{
|
|
if (betSlider == null)
|
|
return;
|
|
|
|
int maxBet = GetRematchMaxBetCoins();
|
|
betSlider.maxValue = maxBet;
|
|
if (maxBet <= 0)
|
|
{
|
|
betSlider.minValue = 0;
|
|
betSlider.value = 0;
|
|
}
|
|
else
|
|
{
|
|
betSlider.minValue = Mathf.Clamp(maxBet / 10f, 5, 10000);
|
|
betSlider.value = Mathf.Clamp(maxBet / 2, betSlider.minValue, maxBet);
|
|
}
|
|
OnBetSliderValueChanged(betSlider.value);
|
|
}
|
|
|
|
static void SetPersonalBetLimit(int limitCoins)
|
|
{
|
|
limitCoins = Mathf.Clamp(limitCoins, BetLimitMin, BetLimitMax);
|
|
PlayerPrefs.SetInt(PersonalBetLimitPrefsKey, limitCoins);
|
|
PlayerPrefs.Save();
|
|
}
|
|
|
|
static string FormatBetLimitLabel(int limitCoins)
|
|
{
|
|
if (limitCoins >= BetLimitUnlimited)
|
|
return "∞";
|
|
return CoinHelper.FormatString(limitCoins) + " RC";
|
|
}
|
|
|
|
static string FormatBetLimitWarningText(int limitCoins) =>
|
|
"Max Bet : " + FormatBetLimitLabel(limitCoins);
|
|
|
|
void UpdateBetLimitWarningText()
|
|
{
|
|
if (txtBetLimitWarning != null)
|
|
txtBetLimitWarning.text = FormatBetLimitWarningText(GetPersonalBetLimit());
|
|
}
|
|
|
|
void OnBetLimitSliderValueChanged(float value)
|
|
{
|
|
if (txtBetLimitSliderValue != null)
|
|
txtBetLimitSliderValue.text = FormatBetLimitLabel(Mathf.RoundToInt(value));
|
|
}
|
|
|
|
void ApplyBetLimitVisibility()
|
|
{
|
|
bool isLoser = myTeam != winningTeam;
|
|
if (txtBetLimitWarning != null)
|
|
txtBetLimitWarning.gameObject.SetActive(isLoser);
|
|
if (!isLoser)
|
|
return;
|
|
UpdateBetLimitWarningText();
|
|
}
|
|
|
|
public void OpenBetLimitAdjuster()
|
|
{
|
|
if (betLimitAdjustPanel == null)
|
|
return;
|
|
|
|
int limit = GetPersonalBetLimit();
|
|
if (betLimitSlider != null)
|
|
betLimitSlider.SetValueWithoutNotify(limit);
|
|
OnBetLimitSliderValueChanged(limit);
|
|
|
|
betLimitAdjustPanel.DOFade(1, 0.25f);
|
|
betLimitAdjustPanel.blocksRaycasts = true;
|
|
betLimitAdjustPanel.interactable = true;
|
|
}
|
|
|
|
public void CloseBetLimitAdjuster()
|
|
{
|
|
if (betLimitAdjustPanel == null)
|
|
return;
|
|
|
|
betLimitAdjustPanel.DOFade(0, 0.25f);
|
|
betLimitAdjustPanel.blocksRaycasts = false;
|
|
betLimitAdjustPanel.interactable = false;
|
|
}
|
|
|
|
void OnBetLimitAdjustAccepted()
|
|
{
|
|
if (betLimitSlider != null)
|
|
SetPersonalBetLimit(Mathf.RoundToInt(betLimitSlider.value));
|
|
UpdateBetLimitWarningText();
|
|
CloseBetLimitAdjuster();
|
|
}
|
|
|
|
void OnBetAccepted(){
|
|
NetPlayer.localPlayer.AcceptRematch((int)betSlider.value);
|
|
rematchPanel.interactable=false;
|
|
}
|
|
|
|
void OnBetCancelled(){
|
|
NetPlayer.localPlayer.AcceptRematch(0);
|
|
rematchPanel.interactable=false;
|
|
rematchPanel.blocksRaycasts=false;
|
|
rematchPanel.DOFade(0,0.3f).SetEase(Ease.InOutBack);
|
|
}
|
|
|
|
void OnBetSliderValueChanged(float value){
|
|
txtSelectedBet.text = CoinHelper.FormatString((int)value);
|
|
}
|
|
|
|
void OnBtnRematchClicked(){
|
|
if (!BothPlayersHaveMinimumRematchRc())
|
|
return;
|
|
if (txtBetLimitWarning != null)
|
|
txtBetLimitWarning.gameObject.SetActive(false);
|
|
NetPlayer.localPlayer.RequestRematch();
|
|
SetRematchPendingState(true);
|
|
}
|
|
|
|
public void OnRematchRequested(int opponentMaxBetLimitCoins){
|
|
rematchOpponentBetLimitCoins = opponentMaxBetLimitCoins;
|
|
if(winningTeam == myTeam){
|
|
//Only the loser can initiate the rematch; winner sets the stake
|
|
ShowRematchPanel();
|
|
}else{
|
|
rematchWarningLoser.text = "Waiting for opponent to accept";
|
|
}
|
|
}
|
|
|
|
void SetRematchPendingState(bool val){
|
|
btnRematch.interactable = false;
|
|
btnLeave.interactable = !val;
|
|
if(val){
|
|
StopCoroutine(countdownCoroutine);
|
|
countdownTxt.text = "";
|
|
}else{
|
|
countdownCoroutine = StartCoroutine(CoroutineCountdown());
|
|
}
|
|
}
|
|
|
|
|
|
void OnBtnLeaveGameClicked(){
|
|
LevelLoadManager.instance.Leave();
|
|
}
|
|
|
|
void CollectOriginalPositionsAndScales(){
|
|
OriginalPositions = new Dictionary<RectTransform, Vector3>();
|
|
OriginalScales = new Dictionary<RectTransform, Vector3>();
|
|
foreach (var item in comingFromMiddle)
|
|
{
|
|
OriginalPositions.Add(item, item.position);
|
|
OriginalScales.Add(item, item.localScale);
|
|
}
|
|
foreach (var item in middleScalingItems)
|
|
{
|
|
if(!OriginalPositions.ContainsKey(item)){
|
|
OriginalPositions.Add(item, item.position);
|
|
}
|
|
if(!OriginalScales.ContainsKey(item)){
|
|
OriginalScales.Add(item, item.localScale);
|
|
}
|
|
}
|
|
|
|
foreach (var item in comingDown)
|
|
{
|
|
if(!OriginalPositions.ContainsKey(item)){
|
|
OriginalPositions.Add(item, item.position);
|
|
}
|
|
if(!OriginalScales.ContainsKey(item)){
|
|
OriginalScales.Add(item, item.localScale);
|
|
}
|
|
}
|
|
|
|
foreach (var item in prizeFrames)
|
|
{
|
|
if(!OriginalPositions.ContainsKey(item)){
|
|
OriginalPositions.Add(item, item.position);
|
|
}
|
|
if(!OriginalScales.ContainsKey(item)){
|
|
OriginalScales.Add(item, item.localScale);
|
|
}
|
|
}
|
|
}
|
|
void Hide(){
|
|
canvasGroup.alpha = 0;
|
|
canvasGroup.blocksRaycasts = false;
|
|
canvasGroup.interactable = false;
|
|
|
|
rematchPanel.alpha=0;
|
|
rematchPanel.blocksRaycasts = false;
|
|
rematchPanel.interactable = false;
|
|
|
|
if (betLimitAdjustPanel != null)
|
|
{
|
|
betLimitAdjustPanel.alpha = 0;
|
|
betLimitAdjustPanel.blocksRaycasts = false;
|
|
betLimitAdjustPanel.interactable = false;
|
|
}
|
|
}
|
|
|
|
Team winningTeam;
|
|
Team myTeam;
|
|
public void Setup(Team winningTeam, Team myTeam, int redScore, int blueScore){
|
|
this.winningTeam = winningTeam;
|
|
this.myTeam = myTeam;
|
|
p1_winner.gameObject.SetActive(false);
|
|
p2_winner.gameObject.SetActive(false);
|
|
if(myTeam == Team.Red){
|
|
p1_red.SetActive(true);
|
|
p1_blue.SetActive(false);
|
|
p2_red.SetActive(false);
|
|
p2_blue.SetActive(true);
|
|
|
|
p1_icon.sprite = redIcon;
|
|
p2_icon.sprite = blueIcon;
|
|
}else{
|
|
p1_red.SetActive(false);
|
|
p1_blue.SetActive(true);
|
|
p2_red.SetActive(true);
|
|
p2_blue.SetActive(false);
|
|
|
|
p1_icon.sprite = blueIcon;
|
|
p2_icon.sprite = redIcon;
|
|
}
|
|
|
|
p1_name.text = LevelLoadManager.myPlayer.Name;
|
|
p2_name.text = LevelLoadManager.opponentPlayer.Name;
|
|
p1_l10.text = $"L10 {LevelLoadManager.myPlayer.l10_wins}-{LevelLoadManager.myPlayer.l10_losses}";
|
|
p2_l10.text = $"L10 {LevelLoadManager.opponentPlayer.l10_wins}-{LevelLoadManager.opponentPlayer.l10_losses}";
|
|
|
|
if(myTeam == winningTeam){
|
|
p1_winner.gameObject.SetActive(true);
|
|
p2_winner.gameObject.SetActive(false);
|
|
}else{
|
|
p1_winner.gameObject.SetActive(false);
|
|
p2_winner.gameObject.SetActive(true);
|
|
}
|
|
|
|
ApplyBetLimitVisibility();
|
|
}
|
|
|
|
float rcPrize = 0;
|
|
public void Show(Team winningTeam, Team myTeam, int redScore, int blueScore){
|
|
Setup(winningTeam, myTeam, redScore, blueScore);
|
|
|
|
canvasGroup.blocksRaycasts = true;
|
|
canvasGroup.interactable = true;
|
|
|
|
foreach (var item in middleScalingItems)
|
|
{
|
|
item.localScale = new Vector3(0, item.localScale.y, item.localScale.z);
|
|
}
|
|
foreach (var item in comingFromMiddle)
|
|
{
|
|
item.position = new Vector3(Screen.width/2f,OriginalPositions[item].y);
|
|
item.localScale = new Vector3(0, OriginalScales[item].y, OriginalScales[item].z);
|
|
}
|
|
foreach (var item in comingDown)
|
|
{
|
|
item.position = new Vector3(OriginalPositions[item].x, 0.3f);
|
|
item.localScale = new Vector3(OriginalScales[item].x, 0, OriginalScales[item].z);
|
|
}
|
|
|
|
foreach (var item in prizeFrames)
|
|
{
|
|
item.localScale = new Vector3(0, 0, 0);
|
|
}
|
|
|
|
if (GameTutorialManager.tutorialModeEnabled)
|
|
rcPrize = 0;
|
|
else if (winningTeam == myTeam)
|
|
rcPrize = CoinHelper.Format(GameManager.MatchRcPrizeCoins);
|
|
|
|
if (btnRematch != null)
|
|
btnRematch.gameObject.SetActive(!GameTutorialManager.tutorialModeEnabled);
|
|
|
|
UpdateRematchAvailability();
|
|
ApplyRcBalancesToUi(null);
|
|
|
|
StartCoroutine(CoroutineShow());
|
|
|
|
StartCoroutine(CoroutineFetchAndUpdateBalances());
|
|
}
|
|
|
|
IEnumerator CoroutineShow(){
|
|
float fadeInTime = 0.5f;
|
|
float scaleTime = 0.2f;
|
|
float moveTime = 0.3f;
|
|
canvasGroup.DOFade(1, fadeInTime).SetEase(Ease.InOutBack);
|
|
yield return new WaitForSeconds(fadeInTime);
|
|
|
|
foreach (var item in middleScalingItems)
|
|
{
|
|
item.DOScale(OriginalScales[item], scaleTime).SetEase(Ease.InOutBack);
|
|
}
|
|
|
|
yield return new WaitForSeconds(scaleTime * 0.5f);
|
|
foreach (var item in comingFromMiddle)
|
|
{
|
|
item.DOMove(OriginalPositions[item], moveTime).SetEase(Ease.InOutBack);
|
|
item.DOScale(OriginalScales[item], scaleTime).SetEase(Ease.InOutBack);
|
|
}
|
|
|
|
yield return new WaitForSeconds(scaleTime * 0.5f);
|
|
|
|
foreach (var item in prizeFrames)
|
|
{
|
|
item.DOScale(Vector3.one, scaleTime).SetEase(Ease.InOutBack);
|
|
}
|
|
|
|
yield return new WaitForSeconds(scaleTime * 0.5f);
|
|
|
|
//Rewards
|
|
float ccReward = GameTutorialManager.tutorialModeEnabled ? 0f : 100f;
|
|
StartCoroutine(CoroutineSetTextNumber(rcPrize, txtRewardRC, 10, "N1", "+", " RC"));
|
|
StartCoroutine(CoroutineSetTextNumber(ccReward, txtRewardCC, 100, "N0", "+", " CC"));
|
|
|
|
txtBetRC.text = GameTutorialManager.tutorialModeEnabled
|
|
? "0 RC"
|
|
: CoinHelper.FormatString(GameManager.MatchRcPrizeCoins) + " RC";
|
|
|
|
yield return new WaitForSeconds(1f);
|
|
|
|
foreach (var item in comingDown)
|
|
{
|
|
item.DOMove(OriginalPositions[item], 0.3f).SetEase(Ease.InOutBack);
|
|
item.DOScale(OriginalScales[item], 0.3f).SetEase(Ease.InOutBack);
|
|
}
|
|
|
|
|
|
|
|
countdownCoroutine = StartCoroutine(CoroutineCountdown());
|
|
}
|
|
Coroutine countdownCoroutine;
|
|
|
|
IEnumerator CoroutineSetTextNumber(float number, TMP_Text text, float speed = 100f, string formatting = "N0", string prefix = "", string suffix = ""){
|
|
float t=0;
|
|
while(t < number){
|
|
t+=Time.deltaTime*speed;
|
|
text.text = prefix + t.ToString(formatting) + suffix;
|
|
yield return null;
|
|
}
|
|
text.text = prefix + number.ToString(formatting) + suffix;
|
|
}
|
|
|
|
|
|
IEnumerator CoroutineCountdown(){
|
|
TextColorFlash textColorFlash = countdownTxt.GetComponent<TextColorFlash>();
|
|
while(returnToMenuCountdown > 0){
|
|
returnToMenuCountdown--;
|
|
countdownTxt.text = returningToMenuText.Replace("{t}", returnToMenuCountdown.ToString("N0"));
|
|
if(returnToMenuCountdown < 5){
|
|
textColorFlash.duration = 5;
|
|
}
|
|
yield return new WaitForSecondsRealtime(1f);
|
|
}
|
|
|
|
|
|
LevelLoadManager.instance.Leave();
|
|
}
|
|
|
|
|
|
public void ShowRematchPanel(){
|
|
SetRematchPendingState(true);
|
|
ApplyRematchBetSliderLimits();
|
|
StartCoroutine(CoroutineShowRematchPanel());
|
|
}
|
|
|
|
IEnumerator CoroutineShowRematchPanel(){
|
|
rematchPopup.localScale = new Vector3(0, 0, 0);
|
|
rematchPanel.blocksRaycasts = true;
|
|
rematchPanel.interactable = true;
|
|
rematchPanel.DOFade(1, 0.3f).SetEase(Ease.InOutBack);
|
|
yield return new WaitForSeconds(0.1f);
|
|
|
|
rematchPopup.DOScale(1, 0.2f).SetEase(Ease.OutBack);
|
|
yield return new WaitForSeconds(0.2f);
|
|
}
|
|
|
|
|
|
public void OnRematchCancelled(){
|
|
btnRematch.interactable=false;
|
|
btnLeave.interactable=true;
|
|
|
|
rematchWarningLoser.text = "Rematch declined.";
|
|
StartCoroutine(CoroutineHideRematchPanel());
|
|
|
|
countdownCoroutine = StartCoroutine(CoroutineCountdown());
|
|
}
|
|
|
|
IEnumerator CoroutineHideRematchPanel(){
|
|
rematchPopup.DOScale(0, 0.2f).SetEase(Ease.InBack);
|
|
yield return new WaitForSeconds(0.2f);
|
|
rematchPanel.DOFade(0, 0.3f).SetEase(Ease.InOutBack);
|
|
yield return new WaitForSeconds(0.3f);
|
|
}
|
|
|
|
IEnumerator CoroutineFetchAndUpdateBalances()
|
|
{
|
|
var my = LevelLoadManager.myPlayer;
|
|
var opp = LevelLoadManager.opponentPlayer;
|
|
|
|
string baseUrl = (GameManager.DedicatedInternalApiBase ?? "").TrimEnd('/');
|
|
if (string.IsNullOrEmpty(baseUrl) || my == null || opp == null)
|
|
{
|
|
ApplyRcBalancesToUi(null);
|
|
yield break;
|
|
}
|
|
|
|
if (my.UserId > 0)
|
|
yield return FetchPlayerRcAndApply(baseUrl, my);
|
|
if (opp.UserId > 0 && opp.UserId != my.UserId)
|
|
yield return FetchPlayerRcAndApply(baseUrl, opp);
|
|
|
|
ApplyRcBalancesToUi(null);
|
|
}
|
|
|
|
void ApplyRcBalancesToUi(string loadingPlaceholder)
|
|
{
|
|
var my = LevelLoadManager.myPlayer;
|
|
var opp = LevelLoadManager.opponentPlayer;
|
|
string myText = loadingPlaceholder ?? (my != null ? CoinHelper.FormatString((int)my.rc) : "0.0 RC");
|
|
string oppText = loadingPlaceholder ?? (opp != null ? CoinHelper.FormatString((int)opp.rc) : "0.0 RC");
|
|
|
|
if (txtMyRCBalance != null)
|
|
txtMyRCBalance.text = myText;
|
|
if (txtOpponentRCBalance != null)
|
|
txtOpponentRCBalance.text = oppText;
|
|
if (txtRcBalance != null)
|
|
txtRcBalance.text = loadingPlaceholder ?? (my != null ? CoinHelper.FormatString((int)my.rc) + " RC" : "0.0 RC");
|
|
|
|
if (loadingPlaceholder == null)
|
|
{
|
|
UpdateRematchAvailability();
|
|
if (rematchPanel != null && rematchPanel.alpha > 0.01f)
|
|
ApplyRematchBetSliderLimits();
|
|
}
|
|
}
|
|
|
|
static int GetRcCoins(MatchmadePlayer player) =>
|
|
player == null ? 0 : Mathf.Max(0, Mathf.FloorToInt(player.rc));
|
|
|
|
bool BothPlayersHaveMinimumRematchRc()
|
|
{
|
|
return GetRcCoins(LevelLoadManager.myPlayer) >= MinimumRematchRcCoins
|
|
&& GetRcCoins(LevelLoadManager.opponentPlayer) >= MinimumRematchRcCoins;
|
|
}
|
|
|
|
void UpdateRematchAvailability()
|
|
{
|
|
if (GameTutorialManager.tutorialModeEnabled)
|
|
{
|
|
btnRematch.interactable = false;
|
|
if (rematchWarningLoser != null)
|
|
rematchWarningLoser.text = "";
|
|
return;
|
|
}
|
|
|
|
if (winningTeam == myTeam)
|
|
{
|
|
btnRematch.interactable = false;
|
|
if (rematchWarningLoser != null)
|
|
rematchWarningLoser.text = "Only the loser can request a rematch";
|
|
return;
|
|
}
|
|
|
|
if (!BothPlayersHaveMinimumRematchRc())
|
|
{
|
|
btnRematch.interactable = false;
|
|
if (rematchWarningLoser != null)
|
|
rematchWarningLoser.text = "Not enough RC";
|
|
return;
|
|
}
|
|
|
|
btnRematch.interactable = true;
|
|
if (rematchWarningLoser != null)
|
|
rematchWarningLoser.text = "";
|
|
}
|
|
|
|
IEnumerator FetchPlayerRcAndApply(string baseUrl, MatchmadePlayer player)
|
|
{
|
|
string url = $"{baseUrl}/players/{player.UserId}/rc";
|
|
using (var req = UnityWebRequest.Get(url))
|
|
{
|
|
yield return req.SendWebRequest();
|
|
|
|
if (req.responseCode != 200)
|
|
{
|
|
Logger.Log($"Player RC fetch HTTP {(int)req.responseCode}: {req.error} {url}");
|
|
yield break;
|
|
}
|
|
|
|
string text = req.downloadHandler != null ? req.downloadHandler.text : "";
|
|
if (string.IsNullOrEmpty(text))
|
|
yield break;
|
|
|
|
var resp = JsonUtility.FromJson<PlayerRcApiResponse>(text);
|
|
if (resp != null && resp.ok)
|
|
player.rc = resp.rc;
|
|
else if (resp != null && !string.IsNullOrEmpty(resp.error))
|
|
Logger.Log($"Player RC fetch: {resp.error} ({url})");
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
class PlayerRcApiResponse
|
|
{
|
|
public bool ok;
|
|
public int player_id;
|
|
public float rc;
|
|
public string error;
|
|
}
|
|
}
|