public void enter(ClientPeer client)
{
SingleExecute.Instance.Execute(delegate()
{
if (!userCache.IsOnline(client))
{
return;
}
int userId = userCache.GetId(client);
if (matchCache.IsMatching(userId))
{
//user is matching,matching=already enter room
client.Send(OpCode.MATCH, MatchCode.ENTER_SRES, -1);
return;
}
MatchRoom room = matchCache.Enter(userId, client);
//broadcast to all user in room except current client
UserModel model = userCache.GetModelByAccountId(userId);
UserDto userDto = new UserDto(model.ID, model.Name, model.Been, model.WinCount, model.LoseCount, model.RunCount, model.LV, model.Exp);
room.Broadcast(OpCode.MATCH, MatchCode.ENTER_BROADCAST, userDto, client);
//send user's room data to user's client
MatchRoomDto dto = makeRoomDto(room);
client.Send(OpCode.MATCH, MatchCode.ENTER_SRES, dto);
Console.WriteLine("Player enter room......");
});
}
protected override void Start()
{
base.Start();
//fix bug
//如果！= -1 就代表 有角色
MatchRoomDto room = Models.GameModel.MatchRoomDto;
int leftId = room.LeftId;
if (leftId != -1)
{
this.userDto = room.UIdUserDict[leftId];
//fixbug923
if (room.ReadyUIdList.Contains(leftId))
{
readyState();
}
else
{
//nothing
}
}
else
{
setPanelActive(false);
}
}
/// <summary>
/// 他人进入的的处理
/// </summary>
private void EnterBroadcast(UserDto newUser)
{
MatchRoomDto room = Model.gameModel.matchRoomDto;
//更新房间数据
room.Add(newUser);
//重置玩家位置
//显示现在房间内的玩家
ResetPositon();
if (room.leftId != -1)
{
UserDto leftDto = room.uIdUserDtoDict[room.leftId];
Dispatch(AreaCode.UI, UIEvent.SET_LEFT_PLAYER_DATA, leftDto);
}
if (room.rightId != -1)
{
UserDto rightDto = room.uIdUserDtoDict[room.rightId];
Dispatch(AreaCode.UI, UIEvent.SET_RIGHT_PLAYER_DATA, rightDto);
}
//发消息 打开玩家状态面板所有物体
Dispatch(AreaCode.UI, UIEvent.PLAYER_ENTER, newUser.id);
//告诉用户玩家进入
msg.ChangeText(newUser.name + "进入了游戏", Color.yellow);
Dispatch(AreaCode.UI, UIEvent.PROMPTA_ANIM, msg);
}
private void StartMatchResponse(MatchRoomDto dto)
{
//显示进入房间按钮
Dispatch(AreaCode.UI, UIEvent.SHOW_ENTERROOMBTN_ACTIVE, null);
Debug.Log(string.Format("匹配到房间{0} 里面有 {1} 个人", dto.id, dto.uIdUdtoDic.Count));
}
/// <summary>
/// 进入
/// </summary>
void Enter(ClientPeer client)
{
SingleExecute.Instance.Execute
(
delegate()
{
if (!userCache.IsOnLine(client))
{
return;
}
int userID = userCache.GetIdByClient(client);
//判断用户是否已经在用户匹配房间
if (matchCache.IsMatching(userID))
{
client.Send(OpCode.MATCH, MatchCode.ENTER_SRES, -1); //重复加入
return;
}
//正常进入
MatchRoom room = matchCache.Enter(userID, client);
//广播给所有用户 有玩家进入 //参数，新进入的玩家ID 不用广播
UserModel model = userCache.GetModelByUserId(userID);
UserDto userDto = new UserDto(model.id, model.name, model.been, model.lv, model.exp, model.winCount, model.loseCount, model.runCount);
room.Brocast(OpCode.MATCH, MatchCode.ENTER_BRO, userDto, client);
//返回给当前client 房间的数据模型
MatchRoomDto dto = GetMatchRoomDto(room);
//给MatchRoomDto中的uidUserDtoDic<int ,userDto> 进行赋值
//那么需要获取UserModel 房间之中有多个用户
client.Send(OpCode.MATCH, MatchCode.ENTER_SRES, dto);
}
);
}
/// <summary>
/// 当有新玩家进来时、有玩家离开时或自身玩家进来时调用这个方法，刷新一下界面显示
/// </summary>
private void RefreshUI()
{
MatchRoomDto room = Models.GameModel.matchRoomDto;
if (room.LeftPlayerId != -1)
{
UserDto dto = room.userIdUserDtoDic[room.LeftPlayerId];
img_HeadIcon.gameObject.SetActive(true);
img_HeadIcon.sprite = ResourcesManager.GetSprite(dto.IconName);
go_Coin.SetActive(true);
txt_CoinCount.text = dto.CoinCount.ToString();
go_StakesSum.SetActive(true);
txt_UserName.gameObject.SetActive(true);
txt_UserName.text = dto.UserName;
//左边玩家在准备中
if (room.readyUserIdList.Contains(room.LeftPlayerId))
{
txt_Hint.text = "已准备";
txt_Hint.gameObject.SetActive(true);
}
else
{
txt_Hint.gameObject.SetActive(false);
}
}
else
{
txt_Hint.gameObject.SetActive(false);
img_HeadIcon.gameObject.SetActive(false);
go_Coin.SetActive(false);
go_StakesSum.SetActive(false);
txt_UserName.gameObject.SetActive(false);
}
}
/// <summary>
/// 他人进入的广播处理
/// </summary>
/// <param name="newUser"></param>
private void enterBro(UserDto newUser)
{
//fix bug
////发消息 显示玩家的状态面板所有游戏物体
//Dispatch(AreaCode.UI, UIEvent.PLAYER_ENTER, newUser.Id);
//更新房间数据
MatchRoomDto room = Models.GameModel.MatchRoomDto;
room.Add(newUser);
resetPosition();
//给UI绑定数据
if (room.LeftId != -1)
{
UserDto leftUserDto = room.UIdUserDict[room.LeftId];
Dispatch(AreaCode.UI, UIEvent.SET_LEFT_PLAYER_DATA, leftUserDto);
}
if (room.RightId != -1)
{
UserDto rightUserDto = room.UIdUserDict[room.RightId];
Dispatch(AreaCode.UI, UIEvent.SET_RIGHT_PLAYER_DATA, rightUserDto);
}
//发消息 显示玩家的状态面板所有游戏物体
Dispatch(AreaCode.UI, UIEvent.PLAYER_ENTER, newUser.Id);
//给用户一个提示
promptMsg.Change("有新玩家 ( " + newUser.Name + " )进入", UnityEngine.Color.blue);
Dispatch(AreaCode.UI, UIEvent.PROMPT_MSG, promptMsg);
}
/// <summary>
/// 进入匹配
/// </summary>
/// <param name="client"></param>
private void Enter(ClientPeer client)
{
SingleExecute.Instance.Execute(() =>
{
socketMsg.State = MatchCode.Success;
int userId = userCache.GetClientUserId(client);
//判断是否已在匹配房间
if (matchCache.IsMatching(userId))
{
socketMsg.OpCode = MsgType.Match;
socketMsg.SubCode = MatchCode.EnterMatch_Result;
socketMsg.State = MatchCode.Repeat_Match;
client.Send(socketMsg);
return;
}
//进入房间
MatchRoom room = matchCache.Enter(userId, client);
//广播信息
socketMsg.OpCode = MsgType.Match;
socketMsg.SubCode = MatchCode.EnterMatch_Broadcast_Result;
//新进入房间的玩家信息
var userInfo = userCache.GetUserInfo(userId);
socketMsg.value = EntityHelper.Mapping <UserCharacterDto, UserCharacterInfo>(userInfo);
room.Brocast(socketMsg, client);
//返回给客户端数据
MatchRoomDto dto = MakeRoomDto(room);
socketMsg.SubCode = MatchCode.EnterMatch_Result;
socketMsg.value = dto;
client.Send(socketMsg);
});
}
/// <summary>
/// 自身进入的服务器响应
/// </summary>
/// <param name="room"></param>
private void enterResponse(MatchRoomDto matchRoom)
{
//存储本地
//GameModel gModel = Models.GameModel;
//gModel.MatchRoomDto = matchRoom;
//int myUserId = gModel.UserDto.Id;
////重置一下玩家的位置信息
//gModel.MatchRoomDto.ResetPosition(myUserId);
//fix bug
////显示现在房间内的玩家
//if (matchRoom.LeftId != -1)
//{
// UserDto leftUserDto = matchRoom.UIdUserDict[matchRoom.LeftId];
// Dispatch(AreaCode.UI, UIEvent.SET_LEFT_PLAYER_DATA, leftUserDto);
//}
//if (matchRoom.RightId != -1)
//{
// UserDto rightUserDto = matchRoom.UIdUserDict[matchRoom.RightId];
// Dispatch(AreaCode.UI, UIEvent.SET_RIGHT_PLAYER_DATA, rightUserDto);
//}
Models.GameModel.MatchRoomDto = matchRoom;
resetPosition();
//fixbug923
////自身的角色是肯定在的 可以直接的来更新自身的数据
//int myUserId = Models.GameModel.UserDto.Id;
//UserDto myUserDto = matchRoom.UIdUserDict[myUserId];
//Dispatch(AreaCode.UI, UIEvent.SET_MY_PLAYER_DATA, myUserDto);
//显示进入房间的按钮
Dispatch(AreaCode.UI, UIEvent.SHOW_ENTER_ROOM_BUTTON, null);
}
/// <summary>
/// 他人进入房间广播
/// </summary>
/// <param name="socketMsg"></param>
private void EnterBroadcastResult(SocketMsg socketMsg)
{
if ((MatchCode)socketMsg.State == MatchCode.Success)
{
var newUser = socketMsg.value as UserCharacterDto;
//更新房间数据
MatchRoomDto room = Data.GameData.MatchRoomDto;
room.UIdClientDict.Add(newUser.Id, newUser);
room.UIdList.Add(newUser.Id);
ResetPosition();
//给UI绑定数据
if (room.LeftId != -1)
{
UserCharacterDto leftUserDto = room.UIdClientDict[room.LeftId];
Dispatch(AreaCode.UI, UIEvent.Set_Left_Player_Data, leftUserDto);
}
if (room.RightId != -1)
{
UserCharacterDto rightUserDto = room.UIdClientDict[room.RightId];
Dispatch(AreaCode.UI, UIEvent.Set_Right_Player_Data, rightUserDto);
}
//发消息 显示玩家的状态面板所有游戏物体
Dispatch(AreaCode.UI, UIEvent.Player_Enter, newUser.Id);
//给用户一个提示
promptMsg.Text = "有新玩家 ( " + newUser.Name + " )进入";
Dispatch(AreaCode.UI, UIEvent.Prompt_Msg, promptMsg);
}
}
/// <summary>
/// 进入
/// </summary>
/// <param name="client"></param>
private void enter(ClientPeer client)
{
SingleExecute.Instance.Execute(delegate()
{
if (!userCache.IsOnline(client))
{
return;
}
int userId = userCache.GetId(client);
//如果用户已经在匹配房间等待了 那就无视
if (matchCache.IsMatching(userId))
{
//client.Send(OpCode.MATCH, MatchCode.ENTER_SRES, -1);//重复加入
return;
}
//正常进入
MatchRoom room = matchCache.Enter(userId, client);
//广播给房间内除了当前客户端的其他用户，有新玩家加入了 参数：新进入的玩家的用户id
UserModel model = userCache.GetModelById(userId);
UserDto userDto = new UserDto(model.Id, model.Name, model.Been, model.WinCount, model.LoseCount, model.RunCount, model.Lv, model.Exp);
room.Brocast(OpCode.MATCH, MatchCode.ENTER_BRO, userDto, client);
//返回给当前客户端 给他房间的数据模型
MatchRoomDto dto = makeRoomDto(room);
client.Send(OpCode.MATCH, MatchCode.ENTER_SRES, dto);
Console.WriteLine("有玩家进入匹配房间");
});
}
/// <summary>
/// 客户端请求进入房间服务器的响应
/// </summary>
private void EnterRoomSRES(MatchRoomDto matchRoomDto)
{
Models.GameModel.MatchRoomDto = matchRoomDto;
ResetPos();
// 刷新界面左右边玩家的 UI 显示
EventCenter.Broadcast(EventType.RefreshUI);
}
/// <summary>
/// 自身进入服务器的响应
/// </summary>
/// <param name="room"></param>
private void enterResponse(MatchRoomDto room)
{
//存储本地
GameModel gModel = Models.GameModel;
MatchRoomDto matchRoom = gModel.MatchRoomDto;
int myUserId = gModel.UserDto.Id;
matchRoom = room;
//重置一下玩家的位置信息
gModel.MatchRoomDto.ResetPosition(myUserId);
//显示现在房间内的玩家
if (matchRoom.LeftId != -1)
{
UserDto leftUserDto = matchRoom.UIdUserDict[matchRoom.LeftId];
Dispatch(AreaCode.UI, UIEvent.SET_LEFT_PLAYER_DATA, leftUserDto);
}
if (matchRoom.RightId != -1)
{
UserDto rightUserDto = matchRoom.UIdUserDict[matchRoom.RightId];
Dispatch(AreaCode.UI, UIEvent.SET_RIGHT_PLAYER_DATA, rightUserDto);
}
//自身的角色是肯定在的 可以直接的来更新自身的数据
UserDto myUserDto = matchRoom.UIdUserDict[myUserId];
//显示进入房间的按钮
Dispatch(AreaCode.UI, UIEvent.SHOW_ENTER_BUTTON, null);
}
/// <summary>
/// 客户端请求进入房间，服务器的响应
/// </summary>
/// <param name="dto"></param>
private void EnterRoomSRES(MatchRoomDto dto)
{
Models.GameModel.matchRoomDto = dto;
ResetPosition();
//刷新左右边玩家的UI显示
EventCenter.Broadcast(EventDefine.RefreshUI);
}
public override void Start()
{
base.Start();
Bind(UIEvent.Set_Right_Player_Data);
//如果！= -1 就代表 有角色
MatchRoomDto room = Data.GameData.MatchRoomDto;
int rightId = room.RightId;
if (rightId != -1)
{
this.userCharacterDto = room.UIdClientDict[rightId];
if (room.ReadyUIdList.Contains(rightId))
{
ReadyState(true);
}
else
{
//nothing
}
}
else
{
SetPanelActive(false);
}
}
protected override void Start()
{
base.Start();
GameModel gm = Models.GameModel;
if (gm.GetRightUserId() != -1)
{
this.userDto = gm.GetUserDto(gm.GetRightUserId());
MatchRoomDto room = gm.MatchRoomDto;
//fixbug923
if (room.ReadyUIdList.Contains(gm.GetRightUserId()))
{
readyState();
}
else
{
//nothing
}
}
else
{
setPanelActive(false);
}
}
//update other player data show
private void resetPosition()
{
GameModel gModel = Models.GameModel;
MatchRoomDto matchRoom = gModel.MatchRoomDto;
matchRoom.ResetPosition(gModel.UserDto.Id);
}
/// <summary>
/// 进入匹配界面响应
/// </summary>
/// <param name="matchRoom"></param>
private void EnterResponce(MatchRoomDto matchRoom)
{
// 存储本地
Models.gameModel.matchRoomDto = matchRoom;
// TODO 战斗房间 UI
// 显示进入房间按钮
Dispatch(AreaCode.UI, UIEvent.SHOW_ENTER_ROOM_BUTTON, null);
}
/// <summary>
/// 自身进入的服务器响应
/// </summary>
/// <param name="room"></param>
private void enterResponse(MatchRoomDto matchRoom)
{
Models.GameModel.MatchRoomDto = matchRoom;
resetPosition();
//显示进入房间的按钮
Dispatch(AreaCode.UI, UIEvent.SHOW_ENTER_ROOM_BUTTON, null);
}
/// <summary>
/// 重置位置 更新左右玩家显示
/// </summary>
private void ResetPosition()
{
GameData data = Data.GameData;
MatchRoomDto matchRoom = data.MatchRoomDto;
//重置一下玩家的位置
matchRoom.ResetPosition(data.UserCharacterDto.Id);
}
private MatchRoomDto MakeMatchRoomDto(MatchRoom room, int clientId)
{
MatchRoomDto dto = new MatchRoomDto();
for (int i = 0; i < room.clientList.Count; i++)
{
dto.Enter(DatabaseManager.CreateUserDto(room.clientList[i].Id));
}
dto.readyUserIdList = room.readyUIdList;
return(dto);
}
/// <summary>
/// 创建房间数据传输对象
/// </summary>
/// <param name="matchRoom"></param>
/// <param name="roomDto"></param>
private void makeRoomdto(MatchRoom matchRoom, out MatchRoomDto roomDto)
{
roomDto = new MatchRoomDto();
foreach (var uid in matchRoom.UidClientpeerDic.Keys)
{
UserModel userModel = UserCache.Instance.GetModelByClientPeer(matchRoom.UidClientpeerDic[uid]);
UserDto userDto = new UserDto(userModel.Id, userModel.Name, userModel.Money, userModel.WinCount, userModel.LoseCount, userModel.RunCount, userModel.Lv, userModel.Exp);
//roomDto.UidUdtoDic.Add(uid, userDto);
roomDto.Add(uid, userDto);
}
roomDto.ReadyUidlist = matchRoom.ReadyUidlist;
}
private void EnterRoom(MatchRoomDto dto)
{
//存储本地
Models.gameModel.MatchRoomDto = dto;
Debug.Log("更新房间信息成功");
//更新现在在房间内的玩家
UpdatePlayersInfo();
//更新自己的信息
UserDto myUserDto = Models.gameModel.UserDto;
Dispatch(AreaCode.UI, UIEvent.SET_MYPLAYER_DATA, myUserDto);
}
public Task <MatchRoomDto> GetMatchRoom()
{
var result = new MatchRoomDto
{
MatchStarted = _matchStarted,
MatchId = this.GetPrimaryKeyString(),
OwnerPlayerId = _ownerId,
Players = _players.Select(Convert).ToArray(),
VirtualPlayers = _virtualPlayers.Select(Convert).ToArray(),
};
return(Task.FromResult(result));
}
private MatchRoomDto makeRoomDto(MatchRoom room)
{
MatchRoomDto dto = new MatchRoomDto();
foreach (var uid in room.UIdClientDict.Keys)
{
UserModel model = userCache.GetModelById(uid);
UserDto userDto = new UserDto(model.Id, model.Name, model.Been, model.WinCount, model.LoseCount, model.RunCount, model.Lv, model.Exp);
dto.UIdUserDict.Add(uid, userDto);
}
dto.ReadyUIdList = room.ReadyUIdList;
return(dto);
}
private void setInfo()
{
int myuid = GameModles.Instance.userDto.ID;
MatchRoomDto matchRoomDto = GameModles.Instance.matchRoomDto;
foreach (var item in matchRoomDto.UidUdtoDic)
{
if (item.Key != myuid)
{
Button_Head.gameObject.SetActive(true);
Text_Name.text = item.Value.Name;
}
}
}
private MatchRoomDto MakeRoomDto(MatchRoom room)
{
MatchRoomDto dto = new MatchRoomDto();
//给 UIdClientDict 赋值
foreach (var uId in room.UIdClientDict.Keys)
{
var info = userCache.GetUserInfo(uId);
UserCharacterDto userCharacter = EntityHelper.Mapping <UserCharacterDto, UserCharacterInfo>(info);
dto.UIdClientDict.Add(uId, userCharacter);
dto.UIdList.Add(uId);
}
dto.ReadyUIdList = room.ReadyUIdList;
return(dto);
}
/// <summary>
///
/// </summary>
/// <param name="room"></param>
/// <returns></returns>
private MatchRoomDto MakeRoomDto(MatchRoom room)
{
MatchRoomDto roomDto = new MatchRoomDto(room.id);
roomDto.readyUidList = room.readyUidList;
//给roomDto中的所有玩家信息字典 赋值
foreach (var id in room.uidList)
{
UserModel model = user.GetModelById(id);
UserDto userDto = new UserDto();
userDto.Set("", model.id, model.name, model.beens, model.winCount, model.loseCount, model.runCount, model.lv, model.exp);
roomDto.Add(userDto);
}
return(roomDto);
}
private MatchRoomDto GetMatchRoomDto(MatchRoom room)
{
MatchRoomDto dto = new MatchRoomDto();
foreach (var uid in room.uIdClientDict.Keys)
{
UserModel model = userCache.GetModelByUserId(uid);
UserDto userdto = new UserDto(model.id, model.name, model.been, model.lv, model.exp, model.winCount, model.loseCount, model.runCount);
dto.uIdUserDtoDict.Add(uid, userdto);
dto.uIdList.Add(uid);
//能否直接使用dto.Add(userdto); //否则此方法意义？
}
dto.readyUIdList = room.readyIdList;
return(dto);
}
protected override void Start()
{
base.Start();
MatchRoomDto matchRoomDto = Model.gameModel.matchRoomDto;
if (matchRoomDto.rightId != -1)
{
this.userDto = matchRoomDto.uIdUserDtoDict[matchRoomDto.rightId];
if (matchRoomDto.readyUIdList.Contains(matchRoomDto.rightId))
{
ReadyState();
}
}
else
{
SetPanelActive(false);
}
}
