public override bool TakeAction()
{
PlayerFoundryLogic pf = new PlayerFoundryLogic();
pf.SetUser(m_UserId);
if (CacheSet.FoundryRoomCache.FindKey(pf.MyFoundry.CurrentRoomId).Players[0] != m_UserId)
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You have not this permission";
return(false);
}
pf.SetUser(m_RequestPacket.PlayerId);
pf.QuitRoom();
pf.SetUser(m_UserId);
pf.PushRoomPlayerChangedNotify();
var target = GameSession.Get(m_RequestPacket.PlayerId);
if (target != null)
{
LCKickedFromGearFoundryTeam package = new LCKickedFromGearFoundryTeam();
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(package.PacketActionId, ProtoBufUtils.Serialize(package));
target.SendAsync(buffer, 0, buffer.Length);
}
return(true);
}
public override bool TakeAction()
{
LWGetWorldSinglePvpRank package = new LWGetWorldSinglePvpRank()
{
UserId = m_UserId,
ServerId = int.Parse(ConfigUtils.GetSetting("Server.Id"))
};
WorldServerSender.Send("LWGetWorldSinglePvpRankHandler", package, delegate(RemotePackage callback)
{
var res = RemoteCommunication.ParseRemotePackage <WLGetWorldSinglePvpRank>(callback.Message as byte[]);
m_ResponsePacket.MyRank = res.MyRank;
m_ResponsePacket.MyScore = res.MyScore;
for (int i = 0; i < res.PlayerInfo.Count; i++)
{
m_ResponsePacket.PlayerInfo.Add(new PBPlayerInfo()
{
Id = res.PlayerInfo[i].Id,
Name = res.PlayerInfo[i].Name,
PortraitType = res.PlayerInfo[i].PortraitType,
});
m_ResponsePacket.ServerId.Add(res.ServerId[i]);
m_ResponsePacket.Score.Add(res.Score[i]);
}
var buff = CustomActionDispatcher.GeneratePackageStream(actionGetter.GetActionId(), ProtoBufUtils.Serialize(m_ResponsePacket));
GameSession.Get(m_UserId).SendAsync(buff, 0, buff.Length);
});
return(true);
}
public override bool TakeAction()
{
PlayerFriendsLogic pf = new PlayerFriendsLogic();
if (!pf.DeleteFriend(m_UserId, m_RequestPacket.PlayerId))
{
ErrorCode = (int)ErrorType.CannotOpenChance;
ErrorInfo = "You don't have this friend";
return(false);
}
var target = GameSession.Get(m_RequestPacket.PlayerId);
if (target != null)
{
LCDeleteFriend sendPost = new LCDeleteFriend()
{
DeletedPlayerId = m_UserId,
IsActive = false
};
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(3104, ProtoBufUtils.Serialize(sendPost));
target.SendAsync(buffer, 0, buffer.Length);
}
m_ResponsePacket.DeletedPlayerId = m_RequestPacket.PlayerId;
m_ResponsePacket.IsActive = true;
return(true);
}
public void Move(float XCoord, float YCoord)
{
m_NearbyPosition.MyPositionX = XCoord;
m_NearbyPosition.MyPositionY = YCoord;
List <int> disconnectedPlayers = new List <int>();
foreach (int playerId in m_NearbyPosition.Visitors)
{
var target = GameSession.Get(playerId);
if (target != null && target.IsSocket)
{
LCPlayerMove package = new LCPlayerMove();
package.LobbyPositionX = XCoord;
package.LobbyPositionY = YCoord;
package.PlayerId = m_UserId;
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(package.PacketActionId, ProtoBufUtils.Serialize(package));
target.SendAsync(buffer, 0, buffer.Length);
}
else
{
disconnectedPlayers.Add(playerId);
}
}
m_NearbyPosition.ModifyLocked(() =>
{
foreach (int playerId in disconnectedPlayers)
{
m_NearbyPosition.Visitors.Remove(playerId);
}
});
}
public void Execute()
{
var roomList = CacheSet.FoundryRoomCache.FindAll();
PlayerFoundryLogic pf = new PlayerFoundryLogic();
foreach (var room in roomList)
{
room.Progress = 0;
room.Level = 0;
foreach (var player in room.Players)
{
pf.SetUser(player);
pf.ResetUser();
var target = GameSession.Get(player);
if (target != null)
{
LCResetGearFoundryInfo package = new LCResetGearFoundryInfo();
package.NextFoundryTimeInTicks = pf.MyFoundry.NextFoundryTime;
package.Progress = new PBGearFoundryProgressInfo()
{
CurrentLevel = room.Level, CurrentProgress = room.Progress
};
package.RewardFlags.AddRange(pf.MyFoundry.CanReceiveRewards);
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(package.PacketActionId, ProtoBufUtils.Serialize(package));
target.SendAsync(buffer, 0, buffer.Length);
}
}
}
}
public override bool TakeAction()
{
m_ResponsePacket.PlayerId = m_RequestPacket.FriendCandidatePlayerId;
PlayerFriendsLogic pf = new PlayerFriendsLogic();
pf.SetUser(m_RequestPacket.FriendCandidatePlayerId);
if (!pf.Invited(m_UserId))
{
ErrorCode = (int)ErrorType.CannotMakeFriendRequest;
ErrorInfo = "You can not invite this player";
return(false);
}
var target = GameSession.Get(m_RequestPacket.FriendCandidatePlayerId);
if (target == null)
{
return(true);
}
LCReceiveFriendRequest request = new LCReceiveFriendRequest();
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
request.Player = new PBPlayerInfo()
{
Id = m_UserId,
Name = p.MyPlayer.Name,
Level = p.MyPlayer.Level,
VipLevel = p.MyPlayer.VIPLevel
};
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(3107, ProtoBufUtils.Serialize(request));
target.SendAsync(buffer, 0, buffer.Length);
return(true);
}
public void PushRoomProgressChangedNotify()
{
var roomInfo = CacheSet.FoundryRoomCache.FindKey(m_Foundry.CurrentRoomId);
LCPerformFoundry package = new LCPerformFoundry();
int userId = m_UserId;
foreach (int playerId in roomInfo.Players)
{
var target = GameSession.Get(playerId);
if (target != null && playerId != userId)
{
SetUser(playerId);
package.RewardFlags.AddRange(m_Foundry.CanReceiveRewards);
package.PerformerPlayerId = userId;
var room = CacheSet.FoundryRoomCache.FindKey(m_Foundry.CurrentRoomId);
package.Progress = new PBGearFoundryProgressInfo()
{
CurrentLevel = room.Level,
CurrentProgress = room.Progress
};
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(2108, ProtoBufUtils.Serialize(package));
target.SendAsync(buffer, 0, buffer.Length);
}
}
SetUser(userId);
}
public override bool TakeAction()
{
PlayerFriendsLogic pf = new PlayerFriendsLogic();
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
PBPlayerInfo myInfo = new PBPlayerInfo()
{
Id = m_UserId,
Name = p.MyPlayer.Name,
Level = p.MyPlayer.Level,
VipLevel = p.MyPlayer.VIPLevel,
LastLoginInTicks = p.MyPlayer.LastLoginTime
};
p.SetUser(m_RequestPacket.PlayerId);
PBPlayerInfo friendInfo = new PBPlayerInfo()
{
Id = m_RequestPacket.PlayerId,
Name = p.MyPlayer.Name,
Level = p.MyPlayer.Level,
VipLevel = p.MyPlayer.VIPLevel,
LastLoginInTicks = p.MyPlayer.LastLoginTime
};
LCReceiveRespondToFriendRequest SendPackage = new LCReceiveRespondToFriendRequest()
{
Accept = m_RequestPacket.Accept,
Player = myInfo,
};
if (m_RequestPacket.Accept == true)
{
if (!pf.AddFriend(m_UserId, m_RequestPacket.PlayerId))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "Can't add this friend";
return(false);
}
pf.SetUser(m_UserId);
m_ResponsePacket.CanGiveEnergy = pf.MyFriends.Friends[m_RequestPacket.PlayerId].CanSendEnergy;
m_ResponsePacket.CanReceiveEnergy = pf.MyFriends.Friends[m_RequestPacket.PlayerId].CanReceiveEnergy;
pf.SetUser(m_RequestPacket.PlayerId);
SendPackage.CanGiveEnergy = pf.MyFriends.Friends[m_UserId].CanSendEnergy;
SendPackage.CanReceiveEnergy = pf.MyFriends.Friends[m_UserId].CanReceiveEnergy;
pf.RemoveInvitation(m_UserId);
}
var target = GameSession.Get(m_RequestPacket.PlayerId);
if (target != null)
{
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(3111, ProtoBufUtils.Serialize(SendPackage));
target.SendAsync(buffer, 0, buffer.Length);
}
pf.SetUser(m_UserId);
pf.RemoveInvitation(m_RequestPacket.PlayerId);
m_ResponsePacket.Accept = m_RequestPacket.Accept;
m_ResponsePacket.Player = friendInfo;
return(true);
}
public void SendNotification()
{
LCHaveNewEmail package = new LCHaveNewEmail();
byte[] data = ProtoBufUtils.Serialize(package);
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(3202, data);
GameSession.Get(m_UserId).SendAsync(buffer, 0, buffer.Length);
}
private static void PushAnnouncement(LCPushSystemAnnouncement packet)
{
byte[] data = ProtoBufUtils.Serialize(packet);
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(4006, data);
foreach (var session in GameSession.GetOnlineAll())
{
if (session.Connected)
{
session.SendAsync(buffer, 0, buffer.Length);
}
}
}
public void PushRoomPlayerChangedNotify(int roomId = 0, bool needPushToMe = true)
{
FoundryRoom roomInfo;
if (roomId == 0)
{
roomInfo = CacheSet.FoundryRoomCache.FindKey(m_Foundry.CurrentRoomId);
}
else
{
roomInfo = CacheSet.FoundryRoomCache.FindKey(roomId);
}
if (roomInfo == null)
{
return;
}
LCPlayerListInGearFoundryTeam package = new LCPlayerListInGearFoundryTeam();
List <GameSession> targets = new List <GameSession>();
PlayerLogic p = new PlayerLogic();
int userId = m_UserId;
foreach (int playerId in roomInfo.Players)
{
var target = GameSession.Get(playerId);
if (target != null)
{
targets.Add(target);
}
var gearFoundryPlayerInfo = new PBGearFoundryPlayerInfo();
p.SetUser(playerId);
gearFoundryPlayerInfo.Player = new PBPlayerInfo()
{
Id = playerId,
Name = p.MyPlayer.Name,
PortraitType = p.MyPlayer.PortraitType,
Level = p.MyPlayer.Level
};
SetUser(playerId);
gearFoundryPlayerInfo.FoundryCount = m_Foundry.FoundryCount;
package.Players.Add(gearFoundryPlayerInfo);
}
SetUser(userId);
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(2105, ProtoBufUtils.Serialize(package));
foreach (var target in targets)
{
if (!needPushToMe && target.UserId == m_UserId)
{
continue;
}
target.SendAsync(buffer, 0, buffer.Length);
}
}
public override bool TakeAction()
{
GameSession target = GameSession.Get(m_RequestPacket.FriendPlayerId);
if (target == null)
{
ErrorCode = (int)ErrorType.PlayerNotOnline;
ErrorInfo = "Player is not online";
return(false);
}
PlayerFoundryLogic pf = new PlayerFoundryLogic();
pf.SetUser(m_UserId);
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
int teamId = pf.GetPlayerFoundryInfo().CurrentRoomId;
if (teamId < 0)
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You are not in a room";
return(false);
}
if (CacheSet.FoundryRoomCache.FindKey(teamId).Players[0] != m_UserId)
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You have not this permission";
return(false);
}
LCInvitedForGearFoundry package = new LCInvitedForGearFoundry();
package.TeamId = teamId;
package.InviterPlayer = new PBPlayerInfo()
{
Id = m_UserId,
Name = p.MyPlayer.Name,
Level = p.MyPlayer.Level,
PortraitType = p.MyPlayer.PortraitType
};
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(2112, ProtoBufUtils.Serialize(package));
target.SendAsync(buffer, 0, buffer.Length);
m_ResponsePacket.FriendPlayerId = m_RequestPacket.FriendPlayerId;
return(true);
}
private static byte[] GenPackage(int type, Player sender, string message)
{
LCGetChat chatPackage = new LCGetChat();
chatPackage.Type = type;
chatPackage.Massage = message;
chatPackage.Sender = new PBPlayerInfo()
{
Id = sender.Id,
Name = sender.Name,
VipLevel = sender.VIPLevel,
Level = sender.Level
};
chatPackage.Time = DateTime.UtcNow.Ticks;
byte[] data = ProtoBufUtils.Serialize(chatPackage);
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(3002, data);
return(buffer);
}
private void PushProgressModified(List <TrackingAchievement> achievements)
{
LCPushAchievementProgress packet = new LCPushAchievementProgress();
foreach (var achievement in achievements)
{
packet.TrackingAchievements.Add(new PBTrackingAchievement()
{
AchievementId = achievement.Id,
ProgressCount = achievement.Progress
});
}
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(packet.PacketActionId, ProtoBufUtils.Serialize(packet));
var session = GameSession.Get(m_UserId);
if (session != null)
{
session.SendAsync(buffer, 0, buffer.Length);
}
}
protected override void TakeRemote()
{
TraceLog.ReleaseWrite("Player:{0} match success", m_RequestPacket.PlayerId.ToString());
LCPushPvpMatchSuccess package = new LCPushPvpMatchSuccess()
{
RoomId = m_RequestPacket.RoomId,
InstanceId = m_RequestPacket.InstanceId,
Token = m_RequestPacket.Token,
RoomServerHost = m_RequestPacket.RoomServerHost,
RoomServerPort = m_RequestPacket.RoomServerPort,
EnemyInfo = m_RequestPacket.EnemyInfo,
};
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(package.PacketActionId, ProtoBufUtils.Serialize(package));
try
{
GameSession.Get(m_RequestPacket.PlayerId).SendAsync(buffer, 0, buffer.Length);
}
catch
{
return;
}
}
public override bool TakeAction()
{
PlayerFriendsLogic pf = new PlayerFriendsLogic();
pf.SetUser(m_UserId);
if (!pf.SendEnergy(m_RequestPacket.FriendPlayerId))
{
ErrorCode = (int)ErrorType.CannotOpenChance;
ErrorInfo = "you can not send energy to this player";
return(false);
}
GameSession target = GameSession.Get(m_RequestPacket.FriendPlayerId);
if (target != null)
{
LCGivenEnergyByFriend package = new LCGivenEnergyByFriend();
package.FriendPlayerId = m_UserId;
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(3112, ProtoBufUtils.Serialize(package));
target.SendAsync(buffer, 0, buffer.Length);
}
m_ResponsePacket.FriendPlayerId = m_RequestPacket.FriendPlayerId;
m_ResponsePacket.RemainCount = GameConsts.Social.MaxSendCount - pf.MyFriends.SendCount;
return(true);
}
public override void WriteResponse(BaseGameResponse response)
{
CustomActionDispatcher.ResponseOK(response, actionGetter, ProtoBufUtils.Serialize(m_ResponsePacket));
}
public static void ExecuteMatch(object state)
{
var queues = CacheSet.PVPMathcQueueCache.FindAll();
PlayerSinglePvpLogic psp = new PlayerSinglePvpLogic();
foreach (var queue in queues)
{
if (queue.InQueueGroups.Count <= 1)
{
continue;
}
if (queue.MatchedGroupCount > 0)
{
ClearMatchedGroups(queue);
}
var groups = new List <PVPGroup>();
groups.AddRange(queue.InQueueGroups);
groups.Sort();
for (int i = 0; i < groups.Count; i++)
{
if (i + 1 >= groups.Count)
{
break;
}
bool success = true;
LRCreateNewRoom userData = new LRCreateNewRoom();
foreach (int playerId in groups[i].Players)
{
if (!GameSession.Get(playerId).Connected)
{
queue.InQueueGroups.RemoveAt(i);
success = false;
break;
}
PBRoomPlayerInfo playerRoomData = GetPlayerRoomData(playerId);
userData.RoomPlayerInfo.Add(playerRoomData);
}
if (!success)
{
continue;
}
foreach (int playerId in groups[++i].Players)
{
if (!GameSession.Get(playerId).Connected)
{
queue.InQueueGroups.RemoveAt(i);
success = false;
break;
}
PBRoomPlayerInfo playerRoomData = GetPlayerRoomData(playerId);
userData.RoomPlayerInfo.Add(playerRoomData);
}
if (!success)
{
continue;
}
userData.Token = GetToken();
var room = RoomServerManager.GetLowestLoadedRoomServer();
TraceLog.Write("room" + room.Id.ToString() + "::" + room.IP);
RoomServerSender.Send(room.Id, "LRCreateNewRoomHandler", userData, delegate(RemotePackage callback)
{
var res = RemoteCommunication.ParseRemotePackage <RLCreateNewRoom>(callback.Message as byte[]);
LCPushPvpMatchSuccess package = new LCPushPvpMatchSuccess()
{
RoomId = res.RoomId, RoomServerHost = room.Host, RoomServerPort = room.Port, Token = userData.Token, InstanceId = res.InstanceId
};
var rank = RankingFactory.Get <SinglePvpRankUser>("SinglePvpRanking");
foreach (int playerId in groups[queue.MatchedGroupCount].Players)
{
foreach (var rp in userData.RoomPlayerInfo)
{
if (rp.PlayerInfo.Id != playerId)
{
package.EnemyInfo = rp;
}
}
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(package.PacketActionId, ProtoBufUtils.Serialize(package));
try
{
GameSession.Get(playerId).SendAsync(buffer, 0, buffer.Length);
}
catch
{
continue;
}
}
foreach (int playerId in groups[queue.MatchedGroupCount + 1].Players)
{
foreach (var rp in userData.RoomPlayerInfo)
{
if (rp.PlayerInfo.Id != playerId)
{
package.EnemyInfo = rp;
}
}
byte[] buffer = CustomActionDispatcher.GeneratePackageStream(package.PacketActionId, ProtoBufUtils.Serialize(package));
try
{
GameSession.Get(playerId).SendAsync(buffer, 0, buffer.Length);
}
catch
{
continue;
}
}
queue.MatchedGroupCount += 2;
});
}
ClearMatchedGroups(queue);
}
}
