AxibugEmuOnline/AxibugEmuOnline.Server/Manager/RoomManager.cs

using AxibugEmuOnline.Server.Common;
using AxibugEmuOnline.Server.Manager;
using AxibugEmuOnline.Server.NetWork;
using AxibugProtobuf;
using MySql.Data.MySqlClient;
using Org.BouncyCastle.Crypto.Parameters;
using System.Data;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Security.Policy;

namespace AxibugEmuOnline.Server
{

	public class RoomManager
	{
		Dictionary<int, Data_RoomData> mDictRoom = new Dictionary<int, Data_RoomData>();
		List<int> mKeyRoomList = new List<int>();
		AutoResetEvent roomTickARE;
		Thread threadRoomTick;

		int RoomIDSeed = 1;
		public RoomManager()
		{
			NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomList, OnCmdRoomList);
			NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomGetScreen, CmdRoomGetScreen);
			NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomCreate, OnCmdRoomCreate);
			NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomJoin, OnCmdRoomJoin);
			NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomLeave, OnCmdRoomLeave);
			NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomChangePlayerWithJoy, OnCmdRoomChangePlayerWithJoy);
			NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomHostPlayerUpdateStateRaw, OnHostPlayerUpdateStateRaw);
			NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomPlayerReady, OnRoomPlayerReady);
			NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomSingelPlayerInput, OnSingelPlayerInput);

			NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdScreen, OnCmdScreen);

			roomTickARE = AppSrv.g_Tick.AddNewARE(TickManager.TickType.Interval_16MS);
			threadRoomTick = new Thread(UpdateLoopTick);
			threadRoomTick.Start();

			//System.Timers.Timer mTimer16ms = new System.Timers.Timer(16);//实例化Timer类
			//mTimer16ms.Elapsed += new System.Timers.ElapsedEventHandler((source, e) => { UpdateAllRoomLogic(); });//到达时间的时候执行事件；
			//mTimer16ms.AutoReset = true;//设置是执行一次（false）还是一直执行(true)；
			//mTimer16ms.Enabled = true;//是否执行System.Timers.Timer.Elapsed事件；
			//mTimer16ms.Start();
		}

		#region 房间管理

		int GetNewRoomID()
		{
			return RoomIDSeed++;
		}

		void AddRoom(Data_RoomData data)
		{
			lock (mDictRoom)
			{
				if (!mDictRoom.ContainsKey(data.RoomID))
				{
					mDictRoom.Add(data.RoomID, data);
					mKeyRoomList.Add(data.RoomID);
				}
			}
		}

		void RemoveRoom(int RoomID)
		{
			lock (mDictRoom)
			{
				if (mDictRoom.ContainsKey(RoomID))
				{
					mDictRoom.Remove(RoomID);
					mKeyRoomList.Remove(RoomID);
				}
			}
		}

		public Data_RoomData GetRoomData(int RoomID)
		{
			if (!mDictRoom.TryGetValue(RoomID, out Data_RoomData data))
				return null;
			return data;
		}

		public List<Data_RoomData> GetRoomList()
		{
			lock (mDictRoom)
			{
				List<Data_RoomData> temp = new List<Data_RoomData>();
				foreach (var room in mDictRoom)
				{
					temp.AddRange(mDictRoom.Values);
				}
				return temp;
			}
		}

		#endregion

		#region

		public enum RoomLogType
		{
			Create = 0,
			Join = 1,
			Leave = 2
		}
		public void RoomLog(long uid, int platform, int RoomID, int RomID, RoomLogType state)
		{
			MySqlConnection conn = Haoyue_SQLPoolManager.DequeueSQLConn("RoomLog");
			try
			{
				string query = "INSERT INTO `haoyue_emu`.`room_log` (`uid`, `platform`, `romid`,`roomid`, `state`) VALUES ( ?uid, ?platform, ?romid, ?roomid, ?state);";
				using (var command = new MySqlCommand(query, conn))
				{
					// 设置参数值
					command.Parameters.AddWithValue("?uid", uid);
					command.Parameters.AddWithValue("?platform", platform);
					command.Parameters.AddWithValue("?romid", RomID);
					command.Parameters.AddWithValue("?roomid", RoomID);
					command.Parameters.AddWithValue("?state", state);
					command.ExecuteNonQuery();
				}

				if (state == RoomLogType.Create)
				{
					query = "update romlist_nes set playcount = playcount + 1 where id = ?romid";
					using (var command = new MySqlCommand(query, conn))
					{
						command.Parameters.AddWithValue("?romid", RomID);
						command.ExecuteNonQuery();
					}
				}
			}
			catch (Exception e)
			{
			}
			Haoyue_SQLPoolManager.EnqueueSQLConn(conn);
		}
		#endregion

		private Protobuf_Room_MiniInfo GetProtoDataRoom(Data_RoomData room)
		{
			Protobuf_Room_MiniInfo result = new Protobuf_Room_MiniInfo()
			{
				GameRomID = room.GameRomID,
				RoomID = room.RoomID,
				GameRomHash = room.RomHash,
				ScreenProviderUID = room.ScreenProviderUID,
				HostPlayerUID = room.HostUID,
				GameState = room.GameState,
				ObsUserCount = 0,//TODO
			};

			for (byte i = 0; i < room.PlayerSlot.Count(); i++)
			{
				Protobuf_Room_GamePlaySlot pbSlot = new Protobuf_Room_GamePlaySlot();
				Data_RoomSlot slot = room.PlayerSlot[i];
				if (slot.UID > 0)
				{
					pbSlot.PlayerUID = slot.UID;
					pbSlot.PlayerLocalJoyIdx = (int)slot.LocalJoyIdx;
					if (AppSrv.g_ClientMgr.GetClientByUID(pbSlot.PlayerUID, out ClientInfo _client))
						pbSlot.PlayerNickName = _client.NickName;
				}
				result.GamePlaySlotList.Add(pbSlot);
			}

			return result;
		}

		public void OnCmdRoomList(Socket sk, byte[] reqData)
		{
			AppSrv.g_Log.DebugCmd($"OnCmdRoomList");
			ClientInfo _c = AppSrv.g_ClientMgr.GetClientForSocket(sk);
			Protobuf_Room_List msg = ProtoBufHelper.DeSerizlize<Protobuf_Room_List>(reqData);

			Protobuf_Room_List_RESP resp = new Protobuf_Room_List_RESP();
			List<Data_RoomData> temp = GetRoomList();
			foreach (var room in temp)
				resp.RoomMiniInfoList.Add(GetProtoDataRoom(room));
			AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomList, (int)ErrorCode.ErrorOk, ProtoBufHelper.Serizlize(resp));
		}
		public void CmdRoomGetScreen(Socket sk, byte[] reqData)
		{
			AppSrv.g_Log.DebugCmd($"CmdRoomGetScreen");
			ClientInfo _c = AppSrv.g_ClientMgr.GetClientForSocket(sk);
			Protobuf_Room_Get_Screen msg = ProtoBufHelper.DeSerizlize<Protobuf_Room_Get_Screen>(reqData);

			Data_RoomData room = GetRoomData(_c.RoomState.RoomID);
			bool bHadRoomStateChange = false;
			ErrorCode Errcode = ErrorCode.ErrorOk;
			Protobuf_Room_Get_Screen_RESP resp = new Protobuf_Room_Get_Screen_RESP();
			if (room == null)
				Errcode = ErrorCode.ErrorRoomNotFound;
			else
			{
				resp.FrameID = (int)room.mCurrServerFrameId;
				resp.RoomID = room.RoomID;
				resp.RawBitmap = room.ScreenRaw;
			}

			AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomGetScreen, (int)ErrorCode.ErrorOk, ProtoBufHelper.Serizlize(resp));
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="RoomID"></param>
		/// <param name="type">//[0] 更新或新增 [1] 删除</param>
		public void SendRoomUpdateToAll(Data_RoomData room, int type)
		{
			if (room == null)
				return;

			Protobuf_Room_Update_RESP resp = new Protobuf_Room_Update_RESP()
			{
				UpdateType = type,
				RoomMiniInfo = GetProtoDataRoom(room)
			};

			AppSrv.g_ClientMgr.ClientSendALL((int)CommandID.CmdRoomListUpdate, (int)ErrorCode.ErrorOk, ProtoBufHelper.Serizlize(resp));
		}

		public void OnCmdRoomCreate(Socket sk, byte[] reqData)
		{
			AppSrv.g_Log.DebugCmd($"OnCmdRoomCreate");
			ClientInfo _c = AppSrv.g_ClientMgr.GetClientForSocket(sk);
			Protobuf_Room_Create msg = ProtoBufHelper.DeSerizlize<Protobuf_Room_Create>(reqData);
			Protobuf_Room_Create_RESP resp = new Protobuf_Room_Create_RESP();

			Data_RoomData newRoom = new Data_RoomData();
			newRoom.Init(GetNewRoomID(), msg.GameRomID, msg.GameRomHash, _c.UID);
			AddRoom(newRoom);
			ErrorCode joinErrcode = ErrorCode.ErrorOk;
			//加入
			if (newRoom.Join(0, 0, _c, out joinErrcode, out bool bHadRoomStateChange))
			{
				//创建成功下行
				resp.RoomMiniInfo = GetProtoDataRoom(newRoom);
			}
			AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomCreate, (int)joinErrcode, ProtoBufHelper.Serizlize(resp));

			if (joinErrcode == ErrorCode.ErrorOk && bHadRoomStateChange)
				SendRoomStepChange(newRoom);

			SendRoomUpdateToAll(newRoom, 0);

			RoomLog(_c.UID, 1, newRoom.RoomID, newRoom.GameRomID, RoomLogType.Create);
		}

		public void OnCmdRoomJoin(Socket sk, byte[] reqData)
		{
			AppSrv.g_Log.DebugCmd($"OnCmdRoomJoin");
			ClientInfo _c = AppSrv.g_ClientMgr.GetClientForSocket(sk);
			Protobuf_Room_Join msg = ProtoBufHelper.DeSerizlize<Protobuf_Room_Join>(reqData);
			Protobuf_Room_Join_RESP resp = new Protobuf_Room_Join_RESP();
			ErrorCode joinErrcode;
			Data_RoomData room = GetRoomData(msg.RoomID);
			bool bHadRoomStateChange = false;
			if (room == null)
			{
				joinErrcode = ErrorCode.ErrorRoomNotFound;

				AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomJoin, (int)joinErrcode, ProtoBufHelper.Serizlize(resp));
				return;
			}


            lock (room)
			{

				if (!room.GetFreeSlot(out uint SlotIdx))
                {
                    joinErrcode = ErrorCode.ErrorRoomSlotAlreadlyHadPlayer;
                    AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomJoin, (int)joinErrcode, ProtoBufHelper.Serizlize(resp));
					return;
                }

                //加入
                if (room.Join(SlotIdx, (uint)0, _c, out joinErrcode, out bHadRoomStateChange))
				{
					Data_RoomData roomData = GetRoomData(msg.RoomID);
					resp.RoomMiniInfo = GetProtoDataRoom(roomData);
				}

				AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomJoin, (int)joinErrcode, ProtoBufHelper.Serizlize(resp));
				Protobuf_Room_MyRoom_State_Change(msg.RoomID);

				if (joinErrcode == ErrorCode.ErrorOk && bHadRoomStateChange)
					SendRoomStepChange(room);

				if (room != null)
				{
					SendRoomUpdateToAll(room, 0);
				}
			}
			RoomLog(_c.UID, 1, room.RoomID, room.GameRomID, RoomLogType.Join);
		}
		public void OnCmdRoomLeave(Socket sk, byte[] reqData)
		{
			AppSrv.g_Log.DebugCmd($"OnCmdRoomLeave");
			ClientInfo _c = AppSrv.g_ClientMgr.GetClientForSocket(sk);
			Protobuf_Room_Leave msg = ProtoBufHelper.DeSerizlize<Protobuf_Room_Leave>(reqData);
			LeaveRoom(_c, msg.RoomID);
			//Protobuf_Room_Leave_RESP resp = new Protobuf_Room_Leave_RESP();
			//ErrorCode errcode;
			//Data_RoomData room = GetRoomData(_c.RoomState.RoomID);
			//bool bHadRoomStateChange = false;
			//if (room == null)
			//    errcode = ErrorCode.ErrorRoomNotFound;
			//else
			//{
			//    if (room.Leave(_c, out errcode, out bHadRoomStateChange))
			//    {
			//        resp.RoomID = msg.RoomID;
			//    }
			//}
			//AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomLeave, (int)errcode, ProtoBufHelper.Serizlize(resp));
			//Protobuf_Room_MyRoom_State_Change(msg.RoomID);

			//if (errcode == ErrorCode.ErrorOk && bHadRoomStateChange)
			//    SendRoomStepChange(room);

			//SendRoomUpdateToAll(room.RoomID, 1);
			//if (room.GetPlayerCount() < 1)
			//    RemoveRoom(room.RoomID);
		}
		public void LeaveRoom(ClientInfo _c, int RoomID)
		{
			AppSrv.g_Log.Debug($"LeaveRoom");
			if (RoomID < 0)
				return;
			Protobuf_Room_Leave_RESP resp = new Protobuf_Room_Leave_RESP();
			ErrorCode errcode;
			Data_RoomData room = GetRoomData(_c.RoomState.RoomID);
			bool bHadRoomStateChange = false;
			if (room == null)
			{
				errcode = ErrorCode.ErrorRoomNotFound;
				AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomLeave, (int)errcode, ProtoBufHelper.Serizlize(resp));
				return;
			}

			if (room.Leave(_c, out errcode, out bHadRoomStateChange))
			{
				resp.RoomID = RoomID;
			}
			AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomLeave, (int)errcode, ProtoBufHelper.Serizlize(resp));
			Protobuf_Room_MyRoom_State_Change(RoomID);

			if (errcode == ErrorCode.ErrorOk && bHadRoomStateChange)
				SendRoomStepChange(room);

			if (room.GetPlayerCount() < 1)
			{
				SendRoomUpdateToAll(room, 1);
				RemoveRoom(room.RoomID);
			}
			else
				SendRoomUpdateToAll(room, 0);

			RoomLog(_c.UID, 1, room.RoomID, room.GameRomID, RoomLogType.Leave);
		}

		public void OnCmdRoomChangePlayerWithJoy(Socket sk, byte[] reqData)
		{
			AppSrv.g_Log.DebugCmd($"OnCmdRoomChangePlayerjoySlot");
			ClientInfo _c = AppSrv.g_ClientMgr.GetClientForSocket(sk);
			Protobuf_Room_Change_PlaySlotWithJoy msg = ProtoBufHelper.DeSerizlize<Protobuf_Room_Change_PlaySlotWithJoy>(reqData);
			Protobuf_Room_Change_PlaySlotWithJoy_RESP resp = new Protobuf_Room_Change_PlaySlotWithJoy_RESP();
			ErrorCode errcode = ErrorCode.ErrorOk;
			Data_RoomData room = GetRoomData(_c.RoomState.RoomID);
			if (room == null)
				errcode = ErrorCode.ErrorRoomNotFound;

			if (errcode == ErrorCode.ErrorOk)
			{
				Dictionary<uint, uint> newSlotIdx2JoyIdx = new Dictionary<uint, uint>();
				foreach (var slotinfo in msg.SlotWithJoy)
				{
					//如果有任意一个槽位有人
					if (room.GetPlayerUIDByIdx((uint)slotinfo.PlayerSlotIdx, out long UID))
					{
						//且人不是自己，则不允许换位
						if(UID != _c.UID) 
							errcode = ErrorCode.ErrorRoomSlotAlreadlyHadPlayer; break;
					}

					newSlotIdx2JoyIdx[(uint)slotinfo.PlayerSlotIdx] = (uint)slotinfo.PlayerLocalJoyIdx;
				}

				room.SetPlayerSlotData(_c,ref newSlotIdx2JoyIdx);
			}
			AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomMyRoomStateChanged, (int)errcode, ProtoBufHelper.Serizlize(resp));
		}

		public void OnHostPlayerUpdateStateRaw(Socket sk, byte[] reqData)
		{
			ClientInfo _c = AppSrv.g_ClientMgr.GetClientForSocket(sk);
			AppSrv.g_Log.DebugCmd($"OnHostPlayerUpdateStateRaw 上报即时存档 UID->{_c.UID}");
			Protobuf_Room_HostPlayer_UpdateStateRaw msg = ProtoBufHelper.DeSerizlize<Protobuf_Room_HostPlayer_UpdateStateRaw>(reqData);
			Protobuf_Room_HostPlayer_UpdateStateRaw_RESP resp = new Protobuf_Room_HostPlayer_UpdateStateRaw_RESP();
			ErrorCode errcode = ErrorCode.ErrorOk;
			Data_RoomData room = GetRoomData(_c.RoomState.RoomID);
			if (room == null)
				errcode = ErrorCode.ErrorRoomNotFound;
			else if (room.GameState != RoomGameState.WaitRawUpdate)
				errcode = ErrorCode.ErrorRoomCantDoCurrState;

			AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomHostPlayerUpdateStateRaw, (int)errcode, ProtoBufHelper.Serizlize(resp));

			if (errcode == ErrorCode.ErrorOk)
			{
				room.SetLoadRaw(msg.LoadStateRaw, out bool bHadRoomStateChange);
				if (bHadRoomStateChange)
					SendRoomStepChange(room);
			}
		}

		public void OnRoomPlayerReady(Socket sk, byte[] reqData)
		{
			ClientInfo _c = AppSrv.g_ClientMgr.GetClientForSocket(sk);
			AppSrv.g_Log.DebugCmd($"OnRoomPlayerReady _c->{_c.UID}");
			Protobuf_Room_Player_Ready msg = ProtoBufHelper.DeSerizlize<Protobuf_Room_Player_Ready>(reqData);
			ErrorCode errcode = ErrorCode.ErrorOk;
			Data_RoomData room = GetRoomData(_c.RoomState.RoomID);
			if (room == null)
				return;
			lock (room)
			{
				AppSrv.g_Log.Debug($"SetRePlayerReady RoomID->{room.RoomID},UID->{_c.UID}");
				room.SetRePlayerReady(_c.UID, out errcode, out bool bHadRoomStateChange);
				if (bHadRoomStateChange)
				{
					SendRoomStepChange(room);
				}
			}
		}

		public void OnSingelPlayerInput(Socket sk, byte[] reqData)
		{
			ClientInfo _c = AppSrv.g_ClientMgr.GetClientForSocket(sk);
			Protobuf_Room_SinglePlayerInputData msg = ProtoBufHelper.DeSerizlize<Protobuf_Room_SinglePlayerInputData>(reqData);
			Data_RoomData room = GetRoomData(_c.RoomState.RoomID);
			if (room == null)
				return;

			//取玩家操作数据中的第一个
			ServerInputSnapShot temp = new ServerInputSnapShot();
			temp.all = msg.InputData;
			//room.SetPlayerInput(_c.RoomState.PlayerIdx, msg.FrameID, temp);

			//是否需要推帧
			if (room.GetNeedForwardTick(msg.FrameID, out long forwaFrame))
			{
				for (int i = 0; i < forwaFrame; i++)
				{
					if (i + 1 == forwaFrame)//最后一帧
					{
						//写入操作前、将网络波动堆积，可能造成瞬时多个连续推帧结果（最后一帧除外）立即广播，不等16msTick
						//if (forwaFrame > 1)
						//    room.SynInputData();

						//推帧过程中，最后一帧才写入操作
						room.SetPlayerInput(_c.UID, msg.FrameID, temp);
					}
					//推帧
					room.TakeFrame();
				}
			}
			else//不需要推帧
			{
				//虽然不推帧，但是存入Input
				room.SetPlayerInput(_c.UID, msg.FrameID, temp);
			}

			if (room.LastTestRecv != room.mCurrInputData.all)
			{
				room.LastTestRecv = room.mCurrInputData.all;
				//AppSrv.g_Log.Debug($" {DateTime.Now.ToString("hh:mm:ss.fff")} SynTestRecv=> UID->{_c.UID} roomId->{room.mCurrServerFrameId} input->{msg.InputData}");
			}
		}

		public void OnCmdScreen(Socket sk, byte[] reqData)
		{
			AppSrv.g_Log.DebugCmd($"OnCmdScreen lenght:{reqData.Length}");
			ClientInfo _c = AppSrv.g_ClientMgr.GetClientForSocket(sk);
			Protobuf_Screnn_Frame msg = ProtoBufHelper.DeSerizlize<Protobuf_Screnn_Frame>(reqData);
			Data_RoomData room = AppSrv.g_Room.GetRoomData(msg.RoomID);
			room.InputScreenData(msg.RawBitmap);
		}

		/// <summary>
		/// 广播房间状态变化
		/// </summary>
		/// <param name="RoomID"></param>
		public void Protobuf_Room_MyRoom_State_Change(int RoomID)
		{
			Data_RoomData room = GetRoomData(RoomID);
			if (room == null)
				return;

			Protobuf_Room_MyRoom_State_Change resp = new Protobuf_Room_MyRoom_State_Change()
			{
				RoomMiniInfo = GetProtoDataRoom(room)
			};

			List<ClientInfo> userlist = room.GetAllPlayerClientList();

			foreach (ClientInfo _c in userlist)
			{
				AppSrv.g_ClientMgr.ClientSend(_c, (int)CommandID.CmdRoomMyRoomStateChanged, (int)ErrorCode.ErrorOk, ProtoBufHelper.Serizlize(resp));
			}
		}

		/// <summary>
		/// 广播联机Step
		/// </summary>
		/// <param name="room"></param>
		public void SendRoomStepChange(Data_RoomData room)
		{
			List<ClientInfo> roomClient = room.GetAllPlayerClientList();
			switch (room.GameState)
			{
				case RoomGameState.WaitRawUpdate:
					{
						Protobuf_Room_WaitStep_RESP resp = new Protobuf_Room_WaitStep_RESP()
						{
							WaitStep = 0
						};
						AppSrv.g_Log.DebugCmd($"Step:0 WaitRawUpdate 广播等待主机上报即时存档");
						AppSrv.g_ClientMgr.ClientSend(roomClient, (int)CommandID.CmdRoomWaitStep, (int)ErrorCode.ErrorOk, ProtoBufHelper.Serizlize(resp));
					}
					break;
				case RoomGameState.WaitReady:
					{
						Protobuf_Room_WaitStep_RESP resp = new Protobuf_Room_WaitStep_RESP()
						{
							WaitStep = 1,
							LoadStateRaw = room.NextStateRaw
						};
						AppSrv.g_Log.DebugCmd($"Step:1 WaitReady 广播即时存档");
						AppSrv.g_ClientMgr.ClientSend(roomClient, (int)CommandID.CmdRoomWaitStep, (int)ErrorCode.ErrorOk, ProtoBufHelper.Serizlize(resp));
					}
					break;
				case RoomGameState.InOnlineGame:
					{
						Protobuf_Room_WaitStep_RESP resp = new Protobuf_Room_WaitStep_RESP()
						{
							WaitStep = 2,
						};
						AppSrv.g_Log.DebugCmd($"Step:2 InOnlineGame 广播开始游戏");
						AppSrv.g_ClientMgr.ClientSend(roomClient, (int)CommandID.CmdRoomWaitStep, (int)ErrorCode.ErrorOk, ProtoBufHelper.Serizlize(resp));
					}
					break;
			}
		}

		#region 房间帧循环
		void UpdateLoopTick()
		{
			while (true)
			{
				roomTickARE.WaitOne();
				UpdateAllRoomLogic();
			}
		}
		void UpdateAllRoomLogic()
		{
			if (mKeyRoomList.Count < 1)
				return;
			for (int i = 0; i < mKeyRoomList.Count; i++)
			{
				int roomid = mKeyRoomList[i];
				if (!mDictRoom.TryGetValue(roomid, out Data_RoomData room) || room.GameState < RoomGameState.InOnlineGame)
					continue;
				//更新帧
				//room.TakeFrame();
				//广播
				room.SynInputData();
			}
		}
		#endregion
	}

	public class Data_RoomData
	{
		public int RoomID { get; private set; }
		public int GameRomID { get; private set; }
		public string RomHash { get; private set; }
		public long HostUID { get; private set; }
		public long ScreenProviderUID { get; private set; }
		public Data_RoomSlot[] PlayerSlot;
		public long Player1_UID => PlayerSlot[0].UID;
		public long Player2_UID => PlayerSlot[1].UID;
		public long Player3_UID => PlayerSlot[2].UID;
		public long Player4_UID => PlayerSlot[3].UID;
		public Google.Protobuf.ByteString? NextStateRaw { get; private set; }
		public Google.Protobuf.ByteString? ScreenRaw { get; private set; }
		//public bool[] PlayerReadyState { get; private set; }
		public List<long> SynUIDs;
		//public RoomPlayerState PlayerState => getPlayerState();
		private RoomGameState mGameState;
		public uint mCurrServerFrameId = 0;
		public ServerInputSnapShot mCurrInputData;
		public Queue<(uint, ServerInputSnapShot)> mInputQueue;
		object synInputLock = new object();
		//TODO
		public Dictionary<int, Queue<byte[]>> mDictPlayerIdx2SendQueue;
		public RoomGameState GameState
		{
			get { return mGameState; }
			set
			{
				if (mGameState != value)
				{
					mGameState = value;
					switch (value)
					{
						case RoomGameState.WaitRawUpdate:
							NextStateRaw = null;
							break;
						case RoomGameState.WaitReady:
							ClearAllSlotReadyState();//清理玩家所有准备状态
							break;
					}
				}
			}
		}
		/// <summary>
		/// 服务器提前帧数
		/// </summary>
		public uint SrvForwardFrames { get; set; }
		public void Init(int roomID, int gameRomID, string roomHash, long hostUId, bool bloadState = false)
		{
			RoomID = roomID;
			GameRomID = gameRomID;
			RomHash = roomHash;
			HostUID = hostUId;
			ScreenProviderUID = hostUId;

			if (PlayerSlot == null)
				PlayerSlot = new Data_RoomSlot[4];

			for (uint i = 0; i < PlayerSlot.Length; i++)
				PlayerSlot[i].Init(i);

			//PlayerReadyState = new bool[4];
			SynUIDs = new List<long>();//广播角色列表
			GameState = RoomGameState.NoneGameState;
			mCurrInputData = new ServerInputSnapShot();
			mInputQueue = new Queue<(uint, ServerInputSnapShot)>();
			mDictPlayerIdx2SendQueue = new Dictionary<int, Queue<byte[]>>();
		}
		public Dictionary<uint, uint> GetSlotDataByUID(long uid)
		{
			Dictionary<uint, uint> slotIdx2JoyIdx = new Dictionary<uint, uint>();
			var dataarr = PlayerSlot.Where(w => w.UID == uid).ToArray();
			foreach (var slot in dataarr)
				slotIdx2JoyIdx[slot.SlotIdx] = slot.LocalJoyIdx;
			return slotIdx2JoyIdx;
		}
		/// <summary>
		/// 按照SlotIdx设置Input
		/// </summary>
		/// <param name="slotIdx"></param>
		void SetInputDataBySlotIdx(uint slotIdx, byte val)
		{
			switch (slotIdx)
			{
				case 0: mCurrInputData.p1_byte = val; break;
				case 1: mCurrInputData.p2_byte = val; break;
				case 2: mCurrInputData.p3_byte = val; break;
				case 4: mCurrInputData.p3_byte = val; break;
			}
		}
		/// <summary>
		/// 按照UID清理SlotData
		/// </summary>
		/// <param name="uid"></param>
		void ClearSlotDataByUid(long uid)
		{
			var dataarr = PlayerSlot.Where(w => w.UID == uid).ToArray();
			foreach (var slot in dataarr)
			{
				dataarr[slot.SlotIdx].Init(slot.SlotIdx);
				ClearInputDataBySlotIdx(slot.SlotIdx);
			}
		}
		/// <summary>
		/// 按照SlotIdx清理SlotData
		/// </summary>
		/// <param name="slotIdx"></param>
		void ClearSlotDataBySlotIdx(uint slotIdx)
		{
			PlayerSlot[slotIdx].Init(slotIdx);
			ClearInputDataBySlotIdx(slotIdx);
		}
		/// <summary>
		/// 按照SlotIdx清理Input
		/// </summary>
		/// <param name="slotIdx"></param>
		void ClearInputDataBySlotIdx(uint slotIdx)
		{
			switch (slotIdx)
			{
				case 0: mCurrInputData.p1_byte = 0; break;
				case 1: mCurrInputData.p2_byte = 0; break;
				case 2: mCurrInputData.p3_byte = 0; break;
				case 4: mCurrInputData.p3_byte = 0; break;
			}
		}
		/// <summary>
		/// 更新同步名单
		/// </summary>
		void UpdateSynUIDs()
		{
			for (int i = SynUIDs.Count - 1; i >= 0; i--)
			{
				long uid = SynUIDs[i];

				bool bHad = false;
				if (Player1_UID == uid) bHad = true;
				else if (Player2_UID == uid) bHad = true;
				else if (Player3_UID == uid) bHad = true;
				else if (Player4_UID == uid) bHad = true;
				if (bHad)
					SynUIDs.RemoveAt(i);
			}
			if (!SynUIDs.Contains(Player1_UID)) SynUIDs.Add(Player1_UID);
			if (!SynUIDs.Contains(Player2_UID)) SynUIDs.Add(Player2_UID);
			if (!SynUIDs.Contains(Player3_UID)) SynUIDs.Add(Player3_UID);
			if (!SynUIDs.Contains(Player4_UID)) SynUIDs.Add(Player4_UID);
		}

		#region 准备状态管理
		bool IsAllReady()
		{
			bool Ready = true;
			if (
				(Player1_UID > 0 && !PlayerSlot[0].Ready)
				||
				(Player2_UID > 0 && !PlayerSlot[1].Ready)
				||
				(Player3_UID > 0 && !PlayerSlot[2].Ready)
				||
				(Player4_UID > 0 && !PlayerSlot[3].Ready)
				)
			{
				Ready = false;
			}
			return Ready;
		}
		/// <summary>
		/// 清除所有槽位准备状态
		/// </summary>
		void ClearAllSlotReadyState()
		{
			for (var i = 0; i < PlayerSlot.Length; i++)
			{
				PlayerSlot[i].Ready = false;
			}
		}
		/// <summary>
		/// 按照UID设置Ready信息
		/// </summary>
		/// <param name="uid"></param>
		void SetReadyByUid(long uid)
		{
			for (var i = 0; i < PlayerSlot.Length; i++)
			{
				if (PlayerSlot[i].UID == uid)
					PlayerSlot[i].Ready = true;
			}
		}
		#endregion

		public void SetPlayerSlotData(ClientInfo _c, ref readonly Dictionary<uint, uint> newSlotIdx2JoyIdx)
		{
			Dictionary<uint, uint> oldSlotIdx2JoyIdx = GetSlotDataByUID(_c.UID);
			HashSet<uint> diffSlotIdxs = new HashSet<uint>();
			foreach (var old in oldSlotIdx2JoyIdx)
			{
				uint old_slotIdx = old.Key;
				//如果旧位置已经不存在于新位置，则需要算作diff
				if (!newSlotIdx2JoyIdx.ContainsKey(old_slotIdx))
				{
					diffSlotIdxs.Add(old_slotIdx); continue;
				}
				uint old_slotjoyIdx = old.Value;
				//如果旧位置不变，但客户端本地JoyIdx变化则算作diff
				if (old_slotjoyIdx != newSlotIdx2JoyIdx[old_slotIdx])
				{
					diffSlotIdxs.Add(old_slotIdx); continue;
				}
			}
			//如果是在旧数据中不存在的位置，则算作diff
			foreach (var newdata in newSlotIdx2JoyIdx)
			{
				uint new_slotIdx = newdata.Key;
				if (!oldSlotIdx2JoyIdx.ContainsKey(new_slotIdx))
				{
					diffSlotIdxs.Add(new_slotIdx); continue;
				}
			}
			//必要的diff slot 清理键值数据
			foreach (var diffSlotIdx in diffSlotIdxs)
			{
				ClearSlotDataBySlotIdx(diffSlotIdx);
			}
			//设置新的槽位
			foreach (var slotdata in newSlotIdx2JoyIdx)
			{
				PlayerSlot[slotdata.Key].LocalJoyIdx = slotdata.Value;
				AppSrv.g_Log.Debug($"SetPlayerUID RoomID->{RoomID} _c.UID->{_c.UID}  PlayerSlotIdx->{slotdata.Key} LocalJoyIdx->{slotdata.Value}");
			}
			//更新需要同步的UID
			UpdateSynUIDs();
			_c.RoomState.SetRoomData(this.RoomID);
		}
		public void RemovePlayer(ClientInfo _c)
		{
			ClearSlotDataByUid(_c.UID);
			UpdateSynUIDs();
			_c.RoomState.ClearRoomData();
		}
		public bool GetPlayerUIDByIdx(uint Idx, out long UID)
		{
			switch (Idx)
			{
				case 0: UID = Player1_UID; break;
				case 1: UID = Player2_UID; break;
				case 2: UID = Player3_UID; break;
				case 3: UID = Player4_UID; break;
				default: UID = -1; break;
			}
			return UID > 0;
		}
		public bool GetFreeSlot(out uint SlotIdx)
		{
			for (uint i = 0; i < PlayerSlot.Length; i++)
			{
				if (PlayerSlot[i].UID < 0)
				{
					SlotIdx = i;
					return true;
				}
			}
			SlotIdx = 0;
			return false;
        }
		public bool GetPlayerClientByIdx(uint Idx, out ClientInfo _c)
		{
			_c = null;
			if (!GetPlayerUIDByIdx(Idx, out long UID))
				return false;

			if (!AppSrv.g_ClientMgr.GetClientByUID(UID, out _c))
				return false;

			return true;
		}
		public List<ClientInfo> GetAllPlayerClientList()
		{
			List<ClientInfo> list = new List<ClientInfo>();
			List<long> Uids = SynUIDs;
			foreach (long uid in Uids)
			{
				if (!AppSrv.g_ClientMgr.GetClientByUID(uid, out ClientInfo _c, true))
					continue;
				list.Add(_c);
			}
			return list;
		}

		void SetInputBySlotIdxJoyIdx(uint SlotIdx, uint LocalJoyIdx, ServerInputSnapShot clieninput)
		{
			switch (LocalJoyIdx)
			{
				case 0: SetInputDataBySlotIdx(SlotIdx, clieninput.p1_byte); break;
				case 1: SetInputDataBySlotIdx(SlotIdx, clieninput.p2_byte); break;
				case 2: SetInputDataBySlotIdx(SlotIdx, clieninput.p3_byte); break;
				case 3: SetInputDataBySlotIdx(SlotIdx, clieninput.p4_byte); break;
			}
		}
		public int GetPlayerCount()
		{
			return SynUIDs.Count;
		}
		public void UpdateRoomForwardNum()
		{
			List<ClientInfo> playerlist = GetAllPlayerClientList();
			double maxNetDelay = 0;
			for (int i = 0; i < playerlist.Count; i++)
			{
				ClientInfo player = playerlist[i];
				maxNetDelay = Math.Max(maxNetDelay, player.AveNetDelay);
			}
			float MustTaskFrame = 1;
			SrvForwardFrames = (uint)((maxNetDelay / 0.016f) + MustTaskFrame);
			if (SrvForwardFrames < 2)
				SrvForwardFrames = 2;
			//AppSrv.g_Log.Debug($"服务器提前跑帧数：Max(2,({maxNetDelay} / {0.016f}) + {MustTaskFrame}) = {SrvForwardFrames}");
		}

		#region 帧相关
		void StartNewTick()
		{
			mInputQueue.Clear();
			mDictPlayerIdx2SendQueue.Clear();

			mCurrServerFrameId = 0;
			mCurrInputData.all = 1;

			UpdateRoomForwardNum();

			uint StartForwardFrames = (SrvForwardFrames * 2) + 5;
			StartForwardFrames = Math.Min(10, StartForwardFrames);
			//服务器提前跑帧数
			for (int i = 0; i < SrvForwardFrames; i++)
				TakeFrame();
			AppSrv.g_Log.Info($"房间初始提前量=>{StartForwardFrames}，当前延迟提前量=>{SrvForwardFrames}");
		}
		public void TakeFrame()
		{
			lock (synInputLock)
			{
				mInputQueue.Enqueue((mCurrServerFrameId, mCurrInputData));
				mCurrServerFrameId++;
				if (mCurrServerFrameId % 60 == 0)
				{
					UpdateRoomForwardNum();
				}
			}
		}
		#endregion

		ulong LastTestSend = 0;
		internal ulong LastTestRecv;

		public List<double> send2time = new List<double>();
		const int SynLimitOnSec = 63;

		/// <summary>
		/// 广播数据
		/// </summary>
		public void SynInputData()
		{
			List<(uint frameId, ServerInputSnapShot inputdata)> temp = null;
			bool flagInitList = false;
			lock (synInputLock)
			{
				double timeNow = AppSrv.g_Tick.timeNow;
				while (mInputQueue.Count > 0)
				{
					if (send2time.Count >= SynLimitOnSec)
					{
						//AppSrv.g_Log.Info($"{timeNow} - {send2time[0]} =>{timeNow - send2time[0]}");
						if (timeNow - send2time[0] < 1f) //最早的历史发送还在一秒之内
							break;
						else
							send2time.RemoveAt(0);
					}

					if (!flagInitList)
					{
						flagInitList = true;
						temp = new List<(uint frameId, ServerInputSnapShot inputdata)>();
					}
					temp.Add(mInputQueue.Dequeue());
					send2time.Add(timeNow);
				}
				//while (mInputQueue.Count > 0)
				//{
				//    temp.Add(mInputQueue.Dequeue());
				//}
			}

			if (!flagInitList)
				return;

			for (int i = 0; i < temp.Count; i++)
			{
				(uint frameId, ServerInputSnapShot inputdata) data = temp[i];

				Protobuf_Room_Syn_RoomFrameAllInputData resp = new Protobuf_Room_Syn_RoomFrameAllInputData()
				{
					FrameID = data.frameId,
					InputData = data.inputdata.all,
					ServerFrameID = mCurrServerFrameId,
					ServerForwardCount = this.SrvForwardFrames
				};
				AppSrv.g_ClientMgr.ClientSend(SynUIDs, (int)CommandID.CmdRoomSynPlayerInput, (int)ErrorCode.ErrorOk, ProtoBufHelper.Serizlize(resp));
				//if (LastTestSend != data.inputdata.all)
				//{
				//    LastTestSend = data.inputdata.all;
				//    AppSrv.g_Log.Debug($" {DateTime.Now.ToString("hh:mm:ss.fff")} SynInput=> RoomID->{RoomID} ServerFrameID->{mCurrServerFrameId} SynUIDs=>{string.Join(",", SynUIDs)} ");
				//}
			}
		}

		bool CheckRoomStateChange(int oldPlayerCount, int newPlayerCount)
		{
			bool bChanged = false;
			bool bNewToOnlyHost = (oldPlayerCount != 1 && newPlayerCount == 1);
			bool bMorePlayer = (oldPlayerCount < 2 && newPlayerCount >= 2) || (newPlayerCount > oldPlayerCount);
			switch (this.GameState)
			{
				case RoomGameState.NoneGameState:
					if (bNewToOnlyHost)
					{
						this.GameState = RoomGameState.OnlyHost;
						bChanged = true;
					}
					break;
				case RoomGameState.OnlyHost:
					if (bMorePlayer)//加入更多玩家
					{
						this.GameState = RoomGameState.WaitRawUpdate;
						bChanged = true;
						break;
					}
					break;
				case RoomGameState.WaitRawUpdate:
					if (bMorePlayer)//加入更多玩家
					{
						this.GameState = RoomGameState.WaitRawUpdate;
						bChanged = true;
						break;
					}
					if (NextStateRaw != null)//已经上传即时存档
					{
						this.GameState = RoomGameState.WaitReady;
						bChanged = true;
						break;
					}
					break;
				case RoomGameState.WaitReady:
					if (bMorePlayer)//加入更多玩家
					{
						this.GameState = RoomGameState.WaitRawUpdate;
						bChanged = true;
						break;
					}
					//没有未准备的
					bool bAllReady = IsAllReady();
					if (bAllReady)
					{
						this.GameState = RoomGameState.InOnlineGame;
						//新开Tick
						StartNewTick();
						bChanged = true;
						break;
					}
					break;
				case RoomGameState.Pause:
					if (bMorePlayer)//加入更多玩家
					{
						this.GameState = RoomGameState.WaitRawUpdate;
						bChanged = true;
						break;
					}
					break;
				case RoomGameState.InOnlineGame:
					if (bMorePlayer)//加入更多玩家
					{
						this.GameState = RoomGameState.WaitRawUpdate;
						bChanged = true;
						break;
					}
					break;
			}
			return bChanged;
		}


		#region 对外开放函数

		#region 房间进出
		/// <summary>
		/// 进入房间
		/// </summary>
		/// <param name="RoomID"></param>
		/// <param name="PlayerNum"></param>
		/// <param name="_c"></param>
		/// <param name="errcode"></param>
		/// <returns></returns>
		public bool Join(uint slotIdx, uint joyIdx, ClientInfo _c, out ErrorCode errcode, out bool bHadRoomStateChange)
		{
			bHadRoomStateChange = false;
			int oldPlayerCount = GetPlayerCount();
			if (GetPlayerUIDByIdx(slotIdx, out long hadUID))
			{
				errcode = ErrorCode.ErrorRoomSlotAlreadlyHadPlayer;
				return false;
			}
			AppSrv.g_Log.Debug($"Join _c.UID->{_c.UID} RoomID->{RoomID}");
			Dictionary<uint, uint> slotInfo = new Dictionary<uint, uint>();
			slotInfo[slotIdx] = joyIdx;
			SetPlayerSlotData(_c, ref slotInfo);
			int newPlayerCount = GetPlayerCount();
			errcode = ErrorCode.ErrorOk;
			bHadRoomStateChange = CheckRoomStateChange(oldPlayerCount, newPlayerCount);
			return true;
		}

		/// <summary>
		/// 离开房间
		/// </summary>
		/// <param name="RoomID"></param>
		/// <param name="_c"></param>
		/// <param name="errcode"></param>
		/// <returns></returns>
		public bool Leave(ClientInfo _c, out ErrorCode errcode, out bool bHadRoomStateChange)
		{
			int oldPlayerCount = GetPlayerCount();
			RemovePlayer(_c);
			int newPlayerCount = GetPlayerCount();
			errcode = ErrorCode.ErrorOk;
			bHadRoomStateChange = CheckRoomStateChange(oldPlayerCount, newPlayerCount);
			return true;
		}
		#endregion
		public void SetPlayerInput(long UID, uint LocalJoyIdx, ServerInputSnapShot clieninput)
		{
			for (uint i = 0; i < PlayerSlot.Count(); i++)
			{
				Data_RoomSlot slotData = PlayerSlot[i];
				if (slotData.UID != UID)
					continue;
				SetInputBySlotIdxJoyIdx(slotData.SlotIdx, slotData.LocalJoyIdx, clieninput);
			}
		}
		public bool SetRePlayerReady(long UID, out ErrorCode errcode, out bool bHadRoomStateChange)
		{
			int oldPlayerCount = GetPlayerCount();
			SetReadyByUid(UID);
			int newPlayerCount = GetPlayerCount();
			errcode = ErrorCode.ErrorOk;
			bHadRoomStateChange = CheckRoomStateChange(oldPlayerCount, newPlayerCount);
			return true;
		}
		public void SetLoadRaw(Google.Protobuf.ByteString NextStateRaw, out bool bHadRoomStateChange)
		{
			int oldPlayerCount = GetPlayerCount();
			AppSrv.g_Log.Debug($"SetLoadRaw proto Lenght->{NextStateRaw.Length}");
			this.NextStateRaw = NextStateRaw;
			int newPlayerCount = GetPlayerCount();
			bHadRoomStateChange = CheckRoomStateChange(oldPlayerCount, newPlayerCount);
		}
		public void InputScreenData(Google.Protobuf.ByteString screenRaw)
		{
			this.ScreenRaw = NextStateRaw;
		}
		public bool GetNeedForwardTick(uint clientFrame, out long forwaFrame)
		{
			forwaFrame = 0;
			//目标帧，客户端+服务器提前量
			long targetFrame = clientFrame + SrvForwardFrames;
			if (targetFrame > mCurrServerFrameId)//更靠前
				forwaFrame = targetFrame - mCurrServerFrameId;
			return forwaFrame > 0;
		}
		#endregion
	}

	public class Data_RoomSlot
	{
		public uint SlotIdx { get; set; }
		public long UID { get; set; }
		public uint LocalJoyIdx { get; set; }
		public bool Ready = false;
		public void Init(uint SlotIdx)
		{
			this.SlotIdx = SlotIdx;
			UID = -1;
			LocalJoyIdx = 0;
			Ready = false;
		}
	}

	[StructLayout(LayoutKind.Explicit, Size = 8)]
	public struct ServerInputSnapShot
	{
		[FieldOffset(0)]
		public UInt64 all;

		[FieldOffset(0)]
		public byte p1_byte;
		[FieldOffset(1)]
		public byte p2_byte;
		[FieldOffset(2)]
		public byte p3_byte;
		[FieldOffset(3)]
		public byte p4_byte;

		[FieldOffset(0)]
		public ushort p1_ushort;
		[FieldOffset(2)]
		public ushort p2_ushort;
		[FieldOffset(4)]
		public ushort p3_ushort;
		[FieldOffset(6)]
		public ushort p4_ushort;
	}
}