garden_client/Assets/Script/SFS/Manager/PlazaRoomManager.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;

public class PlazaRoomManager 
{
    public class PlazaRoomPlayer
    {
        #region Config

        public string NickName;

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

        #endregion

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


            NickNameTransform = ManaReso.Get("NickName", Folder.UI, false, ManaReso.Get("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("UI", "未命名") : nickname;
            NickNameTransform.GetComponent<Text>().text = NickName;


            MessageBox = ManaReso.Get("MessageBox", Folder.UI, false, ManaReso.Get("W_HudParent"), false, ObjType.MessageBox);

            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();
            }

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

            Player.PlayAnim(Player.IdleAnimationName);
        }

        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 duration = Mathf.Clamp(Vector3.Magnitude(destination - Player.transform.position) / 1.5f, 0.25f, 10f) / 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(string message)
        {
            if (MessgeCoroutine != null)
            {
                Auxiliary.Instance.StopCoroutine(MessgeCoroutine);
            }

            MessageBox.GetChild(0).GetComponent<Text>().text = message;
            MessageBox.TweenForCG();

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

    #region Variable

    public GardenSmartFox GardenSmartFox;

    public User SelfUser;
    public PlazaRoomPlayer SelfInstance;
    public Room CurrentPlazaRoom;

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

    public bool EnteringPlazaRoom;
    public bool IsBlackMaskFinish;
    public RequestStatus JoinRoomStatus = RequestStatus.Pending;

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

    #endregion

    public void OnEnterPlazaRoomButton()
    {
        IsBlackMaskFinish = false;
        EnteringPlazaRoom = true;

        ManaCenter.SceneSwitchLock = true;

        TweenRoot tweenRoot = ManaReso.Get("V_BlackMask").TweenBacCG();

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

        GardenSmartFox.ExecuteAfterCheckConection
            (
                () =>
                {
                    GardenSmartFox.PlazaRoomManager.JoinRoomStatus = RequestStatus.Pending;
                    GardenSmartFox.ExtensionManager.PlazaRoomExtension.JoinPlazaRoom();
                },
                (succeed, baseEvent) =>
                {
                    if (!succeed)
                    {
                        GardenSmartFox.PlazaRoomManager.JoinRoomStatus = RequestStatus.Failed;
                        TryEnterPlazaRoom();
                    }
                },
                (succeed, baseEvent) =>
                {
                    if (!succeed)
                    {
                        GardenSmartFox.PlazaRoomManager.JoinRoomStatus = RequestStatus.Failed;
                        TryEnterPlazaRoom();
                    }
                }
            );
    }

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

        if (!GardenSmartFox.PlazaRoomManager.EnteringPlazaRoom)
        {
            return;
        }

        if (GardenSmartFox.PlazaRoomManager.JoinRoomStatus == RequestStatus.Pending)
        {
            return;
        }

        if (GardenSmartFox.PlazaRoomManager.JoinRoomStatus == RequestStatus.Failed)
        {
            QuitPlazaRoom();

            Bubble.Show(null, Language.GetStr("UI", "加入房间失败"), null, null, () => { ManaReso.Get("V_BlackMask").TweenForCG();},null,false);

            EnteringPlazaRoom = false;
        }
        else if (GardenSmartFox.PlazaRoomManager.JoinRoomStatus == RequestStatus.Succeed)
        {
            EnterPlazaRoom();

            EnteringPlazaRoom = false;
        }
    }

    public void EnterPlazaRoom()
    {
        GardenSmartFox.PlazaRoomManager.CameraLeftBorder = ManaReso.Get("PlazaRoomCameraLeftBorder").position.x;
        GardenSmartFox.PlazaRoomManager.CameraRightBorder = ManaReso.Get("PlazaRoomCameraRightBorder").position.x;

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

        ManaReso.Get("V_BlackMask").TweenForCG();

        ManaReso.SetActive("C_Main2", false);
        ManaReso.SetActive("Garden", false);
        ManaReso.SetActive("PlazaRoom", true);
        ManaReso.SetActive("W_HudParent", true);
        ManaReso.SetActive("X_PlazaRoom", true);
    }

    public void ExitPlazaRoom()
    {
        QuitPlazaRoom();

        TweenRoot tweenRoot = ManaReso.Get("V_BlackMask").TweenBacCG();

        tweenRoot.AddEventOnetime
            (
                EventType.BackwardFinish,
                () =>
                {
                    PlazaRoomSky.position = SkyOriginPosition;
                    PlazaRoomCamera.transform.position = CameraOriginPosition;

                    ManaReso.SetActive("C_Main2", true);
                    ManaReso.SetActive("Garden", true);
                    ManaReso.SetActive("PlazaRoom", false);
                    ManaReso.SetActive("W_HudParent", false);
                    ManaReso.SetActive("X_PlazaRoom", false);

                    ManaReso.Get("V_BlackMask").TweenForCG();

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

                    UserInstanceDictionary = new Dictionary<User, PlazaRoomPlayer>();
                }
            );
    }

