internal void NotifyCreated(ItemRecord record)
{
OnRecordCreated(record);
var evt = Created;
if (evt != null)
{
evt(record);
}
}
private void LogItemEvent(GuildBankLogEntryType type, Character actor, ItemRecord record, int amount, GuildBankTab intoTab)
{
var entry = new GuildBankLogEntry(Bank.Guild.Id)
{
Type = type,
Actor = actor,
BankLog = this,
DestinationTab = intoTab,
ItemEntryId = (int)record.EntryId,
ItemStackCount = (int)amount,
Created = DateTime.Now
};
lock (moneyLogEntries)
{
moneyLogEntries.Insert(entry);
}
}
private static void RemoveDrop(WorldClient client, string[] args)
{
if (args.Length < 2)
{
client.Character.Reply("Remove a drop from a monster");
client.Character.Reply("» .drops rmdrop|rm|rd $ItemId $MonsterId");
client.Character.Reply("- <b>$ItemId</b> ⇒ The ID of the item.");
client.Character.Reply("- <b>$MonsterId</b> ⇒ The ID of the monster.");
return;
}
ushort itemId = ushort.Parse(args[1]);
ItemRecord item = ItemRecord.GetItem(itemId);
if (args.Length != 3)
{
int count = 0;
foreach (MonsterRecord monster in MonsterRecord.Monsters)
{
MonsterDrop drop = monster.Drops.Find(d => d.ItemId == itemId);
if (drop != null)
{
monster.Drops.Remove(drop);
count++;
client.Character.Reply($" - Removed drop from monster {monster.Name} ({monster.Id}).");
monster.UpdateInstantElement();
}
}
client.Character.Reply($"Removed drop '{item.Name}' ({item.Id}) from {count} monsters.");
}
else
{
ushort monsterId = ushort.Parse(args[2]);
MonsterRecord monsterRecord = MonsterRecord.GetMonster(monsterId);
monsterRecord.Drops.RemoveAll(d => d.ItemId == itemId);
monsterRecord.UpdateInstantElement();
client.Character.Reply($"Successfully removed drop '{item.Name}' ({item.Id}) from monster '{monsterRecord.Name}' {monsterId}");
}
}
/// <summary>
/// Initializes a new Item
/// </summary>
internal void InitItem(ItemTemplate template, Character owner, int amount)
{
m_record = ItemRecord.CreateRecord();
EntryId = m_record.EntryId = template.Id;
Type |= ObjectTypes.Item;
m_template = template;
Durability = m_template.MaxDurability;
MaxDurability = m_template.MaxDurability;
Flags = m_template.Flags;
TextId = m_template.PageTextId;
Amount = amount;
OwningCharacter = owner;
EntityId = m_record.EntityId;
// set charges to max
if (m_template.UseSpell != null && m_template.UseSpell.HasCharges)
{
m_record.Charges = m_template.UseSpell.Charges;
SetSpellCharges(m_template.UseSpell.Index, m_template.UseSpell.Charges);
}
var randomEnchants = m_template.RandomPrefixes;
if (randomEnchants != null)
{
ApplyRandomEnchants(randomEnchants, EnchantSlot.PropSlot2, EnchantSlot.PropSlot4);
}
randomEnchants = m_template.RandomSuffixes;
if (randomEnchants != null)
{
if (ApplyRandomEnchants(randomEnchants, EnchantSlot.PropSlot0, EnchantSlot.PropSlot2))
{
RandomPropertiesId = m_enchantments[(int)EnchantSlot.PropSlot0].Entry.Id;
}
}
template.NotifyCreated(m_record);
OnInit();
}
public void Initialize(ItemRecord item, int quantity, Action unityAction)
{
this.item = item;
Quantity = quantity;
image.sprite = item.Icon;
text.text = quantity.ToString();
onClick = unityAction;
if (quantity < 2)
{
text.gameObject.SetActive(false);
}
else
{
text.text = quantity.ToString();
}
}
public ActionResult ConfirmPay(int?addressId, int?cardId)
{
var cart = db.GetUserProfile(User.Identity.Name).UserData.ShoppingCart;
//新建订单
var order = new Order()
{
CreateDate = DateTime.Now, UserData = cart.UserData, ItemRecordSets = new List <ItemRecordSet>()
};
db.Orders.Add(order);
//将购物车数据添加到订单并生成历史记录
foreach (var set in cart.ItemSets)
{
var r = new ItemRecord {
Item = set.Item, HistoryPrice = set.Price, IsDigital = set.IsDigital
};
var rset = new ItemRecordSet {
ItemRecord = r, Count = set.Count
};
order.ItemRecordSets.Add(rset);
}
//查找是否数字版，添加到个人拥有的数字列表
foreach (var set in cart.ItemSets)
{
if (set.IsDigital)
{
cart.UserData.OwnedDigitalItems.Add(new OwnedDigitalItem {
Item = set.Item, UserData = cart.UserData
});
}
}
//清空购物车数据
var list = cart.ItemSets.ToList();
foreach (var item in list)
{
db.ItemSets.Remove(item);
}
db.SaveChanges();
return(RedirectToAction("Details", "Order", new { id = order.Id }));
}
public override void Initialize(System.IO.BinaryReader reader, RecordHeader header)
{
var index = 0;
ItemRecord item = null;
var itemChance = 0;
while (reader.BaseStream.Position < header.DataEndPos)
{
var type = (SubRecordType)reader.ReadInt32();
var size = reader.ReadInt32();
switch (type)
{
case SubRecordType.Id:
name = reader.ReadString(size);
break;
case SubRecordType.Data:
data = new LeveledItemRecordData(reader);
break;
case SubRecordType.NextName:
chanceNone = reader.ReadByte();
break;
case SubRecordType.Index:
count = reader.ReadInt32();
items = new Tuple <ItemRecord, int> [count];
break;
case SubRecordType.ItemName:
item = Record.GetRecord <ItemRecord>(reader.ReadString(size));
break;
case SubRecordType.IntValue:
itemChance = reader.ReadInt16();
items[index] = new Tuple <ItemRecord, int>(item, itemChance);
index++;
break;
}
}
}
bool IsSetCompleted(uint transmogSetId)
{
var transmogSetItems = Global.DB2Mgr.GetTransmogSetItems(transmogSetId);
if (transmogSetItems.Empty())
{
return(false);
}
int[] knownPieces = new int[EquipmentSlot.End];
for (var i = 0; i < EquipmentSlot.End; ++i)
{
knownPieces[i] = -1;
}
foreach (TransmogSetItemRecord transmogSetItem in transmogSetItems)
{
ItemModifiedAppearanceRecord itemModifiedAppearance = CliDB.ItemModifiedAppearanceStorage.LookupByKey(transmogSetItem.ItemModifiedAppearanceID);
if (itemModifiedAppearance == null)
{
continue;
}
ItemRecord item = CliDB.ItemStorage.LookupByKey(itemModifiedAppearance.ItemID);
if (item == null)
{
continue;
}
int transmogSlot = Item.ItemTransmogrificationSlots[(int)item.inventoryType];
if (transmogSlot < 0 || knownPieces[transmogSlot] == 1)
{
continue;
}
(var hasAppearance, bool isTemporary) = HasItemAppearance(transmogSetItem.ItemModifiedAppearanceID);
knownPieces[transmogSlot] = (hasAppearance && !isTemporary) ? 1 : 0;
}
return(!knownPieces.Contains(0));
}
void DisplayItemsFoldout()
{
if (currentItems == null || currentItems.Length == 0)
{
EditorGUILayout.HelpBox("No items found.", MessageType.Info);
return;
}
for (int i = 0; i < currentItems.Length; i++)
{
ItemRecord itemRecord = currentItems[i] as ItemRecord;
DaggerfallUnityItem item = new DaggerfallUnityItem(itemRecord);
int equippedIndex = GetEquippedIndex(itemRecord);
//if (equippedIndex == -1)
// continue;
//string savedName = itemRecord.ParsedData.name;
//ItemGroups itemGroup = (ItemGroups)itemRecord.ParsedData.category1;
//int itemIndex = itemRecord.ParsedData.category2;
//ItemDescription itemDesc = itemHelper.GetItemDescription(itemGroup, itemIndex);
////string cat1 = ((ItemGroups)itemRecord.ParsedData.category1).ToString();
////string cat2 = itemRecord.ParsedData.category2.ToString();
////string subName = ItemHelper.ToSubCategoryName((ItemGroups)itemRecord.ParsedData.category1, itemRecord.ParsedData.category2);
////string other = itemRecord.ParsedData.category2.ToString();
//string textLabel = string.Format(
// "{0} [mat=0x{1:X4}]",
// itemHelper.ResolveItemName(itemRecord.ParsedData),
// itemRecord.ParsedData.material);
string textLabel = string.Format("Item [{0}]", item.LongName);
if (equippedIndex != -1)
{
textLabel = "*" + textLabel;
}
//string textLabel = itemHelper.GetClassicItemName(itemRecord.ParsedData);
EditorGUILayout.LabelField(textLabel);
}
}
public async Task <Item> AddAsync(string collectionName, string data, string userId, DateTimeOffset datetime)
{
using (var tran = await _db.Database.BeginTransactionAsync())
{
var item = new Item
{
Id = Helper.CreateKey(),
CollectionName = collectionName,
CreatedAt = datetime,
UpdatedAt = datetime,
CreatedBy = userId,
UpdatedBy = userId,
IsValid = true,
};
await _db.AddAsync(item);
await _db.SaveChangesAsync();
var record = new ItemRecord
{
Id = Helper.CreateKey(),
ItemId = item.Id,
Data = data,
CreatedAt = datetime,
CreatedBy = userId,
};
item.Data = data;
item.CurrentId = record.Id;
await _db.AddAsync(record);
await _db.SaveChangesAsync();
tran.Commit();
_db.Entry(item).State = EntityState.Detached;
return(item);
}
}
/// <summary>
/// A recursive one ;)
/// </summary>
public int[] RemoveRecipeItem(ItemRecord record)
{
List <int> results = new List <int>();
foreach (var itemRecipe in record.RecipeItemRecords)
{
var removed = RemoveItem(itemRecipe.ItemId);
if (removed != null)
{
results.Add(removed.Record.GetTotalPrice());
}
else
{
results.AddRange(RemoveRecipeItem(itemRecipe));
}
}
return(results.ToArray());
}
public void SendMail(string subject, uint money, ItemRecord item, string body)
{
MailMessage mailMessage = new MailMessage(subject, body)
{
SenderId = (uint)this.HouseFaction,
ReceiverId = this.OwnerLowId,
MessageStationary = MailStationary.Auction,
MessageType = MailType.Auction,
IncludedMoney = money,
LastModifiedOn = new DateTime?(),
SendTime = DateTime.Now,
DeliveryTime = DateTime.Now
};
if (item != null)
{
mailMessage.AddItem(item);
}
mailMessage.Send();
}
int GetEquippedIndex(ItemRecord record)
{
if (characterRecord == null || record.RecordType != RecordTypes.Item || record.Parent == null)
{
return(-1);
}
// Try to match item RecordID with equipped item IDs
// Item RecordID must be shifted right 8 bits
uint[] equippedItems = characterRecord.ParsedData.equippedItems;
for (int i = 0; i < equippedItems.Length; i++)
{
if (equippedItems[i] == record.RecordRoot.RecordID)
{
return(i);
}
}
return(-1);
}
public async Task <ItemRecord> InsertRecord(ItemRecord newRecord)
{
var attributes = ConvertToAttributeCollection(newRecord);
var request = new PutItemRequest
{
TableName = _tableName,
Item = attributes,
ConditionExpression = $"attribute_not_exists({nameof(newRecord.Id).ToLower()})" //only create new
};
var response = await _dynamoClient.PutItemAsync(request);
if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
return(newRecord);
}
throw new Exception($"Insert failed, server returned status {response.HttpStatusCode}");
}
public void SerializeDeserializeObjTest()
{
// arrange
var stream = new MemoryStream();
var source = new ItemRecord
{
Name = "Test",
TemplateID = new Guid()
};
// act
Serializer.Serialize(stream, source);
stream.Seek(0, SeekOrigin.Begin);
var copy = Serializer.Deserialize <ItemRecord>(stream);
// assert
Assert.AreNotEqual(source, copy);
Assert.AreEqual(source.Name, copy.Name);
Assert.AreEqual(source.TemplateID, copy.TemplateID);
}
public static string GetNameString(short id, int amount)
{
ItemRecord data = World.Instance.EIF.GetItemRecordByID(id);
switch (data.ID)
{
case 1:
return(string.Format("{0} {1}", amount, data.Name));
default:
if (amount == 1)
{
return(data.Name);
}
if (amount > 1)
{
return(string.Format("{0} x{1}", data.Name, amount));
}
throw new Exception("There shouldn't be an item in the inventory with amount zero");
}
}
private void AddItem(Update update, SubscriberRecord subscriberRecord)
{
var item = new ItemRecord
{
BotInstanceId = BotInstanceId,
MessageId = update.Message.MessageId,
ChatId = subscriberRecord.ChatId,
};
if (update.Message.Type == MessageType.Photo)
{
item.ItemType = ItemRecord.ItemTypes.IMAGE;
item.FileId = update.Message.Photo[update.Message.Photo.Length - 1].FileId;
ItemsQueueRepo.Add(subscriberRecord, item);
}
else if (update.Message.Type == MessageType.Text)
{
var isUri = Uri.IsWellFormedUriString(update.Message.Text, UriKind.RelativeOrAbsolute);
item.ItemType = ItemRecord.ItemTypes.WEB_PAGE;
item.Text = update.Message.Text;
}
else if (update.Message.Type == MessageType.Document)
{
switch (update.Message.Document.MimeType)
{
case "application/pdf":
item.ItemType = ItemRecord.ItemTypes.PDF_FILE;
item.FileId = update.Message.Document.FileId;
ItemsQueueRepo.Add(subscriberRecord, item);
break;
case "image/jpeg":
case "image/png":
item.ItemType = ItemRecord.ItemTypes.IMAGE;
item.FileId = update.Message.Document.FileId;
ItemsQueueRepo.Add(subscriberRecord, item);
break;
}
}
}
private static void UpdateDrop(WorldClient client, string[] args)
{
if (args.Length < 6)
{
client.Character.Reply("Add a drop to a set of monsters");
client.Character.Reply("» .drops updatedrop|ud $ItemId $MonsterId $DropRate $MinPP $MinCount $MaxCount");
client.Character.Reply(" - <b>$ItemId</b> ⇒ The ID of the item.");
client.Character.Reply(" - <b>$MonsterId</b> ⇒ The ID of the item.");
client.Character.Reply(" - <b>$DropRate</b> ⇒ The drop percent [0, 100].");
client.Character.Reply(" - <b>$MinPP</b> ⇒ The min PP value0.");
client.Character.Reply(" - <b>$MinCount</b> ⇒ Minimum number of dropped items.");
client.Character.Reply(" - <b>$MaxCount</b> ⇒ Maximum number of dropped items.");
return;
}
ushort itemId = ushort.Parse(args[1]);
ushort monsterId = ushort.Parse(args[2]);
short dropRate = short.Parse(args[3]);
int pp = int.Parse(args[4]);
int minCount = int.Parse(args[5]);
int maxCount = int.Parse(args[6]);
ItemRecord item = ItemRecord.GetItem(itemId);
MonsterRecord monsterRecord = MonsterRecord.GetMonster(monsterId);
MonsterDrop monsterDrop = monsterRecord.Drops.Find(d => d.ItemId == itemId);
monsterDrop.PercentDropForGrade1 = dropRate;
monsterDrop.PercentDropForGrade2 = (short)(dropRate + 2);
monsterDrop.PercentDropForGrade3 = (short)(dropRate + 4);
monsterDrop.PercentDropForGrade4 = (short)(dropRate + 6);
monsterDrop.PercentDropForGrade5 = (short)(dropRate + 8);
monsterDrop.Count = minCount;
monsterDrop.DropLimit = maxCount;
monsterDrop.ProspectingLock = pp;
monsterRecord.UpdateInstantElement();
client.Character.Reply($"Successfully removed drop '{item.Name}' ({item.Id}) from monster '{monsterRecord.Name}' {monsterId}");
}
/// <summary>Initializes a new Item</summary>
internal void InitItem(ItemTemplate template, Character owner, int amount)
{
m_record = ItemRecord.CreateRecord();
EntryId = m_record.EntryId = template.Id;
Type |= ObjectTypes.Item;
m_template = template;
Durability = m_template.MaxDurability;
MaxDurability = m_template.MaxDurability;
Flags = m_template.Flags;
TextId = m_template.PageTextId;
Amount = amount;
OwningCharacter = owner;
EntityId = m_record.EntityId;
if (m_template.UseSpell != null && m_template.UseSpell.HasCharges)
{
m_record.Charges = m_template.UseSpell.Charges;
SetSpellCharges(m_template.UseSpell.Index, m_template.UseSpell.Charges);
}
template.NotifyCreated(m_record);
OnInit();
}
public IActionResult Update(long id, [FromBody] ItemRecord item)
{
if (item == null || item.Id != id)
{
return(BadRequest());
}
var existingItem = m_Context.Items.FirstOrDefault(t => t.Id == id);
if (existingItem == null)
{
return(NotFound());
}
existingItem.ItemName = item.ItemName;
existingItem.Price = item.Price;
m_Context.Items.Update(existingItem);
m_Context.SaveChanges();
return(new NoContentResult());
}
public static void JoyCommand(string value, WorldClient client)
{
List <ushort> spells = new List <ushort>();
var items = ItemRecord.GetItems(ItemTypeEnum.FÉE_D_ARTIFICE);
foreach (ItemRecord item in items)
{
SpellRecord spell = SpellRecord.Spells.Find(x => x.Name == item.Name);
if (spell != null)
{
spells.Add(spell.Id);
}
}
foreach (ushort spell in spells)
{
Thread.Sleep(1000);
client.Character.SpellAnim(spell);
}
}
/// <summary>
/// Créer un item mination lié a un joueur.
/// </summary>
/// <param name="template"></param>
/// <param name="quantity"></param>
/// <param name="characterId"></param>
/// <param name="monster"></param>
/// <param name="monsterGradeId"></param>
/// <returns></returns>
public static CharacterItemRecord CreateMinationItem(ItemRecord template, uint quantity, long characterId, MonsterRecord monster, sbyte monsterGradeId)
{
CharacterItemRecord item;
if (monster.IsMiniBoss)
{
item = MinationItemMiniBossTemplate.GetCharacterItem(characterId, quantity, true);
}
else if (monster.IsBoss)
{
item = MinationItemBossTemplate.GetCharacterItem(characterId, quantity, true);
}
else
{
item = MinationItemTemplate.GetCharacterItem(characterId, quantity, true);
}
item.Effects.Clear();
item.AddEffect(new EffectMination(monster.Id, monster.Name, monsterGradeId));
item.AddEffect(new EffectMinationLevel(1, 0, 0));
item.AddEffectInteger(EffectsEnum.Effect_Followed, monster.Id);
return(item);
}
public static void HandleMimicryObjectEraseRequest(MimicryObjectEraseRequestMessage message, WorldClient client)
{
CharacterItemRecord item = client.Character.Inventory.GetItem(message.hostUID);
if (message.hostPos != 63)
{
client.Character.RefreshActorOnMap();
client.Character.RefreshStats();
}
if (client.Character.Inventory.GetEquipedItems().Contains(item))
{
client.Character.Inventory.SetItemPosition(item.UId, CharacterInventoryPositionEnum.INVENTORY_POSITION_NOT_EQUIPED, 1);
}
item.RemoveAllEffects(EffectsEnum.Effect_ChangeAppearence1151);
CharacterItemRecord newItem = (CharacterItemRecord)item.CloneWithoutUID();
newItem.AppearanceId = ItemRecord.GetItem(newItem.GId).AppearanceId;
client.Character.Inventory.RemoveItem(item, item.Quantity);
client.Character.Inventory.AddItem(newItem, 1);
client.Character.RefreshActorOnMap();
client.Character.RefreshStats();
}
public CharacterItemRecord Add(ushort gid, uint quantity, bool notif = true, bool refresh = true)
{
ItemRecord template = ItemRecord.GetItem(gid);
if (template == null)
{
Character.Reply("L'item n'éxiste pas");
return(null);
}
var newObjitem = template.GenerateRandomObjectItem();
newObjitem.quantity = quantity;
CharacterItemRecord newItem = new CharacterItemRecord(newObjitem, Character.Id);
ItemCustomEffects.Instance.Init(newItem);
Add(newItem, refresh);
if (notif)
{
Character.Reply("Vous avez obtenu " + quantity + " " + template.Name);
}
return(newItem);
}
public ItemSearchDocument(ItemRecord record)
{
Id = record.GTIN;
// we want to do some work in setting
// up the values that will be analyzed
// thinking about what the user might
// type into our search input
Names = new[]
{
record.Name,
record.BrandName
}
.Union(record.Name.Split(' '))
.Union(record.BrandName.Split(' '))
.Distinct(StringComparer.OrdinalIgnoreCase)
.ToArray();
Name = record.Name;
BrandName = record.BrandName;
Data = record;
}
public async Task <ActionResult <ItemDetail> > PostItemDetail([FromBody] dynamic item)
{
ItemRecord itemRecord = JsonConvert.DeserializeObject <ItemRecord>(item.ToString());
var accessToken = Request.Headers["Authorization"].ToString().Replace("Bearer", "").Trim();
//var otp = GetOtp(accessToken);
var identity = HttpContext.User.Identity as ClaimsIdentity;
// Gets list of claims.
IEnumerable <Claim> claim = identity.Claims;
var dataStoreId = claim
.Where(x => x.Type == "DataStoreId")
.FirstOrDefault().Value;
var dataStoreItem = _context.DataStoreItem
.Where(d => d.DataStoreId == int.Parse(dataStoreId) &&
d.StoreItemName == itemRecord.StoreItemName &&
d.Completed == false)
.FirstOrDefault();
if (dataStoreItem == null)
{
return(NotFound());
}
ItemDetail itemDetail = new ItemDetail();
itemDetail.DataStoreItemId = dataStoreItem.Id;
itemDetail.ItemDetailName = itemRecord.ItemDetailName;
itemDetail.ItemDetailValue = _protector.Protect(itemRecord.ItemDetailValue);
_context.ItemDetail.Add(itemDetail);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetItemDetail", new { id = itemDetail.Id }, itemDetail));
}
/// <summary>
///
/// </summary>
public void LoadItems()
{
if (!_hasItemLoaded)
{
try
{
foreach (var itemRecord in ItemRecord.LoadAuctionedItems())
{
_auctionedItems.Add(itemRecord.EntityLowId, itemRecord);
}
_hasItemLoaded = true;
}
catch (Exception e)
{
RealmDBMgr.OnDBError(e);
foreach (var itemRecord in ItemRecord.LoadAuctionedItems())
{
_auctionedItems.Add(itemRecord.EntityLowId, itemRecord);
}
_hasItemLoaded = true;
}
}
}
/// <summary>Loads an already created item without owner</summary>
/// <param name="record"></param>
/// <param name="template"></param>
internal void LoadItem(ItemRecord record, ItemTemplate template)
{
m_record = record;
EntityId = record.EntityId;
m_template = template;
EntryId = m_template.Id;
Type |= ObjectTypes.Item;
SetUInt32(ItemFields.FLAGS, (uint)record.Flags);
SetInt32(ItemFields.DURABILITY, record.Durability);
SetInt32(ItemFields.DURATION, record.Duration);
SetInt32(ItemFields.STACK_COUNT, record.Amount);
SetInt32(ItemFields.PROPERTY_SEED, record.RandomSuffix);
SetInt32(ItemFields.RANDOM_PROPERTIES_ID, record.RandomProperty);
SetInt64(ItemFields.CREATOR, record.CreatorEntityId);
SetInt64(ItemFields.GIFTCREATOR, record.GiftCreatorEntityId);
ItemText = record.ItemText;
if (m_template.UseSpell != null)
{
SetSpellCharges(m_template.UseSpell.Index, record.Charges);
}
MaxDurability = m_template.MaxDurability;
OnLoad();
}
private bool AddItemToSlot(int slot, ItemRecord item, int count = 1)
{
//this is ADD item - don't allow adding items that have been added already
if (slot < 0 || m_childItems.Count(_item => _item.Slot == slot) > 0)
{
return(false);
}
List <Tuple <int, int> > points;
if (!_fitsInSlot(slot, item.Size, out points))
{
return(false);
}
points.ForEach(point => m_filledSlots[point.Item1, point.Item2] = true); //flag that the spaces are taken
m_inventoryKey.SetValue(string.Format("item{0}", slot), item.ID, RegistryValueKind.String); //update the registry
m_childItems.Add(new EOInventoryItem(m_api, slot, item, new InventoryItem {
amount = count, id = (short)item.ID
}, this)); //add the control wrapper for the item
m_childItems[m_childItems.Count - 1].DrawOrder = (int)ControlDrawLayer.DialogLayer - (2 + slot % INVENTORY_ROW_LENGTH);
return(true);
}
public void TesT5()
{
var root = new ItemRecord {
ID = ItemIDs.RootItemID, Name = "Sitecore"
};
var content1 = new ItemRecord {
ID = Guid.NewGuid(), Name = "content", ParentID = root.ID
};
var content2 = new ItemRecord {
ID = Guid.NewGuid(), Name = "content", ParentID = root.ID
};
var home = new ItemRecord {
ID = Guid.NewGuid(), Name = "Home", ParentID = content2.ID
};
var namesCache = new ChildrenDataSet(new ItemDefinitions(root, content1, content2, home));
// act
Guid id;
var result = ItemPathResolver.TryResolvePath("/sitecore/content/home", namesCache, out id);
Assert.IsTrue(result);
Assert.AreEqual(home.ID, id);
}
public static void HandleBuyItemRequestMessage(BuyItemRequestMessage message, LoLClient client)
{
ItemRecord itemRecord = ItemRecord.GetItemRecord(message.itemId);
if (client.Hero.Stats.Gold >= itemRecord.Price)
{
int[] recipePrices = client.Hero.Inventory.RemoveRecipeItem(itemRecord);
Item itemResult = client.Hero.Inventory.AddItem(itemRecord);
if (itemResult != null)
{
int priceTotal = itemRecord.GetTotalPrice();
foreach (var price in recipePrices)
{
priceTotal -= price;
}
client.Hero.RemoveGold(priceTotal);
client.Hero.UpdateStats();
}
}
}
/// <summary>
/// Checks if the given amount of the given item stack can be stored in the given slot (optionally with merging),
/// without necessitating an Item swap. No actual store takes place.
/// </summary>
/// <param name="item">The <see cref="ItemRecord" /> to store.</param>
/// <param name="amount">The amount of items from the stack to store.</param>
/// <param name="slot">The slotId where you want to store.</param>
/// <param name="allowMerge">Whether or not to try and merge the stacks.</param>
/// <returns>true if no Item swap is needed.</returns>
public bool CheckStoreItemInSlot(ItemRecord item, int amount, int slot, bool allowMerge)
{
if (slot >= GuildMgr.MAX_BANK_TAB_SLOTS) return false;
if (item.Amount < amount) return false; // Cheater!
var curItem = this[slot];
if (curItem == null) return true;
if (allowMerge && this[slot].EntryId == item.EntryId)
{
// try to merge the stacks.
var freeSpace = (int)curItem.Template.MaxAmount - curItem.Amount;
return (freeSpace >= amount);
}
// gonna swap
return false;
}
private void LogItemEvent(GuildBankLogEntryType type, Character actor, ItemRecord record, int amount, GuildBankTab intoTab)
{
var entry = new GuildBankLogEntry {
Type = type,
Actor = actor,
BankLog = this,
DestinationTab = intoTab,
ItemEntryId = (int)record.EntryId,
ItemStackCount = (int)amount,
TimeStamp = DateTime.Now
};
MoneyLogEntries.Push(entry);
MoneyLogEntries = EnsureStackSize(MoneyLogEntries);
}
public void LogEvent(GuildBankLogEntryType type, Character member, uint money, ItemRecord item, int amount, GuildBankTab intoTab)
{
switch (type)
{
case GuildBankLogEntryType.None:
{
break;
}
case GuildBankLogEntryType.DepositItem:
{
LogItemEvent(type, member, item, amount, intoTab);
break;
}
case GuildBankLogEntryType.WithdrawItem:
{
LogItemEvent(type, member, item, amount, intoTab);
break;
}
case GuildBankLogEntryType.MoveItem:
{
LogItemEvent(type, member, item, amount, intoTab);
break;
}
case GuildBankLogEntryType.DepositMoney:
{
LogMoneyEvent(type, member, money);
break;
}
case GuildBankLogEntryType.WithdrawMoney:
{
LogMoneyEvent(type, member, money);
break;
}
case GuildBankLogEntryType.MoneyUsedForRepairs:
{
LogMoneyEvent(type, member, money);
break;
}
case GuildBankLogEntryType.MoveItem_2:
{
LogItemEvent(type, member, item, amount, intoTab);
break;
}
case GuildBankLogEntryType.Unknown1:
{
break;
}
case GuildBankLogEntryType.Unknown2:
{
break;
}
default:
{
break;
}
} // end switch
} // end method
public void LogEvent(GuildBankLogEntryType type, Character chr, ItemRecord item, int amount, GuildBankTab intoTab)
{
LogEvent(type, chr, 0, item, amount, intoTab);
}
private void OnRecordCreated(ItemRecord record)
{
if (IsCharter)
{
if (!record.IsNew)
{
// this is executed in the IO-context
PetitionRecord.LoadRecord(record.OwnerId);
}
}
}
public EOInventoryItem(PacketAPI api, int slot, ItemRecord itemData, InventoryItem itemInventoryInfo, EOInventory inventory)
: base(null, null, inventory)
{
m_api = api;
m_itemData = itemData;
m_inventory = itemInventoryInfo;
Slot = slot;
UpdateItemLocation(Slot);
m_itemgfx = GFXLoader.TextureFromResource(GFXTypes.Items, 2 * itemData.Graphic, true);
m_highlightBG = new Texture2D(Game.GraphicsDevice, DrawArea.Width - 3, DrawArea.Height - 3);
Color[] highlight = new Color[(drawArea.Width - 3) * (drawArea.Height - 3)];
for (int i = 0; i < highlight.Length; ++i) { highlight[i] = Color.FromNonPremultiplied(200, 200, 200, 60); }
m_highlightBG.SetData(highlight);
_initItemLabel();
m_recentClickTimer = new Timer(
_state => { if (m_recentClickCount > 0) Interlocked.Decrement(ref m_recentClickCount); }, null, 0, 1000);
}
private bool _addItemToSlot(bool[,] filledSlots, int slot, ItemRecord item, int count = 1)
{
//this is ADD item - don't allow adding items that have been added already
if (slot < 0 || m_childItems.Count(_item => _item.Slot == slot) > 0) return false;
List<Tuple<int, int>> points;
if (!_fitsInSlot(filledSlots, slot, item.Size, out points)) return false;
points.ForEach(point => filledSlots[point.Item1, point.Item2] = true); //flag that the spaces are taken
m_inventoryKey.SetValue(string.Format("item{0}", slot), item.ID, RegistryValueKind.String); //update the registry
m_childItems.Add(new EOInventoryItem(m_api, slot, item, new InventoryItem { amount = count, id = (short)item.ID }, this)); //add the control wrapper for the item
m_childItems[m_childItems.Count - 1].DrawOrder = (int) ControlDrawLayer.DialogLayer - (2 + slot%INVENTORY_ROW_LENGTH);
return true;
}
private void LogItemEvent(GuildBankLogEntryType type, Character actor, ItemRecord record, int amount, GuildBankTab intoTab)
{
var entry = new GuildBankLogEntry(Bank.Guild.Id)
{
Type = type,
Actor = actor,
BankLog = this,
DestinationTab = intoTab,
ItemEntryId = (int)record.EntryId,
ItemStackCount = (int)amount,
Created = DateTime.Now
};
lock (moneyLogEntries)
{
moneyLogEntries.Insert(entry);
}
}
/// <summary>
/// Places the given item in the given slot (or tries mergeing at slot> if indicated).
/// Make sure that the depositer has deposit rights to this BankTab!
/// </summary>
/// <param name="item">The <see cref="ItemRecord" /> to store.</param>
/// <param name="slot">The slotId where you want to store.</param>
/// <param name="allowMerge">Whether or not to try and merge the stacks.</param>
/// <returns>The <see cref="ItemRecord" /> that was in the slot (or the original <see cref="ItemRecord" /> minus the items that were merged)
/// or null if the store/merge was successful.</returns>
public ItemRecord StoreItemInSlot(ItemRecord item, int slot, bool allowMerge)
{
return StoreItemInSlot(item, item.Amount, slot, allowMerge);
}
private void continuebtn_Click(object sender, EventArgs e)
{
//process new item into syteline
if (ViableToDump())
{
ItemRecord toAdd = new ItemRecord();
toAdd = CollectItem();
//System.Data.SqlClient.SqlTransaction transaction = null;
try
{
//transaction = TableAdapterHelper.BeginTransaction(itemTableAdapter);
//itemTableAdapter.InsertNewItem(toAdd.item, toAdd.description, toAdd.qty_allocjob, toAdd.u_m, toAdd.lead_time, toAdd.lot_size, toAdd.qty_used_ytd, toAdd.qty_mfg_ytd, toAdd.abc_code, toAdd.drawing_nbr, toAdd.product_code, toAdd.p_m_t_code, toAdd.cost_method, toAdd.lst_lot_size, toAdd.unit_cost, toAdd.lst_u_cost, toAdd.avg_u_cost, toAdd.job, toAdd.suffix, toAdd.stocked, toAdd.matl_type, toAdd.family_code, toAdd.low_level, toAdd.last_inv, toAdd.days_supply, toAdd.order_min, toAdd.order_mult, toAdd.plan_code, toAdd.mps_flag, toAdd.accept_req, toAdd.change_date, toAdd.revision, toAdd.phantom_flag, toAdd.plan_flag, toAdd.paper_time, toAdd.dock_time, toAdd.asm_setup, toAdd.asm_run, toAdd.asm_matl, toAdd.asm_tool, toAdd.asm_fixture, toAdd.asm_other, toAdd.asm_fixed, toAdd.asm_var, toAdd.asm_outside, toAdd.comp_setup, toAdd.comp_run, toAdd.comp_matl, toAdd.comp_tool, toAdd.comp_fixture, toAdd.comp_other, toAdd.comp_fixed, toAdd.comp_var, toAdd.comp_outside, toAdd.sub_matl, toAdd.shrink_fact, toAdd.alt_item, toAdd.unit_weight, toAdd.weight_units, toAdd.charfld4, toAdd.cur_u_cost, toAdd.feat_type, toAdd.var_lead, toAdd.feat_str, toAdd.next_config, toAdd.feat_templ, toAdd.backflush, toAdd.charfld1, toAdd.charfld2, toAdd.charfld3, toAdd.decifld1, toAdd.decifld2, toAdd.decifld3, toAdd.logifld, toAdd.datefld, toAdd.track_ecn, toAdd.u_ws_price, toAdd.comm_code, toAdd.origin, toAdd.unit_mat_cost, toAdd.unit_duty_cost, toAdd.unit_freight_cost, toAdd.unit_brokerage_cost, toAdd.cur_mat_cost, toAdd.cur_duty_cost, toAdd.cur_freight_cost, toAdd.cur_brokerage_cost, toAdd.tax_code1, toAdd.tax_code2, toAdd.bflush_loc, toAdd.reservable, toAdd.shelf_life, toAdd.lot_prefix, toAdd.serial_prefix, toAdd.serial_length, toAdd.issue_by, toAdd.serial_tracked, toAdd.lot_tracked, toAdd.cost_type, toAdd.matl_cost, toAdd.lbr_cost, toAdd.fovhd_cost, toAdd.vovhd_cost, toAdd.out_cost, toAdd.cur_mat_cost, toAdd.cur_lbr_cost, toAdd.cur_fovhd_cost, toAdd.cur_vovhd_cost, toAdd.cur_out_cost, toAdd.avg_matl_cost, toAdd.avg_lbr_cost, toAdd.avg_fovhd_cost, toAdd.avg_vovhd_cost, toAdd.avg_out_cost, toAdd.prod_type, toAdd.rate_per_day, toAdd.mps_plan_fence, toAdd.pass_req, toAdd.lot_gen_exp, toAdd.supply_site, toAdd.prod_mix, toAdd.stat, toAdd.status_chg_user_code, toAdd.chg_date, toAdd.reason_code, toAdd.supply_whse,
// toAdd.due_period, toAdd.order_max, toAdd.mrp_part, toAdd.infinite_part, toAdd.NoteExistsFlag, toAdd.RecordDate, toAdd.supply_tolerance_hrs, toAdd.exp_lead_time, toAdd.var_exp_lead, toAdd.buyer, toAdd.order_configurable, toAdd.job_configurable, toAdd.cfg_model, toAdd.co_post_config, toAdd.job_post_config, toAdd.auto_job, toAdd.auto_post, toAdd.setupgroup, toAdd.CreatedBy, toAdd.UpdatedBy, toAdd.CreateDate, toAdd.InWorkflow, toAdd.mfg_supply_switching_active, toAdd.time_fence_rule, toAdd.time_fence_value, toAdd.earliest_planned_po_receipt, toAdd.use_reorder_point, toAdd.reorder_point, toAdd.fixed_order_qty, toAdd.unit_insurance_cost, toAdd.unit_loc_frt_cost, toAdd.cur_insurance_cost, toAdd.cur_loc_frt_cost, toAdd.tax_free_matl, toAdd.tax_free_days, toAdd.safety_stock_percent, toAdd.tariff_classification, toAdd.active_for_data_integration, toAdd.rcvd_over_po_qty_tolerance, toAdd.rcvd_under_po_qty_tolerance, toAdd.include_in_net_change_planning, toAdd.kit, toAdd.print_kit_components, toAdd.safety_stock_rule, toAdd.show_in_drop_down_list, toAdd.controlled_by_external_ics, toAdd.inventory_ucl_tolerance, toAdd.inventory_lcl_tolerance, toAdd.separation_attribute, toAdd.batch_release_attribute1, toAdd.batch_release_attribute2, toAdd.batch_release_attribute3, toAdd.picture, toAdd.active_for_customer_portal, toAdd.featured, toAdd.top_seller, toAdd.overview, toAdd.preassign_lots, toAdd.preassign_serials, toAdd.attr_group, toAdd.dimension_group, toAdd.lot_attr_group, toAdd.track_pieces, toAdd.bom_last_import_date, toAdd.save_current_rev_upon_bom_import);
//transaction.Commit();
int VendCount = 0;
try
{
//VendCount = Convert.ToInt32(itemvendTableAdapter.CountVendors(itemtxt.Text));
}
catch { VendCount = 0; }
if (sourcecbo.Text == "Purchased" && VendCount == 0)
{
//add vendor
ItemVendorAdd form = new ItemVendorAdd(itemtxt.Text);
form.ShowDialog();
if (form.DialogResult == DialogResult.Cancel)
{
this.DialogResult = DialogResult.Cancel;
}
form.Dispose();
}
}
catch
{
//transaction.Rollback();
this.DialogResult = DialogResult.Cancel;
MessageBox.Show("An error occured while trying to inject the item into Syteline. Operations will now stop.", "Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.Close();
this.Dispose();
return;
}
finally
{
//transaction.Connection.Close();
//transaction.Dispose();
this.Close();
}
}
}
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
//update the draw location when the player isn't the MainPlayer (so, if they walked)
if (!noLocUpdate && characterSkin != null && _char != null && World.Instance.MainPlayer.ActiveCharacter != null)
drawArea = new Rectangle(
_char.OffsetX + 304 - World.Instance.MainPlayer.ActiveCharacter.OffsetX,
_char.OffsetY + 91 - World.Instance.MainPlayer.ActiveCharacter.OffsetY,
m_skinSourceRect.Width, m_skinSourceRect.Height);
//update when the control is being dragged (when not in-game)
if (EOGame.Instance.State != GameStates.PlayingTheGame &&
PreviousMouseState.LeftButton == ButtonState.Pressed &&
Mouse.GetState().LeftButton == ButtonState.Pressed)
{
Data.SetUpdate(true);
}
#region refresh all the textures from the GFX files or image cache
if (Data.update)
{
if (Data.shield != 0)
{
if (World.Instance.EIF != null)
{
shieldInfo = (ItemRecord)World.Instance.EIF.Data.Find(x => (x as ItemRecord != null) && (x as ItemRecord).DollGraphic == Data.shield && (x as ItemRecord).Type == ItemType.Shield);
shield = spriteSheet.GetShield(shieldInfo.SubType == ItemSubType.Arrows || shieldInfo.SubType == ItemSubType.Wings);
}
}
else
{
shield = null;
shieldInfo = null;
}
if (Data.weapon != 0)
{
if (World.Instance.EIF != null)
{
weaponInfo =
(ItemRecord)
World.Instance.EIF.Data.Find(
x =>
(x as ItemRecord != null) && (x as ItemRecord).DollGraphic == Data.weapon &&
(x as ItemRecord).Type == ItemType.Weapon);
weapon = spriteSheet.GetWeapon(weaponInfo.SubType == ItemSubType.Ranged);
}
}
else
{
weapon = null;
weaponInfo = null;
}
bool isBow = weaponInfo != null && weaponInfo.SubType == ItemSubType.Ranged;
characterSkin = spriteSheet.GetSkin(isBow, out m_skinSourceRect);
boots = Data.boots != 0 ? spriteSheet.GetBoots(isBow) : null;
armor = Data.armor != 0 ? spriteSheet.GetArmor(isBow) : null;
lock (hatHairLock)
hair = Data.hairstyle != 0 ? spriteSheet.GetHair(Data.hairNeedRefresh) : null;
if (Data.hat != 0)
{
lock (hatHairLock)
hat = spriteSheet.GetHat();
if(World.Instance.EIF != null)
hatInfo = (ItemRecord)World.Instance.EIF.Data.Find(x => (x as ItemRecord != null) && (x as ItemRecord).DollGraphic == Data.hat && (x as ItemRecord).Type == ItemType.Hat);
}
else
{
lock (hatHairLock)
{
hat = null;
hatInfo = null;
}
}
maskTheHair(); //this will set the combined hat/hair texture with proper data.
_drawCharToRenderTarget();
Data.SetUpdate(false);
Data.SetHairNeedRefresh(false);
}
#endregion
//bring back from the dead after 2 seconds
if (m_deadTime != null && Character.RenderData.dead && (DateTime.Now - m_deadTime.Value).TotalSeconds > 2)
{
m_deadTime = null;
Character.RenderData.SetDead(false);
}
if (EOGame.Instance.State == GameStates.PlayingTheGame && this == World.Instance.ActiveCharacterRenderer)
{
//adjust SP
if (Character.Stats != null && Character.Stats.sp < Character.Stats.maxsp &&
State != CharacterActionState.Attacking && (int) gameTime.TotalGameTime.TotalMilliseconds%1000 == 0)
Character.Stats.SetSP((short) (Character.Stats.sp + 1));
//5-minute timeout: start sending emotes every minute
if ((DateTime.Now - m_lastActTime).TotalMilliseconds > 300000 &&
(m_lastEmoteTime == null || (DateTime.Now - m_lastEmoteTime.Value).TotalMilliseconds > 60000))
{
m_lastEmoteTime = DateTime.Now;
Character.Emote(Emote.Moon);
PlayerEmote();
}
if (m_drunkTime.HasValue && Character.IsDrunk)
{
//note: these timer values (between 1-6 seconds and 30 seconds) are completely arbitrary
if (!m_lastEmoteTime.HasValue || (DateTime.Now - m_lastEmoteTime.Value).TotalMilliseconds > m_drunkOffset)
{
m_lastEmoteTime = DateTime.Now;
Character.Emote(Emote.Drunk);
PlayerEmote();
m_drunkOffset = (new Random()).Next(1000, 6000); //between 1-6 seconds
}
if ((DateTime.Now - m_drunkTime.Value).TotalMilliseconds >= 30000)
{
m_drunkTime = null;
Character.IsDrunk = false;
}
}
}
#region input handling for keyboard
//only check for a keypress if not currently acting and if this is the active character renderer
//also only check every 1/4 of a second
KeyboardState currentKeyState = Keyboard.GetState();
if (Game.IsActive && _char != null && _char == World.Instance.MainPlayer.ActiveCharacter && gameTime.TotalGameTime.Milliseconds % 100 <= 25 && Dialogs.Count == 0)
{
EODirection direction = (EODirection)255; //first, get the direction we should try to move based on the key presses from the player
bool attacking = false;
if (currentKeyState.IsKeyDown(Keys.Up) && _prevKeyState.IsKeyDown(Keys.Up))
direction = EODirection.Up;
else if (currentKeyState.IsKeyDown(Keys.Down) && _prevKeyState.IsKeyDown(Keys.Down))
direction = EODirection.Down;
else if (currentKeyState.IsKeyDown(Keys.Left) && _prevKeyState.IsKeyDown(Keys.Left))
direction = EODirection.Left;
else if (currentKeyState.IsKeyDown(Keys.Right) && _prevKeyState.IsKeyDown(Keys.Right))
direction = EODirection.Right;
else if ((currentKeyState.IsKeyDown(Keys.LeftControl) || currentKeyState.IsKeyDown(Keys.RightControl)) &&
(_prevKeyState.IsKeyDown(Keys.LeftControl) || _prevKeyState.IsKeyDown(Keys.RightControl)))
{
attacking = true;
direction = _char.RenderData.facing;
startWalkingThroughPlayerTime = null;
}
else
{
//on 'else': code path should return without doing anything
_checkAndHandleEmote(currentKeyState);
startWalkingThroughPlayerTime = null;
}
byte destX, destY;
switch (direction)
{
case EODirection.Up:
destX = (byte) _char.X;
destY = (byte) (_char.Y - 1);
break;
case EODirection.Down:
destX = (byte) _char.X;
destY = (byte) (_char.Y + 1);
break;
case EODirection.Right:
destX = (byte) (_char.X + 1);
destY = (byte) _char.Y;
break;
case EODirection.Left:
destX = (byte) (_char.X - 1);
destY = (byte) _char.Y;
break;
default:
if (State != CharacterActionState.Walking)
_prevKeyState = currentKeyState; //only set this when not walking already
destX = destY = 255;
break;
}
if (destX > World.Instance.ActiveMapRenderer.MapRef.Width || destY > World.Instance.ActiveMapRenderer.MapRef.Height)
{
//this will execute when the direction above is invalid.
//so, if not attacking and not walking we will hit this.
return;
}
//reset the sleeping emote time trackers
m_lastActTime = DateTime.Now;
m_lastEmoteTime = null;
if (!attacking)
{
//valid direction at this point
if (_char.RenderData.facing != direction)
{
_char.Face(direction);
return;
}
TileInfo info = World.Instance.ActiveMapRenderer.GetTileInfo(destX, destY);
switch (info.ReturnType)
{
case TileInfoReturnType.IsOtherPlayer:
if (NoWall) goto case TileInfoReturnType.IsTileSpec;
EOGame.Instance.Hud.SetStatusLabel(DATCONST2.STATUS_LABEL_TYPE_ACTION, DATCONST2.STATUS_LABEL_KEEP_MOVING_THROUGH_PLAYER);
if(startWalkingThroughPlayerTime == null)
startWalkingThroughPlayerTime = gameTime;
else if ((gameTime.TotalGameTime.TotalSeconds - startWalkingThroughPlayerTime.TotalGameTime.TotalSeconds) > 3)
{
startWalkingThroughPlayerTime = null;
goto case TileInfoReturnType.IsTileSpec;
}
break;
case TileInfoReturnType.IsOtherNPC:
if (NoWall) goto case TileInfoReturnType.IsTileSpec;
#if DEBUG
EOGame.Instance.Hud.SetStatusLabel("OTHER NPC IS HERE"); //idk what's supposed to happen here, I think nothing?
#endif
break;
case TileInfoReturnType.IsWarpSpec:
if (NoWall) goto case TileInfoReturnType.IsTileSpec;
if (info.Warp.door != DoorSpec.NoDoor)
{
DoorSpec doorOpened;
if (!info.Warp.doorOpened && !info.Warp.backOff)
{
if ((doorOpened = Character.CanOpenDoor(info.Warp)) == DoorSpec.Door)
World.Instance.ActiveMapRenderer.StartOpenDoor(info.Warp, destX, destY);
}
else
{
//normal walking
if ((doorOpened = Character.CanOpenDoor(info.Warp)) == DoorSpec.Door)
_chkWalk(TileSpec.None, direction, destX, destY);
}
if (doorOpened != DoorSpec.Door)
{
string strWhichKey = "[error key?]";
switch (doorOpened)
{
case DoorSpec.LockedCrystal:
strWhichKey = "Crystal Key";
break;
case DoorSpec.LockedSilver:
strWhichKey = "Silver Key";
break;
case DoorSpec.LockedWraith:
strWhichKey = "Wraith Key";
break;
}
EODialog.Show(DATCONST1.DOOR_LOCKED, XNADialogButtons.Ok, EODialogStyle.SmallDialogSmallHeader);
((EOGame)Game).Hud.SetStatusLabel(DATCONST2.STATUS_LABEL_TYPE_WARNING, DATCONST2.STATUS_LABEL_THE_DOOR_IS_LOCKED_EXCLAMATION,
" - " + strWhichKey);
}
}
else if (info.Warp.levelRequirement != 0 && Character.Stats.level < info.Warp.levelRequirement)
{
EOGame.Instance.Hud.SetStatusLabel(DATCONST2.STATUS_LABEL_TYPE_WARNING,
DATCONST2.STATUS_LABEL_NOT_READY_TO_USE_ENTRANCE,
" - LVL " + info.Warp.levelRequirement);
}
else
{
//normal walking
_chkWalk(TileSpec.None, direction, destX, destY);
}
break;
case TileInfoReturnType.IsTileSpec:
_chkWalk(info.Spec, direction, destX, destY);
break;
}
}
else if(State == CharacterActionState.Standing)
{
if (Character.CanAttack)
{
TileInfo info = World.Instance.ActiveMapRenderer.GetTileInfo((byte)Character.X, (byte)Character.Y);
Character.Attack(Data.facing, destX, destY); //destX and destY validity check above
PlayerAttack(info.ReturnType == TileInfoReturnType.IsTileSpec && info.Spec == TileSpec.Water);
}
else if(Character.Weight > Character.MaxWeight)
{
EOGame.Instance.Hud.SetStatusLabel(DATCONST2.STATUS_LABEL_TYPE_WARNING, DATCONST2.STATUS_LABEL_CANNOT_ATTACK_OVERWEIGHT);
}
}
if (State == CharacterActionState.Standing) _prevKeyState = currentKeyState; //only set this when not walking already
}
#endregion
}
private void OnRecordCreated(ItemRecord record)
{
if (IsCharter)
{
PetitionRecord charter;
if (!record.IsNew)
{
// this is executed in the IO-context
charter = PetitionRecord.LoadRecord(record.EntityLowId);
}
else
{
charter = new PetitionRecord((uint)record.OwnerId, record.EntityLowId);
}
}
}
/// <summary>
/// Tries to store the given item in the given slot. No merge attempted.
/// </summary>
/// <param name="item">The item to store.</param>
/// <param name="slot">The slot to store it in.</param>
/// <returns>The <see cref="ItemRecord" /> that was in the slot (or the original <see cref="ItemRecord" /> minus the items that were merged)
/// or null if the store/merge was successful.</returns>
public ItemRecord StoreItemInSlot(ItemRecord item, int slot)
{
return StoreItemInSlot(item, slot, false);
}
private bool _addItemToSlot(int slot, ItemRecord item, int count = 1)
{
return _addItemToSlot(m_filledSlots, slot, item, count);
}
/// <summary>
/// Places the given amount of the given item stack in the given slot (or tries mergeing at slot if indicated).
/// Make sure that the depositer has deposit rights to this BankTab!
/// </summary>
/// <param name="item">The <see cref="ItemRecord" /> to store.</param>
/// <param name="amount">The amount of items from the stack to store.</param>
/// <param name="slot">The slotId where you want to store.</param>
/// <param name="allowMerge">Whether or not to try and merge the stacks.</param>
/// <returns>The <see cref="ItemRecord" /> that was in the slot (or the original <see cref="ItemRecord" /> minus the items that were merged)
/// or null if the store/merge was successful.</returns>
public ItemRecord StoreItemInSlot(ItemRecord item, int amount, int slot, bool allowMerge)
{
if (slot >= GuildMgr.MAX_BANK_TAB_SLOTS) return item;
if (item.Amount < amount) return item; // Cheater!
var curItem = this[slot];
if (curItem == null)
{
// the slot is empty, rock on
this[slot] = item;
return null;
}
if (allowMerge && this[slot].EntryId == item.EntryId)
{
// try to merge the stacks.
var freeSpace = (int)curItem.Template.MaxAmount - curItem.Amount;
freeSpace = Math.Min(freeSpace, amount);
curItem.Amount += freeSpace;
item.Amount -= freeSpace;
return item.Amount > 0 ? item : null;
}
// gonna swap
this[slot] = item;
return curItem;
}
