mergemilitary/Assets/MMOModule/Scripts/MMOModule.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using MMO;

public partial class MMOModule : MonoBehaviour
{
    public event Action OnEnter;
    public event Action OnExit;

    public event Action OnDataOverride;
    public event Action<int> OnDiamondUpdate;

    //inner sdk
    public event Action<string, Action<bool>> OnShowRV;
    public event Action<string> OnShowIV;
    public event Action<string, string, string> OnLogEvent;
    public event Func<string, string> OnGetConfig;
    public event Action<string> OnShare;
    public event Action OnOpenMoreGames;

    private Action mDelCheckOver;

    public bool IsGuideFinished => MMOUserData.Instance.IsGuideFinished;

    public bool IsAccessible => MMOConstConfig.Instance.IsEnabled && (MMOUserData.Instance.IsMMOUser || MMOUserData.Instance.HasBeenInvited);
    public bool IsInvitable => MMOConstConfig.Instance.IsEnabled && !IsAccessible && MMOInnerSDKManager.Instance.GetConfigBool(MMOConstConfig.Instance.InvitableParam);

    private static MMOModule mInstance = null;
    public static MMOModule Instance
    {
        get
        {
            if (mInstance == null)
            {
                GameObject tMMOGO = Instantiate(Resources.Load(nameof(MMOModule))) as GameObject;
                mInstance = tMMOGO.AddComponent<MMOModule>();
                tMMOGO.SetActive(true);
                DontDestroyOnLoad(tMMOGO);
            }

            return mInstance;
        }
    }

    private MMOUIManager mUIMgr;
    public MMOUIManager UIMgr
    {
        get
        {
            if (mUIMgr == null)
            {
                mUIMgr = GetComponentInChildren<MMOUIManager>(true);
            }

            return mUIMgr;
        }
    }

    private bool mIsOn = false;

    private void OnApplicationFocus(bool pFocus)
    {
        if (pFocus)
        {
            if (MMOConstConfig.Instance.IsEnabled)
            {
                if (Application.internetReachability == NetworkReachability.NotReachable)
                {
                    UIMgr.OpenUI<MMOUINoConnection>();
                }
                else
                {
                    UIMgr.CloseUI<MMOUINoConnection>();

#if !UNITY_EDITOR
                RequestInitData(UIMgr.GetUI<MMOUILoading>().NotifyInitOver);
#endif
                }
            }
            else if (MMOConstConfig.Instance.KeepLoading)
            {
                UIMgr.GetUI<MMOUILoading>().NotifyInitOver();
            }
        }
    }

    private void RequestInitData(Action pDelSyncDone = null)
    {
        if (MMOConstConfig.Instance.IsEnabled)
        {
            MMOAPIRequestManager.Instance.SendRequest<MMORequestLogin, MMORespondLogin>(new MMORequestLogin(), (pRespond) =>
            {
                MMOAPIRequestManager.Instance.SetData(pRespond);
                MMODataSyncManager.Instance.SyncUserData();

                pDelSyncDone?.Invoke();

                MMOAPIRequestManager.Instance.SendRequest<MMORequestInviteProgress, MMORespondInviteProgress>(new MMORequestInviteProgress(pRespond.MyInviteCode), (pRp) =>
                {
                    MMOAPIRequestManager.Instance.SetData(pRp);
                });
            });
        }
    }

    public void EnableMMO(bool pEnable, bool pKeepLoading = false)
    {
        MMOConstConfig.Instance.IsEnabled = pEnable;
        MMOConstConfig.Instance.KeepLoading = pEnable ? true : pKeepLoading;
    }