    public void QuitPlazaRoom()
    {
        ManaCenter.SceneSwitchLock = false;

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

        GardenSmartFox.PlazaRoomManager.CurrentPlazaRoom = null;
    }


    public PlazaRoomManager(GardenSmartFox gardenSmartFox)
    {
        GardenSmartFox = gardenSmartFox;

        GardenSmartFox.ExtensionManager.PlazaRoomExtension.onExitPlazaRoom += OnExitPlazaRoom;
        GardenSmartFox.ExtensionManager.PlazaRoomExtension.onJoinPlazaRoom += OnJoinPlazaRoom;
        GardenSmartFox.ExtensionManager.PlazaRoomExtension.onUserExitCurrentPlazaRoom += OnUserExitPlazaRoom;
        GardenSmartFox.ExtensionManager.PlazaRoomExtension.onUserEnterCurrentPlazaRoom += OnUserEnterPlazaRoom;
        GardenSmartFox.ExtensionManager.PlazaRoomExtension.onSynchronize += Synchronize;
        GardenSmartFox.ExtensionManager.PlazaRoomExtension.onReceiveExpression += ReceiveExpression;
        GardenSmartFox.ExtensionManager.PlazaRoomExtension.onReceivePublicMessage += ReceivePublicMessage;
        GardenSmartFox.ExtensionManager.PlazaRoomExtension.onInstantiate += Instantiate;

        gardenSmartFox.Connector.onConnectionLost += OnConectionLost;
    }

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

        if (EnteringPlazaRoom)
            return;

        KeepAliveThread();

        CameraControllThread();
    }

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

