public override void OnHandlerMessage(Photon.SocketServer.OperationRequest request, OperationResponse response, ClientPeer peer, SendParameters sendParameters)
{
SubCode subCode = ParameterTool.GetParameter<SubCode>(request.Parameters,ParameterCode.SubCode,false);
//给response参数添加subCode
response.Parameters.Add((byte) ParameterCode.SubCode,subCode);
switch (subCode)
{
case SubCode.AddTaskDB:
TaskDB taskDB = ParameterTool.GetParameter<TaskDB>(request.Parameters, ParameterCode.TaskDB);
taskDB.Role = peer.LoginRole;
taskDBManager.AddTaskDB(taskDB);
taskDB.Role = null;
ParameterTool.AddParameter(response.Parameters,ParameterCode.TaskDB, taskDB);
response.ReturnCode = (short) ReturnCode.Success;
break;
case SubCode.GetTaskDB:
List<TaskDB> list = taskDBManager.GetTaskDBList(peer.LoginRole);
foreach (var taskDb in list)
{
taskDb.Role = null;
}
ParameterTool.AddParameter(response.Parameters,ParameterCode.TaskDBList, list);
response.ReturnCode = (short) ReturnCode.Success;
break;
case SubCode.UpdateTaskDB:
TaskDB taskDB2 = ParameterTool.GetParameter<TaskDB>(request.Parameters, ParameterCode.TaskDB);
taskDB2.Role = peer.LoginRole;
taskDBManager.UpdataTaskDB(taskDB2);
response.ReturnCode = (short) ReturnCode.Success;
break;
}
}
public override OperationResponse OnHandlerMeesage(OperationRequest request, ClientPeer peer)
{
object json;
request.Parameters.TryGetValue((byte) ParameterCode.UserCheckInfo, out json);
var user = JsonMapper.ToObject<User>(json.ToString());
var response = new OperationResponse {OperationCode = request.OperationCode};
//查询数据库
var userDb = _manager.GetUserByUsername(user.Username);
if (userDb == null)
{
if (_manager.RegisterUser(user))
{
response.ReturnCode = (short) ReturnCode.Success;
peer.SetUser(user);
}
else
{
response.ReturnCode = (short) ReturnCode.Eception;
response.DebugMessage = "异常";
}
}
else
{
response.ReturnCode = (short) ReturnCode.Fail;
response.DebugMessage = "用户名已存在!";
}
return response;
}
public override OperationResponse OnHandlerMeesage(OperationRequest request, ClientPeer peer)
{
//1.获得客户端发送的帐号和明文密码
object json;
request.Parameters.TryGetValue((byte) ParameterCode.UserCheckInfo, out json);
var user = JsonMapper.ToObject<User>(json.ToString());
var userDb = _manager.GetUserByUsername(user.Username);
var s = userDb != null
? string.Format("user.Username:{0},user.Password:{1} userDb.Username:{2},userDb.Password:{3}",
user.Username, user.Password, userDb.Username, userDb.Password)
: "未找到用户:" + user.Username;
peer.WriteLog(s);
//2.比较,然后创建响应
var response = new OperationResponse {OperationCode = request.OperationCode};
if (userDb != null && userDb.Password == MD5Tool.GetMD5(user.Password))
{
response.ReturnCode = (short) ReturnCode.Success;
peer.SetUser(userDb);
}
else
{
response.ReturnCode = (short) ReturnCode.Fail;
response.DebugMessage = "用户名或密码错误!";
}
return response;
}
public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer, SendParameters sendParameters)
{
SubCode subcode = ParameterTool.GetParameter<SubCode>(request.Parameters, ParameterCode.SubCode, false);
ParameterTool.AddParameter(response.Parameters,ParameterCode.SubCode,subcode, false);
switch (subcode)
{
//查询
case SubCode.GetInventoryItemDB:
List<InventoryItemDB> list = inventoryItemDbManager.GetInventoryDB(peer.LoginRole);
foreach (var temp in list)
{
temp.Role = null;
}
ParameterTool.AddParameter(response.Parameters,ParameterCode.InventoryItemDBList,list);
break;
//添加
case SubCode.AddInventoryItemDB:
InventoryItemDB itemDB = ParameterTool.GetParameter<InventoryItemDB>(request.Parameters,ParameterCode.InventoryItemDB);
itemDB.Role = peer.LoginRole;
inventoryItemDbManager.AddInventoryItemDB(itemDB);
itemDB.Role = null;
ParameterTool.AddParameter(response.Parameters,ParameterCode.InventoryItemDB, itemDB);
response.ReturnCode = (short) ReturnCode.Success;
break;
//更新,一个的情况
case SubCode.UpdateInventoryItemDB:
InventoryItemDB itemDB2 = ParameterTool.GetParameter<InventoryItemDB>(request.Parameters, ParameterCode.InventoryItemDB);
itemDB2.Role = peer.LoginRole;
inventoryItemDbManager.UpdateInventoryItemDB(itemDB2);
break;
//更新穿上和卸下的装备，两个的情况
case SubCode.UpdateInventoryItemDBList:
List<InventoryItemDB> list2 = ParameterTool.GetParameter<List<InventoryItemDB>>(request.Parameters,ParameterCode.InventoryItemDBList);
foreach (var itemDB3 in list2)
{
itemDB3.Role = peer.LoginRole;
}
inventoryItemDbManager.UpdateInventoryItemDBList(list2);
break;
//升级装备
case SubCode.UpgradeEquip:
InventoryItemDB itemDB4 = ParameterTool.GetParameter<InventoryItemDB>(request.Parameters,ParameterCode.InventoryItemDB);
Role role = ParameterTool.GetParameter<Role>(request.Parameters, ParameterCode.Role);
peer.LoginRole = role;
role.User = peer.LoginUser;
itemDB4.Role = role;
inventoryItemDbManager.UpgradeEquip(itemDB4, role);
break;
}
}
public override OperationResponse OnHandlerMeesage(OperationRequest request, ClientPeer peer)
{
var list = _manager.GetserverpropertyList();
var json = JsonMapper.ToJson(list);
var parameters = new Dictionary<byte, object> {{(byte) ParameterCode.ServerList, json}};
var response = new OperationResponse(request.OperationCode, parameters)
{
ReturnCode = (short) ReturnCode.Success
};
return response;
}
public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer,
SendParameters sendParameters)
{
SubCode subcode = ParameterTool.GetSubCode(request.Parameters);
switch (subcode)
{
case SubCode.SyncBossAnimation:
RequestTool.TransmitRequest(peer,request,OpCode);
break;
}
}
//用来转发请求
private void TransmitRequest(ClientPeer peer ,OperationRequest request)
{
foreach (ClientPeer temp in peer.Team.clientPeers)
{
if (temp != peer)
{
EventData data = new EventData();
data.Parameters = request.Parameters;
ParameterTool.AddOperationcodeSubcodeRoleID(data.Parameters, OpCode, peer.LoginRole.ID);
temp.SendEvent(data, new SendParameters());
}
}
}
// Use this for initialization
void Start()
{
this.peer = new ClientPeer ();
// Connection des events avec des fonctions "locales"
this.peer.Connected += new EventHandler(Peer_ConnectedEvent);
this.peer.Disconnected += new EventHandler(Peer_DisconnectedEvent);
this.peer.FullGameReceived += new EventHandler(Peer_FullGameReceived);
// Initialisation du peer
this.peer.ServerAddress = "54.194.106.36:4530"; // Serveur sur le cloud Amazon Web Service.
this.peer.Protocol = ExitGames.Client.Photon.ConnectionProtocol.Tcp;
//
// Etablissement de la connection...
this.peer.Connect ();
}
public void Connect(string hostname, int port)
{
try
{
peer = new ClientPeer(this);
if (!peer.Connect(hostname, port))
{
OnConnectResponse(false);
}
}
catch (Exception ex)
{
OnConnectResponse(false);
DebugReturn(DebugLevel.Error, ex.Message);
DebugReturn(DebugLevel.Error, ex.StackTrace);
}
}
public override void OnHandlerMessage(Photon.SocketServer.OperationRequest request, OperationResponse response, ClientPeer peer, SendParameters sendParameters)
{
//先得到子操作代码，根据子操作代码，分别进行不同的处理
SubCode subcode = ParameterTool.GetParameter<SubCode>(request.Parameters, ParameterCode.SubCode, false);
Dictionary<byte, object> parameters = response.Parameters;
parameters.Add((byte) ParameterCode.SubCode,subcode);
response.OperationCode = request.OperationCode;
switch (subcode)
{
case SubCode.AddRole:
Role role = ParameterTool.GetParameter<Role>(request.Parameters, ParameterCode.Role);
role.User = peer.LoginUser;
roleManager.AddRole(role);
role.User = null; //Json解析的时候不清空role.User会出现问题
//返回给客户端
ParameterTool.AddParameter(parameters,ParameterCode.Role,role);
break;
case SubCode.GetRole:
List<Role> roleList = roleManager.GetRoleListByUser(peer.LoginUser);
//List<Role>中的Role带用User对象，有关联的转换会出现错误，所以把他设置成空
//User是引用类型，json不知道怎么进行操作
foreach (var role1 in roleList)
{
role1.User = null;
}
ParameterTool.AddParameter(parameters,ParameterCode.RoleList, roleList);
break;
case SubCode.SelectRole:
peer.LoginRole = ParameterTool.GetParameter<Role>(request.Parameters, ParameterCode.Role);
break;
case SubCode.UpdateRole:
Role role2 = ParameterTool.GetParameter<Role>(request.Parameters, ParameterCode.Role);
role2.User = peer.LoginUser;
roleManager.UpdateRole(role2);
role2.User = null;
response.ReturnCode = (short) ReturnCode.Success;
ParameterTool.AddParameter(parameters,ParameterCode.Role,role2);
break;
}
}
/// <summary>
/// 加入
/// </summary>
/// <param name="clientPeer"></param>
/// <param name="roomId"></param>
/// <param name="tmpRoomInfo"></param>
private void Join(ClientPeer clientPeer, int roomId, RoomInfo tmpRoomInfo)
{
this._roomClientDict[tmpRoomInfo].Add(clientPeer);
try
{
if (!this.RoomClientIndexDict[tmpRoomInfo].ContainsKey(clientPeer))
{
RoomInfo roomInfo = this.GetRoomInfoByRoomId(roomId);
List <ClientPeer> clients = this.RoomClientsDict[roomInfo];
Dictionary <ClientPeer, int> clientDict = this.RoomClientIndexDict[tmpRoomInfo];
this.RoomClientIndexDict[tmpRoomInfo].Add(clientPeer, ++clientDict[clients[0]]);//保存玩家加入房间后的座位索引值
}
}
catch (System.Exception ex)
{
System.Console.WriteLine(ex.StackTrace);
}
}
public override void OnHandlerMessage(Photon.SocketServer.OperationRequest request, OperationResponse response, ClientPeer peer, SendParameters sendParameters)
{
User user = ParameterTool.GetParameter<User>(request.Parameters,ParameterCode.User);
User userDB = manager.GetUserByUsername(user.Username);
if (userDB != null)
{
response.ReturnCode = (short) ReturnCode.Fail;
response.DebugMessage = "用户名重复";
}
else
{
user.Password = MD5Tool.GetMD5(user.Password);
manager.AddUser(user);
response.ReturnCode = (short) ReturnCode.Success;
}
}
public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer,
SendParameters sendParameters)
{
SubCode subcode = ParameterTool.GetSubCode(request.Parameters);
switch (subcode)
{
case SubCode.CreateEnemy:
TransmitRequest(peer,request);
break;
case SubCode.SyncPositionAndRotation:
TransmitRequest(peer, request);
break;
case SubCode.SyncAnimation:
TransmitRequest(peer, request);
break;
}
}
/// <summary>
/// 离开房间
/// </summary>
/// <param name="clientPeer"></param>
/// <param name="roomId"></param>
/// <returns></returns>
public RoomInfo LeaveRoom(ClientPeer clientPeer, int roomId)
{
//离开的时候需要把客户端用户从房间内移除
List <UserInfo> userInfos = this.RoomIdRooms[roomId].UserInfos;
for (int userIndex = 0; userIndex < userInfos.Count; userIndex++)
{
if (userInfos[userIndex].ClientUserSocket == clientPeer.ClientSocket)
{
this.RoomIdRooms[roomId].UserInfos.Remove(userInfos[userIndex]);
break;
}
}
this.RoomClientsDict[this.RoomIdRooms[roomId]].Remove(clientPeer); //从房间客户端对象中移除指定客户端连接对象
this.RoomIdRooms[roomId].PersonNumber--; //离开房间以后需要将人数减少1
LogMessage.Instance.SetLogMessage(clientPeer.ClientSocket.RemoteEndPoint.ToString() + " 离开了 [ " + roomId + " ] 房间~");
return(this._roomIdRooms[roomId]);
}
/// <summary>
/// 进入房间
/// </summary>
/// <param name="client"></param>
public void Enter(int userId, ClientPeer client)
{
if (!uIdClientDic.ContainsKey(userId))
{
uIdClientDic.Add(userId, client);
}
if (!uidList.Contains(userId))
{
uidList.Add(userId);
}
Console.WriteLine("当前有以下几个人。。。");
foreach (var item in uidList)
{
Console.WriteLine(item);
}
Console.WriteLine("当前有以上几个人。。。");
}
/// <summary>
/// 转换出牌者
/// </summary>
/// <param name="room"></param>
private void Turn(FightRoom room)
{
//下一个出牌的id
int nextUId = room.Turn();
//如果下一个玩家掉线
if (room.LeaveUIdList.Contains(nextUId))
{
}
else
{
ClientPeer nextClient = UserCache.GetClient(nextUId);
socketMsg.State = FightCode.Success;
socketMsg.SubCode = FightCode.Turn_Deal_Bro;
socketMsg.value = nextUId;
nextClient.Send(socketMsg);
}
}
/// <summary>
/// 处理兵种移动请求
/// </summary>
private void processArmyMove(ClientPeer clientPeer, MapMoveDto mapMoveDto)
{
SingleExecute.Instance.processSingle(
() =>
{
if (!UserCache.Instance.IsOnline(clientPeer))
{
return;
}
int uid = UserCache.Instance.GetId(clientPeer);
FightRoom fightRoom = FightRoomCache.Instance.GetRoomByUid(uid);
//向房间内其他人传送移动信息
fightRoom.Broadcast(OpCode.FIGHT, FightCode.MAP_ARMY_MOVE_SBOD, mapMoveDto, clientPeer);
}
);
}
/// <summary>
/// 断开连接
/// </summary>
/// <param name="clientPeer"></param>
public void OnDisconnect(ClientPeer clientPeer)
{
if (clientPeer != null)//如果要断开连接的客户端对象是可用状态
{
//Todo:一旦玩家断开了连接 可能要做断线重连功能
//Todo:目前先这样做,就是判断所有房间内存不存在这个玩家,如果有一个房间内存在这个玩家,那么直接将这个玩家从房间内移除即可,其实就是类似于,玩家离开房间的操作
//判断玩家在不在房间缓存类对象中的某一个房间内
if (this.roomCache.IsInRoom(clientPeer, out int roomId)) //如果玩家在某一个房间内
{
UserInfo userInfo = this.roomCache.GetUserInfoByClientPeer(clientPeer); //取出离开房间的玩家信息数据
this.message.ChangeMessage(OperationCode.Room, (int)RoomCode.LeaveRoom_BroadcastResponse, userInfo.ClientIndex.ToString()); //房间模块,离开房间响应,离开房间的玩家座位索引号
this.roomCache.BroadcastMessageByRoomId(roomId, this.message); //广播消息
RoomInfo leaveRoomInfo = this.roomCache.LeaveRoom(clientPeer, roomId); //使玩家离开房间,返回一个离开房间的房间信息对象
//Todo:这里需要广播消息给房间内的每一个玩家,通知他们哪个玩家离开了房间,客户端需要更新界面的显示,也就是把离开的玩家的界面元素清除
}
clientPeer.OnDisconnect();//无论玩家在不在房间内,直接断开玩家与服务端的连接即可
}
}//断开连接
/// <summary>
/// 通过房间进入码处理加入房间的业务请求
/// </summary>
/// <param name="clientPeer">加入房间的客户端对象</param>
/// <param name="roomEnterCode">要加入的房间进入码</param>
private void ProcessJoinRoomRequestByRoomEnterCode(ClientPeer clientPeer, int roomEnterCode)
{
RoomInfo tmpRoom = this.roomCache.JoinRoomByRoomEnterCode(clientPeer, roomEnterCode); //获取要加入的房间
if (tmpRoom != null)
{
if (tmpRoom.RoomState == RoomState.Waiting) //如果房间处于等待状态
{
this.ProcessJoinRoom(tmpRoom, clientPeer); //加入房间
}
else//房间不处于等待状态中 不能加入
{
this.message.ChangeMessage(OperationCode.Message, (int)MessageCode.SingleMessage, "房间已经满员,不能加入~");
clientPeer.OnSendMessage(this.message);//通知这个客户端对象,告诉它,房间已经满员了,不能进行加入.
return;
}
}
}
/// <summary>
/// 不出的处理
/// </summary>
/// <param name="client"></param>
private void pass(ClientPeer client, bool value)
{
SingleExecute.Instance.Execute(
() =>
{
if (userCache.IsOnline(client) == false)
{
return;
}
//必须确保在线
int userId = userCache.GetId(client);
FightRoom room = fightCache.GetRoomByUId(userId);
if (value == true)
{
if (room.roundModel.BiggestUId == userId)
{
//由于计时结束不出牌换人
client.Send(OpCode.FIGHT, FightCode.PASS_SRES, 0);
turn(room);
room.roundModel.BiggestUId = room.roundModel.CurrentUId;
return;
}
else
{
client.Send(OpCode.FIGHT, FightCode.PASS_SRES, 0);
turn(room);
}
}
else
{
if (room.roundModel.BiggestUId == userId)
{
//当前玩家是最大出牌者 没人管他，不能不出
client.Send(OpCode.FIGHT, FightCode.PASS_SRES, -1);
return;
}
else
{
client.Send(OpCode.FIGHT, FightCode.PASS_SRES, 0);
turn(room);
}
}
});
}
public override void OnOperationRequest(OperationRequest operationRequest, SendParameters sendParameters,
ClientPeer peer)
{
//取得所有玩家信息
var usernameLists = new List <string>();
foreach (var tempPeer in MyGameServer.Instance.peerList)
{
if (string.IsNullOrEmpty(tempPeer.username) == false && tempPeer != peer)
{
usernameLists.Add(tempPeer.username);
}
}
//序列化为一个字符串
var sw = new StringWriter();
var serializer = new XmlSerializer(typeof(List <string>));
serializer.Serialize(sw, usernameLists);
sw.Close();
var userString = sw.ToString();
//将所有用户发送给新加入的客户端
var data = new Dictionary <byte, object>();
data.Add((byte)ParameterCode.UsernameList, userString);
var response = new OperationResponse(operationRequest.OperationCode);
response.Parameters = data;
peer.SendOperationResponse(response, sendParameters);
//告诉其他客户端有新用户加入
foreach (var tempPeer in MyGameServer.Instance.peerList)
{
if (string.IsNullOrEmpty(tempPeer.username) == false && tempPeer != peer)
{
var ed = new EventData((byte)EventCode.NewPlayer);
var datas = new Dictionary <byte, object>();
datas.Add((byte)ParameterCode.UserName, peer.username);
ed.Parameters = datas;
tempPeer.SendEvent(ed, sendParameters);
}
}
}
/// <summary>
/// 同步角色移动方向
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
/// <param name="peer"></param>
/// <param name="sendParameters"></param>
void SyncRoleMoveDir(OperationRequest request, OperationResponse response, ClientPeer peer, SendParameters sendParameters)
{
Dictionary <byte, object> m_dic = request.Parameters;
object value;
// 客户端传递过来的参数信息：角色ID，坐标：X,Y,Z
if (m_dic.TryGetValue((byte)ParameterCode.SyncInfo, out value))
{
string strValue = value.ToString();
//Helper.Log("同步角色移动方向:" + strValue);
string[] pStr1 = strValue.Split(',');
if (pStr1.Length == 4)
{
if (null == peer.m_myTeam)
{
return;
}
List <ClientPeer> pTeam = peer.m_myTeam.m_pTeam;
if (pTeam == null)
{
return;
}
// 通知队伍中的其他Peer返回队伍角色信息给客户端
for (int k = 0; k < pTeam.Count; ++k)
{
ClientPeer curPeer = pTeam[k];
// 九宫格同步
bool bSync = Helper.IsSudoKu(peer.m_vCurPos, curPeer.m_vCurPos);
if (curPeer != peer && bSync)
{
EventData eventData = new EventData();
eventData.Parameters = m_dic;
// 返回操作码
eventData.Code = (byte)OperationCode.SyncMoveDir;
curPeer.SendEvent(eventData, new SendParameters());
//Helper.Log(curPeer.m_curRole.Name + "--:同步:" + peer.m_curRole.Name + "-移动方向：" + strValue);
}
}
}
}
}
/// <summary>
/// 登录
/// </summary>
/// <param name="client"></param>
/// <param name="info"></param>
private void Login(ClientPeer client, UserInfoDto info)
{
SingleExecute.Instance.Execute(() =>
{
var msg = new SocketMsg
{
OpCode = MsgType.Account,
SubCode = AccountCode.Login_Check,
State = AccountCode.Success
};
if (!accountCache.IsExist(info.Account))
{
msg.State = AccountCode.AccountDoesNotExist;
client.Send(msg);
return;
}
if (accountCache.IsOnline(info.Account))
{
msg.State = AccountCode.AccountOnline;
client.Send(msg);
return;
}
if (!accountCache.IsMatch(info.Account, info.Password))
{
msg.State = AccountCode.AccountPasswordDoesNotMatch;
client.Send(msg);
return;
}
//查询数据库是否存在当前账号
//var db = DatabaseHelper.GetInstance();
//var userInfo = db.Queryable<UserInfo>().Where(w => w.Account == info.Account && w.Password == info.Password).First();
//if (userInfo == null)
//{
// msg.value = MsgType.AccountPasswordDoesNotMatch;
// client.Send(msg);
// return;
//}
//登陆成功 放入缓存
accountCache.Online(client, info.Account);
client.Send(msg);
});
}
/// <summary>
/// 为指定客户端连接对象减钱
/// </summary>
/// <param name="clientPeer"></param>
/// <param name="money"></param>
public bool SubMoney(ClientPeer clientPeer, int money)
{
if (money <= 0)
{
return(false);
}
else
{
if (money > this.clientUserDict[clientPeer].Money)
{
return(false);
}
else
{
this.clientUserDict[clientPeer].Money -= money;
return(true);
}
}
}
/// <summary>
/// 广播发消息
/// </summary>
public void Broadcase(int opCode, int subCode, object value, ClientPeer exceptClient = null)
{
Console.WriteLine("--广播有玩家加入的消息--" + opCode + subCode);
NetMsg msg = new NetMsg(opCode, subCode, value);
byte[] data = EncodeTool.EncodeMsg(msg);
byte[] packet = EncodeTool.EncodePacket(data);
foreach (var client in clientList)
{
if (client == exceptClient)
{
Console.WriteLine("--wangzhi--房间里玩家的id--" + client.Id);
Console.WriteLine("--wangzhi--忽略的玩家ID--" + exceptClient.Id);
continue;
}
client.SendMsg(packet);
}
}
void OnRequestRaidRankingReceived(ClientPeer peer, OperationRequest operationRequest, SendParameters sendParameters)
{
var workRankingList = MongoHelper.RaidRankingCollection.GetAllSorting( ).GetAwaiter( );
workRankingList.OnCompleted(() =>
{
var rankingDataList = workRankingList.GetResult( );
if (rankingDataList == null || rankingDataList.Count == 0)
{
RaidRankingData data = CreateRaidRankingData(peer);
var workRankingAdd = MongoHelper.RaidRankingCollection.Add(data).GetAwaiter( );
workRankingAdd.OnCompleted(() =>
{
RankingEvent.OnUpdateRaidRanking(peer, data, null, new List <RaidRankingData> {
data
});
BossEvent.OnUpdateRaidBoss(peer, 16);
});
return;
}
// TODO : 보스 디졌는지 안디졌는지 확인
var myRankingData = rankingDataList.Find(x => x.Key.Equals(peer.Id));
var lastHitData = rankingDataList.Find(x => x.LastHit == true);
if (myRankingData == null)
{
myRankingData = CreateRaidRankingData(peer);
var workRankingAdd = MongoHelper.RaidRankingCollection.Add(myRankingData).GetAwaiter( );
workRankingAdd.OnCompleted(() =>
{
rankingDataList.Add(myRankingData);
RankingEvent.OnUpdateRaidRanking(peer, myRankingData, lastHitData, rankingDataList);
BossEvent.OnUpdateRaidBoss(peer, 16);
});
}
else
{
RankingEvent.OnUpdateRaidRanking(peer, myRankingData, lastHitData, rankingDataList);
BossEvent.OnUpdateRaidBoss(peer, 16);
}
});
}
private void deal(ClientPeer client, DealDto dto)
{
SingleExecute.Instance.Execute(() =>
{
if (!userCache.IsOnline(client))
{
return;
}
int userId = userCache.GetId(client);
if (userId != dto.UserId)
{
return;
}
FightRoom fightRoom = fightCache.GetRoomByUId(userId);
bool canDeal = fightRoom.DeadCard(dto.Type, dto.Weight, dto.Length, dto.UserId, dto.selectCardList);
if (canDeal == false)
{
client.Send(OpCode.FIGHT, FightCode.DEAL_SRES, -1);
return;
}
else
{
//send deal successful message
client.Send(OpCode.FIGHT, FightCode.DEAL_SRES, 0);
//check reamin hands
List <CardDto> remainCard = fightRoom.GetPlayerModel(userId).CardList;
dto.RemainCardList = remainCard;
Broadcast(fightRoom, OpCode.FIGHT, FightCode.DEAL_BROADCAST, dto);
if (remainCard.Count == 0)
{
Console.WriteLine("Game Over");
gameOver(userId, fightRoom);
}
else
{
Turn(fightRoom);
}
}
});
}
/// <summary>
/// 开始战斗
/// </summary>
/// <param name="clientList"></param>
/// <param name="roomType"></param>
public void StartFight(List <ClientPeer> clientList, int roomType)
{
SingleExecute.Instance.Execute(() =>
{
FightRoom room = fightCache.CreateRoom(clientList);
switch (roomType)
{
case 0:
room.bottomStakes = 10;
room.topStakes = 100;
room.lastPlayerStakesCount = 10;
break;
case 1:
room.bottomStakes = 20;
room.topStakes = 200;
room.lastPlayerStakesCount = 20;
break;
case 2:
room.bottomStakes = 50;
room.topStakes = 500;
room.lastPlayerStakesCount = 50;
break;
default:
break;
}
//选择庄家
ClientPeer bankerClient = room.SetBanker();
//发牌
room.DealCard();
//对手牌排序
room.SortAllPlayerCard();
//获得牌型
room.GetAllPlayerCardType();
room.Broadcase(OpCode.Fight, FightCode.StartFight_BRO, room.playerList);
//转换下注,换到下一个玩家下注
//TODO
});
}
public override void OnOperateRequest(byte[] bytes, ClientPeer peer, SendParameters sendParameters)
{
ReadyData readyData = PackageHelper.Desirialize <ReadyData>(bytes);
GameApplication application = GameApplication.Instance as GameApplication;
if (application == null)
{
return;
}
Room room = application.GetRoom(readyData.roomID);
ClientInfo clientInfo = application.GetClientInfo(peer as GameClientPeer);
if (room != null && clientInfo != null)
{
room.Ready(clientInfo);
}
}
/// <summary>
/// 广播消息
/// </summary>
/// <param name="opCode"></param>
/// <param name="subCode"></param>
/// <param name="value"></param>
/// <param name="client"></param>
public void Brocast(FightRoom room, int opCode, int subCode, object value, ClientPeer client = null)
{
byte[] msg = GetMsg(opCode, subCode, value);
//优化广播消息，进行一次沾包
foreach (var player in room.playerList)
{
if (user.IsOnLine(player.UserId))//为什么做这个判断。因为3个人，退出了一个之后只剩两个，此时player里面还是3个角色 第二个角色再次退出的时候就会抛异常
{
var target = user.GetClientById(player.UserId);
//给其他客户端发消息
if (client == target || !fight.IsFighting(player.UserId)) //提前退出的玩家不广播
{
continue;
}
target.StartSend(msg);
}
}
}
public void OutRoom(Room roomTemp, ClientPeer client)
{
if (roomTemp.userList.Count <= 1)
{
roomList.Remove(roomTemp);
if (roomTemp == room)
{
room.userDic.Clear();
room.userList.Clear();
}
return;
}
if (roomTemp.userDic.ContainsKey(client))
{
roomTemp.userList.Remove(roomTemp.userDic[client]);
roomTemp.userDic.Remove(client);
}
}
private void processCREQ(ClientPeer clientPeer, int chattype)
{
if (!UserCache.Instance.IsOnline(clientPeer))
{
return;
}
int uid = UserCache.Instance.GetId(clientPeer);
if (MatchCache.Instance.IsMatching(uid))
{
//如果用户正在匹配房间可以发送聊天信息
MatchRoom matchRoom = MatchCache.Instance.GetRoom(uid);
chatDto.Change(uid, chattype);
//向自己以外的玩家发送聊天消息
matchRoom.Broadcast(OpCode.CHAT, ChatCode.SBOD, chatDto);
}
//TODO在游戏房间也可以发送
}
void SendEventByPeer(ClientPeer peer, OperationCode opCode, SubCode subCode, List <Role> rolelList, int masterRoleId)
{
//OperationResponse response=new OperationResponse();
//response.Parameters=new Dictionary<byte, object>();
//ParameterTool.AddSubcode(response.Parameters,subCode);
//ParameterTool.AddParmeter(response.Parameters,ParameterCode.RoleList,rolelList);
//response.ReturnCode = (short) ReturnCode.GetTeam;
//peer.SendOperationResponse(response, sendParameters);
EventData eventData = new EventData();
eventData.Parameters = new Dictionary <byte, object>();
ParameterTool.AddParmeter(eventData.Parameters, ParameterCode.OperationCode, opCode, false);
ParameterTool.AddSubcode(eventData.Parameters, subCode);
ParameterTool.AddParmeter(eventData.Parameters, ParameterCode.RoleList, rolelList);
ParameterTool.AddParmeter(eventData.Parameters, ParameterCode.MasterRoleId, masterRoleId, false);
peer.SendEvent(eventData, new SendParameters());
}
/// <summary>
/// 技能升级
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
/// <param name="peer"></param>
/// <param name="sendParameters"></param>
void UpdateSkill(OperationRequest request, OperationResponse response, ClientPeer peer, SendParameters sendParameters)
{
Dictionary <byte, object> m_dic = request.Parameters;
object value;
response.ReturnCode = (short)ReturnCode.Fail;
// 客户端传递过来的参数信息：skillid,lv
if (m_dic.TryGetValue((byte)ParameterCode.SkillInfo, out value))
{
string strValue = value.ToString();
Helper.Log("UpdateSkill:" + strValue);
string[] pStr1 = strValue.Split(',');
if (pStr1.Length == 2)
{
int nSkillID = Helper.IntParse(pStr1[0]);
List <SkillData> pList = m_skillMgr.GetSkillBySkillID(nSkillID);
if (pList != null && pList.Count > 0)
{
SkillData data = pList[0];
data.Lv = Helper.IntParse(pStr1[1]);
// 更新角色金币
int nNeedGold = data.Lv * 100;
RoleData curRole = peer.m_curRole;
List <RoleInfoData> p = m_roleMgr.GetRoleData(curRole.Id);
if (p != null && p.Count > 0)
{
RoleInfoData curRoleData = p[0];
if (curRoleData.Gold >= nNeedGold && curRole.Lv > data.Lv)
{
// 客户端金币减少的时候会同步一次，这里不就用同步了
//m_roleMgr.UpdateRoleInfo(curRoleData);
data.Lv += 1;
m_skillMgr.UpdateSkill(data);
Helper.Log("UpdateSkill Success:" + data.SkillID);
response.ReturnCode = (short)ReturnCode.Success;
}
}
}
}
}
return;
}
public byte[] Login(byte[] data, ClientPeer client, MainServer server)
{
AccountInfo recive = MessageTool.ProtoBufDataDeSerialize <AccountInfo>(data);
AccountInfo user = mAccount.VerifyUser(client.MySQLConn, recive.AccountName, recive.Password);
MSGCallBack msg;
if (user == null)
{
msg = new MSGCallBack(ReturnCode.Fail);
}
else
{
client.IsOnLine = true;
client.SetCurAccountData(user);
msg = new MSGCallBack(ReturnCode.Success);
}
return(MessageTool.ProtoBufDataSerialize(msg));
}
/// <summary>
/// 获取角色信息
/// </summary>
/// <returns></returns>
private void getUserInfo(ClientPeer client)
{
if (!accountCache.IsOnline(client))
{
throw new IndexOutOfRangeException("账号不在线，不能获取角色信息");
}
int accid = accountCache.GetId(client);
if (!userModelCache.IsExistUserModel(accid))
{
client.Send(OpCode.USER, UserSubCode.GET_USER_INFO_SRES, null);
return;
}
UserModel userModel = userModelCache.GetModelByAccid(accid);
UserDto userDto = new UserDto(userModel.Id, userModel.Name, userModel.Been, userModel.Win, userModel.Fail, userModel.Escape, userModel.Lv, userModel.Exp);
client.Send(OpCode.USER, UserSubCode.GET_USER_INFO_SRES, userDto);
return;
}
public void OnReceive(ClientPeer client, SocketMsg msg)
{
var code = (UserCode)msg.SubCode;
switch (msg.SubCode)
{
case UserCode.CreateCharacterRequest:
Create(client, msg.value.ToString());
break;
case UserCode.GetInfoRequest:
GetCharacterInfo(client);
break;
case UserCode.OnlineRequest:
Online(client);
break;
}
}
/// <summary>
/// 获取怪物和最近玩家之间的距离
/// </summary>
float GetMinDis(Monster monster, out Vector3 _vRole)
{
float minDis = int.MaxValue;
_vRole = monster.m_curPos;
for (int i = 0; i < m_pTeamPeer.Count; ++i)
{
ClientPeer curPeer = m_pTeamPeer[i];
Vector3 vRolePos = curPeer.m_vCurPos;
Vector3 vMPos = monster.m_curPos;
float d = Vector3.Distance(vMPos, vRolePos);
if (d < minDis)
{
minDis = d;
_vRole = vRolePos;
}
}
return(minDis);
}
private void HandleEnterRoom(ClientPeer client)
{
if (Sessions.matchSession.IsMatching(client)) // 已在队列中则不管
{
return;
}
//先进入房间
MatchRoom room = Sessions.matchSession.EnterRoom(client);
UserInfoDto userInfoDto = DatabaseManager.CreateUserInfoDto(client.userId);
//然后向其他房间内用户广播进入房间信息
room.Broadcast(OpCode.match, MatchCode.EnterBrd, userInfoDto, client);
//最后向客户端返回当前的房间信息
MatchRoomDto matchRoomDto = room.CreateMatchRoomDto();
client.SendNetMsg(OpCode.match, MatchCode.EnterSRes, matchRoomDto);
}
public static void OnUpdateResource(ClientPeer peer)
{
TheLordServer.Log.InfoFormat("[OnUpdateResource] - {0}", peer.RemoteIPAddress);
if (peer.userAgent.UserData == null || peer.userAgent.UserAssetData == null)
{
// 로그인 씬으로
return;
}
EventData data = new EventData((byte)EventCode.UpdateResource);
var packet = new ProtoData.ResourceData( );
packet.gold = peer.userAgent.UserAssetData.Gold;
packet.cash = peer.userAgent.UserAssetData.Cash;
packet.index = peer.userAgent.UserAssetData.Index;
packet.tier = peer.userAgent.UserAssetData.Tier;
data.Parameters = BinSerializer.ConvertPacket(packet);
peer.SendEvent(data, new SendParameters( ));
}
/// <summary>
/// 解析数据
/// </summary>
/// <param name="client"></param>
/// <param name="msg"></param>
public void OnReceive(ClientPeer client, SocketMsg msg)
{
var code = (MatchCode)msg.SubCode;
switch (code)
{
case MatchCode.EnterMatch_Request:
Enter(client);
break;
case MatchCode.LeaveMatch_Request:
Leave(client);
break;
case MatchCode.Ready_Request:
Ready(client);
break;
}
}
public static void OnUpdateRaidBoss(ClientPeer peer, int index)
{
EventData eventData = new EventData((byte)EventCode.UpdateRaidBoss);
var bossData = TheLordServer.Instance.bossDataList[0];
if (bossData == null)
{
TheLordServer.Log.Info("보스가 없습니다.");
return;
}
var packet = new ProtoData.RaidBossData( );
packet.index = bossData.Index;
packet.hp = (int)bossData.HP;
eventData.Parameters = BinSerializer.ConvertPacket(packet);
peer.SendEvent(eventData, new SendParameters( ));
}
public void StartClient(List<SinkNode> sinkNodes)
{
foreach (var sinkNode in sinkNodes)
{
string ipAddress = sinkNode.IPAddress;
int port = Convert.ToInt32(sinkNode.Port);
ClientPeer client = new ClientPeer(sinkNode.Id.ToString(),
new TwoBytesNboHeaderChannel(new Iso8583Ascii1987BinaryBitmapMessageFormatter(), ipAddress, port),
new BasicMessagesIdentifier(11, 41));
client.RequestDone += new PeerRequestDoneEventHandler(Client_RequestDone);
client.RequestCancelled += new PeerRequestCancelledEventHandler(Client_RequestCancelled);
client.Connected += new PeerConnectedEventHandler(ClientPeerConnected);
client.Receive += new PeerReceiveEventHandler(ClientPeerOnReceive);
client.Disconnected += new PeerDisconnectedEventHandler(ClientPeerDisconnected);
//client.Connect();
}
}
public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer, SendParameters sendParameters)
{
SubCode subCode = ParameterTool.GetSubCode(request.Parameters);
ParameterTool.AddSubCode(response.Parameters,subCode);
switch (subCode)
{
case SubCode.Add:
SkillDB skillDB = ParameterTool.GetParameter<SkillDB>(request.Parameters, ParameterCode.SkillDB);
skillDB.Role = peer.LoginRole;
skillDBManager.Add(skillDB);
skillDB.Role = null;
ParameterTool.AddParameter(response.Parameters,ParameterCode.SkillDB,skillDB);
break;
case SubCode.Get:
List<SkillDB> list = skillDBManager.Get(peer.LoginRole);
foreach (var temp in list)
{
temp.Role = null;
}
ParameterTool.AddParameter(response.Parameters,ParameterCode.SkillDBList,list);
break;
case SubCode.Update:
SkillDB skillDB2 = ParameterTool.GetParameter<SkillDB>(request.Parameters, ParameterCode.SkillDB);
skillDB2.Role = peer.LoginRole;
skillDBManager.Update(skillDB2);
break;
case SubCode.Upgrade:
SkillDB skillDB3 = ParameterTool.GetParameter<SkillDB>(request.Parameters, ParameterCode.SkillDB);
Role role = ParameterTool.GetParameter<Role>(request.Parameters, ParameterCode.Role);
role.User = peer.LoginUser;
skillDB3.Role = role;
skillDBManager.Upgrade(skillDB3,role);
skillDB3.Role = null;
ParameterTool.AddParameter(response.Parameters,ParameterCode.SkillDB, skillDB3);
break;
}
}
//得到客户端传递过来的user对象，根据用户名和密码进行查询，查询是否存在数据库，如果存在登录成功，否则登录失败
public override void OnHandlerMessage(Photon.SocketServer.OperationRequest request, OperationResponse response, ClientPeer peer, SendParameters sendParameters)
{
//得到user参数
Dictionary<byte, object> parameters = request.Parameters;
object jsonObject = null;
parameters.TryGetValue((byte) ParameterCode.User, out jsonObject);
//把字符串转成user的对象
User user = JsonMapper.ToObject<User>(jsonObject.ToString());
User userDB = manager.GetUserByUsername(user.Username);
if (userDB != null && userDB.Password == MD5Tool.GetMD5(user.Password))
{
//用户名和密码正确 登录成功
response.ReturnCode =(short)ReturnCode.Success;
peer.LoginUser = userDB;
}
else
{
response.ReturnCode = (short) ReturnCode.Fail;
response.DebugMessage = "用户名或密码错误";
}
}
private void SentEventByPeer(ClientPeer peer,OperationCode opCode, SubCode subcode,List<Role> rolelist,int masterRoleID)
{
//OperationResponse response = new OperationResponse();
//response.Parameters = new Dictionary<byte, object>();
//ParameterTool.AddSubCode(response.Parameters,subcode);
//ParameterTool.AddParameter(response.Parameters,ParameterCode.RoleList, rolelist);
//response.ReturnCode = (short) ReturnCode.GetTeam;
//peer.SendOperationResponse(response, sendParameters);
EventData eventData = new EventData();
eventData.Parameters = new Dictionary<byte, object>();
ParameterTool.AddParameter(eventData.Parameters,ParameterCode.OperationCode,opCode,false);
ParameterTool.AddSubCode(eventData.Parameters,subcode);
ParameterTool.AddParameter(eventData.Parameters,ParameterCode.RoleList,rolelist);
ParameterTool.AddParameter(eventData.Parameters,ParameterCode.MasterRoleID, masterRoleID,false);
peer.SendEvent(eventData,new SendParameters());
}
private void SendMoveAnimationEvent(ClientPeer peer,OperationCode opCode,SubCode subCode,int roleID,Dictionary<byte,object> parameters )
{
EventData data = new EventData();
data.Parameters = parameters;
ParameterTool.AddOperationcodeSubcodeRoleID(parameters,opCode,roleID);
peer.SendEvent(data, new SendParameters());
}
public override void OnHandlerMessage(OperationRequest request, OperationResponse response, ClientPeer peer, SendParameters sendParameters)
{
SubCode subcode = ParameterTool.GetSubCode(request.Parameters);
ParameterTool.AddSubCode(response.Parameters,subcode);
switch (subcode)
{
//组队
case SubCode.SendTeam:
if (TaidouApplication.Instance.clientPeersForTeam.Count >= 2)
{
//取得list中的前两个peer 跟当前的peer进行组队
ClientPeer peer1 = TaidouApplication.Instance.clientPeersForTeam[0];
ClientPeer peer2 = TaidouApplication.Instance.clientPeersForTeam[1];
Team t = new Team(peer1,peer2,peer);
TaidouApplication.Instance.clientPeersForTeam.RemoveRange(0,2);
//当前队伍里面的角色
List<Role> roleList = new List<Role>();
foreach (var clientPeer in t.clientPeers)
{
roleList.Add(clientPeer.LoginRole);
}
ParameterTool.AddParameter(response.Parameters,ParameterCode.RoleList, roleList);
ParameterTool.AddParameter(response.Parameters,ParameterCode.MasterRoleID,t.masterRoleId ,false);
response.ReturnCode = (short) ReturnCode.GetTeam;
//给其他客户端发起响应
SentEventByPeer(peer1,(OperationCode) response.OperationCode, SubCode.GetTeam, roleList,t.masterRoleId);
SentEventByPeer(peer2,(OperationCode) response.OperationCode, SubCode.GetTeam, roleList,t.masterRoleId);
}
else
{
//当当前服务器可供组队的客户端不足的时候，把自身添加到集合中等待组队
TaidouApplication.Instance.clientPeersForTeam.Add(peer);
response.ReturnCode = (short) ReturnCode.WaitingTeam;
}
break;
//取消组队
case SubCode.CancelTeam:
TaidouApplication.Instance.clientPeersForTeam.Remove(peer);
response.ReturnCode = (short) ReturnCode.Success;
break;
//同步位置和旋转
case SubCode.SyncPositionAndRotation:
//位置
object posObj = null;
request.Parameters.TryGetValue((byte) ParameterCode.Position, out posObj);
//旋转
object eulerAnglesObj = null;
request.Parameters.TryGetValue((byte) ParameterCode.EulerAngle, out eulerAnglesObj);
//角色ID
foreach (ClientPeer temp in peer.Team.clientPeers)
{
//判断是否是当前的客户端
if (temp != peer)
{
//向其他客户端发送请求
SendEventByPeer(temp,OpCode,SubCode.SyncPositionAndRotation,peer.LoginRole.ID,posObj,eulerAnglesObj);
}
}
break;
//同步移动动作
case SubCode.SyncMoveAnimation:
foreach (ClientPeer temp in peer.Team.clientPeers)
{
//判断是否是当前的客户端
if (temp != peer)
{
SendMoveAnimationEvent(temp,OpCode,SubCode.SyncMoveAnimation,peer.LoginRole.ID,request.Parameters);
}
}
break;
case SubCode.SyncAnimation:
request.Parameters.Add((byte) ParameterCode.RoleID,peer.LoginRole);
RequestTool.TransmitRequest(peer,request,OpCode);
break;
case SubCode.SendGameState:
RequestTool.TransmitRequest(peer,request,OpCode);
peer.Team.Dismiss();//解散队伍
break;
}
}
public override OperationResponse OnHandlerMeesage(OperationRequest request, ClientPeer peer)
{
var subCode = ParameterTool.GetParameter<SubCode>(request.Parameters, ParameterCode.SubCode, false);
peer.WriteLog("Handling Request OperationCode:Role SubCode:" + subCode);
var parameters = new Dictionary<byte, object>
{
{(byte) ParameterCode.SubCode, subCode}
};
var response = new OperationResponse
{
OperationCode = request.OperationCode,
ReturnCode = (short) ReturnCode.Success
};
peer.WriteLog(subCode.ToString());
switch (subCode)
{
case SubCode.GetRole:
//1.返回当前用户的角色列表
var roles = _manager.GetRoles(peer.User);
foreach (var role1 in roles)
{
role1.User = null;
}
var json = JsonMapper.ToJson(roles);
parameters.Add((byte) ParameterCode.RoleList, json);
break;
case SubCode.AddRole:
//2.为当前用户添加一个角色
var role = ParameterTool.GetParameter<Role>(request.Parameters, ParameterCode.Role);
if (_manager.ContainRole(role.Name))
{
response.ReturnCode = (short) ReturnCode.Fail;
response.DebugMessage = "昵称已被占用";
}
else
{
role.User = peer.User;
response.ReturnCode = (short) (_manager.AddRole(role) ? ReturnCode.Success : ReturnCode.Fail);
role.User = null;
json = JsonMapper.ToJson(role);
parameters.Add((byte) ParameterCode.Role, json);
}
break;
case SubCode.SelectRole:
//3.设定登录的角色
role = ParameterTool.GetParameter<Role>(request.Parameters, ParameterCode.Role);
peer.SetLoginRole(role);
ParameterTool.AddParameter(parameters, ParameterCode.Role, role);
role.User = peer.User;
break;
case SubCode.UpdateRole:
//更新当前角色信息
role = ParameterTool.GetParameter<Role>(request.Parameters, ParameterCode.Role);
role.User = peer.User;
_manager.UpdateRole(role);
role.User = null;
ParameterTool.AddParameter(parameters, ParameterCode.Role, role);
break;
default:
throw new ArgumentOutOfRangeException();
}
response.Parameters = parameters;
return response;
}
public abstract OperationResponse OnHandlerMeesage(OperationRequest request, ClientPeer peer);
//向客户端发送位置和旋转的数据 进行同步
private void SendEventByPeer(ClientPeer peer,OperationCode opCode,SubCode subCode,int roleId,object posObj,object eulerAnglesObj)
{
EventData data = new EventData();
data.Parameters = new Dictionary<byte, object>();
ParameterTool.AddParameter(data.Parameters,ParameterCode.OperationCode, opCode,false);
ParameterTool.AddParameter(data.Parameters,ParameterCode.SubCode, subCode,false);
data.Parameters.Add((byte) ParameterCode.RoleID,roleId);
data.Parameters.Add((byte) ParameterCode.Position,posObj.ToString());
data.Parameters.Add((byte) ParameterCode.EulerAngle,eulerAnglesObj.ToString());
peer.SendEvent(data, new SendParameters());
}
private Iso8583Message ToFEP(Iso8583Message msgToSend, SinkNode sinkNode, out bool needReversal)
{
Message response = null;
string responseMsg = string.Empty;
needReversal = false;
try
{
if (msgToSend == null)
{
Logger.Log("Iso message is null.");
return SetReponseMessage(msgToSend, "20"); //Invalid response
}
if (sinkNode == null)
{
Logger.Log("Sink node is null.");
return SetReponseMessage(msgToSend, "91"); //Issuer inoperative
}
int maxNoRetries = 3;
int serverTimeout = 60000;
sinkNode.IsActive = true;
ClientPeer _clientPeer = new ClientPeer(sinkNode.Name, new TwoBytesNboHeaderChannel(
new Iso8583Ascii1987BinaryBitmapMessageFormatter(), sinkNode.IPAddress,
Convert.ToInt16(sinkNode.Port)), new Trx.Messaging.BasicMessagesIdentifier(11));
_clientPeer.Connect();
Thread.Sleep(1800);
int retries = 0;
while (retries < maxNoRetries)
{
if (_clientPeer.IsConnected)
{
break;
}
else
{
_clientPeer.Close();
retries++;
_clientPeer.Connect();
}
Thread.Sleep(2000);
}
PeerRequest request = null;
if (_clientPeer.IsConnected)
{
request = new PeerRequest(_clientPeer, msgToSend);
request.Send();
request.WaitResponse(serverTimeout);
//request.MarkAsExpired(); //uncomment to test timeout
if (request.Expired)
{
Logger.Log("Connection timeout.");
needReversal = true;
return SetReponseMessage(msgToSend, "68"); //Response received too late
}
if (request != null)
{
response = request.ResponseMessage;
//ResponseMessage = GetResponseMesage(response as Iso8583Message);
}
return response as Iso8583Message;
}
else
{
Console.WriteLine("\n Could not connect to the Sink Node..");
Console.BackgroundColor = ConsoleColor.Red;
Logger.Log("\n Could not connect to the Sink Node.");
return SetReponseMessage(msgToSend, "91");
}
}
catch (Exception ex)
{
Logger.Log("ERROR: " + ex.Message);
return SetReponseMessage(msgToSend, "06"); //Error
}
}