    public void Init(Action pDelInitOver)
    {
        if (!MMOConstConfig.Instance.IsEnabled)
        {
            if (MMOConstConfig.Instance.KeepLoading)
            {
                MMOUILoading tLoading = UIMgr.OpenUI<MMOUILoading>();
                tLoading.DelInitOver = pDelInitOver;
                return;
            }

            pDelInitOver?.Invoke();
            return;
        }
        
        //Inner SDK Delegate
        MMOInnerSDKManager.Instance.DelShowRV = ShowRV;
        MMOInnerSDKManager.Instance.DelShowIV = ShowIV;
        MMOInnerSDKManager.Instance.DelLogEvent = LogEvent;
        MMOInnerSDKManager.Instance.DelGetConfig = GetConfig;
        MMOInnerSDKManager.Instance.DelShare = Share;
        MMOInnerSDKManager.Instance.DelOpenMoreGames = OpenMoreGames;

        //data
        MMODataSyncManager.Instance.DelDataOverride = DataOverride;
        MMOUserData.Instance.DelUpdateDiamond = UpdateDiamond;
        MMOUserData.Instance.DelUpdateLevel = UpdateLevel;

        MMOUserData.Instance.CheckTask();

        MMOUILoading tUILoading = UIMgr.OpenUI<MMOUILoading>();
        tUILoading.DelInitOver = pDelInitOver;
        tUILoading.DelLoadOver = OnLoadOver;

        RequestInitData();
    }

    public void StartGame(Action pDelCheckOver, bool pIsMMOUser, int pDiamond, int pLevel)
    {
        if (!MMOConstConfig.Instance.IsEnabled)
        {
            if (MMOConstConfig.Instance.KeepLoading)
            {
                MMOUILoading tLoading = UIMgr.GetUI<MMOUILoading>();
                if (tLoading.IsOpened)
                {
                    tLoading.DelLoadOver = pDelCheckOver;
                    tLoading.FinishRest();
                }
                else
                {
                    pDelCheckOver?.Invoke();
                }
                MMOUserData.Instance.FinishLoading();
                return;
            }

            pDelCheckOver?.Invoke();
            return;
        }

        mDelCheckOver = pDelCheckOver;

        MMOUserData.Instance.IsMMOUser = pIsMMOUser;
        MMOUserData.Instance.Diamond = pDiamond;
        MMOUserData.Instance.GameLevel = pLevel;

        if (UIMgr.GetUI<MMOUILoading>().IsOpened)
        {
            UIMgr.GetUI<MMOUILoading>().FinishRest();
        }
        else
        {
            CheckGuide();
        }
    }

    public void LogMMOUser(bool pIsMMO)
    {
        MMOInnerSDKManager.Instance.LogEvent("Robux_" + pIsMMO);
    }

    private void OnLoadOver()
    {
        MMOUserData.Instance.FinishLoading();

        CheckGuide();
    }

    private void CheckGuide()
    {
        if (MMOConstConfig.Instance.IsEnabled && MMOUserData.Instance.IsMMOUser && !MMOUserData.Instance.IsGuideFinished)
        {
            if (!MMOUserData.Instance.HasFirstSubmitted)
            {
                ShowFirstFill();
            }
            else
            {
                ShowGuide();
            }
        }
        else
        {
            MMOInnerSDKManager.Instance.LogUserType(MMOEventValue.Organic);
            mDelCheckOver?.Invoke();
        }
    }

    private void ShowFirstFill()
    {
        SetIsOn(true);
        MMOUIFirstFill tUI = UIMgr.OpenUI<MMOUIFirstFill>();
        tUI.DelSubmit = ShowGuide;
        tUI.DelClose = Exit;
    }

    private void ShowGuide()
    {
        SetIsOn(true);
        UIMgr.OpenUI<MMOUIGuide>().DelClose = OnGuideOver;
    }

    private void OnGuideOver()
    {
        mDelCheckOver?.Invoke();
        Exit();
    }

    private void SetIsOn(bool pIsOn)
    {
        mIsOn = pIsOn;
        if (pIsOn)
        {
            OnEnter?.Invoke();
        }
        else
        {
            OnExit?.Invoke();
        }
    }

    public void Enter(int pDiamond, int pGameLevel, int pPartIndex = 0)//0 task,1 skin
    {
        MMOUserData.Instance.Diamond = pDiamond;
        MMOUserData.Instance.GameLevel = pGameLevel;

        UIMgr.OpenUI<MMOUITop>();
        UIMgr.OpenUI<MMOUIMain>().ShowPart(pPartIndex);

        MMOInnerSDKManager.Instance.LogRobuxAction(MMOEventValue.EnterMMO);

        SetIsOn(true);
    }

