void JoinPressed()
{
AudioMgr.Instance.SoundPlay("anniu", 2f, 2);
if (InputText_RoomId.text == "")
{
GameEvent.DoMsgEvent("房间号不能为空!");
return;
}
if (int.Parse(InputText_RoomId.text) <= 0)
{
GameEvent.DoMsgEvent("房间号不合法!");
return;
}
Debug.Log("加入的房间号=" + int.Parse(InputText_RoomId.text));
AudioMgr.Instance.SoundPlay("btnClick", 1f, 2);
SocketModel JoinRoomRequset = new SocketModel();
JoinRoomRequset.SetMainCmd(ProtocolMC.Main_Cmd_HALL);
JoinRoomRequset.SetSubCmd(ProtocolSC.Sub_Cmd_JoinRoomRqs);
JoinRoomRequset.SetCommand(0);
List <string> message = new List <string>();
message.Add(InputText_RoomId.text);
if (InputText_PassWord.text == "")
{
message.Add("000");
}
else
{
message.Add(InputText_PassWord.text);
}
JoinRoomRequset.SetMessage(message);
NettySocket.Instance.SendMsg(JoinRoomRequset);//发送这条消息给服务器
}
public void onGetMailList(SocketModel model)
{
//FIX:
//NoticeMessage.MsgMailListRep msg = MsgSerializer.Deserialize<NoticeMessage.MsgMailListRep>(model);
//int count = msg.mailAry.Count;
//Debug.Log("mail count : " + count);
//for (int i = 0; i < count; i++)
//{
// Mail mail = new Mail();
// mail.mailId = msg.mailAry[i].index;
// mail.from = msg.mailAry[i].from;
// mail.time = msg.mailAry[i].time;
// mail.mailTitle = msg.mailAry[i].title;
// mail.mailContent = msg.mailAry[i].body;
// mail.readed = msg.mailAry[i].reader;
// for (int j = 0; j < msg.mailAry[i].itemAry.Count; j++)
// {
// Goods goods = new Goods();
// goods.guid = msg.mailAry[i].itemAry[j].guid;
// goods.templateId = msg.mailAry[i].itemAry[j].templateid;
// goods.number = msg.mailAry[i].itemAry[j].number;
// mail.itemAry.Add(goods);
// }
// MonoInstancePool.getInstance<MailManager>().mailList.Add(mail);
//}
}
static int _CreateSocketModel(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
if (count == 0)
{
SocketModel obj = new SocketModel();
ToLua.PushObject(L, obj);
return(1);
}
else if (count == 4)
{
byte arg0 = (byte)LuaDLL.luaL_checknumber(L, 1);
int arg1 = (int)LuaDLL.luaL_checknumber(L, 2);
int arg2 = (int)LuaDLL.luaL_checknumber(L, 3);
byte[] arg3 = ToLua.CheckByteBuffer(L, 4);
SocketModel obj = new SocketModel(arg0, arg1, arg2, arg3);
ToLua.PushObject(L, obj);
return(1);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to ctor method: SocketModel.New"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
//开局
public void RoomGameStart(SocketModel socketModel)
{
//
GameInfo.Instance.isGameStart = 1;
int value = socketModel.GetCommand();
if (value > 0)
{
//手牌
List <int> list = socketModel.GetData();
list.Reverse();
GameInfo.Instance.myHandMj = list;
//房间信息
List <string> msg = socketModel.GetMessage();
GameInfo.Instance.zhuangjia = int.Parse(msg[0]);
GameInfo.Instance.round = int.Parse(msg[1]);
GameInfo.Instance.mjLeft = int.Parse(msg[2]);
//开始后，设置所有人状态为未准备
GameInfo.Instance.isMyReady = 0;
GameInfo.Instance.isRightReady = 0;
GameInfo.Instance.isTopReady = 0;
GameInfo.Instance.isLeftReady = 0;
//通知UI游戏开始了
GameEvent.DoGameStartEvent(1);
Debug.Log("人满开局发牌 " + list);
}
int mjNum = socketModel.GetCommand();
RoomEvent.DoActionLeftMj(mjNum);
}
private void OnNotifyBattleStart(SocketModel model)
{
NotifyBattleStart notify = SerializeUtil.Deserialize <NotifyBattleStart>(model.message);
CacheManager.instance.battleid = notify.battleid;
CacheManager.instance.battleType = (EBattle)notify.battleType;
CacheManager.instance.limitNum = notify.numberLimit;
UIManager.instance.CloseAll();
for (int i = 0; i < notify.tanks.Count; i++)
{
//修改缓存
//CacheManager.instance.tanks.Add(notify.tanks[i]);
BaseTank tank = null;
if (notify.tanks[i].id == CacheManager.instance.account)
{
//CacheManager.instance.myTank = notify.tanks[i];
tank = new Tank(notify.tanks[i]);
}
else
{
tank = new OtherTank(notify.tanks[i]);
}
TankManager.instance.AddTank(tank);
}
}
private void HuPressed()
{
//告诉服务器胡牌
SocketModel ActionRequset = new SocketModel();
ActionRequset.SetMainCmd(ProtocolMC.Main_Cmd_ROOM);
if (huType == CardView.CHI_HU_糊牌)
{
ActionRequset.SetSubCmd(ProtocolSC.Sub_Cmd_GAME_HUPAI);
}
else if (huType == CardView.CHI_GANG_抢杠)
{
ActionRequset.SetCommand(1);
ActionRequset.SetSubCmd(ProtocolSC.Sub_Cmd_GAME_QIANGGANG);
}
else if (huType == CardView.CHI_ZIMO_自摸)
{
ActionRequset.SetSubCmd(ProtocolSC.Sub_Cmd_GAME_ZIMO);
}
List <int> datalist = new List <int>();
datalist.Add(GameInfo.Instance.roomId); //房间号
datalist.Add(GameInfo.Instance.positon); //位置
ActionRequset.SetData(datalist);
NettySocket.Instance.SendMsg(ActionRequset); //发送这条消息给服务器
closeAct();
}
/// <summary>
/// 用户消息到达
/// </summary>
/// <param name="token"></param>
/// <param name="message"></param>
public void MessageReceive(UserToken token, SocketModel message)
{
//处理客户端的请求
switch (message.command)
{
//处理客户端的登录请求
case GameProtocol.LoginProtocol.ENTER_CREQ:
DebugUtil.Instance.LogToTime("用户请求登录消息到达");
//对三级消息体的转换
RequestLoginModel rlm = message.GetMessage <RequestLoginModel>();
//获取登录的结果
int result = BizFactory.login.Login(token, rlm);
//完成了一次对客户端的消息返回
token.write(TypeProtocol.LOGIN, LoginProtocol.ENTER_SRES, result);
break;
//处理客户端的快速注册请求
case GameProtocol.LoginProtocol.QUICKREG_CREQ:
DebugUtil.Instance.LogToTime("用户请求快速注册消息到达");
ResponseRegisterModel rrmodel = BizFactory.login.Reg(token);
//完成了一次对客户端请求注册的消息返回
token.write(TypeProtocol.LOGIN, LoginProtocol.QUICKREG_SRES, rrmodel);
break;
}
}
/// <summary>
/// 网络消息分发
/// </summary>
/// <param name="sm"></param>
public void OnMessageReceived(SocketModel sm)
{
switch (sm.type)
{
case Protocol.Protocol.TYPE_USER:
userHandler.OnMessageReceived(sm);
break;
case Protocol.Protocol.TYPE_SELECT:
selectHandler.OnMessageReceived(sm);
break;
case Protocol.Protocol.TYPE_MATCH:
matchHandler.OnMessageReceived(sm);
break;
case Protocol.Protocol.TYPE_LOGIN:
loginHandler.OnMessageReceived(sm);
break;
case Protocol.Protocol.TYPE_FIGHT:
fightHandler.OnMessageReceived(sm);
break;
case Protocol.Protocol.TYPE_TIME:
timeHandler.OnMessageReceived(sm);
break;
default:
break;
}
}
/// <summary>
/// 消息体反序列化
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static object decode(byte[] value)
{
ByteArray ba = new ByteArray(value);
SocketModel model = new SocketModel();
byte type;
int area;
int command;
//从数据中读取 三层协议 读取数据顺序必须和写入顺序保持一致
ba.read(out type);
ba.read(out area);
ba.read(out command);
model.type = type;
model.area = area;
model.command = command;
//判断读取完协议后 是否还有数据需要读取 是则说明有消息体 进行消息体读取
if (ba.Readnable) {
byte[] message;
//将剩余数据全部读取出来
ba.read(out message, ba.Length - ba.Position);
//反序列化剩余数据为消息体
model.message = SerializeUtil.decode(message);
}
ba.Close();
return model;
}
/// <summary>
/// 传输模型的解码
/// </summary>
/// <param name="data">字节数据</param>
/// <returns>模型数据</returns>
private SocketModel modelDecode(byte[] data)
{
ByteArray ba = new ByteArray(data);
int type;
int area;
int command;
ba.read(out type);
ba.read(out area);
ba.read(out command);
SocketModel sm = new SocketModel();
sm.type = type;
sm.area = area;
sm.command = command;
//如果剩下还有数据，将剩下的数据读到一个数组，并对此数组解码成object
if (ba.Readnable)
{
byte[] message;
ba.read(out message, ba.Length - ba.Position);
sm.message = SerializeUtil.decoder(message);
}
return(sm);
}
void HandlerInterface.MessageReceive(UserToken token, SocketModel message)
{
switch (message.command)
{
case BattleRoomProtocol.CREATE_ONE_C:
// 创建战斗房间，需要战斗人员们的ID，从ID获取到配置的技能信息，初始化玩家的卡牌、技能、血量、MP等数据
// 创建怪物ID，做一个定时器，每回合调用。
Console.WriteLine("接收到一个创建房间的请求");
roomManager.createOneRoom(new List <UserToken>()
{
token
});
break;
//case BattleRoomProtocol.TEXT_MESSAGE:
// break;
case BattleRoomProtocol.CREATE_TWO_C:
Console.WriteLine("有人想创建一个多人房间");
addTwoBattleRoomRoleModels(token);
break;
default:
{
//将消息转发到处理房间。
var room = roomManager.GetRoomById(message.getMessage <RoomDTO>().roomId);
// TODO room.useCard(message.getMessage<BattleRoomDTO>());
room.receiveMessage(message.command, message.getMessage <RoomDTO>());
}
break;
}
}
public void MessageReceive(SocketModel model)
{
switch (model.command)
{
case UserProtocol.GETINFO_SRES:
{
UserModel um = model.GetMessage <UserModel>();
if (um != null)
{
GameApp.Instance.CommonHintDlgScript.OpenHint("获取用户信息成功" + um.nickname);
GameSession.Instance.UserInfo = um;
//用户信息加载成功后，加载main场景
GameApp.Instance.GameLevelManagerScript.LoadScene(GameResources.SceneName.MAIN);
}
else
{
//用户信息加载失败，显示提示信息，先关闭网络再开启网络
GameApp.Instance.CommonHintDlgScript.OpenHint("获取用户信息失败");
ExtendHandler.Close();
ExtendHandler.Connect();
}
GameApp.Instance.CommonHintDlgScript.OpenHint("获取no" + um.nickname);
}
break;
}
}
public void onRefreshShopList(SocketModel module)
{
//刷新商品列表
ItemMessage.MsgRefreshShopItemListRep msg = MsgSerializer.Deserialize<ItemMessage.MsgRefreshShopItemListRep>(module);
ShopManager shopManager = MonoInstancePool.getInstance<ShopManager>();
int shopId = msg.idx;
shopManager.ClearShopInfo(shopId);
for (int i = 0; i < msg.itemList.Count; i++)
{
Property.ShopItem item = msg.itemList[i];
ShopItem baseItem = ParseItem(item);
baseItem.shopId = shopId;
MonoInstancePool.getInstance<ShopManager>().AddShopItem(shopId ,baseItem.idx , baseItem);
}
if (msg.refresh_type == (int)ItemMessage.ENUM_TYPE.ENUM_TYPE_MANUAL)
{
int money_type = msg.moneyType;
int money = msg.money;
MonoInstancePool.getInstance<UserData>().subMoney(money_type, money);
}
shopManager.GetShopById(shopId).freshCount = msg.refreshCount;
shopManager.ChangedNotify = true;
}
public void onGetItemList(SocketModel module)
{
ItemMessage.MsgGetItemListRep msg = MsgSerializer.Deserialize<ItemMessage.MsgGetItemListRep>(module);
BagStruct bag = MonoInstancePool.getInstance<BagManager>().getBagByType(msg.type);
if (bag == null)
{
Debug.LogError("have not this bag!");
return;
}
bag.clear();
//Debug.Log("bag: " + msg.type + " have: " + msg.itemList.Count + " " + msg.equipList.Count);
if (msg.type == (int)GlobalDef.BagType.B_EQUIPMENT)
{
for (int i = 0; i < msg.equipList.Count; i++)
{
Property.Equip item = msg.equipList[i];
EquipmentItem baseItem = new EquipmentItem();
baseItem.parseData(item);
bag.addItem(baseItem);
bag.IsDirty = true;
}
}
else
{
for (int i = 0; i < msg.itemList.Count; i++)
{
Property.Item item = msg.itemList[i];
BaseItem baseItem = MonoInstancePool.getInstance<BagManager>().createItemByData(item);
bag.addItem(baseItem);
bag.IsDirty = true;
}
}
}
public void onChatMessage(SocketModel model)
{
NoticeMessage.MsgChatRep msg = MsgSerializer.Deserialize<NoticeMessage.MsgChatRep>(model);
Chat chat = new Chat();
chat.uid = msg.uid;
chat.name = msg.name;
chat.type = msg.type;
chat.data = msg.data;
chat.targetUid = msg.target;
if (msg.item != null) {
chat.goods.guid = msg.item.guid;
//server changed, client not change
// chat.goods.number = msg.item.number;
}
chat.targetName = msg.tarname;
ChatManager chatManager = MonoInstancePool.getInstance<ChatManager>();
if (chat.type == (int)GlobalDef.CHAT_CHANNEL.ALL_CHANNEL)
{
chatManager.setSystemChatList(chat);
chatManager.setHaveNewSystemChat(true);
}
else if (chat.type == (int)GlobalDef.CHAT_CHANNEL.WORLD_CHANNEL)
{
chatManager.setWorldChatList(chat);
chatManager.setHaveNewWorldChat(true);
}
else if (chat.type == (int)GlobalDef.CHAT_CHANNEL.PRIVATE_CHANNEL)
{
chatManager.setPrivateChatList(chat);
chatManager.setHaveNewPrivateChat(true);
//chatManager.setTargetId(chat.uid);
}
chatManager.setIsDirty(true);
}
//摸牌
public void MoPai(SocketModel socketModel)
{
//GameEvent.DoMsgTipEvent(" 收到摸牌数据");
List <string> msgList = socketModel.GetMessage();
//如果是自己摸牌
Debug.Log("摸牌的位置=" + int.Parse(msgList[0]));
if (int.Parse(msgList[0]) == GameInfo.Instance.positon)
{
Debug.Log("是自己摸牌 摸的牌= " + int.Parse(msgList[1]));
//GameEvent.DoMsgTipEvent("是自己摸牌 摸的牌= " + int.Parse(msgList[1]));
//摸起的牌放到手牌队列里
int mj = int.Parse(msgList[1]);
GameInfo.Instance.putMjtoHandList(mj);
//广播给UI显示
GameEvent.DoMoPai(mj);
Debug.Log("摸牌==" + mj);
//是否能,杠,糊
List <int> list = socketModel.GetData();
RoomEvent.DoActionList(list);
//如果Action有数据,可以杠
if (socketModel.GetAdata() != null && socketModel.GetAdata().Count > 0)
{
Debug.Log("可以杠牌=" + socketModel.GetAdata().Count);
GameInfo.Instance.gangList = socketModel.GetAdata();//杠的数据保存在INFO, 选择牌型后清空
}
}
//不管是谁摸，更新牌的数量
Debug.Log("剩余牌的数量=" + socketModel.GetCommand());
int mjNum = socketModel.GetCommand();
RoomEvent.DoActionLeftMj(mjNum);
}
public void MessageReceive(SocketModel model)
{
switch (model.command)
{
case AccountProtocol.REGISTER_SRES:
int registResult = model.GetMessage <int>();
registRes(registResult);
break;
case AccountProtocol.LOGIN_SRES:
int accResult = model.GetMessage <int>();
loginRes(accResult);
break;
case AccountProtocol.OFFLINE_SRES:
break;
default:
break;
}
}
//一局结束
public void GameEnd(SocketModel socketModel)
{
Debug.Log("收到小结算数据");
List <PlayerData> plist = socketModel.GetPdata();
GameInfo.Instance.jieSuanRoundData = plist;
}
public int parse(SocketModel module)
{
switch (module.messageID)
{
case (int)TaskMessage.TASK_MSG_ID.ID_S2C_GET_TASK_LIST: //= 80002; // 获取任务列表
onGetTaskList(module);
break;
case (int)TaskMessage.TASK_MSG_ID.ID_S2C_ADD_NEW_TASK: //= 80003; // 增加新任务
onAddTask(module);
break;
case (int)TaskMessage.TASK_MSG_ID.ID_S2C_GET_REWARD: //= 80005; // 获取奖励
onGetTaskRework(module);
break;
case (int)TaskMessage.TASK_MSG_ID.ID_S2C_GET_ACHIEVEMENT_LIST: //= 80102; // 获取成就列表
onGetAchievementList(module);
break;
case (int)TaskMessage.TASK_MSG_ID.ID_S2C_UPDATE_ACHIEVEMENT: //= 80103; // 更新成就进度
onUpdateAchievement(module);
break;
case (int)TaskMessage.TASK_MSG_ID.ID_S2C_FINISH_ACHIEVEMENT: //= 80104; // 成就达成
onFinishAchievement(module);
break;
case (int)TaskMessage.TASK_MSG_ID.ID_S2C_ADD_NEW_ACHIEVEMENT: //= 80105; // 添加新成就
onAddAchievement(module);
break;
case (int)TaskMessage.TASK_MSG_ID.ID_S2C_GET_BLEED_SOUL: //= 80202; // 获取血魂信息
onGetBloodsoul(module);
break;
default:
return -1;
}
return 0;
}
private void OnReqBuy(UserToken token, SocketModel model)
{
ReqBuy req = SerializeUtil.Deserialize <ReqBuy>(model.message);
AccountData acc = CacheManager.instance.GetAccount(token.accountid);
ItemCfg cfg = ConfigManager.instance.items[req.itemid];
if (acc.diamond < cfg.Price)
{
TipsError tips = new TipsError();
tips.code = (int)ECode.EBuyError;
NetworkManager.Send <TipsError>(token, (int)MsgID.TipError, tips);
}
else
{
acc.diamond -= cfg.Price;
ItemData item = new ItemData();
item.account = token.accountid;
item.itemid = req.itemid;
item.count = 1;
CacheManager.instance.AddItem(token.accountid, item);
RspBuy rsp = new RspBuy();
rsp.diamond = acc.diamond;
rsp.item = new ItemDTO();
rsp.item.id = item.Id;
rsp.item.account = item.account;
rsp.item.itemid = item.itemid;
rsp.item.count = item.count;
rsp.item.slot = item.slot;
NetworkManager.Send <RspBuy>(token, (int)MsgID.RspBuy, rsp);
}
}
//缓存中有数据处理
void onData()
{
// 长度解码
byte[] result = decode(ref cache);
// 长度解码返回空 说明消息体不全，等待下条消息过来补全
if (result == null)
{
isReading = false;
return;
}
SocketModel message = mdecode(result);
if (message == null)
{
isReading = false;
return;
}
// 进行消息的处理
messages.Add(message);
// 尾递归 防止在消息处理过程中 有其他消息到达而没有经过处理
onData();
}
public void MessageReceive(SocketModel model)
{
if (model.Command == MatchProtocol.ENTER_DELECT_BRO)
{
Application.LoadLevel(2);
}
}
public static SocketModel mdecode(byte[] value)
{
ByteArray ba = new ByteArray(value);
SocketModel model = new SocketModel();
int command;
// 从数据中读取 三层协议 读取数据顺序必须和写入顺序保持一致
ba.read(out command);
model.command = command;
// 判断读取完协议后 是否还有数据需要读取 是则说明有消息体 进行消息体读取
if (ba.Readnable)
{
byte[] message;
// 将剩余数据全部读取出来
ba.read(out message, ba.Length - ba.Position);
// 反序列化剩余数据为消息体
model.message = message;
}
ba.Close();
return(model);
}
void OnGetAreanSelf(SocketModel module){
var areanMng = MonoInstancePool.getInstance<AreanManager>();
MsgArenaInfoRep msg = MsgSerializer.Deserialize<MsgArenaInfoRep>(module);
areanMng.areanUserInfo.index = msg.rank;
areanMng.areanUserInfo.hIndex = msg.hrank;
areanMng.areanUserInfo.coin = msg.arenaCoin;
areanMng.areanUserInfo.fightCount = msg.count;
areanMng.areanUserInfo.buyCount = msg.buyCount;
areanMng.areanUserInfo.countCdTime = msg.countTime;
areanMng.areanUserInfo.modified = true;
List<ArenaRecord> records = msg.record;
for(int i = 0 ; i < records.Count ; i++){
var data = new AreanRecordData();
data.uid = records[i].uid;
data.type = records[i].type;
data.rankIndex = records[i].rank;
data.result = records[i].result;
data.time = records[i].time;
areanMng.AddRecordData(data);
}
MonoInstancePool.getInstance<SendAreanHandler>().SendAreanRankListReq();
}
public void MessageReceive(SocketModel model)
{
Debug.Log((MsgID)model.command);
Action <SocketModel> handler = _handlers[(MsgID)model.command];
handler(model);
}
public void MessageReceive(UserToken token, SocketModel message)
{
if (!CacheFactory.user.IsOnline(token))
{
return;
}
switch (message.command)
{
//请求开始匹配
case MatchProtocol.STARTMATCH_CREQ:
{
//获取请求匹配的结果
ResponseStartMatchInfo result = BizFactory.match.StartMatch(token, (SConst.GameType)message.GetMessage <int>());
token.write(TypeProtocol.MATCH, MatchProtocol.STARTMATCH_SRES, result);
}
break;
//请求离开匹配
case MatchProtocol.LEAVEMATCH_CREQ:
{
int result = BizFactory.match.LeaveMatch(token);
token.write(TypeProtocol.MATCH, MatchProtocol.LEAVEMATCH_SRES, result);
}
break;
}
}
//抢杠
public void QiangGang(SocketModel socketModel)
{
//收到这个数据说明，能抢杠胡
List <int> list = socketModel.GetData();
RoomEvent.DoActionList(list);
}
//private Dictionary<int, GameObject> teamTwo = new Dictionary<int, GameObject>();
public void MessageReceive(SocketModel model)
{
switch (model.command)
{
case FightProtocol.START_BRO:
start(model.GetMessage <FightRoomModel>());
break;
case FightProtocol.MOVE_BRO:
move(model.GetMessage <MoveDTO>());
break;
case FightProtocol.ATTACK_BRO:
atk(model.GetMessage <AttackDTO>());
break;
case FightProtocol.DAMAGE_BRO:
damage(model.GetMessage <DamageDTO>());
break;
case FightProtocol.SKILL_BRO:
skill(model.GetMessage <SkillAtkModel>());
break;
case FightProtocol.REFRESH_BRO:
refreshMonster(model.GetMessage <FightMonsterModel[]>());
break;
}
}
/// <summary>
/// 填充客户端套接字
/// </summary>
/// <param name="conferenceName">会议名称</param>
/// <param name="contactUrl">参会人</param>
/// <param name="socket">套接字</param>
public static void FillsocDic(Dictionary <string, MeetServerSocket> dicServierSocket, string conferenceName, string contactUrl, Socket socket, SocketClientType socketClientType)
{
try
{
//查看是否包含该会议通讯节点
if (dicServierSocket.ContainsKey(conferenceName))
{
SocketModel socketModel = new SocketModel()
{
Socket = socket, SocketClientType = socketClientType
};
//会议的通信节点集合
Dictionary <string, SocketModel> dicSocketModels = dicServierSocket[conferenceName].DicClientSocket;
//该会议通讯节点是否包含该客户端通讯节点（处于一对多的映射关系）
if (!dicSocketModels.ContainsKey(contactUrl))
{
//该会议通讯节点添加该客户端的通讯节点
dicSocketModels.Add(contactUrl, socketModel);
}
else if (dicSocketModels.ContainsKey(contactUrl) && !dicSocketModels[contactUrl].Socket.Connected)
{
//该会议通讯节点添加该客户端的通讯节点
dicSocketModels[contactUrl] = socketModel;
}
}
}
catch (Exception ex)
{
LogManage.WriteLog(typeof(Constant), ex);
}
}
void OnGetRankList(SocketModel module){
MsgArenaRanklistRep msg = MsgSerializer.Deserialize<MsgArenaRanklistRep>(module);
var areanMng = MonoInstancePool.getInstance<AreanManager>();
areanMng.GetAreanRankList().Clear();
List<Ranklist> rankList = msg.list;
for(int i = 0 ; i < rankList.Count ; i++){
var rankInfo = rankList[i];
if(rankInfo.rank == MonoInstancePool.getInstance<AreanManager>().GetSelfRankData().index){
continue;
}
var rankData = new AreanRankData();
rankData.uid = rankInfo.uid;
rankData.rankIndex = rankInfo.rank;
rankData.fightStrength = rankInfo.fighting;
rankData.name = rankInfo.name;
List<HeroBase> heroList = rankInfo.list;
for(int j = 0 ; j < heroList.Count && j < 3; j++){
rankData.heroDatas[j] = new AreanHeroData();
rankData.heroDatas[j].id = heroList[j].heroid;
rankData.heroDatas[j].lv = heroList[j].level;
rankData.heroDatas[j].starLv = heroList[j].starLevel;
rankData.heroDatas[j].realm = heroList[j].realm;
}
areanMng.AddRankData(rankData);
}
areanMng.SortRankList();
}
public int parse(SocketModel module)
{
switch (module.messageID)
{
case (int)FriendMessage.FRIEND_MSG_ID.ID_S2C_FRIEND_COUNT:// 获取好友总数
ongGetFriendCount(module);
break;
case (int)FriendMessage.FRIEND_MSG_ID.ID_S2C_FRIEND_LIST:// 获取好友列表
onGetFriendList(module);
break;
case (int)FriendMessage.FRIEND_MSG_ID.ID_S2C_FRIEND_FIND:// 查找好友
onSearchFriend(module);
break;
case (int)FriendMessage.FRIEND_MSG_ID.ID_S2C_FRIEND_ADD:// 添加好友
onAddFriend(module);
break;
case (int)FriendMessage.FRIEND_MSG_ID.ID_S2C_FRIEND_DELETE:// 删除好友
onDeleteFriend(module);
break;
case (int)FriendMessage.FRIEND_MSG_ID.ID_S2C_FRIEND_REQUEST:// 好友申请
onInviteMe(module);
break;
default:
return -1;
}
return 0;
}
/// <summary>
///初始化发牌
/// </summary>
public void initHandMj()
{
for (int i = 0; i < GameInfo.Instance.myHandMj.Count; i++)
{
string mj = GameInfo.Instance.myHandMj[i].ToString();
//最后显示
GameObject mjCard = Instantiate(Resources.Load("Prefab/GameObject_mj_my")) as GameObject;
mjCard.transform.localPosition = new Vector3(i * -83, 0, 0);
mjCard.transform.SetParent(this.transform, false);
mjCard.GetComponent <Mj_my>().setPic(mj);
mjCard.GetComponent <Mj_my>().mjId = mj;
mjCard.name = mjLocId.ToString();
mjLocId++;
CardList.Add(mjCard);
Debug.Log("mjCard =", mjCard);
Debug.Log("CardList =" + CardList.Count);
}
if (GameInfo.Instance.positon == GameInfo.Instance.zhuangjia)//只用来开局判断自己是不是庄家,如果是就摸牌
{
//告诉服务器摸牌
SocketModel MoPaiRequset = new SocketModel();
MoPaiRequset.SetMainCmd(ProtocolMC.Main_Cmd_ROOM);
MoPaiRequset.SetSubCmd(ProtocolSC.Sub_Cmd_GAME_MOPAI);
MoPaiRequset.SetCommand(0);
List <int> datalist = new List <int>();
datalist.Add(GameInfo.Instance.roomId); //房间号
datalist.Add(GameInfo.Instance.positon); //位置
MoPaiRequset.SetData(datalist);
NettySocket.Instance.SendMsg(MoPaiRequset); //发送这条消息给服务器
}
}
public int parse(SocketModel module){
switch(module.messageID){
case (int)FIGHT_MSG_ID.ID_S2C_ARENA_RANKLIST: // 获取竞技场排行榜
OnGetRankList(module);
break;
case (int)FIGHT_MSG_ID.ID_S2C_ARENA_INFO: // 获取竞技场信息
OnGetAreanSelf(module);
break;
case (int)FIGHT_MSG_ID.ID_S2C_ARENA_OTHER_INFO: // 获取排行榜用户信息
OnGetOtherAreanInfo(module);
break;
case (int)FIGHT_MSG_ID.ID_S2C_ARENA_FIGHT_INFO: // 竞技场挑战记录
OnGetFightRecord(module);
break;
case (int)FIGHT_MSG_ID.ID_S2C_ARENA_COIN: // 更新竞技场币
OnUpdateAreanCoin(module);
break;
case (int)FIGHT_MSG_ID.ID_S2C_ARENA_COUNT: // 更新挑战次数
OnUpdateAreanCount(module);
break;
case (int)FIGHT_MSG_ID.ID_S2C_ARENA_BUY_COUNT: // 购买挑战次数
OnBuyFightCount(module);
break;
}
return 0;
}
public void ParseData()
{
//有数据的话就调用长度解码
byte[] result = Decode(ref cache);
if (result == null)
{
isReading = false;
return;
}
//消息体解码
SocketModel msg = MDecode(result);
//将消息体存储，等待调用
if (msg == null)
{
isReading = false;
return;
}
msgList.Add(msg);
//尾递归，防止在消息处理过程中，有其他消息过来
ParseData();
}
public void MessageReceive(SocketModel model)
{
switch (model.Command)
{
case SelectProtocol.DESTROY_BRO:
Application.LoadLevel(1);
break;
case SelectProtocol.ENTER_SRES:
Enter(model.GetMessage<SelectRoomDTO>());
break;
case SelectProtocol.ENTER_EXBRO:
Enter(model.GetMessage<int>());
break;
case SelectProtocol.FIGHT_BRO:
Application.LoadLevel(3);
break;
case SelectProtocol.READY_BRO:
Ready(model.GetMessage<SelectModel>());
break;
case SelectProtocol.SELECT_BRO:
Select(model.GetMessage<SelectModel>());
break;
case SelectProtocol.SELECT_SRES:
WarningManager.errors.Add(new WarningModel("角色选择失败"));
break;
case SelectProtocol.TALK_BRO:
Talk(model.GetMessage<string>());
break;
}
}
// 缓存中数据处理
public void OnDate()
{
// 有数据的话就调用长度解码
byte[] result = Decode(ref cache);
if (result == null)
{
isReading = false;
return;
}
// 消息体解码
SocketModel messages = ModelDecode(result);
if (messages == null)
{
isReading = false;
return;
}
// 将消息体存储 等待Unity调用
messagesList.Add(messages);
// 尾递归防止在消息处理过程中有其他的消息而没有经过处理
OnDate();
}
//消息体解码
private SocketModel MDecode(byte[] data)
{
ByteArray ba = new ByteArray(data);
SocketModel model = new SocketModel();
byte type;
int area;
int command;
ba.read(out type);
ba.read(out area);
ba.read(out command);
model.type = type;
model.area = area;
model.command = command;
if (ba.Readable)
{
byte[] msg;
ba.read(out msg, ba.Length - ba.Position);
//反序列化
model.msg = SeriaLiseUtil.Decode(msg);
ba.Close();
}
return(model);
}
private void OnRegister(UserToken token, SocketModel model)
{
// 解析消息
ReqRegister req = SerializeUtil.Deserialize <ReqRegister>(model.message);
// 从数据库里查询有没有这个账号
string sql = string.Format("select * from account where account = '{0}'", req.account);
List <AccountData> accData = MysqlManager.instance.ExecQuery <AccountData>(sql);
RespRegister resp = new RespRegister();
if (accData.Count > 0)
{
resp.msgtips = (uint)MsgTips.AccountRepeat;
}
else
{
resp.msgtips = (uint)MsgTips.RegisterSuccess;
// 往数据库里插入一个账号
//sql = string.Format("insert into account(account,password) values('{0}','{1}')", req.account, req.password);
//MysqlManager.instance.ExecNonQuery(sql);
}
// 给客户端发送一个应答
NetworkManager.Send(token, (int)MsgID.ACC_REG_SRES, resp);
}
public void Process(SocketModel model)
{
if (model.returnCode == ReturnCode.Success)
{
//服务器正常返回
PlayerInfoDTO data = JsonCoding<PlayerInfoDTO>.decode(model.message);
PlayerInfo playerInfo = new PlayerInfo();
playerInfo.UUID = data.UUID;
playerInfo.uid = data.uid;
playerInfo.playerName = data.playerName;
playerInfo.level = data.level;
playerInfo.coin = data.coin;
playerInfo.gem = data.gem;
playerInfo.vipExpire = data.vipExpire;
//UDP返回的数据不提交给全局
Global.Instance.playerInfo = playerInfo;
if (Global.Instance.scene == SceneType.MenuScene)
{
//更新UI数据
GameObject.FindGameObjectWithTag(Tags.SceneController).GetComponent<MenuScene>().UpdatePlayerInfo();
}
}
}
public override void MessageReceive(UserToken token, object message)
{
SocketModel model = message as SocketModel;
switch (model.type)
{
case Protocol.TYPE_LOGIN:
login.MessageReceive(token, model);
break;
case Protocol.TYPE_USER:
user.MessageReceive(token, model);
break;
case Protocol.TYPE_MATCH:
match.MessageReceive(token, model);
break;
case Protocol.TYPE_SELECT:
select.MessageReceive(token, model);
break;
case Protocol.TYPE_FIGHT:
fight.MessageReceive(token, model);
break;
case Protocol.TYPE_EXPLORE:
explore.MessageReceive(token, model);
break;
default:
//未知模块 可能是客户端作弊了 无视
break;
}
}
public void MessageReceive(SocketModel model)
{
if (model.command == MatchProtocol.ENTER_SELECT_BRO)
{
Application.LoadLevel(2);
}
}
public override void MessageReceive(UserToken token, object message)
{
try
{
Console.WriteLine("ces:" + message);
SocketModel model = message as SocketModel;
switch (model.type)
{
case TypeProtocol.TYPE_LOGIN:
login.MessageReceive(token, model);
break;
case TypeProtocol.TYPE_MAIN_ROOM:
mainRoom.MessageReceive(token, model);
break;
case TypeProtocol.TYPE_MATCH_JJC:
jjcmatch.MessageReceive(token, model);
break;
case TypeProtocol.TYPE_BATTLE_ROOM:
battleRoom.MessageReceive(token, model);
break;
default:
//未知模块，无视
break;
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
//获取好友列表
public void onGetFriendList(SocketModel module)
{
FriendMessage.MsgFriendListRep msg = MsgSerializer.Deserialize<FriendMessage.MsgFriendListRep>(module);
MonoInstancePool.getInstance<FriendManager>().friendList.Clear();
MonoInstancePool.getInstance<FriendManager>().applyLsit.Clear();
for (int i = 0; i < msg.FriendAry.Count; i++)
{
Friend friend = new Friend();
friend.fiendId = msg.FriendAry[i].uid;
friend.friendName = msg.FriendAry[i].name;
friend.friendLevel = msg.FriendAry[i].level;
friend.imageID = msg.FriendAry[i].headid;
friend.vipLevel = msg.FriendAry[i].vip;
if (msg.type == (int)GlobalDef.FriendType.FriendList)
{
MonoInstancePool.getInstance<FriendManager>().friendList.Add(friend);
}
else if (msg.type == (int)GlobalDef.FriendType.InviteList)
{
MonoInstancePool.getInstance<FriendManager>().applyLsit.Add(friend);
}
}
if (msg.type == (int)GlobalDef.FriendType.FriendList) //显示好友列表
{
MonoInstancePool.getInstance<FriendManager>().IsDirty = true;
}
else if (msg.type == (int)GlobalDef.FriendType.InviteList) //显示邀请好友列表
{
MonoInstancePool.getInstance<FriendManager>().IsDirty = true;
}
}
//获取好友总数
public void ongGetFriendCount(SocketModel module)
{
FriendMessage.MsgFriendCountRep msg = MsgSerializer.Deserialize<FriendMessage.MsgFriendCountRep>(module);
int friendCount = msg.friendCount;
MonoInstancePool.getInstance<FriendManager>().friendCount = friendCount;
}
void OnChapterBoxInfo(SocketModel module){
ChapterManager chapterManager = MonoInstancePool.getInstance<ChapterManager>();
// var msg = MsgSerializer.Deserialize<MsgChapteredBoxRep>(module);
// List<Property.Equip> equipments = msg.equip;
// List<Property.Item> items = msg.item;
// ChapterStruct chapter = chapterManager.GetChapterById(350001);
// chapter.award.Box1 = true;
}
public void MessageReceive(UserToken token, SocketModel message)
{
switch (message.Command)
{
case MatchProtocol.ENTER_CREQ:
Enter(token);
break;
case MatchProtocol.LEAVE_CREQ:
Leave(token);
break;
}
}
public void OnChapteredList(SocketModel module){
var msg = MsgSerializer.Deserialize<MsgChapteredListRep>(module);
List<Chaptered> normalChapters = msg.normal;
List<Chaptered> nightmareChpataers = msg.nightmare;
List<ChapteredAward> awards = msg.award;
// 章节列表...
UpdateChapterDungeonsInfo(normalChapters , ChapterLevel.Normal);
UpdateChapterDungeonsInfo(nightmareChpataers , ChapterLevel.NightMare);
UpdateChapterAwardsInfo(awards);
MonoInstancePool.getInstance<ChapterManager>().UpdateUnLockInfo();
MonoInstancePool.getInstance<ChapterManager>().InitCurrentChapter();
}
public void MessageReceive(SocketModel model)
{
// WarningManager.errors.Add(new WarningModel(model.Message+""));
switch (model.Command)
{
case LoginProtocol.LOGIN_SRES:
Login(model.GetMessage<int>());
break;
case LoginProtocol.REG_SRES:
Reg(model.GetMessage<int>());
break;
}
}
public void MessageReceive(UserToken token, SocketModel message)
{
//登录模块没有子模块，所以直接判断命令协议
switch (message.Command)
{
case LoginProtocol.LOGIN_CREQ:
Login(token, message.GetMessage<AccountInfoDTO>());
break;
case LoginProtocol.REG_CREQ:
Reg(token, message.GetMessage<AccountInfoDTO>());
break;
}
}
public int parse(SocketModel module)
{
switch (module.messageID)
{
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_ITEM_LIST:// 获取道具列表
onGetItemList(module);
break;
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_ITEM_USE: // 使用道具
onUseItem(module);
break;
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_ITEM_DEL: // 删除道具
onDelItem(module);
break;
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_ITEM_ADD: // 添加道具
onAddItem(module);
break;
//shop
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_GET_SHOP_ITEM_LIST: // 获取商品列表
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_REFRESH_SHOP_ITEM_LIST: // 刷新商品列表
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_BUY_SHOP_ITEM: // 购买商品
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_SELL_ITEM: // 出售商品
MonoInstancePool.getInstance<ShopModuleMsg>().parse(module);
break;
//equipment
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_REINFORCEMENT_EQUIP: //装备强化
onReinforcementEquip(module);
break;
//case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_UPDATE_EQUIP_STAR: //装备升星
// onGetEquipmentStar(module);
// break;
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_INLAY_GEM: //宝石镶嵌
break;
// case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_WEAR_EQUIP: //穿装备
// onPutOnEquip(module);
// break;
// case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_DROP_EQUIP: //脱装备
// onPutOffEquip(module);
//break;
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_EQUIP_RESOLVE: //熔炼装备
onSmeltingEquip(module);
break;
case (int)ItemMessage.ITEM_MSG_ID.ID_S2C_EQUIP_FORGE:
onForgingEquip(module);
break;
default:
return -1;
}
return 0;
}
public void MessageReceive(SocketModel model)
{
switch (model.Command)
{
case UserProtocol.INFO_SRES:
GetInfo(model.GetMessage<UserDTO>());
break;
case UserProtocol.CREATE_SRES:
CreateRole(model.GetMessage<bool>());
break;
case UserProtocol.ONLINE_SRES:
OnLine(model.GetMessage<UserDTO>());
break;
}
}
public void MessageReceive(UserToken token, SocketModel message)
{
switch (message.Command)
{
case UserProtocol.CREATE_CREQ:
CreateRole(token, message.GetMessage<string>());
break;
case UserProtocol.INFO_CREQ:
GetInfo(token);
break;
case UserProtocol.ONLINE_CREQ:
OnLine(token);
break;
}
}
public int parse(SocketModel module)
{
switch(module.messageID)
{
case (int)LoginMessage.LOGIN_MSG_ID.ID_S2C_LOGIN:
onLogin(module);
break;
case (int)LoginMessage.LOGIN_MSG_ID.ID_S2C_RECONNECT:
onReconnect(module);
break;
default:
return -1;
}
return 0;
}
public void Process(SocketModel model)
{
if (model.returnCode == ReturnCode.Success)
{
if (Global.Instance.scene == SceneType.MenuScene && Global.Instance.activedSceneManager is MenuScene)
{
MenuScene menuScene = Global.Instance.activedSceneManager as MenuScene;
InvInfoDTO data = JsonCoding<InvInfoDTO>.decode(model.message);
int type = data.type;//player = 1,Hero = 2,Guide = 3,Inv = 4
switch (type)
{
case 1:
{
menuScene.ResponsePlayerPage(data.returnData);
break;
}
case 2:
{
menuScene.ResponseHeroPage(data.returnData);
break;
}
case 3:
{
menuScene.ResponseGuidePage(data.returnData);
break;
}
case 4:
{
menuScene.ResponseInvPage(data.returnData);
break;
}
default:
{
LogsSystem.Instance.Print("接收到非法的数据类型:" + type, LogLevel.WARN);
break;
}
}
}
else
{
LogsSystem.Instance.Print("不合理的游戏场合，数据被抛弃", LogLevel.WARN);
}
}
else
{
LogsSystem.Instance.Print("接收到失败的返回值:" + model.returnCode, LogLevel.WARN);
}
}
public void onLogin(SocketModel module)
{
MsgLoginRep msg = MsgSerializer.Deserialize<MsgLoginRep>(module);
int result = msg.result;
if(result == (int)enResult.EN_SUCCEED) //获取基础数据
{
MonoInstancePool.getInstance<SendUserDataMsgHander>().SendGetPlayerBaseReq();
//心跳定时
InvokeRepeating ("sendHeartBeatMsg", 2f, GlobalDef.SEND_HEARTBEAT_TIME);
}
else if(result == (int)enResult.EN_ERROR)
{
reLogin();
}
}
public void Process(SocketModel model)
{
int returnCode = model.returnCode;
LoginDTO data = JsonCoding<LoginDTO>.decode(model.message);
if (returnCode == ReturnCode.Success)
{
LogsSystem.Instance.Print("登陆成功");
Global.Instance.playerName = data.playerName;
Global.Instance.UUID = data.UUID;
EnterGame();
}
else if (returnCode == ReturnCode.Pass)
{
LogsSystem.Instance.Print("登陆成功，内部版本号不同");
Global.Instance.playerName = data.playerName;
Global.Instance.UUID = data.UUID;
//按钮事件
List<EventDelegate.Callback> events = new List<EventDelegate.Callback>();
events.Add(new EventDelegate.Callback(Windows.CloseWindow));
events.Add(new EventDelegate.Callback(EnterGame));
Windows.CreateWindows("版本已过时", "游戏版本已过时，是否仍旧进入游戏?（可能会产生未知的错误）", "进入游戏", UIWidget.Pivot.Center, events);
}
else if (returnCode == ReturnCode.Repeal)
{
LogsSystem.Instance.Print("外部版本号不同");
Windows.CreateWindows("版本已过时", "游戏版本已过时，请前往官网下载最新游戏版本以进入游戏");
}
else if (returnCode == ReturnCode.Refuse)
{
LogsSystem.Instance.Print("服务器已满员");
ShortMessagesSystem.Instance.ShowShortMessage("服务器已满员");
return;
}
else if (returnCode == ReturnCode.Failed)
{
LogsSystem.Instance.Print("登陆失败，可能是账户或者密码错误");
ShortMessagesSystem.Instance.ShowShortMessage("登陆失败，可能是账户或者密码错误");
return;
}
else
{
LogsSystem.Instance.Print("未知的返回值");
}
}
public int parse(SocketModel module)
{
switch (module.messageID) {
case (int)FIGHT_MSG_ID.ID_S2C_CHAPTERED_LIST:
OnChapteredList(module);
break;
case (int)FIGHT_MSG_ID.ID_S2C_CHAPTERED_INFO:
UpdateChapterInfo(module);
break;
case (int)FIGHT_MSG_ID.ID_S2C_CHAPTERED_BOX:
OnChapterBoxInfo(module);
break;
default:
return -1;
}
return 0;
}
void UpdateChapterInfo(SocketModel module){
ChapterManager chapterManager = MonoInstancePool.getInstance<ChapterManager>();
var msg = MsgSerializer.Deserialize<MsgChapteredRep>(module);
int chapterId = msg.chaptered;
int dungeonId = msg.dungeon;
int dungeonStarNum = msg.star;
int chapterStarNum = msg.total;
int dungeonType = msg.type;
bool pass = msg.pass;
ChapterLevel level = (ChapterLevel)dungeonType;
ChapterStruct chapterStruct = chapterManager.GetChapterById(chapterId);
chapterStruct.award.totalCurrentStars = chapterStarNum;
chapterStruct.passedDic[(int)level] = pass;
chapterStruct.PassDungeon(level , dungeonId , dungeonStarNum);
MonoInstancePool.getInstance<ChapterManager>().UpdateUnLockInfo();
}
/// <summary>
/// 处理UDP SOCKET消息
/// </summary>
private void ProcessUDPMessage(SocketModel model)
{
LogsSystem.Instance.Print(string.Format("数据返回：返回码[{0}] 协议[{1}] 消息[{2}]", model.returnCode, model.protocol, model.message));
switch (model.protocol)
{
case SocketProtocol.LOGIN:
{
loginHandler.Process(model);
break;
}
case SocketProtocol.CHAT:
{
chatHandler.Process(model);
break;
}
case SocketProtocol.PLAYERINFO:
{
playerInfoHandler.Process(model);
break;
}
case SocketProtocol.CARDINFOLIST:
{
cardInfoHandler.Process(model);
break;
}
case SocketProtocol.OFFLINE:
{
List<EventDelegate.Callback> events = new List<EventDelegate.Callback>();
events.Add(new EventDelegate.Callback(Windows.CloseWindow));
events.Add(new EventDelegate.Callback(LoadLoginScene));
Windows.CreateWindows("断线", "您已经断开了连接", "重新登录", UIWidget.Pivot.Top, events, Windows.WindowsType.MessageWindow);
break;
}
case SocketProtocol.INVINFO:
{
invInfoHandler.Process(model);
break;
}
default:
{
LogsSystem.Instance.Print("未知的协议");
break;
}
}
}
public void MessageReceive(UserToken token, SocketModel message)
{
switch (message.Command)
{
case FightProtocol.ENTER_CREQ:
Enter(token);
break;
case FightProtocol.MOVE_CREQ:
Move(token,message.GetMessage<MoveDTO>());
break;
case FightProtocol.ATTACK_CREQ:
Attack(token,message.GetMessage<int>());
break;
case FightProtocol.DAMAGE_CREQ:
Damage(token, message.GetMessage<DamageDTO>());
break;
}
}
