garden_client/Assets/Script/SFS/Manager/PlazaRoomController.cs

using System;
using UnityEngine;

using System.Collections.Generic;
using System.Linq;
using LitJson;
using Sfs2X.Core;
using Sfs2X.Entities;
using Sfs2X.Entities.Data;
using Sfs2X.Requests;
using Sfs2X.Entities.Variables;
using UnityEngine.UI;
using Random = UnityEngine.Random;

public enum JoinRoomResult
{
    RoomFullError = 0,
    RoomExpireError = 1,
    Unknown = 2,
    Succeed = 3,
    Pending = 4,
}

public class PlazaRoomController
{
    private static int MinMessageFontSize = 12;
    private static int MaxMessageFontSize = 20;
    private static Vector3 PlazaRoomPlayerScale = new Vector3(0.525f, 0.525f, 0.525f);
    public class PlazaRoomPlayer
    {
        #region Config

        public string NickName;

        public Player Player;
        public Transform NickNameTransform;
        public List<TweenRoot> TweenRoots;

        public BestfitText MessageLab;
        public Transform MessageBox;

        #endregion

        public PlazaRoomPlayer(Player player, string nickname)
        {
            Player = player;
            TweenRoots = new List<TweenRoot>();


            NickNameTransform = ResourceManager.Get(ResourceLabel.NickName, Folder.UI, false, ResourceManager.Get(ObjectLabel.W_HudParent), false, ObjType.NickName);

            HudTarget hudTarget = NickNameTransform.GetComponent<HudTarget>();

            if (hudTarget == null)
            {
                hudTarget = NickNameTransform.AddComponent<HudTarget>();
            }

            hudTarget.PosTra = Player.ChildDic["NickName"];
            hudTarget.SetPosition();

            NickName = string.IsNullOrEmpty(nickname) ? Language.GetStr(LanguageLabel.UI__Unnamed) : nickname;
            NickNameTransform.GetComponent<Text>().text = NickName;


            MessageBox = ResourceManager.Get(ResourceLabel.MessageBox, Folder.UI, false, ResourceManager.Get(ObjectLabel.W_HudParent), false, ObjType.MessageBox);
            MessageLab = MessageBox.GetComponentInChildren<BestfitText>();
            MessageLab.VerticalMinSize = MinMessageFontSize;
            MessageLab.VerticalMaxSize = MaxMessageFontSize;

            hudTarget = MessageBox.GetComponent<HudTarget>();

            if (hudTarget == null)
            {
                hudTarget = MessageBox.AddComponent<HudTarget>();
            }

            hudTarget.PosTra = Player.ChildDic["MessageBox"];

            MessageBox.CreateTweenCG(0, 1, 0.25f, true, true, Curve.EaseOutQuad).InOrigin = true;
        }

        public void Save()
        {
            foreach (var tweenRoot in TweenRoots)
            {
                tweenRoot.Pause();
            }

            ResourceManager.Save(Player);
            ResourceManager.Save(NickNameTransform);
            ResourceManager.Save(MessageBox);

            Player.PlayAnim(Player.IdleAnimationName);
            Player.DeactiveShadow();
            Player.Shadow.SetLZ(0);
            Player.ExpressionMeshFilter.transform.parent = Player.transform;
        }

        public bool IsMoving;
        public float Speed = 1f;
        public Vector3 Destination;
        public TweenVec MoveTween;
        public void MoveTo(Vector3 destination)
        {
            if (destination.Equal(Player.transform.position))
            {
                return;
            }

            if (destination.x > Player.transform.position.x)
            {
                Player.Flip(PlayerDirection.Right);
            }
            else
            {
                Player.Flip(PlayerDirection.Left);
            }

            float offsetX = Mathf.Abs(destination.x - Player.transform.position.x);
            float offsetY = Mathf.Abs(destination.y - Player.transform.position.y);
            float offset = Mathf.Sqrt(offsetX*offsetX + offsetY*offsetY);
            float duration = Mathf.Clamp(offset/1.5f, 0.25f, 100f)/Speed;
           
            MoveTween = Player.transform.CreateTweenVec3D(destination, duration, false, true, true, Curve.EaseOutQuad);

            MoveTween.StartForward();
            MoveTween.AddEventOnetime(EventType.ForwardFinish, StopMove);
            TweenRoots.Add(MoveTween);

            IsMoving = true;
            Destination = destination;

            Player.PlayAnim(Player.WalkAnimationName);
        }

