public override bool TakeAction()
{
DTInstanceStory instanceData = CacheSet.InstanceStoryTable.GetData(m_RequestPacket.InstanceId);
PlayerHeroLogic ph = new PlayerHeroLogic();
ph.SetUser(m_UserId).SetHero(instanceData.HeroId);
if (ph.GetHeroInfo() == null)
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You can not enter this instance";
return(false);
}
PlayerStoryInstanceLogic ps = new PlayerStoryInstanceLogic();
ps.SetUser(m_UserId);
CacheDictionary <int, int> dropItems = new CacheDictionary <int, int>();
foreach (int dropId in instanceData.DropIds)
{
var itemDict = ps.GetDropItems(dropId, m_RequestPacket.StarLevel);
dropItems = GameUtils.MergeItemDict(dropItems, itemDict) as CacheDictionary <int, int>;
}
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
PBReceivedItems receivedItems;
pp.GetItems(dropItems, ReceiveItemMethodType.CompleteInstance, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
m_ResponsePacket.Count = ps.GetCount();
m_ResponsePacket.StarLevel = m_RequestPacket.StarLevel;
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);
}
private List <PBKeyValuePair> ProcessClaimReward(List <PBKeyValuePair> Params, out PBReceivedItems receivedItems, out PBPlayerInfo playerInfo, out List <PBLobbyHeroInfo> heroInfos)
{
receivedItems = null;
playerInfo = null;
heroInfos = null;
int dayCnt = CacheSet.OperationActivitySevenDayTable.Count;
if (DateTime.UtcNow.Date == new DateTime(m_SevenDayCheckIn.LastClaimedTime).Date || m_SevenDayCheckIn.ClaimedCount >= dayCnt)
{
return(null);
}
List <PBKeyValuePair> retval = new List <PBKeyValuePair>();
retval.AddRange(Params);
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_SevenDayCheckIn.UserId);
var reward = CacheSet.OperationActivitySevenDayTable.GetData(m_SevenDayCheckIn.ClaimedCount + 1);
pp.GetItems(new Dictionary <int, int>()
{
{ reward.RewardId, reward.RewardCount }
}, ReceiveItemMethodType.None, out receivedItems);
m_SevenDayCheckIn.ClaimedCount += 1;
m_SevenDayCheckIn.LastClaimedTime = DateTime.UtcNow.Ticks;
retval.Add(new PBKeyValuePair()
{
Key = "ClaimedCnt", Value = m_SevenDayCheckIn.ClaimedCount.ToString()
});
retval.Add(new PBKeyValuePair()
{
Key = "HasClaimed", Value = "true"
});
return(retval);
}
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 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()
{
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()
{
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);
}
public override bool TakeAction()
{
var pa = PlayerAchievementLogic.GetInstance(m_UserId);
TrackingAchievement nextAchievement;
PackageFullReason reason;
var RewardItems = pa.CompleteAchievement(m_RequestPacket.AchievementId, out nextAchievement);
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;
if (nextAchievement != null)
{
m_ResponsePacket.NextTrackingAchievement = new PBTrackingAchievement()
{
AchievementId = nextAchievement.Id,
ProgressCount = nextAchievement.Progress,
};
}
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.AchievementId = m_RequestPacket.AchievementId;
return(true);
}
public void GetReward(PlayerChessLogic playerChess)
{
playerChess.MyChess.GotCoin += m_GotCoin;
playerChess.MyChess.GotMoney += m_GotMoney;
playerChess.MyChess.GotStarEnergy += m_GotStarEnergy;
PlayerPackageLogic package = new PlayerPackageLogic();
package.SetUser(m_UserId);
PBReceivedItems receivedItems;
package.GetItems(m_GotItems, ReceiveItemMethodType.TurnOverChess, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
foreach (var gear in m_ResponsePacket.ReceivedItems.GearInfo)
{
playerChess.MyChess.GotGears.Add(gear.Id);
}
foreach (var inventory in m_ResponsePacket.ReceivedItems.ItemInfo)
{
if (playerChess.MyChess.GotItems.ContainsKey(inventory.Type))
{
playerChess.MyChess.GotItems[inventory.Type] += inventory.Count;
}
else
{
playerChess.MyChess.GotItems.Add(inventory.Type, inventory.Count);
}
}
foreach (var soul in m_ResponsePacket.ReceivedItems.SoulInfo)
{
playerChess.MyChess.GotSouls.Add(soul.Id);
}
foreach (var epigraph in m_ResponsePacket.ReceivedItems.EpigraphInfo)
{
playerChess.MyChess.GotEpigraphs.Add(epigraph.Type);
}
m_ResponsePacket.Success = true;
m_ResponsePacket.RewardCoins = m_GotCoin;
m_ResponsePacket.RewardMoney = m_GotMoney;
m_ResponsePacket.RewardStarEnergy = m_GotStarEnergy;
m_ResponsePacket.FieldId = m_RequestPacket.FieldId;
}
public override bool TakeAction()
{
PlayerInstanceLogic pi = new PlayerInstanceLogic();
pi.SetUser(m_UserId);
pi.LeaveInstance();
if (!m_RequestPacket.Win)
{
m_ResponsePacket.Win = false;
m_ResponsePacket.InstanceType = m_RequestPacket.InstanceType;
return(true);
}
PlayerCosmosCrackLogic pcc = new PlayerCosmosCrackLogic().SetUser(m_UserId);
m_ResponsePacket.RewardLevel = pcc.GetCosmosCrackInstanceInfo().ChosenInstance[m_RequestPacket.InstanceType].RewardLevel;
var rewards = pcc.LeaveInstance(m_RequestPacket.InstanceType);
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
PBReceivedItems receivedItems;
pp.GetItems(rewards, ReceiveItemMethodType.None, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
m_ResponsePacket.Win = true;
m_ResponsePacket.InstanceType = m_RequestPacket.InstanceType;
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = m_UserId,
Coin = p.MyPlayer.Coin,
Money = p.MyPlayer.Money,
Energy = p.MyPlayer.Energy,
Spirit = p.MyPlayer.Spirit,
MeridianEnergy = p.MyPlayer.StarEnergy,
DragonStripeToken = p.MyPlayer.DragonStripeToken
};
return(true);
}
public override bool TakeAction()
{
PlayerDefaultShopLogic pds = new PlayerDefaultShopLogic();
pds.SetUser(m_UserId);
if (!pds.PurchaseItem(m_RequestPacket.ShopItemIndex, m_RequestPacket.TypeId, m_RequestPacket.Count))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "Item info is not correct";
return(false);
}
Dictionary <int, int> itemDict = new Dictionary <int, int>();
itemDict.Add(m_RequestPacket.TypeId, m_RequestPacket.Count);
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
PBReceivedItems receivedItems;
pp.GetItems(itemDict, ReceiveItemMethodType.None, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
m_ResponsePacket.OpenedGoodInfo.Add(new PBItemInfo()
{
Type = m_RequestPacket.TypeId, Count = m_RequestPacket.Count
});
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = m_UserId,
Money = p.MyPlayer.Money,
Coin = p.MyPlayer.Coin,
Spirit = p.MyPlayer.Spirit
};
m_ResponsePacket.ShopItemIndex = m_RequestPacket.ShopItemIndex;
return(true);
}
public override bool TakeAction()
{
PlayerFoundryLogic pf = new PlayerFoundryLogic();
pf.SetUser(m_UserId);
int[] drops = GameConsts.Foundry.FoundryRewardDropPackageId[m_RequestPacket.Level];
RandomDropLogic random = RandomDropLogic.GetInstance();
CacheDictionary <int, int> dropDict = new CacheDictionary <int, int>();
foreach (int dropId in drops)
{
DTDrop dataRow = CacheSet.DropTable.GetData(dropId);
random.GetDropDict(dataRow, dropDict);
}
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
if (!pp.CheckPackageSlot(dropDict))
{
ErrorCode = (int)ErrorType.PackageSlotFull;
ErrorInfo = "package is full";
return(false);
}
if (!pf.GetReward(m_RequestPacket.Level))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You can not get this reward";
return(false);
}
PBReceivedItems receivedItems;
pp.GetItems(dropDict, ReceiveItemMethodType.GearFoundry, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
m_ResponsePacket.RewardFlags.AddRange(pf.MyFoundry.CanReceiveRewards);
return(true);
}
public override bool TakeAction()
{
InstanceProgressLogic ip = new InstanceProgressLogic();
ip.SetUser(m_UserId);
if (!(ip.GetInstanceProgress()).ContainsKey(m_RequestPacket.InstanceId))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You have not passed this instance";
return(false);
}
PlayerInstanceLogic pi = new PlayerInstanceLogic();
pi.SetUser(m_UserId);
CacheDictionary <int, int> dropItems = new CacheDictionary <int, int>();
for (int i = 0; i < m_RequestPacket.Count; i++)
{
PBInstanceDrop instanceDrop = new PBInstanceDrop();
List <PBDropInfo> dropList = new List <PBDropInfo>();
List <PBDropInfo> dropPack;
var dropDict = pi.GenerateDropList(m_RequestPacket.InstanceId, true, out dropPack);
GameUtils.MergeItemDict(dropItems, dropDict);
foreach (var dropItem in dropDict)
{
PBDropInfo item = new PBDropInfo()
{
DropId = dropItem.Key,
DropCount = dropItem.Value
};
instanceDrop.Items.Add(item);
}
m_ResponsePacket.Drops.Add(instanceDrop);
}
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
if (!pp.CheckPackageSlot(dropItems))
{
ErrorCode = (int)ErrorType.PackageSlotFull;
ErrorInfo = "Package full";
return(false);
}
PlayerLogic p = new PlayerLogic();
p.SetUser(m_UserId);
int energy = PlayerInstanceLogic.GetInstanceEnergy(m_RequestPacket.InstanceId);
long nextRecoverTime;
if (!p.DeductEnergy(energy * m_RequestPacket.Count, out nextRecoverTime))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "You have not enough energy";
return(false);
}
PBReceivedItems receivedItems;
pp.GetItems(dropItems, ReceiveItemMethodType.CompleteInstance, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
DTInstance instanceData = PlayerInstanceLogic.GetInstanceData(m_RequestPacket.InstanceId);
p.AddCoin(instanceData.Coin * m_RequestPacket.Count);
p.AddExp(instanceData.PlayerExp * m_RequestPacket.Count);
m_ResponsePacket.Count = m_RequestPacket.Count;
m_ResponsePacket.InstanceId = m_RequestPacket.InstanceId;
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = m_UserId,
Coin = p.MyPlayer.Coin,
Exp = p.MyPlayer.Exp,
Level = p.MyPlayer.Level,
Energy = p.MyPlayer.Energy,
NextEnergyRecoveryTime = nextRecoverTime
};
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
});
}
PlayerDailyQuestLogic.GetInstance(m_UserId).UpdateDailyQuest(DailyQuestType.CleanOutInstance, m_RequestPacket.Count);
return(true);
}
public override bool TakeAction()
{
PlayerMeridianLogic playerMeridian = new PlayerMeridianLogic();
playerMeridian.SetUser(m_UserId);
PlayerLogic player = new PlayerLogic();
player.SetUser(m_UserId);
DTMeridian starData = CacheSet.MeridianTable.GetData(m_RequestPacket.StarId);
if (starData == null)
{
ErrorCode = (int)ErrorType.CannotOpenChance;
ErrorInfo = "wrong star Id";
return(false);
}
if (!player.DeductStarEnergy(starData.CostMeridianEnergy))
{
if (!player.DeductMoney(starData.CostMoney))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "have not enough energy or money";
return(false);
}
}
if (!playerMeridian.OpenStar(m_RequestPacket.StarId, starData.Type))
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "you can not open this Star yet";
return(false);
}
player.AddCoin(starData.RewardCoin);
player.AddMoney(starData.RewardMoney);
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Id = m_UserId, Coin = player.MyPlayer.Coin, Money = player.MyPlayer.Money, MeridianEnergy = player.MyPlayer.StarEnergy
};
Dictionary <int, int> dropItem = new Dictionary <int, int>();
dropItem.Add(starData.RewardId, starData.RewardCount);
PlayerPackageLogic playerPackage = new PlayerPackageLogic();
playerPackage.SetUser(m_UserId);
PBReceivedItems receivedItems;
playerPackage.GetItems(dropItem, ReceiveItemMethodType.None, out receivedItems);
foreach (var gear in receivedItems.GearInfo)
{
m_ResponsePacket.GearInfo.Add(gear);
}
foreach (var inventory in receivedItems.ItemInfo)
{
m_ResponsePacket.ItemInfo.Add(inventory);
}
foreach (var meridian in playerMeridian.MyMeridian.UnlockedMeridians)
{
PBMeridianInfo meridianInfo = new PBMeridianInfo()
{
Id = meridian.Key
};
meridianInfo.UnlockedStars.AddRange(meridian.Value.UnlockedStars);
m_ResponsePacket.MeridianInfo.Add(meridianInfo);
}
return(true);
}
public override bool TakeAction()
{
PlayerChessLogic chess = new PlayerChessLogic();
chess.SetUser(m_UserId);
int coin;
int money;
int starEnergy;
Dictionary <int, int> rewardItems = chess.BombAll(out coin, out money, out starEnergy);
if (rewardItems == null)
{
ErrorCode = (int)ErrorType.RequireNotMet;
ErrorInfo = "Money not enough";
return(false);
}
chess.MyChess.GotCoin += coin;
m_ResponsePacket.RewardCoins = coin;
chess.MyChess.GotMoney += money;
m_ResponsePacket.RewardMoney = money;
chess.MyChess.GotStarEnergy += starEnergy;
m_ResponsePacket.RewardStarEnergy = starEnergy;
PlayerPackageLogic package = new PlayerPackageLogic();
package.SetUser(m_UserId);
PBReceivedItems receivedItems;
package.GetItems(rewardItems, ReceiveItemMethodType.TurnOverChess, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
foreach (var gear in m_ResponsePacket.ReceivedItems.GearInfo)
{
chess.MyChess.GotGears.Add(gear.Id);
}
foreach (var inventory in m_ResponsePacket.ReceivedItems.ItemInfo)
{
if (chess.MyChess.GotItems.ContainsKey(inventory.Type))
{
chess.MyChess.GotItems[inventory.Type] += inventory.Count;
}
else
{
chess.MyChess.GotItems.Add(inventory.Type, inventory.Count);
}
}
foreach (var soul in m_ResponsePacket.ReceivedItems.SoulInfo)
{
chess.MyChess.GotSouls.Add(soul.Id);
}
foreach (var epigraph in m_ResponsePacket.ReceivedItems.EpigraphInfo)
{
chess.MyChess.GotEpigraphs.Add(epigraph.Type);
}
m_ResponsePacket.Success = true;
PlayerLogic player = new PlayerLogic();
player.SetUser(m_UserId);
player.MyPlayer.Coin += coin;
player.MyPlayer.Money += money;
m_ResponsePacket.PlayerInfo = new PBPlayerInfo()
{
Coin = player.MyPlayer.Coin, Money = player.MyPlayer.Money
};
return(true);
}
private void GetReward(DropItem item)
{
PlayerPackageLogic pp = new PlayerPackageLogic();
pp.SetUser(m_UserId);
var type = m_RequestPacket.ChanceType == (int)ChanceType.Money ? ReceiveItemMethodType.MoneyChance : ReceiveItemMethodType.CoinChance;
if (PlayerPackageLogic.IsItem(item.ItemId))
{
m_ResponsePacket.ReceivedItems = new PBReceivedItems();
var itemData = CacheSet.ItemTable.GetData(item.ItemId);
if (itemData.FunctionId == (int)ItemFunctions.AddHero)
{
PlayerHeroLogic ph = new PlayerHeroLogic();
ph.SetUser(m_UserId);
int heroId = int.Parse(itemData.FunctionParams);
ItemListItem piece = ph.AddNewHero(heroId, type);
if (piece == null)
{
Hero newHero = ph.MyHeros.Heros[heroId];
m_ResponsePacket.LobbyHeroInfo = new PBLobbyHeroInfo()
{
Type = newHero.HeroType,
Level = newHero.HeroLv,
Exp = newHero.HeroExp,
ElevationLevel = newHero.ElevationLevel,
ConsciousnessLevel = newHero.ConsciousnessLevel,
StarLevel = newHero.HeroStarLevel
};
}
else
{
pp.AddInventory(piece);
m_ResponsePacket.ReceivedItems.ItemInfo.Add(new PBItemInfo()
{
Type = piece.Id,
Count = pp.MyPackage.Inventories[piece.Id]
});
}
}
else
{
pp.AddInventory(new ItemListItem()
{
Id = item.ItemId, Count = item.ItemCount
});
m_ResponsePacket.ReceivedItems.ItemInfo.Add(new PBItemInfo()
{
Type = item.ItemId,
Count = pp.MyPackage.Inventories[item.ItemId]
});
}
}
else
{
Dictionary <int, int> itemDict = new Dictionary <int, int>();
itemDict.Add(item.ItemId, item.ItemCount);
PBReceivedItems receivedItems;
pp.GetItems(itemDict, type, out receivedItems);
m_ResponsePacket.ReceivedItems = receivedItems;
}
}