garden_client/Assets/Script/SFS/SFSEvent/PlazaRoomEvent.cs

using UnityEngine;

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

public class PlazaRoomEvent
{
    #region Variable

    public Room CurrentPlazaRoom;
    public SFSEventManager SFSEventManager;

    public static string PlazaRoomGroupID = "Default";

    #endregion

    public PlazaRoomEvent(SFSEventManager eventManager)
    {
        SFSEventManager = eventManager;
    }


    public void GetRoomData(int startIndex)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutInt(Label.CommandID, PlazaRoomReq.GetRoomData.GetHashCode());
        parameter.PutInt(Label.Data, startIndex);
        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

    public void GetCustomRoomData(int startIndex, long serialNumber)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutInt(Label.CommandID, PlazaRoomReq.GetCustomRoomData.GetHashCode());
        parameter.PutInt(Label.Data, startIndex);
        parameter.PutLong(Label.UserID, serialNumber);
        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

    public void GetRoomFullStatus(List<int> databaseRoomIDs)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutIntArray(Label.DataArray, databaseRoomIDs.ToArray());
        parameter.PutInt(Label.CommandID, PlazaRoomReq.GetRoomFullStatus.GetHashCode());
        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

    public void CreateRoom(string roomName, long serialNumber, int duration, int maxPlayer, int value)
    {
        SFSManager.GardenSmartFox.ExecuteAfterCheckConection
        (
            () =>
            {
                SFSObject parameter = new SFSObject();
                parameter.PutUtfString(Label.RoomName, roomName);
                parameter.PutLong(Label.UserID, serialNumber);
                parameter.PutInt(gd_room.Duration, duration);
                parameter.PutInt(gd_room.MaxPlayer, maxPlayer);
                parameter.PutInt(Label.ChestValue, value);
                parameter.PutInt(Label.CommandID, PlazaRoomReq.CreateRoom.GetHashCode());
                SFSManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
            },
            (succeed, baseEvent) =>{ if (!succeed) SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.OnCreateRoomError(baseEvent); },
            (succeed, baseEvent) => { if (!succeed) SFSManager.GardenSmartFox.EventManager.PlazaRoomEvent.OnCreateRoomError(baseEvent); }
        );
    }

    public void ExitPlazaRoom()
    {
        SFSEventManager.GardenSmartFox.SmartFox.Send(new LeaveRoomRequest(CurrentPlazaRoom));

        SFSEventManager.GardenSmartFox.PlazaRoomManager.OnExitPlazaRoom();
    }

    public void JoinPlazaRoom(int databaseRoomID)
    {
        SFSManager.GardenSmartFox.ExecuteAfterCheckConection
        (
            () =>
            {
                SFSObject parameter = new SFSObject();
                parameter.PutInt(Label.CommandID, PlazaRoomReq.JoinRoom.GetHashCode());
                parameter.PutInt(Label.DatabaseRoomID, databaseRoomID);
                SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
            },
            (succeed, baseEvent) => { if(!succeed) OnJoinPlazaRoomError(baseEvent); },
            (succeed, baseEvent) => { if (!succeed) OnJoinPlazaRoomError(baseEvent); }
        );
    }


    public void SendInstantiateRequset(int senderID, int[] dressDataIDs, Vector3 position, PlayerDirection direction, string nickname,  int receiverID)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutInt(InfoLabel.SenderID.GetHashString(), senderID);
        parameter.PutIntArray(InfoLabel.Close.GetHashString(), dressDataIDs);
        parameter.PutUtfString(InfoLabel.Position.GetHashString(), position.VectorToString());
        parameter.PutInt(InfoLabel.PlayerDirection.GetHashString(), direction.GetHashCode());
        parameter.PutUtfString(InfoLabel.NickName.GetHashString(), nickname);