        public void StopMove()
        {
            IsMoving = false;

            Player.PlayAnim(Player.IdleAnimationName);
        }

        public float MessgeTime = 3f;
        public Coroutine MessgeCoroutine;
        public void ShowMessage(Color color, string message)
        {
            if (MessgeCoroutine != null)
            {
                Auxiliary.Instance.StopCoroutine(MessgeCoroutine);
            }

            MessageLab.text = message;
            MessageLab.color = color;

            MessageBox.TweenForCG();

            MessgeCoroutine = Auxiliary.Instance.DelayCall(() => { MessageBox.TweenBacCG(); }, MessgeTime);
        }
    }

    #region Config

    public GardenSmartFox GardenSmartFox;

    public PlazaRoomPlayer SelfInstance;
    public Room CurrentPlazaRoom;
    public RoomData CurrentRoomData;

    public bool JoinedPlazaRoom
    {
        get { return CurrentPlazaRoom != null; }
    }
    public bool InPlazaRoom;

    public bool IsBlackMaskFinish;
    public JoinRoomResult JoinRoomResult = JoinRoomResult.Pending;

    public Dictionary<int, PlazaRoomPlayer> UserInstanceDictionary = new Dictionary<int, PlazaRoomPlayer>();

    #endregion

    private Coroutine JoinRoomCoroutine;
    public void BeginEnterPlazaRoom(RoomData roomData)
    {
        CurrentRoomData = roomData;

        IsBlackMaskFinish = false;
        JoinRoomResult = JoinRoomResult.Pending;

        AudioManager.MusicTheme.TweenBacAudio();

        ResourceManager.Get(ObjectLabel.B_SignIn0).TweenBacCG();
        ResourceManager.Get(ObjectLabel.T_NickName).TweenBacCG();

        Manager.SceneSwitchLock = true;

        TweenRoot tweenRoot = ResourceManager.Get(ObjectLabel.V_BlackMask).TweenBacCG();

        tweenRoot.AddEventOnetime
        (
            EventType.BackwardFinish, () =>
            {
                IsBlackMaskFinish = true;
                TryEnterPlazaRoom();
            }
        );

        GardenSmartFox.ExecuteAfterCheckConection
        (
            null,
            (succeed, baseEvent) =>
            {
                if (!succeed)
                {
                    JoinRoomResult = JoinRoomResult.Unknown;
                    TryEnterPlazaRoom();
                }
            },
            (succeed, baseEvent) =>
            {
                if (!succeed)
                {
                    JoinRoomResult = JoinRoomResult.Unknown;
                    TryEnterPlazaRoom();
                }
            }
        );

        JoinRoomCoroutine = DelayCall.Call(5f, () => { OnJoinPlazaRoomError(JoinRoomResult.Unknown); });
    }

    public void TryEnterPlazaRoom()
    {
        if (!GardenSmartFox.PlazaRoomController.IsBlackMaskFinish)
            return;

        if (JoinRoomResult == JoinRoomResult.Pending)
            return;

        if (JoinRoomResult == JoinRoomResult.Succeed)
        {
            EnterPlazaRoom();
        }
        else
        {
            QuitPlazaRoom();

            if (JoinRoomResult == JoinRoomResult.RoomFullError)
            {
                Bubble.Show(null, Language.GetStr(LanguageLabel.UI__Z_RoomFull), null, null, () => { ResourceManager.Get(ObjectLabel.V_BlackMask).TweenForCG(); AudioManager.MusicTheme.TweenForAudio(); }, null, false);
            }
            else if (JoinRoomResult == JoinRoomResult.RoomExpireError)
            {
                Bubble.Show(null, Language.GetStr(LanguageLabel.UI__Z_RoomExpire), null, null, () => { ResourceManager.Get(ObjectLabel.V_BlackMask).TweenForCG(); AudioManager.MusicTheme.TweenForAudio(); }, null, false);
            }
            else
            {
                Bubble.Show(null, Language.GetStr(LanguageLabel.UI__Z_Unknown), null, null, () => { ResourceManager.Get(ObjectLabel.V_BlackMask).TweenForCG(); AudioManager.MusicTheme.TweenForAudio(); }, null, false);
            }
        }
    }

