public bool IsAddLimited(OnlineGuildMember member, string itemclass, int slotNo, int amount, int targetTab)
{
if (member.GuildMember.Rank > GuildMemberRank.Member)
{
member.SendOperationFailedDialog("GuildStorageFail_RankLimited");
return(true);
}
if (itemclass == "gold")
{
int num = FeatureMatrix.GetInteger("GuildStorageGoldHoldingLimit");
if (num == 0)
{
num = int.MaxValue;
}
if (this.GoldHolding > num - amount)
{
member.SendOperationFailedDialog("GuildStorageFail_GoldAddLimit");
return(true);
}
return(false);
}
else
{
int num2 = (int)(this.AccessLimitTag >> targetTab * this.GuildStorageSettingFlagBitsPerTab & (long)this.GuildStorageSettingMask);
if (num2 != 0 && member.GuildMember.Rank > (GuildMemberRank)num2)
{
member.SendOperationFailedDialog("GuildStorageFail_RankLimited");
return(true);
}
return(false);
}
}
public NotifyRandomItem()
{
this.IsTelepathyEnable = true;
this.IsUIEnable = true;
this.IsTownOnly = FeatureMatrix.IsEnable("RandomItemBroadcastMode");
this.AnnounceLevel = FeatureMatrix.GetInteger("RandomItem_AnnounceLevel");
}
public static GroupNameCheckResult _CheckGroupName(string name)
{
Regex regex = new Regex(FeatureMatrix.GetString("GuildNamingRule"), RegexOptions.Compiled);
Regex regex2 = new Regex("^[a-zA-Z0-9_]*$", RegexOptions.Compiled);
bool flag = regex2.IsMatch(name);
if ((flag && name.Length > FeatureMatrix.GetInteger("GuildNamingRuleMaxBytes")) || (!flag && name.Length > FeatureMatrix.GetInteger("GuildNamingRuleMaxBytes") / 2))
{
return(GroupNameCheckResult.NotMatchedNamingRuleMaxBytes);
}
if (!regex.IsMatch(name))
{
return(GroupNameCheckResult.NotMatchedNamingRule);
}
int integer = FeatureMatrix.GetInteger("NamingRuleRepeatingCharCheckCount");
if (integer > 0)
{
string text = string.Empty;
foreach (char c in name)
{
if (!string.IsNullOrEmpty(text) && text[text.Length - 1] != c)
{
text = string.Empty;
}
text += c;
if (text.Length > integer)
{
return(GroupNameCheckResult.RepeatedCharacters);
}
}
}
return(GroupNameCheckResult.Succeed);
}
public DSEntityMakerSystem(DSService parent)
{
this.NormalRaidResorcePoint = FeatureMatrix.GetInteger("DSNormalRaidResorcePoint");
this.GaiantRaidResorcePoint = FeatureMatrix.GetInteger("DSGiantRaidResorcePoint");
this.PvpResorcePoint = FeatureMatrix.GetInteger("DSPvpResorcePoint");
this.DSServiceInfoDic = new Dictionary <int, DSServiceInfo>();
this.DSEntityMakerList = new LinkedList <DSEntityMakerQueue>();
this.Parent = parent;
this.startID = 0;
DSServiceInfo.SetDSResorcePoint(this.NormalRaidResorcePoint, this.GaiantRaidResorcePoint, this.PvpResorcePoint);
}
public bool UpdateMaxMemberLimit(int guildSN, int maxMemberLimit)
{
if (FeatureMatrix.IsEnable("InGameGuild") && FeatureMatrix.GetInteger("InGameGuild_MaxMemberLimit") >= maxMemberLimit)
{
int num = this.UpdateGuildInfo(new int?(FeatureMatrix.GameCode), new int?(GuildAPI.ServerCode), new int?(guildSN), new int?(maxMemberLimit), null, null, null, null, new int?(FeatureMatrix.GetInteger("InGameGuild_MaxMember")), null);
if (num == 1)
{
return(true);
}
}
return(false);
}
public bool IsPickLimited(OnlineGuildMember member, string itemclass, int slotNo, int amount)
{
if (member.GuildMember.Rank > GuildMemberRank.Member)
{
member.SendOperationFailedDialog("GuildStorageFail_RankLimited");
return(true);
}
if (itemclass == "gold")
{
if (this.GoldHolding - amount < this.GoldPickLimit)
{
member.SendOperationFailedDialog("GuildStorageFail_GoldPickLimitBySetting");
return(true);
}
int integer = FeatureMatrix.GetInteger("GuildStorageGoldDailyLimit");
if (integer == 0)
{
return(false);
}
int num = int.Parse(DateTime.Now.ToString("yyyyMMdd"));
foreach (GuildStorageBriefLogElement guildStorageBriefLogElement in this.BriefTodayLogs)
{
if (guildStorageBriefLogElement.Datestamp == num && guildStorageBriefLogElement.CharacterName == member.CharacterName && guildStorageBriefLogElement.OperationType == GuildStorageOperationType.Gold)
{
if (guildStorageBriefLogElement.PickCount + amount - guildStorageBriefLogElement.AddCount > integer)
{
member.SendOperationFailedDialog("GuildStorageFail_GoldPickDailyLimit");
return(true);
}
return(false);
}
}
if (amount > integer)
{
member.SendOperationFailedDialog("GuildStorageFail_GoldPickDailyLimit");
return(true);
}
return(false);
}
else
{
int num2 = slotNo / this.GuildStorageSlotsPerTab;
int num3 = (int)(this.AccessLimitTag >> num2 * this.GuildStorageSettingFlagBitsPerTab & (long)this.GuildStorageSettingMask);
if (num3 != 0 && member.GuildMember.Rank > (GuildMemberRank)num3)
{
member.SendOperationFailedDialog("GuildStorageFail_RankLimited");
return(true);
}
return(false);
}
}
public void PrintDsState()
{
int num = FeatureMatrix.GetInteger("DSStatusLogPeriod");
if (num > 0)
{
string log = string.Format("{0}\n{1}\n===========================================\n", DateTime.Now.ToString(), this.DSWaitingSystem.ToString());
FileLog.Log("DS_Status.log", log);
}
else
{
num = 10;
}
Scheduler.Schedule(base.Thread, Job.Create(new Action(this.PrintDsState)), num * 1000);
}
public static GoalTarget From(QuestGoalInfo info)
{
return(new GoalTarget
{
GoalID = info.ID,
Weight = info.Weight,
Regex = ((info.Target == null || info.GameSetting != null) ? "" : info.Target),
Count = info.TargetCount.Value,
Positive = (info.IsPositive != 0),
Exp = info.XP * FeatureMatrix.GetInteger("ExpRate_Combat") / 100,
Gold = info.Gold * FeatureMatrix.GetInteger("GoldRate_Combat") / 100,
BaseExp = info.XP,
ItemReward = ((info.Item == null) ? "" : info.Item),
ItemNum = info.ItemNum
});
}
public int GetMaxMemberLimit(int guildSN)
{
if (FeatureMatrix.IsEnable("InGameGuild"))
{
if (FeatureMatrix.GetInteger("InGameGuild_MaxMemberLimit") > FeatureMatrix.GetInteger("InGameGuild_MaxMember"))
{
GetInGameGuildInfo getInGameGuildInfo = this.GetInGameGuildInfo(new int?(FeatureMatrix.GameCode), new int?(GuildAPI.ServerCode), new int?(guildSN)).FirstOrDefault <GetInGameGuildInfo>();
if (getInGameGuildInfo != null && getInGameGuildInfo.MaxMemberLimit > FeatureMatrix.GetInteger("InGameGuild_MaxMember"))
{
return(getInGameGuildInfo.MaxMemberLimit);
}
}
return(FeatureMatrix.GetInteger("InGameGuild_MaxMember"));
}
return(0);
}
public void SyncDSStatus()
{
if (this.WaitingParty != null)
{
int orderCount = this.WaitingParty.Order ?? (FeatureMatrix.GetInteger("DSWaitingMax") + 1);
this.SendMessage <DSPlayerStatusMessage>(new DSPlayerStatusMessage(this.WaitingParty.QuestID, this.Status, this.WaitingParty.RegisteredTime, orderCount, this.IsGiantRaid));
return;
}
if (this.Ship == null)
{
this.SendMessage <DSPlayerStatusMessage>(new DSPlayerStatusMessage("", this.Status, "", this.IsGiantRaid));
return;
}
if (this.Status == DSPlayerStatus.ShipWaitingMember)
{
this.SendMessage <DSPlayerStatusMessage>(new DSPlayerStatusMessage(this.Ship.QuestID, this.Status, this.Ship.Players.Count, this.Ship.PartyID, this.IsGiantRaid));
return;
}
this.SendMessage <DSPlayerStatusMessage>(new DSPlayerStatusMessage(this.Ship.QuestID, this.Status, this.Ship.PartyID, this.IsGiantRaid));
}
public void RefreshOrder()
{
int integer = FeatureMatrix.GetInteger("DSWaitingMax");
int num = 1;
foreach (DSWaitingParty dswaitingParty in this.WaitingParties)
{
dswaitingParty.UpdateOrder(num);
dswaitingParty.Sync();
if (this.IsGiantRaid)
{
num += dswaitingParty.Members.Count;
}
else
{
num++;
}
if (num > integer)
{
break;
}
}
}
public override void Initialize(JobProcessor thread)
{
ConnectionStringLoader.LoadFromServiceCore(Settings.Default);
DSContents.Initialize();
base.Initialize(thread, DSServiceOperations.TypeConverters);
base.RegisterMessage(OperationMessages.TypeConverters);
base.RegisterAllProcessors(Assembly.GetExecutingAssembly());
this.MessageHandlerFactory = new MessageHandlerFactory(true);
this.MessageHandlerFactory.Register <DSEntity>(Messages.TypeConverters, "ProcessMessage");
this.InitializeTcpClientHolder();
base.Disposed += delegate(object _, EventArgs __)
{
this.KillDSProcess();
};
this.KillDSProcess();
DSService.MyIP = this.GetMyIP();
this.InitializeTcpServer(ServiceCoreSettings.Default.DSServicePort);
base.OnSetupID += delegate(int id)
{
Scheduler.Schedule(base.Thread, Job.Create(new Action(this.SetupDSController)), 0);
};
int integer = FeatureMatrix.GetInteger("DSCactiFrequency");
if (integer > 0)
{
this.CactiCsvFileDropper = new CactiCsvFileDropper("Cacti", "DSService", integer, new List <string>
{
"ProcessCount",
"FPS_siglint",
"FPS_bugeikloth",
"FPS_elculous"
});
this.CactiCsvFileDropper.FileDropStarted += this.GetCactiInformation;
}
FeatureMatrix.onUpdated += this.OnUpdatedFetureMatrix;
}
public override IEnumerable <object> Run()
{
GuildStorageManager storage = this.Entity.Storage;
OnlineGuildMember member = this.Entity.GetOnlineMember(this.Operation.PuchasedCID);
if (!this.Entity.Storage.Valid || !FeatureMatrix.IsEnable("GuildStorage"))
{
member.SendOperationFailedDialog("GuildStorageFail_Processing");
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Invalid);
this.Finished = true;
yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] GuildStorage")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else if (this.Entity.Storage.Processing)
{
member.SendOperationFailedDialog("GuildStorageFail_Processing");
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Processing);
this.Finished = true;
yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] Entity.Storage.Processing")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else if (!this.Entity.Storage.IsEnabled)
{
member.SendOperationFailedDialog("GuildStorageFail_Stopped");
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Invalid);
this.Finished = true;
yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] Entity.Storage.IsEnabled")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else if (storage.StorageCount >= storage.GuildStorageSlotsMax)
{
member.SendOperationFailedDialog("GuildStorageFail_Full");
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Invalid);
this.Finished = true;
yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] storage.StorageCount")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else
{
this.Entity.Storage.Processing = true;
int targetSlotCount = 0;
if (this.Entity.Storage.StorageCount == 0 && !FeatureMatrix.IsEnable("GuildStoargeSlotAllCash"))
{
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.PurchaseSlotByGold);
if (FeatureMatrix.GetInteger("GuildStorageSlotGoldPrice") > 0)
{
DestroyItem op = new DestroyItem("gold", FeatureMatrix.GetInteger("GuildStorageSlotGoldPrice"), GiveItem.SourceEnum.Unknown);
OperationSync sync = new OperationSync()
{
Connection = member.PlayerConn,
Operation = (Operation)op
};
yield return((object)sync);
if (!sync.Result || !op.Result)
{
this.Entity.Storage.Processing = false;
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.Error_PurchaseSlotByGold);
member.SendOperationFailedDialog("GuildStorageFail_PurchaseFailed");
this.Finished = true;
yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] op.Result")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
yield break;
}
}
targetSlotCount = this.Entity.Storage.GuildStorageSlotsFirstPurchase;
}
else
{
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.PurchaseSlotByCash);
if (!FeatureMatrix.IsEnable("GuildStoargeSlotFree"))
{
if (this.Operation.ProductNo == -1)
{
member.SendOperationFailedDialog("GuildStorageFail_PurchaseFailed");
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Invalid);
this.Entity.Storage.Processing = false;
this.Finished = true;
yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] Operation.ProductNo")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
yield break;
}
else
{
DirectPickUpByProductNo op = new DirectPickUpByProductNo()
{
ProductNoList = new List <int>()
{
this.Operation.ProductNo
},
IsCredit = this.Operation.IsCredit
};
OperationSync sync = new OperationSync()
{
Connection = member.CashShopConn,
Operation = (Operation)op
};
yield return((object)sync);
if (!sync.Result || !op.Result || !op.ResultingItems.ContainsKey("guildstorage_ticket"))
{
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.Error_PurchaseSlotByCash);
member.SendOperationFailedDialog("GuildStorageFail_PurchaseFailed");
this.Entity.Storage.Processing = false;
this.Finished = true;
yield return((object)new FailMessage("[PurchaseGuildStorageProcessor] guildstorage_ticket")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
yield break;
}
}
}
targetSlotCount = this.Entity.Storage.GuildStorageSlotsPerPurchase;
}
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.Process);
AddGuildStorageSlots requestOp = new AddGuildStorageSlots()
{
SlotCount = targetSlotCount
};
requestOp.OnComplete += (Action <Operation>)(___ => this.Entity.Storage.StorageCount = requestOp.ResultSlotCount);
OperationSync sync2 = new OperationSync()
{
Connection = this.Entity.Storage.ItemConn,
Operation = (Operation)requestOp
};
yield return((object)sync2);
if (requestOp.Result)
{
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.Done);
}
else
{
storage.AddGuildStorageLedger(this.Operation.PuchasedCID, GuildStorageOperationCode.PurchaseGuildStorage, GuildStorageEventCode.Error_ProcessFail);
}
this.Entity.Storage.Processing = false;
this.Entity.Storage.ReportExtendSlot(member.CharacterName, this.Entity.Storage.GuildStorageSlotsPerPurchase);
this.Finished = true;
yield return((object)new OkMessage());
}
}
public bool UpdateNewbieRecommend(int guildSN, bool recommend)
{
if (FeatureMatrix.IsEnable("NewbieGuildRecommend"))
{
int num = this.UpdateGuildInfo(new int?(FeatureMatrix.GameCode), new int?(GuildAPI.ServerCode), new int?(guildSN), null, new bool?(recommend), null, null, null, new int?(FeatureMatrix.GetInteger("InGameGuild_MaxMember")), null);
if (num == 1)
{
return(true);
}
}
return(false);
}
public override IEnumerable <object> Run()
{
if (this.service.IsCashShopStopped)
{
base.Finished = true;
base.Entity.SendErrorDialog("CashShop_EmergencyStop");
yield return(new FailMessage("[QueryCashShopItemPickUpProcessor] service.IsCashShopStopped")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else if (base.Entity.CID == -1L)
{
base.Finished = true;
base.Entity.SendErrorDialog("CashShop_NotReady");
yield return(new FailMessage("[QueryCashShopItemPickUpProcessor] Entity.CID")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else
{
AsyncResultSync sync = new AsyncResultSync(this.service.Thread);
IAsyncResult ar = base.Entity.BeginInventoryPickup(base.Operation.OrderNo, base.Operation.ProductNo, base.Operation.Quantity, new AsyncCallback(sync.AsyncCallback), "DirectPurchase");
if (ar != null)
{
yield return(sync);
}
if (ar == null && !sync.Result)
{
base.Finished = true;
yield return(new FailMessage("[QueryCashShopItemPickUpProcessor] !sync.Result")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else
{
InventoryPickupOnceResponse asyncResult = base.Entity.EndInventoryPickUp(ar);
if (asyncResult == null)
{
base.Finished = true;
yield return(new FailMessage("[QueryCashShopItemPickUpProcessor] asyncResult")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else
{
bool isGift = base.Entity.GiftSenderCIDDict.ContainsKey(base.Operation.OrderNo);
GiveItem giveItemOp = asyncResult.ToGiveItem(this.service, isGift);
if (giveItemOp != null && giveItemOp.ItemRequestInfo.Count > 0)
{
foreach (ItemRequestInfo.Element element in giveItemOp.ItemRequestInfo.Elements)
{
Log <QueryCashShopItemPickUpProcessor> .Logger.InfoFormat("{0} x {1}", element.ItemClassEx, element.Num);
}
OperationSync giveItemSync = new OperationSync
{
Connection = base.Entity.ItemConnection,
Operation = giveItemOp
};
yield return(giveItemSync);
base.Entity.CashShopProcessLog(base.Operation.OrderNo, giveItemOp, giveItemSync.Result);
if (!giveItemSync.Result || giveItemOp.ErrorCode != GiveItem.ResultEnum.Success)
{
Log <QueryCashShopItemPickUpProcessor> .Logger.ErrorFormat("GiveItemSync is failed. NexonID: {0}, CID: {1}", base.Entity.NexonID, base.Entity.CID);
base.Entity.EndInventoryPickUp_OnFail(asyncResult);
base.Finished = true;
yield return(new FailMessage("[QueryCashShopItemPickUpProcessor] giveItemOp.ErrorCode")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
OperationSync giveMileageSync = new OperationSync();
bool useMileageSystem = FeatureMatrix.IsEnable("CashShop_MileageSystem");
if (useMileageSystem)
{
double mileageRatio = (double)((float)FeatureMatrix.GetInteger("CashShop_MileageRatio") / 100f);
int totalPrice = this.service.ProductByProductID.TryGetValue(base.Operation.ProductNo).SalePrice *(int)asyncResult.ProductPieces;
int mileagePoint = Convert.ToInt32(Math.Floor((double)totalPrice * mileageRatio));
mileagePoint = ((mileagePoint == 0) ? 1 : mileagePoint);
CashshopMileage mileageOp = null;
if (isGift)
{
long cid = base.Entity.GiftSenderCIDDict.TryGetValue(base.Operation.OrderNo);
mileageOp = new CashshopMileage(cid, mileagePoint, CashshopMileage.ProcessEnum.ADD_GIFT_USER);
}
else
{
mileageOp = new CashshopMileage(0L, mileagePoint, CashshopMileage.ProcessEnum.ADD);
}
giveMileageSync.Connection = base.Entity.ItemConnection;
giveMileageSync.Operation = mileageOp;
yield return(giveMileageSync);
if (!giveMileageSync.Result)
{
Log <QueryCashShopItemPickUpProcessor> .Logger.ErrorFormat("GiveItemSync is failed. NexonID: {0}, CID: {1}", base.Entity.NexonID, base.Entity.CID);
base.Entity.CashShopProcessLog("", base.Operation.OrderNo.ToString(), base.Operation.OrderNo, mileagePoint, base.Entity.CID, base.Entity.NexonSN, "Mileage", "GiveFail");
}
}
base.Entity.EndInventoryPickUp_OnComplete(asyncResult);
int tircoinCount = 0;
foreach (ItemRequestInfo.Element element2 in giveItemOp.ItemRequestInfo.Elements)
{
if (element2.ItemClassEx.StartsWith("tir_coin"))
{
tircoinCount += element2.Num;
}
}
if (tircoinCount > 0)
{
SendPacket op = SendPacket.Create <OpenCustomDialogUIMessage>(new OpenCustomDialogUIMessage
{
DialogType = 3,
Arg = new List <string>
{
tircoinCount.ToString()
}
});
base.Entity.FrontendConnection.RequestOperation(op);
SystemMessage serializeObject = new SystemMessage(SystemMessageCategory.System, "GameUI_Heroes_SystemMessage_TirCoin_BuyOK", new object[]
{
tircoinCount
});
SendPacket op2 = SendPacket.Create <SystemMessage>(serializeObject);
base.Entity.FrontendConnection.RequestOperation(op2);
}
base.Finished = true;
yield return(new OkMessage());
}
else
{
Log <QueryCashShopItemPickUpProcessor> .Logger.ErrorFormat("ToGiveItem is failed or there's no given item. NexonID: {0}, CID: {1}", base.Entity.NexonID, base.Entity.CID);
base.Entity.EndInventoryPickUp_OnFail(asyncResult);
base.Finished = true;
yield return(new FailMessage("[QueryCashShopItemPickUpProcessor] giveItemOp.ItemRequestInfo.Count")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
}
}
}
yield break;
}
public override IEnumerable <object> Run()
{
HeroesDataContext context = new HeroesDataContext();
context.UpdateGuildInfo(new int?(FeatureMatrix.GameCode), new int?(GuildAPI.ServerCode), new int?(base.Entity.GuildSN), null, null, null, null, base.Operation.Text, new int?(FeatureMatrix.GetInteger("InGameGuild_MaxMember")), null);
base.Entity.GuildInfo.GuildNotice = base.Operation.Text;
base.Entity.ReportGuildInfoChanged();
base.Entity.Sync();
base.Finished = true;
yield return(new OkMessage());
yield break;
}
public override IEnumerable <object> Run()
{
bool queryResult = false;
HeroesUserGuildInfo queryFuncResult = null;
if (FeatureMatrix.IsEnable("GuildProcessorNotUseAsync"))
{
queryResult = true;
List <HeroesUserGuildInfo> guildInfo = GuildAPI.GetAPI().GetGuildInfo(base.Operation.GuildMemberKey);
if (guildInfo.Count > 0)
{
queryFuncResult = guildInfo.First <HeroesUserGuildInfo>();
}
}
else
{
AsyncFuncSync <HeroesUserGuildInfo> sync = new AsyncFuncSync <HeroesUserGuildInfo>(delegate
{
List <HeroesUserGuildInfo> guildInfo3 = GuildAPI.GetAPI().GetGuildInfo(base.Operation.GuildMemberKey);
if (guildInfo3.Count == 0)
{
return(null);
}
return(guildInfo3.First <HeroesUserGuildInfo>());
});
yield return(sync);
queryResult = sync.Result;
queryFuncResult = sync.FuncResult;
}
base.Finished = true;
if (queryResult)
{
if (queryFuncResult == null)
{
Log <QueryGuildIDProcessor> .Logger.WarnFormat("[{0}] No Guild", base.Operation.GuildMemberKey.CharacterName);
yield return(0L);
yield return("");
yield return(0);
yield return(0);
int maxMember = FeatureMatrix.IsEnable("InGameGuild") ? FeatureMatrix.GetInteger("InGameGuild_MaxMember") : 0;
yield return(maxMember);
}
else
{
Log <QueryGuildIDProcessor> .Logger.WarnFormat("[{0}] GuildSN[{1}] GuildName[{2}] Rank[{3}] ", new object[]
{
base.Operation.GuildMemberKey.CharacterName,
queryFuncResult.CharacterSN,
queryFuncResult.CharacterName,
queryFuncResult.GroupUserType
});
int maxMemberLimit = 0;
int level = 0;
using (HeroesDataContext heroesDataContext = new HeroesDataContext())
{
GetInGameGuildInfo guildInfo2 = heroesDataContext.GetGuildInfo(queryFuncResult.GuildSN);
maxMemberLimit = guildInfo2.MaxMemberLimit;
level = guildInfo2.Level;
}
yield return((long)queryFuncResult.GuildSN);
yield return(queryFuncResult.GuildName);
yield return(level);
yield return((int)queryFuncResult.GroupUserType.ToGuildMemberRank());
yield return(maxMemberLimit);
}
}
else
{
yield return(new FailMessage("[QueryGuildIDProcessor] queryResult"));
}
yield break;
}
public bool set_guild_level()
{
int argInt = base.Operation.GetArgInt(0, 1);
int argInt2 = base.Operation.GetArgInt(1, 0);
base.Entity.SetGuildLevel(argInt, argInt2);
using (HeroesDataContext heroesDataContext = new HeroesDataContext())
{
heroesDataContext.UpdateGuildInfo(new int?(FeatureMatrix.GameCode), new int?(GuildAPI.ServerCode), new int?(base.Entity.GuildSN), null, null, new int?(base.Entity.GuildInfo.GuildLevel), new long?(base.Entity.GuildInfo.GuildPoint), null, new int?(FeatureMatrix.GetInteger("InGameGuild_MaxMember")), null);
}
base.Entity.ReportGuildInfoChanged();
base.Entity.Sync();
return(true);
}
public bool GiveGP()
{
int argInt = base.Operation.GetArgInt(0, 0);
int argInt2 = base.Operation.GetArgInt(1, 255);
bool flag = base.Operation.GetArgInt(2, 0) != 0;
if (!GPGainTypeUtil.IsValidGPGainTypeValue(argInt2, true))
{
Log <_CheatCommandProcessor> .Logger.ErrorFormat("Invalid gainType value is retrieved from DB: GPGainType: {0}, GuildSN: {1}", argInt2, base.Entity.GuildSN);
return(false);
}
if (!flag)
{
int num = base.Entity.GiveGP(argInt, (GPGainType)argInt2, 0L);
if (num != 0)
{
using (HeroesDataContext heroesDataContext = new HeroesDataContext())
{
heroesDataContext.UpdateGuildInfo(new int?(FeatureMatrix.GameCode), new int?(GuildAPI.ServerCode), new int?(base.Entity.GuildSN), null, null, new int?(base.Entity.GuildInfo.GuildLevel), new long?(base.Entity.GuildInfo.GuildPoint), null, new int?(FeatureMatrix.GetInteger("InGameGuild_MaxMember")), null);
}
base.Entity.ReportGuildInfoChanged();
base.Entity.Sync();
}
return(true);
}
long num2 = 0L;
foreach (KeyValuePair <string, OnlineGuildMember> keyValuePair in base.Entity.OnlineMembers)
{
if (keyValuePair.Value.FID == base.Connection.RemoteID)
{
num2 = keyValuePair.Value.CID;
break;
}
}
if (num2 == 0L)
{
Log <_CheatCommandProcessor> .Logger.WarnFormat("Could not find _CheatCommand requester by FID. FID: {0}", base.Connection.RemoteID);
return(false);
}
GiveGuildGP giveGuildGP = new GiveGuildGP();
giveGuildGP.GainType = (GPGainType)argInt2;
giveGuildGP.GiveDict.Add(num2, argInt);
this.service.RequestOperation(base.Entity.Entity, new Location(base.Entity.GuildID, "GuildService.GuildService"), giveGuildGP);
return(true);
}
public override IEnumerable<object> Run()
{
base.Finished = true;
if (!FeatureMatrix.IsEnable("GuildLevel"))
{
yield return new FailMessage("[GiveGuildGPProcessor] GuildLevel")
{
Reason = FailMessage.ReasonCode.NotSupportedOperation
};
}
else
{
using (HeroesDataContext context = new HeroesDataContext())
{
bool gpAdded = false;
foreach (KeyValuePair<long, int> keyValuePair in base.Operation.GiveDict)
{
long key = keyValuePair.Key;
int value = keyValuePair.Value;
OnlineGuildMember onlineGuildMember = null;
foreach (KeyValuePair<string, OnlineGuildMember> keyValuePair2 in base.Entity.OnlineMembers)
{
if (keyValuePair2.Value.CID == key)
{
onlineGuildMember = keyValuePair2.Value;
break;
}
}
if (onlineGuildMember != null && onlineGuildMember.GuildMember.Rank.IsRegularMember())
{
int num = base.Entity.GiveGP(value, base.Operation.GainType, key);
gpAdded |= (num != 0);
try
{
onlineGuildMember.GuildMember.AddPoint(num);
long point = onlineGuildMember.GuildMember.GetPoint();
base.Entity.ReportGuildMemberChanged(onlineGuildMember.GuildMember.Key);
context.UpdateGuildCharacterInfo(new long?(key), new long?(point));
GuildLog.AddGuildLedger(new LogData((long)base.Entity.GuildSN, key, OperationType.GainGuildPoint, GuildLedgerEventType.UpdateGuildUserPoint, point.ToString()));
}
catch (Exception ex)
{
Log<GiveGuildGP>.Logger.ErrorFormat("Error while GiveGuildGPProcessor, Step UpdateGuildCharacterInfo : {0}", ex.ToString());
}
}
}
if (!gpAdded)
{
yield return new FailMessage("[GiveGuildGPProcessor] gpAdded");
yield break;
}
try
{
context.UpdateGuildInfo(new int?(FeatureMatrix.GameCode), new int?(GuildAPI.ServerCode), new int?(base.Entity.GuildSN), null, null, new int?(base.Entity.GuildInfo.GuildLevel), new long?(base.Entity.GuildInfo.GuildPoint), null, new int?(FeatureMatrix.GetInteger("InGameGuild_MaxMember")), null);
}
catch (Exception ex2)
{
Log<GiveGuildGP>.Logger.ErrorFormat("Error while GiveGuildGPProcessor, Step UpdateGuildInfo : {0}", ex2.ToString());
}
}
base.Entity.ReportGuildInfoChanged();
base.Entity.Sync();
yield return new OkMessage();
}
yield break;
}
public override IEnumerable <object> Run()
{
base.Operation.Result = DirectPurchaseGuildItemResultCode.Success;
GuildLedgerEventType result = GuildLedgerEventType.Success;
GuildMember myInfo = base.Entity.GetGuildMember(base.Operation.Key.CharacterName);
OnlineGuildMember member = base.Entity.GetOnlineMember(myInfo.Key.CID);
string maxIncreaseCountParsing = base.Operation.ItemClass.Replace("guild_extension_member_", "");
int maxIncreaseCount = 0;
if (!base.Entity.IsInitialized || base.Entity.GuildInfo == null)
{
base.Operation.Result = DirectPurchaseGuildItemResultCode.GuildNotInitialize;
result = GuildLedgerEventType.GuildNotInitialize;
}
else if (myInfo == null || !myInfo.Rank.IsMaster() || member == null)
{
base.Operation.Result = DirectPurchaseGuildItemResultCode.IsNotMaster;
result = GuildLedgerEventType.IsNotMaster;
}
else if (!int.TryParse(maxIncreaseCountParsing, out maxIncreaseCount))
{
base.Operation.Result = DirectPurchaseGuildItemResultCode.CannotParseItem;
result = GuildLedgerEventType.CannotParseItem;
}
else if (FeatureMatrix.GetInteger("InGameGuild_MaxMemberLimit") < base.Entity.GuildInfo.MaxMemberCount + maxIncreaseCount)
{
base.Operation.Result = DirectPurchaseGuildItemResultCode.OverMaxMemberLimit;
result = GuildLedgerEventType.OverMaxMemberLimit;
}
if (base.Operation.Result != DirectPurchaseGuildItemResultCode.Success)
{
GuildLog.AddGuildLedger(new LogData((long)base.Entity.GuildSN, base.Operation.Key.CID, OperationType.DirectPurchaseGuildItem, result));
base.Finished = true;
yield return(base.Operation.Result);
}
else
{
DirectPickUpByProductNo directPickupOp = new DirectPickUpByProductNo(new List <int>
{
base.Operation.ProductNo
}, base.Operation.IsCredit);
OperationSync directPickupSync = new OperationSync
{
Connection = member.CashShopConn,
Operation = directPickupOp
};
yield return(directPickupSync);
if (!directPickupSync.Result)
{
if (directPickupOp.FailReasonString.StartsWith("BeginDirectPurchaseItem"))
{
base.Operation.Result = DirectPurchaseGuildItemResultCode.BeginDirectPurchaseItem;
result = GuildLedgerEventType.BeginDirectPurchaseItem;
}
else if (directPickupOp.FailReasonString.StartsWith("EndDirectPurchaseItem"))
{
base.Operation.Result = DirectPurchaseGuildItemResultCode.EndDirectPurchaseItem;
result = GuildLedgerEventType.EndDirectPurchaseItem;
}
else
{
base.Operation.Result = DirectPurchaseGuildItemResultCode.Unknown;
result = GuildLedgerEventType.Unknown;
}
GuildLog.AddGuildLedger(new LogData((long)base.Entity.GuildSN, base.Operation.Key.CID, OperationType.DirectPurchaseGuildItem, result));
base.Finished = true;
yield return(new FailMessage("[DirectPurchaseGuildItemProcessor] directPickupSync.Result"));
}
else
{
bool updateResult = false;
try
{
HeroesDataContext heroesDataContext = new HeroesDataContext();
updateResult = heroesDataContext.UpdateMaxMemberLimit(base.Entity.GuildInfo.GuildSN, base.Entity.GuildInfo.MaxMemberCount + maxIncreaseCount);
if (!updateResult)
{
base.Operation.Result = DirectPurchaseGuildItemResultCode.DatabaseFail;
result = GuildLedgerEventType.DatabaseFail;
}
}
catch (Exception ex)
{
Log <DirectPurchaseGuildItemProcessor> .Logger.Error("UpdateGuildInfoProcessor DataBase Exception ", ex);
base.Operation.Result = DirectPurchaseGuildItemResultCode.DatabaseException;
result = GuildLedgerEventType.DatabaseException;
}
HeroesGuildInfo guildInfo = GuildAPI.GetAPI().GetGuildInfo(base.Entity.GuildSN);
if (guildInfo != null)
{
base.Entity.GuildInfo = guildInfo.ToGuildInfo();
base.Entity.UpdateGroupInfo();
base.Entity.Sync();
}
else
{
base.Operation.Result = DirectPurchaseGuildItemResultCode.ReloadFail;
result = GuildLedgerEventType.ReloadFail;
}
if (!updateResult || base.Operation.Result != DirectPurchaseGuildItemResultCode.Success)
{
RollbackDirectPickUp rollbackPickupOp = new RollbackDirectPickUp
{
OrderNo = directPickupOp.OrderNo,
ProductNoList = directPickupOp.ProductNoList
};
OperationSync rollbackPickupSync = new OperationSync
{
Connection = member.CashShopConn,
Operation = rollbackPickupOp
};
yield return(rollbackPickupSync);
Log <DirectPurchaseGuildItemProcessor> .Logger.ErrorFormat("UpdateGuildInfoProcessor DataBase Fail {0}", base.Entity.GuildSN);
GuildLog.AddGuildLedger(new LogData((long)base.Entity.GuildSN, base.Operation.Key.CID, OperationType.DirectPurchaseGuildItem, result));
base.Finished = true;
yield return(base.Operation.Result);
}
else
{
base.Operation.Result = DirectPurchaseGuildItemResultCode.Success;
result = GuildLedgerEventType.Success;
GuildLog.AddGuildLedger(new LogData((long)base.Entity.GuildSN, base.Operation.Key.CID, OperationType.DirectPurchaseGuildItem, result));
base.Finished = true;
yield return(base.Operation.Result);
}
}
}
yield break;
}
public override IEnumerable <object> Run()
{
if (base.Operation.SearchKey == null || base.Operation.SearchKey.Length < 2 || base.Operation.SearchKey.Length > FeatureMatrix.GetInteger("GuildNamingRuleMaxBytes"))
{
Log <QueryGuildList> .Logger.InfoFormat("길드명 또는 길드 마스터 이름이 잘못되었습니다.{0}", base.Operation.SearchKey);
base.Finished = true;
yield return(new FailMessage("[QueryGuildListProcessor] GuildNamingRuleMaxBytes"));
}
else
{
int total_page = 1;
bool queryResult = false;
List <InGameGuildInfo> queryFuncResult = new List <InGameGuildInfo>();
if (FeatureMatrix.IsEnable("GuildProcessorNotUseAsync"))
{
queryResult = true;
int num;
ICollection <HeroesGuildInfo> list = GuildAPI.GetAPI().SearchGuild(base.Operation.QueryType, 0, base.Operation.Page, base.Operation.PageSize, base.Operation.SearchKey, out num);
total_page = ((num == 0) ? 1 : ((num - 1) / (int)base.Operation.PageSize + 1));
queryFuncResult = list.ToGuildInfoList();
}
else
{
AsyncFuncSync <List <InGameGuildInfo> > sync = new AsyncFuncSync <List <InGameGuildInfo> >(delegate
{
int num2;
ICollection <HeroesGuildInfo> list2 = GuildAPI.GetAPI().SearchGuild(this.Operation.QueryType, 0, this.Operation.Page, this.Operation.PageSize, this.Operation.SearchKey, out num2);
total_page = ((num2 == 0) ? 1 : ((num2 - 1) / (int)this.Operation.PageSize + 1));
return(list2.ToGuildInfoList());
});
yield return(sync);
queryResult = sync.Result;
queryFuncResult = sync.FuncResult;
}
base.Finished = true;
if (queryResult)
{
yield return(queryFuncResult);
yield return(base.Operation.Page);
yield return(total_page);
}
else
{
yield return(new FailMessage("[QueryGuildListProcessor] queryResult"));
}
}
yield break;
}