        if (KeepAliveTimer > KeepAliveTime)
        {
            KeepAliveTimer = 0;

            GardenSmartFox.AddRequest(GardenSmartFox.ConstructCommandParameter(CommandID.KeepAlive.GetHashCode(), new SFSObject(), 0), RequestType.Immediate);
        }
    }

    public float CameraLeftBorder;
    public float CameraRightBorder;
    public Vector3 CameraOriginPosition;
    public Camera PlazaRoomCamera;
    public void CameraControllThread()
    {
        if (PlazaRoomCamera == null)
        {
            return;
        }

        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);
    }


    public void MoveTo(Vector3 destination)
    {
        GardenSmartFoxManager.GardenSmartFox.PlazaRoomManager.SelfInstance.MoveTo(destination);

        GardenSmartFoxManager.GardenSmartFox.PlazaRoomManager.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 (InPlazaRoom)
        {
            OnExitPlazaRoom();
        }
    }


    public void OnExitPlazaRoom()
    {
        ExitPlazaRoom();
    }

    private Vector3 PlayerDefaultPosition;
    public void OnJoinPlazaRoom(Room room)
    {
        PlazaRoom.Initialize();

        GardenSmartFox.PlazaRoomManager.PlazaRoomSky = ManaReso.Get("PlazaRoomSky");
        SkyOriginPosition = GardenSmartFox.PlazaRoomManager.PlazaRoomSky.position;

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

        GardenSmartFox.PlazaRoomManager.CurrentPlazaRoom = room;

        SelfUser = GardenSmartFox.User;
        PlayerDefaultPosition = ManaReso.Get("PlazaRoomDefaultPosition").position;
        SelfInstance = InstantiatePlayer(SelfUser, ManaNickName.NickName, PlayerDefaultPosition, PlayerDirection.Left, ManaData.GetDressDataIDs(ManaPlayer.Player));
        SelfInstance.Player.transform.position += new Vector3(0, 0, -0.001f);

        UserInstanceDictionary.Add(SelfUser, SelfInstance);

        JoinRoomStatus = RequestStatus.Succeed;
        TryEnterPlazaRoom();

        SendInstantiateRequset(-1);
    }

    public void OnUserExitPlazaRoom(User user)
    {
        UserInstanceDictionary[user].Save();

        UserInstanceDictionary.Remove(user);
    }

    public void OnUserEnterPlazaRoom(User user)
    {
        SendInstantiateRequset(user);
    }


    public void Synchronize(User sender, SFSObject parameter)
    {
        if (!UserInstanceDictionary.ContainsKey(sender))
            return;

        if (sender.IsItMe)
            return;

        if (parameter.ContainsKey(DataID.Destination.GetHashString()))
        {
            Vector3 destination = parameter.GetUtfString(DataID.Destination.GetHashString()).StringToVector();

            SynchronizeDestination(destination, sender);
        }

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

            SynchronizeClose(closeIDs, sender);
        }

        //Debug.LogWarning(sender.IsItMe + " : " + jsonData.ToJson());
    }

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

        foreach (var closeID in closeIDs)
        {
            CloseUnit closeUnit = ManaPlayer.CloseUnitDic[closeID];

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

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

    public void ReceiveExpression(int expressionID, User sender)
    {
        PlazaRoomPlayer plazaRoomPlayer = UserInstanceDictionary[sender];

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

        ManaInfoBox.Show(InfoCategory.PlazaRoom, $"{plazaRoomPlayer.NickName} : <({expressionName})>", 10, ManaReso.LoadSprite("Expression", Folder.Scene));
    }

    public void ReceivePublicMessage(string message, User sender)
    {
        PlazaRoomPlayer plazaRoomPlayer = UserInstanceDictionary[sender];

        plazaRoomPlayer.ShowMessage(message);

        ManaInfoBox.Show(InfoCategory.PlazaRoom, $"{plazaRoomPlayer.NickName} : {message}", 10, ManaReso.LoadSprite("Expression", Folder.Scene));
    }

    public void Instantiate(User user, SFSObject parameter)
    {
        if (user.IsItMe)
            return;

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


    public void SendExpression(ExpressionID expressionID)
    {
        GardenSmartFoxManager.GardenSmartFox.ExtensionManager.PlazaRoomExtension.SendExpression(expressionID);
    }

    //private string LastPublicMessage;
    public bool SendPublicMessage(string message)
    {
        if (string.IsNullOrEmpty(message))
        {
            Bubble.Show(null, Language.GetStr("UI", "内容不能为空"));

            return false;
        }
        //else if (LastPublicMessage == message)
        //{
        //    Bubble.Show(null, Language.GetStr("UI", "请勿重复发送"));

        //    return false;
        //}
        else
        {
            //LastPublicMessage = message;

            message = StringFilter.GetFilteredString(message);

            GardenSmartFoxManager.GardenSmartFox.ExtensionManager.PlazaRoomExtension.SendPublicMessage(message);

            //ManaInfoBox.Show(InfoCategory.PlazaRoom, $"{SelfUser.Name} : {message}", 10, ManaReso.LoadSprite("Expression", Folder.Scene));

            return true;
        }
    }


    public void SendInstantiateRequset(User receiver)
    {
        SendInstantiateRequset(receiver.Id);
    }

    public void SendInstantiateRequset(int receiverID)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutInt(DataID.SenderID.GetHashString(), GardenSmartFox.User.Id);
        parameter.PutIntArray(DataID.Close.GetHashString(), ManaData.GetDressDataIDs(SelfInstance.Player).ToArray());
        parameter.PutUtfString(DataID.Position.GetHashString(), SelfInstance.Player.transform.position.VectorToString());
        parameter.PutInt(DataID.PlayerDirection.GetHashString(), SelfInstance.Player.PlayerDirection.GetHashCode());
        parameter.PutUtfString(DataID.NickName.GetHashString(), ManaNickName.NickName);

        GardenSmartFox.AddRequest(GardenSmartFox.ConstructCommandParameter(CommandID.Instantiate.GetHashCode(), parameter, receiverID), RequestType.Immediate);

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


    public void SendSynchronizeDestination(Vector3 destination)
    {
        GardenSmartFoxManager.GardenSmartFox.ExtensionManager.PlazaRoomExtension.SendSynchronizeDestination(destination);
    }

    public PlazaRoomPlayer InstantiatePlayer(User user, string nickName, Vector3 position, PlayerDirection direction, List<int> dressDataIDs)
    {
        Transform tra = ManaReso.Get("Player", Folder.Scene, false, ManaReso.Get("PlazaRoom"), false, ObjType.Player);

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

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

            player.Build();
        }

        foreach (var id in dressDataIDs)
        {
            CloseUnit closeUnit = ManaPlayer.CloseUnitDic[id];

            closeUnit.ChangeDress(player);
        }

        player.SetAllCollider(false);
        player.transform.position = position;
        player.Flip(direction);

        tra.localScale = new Vector3(0.525f, 0.525f, 0.525f);

        return new PlazaRoomPlayer(player, nickName);
    }

    public PlazaRoomPlayer InstantiatePlayer(User user, SFSObject parameter)
    {
        List<int> dressDatas = ManaData.GetDressDataIDs(parameter);
        Vector3 position = parameter.GetUtfString(DataID.Position.GetHashString()).StringToVector();
        PlayerDirection direction = (PlayerDirection) parameter.GetInt(DataID.PlayerDirection.GetHashString());
        string nickName = parameter.GetUtfString(DataID.NickName.GetHashString());

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

        return plazaRoomPlayer;
    }
}