    private Vector3 PlayerDefaultPosition;
    public void EnterPlazaRoom()
    {
        GardenSmartFox.EventManager.PlazaRoomEvent.GetAllChestData(CurrentRoomData.ID);
        foreach (var kv in UserInstanceDictionary)
        {
            if (kv.Value.Player.transform.parent == null)
            {
                kv.Value.Player.transform.parent = ResourceManager.Get("PlazaRoom");
                kv.Value.Player.transform.localScale = PlazaRoomPlayerScale;
            }
        }

        AudioManager.MusicPartyTheme.TweenForAudio();

        InPlazaRoom = true;
        PlazaRoomManager.ClosePanel();

        GardenManager.RetrieveAllElf();
        IAPManager.RetrieveADChest();

        GardenSmartFox.PlazaRoomController.PlazaRoomSky = ResourceManager.Get("PlazaRoomSky");
        SkyOriginPosition = GardenSmartFox.PlazaRoomController.PlazaRoomSky.position;

        GardenSmartFox.PlazaRoomController.PlazaRoomCamera = ResourceManager.Get<Camera>("MainCamera");
        GardenSmartFox.PlazaRoomController.CameraOriginPosition = GardenSmartFox.PlazaRoomController.PlazaRoomCamera.transform.position;

        GardenSmartFox.PlazaRoomController.CameraLeftBorder = ResourceManager.Get("PlazaRoomCameraLeftBorder").position.x;
        GardenSmartFox.PlazaRoomController.CameraRightBorder = ResourceManager.Get("PlazaRoomCameraRightBorder").position.x;

        GardenSmartFox.PlazaRoomController.PlazaRoomCamera.transform.SetX(GardenSmartFox.PlazaRoomController.CameraLeftBorder);

        ResourceManager.Get(ObjectLabel.V_BlackMask).TweenForCG();

        ResourceManager.SetActive(ObjectLabel.C_Main2, false);
        ResourceManager.SetActive(ResourceLabel.Garden, false);
        ResourceManager.SetActive("PlazaRoom", true);
        ResourceManager.SetActive(ObjectLabel.W_HudParent, true);
        ResourceManager.SetActive(ObjectLabel.X_PlazaRoom, true);
    }

    public void ExitPlazaRoom()
    {
        QuitPlazaRoom();

        TweenRoot tweenRoot = ResourceManager.Get(ObjectLabel.V_BlackMask).TweenBacCG();

        tweenRoot.AddEventOnetime
        (
            EventType.BackwardFinish,
            () =>
            {
                ChestManager.RetrieveAllChest();

                InPlazaRoom = false;

                AudioManager.MusicTheme.TweenForAudio();

                PlazaRoomSky.position = SkyOriginPosition;
                PlazaRoomCamera.transform.position = CameraOriginPosition;

                ResourceManager.SetActive(ObjectLabel.C_Main2, true);
                ResourceManager.SetActive(ResourceLabel.Garden, true);
                ResourceManager.SetActive("PlazaRoom", false);
                ResourceManager.SetActive(ObjectLabel.W_HudParent, false);
                ResourceManager.SetActive(ObjectLabel.X_PlazaRoom, false);

                ResourceManager.Get(ObjectLabel.V_BlackMask).TweenForCG();
                ResourceManager.Get(ObjectLabel.B_SignIn0).TweenForCG();
                ResourceManager.Get(ObjectLabel.T_NickName).TweenForCG();

                ResourceManager.Get<Text>(ObjectLabel.X_CurrentInfoLab).text = "";
                Transform tra = ResourceManager.Get(ObjectLabel.X_Info);
                while (tra.childCount > 0)
                {
                    ResourceManager.Save(tra.GetChild(0));
                }

                foreach (var kv in UserInstanceDictionary)
                {
                    kv.Value.Save();
                }

                UserInstanceDictionary = new Dictionary<int, PlazaRoomPlayer>();

                RobotManager.DeactivateAllRobots(true);
            }
        );

        tweenRoot.AddEventOnetime
        (
            EventType.ForwardFinish,
            () =>
            {
                PlazaRoomManager.OpenPanel();
            }
        );
    }