        SFSEventManager.GardenSmartFox.AddRequest(WrapInfoRequest(CurrentPlazaRoom.Id, receiverID, InfoID.Instantiate, parameter), RequestType.Immediate);
    }

    public void SendSynchronizeDestination(Vector3 destination)
    {
        SFSObject sfsObject = new SFSObject();
        sfsObject.PutInt(InfoLabel.SenderID.GetHashString(), SFSEventManager.GardenSmartFox.User.Id);
        sfsObject.PutUtfString(InfoLabel.Destination.GetHashString(), destination.VectorToString());

        SFSObject parameter = WrapInfoRequest(SFSEventManager.GardenSmartFox.PlazaRoomManager.CurrentPlazaRoom.Id, -1, InfoID.Synchronize, sfsObject);

        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.BatchAndOverride, RequestName.SynchronizePosition.ToString(), BatchOption.TryNot);
    }

    public void SendSynchronizeClose(List<int> closeIDs)
    {
        SFSObject sfsObject = new SFSObject();
        sfsObject.PutInt(InfoLabel.SenderID.GetHashString(), SFSEventManager.GardenSmartFox.User.Id);
        sfsObject.PutIntArray(InfoLabel.Close.GetHashString(), closeIDs.ToArray());

        SFSObject parameter = WrapInfoRequest(SFSEventManager.GardenSmartFox.PlazaRoomManager.CurrentPlazaRoom.Id, -1, InfoID.Synchronize, sfsObject);

        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.BatchAndOverride, RequestName.SynchronizeClose.ToString());
    }

    public void SendExpression(ExpressionID expressionID)
    {
        SFSObject sfsObject = new SFSObject();
        sfsObject.PutInt(InfoLabel.SenderID.GetHashString(), SFSEventManager.GardenSmartFox.User.Id);
        sfsObject.PutInt(InfoLabel.Expression.GetHashString(), expressionID.GetHashCode());

        SFSObject parameter = WrapInfoRequest(SFSEventManager.GardenSmartFox.PlazaRoomManager.CurrentPlazaRoom.Id, -1, InfoID.ReceiveExpression, sfsObject);

        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

    public void SendPublicMessage(string message)
    {
        SFSObject sfsObject = new SFSObject();
        sfsObject.PutInt(InfoLabel.SenderID.GetHashString(), SFSEventManager.GardenSmartFox.User.Id);
        sfsObject.PutUtfString(InfoLabel.Message.GetHashString(), message);

        SFSObject parameter = WrapInfoRequest(SFSEventManager.GardenSmartFox.PlazaRoomManager.CurrentPlazaRoom.Id, -1, InfoID.ReceivePublicMessage, sfsObject);

        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

    public void OnReceiveInfo(BaseEvent baseEvent)
    {
        int infoID = (baseEvent.Params["params"] as ISFSObject).GetInt(Label.InfoID);

        if (infoID == InfoID.Instantiate.GetHashCode())
        {
            OnInstantiate(baseEvent);
        }
        else if (infoID == InfoID.Synchronize.GetHashCode())
        {
            OnSynchronize(baseEvent);
        }
        else if (infoID == InfoID.ReceiveExpression.GetHashCode())
        {
            OnReceiveExpression(baseEvent);
        }
        else if (infoID == InfoID.ReceivePublicMessage.GetHashCode())
        {
            OnReceivePublicMessage(baseEvent);
        }
    }

    public void OnInstantiate(BaseEvent baseEvent)
    {
        ISFSObject parameter = (ISFSObject)baseEvent.Params["params"];

        int senderID = parameter.GetInt(InfoLabel.SenderID.GetHashString());

        SFSEventManager.GardenSmartFox.PlazaRoomManager.OnInstantiate(senderID, parameter.GetSFSObject(Label.Data));
    }

    public void OnSynchronize(BaseEvent baseEvent)
    {
        ISFSObject parameter = (ISFSObject)baseEvent.Params["params"];

        int senderID = parameter.GetInt(InfoLabel.SenderID.GetHashString());

        SFSEventManager.GardenSmartFox.PlazaRoomManager.Synchronize(senderID, parameter.GetSFSObject(Label.Data));
    }

    public void OnReceiveExpression(BaseEvent baseEvent)
    {
        ISFSObject parameter = (ISFSObject)baseEvent.Params["params"];
        int senderID = parameter.GetInt(InfoLabel.SenderID.GetHashString());

        parameter = parameter.GetSFSObject(Label.Data);
        int expressionID = parameter.GetInt(InfoLabel.Expression.GetHashString());

        SFSEventManager.GardenSmartFox.PlazaRoomManager.ReceiveExpression(expressionID, senderID);
    }

    public void OnReceivePublicMessage(BaseEvent baseEvent)
    {
        ISFSObject parameter = (ISFSObject)baseEvent.Params["params"];
        int senderID = parameter.GetInt(InfoLabel.SenderID.GetHashString());
        parameter = parameter.GetSFSObject(Label.Data);
        string message = parameter.GetUtfString(InfoLabel.Message.GetHashString());

        SFSEventManager.GardenSmartFox.PlazaRoomManager.ReceivePublicMessage(message, senderID);
    }


    public void CreateChest(int round, int value, ChestType type, int databaseRoomID, long serialNumber, Vector3 position)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutInt(Label.CommandID, PlazaRoomReq.CreateChest.GetHashCode());
        parameter.PutInt(gd_chest.Round, round);
        parameter.PutInt(gd_chest.Value, value);
        parameter.PutInt(gd_chest.Type, type.GetHashCode());
        parameter.PutInt(Label.DatabaseRoomID, databaseRoomID);
        parameter.PutLong(Label.UserID, serialNumber);
        parameter.PutUtfString(gd_chest.Position, position.VectorToString(2));
        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

    public void OnCreateChestError(BaseEvent baseEvent)
    {
        ChestMge.OnCreateChestError();
    }

    public void OnCreateChestSucceed(BaseEvent baseEvent)
    {
        ChestMge.OnCreateChestSucceed();
    }

    public void OnReceiveNewChest(BaseEvent baseEvent)
    {
        ISFSObject parameter = (ISFSObject)baseEvent.Params["params"];
        ChestData chestData = new ChestData(parameter.GetSFSObject(Label.Data));
        ChestMge.OnReceiveNewChest(chestData);
    }


    public void GetChestExpireStatus(List<long> chestIDs)
    {
        SFSManager.GardenSmartFox.ExecuteAfterCheckConection
        (
            () =>
            {
                SFSObject parameter = new SFSObject();
                parameter.PutInt(Label.CommandID, PlazaRoomReq.GetChestExpireStatus.GetHashCode());
                parameter.PutLongArray(Label.DataArray, chestIDs.ToArray());
                SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
            }
        );
    }

    public void OnReceiveChestExpireStatus(BaseEvent baseEvent)
    {
        ISFSObject obj = baseEvent.Params["params"] as ISFSObject;
        long[] chestIDs = obj.GetLongArray(Label.DataArray);
        ChestMge.OnReceiveChestExpireStatus(chestIDs.ToList());
    }


    public void GetChestAward(long chestID)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutInt(Label.CommandID, PlazaRoomReq.GetChestAward.GetHashCode());
        parameter.PutLong(gd_chest.ID, chestID);
        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

    public void GetAllChestData(int databaseRoomID)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutInt(Label.CommandID, PlazaRoomReq.GetAllChestData.GetHashCode());
        parameter.PutInt(Label.DatabaseRoomID, databaseRoomID);
        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

    public void CheckChestRefund(List<int> databaseRoomIDs)
    {
        SFSManager.GardenSmartFox.ExecuteAfterCheckConection
        (
            () =>
            {
                SFSObject parameter = new SFSObject();
                parameter.PutInt(Label.CommandID, PlazaRoomReq.CheckChestRefund.GetHashCode());
                parameter.PutLong(Label.UserID, long.Parse(ManaServer.SerialNumber));
                parameter.PutIntArray(Label.DataArray, databaseRoomIDs.ToArray());
                SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
            }
        );
    }

    public void OnReceiveChestAward(BaseEvent baseEvent)
    {
        ISFSObject arg = baseEvent.Params["params"] as ISFSObject;
        int award = arg.GetInt(Label.Data);
        long chestID = arg.GetLong(Label.ChestID);
        ChestMge.ReceiveChestAward(award, chestID);
    }

    public void OnReceiveAllChestData(BaseEvent baseEvent)
    {
        ISFSArray array = (baseEvent.Params["params"] as ISFSObject).GetSFSArray(Label.DataArray);
        List<ChestData> chestDatas = new List<ChestData>();
        for (int i = 0; i < array.Size(); i++)
        {
            chestDatas.Add(new ChestData(array.GetSFSObject(i)));
        }
        ChestMge.ReceiveAllChestData(chestDatas);
    }

    public void OnReceiveChestRefund(BaseEvent baseEvent)
    {
        ISFSObject arg = baseEvent.Params["params"] as ISFSObject;
        int refund = arg.GetInt(Label.Data);
        List<int> databaseRoomIDs = arg.GetIntArray(Label.DataArray).ToList();

        ChestMge.ReceiveChestRefund(refund, databaseRoomIDs);
    }


    public void CheckDefaultChestStatus(int databaseRoomID)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutInt(Label.CommandID, PlazaRoomReq.CheckDefaultChest.GetHashCode());
        parameter.PutInt(Label.DatabaseRoomID, databaseRoomID);
        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

    public void OnActivateDefaultChest(BaseEvent baseEvent)
    {
        ISFSObject arg = baseEvent.Params["params"]as ISFSObject;
        DateTime dateTime = DateUtil.GetTimeFromSecends(arg.GetLong(Label.Data).ToString());
        //Debug.Log(dateTime);
        ChestMge.ActivateSystemChest(dateTime);
    }

    public void OnReactivateDefaultChest(BaseEvent baseEvent)
    {
        ISFSObject arg = baseEvent.Params["params"]as ISFSObject;
        DateTime dateTime = DateUtil.GetTimeFromSecends(arg.GetLong(Label.Data).ToString());
        //Debug.Log(dateTime);
        ChestMge.ReactivateSystemChest(dateTime);
    }

    public void OnDeactivateDefaultChest(BaseEvent baseEvent)
    {
        ISFSObject arg = baseEvent.Params["params"] as ISFSObject;
        long pasttime = arg.GetLong(Label.Data);
        //Debug.LogWarning(pasttime);
        ChestMge.DeactivateSystemChest(pasttime);
    }

    public void OnReceiveRoomData(BaseEvent baseEvent)
    {
        ISFSArray array = (baseEvent.Params["params"] as ISFSObject).GetSFSArray(Label.DataArray);

        //for (int i = 0; i < array.Size(); i++)
        //{
        //    Debug.LogWarning(array.GetSFSObject(i).GetDump());
        //}

        PlazaRoomMge.OnReceiveRoomData(array);
    }

    public void OnReceiveCustomRoomData(BaseEvent baseEvent)
    {
        ISFSArray array = (baseEvent.Params["params"] as ISFSObject).GetSFSArray(Label.DataArray);

        //for (int i = 0; i < array.Size(); i++)
        //{
        //    Debug.LogWarning(array.GetSFSObject(i).GetDump());
        //}

        PlazaRoomMge.OnReceiveCustomRoomData(array);
    }

    public void OnReceiveRoomFullStatus(BaseEvent baseEvent)
    {
        ISFSObject obj = baseEvent.Params["params"] as ISFSObject;
        int[] idArray = obj.GetIntArray(Label.Data);
        bool[] statusArray = obj.GetBoolArray(Label.DataArray);

        PlazaRoomMge.OnReceiveRoomFullStatus(idArray.ToList(), statusArray.ToList());
    }

    public void OnCreateRoomError(BaseEvent baseEvent)
    {
        PlazaRoomMge.OnCreateRoomError();
    }

    public void OnCreateRoomSucceed(BaseEvent baseEvent)
    {
        RoomData roomData = new RoomData((baseEvent.Params["params"] as ISFSObject));
        PlazaRoomMge.OnCreateRoomSucceed(roomData);
    }


    public void OnJoinPlazaRoomSucceed(BaseEvent baseEvent)
    {
        int roomID = (baseEvent.Params["params"] as ISFSObject).GetInt(Label.RoomID);
        Room room = new SFSRoom(roomID, Random.Range(1f,100f).ToString());           

        CurrentPlazaRoom = room;

        SFSEventManager.GardenSmartFox.PlazaRoomManager.OnJoinPlazaRoom(room);
    }

    public void OnJoinPlazaRoomError(BaseEvent baseEvent)
    {
        int errorID = (baseEvent.Params["params"] as ISFSObject).GetInt(Label.Error);
        JoinRoomResult joinRoomRequest = (JoinRoomResult) errorID;
        SFSEventManager.GardenSmartFox.PlazaRoomManager.OnJoinPlazaRoomError(joinRoomRequest);
    }

    public void OnLeaveRoom(BaseEvent baseEvent)
    {
        SFSEventManager.GardenSmartFox.PlazaRoomManager.OnConectionLost(baseEvent);
    }

    public void OnOtherExitRoom(BaseEvent baseEvent)
    {
        ISFSObject arg = (ISFSObject)baseEvent.Params["params"];
        int userID = arg.GetInt(Label.UserID);

        if (userID != SFSManager.GardenSmartFox.User.Id)
        {
            //Debug.LogWarning($"User : {userID} left room");

            SFSEventManager.GardenSmartFox.PlazaRoomManager.OnUserExitPlazaRoom(userID);
        }
    }

    public void OnOtherEnterRoom(BaseEvent baseEvent)
    {
        ISFSObject arg = (ISFSObject) baseEvent.Params["params"];
        int userID = arg.GetInt(Label.UserID);

        if (userID != SFSManager.GardenSmartFox.User.Id)
        {
            //Debug.LogWarning($"User : {userID} joined room");

            SFSEventManager.GardenSmartFox.PlazaRoomManager.OnUserEnterPlazaRoom(userID);
        }
    }


    public static SFSObject WrapInfoRequest(int roomID, int targetUserID, InfoID infoID, SFSObject parameter)
    {
        SFSObject obj = new SFSObject();

        obj.PutInt(Label.CommandID, PlazaRoomReq.SendInfo.GetHashCode());
        obj.PutInt(Label.RoomID, roomID);
        obj.PutInt(Label.TargetUserID, targetUserID);
        obj.PutInt(Label.InfoID, infoID.GetHashCode());
        obj.PutInt(InfoLabel.SenderID.GetHashString(), SFSManager.GardenSmartFox.User.Id);
        obj.PutSFSObject(Label.Data, parameter);

        return obj;
    }
}