    public void Exit()
    {
        UIMgr.CloseUI<MMOUITop>();

        SetIsOn(false);
    }

    public bool PopVerifyInvitation(Action pDelInvited)
    {
        if (!IsInvitable)
            return false;

        MMOUIInviteVerify tUI = UIMgr.OpenUI<MMOUIInviteVerify>();
        tUI.DelInvited = pDelInvited;
        tUI.DelClose = Exit;

        SetIsOn(true);

        return true;
    }

    public void ShowTip(string pTipString)
    {
        if (mIsOn)
        {
            UIMgr.OpenUI<MMOUITip>().SetTip(pTipString);
        }
    }

    public void PassLevel(int pCurrentLevel, Action<Vector3, int> pDelGetDiamond, Action pDelOver)
    {
        if (!IsAccessible)
        {
            pDelOver?.Invoke();
            return;
        }

        for (int i = 0; i < MMOUserData.Instance.TaskRecordList.Count; i++)
        {
            MMOTaskRecord tRecord = MMOUserData.Instance.TaskRecordList[i];
            if (tRecord.TaskType == MMOTaskType.DailyLevel && !MMOUserData.Instance.HasFinishedTaskToday(tRecord.TaskType))
            {
                int tValue = MMOUserData.Instance.GetTaskValue(tRecord.RecordKey);
                MMOUserData.Instance.SetTaskValue(tRecord.RecordKey, tValue + 1);
            }
        }

        MMOAPIRequestManager.Instance.SendRequest<MMORequestSetLevel, string>(new MMORequestSetLevel(pCurrentLevel));

        //check bonus level
        List<int> tBonusPopLevels = new List<int>();

        string tBonusLevelStr = MMOInnerSDKManager.Instance.GetConfigString(MMOConstConfig.Instance.BonusLevelParam);
        if (!string.IsNullOrEmpty(tBonusLevelStr))
        {
            tBonusPopLevels.Clear();
            string[] tLevelStrs = tBonusLevelStr.Split(',');
            int tLevel = 0;
            for (int i = 0; i < tLevelStrs.Length; i++)
            {
                if (int.TryParse(tLevelStrs[i], out tLevel))
                {
                    tBonusPopLevels.Add(tLevel);
                }
            }
        }

        //check skin piece
        bool tIsSkinPieceLevel = (pCurrentLevel <= 30 && pCurrentLevel % 3 == 0) || (pCurrentLevel > 30 && pCurrentLevel <= 60 && pCurrentLevel % 5 == 0) || (pCurrentLevel > 60 && pCurrentLevel % 10 == 0);

        if (tBonusPopLevels.Contains(pCurrentLevel))
        {
            PopBonus(pDelGetDiamond, pDelOver);
        }
        else if (tIsSkinPieceLevel)
        {
            PopSkinPiece(pDelOver);
        }
        else
        {
            pDelOver?.Invoke();
        }
    }

    private void PopBonus(Action<Vector3, int> pDelGetDiamond, Action pDelOver)
    {
        if (!IsAccessible || !MMOUserData.Instance.HasRegistered)
        {
            pDelOver?.Invoke();
            return;
        }

        MMOUIBonus tUI = UIMgr.OpenUI<MMOUIBonus>();
        tUI.DelGetDiamond = pDelGetDiamond;
        tUI.DelClose = () =>
        {
            pDelOver?.Invoke();
            Exit();
        };

        SetIsOn(true);
    }