    public void QuitPlazaRoom()
    {
        PlazaRoomChest.SystemChest = null;

        Manager.SceneSwitchLock = false;

        GardenSmartFox.SmartFox.Send(new LeaveRoomRequest(CurrentPlazaRoom));

        GardenSmartFox.PlazaRoomController.CurrentPlazaRoom = null;
    }


    public PlazaRoomController(GardenSmartFox gardenSmartFox)
    {
        GardenSmartFox = gardenSmartFox;

        gardenSmartFox.Connector.onConnectionLost += OnConectionLost;
    }

    public void Update()
    {
        if (!JoinedPlazaRoom)
            return;

        if (!InPlazaRoom)
            return;

        //KeepAliveThread();
        //CheckDefautChestThread();
        CameraControllThread();
    }

    public float KeepAliveTime = 30;
    public float KeepAliveTimer;
    public void KeepAliveThread()
    {
        KeepAliveTimer += Time.deltaTime;

        if (KeepAliveTimer > KeepAliveTime)
        {
            KeepAliveTimer = 0;

            SFSObject parameter = new SFSObject();
            parameter.PutInt(SFSLabel.CommandID, PlazaRoomReq.KeepAlive.GetHashCode());
            GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
        }
    }

    public float CameraLeftBorder;
    public float CameraRightBorder;
    public Vector3 CameraOriginPosition;
    public Camera PlazaRoomCamera;
    public void CameraControllThread()
    {
        float x;

        if (SelfInstance.Player.transform.position.x <= CameraLeftBorder)
        {
            x = Mathf.Lerp(PlazaRoomCamera.transform.position.x, CameraLeftBorder, Time.deltaTime);

            if (SkyTween != null)
                SkyTween.Pause();
        }
        else if (SelfInstance.Player.transform.position.x >= CameraRightBorder)
        {
            x = Mathf.Lerp(PlazaRoomCamera.transform.position.x, CameraRightBorder, Time.deltaTime);

            if (SkyTween != null)
                SkyTween.Pause();
        }
        else
        {
            x = Mathf.Lerp(PlazaRoomCamera.transform.position.x, SelfInstance.Player.transform.position.x, Time.deltaTime);
        }

        PlazaRoomCamera.transform.SetX(x);
    }


    private float CheckTime = 10;
    private float CheckTimer;
    public void CheckDefautChestThread()
    {
        CheckTimer += Time.deltaTime;
        if (CheckTimer >= CheckTime)
        {
            CheckTimer = 0;
            GardenSmartFox.EventManager.PlazaRoomEvent.CheckDefaultChestStatus(CurrentRoomData.ID);
        }
    }


    public void MoveTo(Vector3 destination)
    {
        SFSManager.GardenSmartFox.PlazaRoomController.SelfInstance.MoveTo(destination);

        SFSManager.GardenSmartFox.PlazaRoomController.SendSynchronizeDestination(destination);

        MoveSky(SelfInstance.MoveTween.Duration, SelfInstance.MoveTween.Delta);
    }

    private float SkyMoveRatio = 0.1f;
    private Vector3 SkyOriginPosition;
    private TweenRoot SkyTween;
    public Transform PlazaRoomSky;
    private void MoveSky(float duration, Vector3 offset)
    {
        offset *= -SkyMoveRatio;
        offset.y = 0;
        offset.z = 0;

        SkyTween = PlazaRoomSky.transform.CreateTweenVecOffset2D(offset, duration, false, true, true, Curve.Linear);

        SkyTween.StartForward();
    }


    public void OnConectionLost(BaseEvent baseEvent)
    {
        if (JoinedPlazaRoom)
        {
            OnExitPlazaRoom();
        }
    }


    public void OnExitPlazaRoom()
    {
        AudioManager.MusicPartyTheme.TweenBacAudio();
        ExitPlazaRoom();
    }

