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 GetRoomStatus(List<int> databaseRoomIDs)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutIntArray(Label.DataArray, databaseRoomIDs.ToArray());
        parameter.PutInt(Label.CommandID, PlazaRoomReq.GetRoomStatus.GetHashCode());
        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

    public void CreateRoom(string roomName, long serialNumber, int duration, int maxPlayer, int cost)
    {
        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.RoomCost, cost);
                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 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 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)
    {
        int award = (baseEvent.Params["params"] as ISFSObject).GetInt(Label.Data);
        ChestMge.ReceiveChestAward(award);
    }

    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 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 OnReceiveRoomStatus(BaseEvent baseEvent)
    {
        ISFSObject obj = baseEvent.Params["params"] as ISFSObject;
        int[] idArray = obj.GetIntArray(Label.Data);
        bool[] statusArray = obj.GetBoolArray(Label.DataArray);

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

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

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


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