public void SendRoleData(string _Acc)
{
GetRolesList szGetRolesList = new GetRolesList();
szGetRolesList.Acc = _Acc;
szGetRolesList.ZoneID = 0;
MemoryStream msResult = new MemoryStream();
Serializer.Serialize <GetRolesList>(msResult, szGetRolesList);
byte[] msSendData = msResult.ToArray();
TCPOutPacket szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_GSNetClient.OutPacketPool, msSendData, 0, msSendData.Length, (int)CommandID.CMD_GET_ROLE_LIST);
if (m_GSNetClient.SendData(szTCPOutPacket))
{
SysConOut.WriteLine("发送获取角色列表数据成功");
}
else
{
SysConOut.WriteLine("发送获取角色列表数据失败");
}
//TCPOutPacket szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_tcpOutPacketPool,
// StringUtil.substitute("{0}:{1}", _Acc, "0"),
// (int)TCPServerCmds.CMD_ROLE_LIST);
//if (m_GSNetClient.SendData(szTCPOutPacket))
// SysConOut.WriteLine("发送获取角色列表数据成功");
//else
// SysConOut.WriteLine("发送获取角色列表数据失败");
m_GSNetClient.OutPacketPool.Push(szTCPOutPacket);
}
public TCPProcessCmdResults AttchFun(TCPManager tcpMgr, TMSKSocket socket, TCPClientPool tcpClientPool, TCPRandKey tcpRandKey,
TCPOutPacketPool pool, int nID, byte[] data, int count, out TCPOutPacket tcpOutPacket)
{
TCPProcessCmdResults result = TCPProcessCmdResults.RESULT_FAILED;
tcpOutPacket = null;
try
{
if (m_FunInsinuate.ContainsKey(nID))
{
result = m_FunInsinuate[nID](tcpMgr, socket, tcpClientPool, tcpRandKey, pool, nID, data, count, out tcpOutPacket);
}
else
{
SysConOut.WriteLine("收到APP数据，但没找到隐射函数");
}
GameClient client = GameManager.ClientMgr.FindClient(socket);
if (null != client)
{
client.ClientData.LastClientHeartTicks = TimeUtil.NOW();
}
}
catch (Exception ex)
{
SysConOut.WriteLine("AttchFun****************" + ex.ToString());
}
return(result);
}
public void SendPlayGame(string _RoleID)
{
PlayGame szPlayGame = new PlayGame();
szPlayGame.RoleID = Convert.ToInt32(_RoleID);
MemoryStream msResult = new MemoryStream();
Serializer.Serialize <PlayGame>(msResult, szPlayGame);
byte[] msSendData = msResult.ToArray();
TCPOutPacket szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_GSNetClient.OutPacketPool, msSendData, 0, msSendData.Length, (int)CommandID.CMD_PLAY_GAME);
if (m_GSNetClient.SendData(szTCPOutPacket))
{
SysConOut.WriteLine("发送进入游戏成功");
}
else
{
SysConOut.WriteLine("发送进入游戏失败");
}
//TCPOutPacket szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_tcpOutPacketPool, StringUtil.substitute("{0}", _RoleID),
// (int)TCPServerCmds.CMD_PLAY_GAME);
//if (m_GSNetClient.SendData(szTCPOutPacket))
// SysConOut.WriteLine("发送进入游戏成功");
//else
// SysConOut.WriteLine("发送进入游戏失败");
m_GSNetClient.OutPacketPool.Push(szTCPOutPacket);
}
//public static bool SendNetObject<T>(this T obj, CommandID cmd)
//where T : global::ProtoBuf.IExtensible
//{
// int cmdID = (int)cmd;
// try
// {
// using (MemoryStream ms = new MemoryStream())
// {
// Serializer.Serialize<T>(ms, obj);
// byte[] datas = ms.ToArray();//序列化结果
// TCPOutPacket packet = TCPOutPacket.MakeTCPOutPacket(
// Sender.tcpOutPacketPool,
// datas, 0, datas.Length,
// cmdID
// );
// return Sender.SendData(packet);
// }
// }
// catch (Exception e)
// {
// Debug.LogError(e.Message);
// return false;
// }
//}
public void SendInitGame(string _Acc, string _RoleID)
{
InitialGame szInitialGame = new InitialGame();
szInitialGame.Acc = _Acc;
szInitialGame.RoleID = Convert.ToInt32(_RoleID);
MemoryStream msResult = new MemoryStream();
Serializer.Serialize <InitialGame>(msResult, szInitialGame);
byte[] msSendData = msResult.ToArray();
TCPOutPacket szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_GSNetClient.OutPacketPool, msSendData, 0, msSendData.Length, (int)CommandID.CMD_INIT_GAME);
if (m_GSNetClient.SendData(szTCPOutPacket))
{
SysConOut.WriteLine("发送初始化游戏成功");
}
else
{
SysConOut.WriteLine("发送初始化游戏失败");
}
//TCPOutPacket szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_tcpOutPacketPool,
// StringUtil.substitute("{0}:{1}:{2}", _Acc, _RoleID, "0"), (int)TCPServerCmds.CMD_INIT_GAME);
//if (m_GSNetClient.SendData(szTCPOutPacket))
// SysConOut.WriteLine("发送初始化游戏成功");
//else
//{
// SysConOut.WriteLine("发送初始化游戏失败 连接状态 = " + m_GSNetClient.Connected.ToString());
//}
m_GSNetClient.OutPacketPool.Push(szTCPOutPacket);
}
public static void LoadConfig()
{
string fileName = "Config/GameFuncControl.xml";
string fullPathFileName = Global.GameResPath(fileName);
XElement xml = null;
try
{
xml = XElement.Load(fullPathFileName);
}
catch (Exception)
{
return;
}
XElement args = xml.Element("GameFunc");
if (null != args)
{
IEnumerable <XElement> xmlItems = args.Elements();
foreach (var xmlItem in xmlItems)
{
int Effective = (int)Global.GetSafeAttributeLong(xmlItem, "Effective");
if (0 == Effective)
{
int TypeID = (int)Global.GetSafeAttributeLong(xmlItem, "TypeID");
GameFuncTypeList.Add(TypeID);
string Description = Global.GetSafeAttributeStr(xmlItem, "Description");
SysConOut.WriteLine(string.Format("{0}所有功能已屏蔽", Description));
}
}
}
}
/// <summary>
/// 在多个线程内部循环调用
/// </summary>
public void ProcessCmdPackets(Queue <CmdPacket> ls)
{
//dictInPackets.Values值的个数可能会变化，每次处理先保存好最大个数
//同时给出20个冗余数量
int maxCount = dictInPackets.Values.Count + 20;
for (int n = 0; n < maxCount; n++)
{
TCPInPacket tcpInPacket = GetNextTcpInPacket(n);
//这意味着列表数据包变少了
if (null == tcpInPacket)
{
break;
}
ls.Clear();
if (tcpInPacket.PopCmdPackets(ls)) //判断是否取到了指令列表
{
try
{
while (ls.Count > 0)
{
CmdPacket cmdPacket = ls.Dequeue();
//接收到了完整的命令包
TCPOutPacket tcpOutPacket = null;
TCPProcessCmdResults result = TCPProcessCmdResults.RESULT_FAILED;
result = TCPCmdHandler.ProcessCmd(this, tcpInPacket.CurrentSocket, tcpClientPool, tcpRandKey, tcpOutPacketPool, cmdPacket.CmdID, cmdPacket.Data, cmdPacket.Data.Length, out tcpOutPacket);
if (result == TCPProcessCmdResults.RESULT_DATA && null != tcpOutPacket)
{
//向登陆客户端返回数据
socketListener.SendData(tcpInPacket.CurrentSocket, tcpOutPacket);
}
else if (result == TCPProcessCmdResults.RESULT_FAILED)//解析失败, 直接关闭连接
{
if (cmdPacket.CmdID != (int)TCPGameServerCmds.CMD_LOG_OUT)
{
LogManager.WriteLog(LogTypes.Error, string.Format("解析并执行命令失败: {0},{1}, 关闭连接", (TCPGameServerCmds)tcpInPacket.PacketCmdID, Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket)));
}
SysConOut.WriteLine("========================ProcessCmdPackets CloseSocket================");
// Console.WriteLine("========================ProcessCmdPackets CloseSocket================");
//这儿需要关闭链接--->这样关闭对吗?
socketListener.CloseSocket(tcpInPacket.CurrentSocket);
break;
}
}
}
finally
{
//处理结束之后设置相关标志位
tcpInPacket.OnThreadDealingComplete();
}
}
}
}
private static void OnTimedEvent(object source)
{
ScheduleTask task = source as ScheduleTask;
if (task is MonsterTask)
{
MonsterTask monsterTask = task as MonsterTask;
if (monsterTask.mapCode == 1)
{
long ticks1 = TimeUtil.NOW();
SysConOut.WriteLine("----------------------------------时间触发器时间间隔----------------------------" + (ticks1 - ScheduleExecutor2.Instance.Oldticks).ToString());
ScheduleExecutor2.Instance.Oldticks = ticks1;
}
}
if (task.InternalLock.TryEnter())
{
bool logRunTime = false;
long nowTicks = TimeUtil.CurrentTicksInexact;
try
{
task.run();
}
catch (System.Exception ex)
{
LogManager.WriteLog(LogTypes.Error, string.Format("{0}执行时异常,{1}", task.ToString(), ex.ToString()));
}
finally
{
logRunTime = task.InternalLock.Leave();
}
if (logRunTime)
{
long finishTicks = TimeUtil.CurrentTicksInexact;
if (finishTicks - nowTicks > TimeUtil.SECOND)
{
try
{
MonsterTask monsterTask = task as MonsterTask;
if (null != monsterTask)
{
LogManager.WriteLog(LogTypes.Error, string.Format("{0} mapCode:{1},subMapCode:{2},执行时间:{3}毫秒"
, task.ToString(), monsterTask.mapCode, monsterTask.subMapCode, finishTicks - nowTicks));
}
else
{
LogManager.WriteLog(LogTypes.Error, string.Format("{0}执行时间:{1}毫秒", task.ToString(), finishTicks - nowTicks));
}
}
catch
{
//写日志异常就不记了
}
}
}
}
}
public void work()
{
lock (Worker._lock)
{
Worker.nThreadCount++;
this.nThreadOrder = Worker.nThreadCount;
}
TaskWrapper taskWrapper = null;
int lastTickCount = int.MinValue;
while (!Program.NeedExitServer)
{
int tickCount = Environment.TickCount;
if (tickCount <= lastTickCount + 5)
{
if (lastTickCount <= 0 || tickCount >= 0)
{
Thread.Sleep(5);
continue;
}
}
lastTickCount = tickCount;
long ticks = TimeUtil.NOW();
for (;;)
{
try
{
taskWrapper = this.getCanExecuteTask(ticks);
if (taskWrapper == null || null == taskWrapper.CurrentTask)
{
break;
}
if (taskWrapper.canExecute)
{
try
{
taskWrapper.CurrentTask.run();
}
catch (Exception ex)
{
DataHelper.WriteFormatExceptionLog(ex, "异步调度任务执行异常", false, false);
}
}
if (taskWrapper.Periodic > 0L && taskWrapper.canExecute)
{
taskWrapper.resetStartTime();
this.executor.addTask(taskWrapper);
taskWrapper.addExecuteCount();
}
}
catch (Exception)
{
}
}
}
SysConOut.WriteLine(string.Format("ScheduleTask Worker{0}退出...", this.nThreadOrder));
}
/// <summary>
/// 接收数据通知函数
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private bool SocketReceived(object sender, SocketAsyncEventArgs e)
{
try
{
SocketListener sl = sender as SocketListener;
TCPInPacket tcpInPacket = null;
AsyncUserToken userToken = (e.UserToken as AsyncUserToken);
TMSKSocket s = userToken.CurrentSocket;
if (GameManager.FlagOptimizeLock)
{
tcpInPacket = s._TcpInPacket;
if (null == tcpInPacket)
{
lock (dictInPackets) //锁定接收包队列
{
if (!dictInPackets.TryGetValue(s, out tcpInPacket))
{
tcpInPacket = tcpInPacketPool.Pop(s, TCPCmdPacketEvent);
dictInPackets[s] = tcpInPacket;
}
}
s._TcpInPacket = tcpInPacket;
}
}
else
{
lock (dictInPackets) //锁定接收包队列
{
if (!dictInPackets.TryGetValue(s, out tcpInPacket))
{
tcpInPacket = tcpInPacketPool.Pop(s, TCPCmdPacketEvent);
dictInPackets[s] = tcpInPacket;
}
}
}
//处理收到的包
if (!tcpInPacket.WriteData(e.Buffer, e.Offset, e.BytesTransferred))
{
SysConOut.WriteLine(string.Format("接收到非法数据长度的tcp命令, 需要立即断开! {0} {1}", e.Offset, e.BytesTransferred));
//LogManager.WriteLog(LogTypes.Error, string.Format("接收到非法数据长度的tcp命令, 需要立即断开!"));
return(false);
}
}
catch (Exception ex)
{
SysConOut.WriteLine("SocketReceived 异常-------------------" + ex.Message);
}
return(true);
}
public void SendMovePosition()
{
try
{
long tickTime = DateTime.Now.Ticks;
SpriteMovePosition szSpriteMovePosition = new SpriteMovePosition();
szSpriteMovePosition.RoleID = Convert.ToInt32(g_RoleID);
szSpriteMovePosition.MapCode = 1001;
szSpriteMovePosition.action = 2;
szSpriteMovePosition.ToMapX = 22500;
szSpriteMovePosition.ToMapY = 24300;
//szSpriteMove.Movec = moveData.moveCost;
szSpriteMovePosition.ToDiection = 2;
szSpriteMovePosition.clientTicks = 1;
MemoryStream msResult = new MemoryStream();
Serializer.Serialize <SpriteMovePosition>(msResult, szSpriteMovePosition);
byte[] msSendData = msResult.ToArray();
TCPOutPacket szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_GSNetClient.OutPacketPool, msSendData, 0, msSendData.Length,
(int)CommandID.CMD_POSITION_MOVE);
if (!m_GSNetClient.SendData(szTCPOutPacket))
{
SysConOut.WriteLine("发送移位置数据失败");
g_Thread.Abort();
g_Thread = null;
}
m_GSNetClient.OutPacketPool.Push(szTCPOutPacket);
msResult.Dispose();
//long tickTime = DateTime.Now.Ticks;
//var szMove = new SpriteMoveData(Convert.ToInt32(g_RoleID), 1, 2, 2520, 4600, 2, 2840, 4840, tickTime, "1(1,35,60):(1,31,57)");
//TCPOutPacket szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_tcpOutPacketPool, szMove.toBytes(), 0, szMove.toBytes().Length,
// (int)TCPServerCmds.CMD_SPR_MOVE);
//if (!m_GSNetClient.SendData(szTCPOutPacket))
//{
// SysConOut.WriteLine("发送移动数据失败");
// g_Thread.Abort();
// g_Thread = null;
//}
//m_tcpOutPacketPool.Push(szTCPOutPacket);
}
catch (Exception ex)
{
SysConOut.WriteLine(ex.Message);
}
}
public void SendLoginData()
{
TCPOutPacket szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_GSNetClient.OutPacketPool,
StringUtil.substitute("{0}:{1}:{2}:{3}:{4}:{5}", "20191113", g_Acc, g_psw, 1, 1, 1),
(int)TCPServerCmds.CMD_LOGIN_ON1);
if (m_LNetClient.SendData(szTCPOutPacket))
{
SysConOut.WriteLine("发送登陆数据成功");
}
else
{
SysConOut.WriteLine("发送登陆数据失败");
}
m_GSNetClient.OutPacketPool.Push(szTCPOutPacket);
}
public void print()
{
string str = string.Format("接收统计,接收失败={1},成功={2}, Time={5},平均={6}", new object[]
{
0,
this.receiveErrNum,
this.receiveSuNum,
0,
0,
(this.endTime - this.startTime).TotalMilliseconds,
Math.Truncate(100.0 * (this.endTime - this.startTime).TotalMilliseconds / (double)(this.receiveErrNum + this.receiveSuNum)) / 100.0
});
Console.ForegroundColor = ConsoleColor.Red;
SysConOut.WriteLine(str);
Console.ForegroundColor = ConsoleColor.White;
}
public static void stop(string cmd = null)
{
try
{
foreach (ThreadTimerModel item in S2KFCommunication.objList)
{
item.Stop();
}
TestReceiveModel.getInstance().stop();
while (!TcpCall.TestS2KFCommunication.SendData(1, false).IsReturn)
{
}
S2KFCommunication.stage = false;
Console.WriteLine("压测关闭");
double time = 0.0;
int receiveNum = 0;
int sendSuNum = 0;
int sendErrNum = 0;
foreach (ThreadTimerModel item in S2KFCommunication.objList)
{
item.print();
sendSuNum += item.sendSuNum;
sendErrNum += item.sendErrNum;
time += (item.endTime - item.startTime).TotalMilliseconds;
}
string str = string.Format("统计,发送失败={1},发送成功={2}, Time={4},平均={5}", new object[]
{
0,
sendErrNum,
sendSuNum,
receiveNum,
time / (double)S2KFCommunication.objList.Count,
time / (double)S2KFCommunication.objList.Count / (double)(sendSuNum + sendErrNum)
});
Console.ForegroundColor = ConsoleColor.Red;
SysConOut.WriteLine(str);
Console.ForegroundColor = ConsoleColor.White;
TestReceiveModel.getInstance().print();
}
catch (Exception ex)
{
LogManager.WriteException(ex.ToString());
Console.WriteLine("关闭失败 Exception");
}
}
// 程序启动和Reload的时候调用
public void LoadAllMonsterXml()
{
XElement tmpXml = null;
try
{
string Url = Global.GameResPath("Config/Monsters.xml");
SysConOut.WriteLine(Url);
tmpXml = XElement.Load(Url);
}
catch (Exception ex)
{
}
if (tmpXml != null)
{
this.AllMonstersXml = tmpXml;
}
}
/// <summary>
/// 直线移动
/// </summary>
public bool _LinearMove(Monster sprite, Point p, int action)
{
long ticks1 = TimeUtil.NOW();
//sprite.MoveToPos = p;
sprite.DestPoint = p;
bool ret = AStarMove(sprite, p, (int)action);
long ticks2 = TimeUtil.NOW();
///超过100豪秒记录
if (ticks2 > ticks1 + 100)
{
SysConOut.WriteLine(String.Format("_LinearMove 消耗:{0}毫秒, start({1}, {2}), to({3}, {4}), mapID={5}", ticks2 - ticks1, sprite.Coordinate.X, sprite.Coordinate.Y, p.X, p.Y, sprite.MonsterZoneNode.MapCode));
LogManager.WriteLog(LogTypes.Error, String.Format("_LinearMove 消耗:{0}毫秒, start({1}, {2}), to({3}, {4}), mapID={5}", ticks2 - ticks1, sprite.Coordinate.X, sprite.Coordinate.Y, p.X, p.Y, sprite.MonsterZoneNode.MapCode));
}
return(ret);
}
public static void LoadCallPetSystem()
{
lock (CallPetManager._CallPetMutex)
{
CallPetManager.CallPetPriceDict.Clear();
string[] strPrice = GameManager.systemParamsList.GetParamValueByName("CallPet").Split(new char[]
{
','
});
if (strPrice == null || strPrice.Length != 2)
{
SysConOut.WriteLine(" 加载SystemParams.xml时出错!!!CallPet不存在");
}
else
{
CallPetManager.CallPetPriceDict[1] = Convert.ToInt32(strPrice[0]);
CallPetManager.CallPetPriceDict[10] = Convert.ToInt32(strPrice[1]);
double nHour = GameManager.systemParamsList.GetParamValueDoubleByName("FreeCallPet", 0.0);
if (nHour <= 0.0)
{
SysConOut.WriteLine(" 加载SystemParams.xml时出错!!!FreeCallPet不存在");
}
else
{
CallPetManager.CallPetFreeHour = nHour;
double nTemp = GameManager.systemParamsList.GetParamValueDoubleByName("ConsumeCallPetJiFen", 0.0);
if (nTemp < 0.0)
{
SysConOut.WriteLine(" 加载SystemParams.xml时出错!!!ConsumeCallPetJiFen小于0");
}
else
{
CallPetManager.ConsumeCallPetJiFen = nTemp;
nTemp = GameManager.systemParamsList.GetParamValueDoubleByName("ZhaoHuan", 0.0);
if (nTemp < 0.0)
{
}
CallPetManager.CallPetGoodsID = (int)nTemp;
}
}
}
}
}
/// <summary>
/// 周期性任务
/// </summary>
/// <param name="task">任务</param>
/// <param name="delay">延迟开始时间（毫秒）</param>
/// <param name="periodic">间隔周期时间（毫秒）</param>
/// <returns></returns>
public void scheduleExecute(ScheduleTask task, int delay, int periodic)
{
if (periodic < 15 || periodic > 86400 * 1000)
{
throw new Exception("不正确的调度时间间隔periodic = " + periodic);
}
if (delay <= 0)
{
delay = periodic;
}
lock (this)
{
Timer timer;
if (!TimerDict.TryGetValue(task, out timer))
{
int szDuetime = Global.GetRandomNumber(delay / 2, delay * 3 / 2);
timer = new Timer(OnTimedEvent, task, szDuetime, periodic);
TimerDict.Add(task, timer);
if (task is MonsterTask)
{
MonsterTask monsterTask = task as MonsterTask;
if (monsterTask.mapCode == 1)
{
SysConOut.WriteLine(string.Format("Duetime = {0} periodic = {1}", szDuetime, periodic));
}
}
}
else
{
timer.Change(periodic, periodic);
if (task is MonsterTask)
{
MonsterTask monsterTask = task as MonsterTask;
if (monsterTask.mapCode == 1)
{
SysConOut.WriteLine(string.Format("periodic = {0} periodic = {1}", periodic, periodic));
}
}
}
}
}
public bool ConnectSer(string _LoginIP = "127.0.0.1", string _GameIP = "127.0.0.1", int _LPort = 4402, int _GSPort = 9929, int _key = 0)
{
if (!m_LNetClient.Connect(_LoginIP, _LPort))
{
return(false);
}
SysConOut.WriteLine("连接登陆服务器成功 IP=" + _LoginIP + " Port = " + _LPort.ToString());
if (m_GSNetClient != null && !m_GSNetClient.Connect(_GameIP, _GSPort))
{
m_ReConnectCount = 0;
m_LNetClient.Destroy();
return(false);
}
SysConOut.WriteLine("连接游戏服务器成功 IP=" + _GameIP + " Port = " + _GSPort.ToString());
m_Key = _key;
return(true);
}
public bool ProcessServerCmdHandler(TCPClient client, int nID, byte[] data, int count)
{
try
{
mutex.WaitOne();
TCPOutPacket szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_tcpOutPacketPool, data,
0, count, nID);
m_MoveDataList.Enqueue(szTCPOutPacket);
mutex.Release();
}
catch (Exception ex)
{
SysConOut.WriteLine(ex.Message);
}
return(true);
}
public bool KFCallMsgFunc(KFCallMsg msg)
{
try
{
int kuaFuEventType = msg.KuaFuEventType;
if (kuaFuEventType == 10041)
{
if (!this.flag)
{
this.receiveStopNum++;
TcpCall.TestS2KFCommunication.SendData(1, false);
if (this.receiveStopNum % 100 == 0)
{
Console.ForegroundColor = ConsoleColor.Red;
SysConOut.WriteLine(string.Format("结束服务器接收异步消息 {0}", this.receiveStopNum));
Console.ForegroundColor = ConsoleColor.White;
}
return(true);
}
string data = msg.Get <string>();
if (null != data)
{
this.receiveSuNum++;
}
else
{
this.receiveErrNum++;
}
if (this.receiveErrNum + this.receiveSuNum == 50000)
{
this.endTime = DateTime.Now;
}
}
}
catch (Exception ex)
{
LogManager.WriteLog(LogTypes.Exception, string.Format("[ljl_博彩]跨服消息{0}", ex.ToString()), null, true);
}
return(true);
}
/// <summary>
/// 加载精灵类型控件
/// </summary>
/// <param name="sprite">引参:对象精灵</param>
/// <param name="roleID">角色ID</param>
/// <param name="roleSex">性别</param>
/// <param name="name">识别名</param>
/// <param name="sname">角色名</param>
/// <param name="life">当前生命值</param>
/// <param name="mana">当前魔法值</param>
/// <param name="level">等级</param>
/// <param name="experience">经验值</param>
/// <param name="buff">属性BUFF加/减持</param>
/// <param name="facesign">头像</param>
/// <param name="frameRange">各动作帧数</param>
/// <param name="effectiveFrame">各动作起效帧</param>
/// <param name="attackRange">物理攻击距离</param>
/// <param name="seekRange">索敌距离</param>
/// <param name="equipmentBody">衣服代号</param>
/// <param name="equipmentWeapon">武器代号</param>
/// <param name="coordinate">XY坐标</param>
/// <param name="direction">朝向</param>
/// <param name="holdWidth">朝向</param>
/// <param name="holdHeight">朝向</param>
private void LoadMonster(Monster monster, CMonsterZone monsterZone, CMonsterStaticInfo monsterInfo, int monsterType,
int roleID, string name, double life, double mana, Point coordinate, double direction, double moveSpeed, int attackRange)
{
monster.Name = name;
monster.MonsterZoneNode = monsterZone;
monster.MonsterInfo = monsterInfo;
monster.RoleID = roleID;
monster.VLife = life * 10000;//HX_SERVER FOR TEST
monster.VMana = mana;
monster.AttackRange = attackRange;
monster.Coordinate = coordinate;
monster.Direction = direction;
monster.MoveSpeed = moveSpeed;
monster.MonsterType = monsterType;
monster.CoordinateChanged += UpdateMonsterEvent;
SysConOut.WriteLine(string.Format("初始化怪物 {0}----{1}", monster.RoleID, monster.VLife));
//人为导致搜索的时间间隔错开
monster.NextSeekEnemyTicks = Global.MonsterSearchTimer + Global.GetRandomNumber(0, Global.MonsterSearchRandomTimer);
}
public void SendMove()
{
try
{
long tickTime = DateTime.Now.Ticks;
SpriteMove szSpriteMove = new SpriteMove();
szSpriteMove.RoleID = Convert.ToInt32(g_RoleID);
szSpriteMove.MapCode = 1;
szSpriteMove.action = 2;
szSpriteMove.toX = 22500;
szSpriteMove.toY = 32300;
//szSpriteMove.Movec = moveData.moveCost;
szSpriteMove.extAction = 2;
szSpriteMove.fromX = 2840;
szSpriteMove.fromY = 4840;
szSpriteMove.startMoveTicks = tickTime;
szSpriteMove.pathString = "1001(1,283,427):(1,283,427)";
MemoryStream msResult = new MemoryStream();
Serializer.Serialize <SpriteMove>(msResult, szSpriteMove);
byte[] msSendData = msResult.ToArray();
TCPOutPacket szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_GSNetClient.OutPacketPool, msSendData, 0, msSendData.Length,
(int)CommandID.CMD_GAME_MOVE);
if (null == szTCPOutPacket || !m_GSNetClient.SendData(szTCPOutPacket))
{
SysConOut.WriteLine("发送移动数据失败");
g_Thread.Abort();
g_Thread = null;
}
m_GSNetClient.OutPacketPool.Push(szTCPOutPacket);
//m_GSNetClient.NotifyRecvData()
msResult.Dispose();
}
catch (Exception ex)
{
SysConOut.WriteLine(ex.Message);
}
}
/// <summary>
/// 加载SystemParams.xml里的独立配置
/// </summary>
public static void LoadCallPetSystem()
{
lock (_CallPetMutex)
{
CallPetPriceDict.Clear();
string[] strPrice = GameManager.systemParamsList.GetParamValueByName("CallPet").Split(',');
if (null == strPrice || strPrice.Length != 2)
{
SysConOut.WriteLine(" 加载SystemParams.xml时出错!!!CallPet不存在");
return;
}
CallPetPriceDict[1] = Convert.ToInt32(strPrice[0]);
CallPetPriceDict[10] = Convert.ToInt32(strPrice[1]);
double nHour = GameManager.systemParamsList.GetParamValueDoubleByName("FreeCallPet");
if (nHour <= 0)
{
SysConOut.WriteLine(" 加载SystemParams.xml时出错!!!FreeCallPet不存在");
return;
}
CallPetFreeHour = nHour;
double nTemp = GameManager.systemParamsList.GetParamValueDoubleByName("ConsumeCallPetJiFen");
if (nTemp < 0)
{
SysConOut.WriteLine(" 加载SystemParams.xml时出错!!!ConsumeCallPetJiFen小于0");
return;
}
ConsumeCallPetJiFen = nTemp;
nTemp = GameManager.systemParamsList.GetParamValueDoubleByName("ZhaoHuan");
if (nTemp < 0)
{
//SysConOut.WriteLine(" 加载SystemParams.xml时出错!!!CallPetGoodsID小于0");
//return;
}
CallPetGoodsID = (int)nTemp;
}
}
/// <summary>
/// 向某个方向移动到目标附近
/// 移动可能失败,失败原因 1.相关位置不可走 2.相关位置已经有其他角色或者怪物
/// </summary>
/// <param name="nDir"></param>
/// <returns></returns>
public static Boolean WalkToObject(IObject obj, Dircetions nDir, IObject targetObj)
{
if (null == targetObj || null == obj)
{
return(false);
}
int nX, nY;
WalkNearPos(targetObj, nDir, out nX, out nY);
Point grid = obj.CurrentGrid;
int nCurrX = (int)grid.X;
int nCurrY = (int)grid.Y;
//String pathStr = String.Format("{0}_{1}|{2}_{3}", nCurrX, nCurrY, nX, nY);
String pathStr = String.Format("1({0},{1},{2}):({3},{4},{5})", (obj as Monster).CurrentMapCode, nCurrX, nCurrY, (obj as Monster).CurrentMapCode, nX, nY);//HX_SERVER (1,92,130):(1,102,135)
Boolean fResult = false;
if (targetObj is GameClient)
{
fResult = WalkXY(obj, nX, nY, nDir, pathStr, (targetObj as GameClient).ClientData.RoleID);
}
else
{
fResult = WalkXY(obj, nX, nY, nDir, pathStr);
}
if (fResult)
{
SysConOut.WriteLine(String.Format("追击 {0} Path: {1} ", (obj as Monster).RoleID, pathStr));
//System.Console.WriteLine(String.Format("{0} Path: {1} ", (obj as Monster).RoleID, pathStr));
//旧传奇代码这儿是隐藏设置，可能用于隐藏魔法
}
return(fResult);
}
private static void WriteLine(string str, ConsoleColor Color = ConsoleColor.Green)
{
Console.ForegroundColor = Color;
SysConOut.WriteLine(str);
Console.ForegroundColor = ConsoleColor.White;
}
private void SocketConnectState(object sender, SocketConnectEventArgs e)
{
SysConOut.WriteLine("SocketReceived " + e.Error + " ErrorMsg = " + e.ErrorMsg + " ErrorStr = " + e.ErrorStr
+ " NetSocketType = " + e.NetSocketType.ToString());
}
public void ThreadFuncation2()
{
int szOfest = 11;
//autoEvent.WaitOne();
while (true)
{
if (m_MoveDataList.Count > 0)
{
mutex.WaitOne();
try
{
TCPOutPacket szTCPOutPacket = null;
szTCPOutPacket = m_MoveDataList.Dequeue();
string[] fields = null;
if (szTCPOutPacket.PacketCmdID < 30000)
{
fields = Encoding.Default.GetString(szTCPOutPacket.GetPacketBytes(), szOfest, szTCPOutPacket.PacketDataSize - szOfest).Trim().Split(':');
}
switch (szTCPOutPacket.PacketCmdID)
{
case (int)TCPServerCmds.CMD_LOGIN_ON1:
{
m_LNetClient.Disconnect();
m_LNetClient.Destroy();
if (!fields[0].Equals("0"))
{
g_Thread1.Start();
g_Acc = fields[0];
SendRoleData(fields[0]);
}
else
{
SysConOut.WriteLine("登陆失败");
}
break;
}
case (int)TCPServerCmds.CMD_NTF_EACH_ROLE_ALLOW_CHANGE_NAME:
{
SysConOut.WriteLine("==============CHANGE_NAME===============");
foreach (var s in fields)
{
SysConOut.WriteLine(s);
}
break;
}
case (int)CommandID.CMD_GET_ROLE_LIST:
{
SysConOut.WriteLine("==============CMD_ROLE_LIST 30003===============");
//反序列化
MemoryStream msRecvData = new MemoryStream(szTCPOutPacket.GetPacketBytes(), szOfest, szTCPOutPacket.PacketDataSize - szOfest);
GetRolesListReponse szGetRolesListReponse = Serializer.Deserialize <GetRolesListReponse>(msRecvData);
SysConOut.WriteLine("get Role state = " + szGetRolesListReponse.State.ToString());
foreach (var i in szGetRolesListReponse.SubRoleinfo)
{
SysConOut.WriteLine("get Role Role = " + i.RoleID.ToString());
}
if (szGetRolesListReponse.State == (int)ErrorCode.ERROR_INVALID_ROLE)
{
var szRandom = new Random().Next(100);
CreateRoles szCreateRoles = new CreateRoles();
szCreateRoles.Acc = g_Acc;
szCreateRoles.UserName = g_Acc + szRandom.ToString();
szCreateRoles.Sex = 0;
szCreateRoles.occup = 0;
szCreateRoles.ZoneID = 0;
m_tcpOutPacketPool.Push(szTCPOutPacket);
MemoryStream msResult = new MemoryStream();
Serializer.Serialize <CreateRoles>(msResult, szCreateRoles);
byte[] msSendData = msResult.ToArray();
szTCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_GSNetClient.OutPacketPool, msSendData, 0, msSendData.Length, 30002);
if (m_GSNetClient.SendData(szTCPOutPacket))
{
SysConOut.WriteLine("发送创建角色列表数据成功");
}
else
{
SysConOut.WriteLine("发送创建角色列表数据失败");
}
m_GSNetClient.OutPacketPool.Push(szTCPOutPacket);
}
else
{
foreach (var Roleinfo in szGetRolesListReponse.SubRoleinfo)
{
g_RoleID = Roleinfo.RoleID.ToString();
break;
}
SendInitGame(g_Acc, g_RoleID);
Console.Title = "机器人---" + g_RoleID;
}
break;
}
case (int)TCPServerCmds.CMD_ROLE_LIST:
{
SysConOut.WriteLine("==============CMD_ROLE_LIST===============");
if (fields[0].Equals("0"))
{
var szRandom = new Random().Next(100);
var result = StringUtil.substitute("{0}:{1}:{2}:{3}:{4}:{5}:{6}", g_Acc, g_Acc + szRandom.ToString(), 0, 0,
String.Format("{0}${1}", g_Acc + szRandom.ToString(), 0), 0, 1);
TCPOutPacket _TCPOutPacket = TCPOutPacket.MakeTCPOutPacket(m_GSNetClient.OutPacketPool, result,
(int)TCPServerCmds.CMD_CREATE_ROLE);
//创建角色
if (m_GSNetClient.SendData(_TCPOutPacket))
{
SysConOut.WriteLine("发送创建角色数据成功");
}
else
{
SysConOut.WriteLine("发送创建角色数据失败");
}
m_GSNetClient.OutPacketPool.Push(_TCPOutPacket);
}
else
{
string[] fieldsData = fields[1].Split('$');
g_RoleID = fieldsData[0];
SendInitGame(g_Acc, g_RoleID);
Console.Title = "机器人---" + g_RoleID;
}
break;
}
case (int)CommandID.CMD_CREATE_ROLE:
{
SysConOut.WriteLine("====CMD_CREATE_ROLE 30002=====");
MemoryStream msRecvData = new MemoryStream(szTCPOutPacket.GetPacketBytes(), szOfest, szTCPOutPacket.PacketDataSize - szOfest);
CreateRolesReponse szCreateRolesReponse = Serializer.Deserialize <CreateRolesReponse>(msRecvData);
if (szCreateRolesReponse.State == (int)ErrorCode.ERROR_OK)
{
SendRoleData(g_Acc);
}
m_tcpOutPacketPool.Push(szTCPOutPacket);
break;
}
case (int)TCPServerCmds.CMD_CREATE_ROLE:
{
SysConOut.WriteLine("====CMD_CREATE_ROLE=====");
if (!fields[0].Equals("0"))
{
SendRoleData(g_Acc);
}
break;
}
case (int)CommandID.CMD_INIT_GAME:
{
SysConOut.WriteLine("==============CMD_INIT_GAME 30004===============");
MemoryStream msRecvData = new MemoryStream(szTCPOutPacket.GetPacketBytes(), szOfest, szTCPOutPacket.PacketDataSize - szOfest);
InitialGameReponse szInitialGameReponse = Serializer.Deserialize <InitialGameReponse>(msRecvData);
SysConOut.WriteLine("CMD_INIT_GAME RoleID = " + szInitialGameReponse.SubRoleinfo.RoleID.ToString() + " Role = " + g_RoleID.ToString());
SendPlayGame(g_RoleID);
m_tcpOutPacketPool.Push(szTCPOutPacket);
break;
}
case (int)TCPServerCmds.CMD_INIT_GAME:
{
SysConOut.WriteLine("==============CMD_INIT_GAME===============");
RoleData szRoleData = DataHelper.BytesToObject <RoleData>(szTCPOutPacket.GetPacketBytes(), szOfest, szTCPOutPacket.PacketDataSize - szOfest);
SysConOut.WriteLine("CMD_INIT_GAME RoleID = " + szRoleData.RoleID.ToString());
SendPlayGame(g_RoleID);
break;
}
case (int)CommandID.CMD_PLAY_GAME:
{
SysConOut.WriteLine("==============CMD_PLAY_GAME 30005===============");
MemoryStream msRecvData = new MemoryStream(szTCPOutPacket.GetPacketBytes(), szOfest, szTCPOutPacket.PacketDataSize - szOfest);
PlayGameReponse szPlayGameReponse = Serializer.Deserialize <PlayGameReponse>(msRecvData);
SysConOut.WriteLine("CMD_PLAY_GAME RoleID = " + szPlayGameReponse.RoleID.ToString());
if (g_Thread == null)
{
g_Thread = new Thread(new ThreadStart(ThreadFuncation));
}
g_Thread.Start();
m_tcpOutPacketPool.Push(szTCPOutPacket);
break;
}
case (int)TCPServerCmds.CMD_PLAY_GAME:
{
SysConOut.WriteLine("==============CMD_PLAY_GAME===============");
if (g_Thread == null)
{
g_Thread = new Thread(new ThreadStart(ThreadFuncation));
}
g_Thread.Start();
break;
}
case (int)CommandID.CMD_GAME_MOVE:
{
SysConOut.WriteLine("==============CMD_GAME_MOVE 30006===============");
MemoryStream msRecvData = new MemoryStream(szTCPOutPacket.GetPacketBytes(), szOfest, szTCPOutPacket.PacketDataSize - szOfest);
SpriteMove szSpriteMove = Serializer.Deserialize <SpriteMove>(msRecvData);
SysConOut.WriteLine("CMD_SPR_MOVE Role = " + szSpriteMove.RoleID.ToString()
+ " Mapcode = " + szSpriteMove.MapCode.ToString()
+ " action = " + szSpriteMove.action.ToString()
+ " pathString = " + szSpriteMove.pathString);
m_tcpOutPacketPool.Push(szTCPOutPacket);
break;
}
case (int)TCPServerCmds.CMD_SPR_MOVE:
{
SpriteNotifyOtherMoveData moveData = DataHelper.BytesToObject <SpriteNotifyOtherMoveData>(szTCPOutPacket.GetPacketBytes(), 11, szTCPOutPacket.PacketDataSize - 11);
SysConOut.WriteLine("CMD_SPR_MOVE Role = " + moveData.roleID.ToString()
+ " Mapcode = " + moveData.mapCode.ToString()
+ " action = " + moveData.action.ToString()
+ " pathString = " + moveData.pathString);
m_tcpOutPacketPool.Push(szTCPOutPacket);
break;
}
}
}
catch (Exception ex)
{
SysConOut.WriteLine(ex.Message);
}
mutex.Release();
}
Thread.Sleep(100);
}
}
/// <summary>
/// 命令包接收完毕后的回调事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private bool TCPCmdPacketEvent(object sender, int doType)
{
TCPInPacket tcpInPacket = sender as TCPInPacket;
if (0 == doType) //正常的登录指令包
{
int thisTimeCheckTicks = 0;
int checkErrorCode = 0;
if (0xffff == tcpInPacket.PacketCmdID)
{
String cmdData = new UTF8Encoding().GetString(tcpInPacket.GetPacketBytes(), 0, tcpInPacket.PacketDataSize);
if (cmdData == "serveripinfo")
{
String strinfo = string.Format("{0}_{1}", ServerPort, Global.GetLocalAddressIPs());
byte [] arrSendData = Encoding.UTF8.GetBytes(strinfo);
if (null != arrSendData)
{
tcpInPacket.CurrentSocket.Send(arrSendData, arrSendData.Length, SocketFlags.None);
}
}
return(false);
}
//这里实际上是有一个指令流的拷贝，占用的很零碎的内存，这个是否考虑使用内存池????
byte[] bytesData = CheckClientDataValid(tcpInPacket.PacketCmdID, tcpInPacket.GetPacketBytes(), tcpInPacket.PacketDataSize, tcpInPacket.LastCheckTicks, out thisTimeCheckTicks, out checkErrorCode);
if (null != bytesData)
{
tcpInPacket.LastCheckTicks = thisTimeCheckTicks; //记忆此次的心跳数据
//#if false
if (UseWorkerPool)
{
//杰隆的异步处理指令入口代码
TCPCmdWrapper wrapper = TCPCmdWrapper.Get(this, tcpInPacket.CurrentSocket, tcpClientPool, tcpRandKey, tcpOutPacketPool, tcpInPacket.PacketCmdID, bytesData, tcpInPacket.PacketDataSize - 1 - 4);
TCPSession session = null;
if (GameManager.FlagOptimizeLock3)
{
if (null != tcpInPacket.CurrentSocket)
{
session = tcpInPacket.CurrentSocket.session;
}
if (null == session)
{
LogManager.WriteLog(LogTypes.Error, string.Format("未与客户端建立会话: {0},{1}, 错误码:{2}, 关闭连接", (TCPGameServerCmds)tcpInPacket.PacketCmdID, Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket), checkErrorCode));
return(false);
}
}
else
{
lock (tcpSessions)
{
if (!tcpSessions.TryGetValue(tcpInPacket.CurrentSocket, out session))
{
LogManager.WriteLog(LogTypes.Error, string.Format("未与客户端建立会话: {0},{1}, 错误码:{2}, 关闭连接", (TCPGameServerCmds)tcpInPacket.PacketCmdID, Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket), checkErrorCode));
return(false);
}
}
}
int posCmdNum = 0;
session.addTCPCmdWrapper(wrapper, out posCmdNum);
if (posCmdNum > 0)
{
int banSpeedUpMinutes = GameManager.PlatConfigMgr.GetGameConfigItemInt(PlatConfigNames.BanSpeedUpMinutes2, 10); //加速禁止登陆的时间
GameClient client = GameManager.ClientMgr.FindClient(tcpInPacket.CurrentSocket);
if (null != client)
{
GameManager.ClientMgr.NotifyImportantMsg(this.MySocketListener, tcpOutPacketPool, client, StringUtil.substitute(Global.GetLang("本游戏禁止使用加速软件，{0}分钟内将禁止登陆!"), banSpeedUpMinutes), GameInfoTypeIndexes.Error, ShowGameInfoTypes.HintAndBox);
BanManager.BanRoleName(Global.FormatRoleName(client, client.ClientData.RoleName), banSpeedUpMinutes);
}
LogManager.WriteLog(LogTypes.Error, string.Format("通过POSITION指令判断客户端加速: {0}, 指令个数:{1}, 断开连接", Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket), posCmdNum));
return(false);
}
taskExecutor.execute(new ProcessSessionTask(session));
}
//#else
else
{
TCPSession session = null;
if (GameManager.FlagOptimizeLock3)
{
if (null != tcpInPacket.CurrentSocket)
{
session = tcpInPacket.CurrentSocket.session;
}
if (null == session)
{
LogManager.WriteLog(LogTypes.Error, string.Format("未与客户端建立会话: {0},{1}, 错误码:{2}, 关闭连接", (TCPGameServerCmds)tcpInPacket.PacketCmdID, Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket), checkErrorCode));
return(false);
}
}
else
{
lock (tcpSessions)
{
if (!tcpSessions.TryGetValue(tcpInPacket.CurrentSocket, out session))
{
LogManager.WriteLog(LogTypes.Error, string.Format("未与客户端建立会话: {0},{1}, 错误码:{2}, 关闭连接", (TCPGameServerCmds)tcpInPacket.PacketCmdID, Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket), checkErrorCode));
return(false);
}
}
}
int posCmdNum = 0;
session.CheckCmdNum(tcpInPacket.PacketCmdID, out posCmdNum);
if (posCmdNum > 0)
{
int banSpeedUpMinutes = GameManager.PlatConfigMgr.GetGameConfigItemInt(PlatConfigNames.BanSpeedUpMinutes2, 10); //加速禁止登陆的时间
GameClient client = GameManager.ClientMgr.FindClient(tcpInPacket.CurrentSocket);
if (null != client)
{
if (client.CheckCheatData.ProcessBooster)
{
GameManager.ClientMgr.NotifyImportantMsg(this.MySocketListener, tcpOutPacketPool, client, StringUtil.substitute(Global.GetLang("本游戏禁止使用加速软件，{0}分钟内将禁止登陆!"), banSpeedUpMinutes), GameInfoTypeIndexes.Error, ShowGameInfoTypes.HintAndBox);
BanManager.BanRoleName(Global.FormatRoleName(client, client.ClientData.RoleName), banSpeedUpMinutes);
LogManager.WriteLog(LogTypes.Error, string.Format("通过POSITION指令判断客户端加速: {0}, 指令个数:{1}, 断开连接", Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket), posCmdNum));
return(false);
}
else if (client.CheckCheatData.ProcessBoosterTicks == 0)
{
client.CheckCheatData.ProcessBoosterTicks = TimeUtil.NOW();
}
}
}
TCPOutPacket tcpOutPacket = null;
TCPProcessCmdResults result = TCPProcessCmdResults.RESULT_FAILED;
long processBeginTime = TimeUtil.NowEx();
if (tcpInPacket.PacketCmdID > 30000)
{
result = CCTCPCmdHandler.CCProcessCmd(this, tcpInPacket.CurrentSocket, tcpClientPool, tcpRandKey, tcpOutPacketPool, tcpInPacket.PacketCmdID, bytesData, tcpInPacket.PacketDataSize - 1 - 4, out tcpOutPacket);
}
else
{
result = TCPCmdHandler.ProcessCmd(this, tcpInPacket.CurrentSocket, tcpClientPool, tcpRandKey, tcpOutPacketPool, tcpInPacket.PacketCmdID, bytesData, tcpInPacket.PacketDataSize - 1 - 4, out tcpOutPacket);
}
long processTime = (TimeUtil.NowEx() - processBeginTime);
if (GameManager.StatisticsMode > 0 || processTime > 50 || result == TCPProcessCmdResults.RESULT_FAILED)
{
RecordCmdDetail(tcpInPacket.PacketCmdID, processTime, tcpInPacket.PacketDataSize, result);
}
if (result == TCPProcessCmdResults.RESULT_DATA && null != tcpOutPacket)
{
// Console.WriteLine("===>>> tcpOutPacket==== " + tcpOutPacket.PacketCmdID.ToString());
//向登陆客户端返回数据
socketListener.SendData(tcpInPacket.CurrentSocket, tcpOutPacket);
}
else if (result == TCPProcessCmdResults.RESULT_FAILED)//解析失败, 直接关闭连接
{
if (tcpInPacket.PacketCmdID != (int)TCPGameServerCmds.CMD_LOG_OUT)
{
SysConOut.WriteLine(string.Format("解析并执行命令失败: {0},{1}, 关闭连接", (TCPGameServerCmds)tcpInPacket.PacketCmdID, Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket)));
LogManager.WriteLog(LogTypes.Error, string.Format("解析并执行命令失败: {0},{1}, 关闭连接", (TCPGameServerCmds)tcpInPacket.PacketCmdID, Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket)));
}
return(false);
}
}
//#endif
}
else
{
var _s = tcpInPacket.CurrentSocket;
string uid = _s != null?GameManager.OnlineUserSession.FindUserID(_s) : "socket is nil";
SysConOut.WriteLine(string.Format("校验客户端发送的指令数据完整性失败: {0},{1}, 错误码:{2}, uid={3}, 关闭连接", (TCPGameServerCmds)tcpInPacket.PacketCmdID, Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket), checkErrorCode, uid));
LogManager.WriteLog(LogTypes.Error, string.Format("校验客户端发送的指令数据完整性失败: {0},{1}, 错误码:{2}, uid={3}, 关闭连接", (TCPGameServerCmds)tcpInPacket.PacketCmdID, Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket), checkErrorCode, uid));
return(false);
}
}
else if (1 == doType) //正常的登录指令包//策略验证请求
{
//直接发送策略数据
DirectSendPolicyFileData(tcpInPacket);
}
else
{
SysConOut.WriteLine(string.Format("解析并执行命令时类型未知: {0},{1}, 关闭连接", (TCPGameServerCmds)tcpInPacket.PacketCmdID, Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket)));
LogManager.WriteLog(LogTypes.Error, string.Format("解析并执行命令时类型未知: {0},{1}, 关闭连接", (TCPGameServerCmds)tcpInPacket.PacketCmdID, Global.GetSocketRemoteEndPoint(tcpInPacket.CurrentSocket)));
//socketListener.CloseSocket(tcpInPacket.CurrentSocket);
return(false);
}
return(true);
}
public void InitExcel()
{
string fullPathFileName = Logic.Global.GameResPath(SkillPathExcel);
Excel.Application xlApp = new Excel.Application();
xlApp.DisplayAlerts = false;
xlApp.Visible = false;
xlApp.ScreenUpdating = false;
Excel.Workbook xlsWorkBook = xlApp.Workbooks.Open(fullPathFileName, System.Type.Missing, System.Type.Missing, System.Type.Missing,
System.Type.Missing, System.Type.Missing, System.Type.Missing, System.Type.Missing, System.Type.Missing, System.Type.Missing, System.Type.Missing,
System.Type.Missing, System.Type.Missing);
Excel.Worksheet sheet = xlsWorkBook.Worksheets[1];//工作薄从1开始，不是0
int i = 1;
int j = 1;
try
{
int iRowCount = sheet.UsedRange.Rows.Count;
int iColCount = sheet.UsedRange.Columns.Count;
Excel.Range range;
for (; i < iRowCount; i++)
{
SkillObject skillObject = new SkillObject();
for (j = 1; j < iColCount; j++)
{
range = sheet.Cells[i, j];
switch (j)
{
case 1:
{
skillObject.SkillID = Convert.ToInt32((range.Value2 == null) ? "" : range.Text.ToString());
break;
}
case 2:
{
skillObject.SkillName = (range.Value2 == null) ? "" : range.Text.ToString();
break;
}
case 3:
{
skillObject.Remark = (range.Value2 == null) ? "" : range.Text.ToString();
break;
}
case 4:
{
skillObject.Occupation = Convert.ToInt32((range.Value2 == null) ? "" : range.Text.ToString());
break;
}
case 5:
{
skillObject.NeedMP = Convert.ToInt32((range.Value2 == null) ? "" : range.Text.ToString());
break;
}
case 6:
{
skillObject.NeedHP = Convert.ToInt32((range.Value2 == null) ? "" : range.Text.ToString());
break;
}
case 7:
{
skillObject.NeedLV = Convert.ToInt32((range.Value2 == null) ? "" : range.Text.ToString());
break;
}
case 13:
{
skillObject.SkillType = Convert.ToInt32((range.Value2 == null) ? "" : range.Text.ToString());
break;
}
case 15:
{
skillObject.HarmType = Convert.ToInt32((range.Value2 == null) ? "" : range.Text.ToString());
break;
}
case 17:
{
skillObject.HardHarm = Convert.ToInt32((range.Value2 == null) ? "" : range.Text.ToString());
break;
}
case 18:
{
skillObject.EffectList = null;
break;
}
case 19:
{
skillObject.BuffList = null;
break;
}
case 20:
{
skillObject.Distance = Convert.ToInt32((range.Value2 == null) ? "" : range.Text.ToString());
break;
}
case 21:
{
skillObject.CDTime = Convert.ToInt32((range.Value2 == null) ? "" : range.Text.ToString());
break;
}
case 16:
{
skillObject.SkillHarmList = new List <int>();
string[] szSkillHarm = ((range.Value2 == null) ? "" : range.Text.ToString()).Split(',');
foreach (var s in szSkillHarm)
{
skillObject.SkillHarmList.Add(Convert.ToInt32(s));
}
break;
}
case 14:
{
skillObject.RangeType = new List <int>();
string[] szRangeType = ((range.Value2 == null) ? "" : range.Text.ToString()).Split(',');
foreach (var s in szRangeType)
{
skillObject.RangeType.Add(Convert.ToInt32(s));
}
break;
}
case 8:
{
skillObject.NeedWeapons = new List <int>();
string[] szNeedWeapons = ((range.Value2 == null) ? "" : range.Text.ToString()).Split(',');
foreach (var s in szNeedWeapons)
{
skillObject.NeedWeapons.Add(Convert.ToInt32(s));
}
break;
}
case 9:
{
skillObject.NeedSkill = new List <int>();
string[] szNeedSkill = ((range.Value2 == null) ? "" : range.Text.ToString()).Split(',');
foreach (var s in szNeedSkill)
{
skillObject.NeedSkill.Add(Convert.ToInt32(s));
}
break;
}
case 10:
{
skillObject.BecomeNeedSkill = new List <int>();
string[] szBecomeNeedSkill = ((range.Value2 == null) ? "" : range.Text.ToString()).Split(',');
foreach (var s in szBecomeNeedSkill)
{
skillObject.BecomeNeedSkill.Add(Convert.ToInt32(s));
}
break;
}
case 11:
{
skillObject.NextSkill = new List <int>();
string[] szNextSkill = ((range.Value2 == null) ? "" : range.Text.ToString()).Split(',');
foreach (var s in szNextSkill)
{
skillObject.NextSkill.Add(Convert.ToInt32(s));
}
break;
}
case 12:
{
skillObject.BecomeNextSkill = new List <int>();
string[] szBecomeNextSkill = ((range.Value2 == null) ? "" : range.Text.ToString()).Split(',');
foreach (var s in szBecomeNextSkill)
{
skillObject.BecomeNextSkill.Add(Convert.ToInt32(s));
}
break;
}
}
}
SystemSkillList.Add(skillObject.SkillID, skillObject);
}
}
catch (Exception ex)
{
SysConOut.WriteLine(string.Format("加载技能Excel配置文件:{0}, 失败。没有找到相关XML配置文件[{1}] i ={2} j={3}!", SkillPathName, ex.Message, i, j));
// throw new Exception(string.Format("加载技能Excel配置文件:{0}, 失败。没有找到相关XML配置文件!", SkillPathName));
}
finally
{
xlsWorkBook.Close(false, System.Type.Missing, System.Type.Missing);
System.Runtime.InteropServices.Marshal.ReleaseComObject(xlsWorkBook);
xlsWorkBook = null;
xlApp.Workbooks.Close();
xlApp.Quit();
System.Runtime.InteropServices.Marshal.ReleaseComObject(xlApp);
xlApp = null;
}
}
public void InitSkill()
{
//InitExcel();
// return;
XElement szxXml = null;
try
{
string fullPathFileName = Logic.Global.GameResPath(SkillPathName);
szxXml = XElement.Load(fullPathFileName);
if (null == szxXml)
{
throw new Exception(string.Format("加载技能xml配置文件:{0}, 失败。没有找到相关XML配置文件!", fullPathFileName));
}
SystemXmlItem systemXmlItem = new SystemXmlItem();
IEnumerable <XElement> nodes = szxXml.Elements(SkillRootName).Elements();
foreach (var node in nodes)
{
systemXmlItem.XMLNode = node;
SkillObject skillObject = new SkillObject()
{
SkillID = systemXmlItem.GetIntValue("SkillID"),
SkillName = systemXmlItem.GetStringValue("Name"),
Remark = systemXmlItem.GetStringValue("Remark"),
NeedMP = systemXmlItem.GetIntValue("NeedMP"),
NeedHP = systemXmlItem.GetIntValue("NeedHP"),
SkillType = systemXmlItem.GetIntValue("SkillType"),
Distance = systemXmlItem.GetIntValue("Distance"),
CDTime = systemXmlItem.GetIntValue("Cooling"),
HarmType = systemXmlItem.GetIntValue("HarmType"),
Occupation = systemXmlItem.GetIntValue("NeedJob"),
HardHarm = systemXmlItem.GetIntValue("HardHarm"),
NeedLV = systemXmlItem.GetIntValue("NeedLV"),
SkillLevel = systemXmlItem.GetIntValue("SkillLevel"),
Ballistic = systemXmlItem.GetIntValue("Ballistic"),
NeedSkill = null,
BecomeNeedSkill = null,
NextSkill = null,
BecomeNextSkill = null,
BuffList = null,
EffectList = null,
RangeType = null,
NeedWeapons = null,
SkillHarmList = null,
TargetType = systemXmlItem.GetIntValue("TargetType")
};
//务器类型
skillObject.NeedWeapons = new List <int>();
string[] szNeedWeapons = systemXmlItem.GetStringValue("NeedWeapons").Split('#');
foreach (var s in szNeedWeapons)
{
skillObject.NeedWeapons.Add(Convert.ToInt32(s));
}
//前置技能
skillObject.NeedSkill = new List <int>();
string[] szNeedSkill = systemXmlItem.GetStringValue("NeedSkill").Split('#');
foreach (var s in szNeedSkill)
{
skillObject.NeedSkill.Add(Convert.ToInt32(s));
}
//开化后前置技能
skillObject.BecomeNeedSkill = new List <int>();
string[] szBecomeNeedSkill = systemXmlItem.GetStringValue("BecomeNeedSkill").Split('#');
foreach (var s in szBecomeNeedSkill)
{
skillObject.BecomeNeedSkill.Add(Convert.ToInt32(s));
}
//后置技能
skillObject.NextSkill = new List <int>();
string[] szNextSkill = systemXmlItem.GetStringValue("NextSkill").Split('#');
foreach (var s in szNextSkill)
{
skillObject.NextSkill.Add(Convert.ToInt32(s));
}
//开花后得后置技能
skillObject.BecomeNextSkill = new List <int>();
string[] szBecomeNextSkill = systemXmlItem.GetStringValue("BecomeNextSkill").Split('#');
foreach (var s in szBecomeNextSkill)
{
skillObject.BecomeNextSkill.Add(Convert.ToInt32(s));
}
//影响范围
skillObject.RangeType = new List <int>();
string[] szRangeType = systemXmlItem.GetStringValue("RangeType").Split('#');
foreach (var s in szRangeType)
{
skillObject.RangeType.Add(Convert.ToInt32(s));
}
//技能伤害
skillObject.SkillHarmList = new List <int>();
string[] szSkillHarm = systemXmlItem.GetStringValue("SkillHarm").Split('#');
foreach (var s in szSkillHarm)
{
skillObject.SkillHarmList.Add(Convert.ToInt32(s));
}
//释放目标
//skillObject.TargetTypeList = new List<int>();
//string[] szTargetType = systemXmlItem.GetStringValue("TargetType").Split('#');
//foreach (var s in szTargetType)
//{
// skillObject.TargetTypeList.Add(Convert.ToInt32(s));
//}
//释放类型
skillObject.ReleaseTypeList = new List <int>();
string[] szReleaseType = systemXmlItem.GetStringValue("ReleaseType").Split('#');
foreach (var s in szSkillHarm)
{
skillObject.ReleaseTypeList.Add(Convert.ToInt32(s));
}
SystemSkillList.Add(skillObject.SkillID, skillObject);
//SysConOut.WriteLine(string.Format("加载技能配置文件:{0},", skillObject.SkillID));
}
}
catch (Exception ex)
{
SysConOut.WriteLine(string.Format("加载技能Excel配置文件:{0}, 失败。没有找到相关XML配置文件[{1}]!", SkillPathName, ex.Message));
// throw new Exception(string.Format("加载技能xxml配置文件:{0}, 失败。没有找到相关XML配置文件!", SkillPathName));
}
SysConOut.WriteLine(string.Format("加载技能配置文件:{0},", SystemSkillList.Count));
}