    private float SelfInstanceOffset = 0.001f;
    public void OnJoinPlazaRoom(Room room)
    {
        if (JoinRoomResult == JoinRoomResult.Pending)
        {
            GardenSmartFox.PlazaRoomController.CurrentPlazaRoom = room;

            PlazaRoom.Initialize();
            PlayerDefaultPosition = GetDefaultPosition();
            SelfInstance = InstantiatePlayer(NickNameManager.NickName, PlayerDefaultPosition, PlayerDirection.Left, ConfigManager.GetDressDataIDs(PlayerManager.Player));
            UserInstanceDictionary.Add(SFSManager.GardenSmartFox.User.Id, SelfInstance);
            SendInstantiateRequset(-1);
            SelfInstance.Player.transform.SetLZ(SelfInstance.Player.transform.localPosition.z - SelfInstanceOffset);

            JoinRoomResult = JoinRoomResult.Succeed;
            TryEnterPlazaRoom();

            DelayCall.stopCoroutine(JoinRoomCoroutine);
        }
    }

    public void OnJoinPlazaRoomError(JoinRoomResult joinRoomResult)
    {
        if (JoinRoomResult == JoinRoomResult.Pending)
        {
            JoinRoomResult = joinRoomResult;
            TryEnterPlazaRoom();

            DelayCall.stopCoroutine(JoinRoomCoroutine);
        }
    }

    public void OnUserExitPlazaRoom(int userID)
    {
        UserInstanceDictionary[userID].Save();

        UserInstanceDictionary.Remove(userID);
    }

    public void OnUserEnterPlazaRoom(int senderID)
    {
        SendInstantiateRequset(senderID);
    }


    public void Synchronize(int senderID, ISFSObject parameter)
    {
        if (!UserInstanceDictionary.ContainsKey(senderID))
            return;

        if (SFSManager.GardenSmartFox.User.Id == senderID)
            return;

        if (parameter.ContainsKey(InfoLabel.Destination.GetHashString()))
        {
            Vector3 destination = parameter.GetUtfString(InfoLabel.Destination.GetHashString()).ToVector();

            SynchronizeDestination(destination, senderID);
        }

        if (parameter.ContainsKey(InfoLabel.Close.GetHashString()))
        {
            List<int> closeIDs = parameter.GetIntArray(InfoLabel.Destination.GetHashString()).ToList();

            SynchronizeClose(closeIDs, senderID);
        }
    }

    public void SynchronizeClose(List<int> closeIDs, int senderID)
    {
        Player player = UserInstanceDictionary[senderID].Player;

        foreach (var closeID in closeIDs)
        {
            CloseItem closeItem = PlayerManager.CloseItemDic[closeID];

            player.ChangeClose(closeItem.BodyPart, closeItem.ArmatureName);
        }
    }

    public void SynchronizeDestination(Vector3 destination, int senderID)
    {
        UserInstanceDictionary[senderID].MoveTo(destination);
    }

    private float ExpressionDuration = 1;
    public void ReceiveExpression(int expressionID, int senderID)
    {
        PlazaRoomPlayer plazaRoomPlayer = UserInstanceDictionary[senderID];

        string expressionName = Enum.GetName(typeof(ExpressionID), expressionID);
        plazaRoomPlayer.Player.ChangeExpression(expressionName, ExpressionDuration);

        string senderName = senderID == SFSManager.GardenSmartFox.User.Id ? Language.GetStr(LanguageLabel.UI__X_Self) : plazaRoomPlayer.NickName;
        string message = $"{senderName}:\u3000<({expressionName}按钮)>";
        Color textColor = senderID == SFSManager.GardenSmartFox.User.Id ? Lib.SelfMessage : Lib.OtherMessage;
        InfoBoxManager.PlazaRoomInfoBox.Show(message, Mathf.Infinity, textColor, ResourceManager.LoadSprite(ResourceLabel.Expression, Folder.Scene));
        Text text = ResourceManager.Get<Text>(ObjectLabel.X_CurrentInfoLab);
        text.color = textColor;
        text.text = message;
    }