    private void PopSkinPiece(Action pDelOver)
    {
        if (!IsAccessible || !MMOUserData.Instance.HasRegistered)
        {
            pDelOver?.Invoke();
            return;
        }

        Dictionary<int, float> tPickDic = new Dictionary<int, float>();

        MMODataSkin tData;
        int tOwnCount = 0;
        for (int i = MMOTableSkin.Instance.Count - 1; i >= 0; i--)
        {
            tData = MMOTableSkin.Instance[i];
            tOwnCount = MMOUserData.Instance.GetSkinPieceCount(tData.SkinID);
            if (tOwnCount < tData.MaxCount)
            {
                tPickDic.Add(tData.SkinID, tData.Ratio);
            }
        }
        if (tPickDic.Count == 0)
        {
            pDelOver?.Invoke();
            return;
        }

        int tPickedID = MMOUtils.RandomPick(tPickDic);
        //Debug.Log("tPicked ID :" + tPickedID);
        MMODataSkin tPickedData = MMOTableSkin.Instance.GetData(tPickedID);
        tOwnCount = MMOUserData.Instance.GetSkinPieceCount(tPickedID);
        int tAddCount = tOwnCount >= tPickedData.ReduceCount ? 2 : 10;

        MMOUserData.Instance.AddSkinPieceCount(tPickedID, tAddCount);

        MMOUISkinPiece tUI = UIMgr.OpenUI<MMOUISkinPiece>();
        tUI.ConfigSkin(tPickedData, tAddCount);
        tUI.DelClose = () =>
        {
            pDelOver?.Invoke();
            Exit();
        };

        SetIsOn(true);
    }

    public void RewardGet(bool pIsMore)
    {
        MMOInnerSDKManager.Instance.LogResultPage(pIsMore ? MMOEventValue.More_Get : MMOEventValue.Normal_Get);
    }

    public void WatchRVSuccessfully()
    {
        if (!IsAccessible)
            return;

        for (int i = 0; i < MMOUserData.Instance.TaskRecordList.Count; i++)
        {
            MMOTaskRecord tRecord = MMOUserData.Instance.TaskRecordList[i];
            if (tRecord.TaskType == MMOTaskType.WatchRV || (tRecord.TaskType == MMOTaskType.DailyAds && !MMOUserData.Instance.HasFinishedTaskToday(tRecord.TaskType)))
            {
                int tValue = MMOUserData.Instance.GetTaskValue(tRecord.RecordKey);
                MMOUserData.Instance.SetTaskValue(tRecord.RecordKey, tValue + 1);
            }
            else if (tRecord.TaskType == MMOTaskType.RiseRank)
            {
                int tValue = MMOUserData.Instance.GetTaskValue(tRecord.RecordKey);
                MMOUserData.Instance.SetTaskValue(tRecord.RecordKey, tValue + 50);
            }
        }

        UIMgr.GetUI<MMOUIMain>().RefreshTask();
    }

    public void SetTaskValue(MMOTaskType pType, int pValue)
    {
        if (!IsAccessible)
            return;

        for (int i = 0; i < MMOUserData.Instance.TaskRecordList.Count; i++)
        {
            MMOTaskRecord tRecord = MMOUserData.Instance.TaskRecordList[i];
            if (tRecord.TaskType == pType)
            {
                MMOUserData.Instance.SetTaskValue(tRecord.RecordKey, pValue);
            }
        }
    }

    public int GetRewardDiamondOfLevel(int pDiamond, int pLevel)
    {
        int tTarget = 0;
        for (int i = 0; i < MMOUserData.Instance.TaskRecordList.Count; i++)
        {
            if (MMOUserData.Instance.TaskRecordList[i].TaskType == MMOTaskType.GetDiamond)
            {
                if (!MMOUserData.Instance.TaskRecordList[i].IsFinished)
                {
                    tTarget = MMOUserData.Instance.TaskRecordList[i].TargetNum;
                }
            }
        }

        if (tTarget == 0)
        {
            return 1000;
        }

        int tFinalDiamond = 1;
        int tCurLevelDiamond = 1;
        MMODataLevelDiamond tData = MMOTableLevelDiamond.Instance.GetData(pLevel);
        if (tData != null)
        {
            tCurLevelDiamond = tData.Diamond;
        }
        int tExpectedMaxDiamond = pDiamond + (pLevel > 3 ? tCurLevelDiamond * 3 : tCurLevelDiamond);
        if (tExpectedMaxDiamond < tTarget - 200)
        {
            tFinalDiamond = tCurLevelDiamond;
        }
        else
        {
            if (pDiamond < tTarget - 200)
            {
                tFinalDiamond = Mathf.Max((tTarget - 200 - pDiamond) / 3, 10);
            }
            else if (pDiamond >= (tTarget - 200) && pDiamond < (tTarget - 100))
            {
                tFinalDiamond = 10;
            }
            else if (pDiamond >= (tTarget - 100) && pDiamond < (tTarget - 50))
            {
                tFinalDiamond = 3;
            }
        }

        //int tStuckDiamond = 200;
        //int tStuckLevel = 146;
        //int tCurLevelDiamond = 1;
        //MMODataLevelDiamond tData = MMOTableLevelDiamond.Instance.GetData(pLevel);
        //if (tData != null)
        //{
        //    tCurLevelDiamond = tData.Diamond;
        //}

        //if (pLevel > 3 && pLevel <= 50 &&(pDiamond + tCurLevelDiamond * 3) >= tTarget)
        //{
        //    tCurLevelDiamond /= 6;
        //    tStuckLevel = 50;
        //}

        //int tLeftDiamond = tTarget - (pDiamond + tCurLevelDiamond);
        //int tLeftLevel = Mathf.Max(tStuckLevel - pLevel, 1);
        //if (tLeftDiamond <= tStuckDiamond && pLevel <= tStuckLevel)
        //{
        //    tFinalDiamond = Mathf.Max(tLeftDiamond / tLeftLevel / 3, 1);
        //}
        //else
        //{
        //    tFinalDiamond = tCurLevelDiamond;
        //}

        return Mathf.Max(tFinalDiamond, 1);
    }

