//---------------------------------------------------------
/// <summary>
/// 驱动游戏状态
/// </summary>
public void EnterFrame()
{
for (int i = 0; i < m_ListPlayersExitOnNextFrame.Count; i++)
{
FSPPlayer player = m_ListPlayersExitOnNextFrame[i];
FSPServer.Instance.DelSession(player.Sid);
player.Dispose();
}
m_ListPlayersExitOnNextFrame.Clear();
//在这里处理状态
HandleGameState();
//经过上面状态处理之后，有可能状态还会发生变化
if (m_State == FSPGameState.None)
{
return;
}
if (m_LockedFrame.frameId != 0 || !m_LockedFrame.IsEmpty())
{
//将当前帧扔给Player
for (int i = 0; i < m_ListPlayer.Count; i++)
{
FSPPlayer player = m_ListPlayer[i];
player.SendToClient(m_LockedFrame);
if (player.WaitForExit)
{
m_ListPlayersExitOnNextFrame.Add(player);
m_ListPlayer.RemoveAt(i);
--i;
}
}
}
//0帧每个循环需要额外清除掉再重新统计
if (m_LockedFrame.frameId == 0)
{
m_LockedFrame = new FSPFrame();
//防止GC
if (UseDelayGC)
{
m_ListObjectsForDelayGC.Add(m_LockedFrame);
}
}
//在这个阶段，帧号才会不停往上加
if (m_State == FSPGameState.RoundBegin || m_State == FSPGameState.ControlStart)
{
m_CurFrameId++;
m_LockedFrame = new FSPFrame();
m_LockedFrame.frameId = m_CurFrameId;
//防止GC
if (UseDelayGC)
{
m_ListObjectsForDelayGC.Add(m_LockedFrame);
}
}
}
public void Stop()
{
m_GameState = FSPGameState.None;
if (m_Controller != null)
{
m_Controller.Stop();
m_Controller = null;
}
if (m_Client != null)
{
m_Client.Stop();
m_Client = null;
}
m_FrameBuffer.Clear();
m_CurrentFrameIndex = 0;
m_FrameListener = null;
m_NextLocalFrame = null;
_mainPlayerId = 0;
m_Param = null;
m_GameStateListener = null;
m_IsRunning = false;
}
/// <summary>
/// 用于本地兼容，比如打PVE的时候，也可以用帧同步兼容
/// </summary>
/// <param name="vkey"></param>
/// <param name="arg"></param>
bool SendFSPLocal(int vkey, int arg)
{
Debuger.Log(LOG_TAG, "SendFSPLocal() vkey={0}, arg={1}", vkey, arg);
// 新的帧
int nextFrameId = m_CurrentFrameIndex + 1;
if (m_NextLocalFrame == null || m_NextLocalFrame.frameId != nextFrameId)
{
m_NextLocalFrame = new FSPFrame();
m_NextLocalFrame.frameId = nextFrameId;
m_FrameBuffer[m_NextLocalFrame.frameId] = m_NextLocalFrame;
}
// 添加输入
FSPVKey cmd = new FSPVKey();
cmd.playerId = _mainPlayerId;
cmd.vkey = vkey;
cmd.args.Add(arg);
m_NextLocalFrame.vkeys.Add(cmd);
return(true);
}
/// <summary>
/// 执行每一帧
/// </summary>
/// <param name="frameId"></param>
/// <param name="frame"></param>
private void ExecuteFrame(int frameId, FSPFrame frame)
{
if (frame != null && !frame.IsEmpty())
{
for (int i = 0; i < frame.msgs.Count; i++)
{
var msg = frame.msgs[i];
switch (msg.cmd)
{
case FSPBasicCmd.GAME_BEGIN: Handle_GameBegin(msg.args[0]); break;
case FSPBasicCmd.ROUND_BEGIN: Handle_RoundBegin(msg.args[0]); break;
case FSPBasicCmd.CONTROL_START: Handle_ControlStart(msg.args[0]); break;
case FSPBasicCmd.ROUND_END: Handle_RoundEnd(msg.args[0]); break;
case FSPBasicCmd.GAME_END: Handle_GameEnd(msg.args[0]); break;
case FSPBasicCmd.GAME_EXIT: Handle_GameExit(msg.playerId); break;
}
}
}
if (m_FrameListener != null)
{
m_FrameListener(frameId, frame);
}
}
public bool IsEquals(FSPFrame obj)
{
if (obj == null)
{
return(false);
}
return(obj.ToString() == this.ToString());
}
//=======================================================================================
/// <summary>
/// 驱动游戏状态
/// </summary>
public void EnterFrame()
{
for (int i = 0; i < m_ListPlayersExitOnNextFrame.Count; i++)
{
var player = m_ListPlayersExitOnNextFrame[i];
player.Release();
}
m_ListPlayersExitOnNextFrame.Clear();
//处理游戏状态切换
HandleGameState();
//经过上面状态处理之后，有可能状态还会发生变化
if (m_State == FSPGameState.None)
{
return;
}
if (m_LockedFrame.frameId != 0 || !m_LockedFrame.IsEmpty())
{
//将当前帧扔级Player
for (int i = 0; i < m_ListPlayer.Count; i++)
{
FSPPlayer player = m_ListPlayer[i];
player.SendToClient(m_LockedFrame);
if (player.WaitForExit)
{
m_ListPlayersExitOnNextFrame.Add(player);
m_ListPlayer.RemoveAt(i);
--i;
}
}
}
//0帧每个循环需要额外清除掉再重新统计
if (m_LockedFrame.frameId == 0)
{
m_LockedFrame = new FSPFrame();
}
//在这个阶段，帧号才会不停往上加
if (m_State == FSPGameState.RoundBegin || m_State == FSPGameState.ControlStart)
{
m_CurFrameId++;
m_LockedFrame = new FSPFrame();
m_LockedFrame.frameId = m_CurFrameId;
}
}
public void EnterFrame()
{
// 延迟移除，因为还要给些时间发包
for (int i = 0; i < m_ListPlayersExitOnNextFrame.Count; i++)
{
FSPPlayer player = m_ListPlayersExitOnNextFrame[i];
FSPServer.Instance.DelSession(player.Sid);
player.Dispose();
}
m_ListPlayersExitOnNextFrame.Clear();
// 处理状态变化
HandleGameState();
//经过上面状态处理之后，有可能状态还会发生变化
if (m_State == FSPGameState.None)
{
return;
}
if (m_LockedFrame.frameId != 0 || //已经在跑逻辑了
!m_LockedFrame.IsEmpty() //可能还在准备阶段
)
{
for (int i = m_ListPlayer.Count - 1; i >= 0; i--)
{
FSPPlayer player = m_ListPlayer[i];
player.SendToClient(m_LockedFrame);
if (player.WaitForExit)
{
m_ListPlayer.RemoveAt(i);
m_ListPlayersExitOnNextFrame.Add(player);
}
}
}
//0帧每个循环需要额外清除掉再重新统计
if (m_LockedFrame.frameId == 0)
{
// 为了保留m_LockedFrame.vkeys，没有用Clear()来清除
m_LockedFrame = new FSPFrame();
m_FrameRecords.Add(m_LockedFrame);
}
//在这个阶段，帧号才会不停往上加
if (m_State == FSPGameState.RoundBegin || m_State == FSPGameState.ControlStart)
{
m_CurFrameId++;
m_LockedFrame = new FSPFrame();
m_LockedFrame.frameId = m_CurFrameId;
m_FrameRecords.Add(m_LockedFrame);
}
}
public bool Send(FSPFrame frame)
{
if (null != m_aSocket)
{
FSPDataS2C data = new FSPDataS2C();
data.frames.Add(frame);
int len = PBSerializer.NSerialize(data, m_SendBuffer);
return(m_aSocket.SendTo(m_SendBuffer, len, EndPoint));
}
return(false);
}
public bool Send(FSPFrame frame)
{
if (m_Socket != null)
{
FSPData_SC data = new FSPData_SC();
data.frames.Add(frame);
int len = PBSerializer.Serialize(data, m_SendBuffer);
return(m_Socket.SendTo(m_SendBuffer, len, m_EndPoint));
}
return(false);
}
private void OnEnterFrame(int frameId, FSPFrame frame)
{
if (frame != null && frame.vkeys != null)
{
for (int i = 0; i < frame.vkeys.Count; i++)
{
FSPVKey cmd = frame.vkeys[i];
m_lastVKey = cmd.ToString();
this.Log("OnEnterFrame() frameId:{0}, cmd:{1}", frameId, cmd.ToString());
}
}
}
private void AddServerFrame(FSPFrame frame)
{
if (frame.FrameId <= 0)
{
ExecuteFrame(frame.FrameId, frame);
return;
}
frame.FrameId = frame.FrameId * m_Param.ClientFrameRateMultiple;
m_ClientLockedFrame = frame.FrameId + m_Param.ClientFrameRateMultiple - 1;
m_FrameBuffer.Add(frame.FrameId, frame);
m_FrameCtrl.AddFrameId(frame.FrameId);
}
//==================================================================
//发送数据
//==================================================================
public bool Send(FSPFrame frame)
{
if (!IsActived())
{
Debuger.LogWarning("Session已经不活跃了！");
return(false);
}
m_TempSendData.frames.Clear();
m_TempSendData.frames.Add(frame);
int len = PBSerializer.NSerialize(m_TempSendData, m_SendBufferTemp);
return(m_Kcp.Send(m_SendBufferTemp, len) == 0);
}
void ClearRound()
{
m_LockedFrame = new FSPFrame();
m_CurFrameId = 0;
ResetRoundFlag();
for (int i = 0; i < m_ListPlayer.Count; i++)
{
if (m_ListPlayer[i] != null)
{
m_ListPlayer[i].ClearRound();
}
}
}
private void OnEnterFrame(int frameId, FSPFrame frame)
{
GameManager.Instance.EnterFrame(frameId);
if (frame != null && frame.vkeys != null)
{
for (int i = 0; i < frame.vkeys.Count; i++)
{
FSPVKey cmd = frame.vkeys[i];
GameManager.Instance.InputVKey(cmd.vkey, ((float)cmd.args[0]) / 10000.0f, cmd.playerId);
}
}
CheckTimeEnd();
}
private bool TryAddToSession(FSPFrame frame)
{
if (frame.frameId != 0 && frame.frameId <= m_LastAddFrameId)
{
return(true);
}
if (m_Session != null)
{
if (m_Session.Send(frame))
{
m_LastAddFrameId = frame.frameId;
return(true);
}
}
return(false);
}
//--------------------------------------------------------------------
//Round处理函数
private int ClearRound()
{
mLockedFrame = new FSPFrame();
mCurFrameId = 0;
ResetRoundFlag();
for (int i = 0; i < mPlayerList.Count; i++)
{
if (mPlayerList[i] != null)
{
mPlayerList[i].ClearRound();
}
}
return(0);
}
private void OnEnterFrame(int frameId, FSPFrame frame)
{
if (frame == null)
{
// 这是空帧，也需要驱动逻辑
}
else
{
//处理业务逻辑的Frame里的命令
for (int i = 0; i < frame.msgs.Count; i++)
{
Debuger.Log("frameId:{0}, arg:{1}", frameId, frame.msgs[i]);
}
}
//最后驱动渲染,一般来说，渲染层读取逻辑层的数据
CurrentFrame = frame;
}
/// <summary>
/// 用于本地兼容，比如打PVE的时候，也可以用帧同步兼容
/// </summary>
/// <param name="cmd"></param>
/// <param name="arg"></param>
private void SendFSPLocal(int cmd, int[] args)
{
Debuger.Log("vkey={0}, arg={1}", cmd, args.ToListString());
if (m_NextLocalFrame == null || m_NextLocalFrame.frameId != m_CurrentFrameIndex + 1)
{
m_NextLocalFrame = new FSPFrame();
m_NextLocalFrame.frameId = m_CurrentFrameIndex + 1;
m_FrameBuffer.Add(m_NextLocalFrame.frameId, m_NextLocalFrame);
}
FSPMessage msg = new FSPMessage();
msg.cmd = cmd;
msg.args = args;
msg.playerId = m_MinePlayerId;
m_NextLocalFrame.msgs.Add(msg);
}
//====================================================================
//发送相关逻辑
public void SendToClient(FSPFrame frame)
{
if (frame != null)
{
if (!m_FrameCache.Contains(frame))
{
m_FrameCache.Enqueue(frame);
}
}
while (m_FrameCache.Count > 0)
{
if (SendInternal(m_FrameCache.Peek()))
{
m_FrameCache.Dequeue();
}
}
}
/// <summary>
/// 用于本地兼容，比如打PVE的时候，也可以用帧同步兼容
/// </summary>
/// <param name="vkey"></param>
/// <param name="arg"></param>
private void SendFSPLocal(int vkey, int arg = 0)
{
int nextFrameId = m_CurrentFrameIndex + 1;
if (m_NextLocalFrame == null || m_NextLocalFrame.FrameId != nextFrameId)
{
m_NextLocalFrame = new FSPFrame();
m_NextLocalFrame.FrameId = nextFrameId;
m_FrameBuffer.Add(m_NextLocalFrame.FrameId, m_NextLocalFrame);
}
FSPVKey cmd = new FSPVKey();
cmd.Vkey = vkey;
cmd.Args.Add(arg);
cmd.PlayerIdOrClientFrameId = m_MinePlayerId;
m_NextLocalFrame.Vkeys.Add(cmd);
}
/// <summary>
/// 执行每一帧
/// </summary>
/// <param name="frameId"></param>
/// <param name="frame"></param>
private void ExecuteFrame(int frameId, FSPFrame frame)
{
//优先处理流程VKey
if (frame != null && frame.Vkeys != null)
{
for (int i = 0; i < frame.Vkeys.Count; i++)
{
FSPVKey cmd = frame.Vkeys[i];
if (cmd.Vkey == FSPVKeyBase.GAME_BEGIN)
{
Handle_GameBegin(cmd.Args[0]);
}
else if (cmd.Vkey == FSPVKeyBase.ROUND_BEGIN)
{
Handle_RoundBegin(cmd.Args[0]);
}
else if (cmd.Vkey == FSPVKeyBase.CONTROL_START)
{
Handle_ControlStart(cmd.Args[0]);
}
else if (cmd.Vkey == FSPVKeyBase.ROUND_END)
{
Handle_RoundEnd(cmd.Args[0]);
}
else if (cmd.Vkey == FSPVKeyBase.GAME_END)
{
Handle_GameEnd(cmd.Args[0]);
}
else if (cmd.Vkey == FSPVKeyBase.GAME_EXIT)
{
Handle_GameExit(cmd.PlayerIdOrClientFrameId);
}
}
}
//再将其它VKey抛给外界处理
if (m_FrameListener != null)
{
m_FrameListener(frameId, frame);
}
}
/// <summary>
/// execute a frame
/// </summary>
/// <param name="frameId"></param>
/// <param name="frame"></param>
private void ExecuteFrame(int frameId, FSPFrame frame)
{
//handle game state Vkey first
if (frame != null && frame.vkeys != null)
{
for (int i = 0; i < frame.vkeys.Count; i++)
{
FSPVKey cmd = frame.vkeys[i];
if (cmd.vkey == FSPVKeyBase.GAME_BEGIN)
{
Handle_GameBegin(cmd.args[0]);
}
else if (cmd.vkey == FSPVKeyBase.ROUND_BEGIN)
{
Handle_RoundBegin(cmd.args[0]);
}
else if (cmd.vkey == FSPVKeyBase.CONTROL_START)
{
Handle_ControlStart(cmd.args[0]);
}
else if (cmd.vkey == FSPVKeyBase.ROUND_END)
{
Handle_RoundEnd(cmd.args[0]);
}
else if (cmd.vkey == FSPVKeyBase.GAME_END)
{
Handle_GameEnd(cmd.args[0]);
}
else if (cmd.vkey == FSPVKeyBase.GAME_EXIT)
{
Handle_GameExit(cmd.playerId);
}
}
}
//other Virtual key can be handled by game manager
if (mFrameListener != null)
{
mFrameListener(frameId, frame);
}
}
private bool SendInternal(FSPFrame frame)
{
if (frame.frameId != 0 && frame.frameId <= m_LastAddFrameId)
{
//已经Add过了
return(true);
}
if (m_session != null)
{
if (m_session.Send(frame))
{
m_LastAddFrameId = frame.frameId;
return(true);
}
}
return(false);
}
/// <summary>
/// to be compatible with local, like PVE mode can also use Frame Synchronization Protocol
/// </summary>
/// <param name="vkey"></param>
/// <param name="arg"></param>
private void SendFSPLocal(int vkey, int arg = 0)
{
MyLogger.Log(LOG_TAG, "SendFSPLocal() vkey={0}, arg={1}", vkey.ToString(), arg);
int nextFrameId = mCurrentFrameIndex + 1;
if (mNextLocalFrame == null || mNextLocalFrame.frameId != nextFrameId)
{
mNextLocalFrame = new FSPFrame();
mNextLocalFrame.frameId = nextFrameId;
mNextLocalFrame.vkeys = new List <FSPVKey>();
mFrameBuffer.Add(mNextLocalFrame.frameId, mNextLocalFrame);
}
FSPVKey cmd = new FSPVKey();
cmd.vkey = vkey;
cmd.args = new int[] { arg };
cmd.playerId = mMinePlayerId;
mNextLocalFrame.vkeys.Add(cmd);
}
void AddServerFrame(FSPFrame frame)
{
// 一些状态事件，没有frameId的
if (frame.frameId <= 0)
{
ExecuteFrame(frame.frameId, frame);
return;
}
// 客户端的帧率比服务端的要大，这边需要转换一下，等于说
// 客户端的帧序列其实是：0 1 0 1 0 1 0 1...
// 1是服务器下发的实际帧，0是客户端自己插入的空帧，具体有几个0由clientFrameRateMultiple决定
// 服务器逻辑帧一般是15帧，即帧间隔是66.666667ms，因为客户端设置一般是30帧或60帧，刚好是倍数关系，方便计算。
frame.frameId = frame.frameId * m_Param.clientFrameRateMultiple;
// 客户端逻辑能到的最大帧，除了服务器最大帧，还可以加上客户端自己插入的空白帧。
m_ClientLockedFrame = frame.frameId + (m_Param.clientFrameRateMultiple - 1);
// 记录最新的帧数据
m_FrameBuffer[frame.frameId] = frame;
m_Controller.AddFrameId(frame.frameId);
}
public int SendToClient(FSPFrame frame)
{
if (frame != null)
{
if (!m_FrameCache.Contains(frame))
{
m_FrameCache.Enqueue(frame);
}
}
while (m_FrameCache.Count > 0)
{
if (TryAddToSession(m_FrameCache.Peek()))
{
m_FrameCache.Dequeue();
}
else
{
return(-1);
}
}
return(1);
}
/// <summary>
/// invoked by external
/// </summary>
public void EnterFrame()
{
if (!mIsRunning)
{
return;
}
if (!mParam.useLocal)
{
mClient.EnterFrame();
int speed = mFrameCtrl.GetFrameSpeed(mCurrentFrameIndex);
while (speed > 0)
{
if (mCurrentFrameIndex < mClientLockedFrame)
{
mCurrentFrameIndex++;
FSPFrame frame = mFrameBuffer[mCurrentFrameIndex];
ExecuteFrame(mCurrentFrameIndex, frame);
}
speed--;
}
//add pre effect here
}
else
{
if (mClientLockedFrame == 0 || mCurrentFrameIndex < mClientLockedFrame)
{
mCurrentFrameIndex++;
FSPFrame frame = mFrameBuffer[mCurrentFrameIndex];
ExecuteFrame(mCurrentFrameIndex, frame);
}
}
}
/// <summary>
/// 由外界驱动
/// </summary>
public void EnterFrame()
{
if (!m_IsRunning)
{
return;
}
if (!m_Param.UseLocal)
{
m_Client.EnterFrame();
int speed = m_FrameCtrl.GetFrameSpeed(m_CurrentFrameIndex);
while (speed > 0)
{
if (m_CurrentFrameIndex < m_ClientLockedFrame)
{
m_CurrentFrameIndex++;
FSPFrame frame = m_FrameBuffer[m_CurrentFrameIndex];
ExecuteFrame(m_CurrentFrameIndex, frame);
}
speed--;
}
//这里可能加预表现
}
else
{
if (m_ClientLockedFrame == 0 || m_CurrentFrameIndex < m_ClientLockedFrame)
{
m_CurrentFrameIndex++;
FSPFrame frame = m_FrameBuffer[m_CurrentFrameIndex];
ExecuteFrame(m_CurrentFrameIndex, frame);
}
}
}
/// <summary>
/// 监听来自FSPClient的帧数据
/// </summary>
/// <param name="frame"></param>
private void OnFSPListener(FSPFrame frame)
{
AddServerFrame(frame);
}
//---------------------------------------------------------
/// <summary>
/// enter frame
/// </summary>
public void EnterFrame()
{
//delete exited players
for (int i = 0; i < mPlayersExitOnNextFrameList.Count; i++)
{
FSPPlayer player = mPlayersExitOnNextFrameList[i];
FSPServer.Instance.DelSession(player.Sid);
player.Dispose();
}
mPlayersExitOnNextFrameList.Clear();
//hand game state
HandleGameState();
//check if game state changes
if (mState == FSPGameState.None)
{
return;
}
if (mLockedFrame.frameId != 0 || !mLockedFrame.IsEmpty())
{
//send frame to players
for (int i = 0; i < mPlayerList.Count; i++)
{
FSPPlayer player = mPlayerList[i];
player.SendToClient(mLockedFrame);
if (player.WaitForExit)
{
mPlayersExitOnNextFrameList.Add(player);
mPlayerList.RemoveAt(i);
--i;
}
}
}
//clear frame 0 in each iteration
if (mLockedFrame.frameId == 0)
{
mLockedFrame = new FSPFrame();
//delay GC
if (UseDelayGC)
{
mListObjectsForDelayGC.Add(mLockedFrame);
}
}
//add up frame id
if (mState == FSPGameState.RoundBegin || mState == FSPGameState.ControlStart)
{
mCurFrameId++;
mLockedFrame = new FSPFrame();
mLockedFrame.frameId = mCurFrameId;
//防止GC
if (UseDelayGC)
{
mListObjectsForDelayGC.Add(mLockedFrame);
}
}
}
