private void SetPlayerInfo()
{
long nextRecoverTime;
PBPlayerInfo playerInfo = new PBPlayerInfo();
playerInfo.Id = m_UserId;
PlayerLogic player = new PlayerLogic();
player.SetUser(m_UserId);
playerInfo.IsFemale = player.MyPlayer.IsFemale;
playerInfo.Level = player.MyPlayer.Level;
playerInfo.Money = player.MyPlayer.Money;
playerInfo.Name = player.MyPlayer.Name;
playerInfo.PortraitType = player.MyPlayer.PortraitType;
playerInfo.Exp = player.MyPlayer.Exp;
playerInfo.Energy = player.GetNewEnergy(out nextRecoverTime);
playerInfo.NextEnergyRecoveryTime = nextRecoverTime;
playerInfo.Coin = player.MyPlayer.Coin;
playerInfo.MeridianEnergy = player.MyPlayer.StarEnergy;
playerInfo.ArenaToken = player.MyPlayer.ArenaToken;
playerInfo.Spirit = player.MyPlayer.Spirit;
playerInfo.DisplayId = player.MyPlayer.UUID;
playerInfo.PvpToken = player.MyPlayer.PvpToken;
NearbyPlayerLogic np = new NearbyPlayerLogic();
np.SetUser(m_UserId);
playerInfo.PositionX = np.NearbyPlayers.MyPositionX;
playerInfo.PositionY = np.NearbyPlayers.MyPositionY;
m_ResponsePacket.PlayerInfo = playerInfo;
}
public override bool TakeAction()
{
m_ResponsePacket.ChanceType = m_RequestPacket.ChanceType;
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
PlayerChanceLogic pc = new PlayerChanceLogic();
pc.SetUserAndType(m_UserId, m_RequestPacket.ChanceType);
if (!pc.ResetRewards(false))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You have not enough money";
return(false);
}
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = m_UserId,
Coin = p.MyPlayer.Coin,
Money = p.MyPlayer.Money
};
foreach (var item in pc.MyChance.UnopenedChanceRewards)
{
m_ResponsePacket.GoodInfo.Add(new PBItemInfo()
{
Type = item.Value.ItemId,
Count = item.Value.ItemCount
});
}
m_ResponsePacket.FreeChanceTimes = pc.MyChance.TotalFreeCount;
return(true);
}
public override bool TakeAction()
{
PlayerEpigraphLogic pe = new PlayerEpigraphLogic();
pe.SetUser(m_UserId);
int curLevel = pe.GetLevel();
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
if (p.MyPlayer.Level < GameConfigs.GetInt("Epigraph_Required_Level_" + curLevel))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "your level is not reached require";
return(false);
}
pe.UnlockSlot();
foreach (var epigraph in pe.GetEpigraphs())
{
PBEpigraphInfo epInfo = new PBEpigraphInfo();
epInfo.Type = epigraph.Type;
epInfo.Level = epigraph.Level;
m_ResponsePacket.Epigraphs.Add(epInfo);
}
return(true);
}
public static void InitRankList()
{
if (CacheSet.ArenaRankCache.FindAll().Count == 0)
{
PlayerLogic player = new PlayerLogic();
HeroTeamLogic ht = new HeroTeamLogic();
for (int i = 0; i < GameConsts.Arena.RobotCount; i++)
{
player.AddRobot();
PlayerHeroLogic ph = new PlayerHeroLogic();
ph.SetUser(player.MyPlayer.Id);
ht.SetUser(player.MyPlayer.Id);
var heros = new int[] { 1, 2, 5 };//GameUtils.RandomChoose(1, 4, GameConsts.Hero.MaxHeroTeamCount);
foreach (int heroId in heros)
{
ph.AddNewHero(heroId);
ph.MyHeros.Heros[heroId].HeroLv = player.MyPlayer.Level;
}
List <int> heroTeam = new List <int>();
heroTeam.AddRange(heros);
ht.AssignHero(heroTeam);
AddNewPlayer(player.MyPlayer.Id);
PlayerArena pa = new PlayerArena();
pa.UserId = player.MyPlayer.Id;
pa.EnemyId = 0;
CacheSet.PlayerArenaCache.Add(pa);
}
}
}
public override bool TakeAction()
{
PlayerArenaLogic pa = new PlayerArenaLogic();
ArenaRankLogic ar = new ArenaRankLogic();
pa.SetUser(m_UserId);
m_ResponsePacket.ArenaTokenCount = pa.MyArena.ArenaTokenCount;
m_ResponsePacket.ChallengeCount = pa.MyArena.ChallengeCount;
m_ResponsePacket.ClaimedFlags.AddRange(pa.MyArena.ClaimedLivenessRewardFlag);
m_ResponsePacket.MyRank = ar.GetPlayerRank(m_UserId);
m_ResponsePacket.WinCount = pa.MyArena.WinCount;
var matchPlayers = ar.GetMatchPlayers(m_UserId);
PlayerLogic p = new PlayerLogic();
foreach (var player in matchPlayers)
{
PBArenaPlayerAndTeamInfo enemy = new PBArenaPlayerAndTeamInfo();
enemy.Rank = player.RankId;
p.SetUser(player.PlayerId);
enemy.PlayerInfo = new PBPlayerInfo()
{
Id = player.PlayerId,
Name = p.MyPlayer.Name,
Level = p.MyPlayer.Level,
PortraitType = p.MyPlayer.PortraitType
};
m_ResponsePacket.Enemies.Add(enemy);
}
return(true);
}
public override bool TakeAction()
{
var pdq = PlayerDailyQuestLogic.GetInstance(m_UserId);
var RewardItems = pdq.CompleteDailyQuest(m_RequestPacket.QuestId);
if (RewardItems == null)
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You can not claim this achievement";
return(false);
}
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
PBReceivedItems receivedItems;
pp.GetItems(RewardItems, ReceiveItemMethodType.None, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = p.MyPlayer.Id,
Exp = p.MyPlayer.Exp,
Level = p.MyPlayer.Level,
Coin = p.MyPlayer.Coin,
Money = p.MyPlayer.Money,
Spirit = p.MyPlayer.Spirit
};
m_ResponsePacket.QuestId = m_RequestPacket.QuestId;
return(true);
}
public override bool TakeAction()
{
PlayerArenaLogic pa = new PlayerArenaLogic();
pa.SetUser(m_UserId);
ArenaRankLogic ar = new ArenaRankLogic();
PlayerLogic p = new PlayerLogic();
foreach (var report in pa.MyArena.BattleReports)
{
p.SetUser(report.EnemyId);
PBArenaBattleReport pbreport = new PBArenaBattleReport()
{
BattleEndTime = report.BattleTime,
Win = report.IsWin,
IsActive = report.IsActive
};
pbreport.Enemy = new PBArenaPlayerAndTeamInfo()
{
Rank = ar.GetPlayerRank(report.EnemyId)
};
pbreport.Enemy.PlayerInfo = new PBPlayerInfo()
{
Id = report.EnemyId,
Name = p.MyPlayer.Name,
PortraitType = p.MyPlayer.PortraitType,
Level = p.MyPlayer.Level
};
m_ResponsePacket.Reports.Add(pbreport);
}
return(true);
}
public bool AssignHero(List <int> heroTeam)
{
if (heroTeam.Count > 3 || heroTeam.Count == 0)
{
return(false);
}
PlayerHeroLogic ph = new PlayerHeroLogic();
ph.SetUser(m_UserId);
foreach (int heroId in heroTeam)
{
if (!ph.SetHero(heroId).DataCheck())
{
return(false);
}
}
for (int i = 0; i < GameConsts.Hero.MaxHeroTeamCount; i++)
{
if (i + 1 > heroTeam.Count)
{
m_Team.Team[i] = 0;
}
else
{
m_Team.Team[i] = heroTeam[i];
}
}
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
p.RefreshMight();
return(true);
}
public List <Player> GetOnlinePlayers()
{
var onlinePlayers = GameSession.GetOnlineAll();
PlayerLogic p = new PlayerLogic();
List <Player> result = new List <Player>();
int i = 0;
foreach (var player in onlinePlayers)
{
if (player.UserId == m_UserId)
{
continue;
}
p.SetUser(player.UserId);
if (p.MyPlayer != null)
{
result.Add(p.MyPlayer);
}
if (++i >= GameConsts.Social.MaxOnlineCount)
{
break;
}
}
return(result);
}
public override bool TakeAction()
{
PlayerFriendsLogic pf = new PlayerFriendsLogic();
pf.SetUser(m_UserId);
PlayerLogic p = new PlayerLogic();
foreach (var player in pf.GetFriends())
{
p.SetUser(player.Key);
m_ResponsePacket.Players.Add(new PBPlayerInfo()
{
Id = player.Key,
Name = p.MyPlayer.Name,
Level = p.MyPlayer.Level,
VipLevel = p.MyPlayer.VIPLevel,
LastLoginInTicks = p.MyPlayer.LastLoginTime,
IsOnline = p.MyPlayer.Status == PlayerStatus.Online
});
m_ResponsePacket.CanGiveEnergy.Add(player.Value.CanSendEnergy);
m_ResponsePacket.CanReceiveEnergy.Add(player.Value.CanReceiveEnergy);
}
return(true);
}
public void AddExp(int exp)
{
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
AddExp(exp, p.MyPlayer.Level);
}
public override bool TakeAction()
{
PlayerFriendsLogic pf = new PlayerFriendsLogic();
pf.SetUser(m_UserId);
if (!pf.ReceiveEnergy(m_RequestPacket.FriendPlayerId))
{
ErrorCode = (int)ErrorType.CannotOpenChance;
ErrorInfo = "you can not receive energy from this player";
return(false);
}
m_ResponsePacket.FriendPlayerId = m_RequestPacket.FriendPlayerId;
PlayerLogic player = new PlayerLogic();
player.SetUser(m_UserId);
long nextRecoverTime;
player.AddEnergy(1, out nextRecoverTime);
m_ResponsePacket.Me = new PBPlayerInfo()
{
Id = player.MyPlayer.Id,
Energy = player.MyPlayer.Energy,
NextEnergyRecoveryTime = nextRecoverTime
};
m_ResponsePacket.RemainCount = GameConsts.Social.MaxReceiveCount - pf.MyFriends.ReceiveCount;
return(true);
}
public override bool TakeAction()
{
PlayerInstanceLogic pi = new PlayerInstanceLogic();
pi.SetUser(m_UserId);
var dropDict = pi.OpenInInstanceChest(m_RequestPacket.ChestIndex);
foreach (var goods in dropDict)
{
m_ResponsePacket.GoodsInfo.Add(new PBItemInfo()
{
Type = goods.Key,
Count = goods.Value
});
}
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
PBReceivedItems receivedItems;
pp.GetItems(dropDict, ReceiveItemMethodType.CompleteInstance, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = p.MyPlayer.Id,
Coin = p.MyPlayer.Coin,
Money = p.MyPlayer.Money,
Spirit = p.MyPlayer.Spirit,
MeridianEnergy = p.MyPlayer.StarEnergy
};
return(true);
}
public override bool TakeAction()
{
PlayerArenaLogic pa = new PlayerArenaLogic();
pa.SetUser(m_UserId);
Dictionary <int, int> itemDict;
int rewardMoney;
if (!pa.GetLivenessReward(m_RequestPacket.RewardIndex, out itemDict, out rewardMoney))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "you can not get this reward";
return(false);
}
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
p.AddMoney(rewardMoney);
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
PBReceivedItems receivedItems;
pp.GetItems(itemDict, ReceiveItemMethodType.None, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
m_ResponsePacket.RewardId = m_RequestPacket.RewardIndex;
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = p.MyPlayer.Id,
Money = p.MyPlayer.Money
};
return(true);
}
private void InitPlayerLevelAchievementProgress(TrackingAchievement achievement)
{
PlayerLogic player = new PlayerLogic();
player.SetUser(m_UserId);
achievement.Progress = player.MyPlayer.Level;
}
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 override bool TakeAction()
{
var rank = RankingFactory.Get <SinglePvpRankUser>("SinglePvpRanking");
var players = rank.GetRange(0, 100);
PlayerLogic p = new PlayerLogic();
foreach (var player in players)
{
p.SetUser(player.UserId);
m_ResponsePacket.PlayerInfo.Add(new PBPlayerInfo()
{
Id = player.UserId,
Name = p.MyPlayer.Name,
Level = p.MyPlayer.Level,
Might = p.MyPlayer.Might,
PortraitType = p.MyPlayer.PortraitType,
});
m_ResponsePacket.Score.Add(player.Score);
}
var Me = rank.Find(r => r.UserId == m_UserId);
if (Me == null)
{
m_ResponsePacket.MyRank = -1;
m_ResponsePacket.MyScore = 0;
}
else
{
m_ResponsePacket.MyRank = Me.RankId;
m_ResponsePacket.MyScore = Me.Score;
}
return(true);
}
public bool ResetDailyQuestInfo()
{
if (!GameUtils.NeedRefresh(m_DailyQuestInfo.LastRefreshTime, GameConsts.DailyQuest.RefreshTime))
{
return(false);
}
PlayerLogic player = new PlayerLogic();
player.SetUser(m_UserId);
var initialDailyQuests = CacheSet.DailyQuestTable.GetAllData(dq => dq.PrePlayerLevel <= player.MyPlayer.Level);
m_DailyQuestInfo.TrackingDailyQuests.Clear();
m_DailyQuestInfo.CompletedDailyQuests.Clear();
foreach (var quest in initialDailyQuests)
{
TrackingDailyQuest tdq = new TrackingDailyQuest()
{
Id = quest.Id,
Type = quest.QuestType,
Progress = 0,
RequiredProgress = quest.TargetProgressCount,
};
tdq.Params.AddRange(quest.Params);
m_DailyQuestInfo.TrackingDailyQuests.Add(quest.Id, tdq);
}
m_DailyQuestInfo.LastRefreshTime = DateTime.UtcNow.Ticks;
return(true);
}
public override bool TakeAction()
{
PlayerCosmosCrackLogic pcc = new PlayerCosmosCrackLogic().SetUser(m_UserId);
if (!pcc.EnterInstance(m_RequestPacket.InstanceType))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You have not enough RoundCount";
return(false);
}
m_ResponsePacket.InstanceType = m_RequestPacket.InstanceType;
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
m_ResponsePacket.NpcLevel = Math.Max(p.MyPlayer.Level + pcc.GetNPCAndPlayerDeltaLevel(m_RequestPacket.InstanceType), 1);
PlayerInstanceLogic pi = new PlayerInstanceLogic();
pi.SetUser(m_UserId);
var dropInfo = pi.EnterInstance(m_RequestPacket.InstanceType);
if (dropInfo == null)
{
ErrorCode = (int)ErrorType.PackageSlotFull;
ErrorInfo = "Package slot full";
return(false);
}
return(true);
}
public override bool TakeAction()
{
int deductEnergy = PlayerInstanceLogic.GetInstanceEnergy(m_RequestPacket.InstanceType);
PlayerInstanceLogic playerInstance = new PlayerInstanceLogic();
playerInstance.SetUser(m_UserId);
InstanceProgressLogic instanceProgress = new InstanceProgressLogic();
instanceProgress.SetUser(m_UserId);
PlayerLogic player = new PlayerLogic();
player.SetUser(m_UserId);
long nextRecoverTime;
if (playerInstance.MyInstance != null)
{
playerInstance.LeaveInstance();
}
if (!player.DeductEnergy(deductEnergy, out nextRecoverTime))
{
ErrorCode = (int)ErrorType.EnergyNotEnough;
ErrorInfo = "Energy not Enough";
return(false);
}
var instanceData = CacheSet.InstanceTable.GetData(m_RequestPacket.InstanceType);
if (GameConfigs.GetInt("Need_Check_Instance_Prerequisite", 1) > 0 && (instanceData.PrerequisitePlayerLevel > player.MyPlayer.Level || (instanceData.PrerequisiteInstanceId > 0 && !instanceProgress.IsInstanceCompleted(instanceData.PrerequisiteInstanceId))))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "Pre-instance is not completed";
return(false);
}
m_ResponsePacket.InstanceType = m_RequestPacket.InstanceType;
PBPlayerInfo playerInfo = new PBPlayerInfo();
playerInfo.Id = player.MyPlayer.Id;
playerInfo.Energy = player.MyPlayer.Energy;
playerInfo.NextEnergyRecoveryTime = nextRecoverTime;
m_ResponsePacket.PlayerInfo = playerInfo;
var dropInfo = playerInstance.EnterInstance(m_RequestPacket.InstanceType);
if (dropInfo == null)
{
ErrorCode = (int)ErrorType.PackageSlotFull;
ErrorInfo = "Package slot full";
return(false);
}
m_ResponsePacket.DropInfo.AddRange(dropInfo);
foreach (var item in playerInstance.MyInstance.DropList)
{
m_ResponsePacket.ItemInfo.Add(new PBItemInfo()
{
Type = item.Key,
Count = item.Value
});
}
return(true);
}
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);
}
private void ProcessEffect2(int count, string funcParams)
{
int totalAddEnergy = count * int.Parse(funcParams);
PlayerLogic player = new PlayerLogic().SetUser(1);
long nextRecoverTime;
player.AddEnergy(totalAddEnergy, out nextRecoverTime);
}
public override bool TakeAction()
{
// TODO: Add code here.
GearLogic gearlogic = new GearLogic();
gearlogic.SetGear(m_RequestPacket.GearId);
PlayerLogic player = new PlayerLogic();
player.SetUser(m_UserId);
if (gearlogic.MyGear.Level >= player.MyPlayer.Level)
{
ErrorCode = (int)ErrorType.CannotOpenChance;
ErrorInfo = "Can not upgrade,gear reached max level.";
return(false);
}
int targetLevel;
if (m_RequestPacket.IsUpToMax)
{
targetLevel = player.MyPlayer.Level;
}
else
{
targetLevel = gearlogic.MyGear.Level + 1;
}
int totalcost = gearlogic.GetLevelUpCost(targetLevel);
if (!player.DeductCoin(totalcost))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "Can not upgrade, coin not enough.";
return(false);
}
gearlogic.GearLevelUp(targetLevel, m_UserId);
if (m_RequestPacket.HeroType > 0)
{
PlayerHeroLogic ph = new PlayerHeroLogic();
ph.SetUser(m_UserId).SetHero(m_RequestPacket.HeroType);
ph.RefreshMight();
var heroInfo = ph.GetHeroInfo();
m_ResponsePacket.HeroInfo = new PBLobbyHeroInfo()
{
Type = heroInfo.HeroType,
Might = heroInfo.Might
};
}
m_ResponsePacket.LevelUpedGear = new PBGearInfo()
{
Id = m_RequestPacket.GearId,
Level = gearlogic.MyGear.Level
};
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = m_UserId,
Coin = player.MyPlayer.Coin
};
return(true);
}
private void GetInstanceReward(PlayerInstanceLogic instance)
{
int instanceId = instance.MyInstance.InstanceId;
PlayerLogic player = new PlayerLogic();
player.SetUser(m_UserId);
long nextRecoverTime;
if (!m_RequestPacket.Win)
{
int feedbackEnergy = PlayerInstanceLogic.GetFeedBackEnergy(instanceId);
player.AddEnergy(feedbackEnergy, out nextRecoverTime);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo();
m_ResponsePacket.PlayerInfo.Energy = player.MyPlayer.Energy;
m_ResponsePacket.PlayerInfo.NextEnergyRecoveryTime = nextRecoverTime;
return;
}
DTInstance instanceData = PlayerInstanceLogic.GetInstanceData(instanceId);
player.MyPlayer.Coin += instanceData.Coin;
player.AddExp(instanceData.PlayerExp);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo();
m_ResponsePacket.PlayerInfo.Id = player.MyPlayer.Id;
m_ResponsePacket.PlayerInfo.Coin = player.MyPlayer.Coin;
m_ResponsePacket.PlayerInfo.Exp = player.MyPlayer.Exp;
m_ResponsePacket.PlayerInfo.Level = player.MyPlayer.Level;
HeroTeamLogic heroTeam = new HeroTeamLogic();
heroTeam.SetUser(m_UserId);
PlayerHeroLogic playerHero = new PlayerHeroLogic();
playerHero.SetUser(m_UserId);
foreach (int heroId in heroTeam.MyHeroTeam.Team)
{
if (heroId == 0)
{
continue;
}
playerHero.SetHero(heroId).AddExp(instanceData.HeroExp);
m_ResponsePacket.LobbyHeroInfo.Add(new PBLobbyHeroInfo()
{
Type = heroId,
Exp = playerHero.MyHeros.Heros[heroId].HeroExp,
Level = playerHero.MyHeros.Heros[heroId].HeroLv,
Might = playerHero.MyHeros.Heros[heroId].Might,
});
}
m_ResponsePacket.InstanceType = instance.MyInstance.InstanceId;
CacheDictionary <int, int> dropDict = instance.GetDropList();
PlayerPackageLogic package = new PlayerPackageLogic();
package.SetUser(m_UserId);
PBReceivedItems receivedItems;
package.GetItems(dropDict, ReceiveItemMethodType.CompleteInstance, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
}
public override bool TakeAction()
{
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
Player sender = p.MyPlayer;
string message;
if (!ChatProvider.ProcessMessage(m_UserId, m_RequestPacket.Massage, out message))
{
ErrorCode = (int)ErrorType.CannotOpenChance;
ErrorInfo = "illegal message";
return(false);
}
switch ((ChatType)m_RequestPacket.Type)
{
case ChatType.World:
if (!ChatProvider.SendWorld(sender, message))
{
ErrorCode = (int)ErrorType.ChatTooFrequency;
ErrorInfo = "You can not chat too frequency";
}
break;
case ChatType.Private:
Player receiver = PlayerLogic.FindUserByName(m_RequestPacket.ReceiverName);
if (receiver == null)
{
ErrorCode = (int)ErrorType.PlayerNotExist;
ErrorInfo = "Target Player is not Exist";
return(false);
}
if (!ChatProvider.SendPrivate(receiver.Id, sender, message))
{
ErrorCode = (int)ErrorType.PlayerNotOnline;
ErrorInfo = "Target Player is not online";
return(false);
}
break;
case ChatType.Room:
break;
case ChatType.Alliance:
break;
default:
ErrorCode = (int)ErrorType.CannotOpenChance;
ErrorInfo = "wrong type Id";
return(false);
}
m_ResponsePacket.Type = m_RequestPacket.Type;
m_ResponsePacket.Success = true;
return(true);
}
public override bool TakeAction()
{
PlayerMailLogic pm = new PlayerMailLogic();
pm.SetUser(m_UserId);
Dictionary <int, int> itemReward = new Dictionary <int, int>();
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
m_ResponsePacket.AllSuccessful = true;
foreach (int id in m_RequestPacket.OpenEmailIds)
{
var reward = pm.OpenMail(id);
if (reward == null)
{
m_ResponsePacket.AllSuccessful = false;
continue;
}
else
{
m_ResponsePacket.OpenedEmailIds.Add(id);
}
if (reward.Id < GameConsts.MinGearId)
{
GetPlayerReward(reward, p);
}
else
{
if (itemReward.ContainsKey(reward.Id))
{
itemReward[reward.Id] += reward.Count;
}
else
{
itemReward.Add(reward.Id, reward.Count);
}
}
}
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
PBReceivedItems receivedItems;
pp.GetItems(itemReward, ReceiveItemMethodType.None, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = m_UserId,
Coin = p.MyPlayer.Coin,
Money = p.MyPlayer.Money,
Energy = p.MyPlayer.Energy,
MeridianEnergy = p.MyPlayer.StarEnergy
};
return(true);
}
public override bool TakeAction()
{
var allActivities = CacheSet.ActivityTable.GetAllData();
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
foreach (var activity in allActivities)
{
PBActivityInfo activityInfo = new PBActivityInfo();
activityInfo.Id = activity.Id;
activityInfo.Status = LobbyServerUtils.GetActivityStatus(activity, p.MyPlayer.Level);
if (activityInfo.Status == (int)ActivityStatusType.Hidden)
{
continue;
}
switch ((ActivityType)activity.Id)
{
case ActivityType.TurnOverChess:
PlayerChessLogic pc = new PlayerChessLogic();
pc.SetUser(m_UserId);
activityInfo.Progress = pc.MyChess.Count == 0 ? 0 : 1;
activityInfo.CountLimit = 1;
break;
case ActivityType.OfflineArena:
PlayerArenaLogic pa = new PlayerArenaLogic();
pa.SetUser(m_UserId);
activityInfo.Progress = pa.MyArena.ChallengeCount;
activityInfo.CountLimit = GameConsts.Arena.DailyChallengeCount;
break;
case ActivityType.GearFoundry:
PlayerFoundryLogic pf = new PlayerFoundryLogic();
pf.SetUser(m_UserId);
activityInfo.Progress = pf.GetProgress();
activityInfo.CountLimit = 1;
break;
case ActivityType.CosmosCrack:
PlayerCosmosCrackLogic pcc = new PlayerCosmosCrackLogic();
pcc.SetUser(m_UserId);
var cosmosInfo = pcc.GetCosmosCrackInstanceInfo();
activityInfo.Progress = cosmosInfo == null ? 0 : cosmosInfo.PassedRoundCount;
activityInfo.CountLimit = cosmosInfo == null ? 0 : GameConfigs.GetInt("Cosmos_Crack_Round_Limit", 10);
break;
default:
ErrorCode = (int)ErrorType.CannotOpenChance;
ErrorInfo = "invalid activity type";
return(false);
}
m_ResponsePacket.ActivityInfo.Add(activityInfo);
}
return(true);
}
public override bool TakeAction()
{
PlayerChanceLogic pc = new PlayerChanceLogic();
pc.SetUserAndType(m_UserId, m_RequestPacket.ChanceType);
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
Dictionary <int, int> dropDict = new Dictionary <int, int>();
if (!pp.CheckPackageSlot(dropDict))
{
ErrorCode = (int)ErrorType.PackageSlotFull;
ErrorInfo = "package is full";
return(false);
}
var items = pc.OpenAllChance();
if (items == null)
{
ErrorCode = (int)ErrorType.CannotOpenChance;
ErrorInfo = "you can not open this";
return(false);
}
m_ResponsePacket.ChanceType = m_RequestPacket.ChanceType;
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = p.MyPlayer.Id,
Coin = p.MyPlayer.Coin,
Money = p.MyPlayer.Money,
};
foreach (var iteminfo in items)
{
m_ResponsePacket.OpenedIndex.Add(iteminfo.Key);
m_ResponsePacket.OpenedGoodInfo.Add(new PBItemInfo()
{
Type = iteminfo.Value.ItemId,
Count = iteminfo.Value.ItemCount
});
GetItems(iteminfo.Value);
}
ReceiveItemMethodType type = m_RequestPacket.ChanceType == (int)ChanceType.Money ? ReceiveItemMethodType.CoinChance : ReceiveItemMethodType.MoneyChance;
PBReceivedItems receivedItems;
pp.GetItems(m_DropItems, type, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
return(true);
}
private void AddSpirit(int spirit)
{
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
p.AddSpirit(spirit);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = p.MyPlayer.Id,
Spirit = p.MyPlayer.Spirit
};
}
private void AddPvpToken(int token)
{
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
p.AddPvpToken(token);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = p.MyPlayer.Id,
PvpToken = p.MyPlayer.ArenaToken
};
}