    public void ReceivePublicMessage(string message, int senderID)
    {
        Color textColor = senderID == SFSManager.GardenSmartFox.User.Id ? Lib.SelfMessage : Lib.OtherMessage;

        PlazaRoomPlayer plazaRoomPlayer = UserInstanceDictionary[senderID];
        plazaRoomPlayer.ShowMessage(textColor, message);

        string senderName = senderID == SFSManager.GardenSmartFox.User.Id ? Language.GetStr(LanguageLabel.UI__X_Self) : plazaRoomPlayer.NickName;

        message = $"{senderName}:\u3000{message}";
        InfoBoxManager.PlazaRoomInfoBox.Show(message, Mathf.Infinity, textColor, ResourceManager.LoadSprite(ResourceLabel.Expression, Folder.Scene));

        ResourceManager.SetText(ObjectLabel.X_CurrentInfoLab, message);
        Text text = ResourceManager.Get<Text>(ObjectLabel.X_CurrentInfoLab);
        text.color = textColor;
        text.text = message;
    }

    public void OnInstantiate(int senderID, ISFSObject parameter)
    {
        if (SFSManager.GardenSmartFox.User.Id == senderID)
            return;

        UserInstanceDictionary.Add(senderID, InstantiatePlayer(parameter));
    }


    public void SendExpression(ExpressionID expressionID)
    {
        SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.SendExpression(expressionID);
    }

    public bool SendPublicMessage(string message)
    {
        if (string.IsNullOrEmpty(message))
        {
            Bubble.Show(null, Language.GetStr(LanguageLabel.UI__CannotEmpty));

            return false;
        }
        else
        {
            message = StringFilter.GetFilteredString(message);

            SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.SendPublicMessage(message);

            return true;
        }
    }

    public void SendInstantiateRequset(int receiverID)
    {
        SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.SendInstantiateRequset(GardenSmartFox.User.Id, ConfigManager.GetDressDataIDs(SelfInstance.Player).ToArray(), SelfInstance.Player.transform.position, SelfInstance.Player.PlayerDirection, NickNameManager.NickName, receiverID);

        if (SelfInstance.IsMoving)
        {
            SendSynchronizeDestination(SelfInstance.Destination);
        }
    }

    public void SendSynchronizeDestination(Vector3 destination)
    {
        SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.SendSynchronizeDestination(GardenSmartFox.User.Id, destination);
    }


    private float ShaowLocalZ = 3;
    public PlazaRoomPlayer InstantiatePlayer(string nickName, Vector3 position, PlayerDirection direction, List<int> dressDataIDs)
    {
        Transform parent = ResourceManager.Get("PlazaRoom", false);
        Transform tra = ResourceManager.Get("Player", Folder.Scene, false, parent, false, ObjType.Player);

        Player player = tra.GetComponent<Player>();

        if (player == null)
        {
            player = tra.AddScript<Player>();

            player.Build();
        }

        foreach (var id in dressDataIDs)
        {
            CloseItem closeItem = PlayerManager.CloseItemDic[id];

            closeItem.ChangeDress(player);
        }

        player.SetAllCollider(false);
        player.transform.position = position;
        player.Flip(direction);
        player.ActiveShadow();
        player.Shadow.SetLZ(ShaowLocalZ);

        tra.localScale = PlazaRoomPlayerScale;

        return new PlazaRoomPlayer(player, nickName);
    }

    public PlazaRoomPlayer InstantiatePlayer(ISFSObject parameter)
    {
        List<int> dressDatas = ConfigManager.GetDressDataIDs(parameter);
        Vector3 position = parameter.GetUtfString(InfoLabel.Position.GetHashString()).ToVector();
        PlayerDirection direction = (PlayerDirection) parameter.GetInt(InfoLabel.PlayerDirection.GetHashString());
        string nickName = parameter.GetUtfString(InfoLabel.NickName.GetHashString());

        PlazaRoomPlayer plazaRoomPlayer = InstantiatePlayer(nickName, position, direction, dressDatas);

        return plazaRoomPlayer;
    }


    private static float MinZOffset = 0.0001f;
    private static float MaxZOffset = 0.001f;
    public static PlayerDirection DefaultDirection = PlayerDirection.Left;
    public static Vector3 GetDefaultPosition()
    {
        float zOffset = Random.Range(MinZOffset, MaxZOffset);
        Vector3 position = ResourceManager.Get("PlazaRoomDefaultPosition").position;
        position.z += zOffset;
        return position;
    }
}