/// <summary>
/// 广播消息逻辑
/// </summary>
/// <param name="convention">广播类型</param>
/// <param name="message">广播值</param>
/// <param name="uniqueID">除该用户以外都广播</param>
private void BoardcastMessage(MessageConvention convention, byte[] message, int uniqueID = -1, byte xieyiSecond = 0, ProtocolType netType = ProtocolType.Tcp)
{
MessageXieYi msgXY = new MessageXieYi((byte)convention, xieyiSecond, message);
for (int i = 0; i < ActorList.Count; i++)//逐个玩家遍历发送消息
{
if (ActorList[i].Register == null)
{
continue;
}
if (ActorList[i].CurState == RoomActorState.Offline)//离线玩家不发送
{
continue;
}
if (ActorList[i].UniqueID != uniqueID)
{
if (netType == ProtocolType.Tcp)
{
AsyncIOCPServer.instance.SendSave(UserTokenInfo[ActorList[i].UniqueID], msgXY.ToBytes());
}
else if (netType == ProtocolType.Udp)
{
if (udpUserInfo[i] == null)
{
Log4Debug("广播时，站位{0}用户udp未连接。" + i);
continue;
}
UdpServer.Instance.SendMessage(udpUserInfo[i].lastPoint, msgXY.ToBytes());
}
}
}
}
public void ConnectedToServer()
{
//获取UdpClient的发送端口
//k_Socket = new KCPSocket(12345, 1, AddressFamily.InterNetwork);
//IPEndPoint localIpep = new IPEndPoint(IPAddress.Parse(Network.player.ipAddress), 12000);
IPEndPoint localIpep = new IPEndPoint(IPAddress.Any, 0);
remoteIpep = new IPEndPoint(IPAddress.Parse("192.168.1.110"), 12000);
kcpClient = new KCPPlayer();
//p2.Init("Player", IPAddress.Parse(Network.player.ipAddress), 12345, 12000);
kcpClient.Init(localIpep, remoteIpep, OnReceive);
UDPLogin login = new UDPLogin()
{
login = DataController.instance.UserID,
roomID = DataController.instance.MyRoomInfo.RoomID,
unique = DataController.instance.MyLocateIndex
};
byte[] message = SerializeHelper.Serialize <UDPLogin>(login);
//因为SendSave限制在断线重连时的重连，所以得绕过判断
MessageXieYi msgxy = new MessageXieYi((byte)MessageConvention.setUDP, 0, message);
byte[] sendBuffer = msgxy.ToBytes();
SendMessage(sendBuffer);
}
public void GetReConnectFrameData(int unique)
{
AsyncUserToken userToken = UserTokenInfo[unique];
int curFrame = FrameIndex;
byte[] message = null;
MessageXieYi xieyi = null;
xieyi = new MessageXieYi((byte)MessageConvention.reConnectIndex, 0, SerializeHelper.ConvertToByte(curFrame + ""));
AsyncIOCPServer.instance.SendSave(userToken, xieyi.ToBytes());
Log4Debug("重连标记帧：" + curFrame);
//帧数据
int limetNum = 1800;
int count = curFrame / limetNum;
count += 1;
for (int i = 0; i < count; i++)
{
int min = i * limetNum;
int max = (i + 1) * limetNum + 1;//多加1帧
if (max > curFrame)
{
max = curFrame;
}
message = GetBoardFrame(min, max);
if (message == null)
{
Log4Debug("重连数据中有空数据->(" + min + "," + max + ")");
}
xieyi = new MessageXieYi((byte)MessageConvention.frameData, 0, message);
AsyncIOCPServer.instance.SendSave(userToken, xieyi.ToBytes());
Log4Debug("发送重连数据->(" + min + "," + max + ")");
}
}
/// <summary>
/// 向该用户广播该房间的人物模型准备数据
/// </summary>
public void GetRoommateNetData(int uniqueID, AsyncUserToken userToken)
{
byte[] message = null;
foreach (var item in ActorList)
{
MessageXieYi xieyi = null;
if (item.Value == null)
{
Log4Debug("检查，房间不该为空");
continue;
}
//准备数据发送完毕，打开UI
message = SerializeHelper.Serialize <GameModelData>(new GameModelData()
{
userIndex = item.Value.UniqueID,
pos = (NetVector3)GameTypeManager.BackStandPos(RoomInfo.RoomType, item.Value.UniqueID),
rotate = new NetVector3(0, GameTypeManager.BackLookAt(RoomInfo.RoomType, item.Value.UniqueID), 0),
animation = 0
});//此处是初始数据
xieyi = new MessageXieYi((byte)MessageConvention.updateModelInfo, 0, message);
AsyncIOCPServer.instance.SendSave(userToken, xieyi.ToBytes());
}
//准备数据发送完毕，打开UI
message = new byte[] { 1 };//此处的数组应该是初始数据
MessageXieYi xieyiFinish = new MessageXieYi((byte)MessageConvention.getPreGameData, 0, message);
AsyncIOCPServer.instance.SendSave(userToken, xieyiFinish.ToBytes());
}
public void SendSave(byte xieYiFirstFlage, byte[] message)
{
Debug.LogError("发送协议：" + (MessageConvention)xieYiFirstFlage);
if (GameManager.instance.CurrentPlayType == FramePlayType.断线重连)
{
return;
}
MessageXieYi msgxy = new MessageXieYi(xieYiFirstFlage, 0, message);
byte[] sendBuffer = msgxy.ToBytes();
SendMessage(sendBuffer);
}
/// <summary>
/// 将需要发送给用户的协议发送
/// </summary>
/// <param name="userID"></param>
/// <param name="message"></param>
/// <param name="xieyiFirst"></param>
/// <param name="xieyiSecond"></param>
public void SendMessageToUser(string userID, byte[] message, byte xieyiFirst, byte xieyiSecond)
{
AsyncUserToken userToken = GetTokenByMemberID(userID);
if (userToken != null)
{
// 创建一个发送缓冲区。
MessageXieYi msgXY = new MessageXieYi(xieyiFirst, xieyiSecond, message);
//Log4Debug("给 ID:" + userID + "/发送消息协议号：" + (MessageConvention)xieyiFirst + "/大小：" + message.Length);
SaveSendMessage(userToken, msgXY.ToBytes());
}
}
void WriteY()
{
for (int i = 0; i < 100; i++)
{
byte j = (byte)i;
MessageXieYi xieyi = new MessageXieYi(1, 0, new byte[5] {
j, j, j, j, j
});
byte[] send = xieyi.ToBytes();
byte[] buffer = AsyncUserToken.GetSendBytes(send);
SendSave(buffer);
}
Console.WriteLine("本次循环完成。");
}
/// <summary>
/// 转换
/// </summary>
/// <param name="xieYiFirstFlage"></param>
/// <param name="message"></param>
public void SendSave(byte xieYiFirstFlage, byte[] message, bool isMask = true)
{
if (isMask)
{
SocketConnectUI.instance.Open((MessageConvention)xieYiFirstFlage);
}
else
{
//Debug.Log("协议：" + (MessageConvention)xieYiFirstFlage + " 不需要显示Loading");
}
MessageXieYi msgxy = new MessageXieYi(xieYiFirstFlage, 0, message);
byte[] sendBuffer = msgxy.ToBytes();
SendSave(MyUserToken, sendBuffer);
}
public void CheckQuit(AsyncUserToken userToken, QuitInfo quitInfo)
{
if (quitInfo.userIndex != 0 && quitInfo.userIndex != quitInfo.quitUnique)//不是房主，并且踢的也不是自己
{
Log4Debug("无权踢人");
quitInfo.isQuit = false;
}
else
{
quitInfo.isQuit = Quit(quitInfo.quitUnique);
}
byte[] message = SerializeHelper.Serialize <QuitInfo>(quitInfo);
MessageXieYi xieyi = new MessageXieYi((byte)MessageConvention.quitRoom, 0, message);
AsyncIOCPServer.instance.SendSave(UserTokenInfo[quitInfo.quitUnique], xieyi.ToBytes());
}
/// <summary>
/// userToken只有一个MemberID能用
/// </summary>
/// <param name="userToken"></param>
public void ReConnect(AsyncUserToken userToken)
{
List <RoomActor> allRA = new List <RoomActor>(ActorList.Values);
RoomActor actor = null;
for (int i = 0; i < allRA.Count; i++)
{
if (allRA[i].Register.userID == userToken.userInfo.Register.userID)
{
actor = allRA[i];
userToken.userInfo = actor;
userToken.userInfo.CurState = RoomActorState.Online;
UserTokenInfo[userToken.userInfo.UniqueID] = userToken;
break;
}
}
//房间信息
MessageXieYi xieyi = new MessageXieYi((byte)MessageConvention.joinRoom, 0, SerializeHelper.ConvertToByte(actor.UniqueID + ""));
AsyncIOCPServer.instance.SendSave(userToken, xieyi.ToBytes());
}
public byte[] SelectMessage(byte[] data, EndPoint endPoint)
{
string strPoint = endPoint.ToString();
byte[] newBuffer = null;
MessageXieYi xieyi = MessageXieYi.FromBytes(data);
if (xieyi == null)
{
return(newBuffer);
}
byte[] tempMessageContent = xieyi.MessageContent;
ActorMoveDirection moveDirection = null;
SingleRoom room = null;
UDPLogin login = null;
//该处RoomList没有加锁
if (ServerDataManager.instance.allRoom.RoomList.ContainsKey(allUDPs[strPoint].roomID))
{
room = ServerDataManager.instance.allRoom.RoomList[allUDPs[strPoint].roomID];
}
switch ((MessageConvention)xieyi.XieYiFirstFlag)
{
case MessageConvention.setUDP:
login = SerializeHelper.Deserialize <UDPLogin>(tempMessageContent);
login.login = strPoint;
allUDPs[strPoint].roomID = login.roomID;
allUDPs[strPoint].unique = login.unique;
Log4Debug("UDP login 房间号：" + login.roomID);
newBuffer = SerializeHelper.Serialize <UDPLogin>(login);
break;
case MessageConvention.moveDirection:
moveDirection = SerializeHelper.Deserialize <ActorMoveDirection>(tempMessageContent);
if (room.ActorList[moveDirection.userIndex].CurState != RoomActorState.Dead)
{
//Log4Debug("将历史帧：" + moveDirection.frameIndex + "保存到" + (moveDirection.frameIndex + room.RoomInfo.frameInterval) + "/" + room.RoomInfo.FrameIndex);
room.SetRecondFrame(xieyi.ToBytes());
//Log4Debug("站位：" + moveDirection.userIndex + " 更新了方向：" + "["
// + moveDirection.direction.x + ","
// + moveDirection.direction.y + ","
// + moveDirection.direction.z + "]"
// + "/速度:" + moveDirection.speed);
}
else
{
Log4Debug("死亡用户不更新移动。");
}
break;
case MessageConvention.rotateDirection:
ActorRotateDirection netRotation = SerializeHelper.Deserialize <ActorRotateDirection>(tempMessageContent);
if (room.ActorList[netRotation.userIndex].CurState != RoomActorState.Dead)
{
room.SetRecondFrame(xieyi.ToBytes());
//Log4Debug("站位：" + netRotation.userIndex + " 更新了旋转：" + netRotation.rotateY);
}
else
{
Log4Debug("死亡用户不更新旋转。");
}
break;
case MessageConvention.jump:
ActorJump netJump = SerializeHelper.Deserialize <ActorJump>(tempMessageContent);
if (room.ActorList[netJump.userIndex].CurState != RoomActorState.Dead)
{
room.SetRecondFrame(xieyi.ToBytes());
}
else
{
Log4Debug("死亡用户不更新跳跃。");
}
break;
case MessageConvention.shootBullet:
ShootInfo shootInfo = SerializeHelper.Deserialize <ShootInfo>(tempMessageContent);
if (room.ActorList[shootInfo.userIndex].CurState != RoomActorState.Dead)
{
room.SetRecondFrame(xieyi.ToBytes());
//Log4Debug("站位：" + netRotation.userIndex + " 更新了旋转：" + netRotation.rotateY);
}
else
{
Log4Debug("死亡用户不更新射击。");
}
break;
case MessageConvention.bulletInfo:
//
BulletInfo bulletInfo = SerializeHelper.Deserialize <BulletInfo>(xieyi.MessageContent);
room.UpdateBulletInfo(bulletInfo); //更新
//room.SetRecondFrame(xieyi.ToBytes());
break;
default:
Log4Debug("检查协议->" + (MessageConvention)xieyi.XieYiFirstFlag);
break;
}
byte[] sendBuffer = null;
if (newBuffer != null)//用户需要服务器返回值给自己的话
{
xieyi = new MessageXieYi(xieyi.XieYiFirstFlag, xieyi.XieYiSecondFlag, newBuffer);
sendBuffer = xieyi.ToBytes();
}
return(sendBuffer);
}
/// <summary>
/// tcp
/// </summary>
/// <param name="xieyi"></param>
/// <param name="userToken"></param>
/// <returns></returns>
public byte[] SelectMessage(MessageXieYi xieyi, AsyncUserToken userToken)
{
JObject json = null;
byte[] newBuffer = null;
byte[] tempMessageContent = xieyi.MessageContent;
int roomID = userToken.userInfo.RoomID;
SingleRoom room = GetSingleRoomByID(roomID);
Register login = null;
RoomActorUpdate roomActorUpdate = null;
ActorMoveDirection moveDirection = null;
if (userToken == null)
{
Log4Debug("该用户已被清理，不处理接收数据。");
return(newBuffer);
}
if (allRoom.RoomList.ContainsKey(userToken.userInfo.RoomID))
{
room = allRoom.RoomList[userToken.userInfo.RoomID];
}
//Log4Debug("/" + xieyi.MessageContentLength);
//try
{
switch ((MessageConvention)xieyi.XieYiFirstFlag)
{
case MessageConvention.login:
login = SerializeHelper.Deserialize <Register>(tempMessageContent);
newBuffer = Login(login, userToken);
break;
case MessageConvention.getHeartBeatTime:
HeartbeatTime hbTime = new HeartbeatTime()
{
time = AsyncIOCPServer.HeartbeatSecondTime
};
newBuffer = SerializeHelper.Serialize <HeartbeatTime>(hbTime);
break;
case MessageConvention.reConnectCheck:
//检查是否是掉线用户
ReconnctInfo rcInfo = new ReconnctInfo();
if (OffLineRooms.ContainsKey(userToken.userInfo.Register.userID))
{
int offRoomID = OffLineRooms[userToken.userInfo.Register.userID];
userToken.userInfo.RoomID = offRoomID;
allRoom.RoomList[offRoomID].ReConnect(userToken);
int removeCount = 0;
OffLineRooms.TryRemove(userToken.userInfo.Register.userID, out removeCount);
rcInfo.isReconnect = true;
}
else
{
rcInfo.isReconnect = false;
}
newBuffer = SerializeHelper.Serialize <ReconnctInfo>(rcInfo);
break;
case MessageConvention.reConnectIndex:
room.GetReConnectFrameData(userToken.userInfo.UniqueID);
break;
case MessageConvention.heartBeat:
//心跳检测客户端传递服务器时间
//Log4Debug("接收到 " + userToken.userInfo.Register.name + " 的心跳检测");
//newBuffer = SerializeHelper.DateTimeToBytes(DateTime.Now);
//newBuffer = SerializeHelper.Serialize<HeartbeatTime>(new HeartbeatTime() { time = AsyncIOCPServer.HeartbeatSecondTime });
break;
case MessageConvention.updateName:
string updateName = SerializeHelper.ConvertToString(tempMessageContent);
Log4Debug("修改人物信息：" + updateName);
newBuffer = UpdateName(userToken, updateName);
break;
case MessageConvention.createRoom:
json = JObject.Parse(SerializeHelper.ConvertToString(xieyi.MessageContent));
newBuffer = allRoom.CreateNewRoom(json, userToken);
break;
case MessageConvention.joinRoom:
json = JObject.Parse(SerializeHelper.ConvertToString(xieyi.MessageContent));
newBuffer = allRoom.JoinRoom(json, userToken);
break;
case MessageConvention.updateRoom:
Log4Debug("更新房间");
json = JObject.Parse(SerializeHelper.ConvertToString(xieyi.MessageContent));
newBuffer = allRoom.UpdateRoom(json);
break;
case MessageConvention.getRoomInfo:
newBuffer = SerializeHelper.Serialize <RoomInfo>(room.RoomInfo);
break;
case MessageConvention.getRoommateInfo:
Log4Debug("请求房间人物信息：" + SerializeHelper.ConvertToString(tempMessageContent));
roomActorUpdate = new RoomActorUpdate();
roomActorUpdate.SetSendInfo(SerializeHelper.ConvertToString(tempMessageContent));
//
newBuffer = SerializeHelper.Serialize <List <RoomActor> >(new List <RoomActor>(room.ActorList.Values));
break;
case MessageConvention.quitRoom:
QuitInfo qInfo = SerializeHelper.Deserialize <QuitInfo>(tempMessageContent);
if (room != null)
{
room.CheckQuit(userToken, qInfo);
}
break;
case MessageConvention.updateActorAnimation:
ActorNetAnimation netAnimation = new ActorNetAnimation();
netAnimation.SetSendInfo(SerializeHelper.ConvertToString(tempMessageContent));
//Log4Debug("set->" + netAnimation.animationIndex + "");
room.UpdateAnimation(netAnimation); //更新
break;
case MessageConvention.updateActorState:
roomActorUpdate = new RoomActorUpdate();
roomActorUpdate.SetSendInfo(SerializeHelper.ConvertToString(tempMessageContent));
Log4Debug("站位：" + userToken.userInfo.UniqueID + "/" + userToken.userInfo.Register.name
+ "用户站位：" + roomActorUpdate.userIndex +
"请求修改状态为->" + (RoomActorState)int.Parse(roomActorUpdate.update));
//
room.UpdateState(roomActorUpdate); //更新
break;
case MessageConvention.prepareLocalModel:
roomActorUpdate = new RoomActorUpdate();
roomActorUpdate.SetSendInfo(SerializeHelper.ConvertToString(tempMessageContent));
//
room.UpdatePrepare(roomActorUpdate, userToken); //更新
break;
case MessageConvention.getPreGameData:
break;
case MessageConvention.startGaming:
break;
case MessageConvention.endGaming:
break;
case MessageConvention.frameData:
FrameInfo frame = SerializeHelper.Deserialize <FrameInfo>(tempMessageContent);
newBuffer = room.GetBoardFrame(frame.frameIndex);
//Log4Debug("用户" + userToken.userInfo.Register.name + "/请求帧数据：" + frame.frameIndex + "/" + room.RoomInfo.FrameIndex + "数据总长：" + newBuffer.Length);
break;
//case MessageConvention.setUDP:
// UDPLogin loginUDP = SerializeHelper.Deserialize<UDPLogin>(tempMessageContent);
// Log4Debug("收到登录UDP账号：" + loginUDP.login);
// room.UpdateUDP(userToken.userInfo.UniqueID, loginUDP);
// break;
default:
Log4Debug("TCP是否判断该协议：" + (MessageConvention)xieyi.XieYiFirstFlag);
break;
}
}
//catch (Exception error)
//{
// Log4Debug("处理逻辑错误：" + error.Message);
//}
// 创建一个发送缓冲区。
byte[] sendBuffer = null;
if (newBuffer != null)//用户需要服务器返回值给自己的话
{
xieyi = new MessageXieYi(xieyi.XieYiFirstFlag, xieyi.XieYiSecondFlag, newBuffer);
sendBuffer = xieyi.ToBytes();
}
return(sendBuffer);
}
//public void ShootBullet(BulletInfo bullet)
//{
// //子弹的拥有者的旋转角度
// Vector3 bulletRotate = ActorList[bullet.userIndex].myRotationInfo.Rotation;
// Vector2 bullet2D = new Vector2(bullet.pos.x, bullet.pos.z);
// //子弹相对落地点（半径以内的x，y）
// Vector2 sPos = new Vector2(
// RoomActor.ShootRadius * Mathf.Sin((Mathf.PI / 180) * bulletRotate.y),
// RoomActor.ShootRadius * Mathf.Cos((Mathf.PI / 180) * bulletRotate.y));
// //子弹世界落地点
// Vector2 bulletWorldPos = sPos + bullet2D;
// foreach (var item in ActorList)//遍历是否射中其他玩家
// {
// bool isShooted = false;
// if (item.Value == null)
// continue;
// if (item.Value.UniqueID == bullet.userIndex)//子弹不检测自身
// continue;
// RoomActor actor = item.Value;
// //待碰撞人物的顶视图世界坐标
// Vector2 cP = new Vector2(actor.MyMoveInfo.Pos.x, actor.MyMoveInfo.Pos.z);
// //子弹发射点和待碰撞人物距离
// float bscDistance = Vector2.Distance(bullet2D, cP);
// //子弹射击方向世界角度
// float shootRotate = bulletRotate.y;
// shootRotate = 90 - shootRotate;//转换模型旋转角度到世界坐标角度
// BackPositiveOfAngle(ref shootRotate);//转换负数角度成正数角度
// //射击点到人物的世界角度
// float middleAngle = Mathf.Atan2(actor.MyMoveInfo.Pos.z - bullet.pos.z, actor.MyMoveInfo.Pos.x - bullet.pos.x) * 180 / Mathf.PI;
// BackPositiveOfAngle(ref middleAngle);
// //射击点到人物边缘的世界角度
// float sideAngle = Mathf.Atan2(RoomActor.ModelRadius, bscDistance) * 180 / Mathf.PI;
// BackPositiveOfAngle(ref sideAngle);
// float angleMin = (middleAngle - sideAngle) > (middleAngle + sideAngle) ? (middleAngle + sideAngle) : (middleAngle - sideAngle);
// float angleMax = (middleAngle - sideAngle) > (middleAngle + sideAngle) ? (middleAngle - sideAngle) : (middleAngle + sideAngle);
// //判断待射击人物的夹角(计算射击点到人物边缘的角度)子弹在朝向模型
// if (shootRotate > angleMin && shootRotate < angleMax)
// {
// if (bscDistance <= RoomActor.ShootRadius)//待检测人物的中心点在射击半径上或内
// {
// isShooted = true;
// }
// else if (bscDistance < RoomActor.ShootRadius + RoomActor.ModelRadius)//子弹落在2个人物之间,正好是射击待碰撞人物中心点，最短距离
// {
// //判断子弹落地点是否在待检测人物半径内
// if (Vector2.Distance(bulletWorldPos, cP) <= RoomActor.ModelRadius)
// {
// isShooted = true;
// }
// }
// }
// //射中人物
// if (isShooted)
// {
// Log4Debug("射中人物：" + actor.UniqueID);
// TeamType bulletType = BackTeamTypeByUnique(bullet.userIndex);
// RoomActorUpdate hit = new RoomActorUpdate() { userIndex = actor.UniqueID, update = (int)bulletType + "" };
// byte[] message = SerializeHelper.ConvertToByte(hit.GetSendInfo());
// //广播
// BoardcastMessage(MessageConvention.shootBullet, message);
// return;
// }
// }
// //Log4Debug("子弹落地点：" + bulletWorldPos);
// //子弹碰撞方块
// foreach (KeyValuePair<int, BoxInfo> item in BoxList)
// {
// Vector2 boxPos = new Vector2(item.Value.position.x, item.Value.position.z);
// Vector2 boxScale = new Vector2(item.Value.scale.x, item.Value.scale.z);
// if (
// bulletWorldPos.x > boxPos.x - (float)(boxScale.x / 2) &&
// bulletWorldPos.x <= boxPos.x + (float)(boxScale.x / 2) &&
// bulletWorldPos.y > boxPos.y - (float)(boxScale.y / 2) &&
// bulletWorldPos.y <= boxPos.y + (float)(boxScale.y / 2)
// )//顶视图看是在方格内的
// {
// Log4Debug("子弹落点：（" + bulletWorldPos.x + "," + bulletWorldPos.y + ") 射中方块坐标：(" + item.Value.position.x + "," + item.Value.position.z + ")");
// //设置色块拥有者
// item.Value.ownerIndex = bullet.userIndex;
// //广播发送消息
// RoomActorUpdate hit = new RoomActorUpdate() { userIndex = bullet.userIndex, update = item.Key + "" };
// byte[] message = SerializeHelper.ConvertToByte(hit.GetSendInfo());
// //射中地板方块
// BoardcastMessage(MessageConvention.updateBox, message);
// return;
// }
// }
// //
//}
public void UpdateBulletInfo(BulletInfo bulletInfo)
{
byte[] message = null;
MessageXieYi xieyi = null;
int boxIndex = -1;
//
switch (bulletInfo.shootTag)
{
case ShootTag.Box:
//设置色块拥有者
lock (BoxList)
{
boxIndex = int.Parse(bulletInfo.shootInfo);
BoxInfo boxInfo = new BoxInfo()
{
ownerIndex = -1, myIndex = boxIndex
};
BoxList.AddOrUpdate(boxIndex, boxInfo, (key, oldValue) => boxInfo);
if (BoxList[boxIndex].ownerIndex < 0)
{
BoxList[boxIndex].ownerIndex = bulletInfo.userIndex;
//生成buff
BuffInfo buffInfo = new BuffInfo()
{
ownerIndex = -1, myIndex = BuffIndex
};
lock (BuffList)
{
buffInfo.boxIndex = boxIndex;
buffInfo.type = RandomBuffType();//随机一个buff类型
BuffList.AddOrUpdate(BuffIndex, buffInfo, (key, oldValue) => buffInfo);
BuffIndex++;
}
Log4Debug("在盒子编号->" + boxIndex + " 掉落Buff,编号->" + buffInfo.myIndex + ",类型->" + buffInfo.type);
//保存子弹消息
message = SerializeHelper.Serialize <BulletInfo>(bulletInfo);
xieyi = new MessageXieYi((byte)MessageConvention.bulletInfo, 0, message);
SetRecondFrame(xieyi.ToBytes());
//保存Buff消息
message = SerializeHelper.Serialize <BuffInfo>(buffInfo);
xieyi = new MessageXieYi((byte)MessageConvention.createBuff, 0, message);
SetRecondFrame(xieyi.ToBytes());
}
else //该色块已被其他人击碎
{
return;
}
}
break;
case ShootTag.Character:
//
int shootedIndex = int.Parse(bulletInfo.shootInfo);
if (ActorList[shootedIndex].MyTeam == ActorList[bulletInfo.userIndex].MyTeam)
{
return;
}
if (ActorList[shootedIndex].CurState == RoomActorState.Gaming)
{
//增加击杀数
ActorList[bulletInfo.userIndex].KillCount++;
if (CurState == RoomActorState.Gaming)
{
message = SerializeHelper.Serialize <List <RoomActor> >(new List <RoomActor>(ActorList.Values));
BoardcastMessage(MessageConvention.getRoommateInfo, message);
}
//改变被射击者状态
RoomActorUpdate dead = new RoomActorUpdate()
{
userIndex = shootedIndex,
update = (int)RoomActorState.Dead + ""
};
UpdateState(dead);
}
else if (ActorList[shootedIndex].CurState == RoomActorState.Invincible)
{
Log4Debug("射击者站位：" + bulletInfo.userIndex + " 攻击无敌站位：->" + shootedIndex);
}
else
{
Log4Debug("射击者站位：" + bulletInfo.userIndex + " 正在鞭尸位置->" + shootedIndex);
}
//保存子弹消息
message = SerializeHelper.Serialize <BulletInfo>(bulletInfo);
xieyi = new MessageXieYi((byte)MessageConvention.bulletInfo, 0, message);
SetRecondFrame(xieyi.ToBytes());
break;
case ShootTag.Wall:
//打中墙的消息就不存了
break;
case ShootTag.Buff:
int buffIndex = int.Parse(bulletInfo.shootInfo);
//Log4Debug("站位：" + bulletInfo.userIndex + " 请求拾取Buff->" + buffIndex);
lock (BuffList)
{
if (BuffList[buffIndex].ownerIndex < 0)
{
BuffList[buffIndex].ownerIndex = bulletInfo.userIndex;
Log4Debug("站位：" + bulletInfo.userIndex + " 拾取了Buff->" + buffIndex);
}
else //该buff已被其他人加成
{
return;
}
}
//保存Buff消息
message = SerializeHelper.Serialize <BuffInfo>(BuffList[buffIndex]);
xieyi = new MessageXieYi((byte)MessageConvention.getBuff, 0, message);
SetRecondFrame(xieyi.ToBytes());
break;
}
//广播发送消息
//byte[] message = SerializeHelper.ConvertToByte(bulletInfo));
//BoardcastMessage(MessageConvention.bulletInfo, message);
}
public void UpdateState(RoomActorUpdate roomActorUpdate)
{
int index = roomActorUpdate.userIndex;
RoomActorState upState = (RoomActorState)int.Parse(roomActorUpdate.update);
if (ActorList[index] == null)
{
return;
}
//if (ActorList[index].CurState != RoomActorState.ReConnect)
{
Log4Debug("站位 " + index + " 更新当前状态：" + ActorList[index].CurState + " -> " + (RoomActorState)int.Parse(roomActorUpdate.update));
ActorList[index].CurState = upState;
byte[] message = SerializeHelper.ConvertToByte(roomActorUpdate.GetSendInfo());
BoardcastMessage(MessageConvention.updateActorState, message);
if (CheckIsAllFixedState(RoomActorState.Ready))
{
ChangeRoomState(RoomActorState.Ready);
}
if (CurState == RoomActorState.Gaming)
{
switch (ActorList[index].CurState)
{
case RoomActorState.ReConnect:
break;
case RoomActorState.WaitForStart:
Log4Debug("模型未准备好的玩家准备好进入游戏了。");
string starttime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");
byte[] start = SerializeHelper.ConvertToByte(starttime);
MessageXieYi xieyi = new MessageXieYi((byte)MessageConvention.startGaming, 0, start);
AsyncIOCPServer.instance.SendSave(UserTokenInfo[index], xieyi.ToBytes());
roomActorUpdate = new RoomActorUpdate()
{
userIndex = index,
update = (int)RoomActorState.Gaming + ""
};
UpdateState(roomActorUpdate); //广播,修改玩家状态用来准备本机数据
break;
case RoomActorState.Dead:
ActorList[index].timerDead = new Timer(new TimerCallback(SetAfterDead), index, RoomActor.DeadLastTime, 0);
break;
}
}
}
//else//reConnect时修改状态
//{
// if (upState == RoomActorState.WaitForStart && RoomInfo.CurState == RoomActorState.Gaming)
// {
// ActorList[index].CurState = RoomActorState.Gaming;
// roomActorUpdate.update = (int)ActorList[index].CurState + "";
// byte[] message = SerializeHelper.ConvertToByte(roomActorUpdate.GetSendInfo());
// BoardcastMessage(MessageConvention.updateActorState, message);
// }
// else
// {
// Log4Debug("想要在重连时更新状态：" + upState);
// }
//}
}
// 會員加入房間
public bool Join(AsyncUserToken userToken, out int UniqueID)
{
UniqueID = -1;
lock (ActorList)
{
foreach (KeyValuePair <int, RoomActor> item in ActorList)
{
if (item.Value.Register == null)
{
UniqueID = item.Key;
item.Value.Register = userToken.userInfo.Register;//先占位，放开lock，允许其他人加入。
break;
}
}
}
if (UniqueID != -1)
{
Log4Debug("账号->" + userToken.userInfo.Register.userID + " 用户名->" + userToken.userInfo.Register.name + " 加入房间->" + RoomInfo.RoomID + " 站位为->" + UniqueID);
//
TeamType myTeam = TeamType.Both;
switch (RoomInfo.RoomType)
{
case GameModel.组队模式:
if (UniqueID % 2 == 0) //红蓝两队
{
myTeam = TeamType.Blue;
}
else
{
myTeam = TeamType.Red;
}
break;
case GameModel.Boss模式:
myTeam = TeamType.Blue;
break;
}
//
RoomActor actor = new RoomActor(RoomInfo.RoomID, UniqueID, userToken.userInfo.Register, myTeam);
actor.MyModelInfo.pos = (NetVector3)GameTypeManager.BackStandPos(RoomInfo.RoomType, UniqueID);
actor.MyModelInfo.rotate = new NetVector3(0, GameTypeManager.BackLookAt(RoomInfo.RoomType, UniqueID), 0);
actor.MyModelInfo.animation = 0;
userToken.userInfo = actor;
lock (UserTokenInfo)
{
UserTokenInfo[UniqueID] = userToken;
}
lock (ActorList)
{
ActorList[UniqueID] = actor;
}
BoardcastActorInfo(UniqueID);
//广播房间信息
byte[] message = SerializeHelper.Serialize <RoomInfo>(RoomInfo);
MessageXieYi xieyi = new MessageXieYi((byte)MessageConvention.getRoomInfo, 0, message);
AsyncIOCPServer.instance.SendSave(userToken, xieyi.ToBytes());
return(true);
}
else
{
return(false);
}
}
