/// <summary>
/// 返回断线信息
/// 用于把用户踢出
/// </summary>
public static GameData Offline()
{
GameData data = new GameData();
data.operateCode = OperateCode.Offline;
data.returnCode = ReturnCode.Refuse;
return data;
}
/// <summary>
/// 对外接口
/// 处理所有的TCP数据
/// 并返回相应
/// 如果返回null则不发送
/// </summary>
public GameData ProcessTcpData(GameData data, Socket socket)
{
int operateCode = data.operateCode;
string operateData = data.operateData;
//分发操作
switch (operateCode)
{
case OperateCode.Identify:
{
string UUID = operateData;
if (TCPDataSender.CheckUUID(UUID))
{
return ProcessIdentify(UUID, socket);
}
else
{
return TCPDataSender.Offline();
}
}
case OperateCode.HeartBeat:
{
HeartBeatSystem.Instance.ProcessHeartBeatPackage(socket);
return null;
}
case OperateCode.Offline:
{
return ProcessCancelMatching(JsonCoding<DisconnectDTO>.decode(data.operateData), socket);
}
case OperateCode.SummonCharacter:
{
return ProcessSummonCharacter(data, socket);
}
case OperateCode.Attack:
{
return ProcessCommonAttack(data, socket);
}
case OperateCode.UseSkill:
{
return ProcessUseSkill(data, socket);
}
case OperateCode.PlayerOwnCard:
{
return ProcessPlayerOwnCard(data, socket);
}
case OperateCode.OperateEquip:
{
return ProcessOperateEquip(data, socket);
}
default:
{
break;
}
}
return null;
}
/// <summary>
/// 把socket连接添加到房间
/// </summary>
/// <param name="socket"></param>
public void AddUnknownSocket(Socket socket)
{
unknownSocket.Add(socket);//添加未知的连接
//发送请求身份验证
GameData data = new GameData();
data.roomID = -1;
data.returnCode = ReturnCode.Request;
data.operateCode = OperateCode.Identify;
TcpServer.Instance.Send(socket, data);
}
/// <summary>
/// 处理卡片使用技能的信息包
/// </summary>
private GameData ProcessUseSkill(GameData data, Socket socket)
{
UseSkillData detail = JsonCoding<UseSkillData>.decode(data.operateData);
GameRoom room = TcpServer.Instance.GetGameRoomManager().GetRoom(data.roomID);
PlayerCard from = GetPlayerCard(data.roomID, detail.fromCardUUID);
PlayerCard to = GetPlayerCard(data.roomID, detail.toCardUUID);
Skill skill = from.GetSkillById(detail.skillID);
if (from.currentEnergy >= skill.skillEnergyCost)
{
//拥有足够能量
skill.OnUse(from, to);//调用技能
detail.skillAppendData = skill.GenerateSkillAppendData();
}
else
{
//没有足够能量
data.returnCode = ReturnCode.Failed;
}
data.operateData = JsonCoding<UseSkillData>.encode(detail);//重新打包
room.SendOperateToAllPlayer(data);//发送全局
return null;
}
/// <summary>
/// 处理玩家召唤怪物到场上
/// 修改服务器本地场景内容
/// 将操作数据发送给双方
/// </summary>
private GameData ProcessSummonCharacter(GameData data, Socket socket)
{
SummonCharacterData detailData = JsonCoding<SummonCharacterData>.decode(data.operateData);
int roomID = data.roomID;
string cardUUID = detailData.cardUUID;
GameRoomManager grm = TcpServer.Instance.GetGameRoomManager();
GameRoom room = grm.GetRoom(roomID);
if (room.playerSocketA.socket == socket || room.playerSocketB.socket == socket)
{
if (room.playerSocketA.socket == socket)
{
//A
if (room.playerDataA.IsOwnCard(cardUUID))
{
//正常召唤
foreach (PlayerCard playerCard in room.playerDataA.characterCardInv)
{
if (playerCard.cardUUID == cardUUID)
{
room.playerDataA.AddPlayerCard(playerCard);//添加到英雄区
LogsSystem.Instance.Print(string.Format("A召唤{0}到场上", playerCard.cardName));
break;
}
}
}
else
{
//报错
LogsSystem.Instance.Print("程序出现异常：没有找到该卡的UUID:" + cardUUID, LogLevel.ERROR);
}
}
else
{
//B
if (room.playerDataB.IsOwnCard(cardUUID))
{
//正常召唤
foreach (PlayerCard playerCard in room.playerDataB.characterCardInv)
{
if (playerCard.cardUUID == cardUUID)
{
room.playerDataB.AddPlayerCard(playerCard);//添加到英雄区
LogsSystem.Instance.Print(string.Format("B召唤{0}到场上", playerCard.cardName));
break;
}
}
}
else
{
//报错
LogsSystem.Instance.Print("程序出现异常：没有找到该卡的UUID:" + cardUUID, LogLevel.ERROR);
}
}
}
else
{
LogsSystem.Instance.Print(string.Format("出现异常:房间{0}内没有找到对应的socket链接", roomID), LogLevel.ERROR);
}
room.SendOperateToAllPlayer(data);//将操作数据原样返回
return null;//把数据原样返回
}
/// <summary>
/// 处理对卡片背包的请求
/// </summary>
private GameData ProcessPlayerOwnCard(GameData data, Socket socket)
{
GameRoom room = TcpServer.Instance.GetGameRoomManager().GetRoom(data.roomID);
GamePlayerOwnCardData detail = JsonCoding<GamePlayerOwnCardData>.decode(data.operateData);
if (room != null)
{
return TcpServer.Instance.GetTCPDataSender().SendPlayerOwnCard(detail, room);
}
else
{
LogsSystem.Instance.Print("房间号不合法", LogLevel.WARN);
return null;
}
}
/// <summary>
/// 处理对操作装备的请求
/// </summary>
private GameData ProcessOperateEquip(GameData data, Socket socket)
{
OperateEquipData detail = JsonCoding<OperateEquipData>.decode(data.operateData);
PlayerCard operateCard = GetPlayerCard(data.roomID, detail.operateCardUUID);
ItemCard operateItem = CardManager.Instance.GetItemCloneByID(detail.equipCardId);
if(operateItem is EquipmentCard)
{
EquipmentCard equipmentCard = operateItem as EquipmentCard;
int equipPosition = detail.equipPosition;
operateCard.playerEquipment.Equip(equipPosition, equipmentCard);
}
else
{
LogsSystem.Instance.Print("不合法操作");
}
return null;
}
/// <summary>
/// 处理普通攻击
/// 将本地数据进行处理
/// 拆包后添加入伤害值返回
/// </summary>
private GameData ProcessCommonAttack(GameData data, Socket socket)
{
AttackData detailData = JsonCoding<AttackData>.decode(data.operateData);
GameRoom room = TcpServer.Instance.GetGameRoomManager().GetRoom(data.roomID);
//获取伤害值
string fromCardUUID = detailData.fromCardUUID;
string toCardUUID = detailData.toCardUUID;
int operatePlayerPosition = detailData.operatePlayerPosition;
int damage = 0;
if (room.playerDataA.IsOwnCard(fromCardUUID))
{
damage = room.playerDataA.GetPlayerCardByCardUUID(fromCardUUID).GetAttack();//获取攻击力
room.playerDataB.GetPlayerCardByCardUUID(toCardUUID).GetDamage(damage);//伤害扣血
}
else if (room.playerDataB.IsOwnCard(fromCardUUID))
{
damage = room.playerDataB.GetPlayerCardByCardUUID(fromCardUUID).GetAttack();//获取攻击力
room.playerDataA.GetPlayerCardByCardUUID(toCardUUID).GetDamage(damage);//伤害扣血
}
else
{
LogsSystem.Instance.Print("场上未找到发起攻击的卡片");
}
detailData.damage = damage;
data.operateData = JsonCoding<AttackData>.encode(detailData);//将修改过的数据压回去
room.SendOperateToAllPlayer(data);
return null;
}
/// <summary>
/// 将数据包发送给房间内两方玩家
/// 常用于数据操作
/// </summary>
/// <param name="data"></param>
public void SendOperateToAllPlayer(GameData data)
{
TcpServer.Instance.Send(playerSocketA.socket, data);
TcpServer.Instance.Send(playerSocketB.socket, data);
}
/// <summary>
/// 计时器回调函数
/// </summary>
private void SendHeartBeatPackage(object target)
{
if (target is PlayerSocket)
{
PlayerSocket playerSocket = target as PlayerSocket;
if (playerSocket.socket.Connected)
{
GameData data = new GameData();
data.operateCode = OperateCode.HeartBeat;
data.operateData = JsonCoding<CommonDTO>.encode(new CommonDTO());
TcpServer.Instance.Send(playerSocket.socket, data);
}
else
{
//断线
RemoveHeartBeatObject(playerSocket);//移除对象
}
}
else
{
LogsSystem.Instance.Print("计时器回调函数接受数据异常，计时器无法正常工作:" + target, LogLevel.ERROR);
}
}
/// <summary>
/// 根据玩家的UUID和UID
/// 发送玩家拥有的卡片(仅在此时创建卡片的UUID)
/// </summary>
public GameData SendPlayerOwnCard(GamePlayerOwnCardData requestData, GameRoom room)
{
int uid = requestData.operatePlayerUid;
string UUID = requestData.operatePlayerUUID;
GameRoom.PlayerPosition position = (GameRoom.PlayerPosition)requestData.operatePlayerPosition;
if (CheckUUID(UUID))
{
string command;
List<PlayerCard> playerCardList = new List<PlayerCard>();
CardManager cardManager = CardManager.Instance;
//获取背包信息
requestData.cardInv = new List<CardInfo>();
command = string.Format("SELECT * FROM cardinventory WHERE CardOwnerId = '{0}'", uid);
DataSet cardInventory = MySQLHelper.GetDataSet(MySQLHelper.Conn, CommandType.Text, command, null);
foreach (DataRow row in cardInventory.Tables[0].Rows)
{
try
{
int cardID = Convert.ToInt32(row["CardId"]);
CharacterCard standardCharacterCard = cardManager.GetCharacterCloneByID(cardID);
PlayerCard playerCard = new PlayerCard();
//卡片通用
playerCard.cardUUID = System.Guid.NewGuid().ToString();//创建卡片的UUID作为唯一标识
playerCard.cardId = cardID;
playerCard.cardName = standardCharacterCard.cardName;
playerCard.cardRarity = standardCharacterCard.cardRarity;
//角色卡通用
playerCard.baseHealth = standardCharacterCard.baseHealth;
playerCard.baseEnergy = standardCharacterCard.baseEnergy;
playerCard.baseAttack = standardCharacterCard.baseAttack;
playerCard.baseSpeed = standardCharacterCard.baseSpeed;
playerCard.growHealth = standardCharacterCard.growHealth;
playerCard.growEnergy = standardCharacterCard.growEnergy;
playerCard.growAttack = standardCharacterCard.growAttack;
playerCard.growSpeed = standardCharacterCard.growSpeed;
//游戏卡个性化
playerCard.cardOwnerId = Convert.ToInt32(row["CardOwnerId"]);
playerCard.cardLevel = Convert.ToInt32(row["CardLevel"]);
playerCard.specialHealth = Convert.ToInt32(row["SpecialHealth"]);
playerCard.specialEnergy = Convert.ToInt32(row["SpecialEnergy"]);
playerCard.specialAttack = Convert.ToInt32(row["SpecialAttack"]);
playerCard.specialSpeed = Convert.ToInt32(row["SpecialSpeed"]);
playerCard.InitHealthAndEnergy();
//设置卡片拥有技能
int[] skillIdArray = IntArray.StringToIntArray(row["CardOwnSkill"].ToString());//获取卡片技能的ID列表
SkillManager skillManager = TcpServer.Instance.GetSkillManager();
foreach (int skillId in skillIdArray)
{
Skill skill = skillManager.GetSkillById(skillId);//从技能管理器中获取该技能的克隆
playerCard.AddSkill(skill);
}
CardInfo cardInfo = playerCard.GetCardInfo();
requestData.cardInv.Add(cardInfo);//添加到列表
playerCardList.Add(playerCard);//添加卡片
}
catch (Exception ex)
{
LogsSystem.Instance.Print(ex.ToString(), LogLevel.WARN);
}
}
//将数据加载到本地内存
room.SetCardInv(playerCardList, position);
//封装返回数据
GameData returnData = new GameData();
returnData.operateCode = OperateCode.PlayerOwnCard;
returnData.roomID = room.roomID;
returnData.returnCode = ReturnCode.Success;
returnData.operateData = JsonCoding<GamePlayerOwnCardData>.encode(requestData);
return returnData;
}
else
{
return Offline();
}
}
/// <summary>
/// 向客户端发送状态修改操作的请求
/// </summary>
public void SendStateOperate(StateSkill skill, PlayerCard operateCard, int operateType, int operatePosition, GameRoom gameRoom)
{
OperateStateData detail = new OperateStateData();
detail.skillID = skill.skillID;
detail.stateOperate = operateType;
detail.ownerCardUUID = operateCard.cardUUID;
detail.appendData = skill.GenerateSkillAppendData();//将技能生成的数据附加值传递
switch (operateCard.GetCardOwnerPosition())
{
case 0://A
{
detail.operatePlayerPosition = 0;
detail.operatePlayerUid = gameRoom.playerSocketA.playerInfo.playerUid;
detail.operatePlayerUUID = gameRoom.playerSocketA.playerInfo.playerUUID;
break;
}
case 1://B
{
detail.operatePlayerPosition = 1;
detail.operatePlayerUid = gameRoom.playerSocketB.playerInfo.playerUid;
detail.operatePlayerUUID = gameRoom.playerSocketB.playerInfo.playerUUID;
break;
}
default:
{
LogsSystem.Instance.Print("错误:卡片拥有者的位置出现错误:" + operateCard.GetCardOwnerPosition(), LogLevel.WARN);
break;
}
}
GameData data = new GameData();
data.returnCode = ReturnCode.Success;
data.roomID = gameRoom.roomID;
data.operateCode = OperateCode.OperateState;
data.operateData = JsonCoding<OperateStateData>.encode(detail);
gameRoom.SendOperateToAllPlayer(data);
}
/// <summary>
/// 玩家登陆大厅
/// </summary>
public void PlayerLoginLobby(int uid, string playerName, string UUID, IPEndPoint iped)
{
//检查玩家是否已经登陆。如果已登陆则踢出之前的
foreach (Player onlinePlayer in lobbyPlayerList)
{
if (onlinePlayer.uid == uid && onlinePlayer.UUID != UUID)
{
//踢出大厅
SocketModel model = new SocketModel();
model.protocol = SocketProtocol.OFFLINE;
model.returnCode = ReturnCode.Refuse;
UdpServer.Instance.SendMsg(JsonCoding<SocketModel>.encode(model), onlinePlayer.IPed.Address.ToString(), onlinePlayer.IPed.Port);//发送断线消息
this.lobbyPlayerList.Remove(onlinePlayer);
//踢出游戏
foreach (PlayerSocket gameOnlinePlayer in gamePlayerList)
{
if (gameOnlinePlayer.playerInfo.playerUid == onlinePlayer.uid)
{
GameData data = new GameData();
data.operateCode = OperateCode.Offline;
data.returnCode = ReturnCode.Refuse;
TcpServer.Instance.Send(gameOnlinePlayer.socket, data);
this.gamePlayerList.Remove(gameOnlinePlayer);
break;//离开游戏玩家列表遍历循环
}
}
break;//离开大厅玩家列表遍历循环
}
}
//登陆系统
Player player = new Player();
player.uid = uid;
player.playerName = playerName;
player.UUID = UUID;
player.IPed = iped;
this.lobbyPlayerList.Add(player);
//登陆成功
LogsSystem.Instance.Print(string.Format("玩家{0}[{1}]已登录到游戏", playerName, iped.Address.ToString()));
}
/// <summary>
/// 玩家登陆游戏服务器
/// </summary>
public void PlayerLoginGameServer(int uid, string playerName, string UUID, Socket socket)
{
//检查玩家是否已经登陆。如果已登陆则踢出之前的
foreach (PlayerSocket onlinePlayer in gamePlayerList)
{
string onlinePlayerUUID = onlinePlayer.playerInfo.playerUUID;
if (onlinePlayerUUID == UUID)
{
GameData data = new GameData();
data.operateCode = OperateCode.Offline;
data.returnCode = ReturnCode.Refuse;
TcpServer.Instance.Send(onlinePlayer.socket, data);
//TcpServer.Instance.
//UdpServer.Instance.SendMsg(JsonCoding<GameData>.encode(model), onlinePlayer.IPed.Address.ToString(), onlinePlayer.IPed.Port);//发送断线消息
this.gamePlayerList.Remove(onlinePlayer);
}
}
//登陆系统
PlayerInfoData pid = new PlayerInfoData();
pid.playerUid = uid;
pid.playerName = playerName;
pid.playerUUID = UUID;
PlayerSocket ps = new PlayerSocket(pid, socket);
this.gamePlayerList.Add(ps);
}
/// <summary>
/// 创建房间
/// </summary>
public GameRoom CreateRoom(PlayerSocket playerSocketA, PlayerSocket playerSocketB)
{
int roomID = availableRoomID;
GameRoom newroom = new GameRoom(roomID, playerSocketA, playerSocketB);
rooms.Add(newroom);
availableRoomID++;
/*
//对playerA发送的卡片信息
TcpServer.Instance.Send(playerSocketA.socket, TcpServer.Instance.GetTCPDataSender().SendPlayerOwnCard(newroom, GameRoom.PlayerPosition.A));
//对playerB发送的卡片信息
TcpServer.Instance.Send(playerSocketB.socket, TcpServer.Instance.GetTCPDataSender().SendPlayerOwnCard(newroom, GameRoom.PlayerPosition.B));
*/
//发送数据,让客户端建立房间
//通用数据
GameData roomData = new GameData();
roomData.operateCode = OperateCode.AllocRoom;
roomData.returnCode = ReturnCode.Success;
//对playerA发送的房间信息
AllocRoomData roomDataToPlayerA = new AllocRoomData();
roomDataToPlayerA.roomID = roomID;
roomDataToPlayerA.allocPosition = AllocRoomData.Position.A;
roomDataToPlayerA.rivalName = playerSocketB.playerInfo.playerName;
roomDataToPlayerA.rivalUid = playerSocketB.playerInfo.playerUid;
roomDataToPlayerA.rivalUUID = playerSocketB.playerInfo.playerUUID;
string messageToA = JsonCoding<AllocRoomData>.encode(roomDataToPlayerA);
//对playerB发送的房间信息
AllocRoomData roomDataToPlayerB = new AllocRoomData();
roomDataToPlayerB.roomID = roomID;
roomDataToPlayerB.allocPosition = AllocRoomData.Position.B;
roomDataToPlayerB.rivalName = playerSocketA.playerInfo.playerName;
roomDataToPlayerB.rivalUid = playerSocketA.playerInfo.playerUid;
roomDataToPlayerB.rivalUUID = playerSocketA.playerInfo.playerUUID;
string messageToB = JsonCoding<AllocRoomData>.encode(roomDataToPlayerB);
//对A发送信息
roomData.operateData = messageToA;
TcpServer.Instance.Send(playerSocketA.socket, roomData);
//对B发送信息
roomData.operateData = messageToB;
TcpServer.Instance.Send(playerSocketB.socket, roomData);
LogsSystem.Instance.Print(string.Format("房间{0}创建完毕；对战玩家[{1},{2}]", roomID, playerSocketA.playerInfo.playerName, playerSocketB.playerInfo.playerName));
return newroom;
}
public void Send(Socket socket, GameData data)
{
string sendMessage = JsonCoding<GameData>.encode(data);
byte[] sendBytes = encoding.GetBytes(sendMessage);
Send(socket, sendBytes);
}