    private void UpdateDiamond(int pDiamond)
    {
        OnDiamondUpdate?.Invoke(pDiamond);

        UIMgr.GetUI<MMOUITop>().DiamondBar.RefreshRes(pDiamond);
        for (int i = 0; i < MMOUserData.Instance.TaskRecordList.Count; i++)
        {
            MMOTaskRecord tRecord = MMOUserData.Instance.TaskRecordList[i];
            if (tRecord.TaskType == MMOTaskType.GetDiamond)
            {
                MMOUserData.Instance.SetTaskValue(tRecord.RecordKey, pDiamond);
            }
        }
    }

    private void UpdateLevel(int pLevel)
    {
        for (int i = 0; i < MMOUserData.Instance.TaskRecordList.Count; i++)
        {
            MMOTaskRecord tRecord = MMOUserData.Instance.TaskRecordList[i];
            if (tRecord.TaskType == MMOTaskType.PassLevel)
            {
                MMOUserData.Instance.SetTaskValue(tRecord.RecordKey, pLevel);
            }
        }
    }

#region Inner SDK
    private void ShowRV(string pPos, Action<bool> pDelResult)
    {
        OnShowRV?.Invoke(pPos, pDelResult);
    }

    private void ShowIV(string pPos)
    {
        OnShowIV?.Invoke(pPos);
    }

    private void LogEvent(string pEvent, string pParam, string pValue)
    {
        OnLogEvent?.Invoke(pEvent, pParam, pValue);
    }

    private string GetConfig(string pKey)
    {
        return OnGetConfig?.Invoke(pKey);
    }

    private void Share(string pContent)
    {
        OnShare?.Invoke(pContent);
    }

    private void OpenMoreGames()
    {
        OnOpenMoreGames?.Invoke();
    }
#endregion

    private void DataOverride()
    {
        OnDataOverride?.Invoke();
    }

    public void DeleteAccount(Action<bool> pDelResult = null)
    {
        MMORespondLogin tLoginData = MMOAPIRequestManager.Instance.GetData<MMORespondLogin>();
        if (tLoginData != null)
        {
            MMOAPIRequestManager.Instance.SendRequest<MMORequestDeleteUser, string>(new MMORequestDeleteUser(tLoginData.PlayerID),(pResult) =>
            {
                pDelResult?.Invoke(true);
            },
            (pErrorCode) =>
            {
                pDelResult?.Invoke(false);
            });
            MMODataSyncManager.Instance.gameObject.SetActive(false);
        }
    }
}

public enum MMOTaskType
{
    DailyReward = -1,
    InviteUsers = -2,

    Unknown = 0,
    GetDiamond,
    PassLevel,
    WatchRV,
    DailyLevel,
    DailyAds,
    RiseRank,
    Final
}