/// <summary>
///
/// </summary>
/// <param name="netState"></param>
/// <param name="packetReader"></param>
internal static void Realm_HandleRegisterRealmResult(NetState netState, PacketReader packetReader)
{
RealmExtendData extendData = netState.GetComponent <RealmExtendData>(RealmExtendData.COMPONENT_ID);
if (extendData == null)
{
Debug.WriteLine("Realm_PacketHandlers.Realm_HandleRegisterRealmResult(...) - extendData == null error!");
return;
}
if (extendData.IsLoggedIn == true)
{
Debug.WriteLine("Realm_PacketHandlers.Realm_HandleRegisterRealmResult(...) - extendData.IsLoggedIn == true error!");
return;
}
uint iRealmSerial = packetReader.ReadUInt32();
extendData.RegisterRealmResult.Serial = new Serial(iRealmSerial);
// 已经登陆
extendData.IsLoggedIn = true;
// 3分钟 向服务端发一次心跳信号
TimeSlice.StartTimeSlice(TimerPriority.Lowest, TimeSpan.FromMinutes(3), TimeSpan.FromMinutes(3), new TimeSliceCallback(SendPing));
LOGs.WriteLine(LogMessageType.MSG_INFO, "RealmServer：登陆RealmServer服务器成功 返回的标示ID({0})", extendData.RegisterRealmResult.Serial.ToString());
}
/// <summary>
///
/// </summary>
public static void StartLoadAccountTimeSlice()
{
s_UnitOfWork.Connection = new SqlConnection(OneDatabase.ConnectionURL);
s_UnitOfWork.AutoCreateOption = AutoCreateOption.SchemaOnly;
ReloadAccount();
TimeSlice.StartTimeSlice(TimerPriority.Lowest, s_RefreshAccountTimeSpan, s_RefreshAccountTimeSpan, new TimeSliceCallback(WowAccountHandler.ReloadAccount));
}
/// <summary>
/// 开始运行数据保存的时间片
/// </summary>
internal void StartSaveTimeSlice()
{
if (m_LockSaveTimeSlice.InLock() == false)
{
return;
}
// 启动BaseWorld保存数据的时间片
m_SaveTimeSlice = TimeSlice.StartTimeSlice(m_SaveTimeSpan, m_SaveTimeSpan, new TimeSliceCallback(this.OnSave));
}
public void StartTimeSliceTest10()
{
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSliceCallback timerCallback = null; // TODO: 初始化为适当的值
TimeSlice expected = null; // TODO: 初始化为适当的值
TimeSlice actual;
actual = TimeSlice.StartTimeSlice(delayTimeSpan, timerCallback);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
/// <summary>
/// 初始化在线状态的检查
/// </summary>
internal void StartCheckAllAliveTime()
{
if (m_LockCheckAlive.InLock() == false)
{
return;
}
// 检测用户是否超时
// 创建检测用户是否超时的时间片(默认5分钟)
m_CheckAliveTimeSlice = TimeSlice.StartTimeSlice(TimerPriority.Lowest, m_CheckAliveTime, m_CheckAliveTime, new TimeSliceCallback(this.CheckAllAlive));
}
/// <summary>
///StartTimeSlice 的测试
///</summary>
public void StartTimeSliceTest6Helper <T>()
{
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSliceStateCallback <T> timerStateCallback = null; // TODO: 初始化为适当的值
T tState = default(T); // TODO: 初始化为适当的值
TimeSlice expected = null; // TODO: 初始化为适当的值
TimeSlice actual;
actual = TimeSlice.StartTimeSlice <T>(delayTimeSpan, timerStateCallback, tState);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void StartTimeSliceTest7()
{
TimerPriority processPriority = new TimerPriority(); // TODO: 初始化为适当的值
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSpan intervalTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSliceCallback timerCallback = null; // TODO: 初始化为适当的值
TimeSlice expected = null; // TODO: 初始化为适当的值
TimeSlice actual;
actual = TimeSlice.StartTimeSlice(processPriority, delayTimeSpan, intervalTimeSpan, timerCallback);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void StartTimeSliceTest17()
{
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSpan intervalTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSliceStateCallback timerStateCallback = null; // TODO: 初始化为适当的值
object tState = null; // TODO: 初始化为适当的值
TimeSlice expected = null; // TODO: 初始化为适当的值
TimeSlice actual;
actual = TimeSlice.StartTimeSlice(delayTimeSpan, intervalTimeSpan, timerStateCallback, tState);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
/// <summary>
/// 开始更新世界
/// </summary>
public void StartUpdateWorld(TimeSpan updateWorldSpeed)
{
m_UpdateWorldSpeed = updateWorldSpeed;
if (m_UpdateWorldTimeSlice != null)
{
m_UpdateWorldTimeSlice.IntervalTime = m_UpdateWorldSpeed; // 如果存在了就只改变间隔时间
}
else
{
// 启动更新世界的时间片
m_UpdateWorldTimeSlice = TimeSlice.StartTimeSlice(m_UpdateWorldSpeed, new TimeSliceCallback(this.OnUpdateWorld));
}
}
/// <summary>
///StartTimeSlice 的测试
///</summary>
public void StartTimeSliceTest4Helper <T>()
{
TimerPriority processPriority = new TimerPriority(); // TODO: 初始化为适当的值
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSpan intervalTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
long iCount = 0; // TODO: 初始化为适当的值
TimeSliceStateCallback <T> timerStateCallback = null; // TODO: 初始化为适当的值
T tState = default(T); // TODO: 初始化为适当的值
TimeSlice expected = null; // TODO: 初始化为适当的值
TimeSlice actual;
actual = TimeSlice.StartTimeSlice <T>(processPriority, delayTimeSpan, intervalTimeSpan, iCount, timerStateCallback, tState);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
/// <summary>
/// 清理当前的网络数据,并断开连接
/// </summary>
/// <param name="bFlush"></param>
public void Dispose(bool bFlush, long iSeconds)
{
// 防止多线程时多次调用Dispose(...)有问题
if (m_Disposed.SetInvalid() == false)
{
return;
}
if (bFlush == true)
{
this.Flush();
TimeSlice.StartTimeSlice(TimeSpan.FromSeconds(iSeconds), new TimeSliceCallback(this.InsideDispose));
}
else
{
this.InsideDispose();
}
}
/// <summary>
/// 清理当前的网络数据,并断开连接
/// </summary>
/// <param name="bFlush"></param>
public void Dispose(bool bFlush, long waitSeconds)
{
// 防止多线程时多次调用Dispose(...)有问题
if (m_Disposed.SetInvalid() == false)
{
return;
}
if (bFlush == true)
{
Flush();
TimeSlice.StartTimeSlice(TimeSpan.FromSeconds(waitSeconds), InsideDispose);
}
else
{
InsideDispose();
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="eventArgs"></param>
public void InitMap(object sender, MapEventArgs eventArgs)
{
eventArgs.Map.MapRectangle = new Rectangle3D(-17067.0f, -17067.0f, -17067.0f, 17067.0f, 17067.0f, 17067.0f);
m_CheckDeactivateSlice = TimeSlice.StartTimeSlice(m_CheckDeactivateTimeSpan, m_CheckDeactivateTimeSpan, new TimeSliceCallback(this.CheckDeactivateSpaceNode));
}
/// <summary>
/// 时间片的处理
/// </summary>
internal void Slice()
{
// 检查有多少新的连接用户
CheckListener();
// 检查有多少新的连出用户
CheckConnecter();
NetState netState = null;
if (m_NetStateQueue.TryDequeue(out netState) == false)
{
return;
}
// 如果没有需要处理的数据则返回
if (netState == null)
{
return;
}
// 处理接收到的数据
if (netState.Running == true)
{
ReceiveQueue receiveQueueBuffer = netState.ReceiveBuffer;
if (receiveQueueBuffer == null)
{
throw new ArgumentNullException("receiveQueueBuffer", "MessagePump.Slice(...) - receiveQueueBuffer == null error!");
}
// 检测是否已经在处理数据中,防止多线程中多次处理里面的数据
if (receiveQueueBuffer.InProcessReceive() == false)
{
return;
}
// 累积过多，会导致线程堵塞，全都在处理自我的数据包逻辑
if (netState.ReceiveBuffer.Length >= netState.ReceiveCachedMaxSize)
{
netState.Dispose();
// 需要注释
Logs.WriteLine(true, LogMessageType.MSG_WARNING, "NetState[{0}] Receive(...) - ReceiveBufferLength[{1}] >= ReceiveCachedMaxSize[{2}] warning (接收缓存的数据包过大)!", ToString(), netState.SendQueue.WaitSendSize, netState.ReceiveCachedMaxSize);
}
else
{
OnProcessReceive(netState);
}
// 已经结束处理
receiveQueueBuffer.OutProcessReceive();
}
// 表示当前已不再处理列表中(减少处理列表的长度)
netState.OutProcessQueue();
// 再次检测是否还有没处理完接受到的数据,如果有,再次进入处理列表(可能是半包或还有没来得急处理的数据,等待数据的完整,1秒以后再次处理,仅调用一次)
if (netState.Running == true)
{
if (netState.ReceiveBuffer.Length > 0)
{
TimeSlice.StartTimeSlice(TimeSpan.FromSeconds(1.0), OnceAgainReceive, netState);
}
}
// 有数据过来需要发送全局信号处理数据包
if (m_NetStateQueue.IsEmpty == false)
{
m_World.SendWorldSignal();
}
}
/// <summary>
/// 时间片的处理
/// </summary>
internal void Slice()
{
// 检查有多少新的连接用户
CheckListener();
// 检查有多少新的连出用户
CheckConnecter();
NetState[] netStateArray = null;
// 转换成数组减少lock处理的时间
m_LockNetStateQueue.Enter();
{
do
{
if (m_NetStateQueue.Count == 0)
{
break;
}
netStateArray = m_NetStateQueue.ToArray();
// 清空数据,下面处理这些数据
m_NetStateQueue.Clear();
} while (false);
}
m_LockNetStateQueue.Exit();
// 如果没有需要处理的数据则返回
if (netStateArray == null)
{
return;
}
// 处理接收到的数据
for (int iIndex = 0; iIndex < netStateArray.Length; iIndex++)
{
NetState netState = netStateArray[iIndex];
if (netState.Running == true)
{
ReceiveQueue receiveQueueBuffer = netState.ReceiveBuffer;
if (receiveQueueBuffer == null)
{
throw new Exception("MessagePump.Slice(...) - receiveQueueBuffer == null error!");
}
// 检测是否已经在处理数据中,防止多线程中多次处理里面的数据
if (receiveQueueBuffer.InProcessReceive() == false)
{
continue;
}
OnProcessReceive(netState);
// 已经结束处理
receiveQueueBuffer.OutProcessReceive();
}
// 表示当前已不再处理列表中(减少处理列表的长度)
netState.OutProcessQueue();
// 再次检测是否还有没处理完接受到的数据,如果有,再次进入处理列表(可能是半包或还有没来得急处理的数据,等待数据的完整,1秒以后再次处理,仅调用一次)
if (netState.Running == true)
{
if (netState.ReceiveBuffer.Length > 0)
{
TimeSlice.StartTimeSlice(TimeSpan.FromSeconds(1.0), new TimeSliceStateCallback <NetState>(this.OnceAgainReceive), netState);
}
}
}
}
/// <summary>
/// 地图点激活
/// </summary>
public virtual void OnSpaceNodeActivate()
{
m_SpaceNodeActivateTimeSlice = TimeSlice.StartTimeSlice(TimeSpan.FromMilliseconds(1000), SpaceNodeActivateCallback);
}
