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 override IEnumerable <object> Run()
{
GuildStorageManager storage = base.Entity.Storage;
OnlineGuildMember member = base.Entity.GetOnlineMember(base.Operation.RequestingCID);
if (!base.Entity.Storage.Valid || !FeatureMatrix.IsEnable("GuildStorage"))
{
member.SendOperationFailedDialog("GuildStorageFail_Processing");
storage.AddGuildStorageLedger(base.Operation.RequestingCID, GuildStorageOperationCode.ArrangeGuildItem, GuildStorageEventCode.Error_Invalid);
base.Finished = true;
yield return(new FailMessage("[ArrangeGuildStorageItemProcessor] GuildStorage")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else if (base.Entity.Storage.Processing)
{
member.SendOperationFailedDialog("GuildStorageFail_Processing");
storage.AddGuildStorageLedger(base.Operation.RequestingCID, GuildStorageOperationCode.ArrangeGuildItem, GuildStorageEventCode.Error_Processing);
base.Finished = true;
yield return(new FailMessage("[ArrangeGuildStorageItemProcessor] Entity.Storage.Processing")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else if (!base.Entity.Storage.IsEnabled)
{
member.SendOperationFailedDialog("GuildStorageFail_Stopped");
storage.AddGuildStorageLedger(base.Operation.RequestingCID, GuildStorageOperationCode.ArrangeGuildItem, GuildStorageEventCode.Error_Invalid);
base.Finished = true;
yield return(new FailMessage("[ArrangeGuildStorageItemProcessor] Entity.Storage.IsEnabled")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else
{
base.Entity.Storage.Processing = true;
QueryItemInfoByItemID op0 = new QueryItemInfoByItemID
{
ItemID = base.Operation.ItemID
};
OperationSync sync0 = new OperationSync
{
Connection = base.Entity.Storage.ItemConn,
Operation = op0
};
yield return(sync0);
if (op0.Result)
{
if (op0.SlotInfo.ItemClass == "gold")
{
member.SendOperationFailedDialog("GuildStorageFail_InvalidItem");
base.Entity.Storage.Processing = false;
base.Finished = true;
yield return(new FailMessage("[ArrangeGuildStorageItemProcessor] op0.SlotInfo.ItemClass")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else if (base.Entity.Storage.IsPickLimited(member, op0.SlotInfo.ItemClass, op0.SlotInfo.Slot, 1) || base.Entity.Storage.IsPickLimited(member, "", base.Operation.Slot, 1))
{
base.Entity.Storage.Processing = false;
base.Finished = true;
yield return(new FailMessage("[ArrangeGuildStorageItemProcessor] Entity.Storage.IsPickLimited")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else
{
storage.AddGuildStorageLedger(base.Operation.RequestingCID, GuildStorageOperationCode.ArrangeGuildItem, GuildStorageEventCode.Process, base.Operation.ItemID.ToString(), base.Operation.Slot);
MoveInventoryItem op = new MoveInventoryItem(base.Operation.ItemID, 0, base.Operation.Slot);
OperationSync sync = new OperationSync
{
Connection = base.Entity.Storage.ItemConn,
Operation = op
};
yield return(sync);
if (sync.Result && op.Result)
{
storage.AddGuildStorageLedger(base.Operation.RequestingCID, GuildStorageOperationCode.ArrangeGuildItem, GuildStorageEventCode.Done, base.Operation.ItemID.ToString(), base.Operation.Slot);
}
else
{
storage.AddGuildStorageLedger(base.Operation.RequestingCID, GuildStorageOperationCode.ArrangeGuildItem, GuildStorageEventCode.Error_TransferFail, base.Operation.ItemID.ToString(), base.Operation.Slot);
member.SendOperationFailedDialog("GuildStorageFail_TransferFailed");
}
base.Entity.Storage.Processing = false;
base.Finished = true;
yield return(new OkMessage());
}
}
else
{
member.SendOperationFailedDialog("GuildStorageFail_InternalError");
base.Entity.Storage.Processing = false;
base.Finished = true;
yield return(new FailMessage("[ArrangeGuildStorageItemProcessor] op0.Result")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
}
yield break;
}
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()
{
GuildStorageManager storage = this.Entity.Storage;
OnlineGuildMember member = this.Entity.GetOnlineMember(this.Operation.OwnerCID);
if (!this.Entity.Storage.Valid || !FeatureMatrix.IsEnable("GuildStorage"))
{
member.SendOperationFailedDialog("GuildStorageFail_Processing");
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Invalid);
this.Finished = true;
yield return((object)new FailMessage("[PickGuildStorageItemProcessor] GuildStorage")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else if (this.Entity.Storage.Processing)
{
member.SendOperationFailedDialog("GuildStorageFail_Processing");
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Processing);
this.Finished = true;
yield return((object)new FailMessage("[PickGuildStorageItemProcessor] Entity.Storage.Processing")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else if (this.Entity.Storage.StorageCount == 0)
{
member.SendOperationFailedDialog("GuildStorageFail_NoSlot");
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.AddGuildItem, GuildStorageEventCode.Error_Invalid);
this.Finished = true;
yield return((object)new FailMessage("[PickGuildStorageItemProcessor] Entity.Storage.StorageCount")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else
{
this.Entity.Storage.Processing = true;
int color1 = -1;
int color2 = -1;
int color3 = -1;
int reduceDurability = -1;
int maxDurabilityBonus = -1;
byte tab = byte.MaxValue;
int slot = -2;
string loggingItemClass = this.Operation.ItemClass;
if (this.Operation.ItemID != 0L)
{
QueryItemInfoByItemID op0 = new QueryItemInfoByItemID()
{
ItemID = this.Operation.ItemID
};
OperationSync sync0 = new OperationSync()
{
Connection = this.Entity.Storage.ItemConn,
Operation = (Operation)op0
};
yield return((object)sync0);
if (op0.Result)
{
if (this.Entity.Storage.IsPickLimited(member, this.Operation.ItemClass, op0.SlotInfo.Slot, this.Operation.Amount))
{
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Limited, this.Operation.ItemClass, this.Operation.Amount);
this.Entity.Storage.Processing = false;
this.Finished = true;
yield return((object)new FailMessage("[PickGuildStorageItemProcessor] Entity.Storage.IsPickLimited")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
yield break;
}
else
{
color1 = op0.SlotInfo.Color1;
color2 = op0.SlotInfo.Color2;
color3 = op0.SlotInfo.Color3;
reduceDurability = op0.SlotInfo.MaxDurability - op0.SlotInfo.Durability;
maxDurabilityBonus = op0.SlotInfo.MaxDurabilityBonus;
tab = (byte)op0.SlotInfo.Tab;
slot = op0.SlotInfo.Slot;
loggingItemClass = op0.ItemClassEX;
}
}
else
{
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Invalid, this.Operation.ItemClass, this.Operation.Amount);
member.SendOperationFailedDialog("GuildStorageFail_InternalError");
this.Entity.Storage.Processing = false;
this.Finished = true;
yield return((object)new FailMessage("[PickGuildStorageItemProcessor] op0.Result")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
yield break;
}
}
else if (this.Entity.Storage.IsPickLimited(member, this.Operation.ItemClass, 0, this.Operation.Amount))
{
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_Invalid, this.Operation.ItemClass, this.Operation.Amount);
this.Entity.Storage.Processing = false;
this.Finished = true;
yield return((object)new FailMessage("[PickGuildStorageItemProcessor] Entity.Storage.IsPickLimited")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
yield break;
}
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.TransferFrom, this.Operation.ItemClass, this.Operation.Amount, color1, color2, color3, reduceDurability, maxDurabilityBonus);
TransferToSystem op1 = new TransferToSystem((ICollection <TransferItemInfo>) new List <TransferItemInfo>()
{
new TransferItemInfo(this.Operation.ItemID, this.Operation.ItemClass, this.Operation.Amount)
}, TransferToSystem.SourceEnum.GuildStorage);
OperationSync sync = new OperationSync()
{
Connection = this.Entity.Storage.ItemConn,
Operation = (Operation)op1
};
yield return((object)sync);
if (!op1.Result)
{
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_TransferFail, this.Operation.ItemClass, this.Operation.Amount, color1, color2, color3, reduceDurability, maxDurabilityBonus);
member.SendOperationFailedDialog("GuildStorageFail_TransferFailed");
this.Entity.Storage.Processing = false;
this.Finished = true;
yield return((object)new FailMessage("[PickGuildStorageItemProcessor] op1.Result")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else
{
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.TransferTo, this.Operation.ItemClass, this.Operation.Amount, color1, color2, color3, reduceDurability, maxDurabilityBonus);
List <long> itemList = new List <long>();
foreach (TransferredItemInfo transferredItem in (IEnumerable <TransferredItemInfo>)op1.TransferredItemList)
{
itemList.Add(transferredItem.ItemID);
}
TransferFromSystem op2 = (int)this.Operation.TargetTab != (int)byte.MaxValue ? (this.Operation.TargetSlot != -1 ? new TransferFromSystem((ICollection <long>)itemList, true, this.Operation.TargetTab, this.Operation.TargetSlot, this.Operation.TargetSlot + 1, TransferFromSystem.SourceEnum.GuildStorage) : new TransferFromSystem((ICollection <long>)itemList, true, this.Operation.TargetTab, 0, 48, TransferFromSystem.SourceEnum.GuildStorage)) : new TransferFromSystem((ICollection <long>)itemList, true, byte.MaxValue, 0, 0, TransferFromSystem.SourceEnum.GuildStorage);
OperationSync sync2 = new OperationSync()
{
Connection = member.PlayerConn,
Operation = (Operation)op2
};
yield return((object)sync2);
if (!op2.Result)
{
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_TransferFail, this.Operation.ItemClass, this.Operation.Amount, color1, color2, color3, reduceDurability, maxDurabilityBonus);
if (op2.FailReason == TransferFromSystem.FailReasonEnum.NoEmptySlot)
{
member.SendOperationFailedDialog("GuildStorageFail_NoEmptySlot");
}
else
{
member.SendOperationFailedDialog("GuildStorageFail_TransferFailed");
}
TransferFromSystem op3 = new TransferFromSystem((ICollection <long>)itemList, false, tab, slot, slot + 1, TransferFromSystem.SourceEnum.GuildStorage);
OperationSync sync3 = new OperationSync()
{
Connection = this.Entity.Storage.ItemConn,
Operation = (Operation)op3
};
yield return((object)sync3);
if (op3.Result)
{
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_TransferFail_Recovered, this.Operation.ItemClass, this.Operation.Amount, color1, color2, color3, reduceDurability, maxDurabilityBonus);
}
else
{
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Error_TransferFail_RecoverFail, this.Operation.ItemClass, this.Operation.Amount, color1, color2, color3, reduceDurability, maxDurabilityBonus);
}
this.Entity.Storage.Processing = false;
this.Finished = true;
yield return((object)new FailMessage("[PickGuildStorageItemProcessor] op2.Result")
{
Reason = FailMessage.ReasonCode.LogicalFail
});
}
else
{
storage.AddGuildStorageLedger(this.Operation.OwnerCID, GuildStorageOperationCode.PickGuildItem, GuildStorageEventCode.Done, this.Operation.ItemClass, this.Operation.Amount, color1, color2, color3, reduceDurability, maxDurabilityBonus);
this.Entity.Storage.ReportPickItem(member.CharacterName, loggingItemClass, this.Operation.Amount, color1, color2, color3);
this.Entity.Storage.Processing = false;
this.Finished = true;
yield return((object)new OkMessage());
}
}
}
}
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()
{
ArraySegment <byte> response = new ArraySegment <byte>(base.Operation.Buffer);
string errorType = "";
string errorValue = "";
bool toClose = false;
if (response.Array.Length >= 4 && response.Array[0] == 204 && response.Array[1] == 20 && response.Array[2] == 234 && response.Array[3] == 30)
{
errorType = "ClientCheat";
errorValue = Encoding.ASCII.GetString(response.Array, 4, response.Array.Length - 4);
if (Log <RespondProcessor> .Logger.IsWarnEnabled)
{
string text = "";
for (int i = 0; i < response.Array.Length; i++)
{
text += string.Format("{0:X2} ", response.Array[i]);
}
Log <RespondProcessor> .Logger.WarnFormat("Client Hack/Cheat Detected {{ Entity.ID = {0:o} }} Msg = {1}", base.Entity.ID, text);
}
}
else
{
AntiCpXSvr.Recommend recommend;
AntiCpXSvr.Error error = AntiCpXSvr.VerifyResponse(base.Entity.Handle, response, out recommend);
if (recommend == AntiCpXSvr.Recommend.KeepSession)
{
if (Log <RespondProcessor> .Logger.IsInfoEnabled)
{
Log <RespondProcessor> .Logger.InfoFormat("AntiCpXSvr.VerifyResponse(clientHandle, responseBuffer, out recommend = {0}) = {1} {{ Entity.ID = {2:o} }}", recommend, error, base.Entity.ID);
}
}
else
{
if (Log <RespondProcessor> .Logger.IsWarnEnabled)
{
Log <RespondProcessor> .Logger.WarnFormat("AntiCpXSvr.VerifyResponse(clientHandle, responseBuffer, out recommend = {0}) = {1} {{ Entity.ID = {2:o} }}", recommend, error, base.Entity.ID);
}
errorType = error.ToString();
toClose = true;
}
}
if (errorType.Length > 0)
{
using (HackShieldErrorLogDataContext hackShieldErrorLogDataContext = new HackShieldErrorLogDataContext())
{
try
{
hackShieldErrorLogDataContext.AddHackShieldError(new long?(base.Operation.CharacterID), errorType, errorValue);
}
catch (Exception ex)
{
Log <RespondProcessor> .Logger.Error(string.Format("Error while making log : [CharacterID = {0}]", base.Operation.CharacterID), ex);
}
}
if (toClose)
{
SendPacket packet;
if (!base.Operation.IsCheat)
{
packet = SendPacket.Create <SystemMessage>(new SystemMessage(SystemMessageCategory.Dialog, "GameUI_HackSheild_Error"));
}
else
{
packet = SendPacket.Create <SystemMessage>(new SystemMessage(SystemMessageCategory.Notice, "GameUI_HackSheild_Contact"));
}
OperationSync sync = new OperationSync
{
Connection = base.Entity.FrontendConn,
Operation = packet
};
yield return(sync);
Scheduler.Schedule(this.Service.Thread, Job.Create(new Action(base.Entity.Entity.Close)), 3000);
}
}
base.Finished = true;
yield break;
}
