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

using UnityEngine;

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

public class PlazaRoomEvent
{
    #region Config

    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(SFSLabel.CommandID, PlazaRoomReq.GetRoomData.GetHashCode());
        parameter.PutInt(SFSLabel.Data, startIndex);
        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

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

    public void GetRoomFullStatus(List<int> databaseRoomIDs)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutIntArray(SFSLabel.DataArray, databaseRoomIDs.ToArray());
        parameter.PutInt(SFSLabel.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(SFSLabel.RoomName, roomName);
                parameter.PutLong(SFSLabel.UserID, serialNumber);
                parameter.PutInt(gd_room.Duration, duration);
                parameter.PutInt(gd_room.MaxPlayer, maxPlayer);
                parameter.PutInt(SFSLabel.ChestValue, value);
                parameter.PutInt(SFSLabel.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 JoinPlazaRoom(int databaseRoomID)
    {
        SFSManager.GardenSmartFox.ExecuteAfterCheckConection
        (
            () =>
            {
                SFSObject parameter = new SFSObject();
                parameter.PutInt(SFSLabel.CommandID, PlazaRoomReq.JoinRoom.GetHashCode());
                parameter.PutInt(SFSLabel.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, string serialNumber, DateTime joinedTime, Vector3 position, PlayerDirection direction, string nickname, int receiverID)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutInt(SFSLabel.InfoID, InfoID.Instantiate.GetHashCode());
        parameter.PutInt(InfoLabel.SenderID.GetHashString(), senderID);
        parameter.PutIntArray(InfoLabel.Close.GetHashString(), dressDataIDs);
        parameter.PutUtfString(InfoLabel.Position.GetHashString(), position.ToStr());
        parameter.PutInt(InfoLabel.PlayerDirection.GetHashString(), direction.GetHashCode());
        parameter.PutUtfString(InfoLabel.NickName.GetHashString(), nickname);
        parameter.PutUtfString(InfoLabel.SerialNumber.GetHashString(), serialNumber);
        parameter.PutLong(InfoLabel.JoinedTime.GetHashString(), joinedTime.Ticks);
        
        SFSEventManager.GardenSmartFox.AddRequest(WrapInfoRequest(CurrentPlazaRoom.Id, receiverID, parameter), RequestType.Immediate);
    }

    public void SendSynchronizeDestination(int senderID, Vector3 destination)
    {
        SFSObject sfsObject = new SFSObject();
        sfsObject.PutInt(SFSLabel.InfoID, InfoID.Synchronize.GetHashCode());
        sfsObject.PutInt(InfoLabel.SenderID.GetHashString(), senderID);
        sfsObject.PutUtfString(InfoLabel.Destination.GetHashString(), destination.ToStr());

        if (SFSEventManager.GardenSmartFox.PlazaRoomController.CurrentPlazaRoom != null)
        {
            SFSObject parameter = WrapInfoRequest(SFSEventManager.GardenSmartFox.PlazaRoomController.CurrentPlazaRoom.Id, -1, sfsObject);

            SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.BatchAndOverride, RequestName.SynchronizePosition, BatchOption.TryNot);
        }
        else
        {
            Debug.LogWarning("null");
        }
    }

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

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

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

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

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

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

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

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

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

    public void OnReceiveInfo(BaseEvent baseEvent)
    {
        ISFSObject arg = (baseEvent.Params[SFSLabel.DefaultParams] as ISFSObject).GetSFSObject(SFSLabel.Data);
        int infoID = arg.GetInt(SFSLabel.InfoID);

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

    public void OnInstantiate(ISFSObject arg)
    {
        int senderID = arg.GetInt(InfoLabel.SenderID.GetHashString());

        SFSEventManager.GardenSmartFox.PlazaRoomController.OnInstantiate(senderID, arg);
    }

    public void OnSynchronize(ISFSObject arg)
    {
        int senderID = arg.GetInt(InfoLabel.SenderID.GetHashString());

        SFSEventManager.GardenSmartFox.PlazaRoomController.Synchronize(senderID, arg);
    }

    public void OnReceiveExpression(ISFSObject arg)
    {
        int senderID = arg.GetInt(InfoLabel.SenderID.GetHashString());
        int expressionID = arg.GetInt(InfoLabel.Expression.GetHashString());

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

    public void OnReceivePublicMessage(ISFSObject arg)
    {
        int senderID = arg.GetInt(InfoLabel.SenderID.GetHashString());
        string message = arg.GetUtfString(InfoLabel.Message.GetHashString());

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


    public void CreateChest(int round, int value, ChestType type, int databaseRoomID, long serialNumber, Vector3 position)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutInt(SFSLabel.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(SFSLabel.DatabaseRoomID, databaseRoomID);
        parameter.PutLong(SFSLabel.UserID, serialNumber);
        parameter.PutUtfString(gd_chest.Position, position.ToStr(2));
        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

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

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

    public void OnReceiveNewChest(BaseEvent baseEvent)
    {
        ISFSObject parameter = (ISFSObject)baseEvent.Params[SFSLabel.DefaultParams];
        ChestData chestData = new ChestData(parameter.GetSFSObject(SFSLabel.Data));
        ChestManager.OnReceiveNewChest(chestData);
    }


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

    public void OnReceiveChestExpireStatus(BaseEvent baseEvent)
    {
        ISFSObject obj = baseEvent.Params[SFSLabel.DefaultParams] as ISFSObject;
        long[] chestIDs = obj.GetLongArray(SFSLabel.DataArray);
        ChestManager.OnReceiveChestExpireStatus(chestIDs.ToList());
    }


    public static SFSObject WrapChestAwardArg(long chestID)
    {
        SFSObject parameter = new SFSObject();
        parameter.PutInt(SFSLabel.CommandID, PlazaRoomReq.GetChestAward.GetHashCode());
        parameter.PutLong(gd_chest.ID, chestID);
        return parameter;
    }

    public void GetChestAward(long chestID)
    {
        SFSObject parameter = WrapChestAwardArg(chestID);
        SFSEventManager.GardenSmartFox.AddRequest(parameter, RequestType.Immediate);
    }

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

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

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

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

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

        ChestManager.ReceiveChestRefund(refund, databaseRoomIDs);
    }


    public void CreateRobot(BaseEvent baseEvent)
    {
        SFSObject arg = baseEvent.Params[SFSLabel.DefaultParams] as SFSObject;
        int currentRobotAmt = arg.GetInt(SFSLabel.Data);
        long robotConfigID = arg.GetLong(SFSLabel.UserID);
        bool random = arg.GetBool(SFSLabel.Random);
        string nickname = arg.GetUtfString(SFSLabel.Nickname);
        List<string> dressdatas = arg.GetUtfStringArray(SFSLabel.DataArray).ToList();
        RobotManager.AddRobot(currentRobotAmt, robotConfigID, random, nickname, dressdatas);
    }


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

    public void OnActivateDefaultChest(BaseEvent baseEvent)
    {
        ISFSObject arg = baseEvent.Params[SFSLabel.DefaultParams] as ISFSObject;
        DateTime dateTime = DateUtil.GetTimeFromSeconds(arg.GetLong(SFSLabel.Data).ToString());
        //Debug.Log(dateTime);
        ChestManager.ActivateSystemChest(dateTime);
    }

    public void OnReactivateDefaultChest(BaseEvent baseEvent)
    {
        ISFSObject arg = baseEvent.Params[SFSLabel.DefaultParams] as ISFSObject;
        DateTime dateTime = DateUtil.GetTimeFromSeconds(arg.GetLong(SFSLabel.Data).ToString());
        //Debug.Log(dateTime);
        ChestManager.ReactivateSystemChest(dateTime);
    }

    public void OnDeactivateDefaultChest(BaseEvent baseEvent)
    {
        ISFSObject arg = baseEvent.Params[SFSLabel.DefaultParams] as ISFSObject;
        long pasttime = arg.GetLong(SFSLabel.Data);
        //Debug.LogWarning(pasttime);
        ChestManager.DeactivateSystemChest(pasttime);
    }

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

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

        PlazaRoomManager.OnReceiveNormalRoomData(array);
    }

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

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

        PlazaRoomManager.OnReceiveCustomRoomData(array);
    }

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

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

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

    public void OnCreateRoomSucceed(BaseEvent baseEvent)
    {
        RoomData roomData = new RoomData((baseEvent.Params[SFSLabel.DefaultParams] as ISFSObject));
        PlazaRoomManager.OnCreateRoomSucceed(roomData);
    }


    public void OnJoinPlazaRoomSucceed(BaseEvent baseEvent)
    {
        ISFSObject arg = baseEvent.Params[SFSLabel.DefaultParams] as ISFSObject;
        int roomID = arg.GetInt(SFSLabel.RoomID);
        DateTime joinedTime = DateUtil.GetTimeFromSeconds(arg.GetLong(SFSLabel.DateTime).ToString()); 
        Room room = new SFSRoom(roomID, Random.Range(1f,100f).ToString());           

        CurrentPlazaRoom = room;

        SFSEventManager.GardenSmartFox.PlazaRoomController.OnJoinPlazaRoom(room, joinedTime);
    }

    public void OnJoinPlazaRoomError(BaseEvent baseEvent)
    {
        int errorID = (baseEvent.Params[SFSLabel.DefaultParams] as ISFSObject).GetInt(SFSLabel.Error);
        JoinRoomResult joinRoomRequest = (JoinRoomResult) errorID;
        SFSEventManager.GardenSmartFox.PlazaRoomController.OnJoinPlazaRoomError(joinRoomRequest);
    }

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

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

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

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

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

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

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


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

        obj.PutInt(SFSLabel.CommandID, PlazaRoomReq.SendInfo.GetHashCode());
        obj.PutInt(SFSLabel.RoomID, roomID);
        obj.PutInt(SFSLabel.TargetUserID, targetUserID);
        obj.PutSFSObject(SFSLabel.Data, parameter);

        return obj;
    }
}