private void GiveItemEntry(ItemEntry right, ref ItemEntry rhs)
{
// show list
rhs.nLevel = right.nLevel;
rhs.strType = right.strType;
rhs.strSubType = right.strSubType;
rhs.strQuality = right.strQuality;
rhs.strSchool = right.strSchool;
// show text
rhs.nMagicNowValue = right.nMagicNowValue;
rhs.nMagicTotalValue = right.nMagicTotalValue; ;
rhs.nMagicBaseValue = right.nMagicBaseValue; ;
rhs.nWGHurtMax = right.nWGHurtMax; ;
rhs.nWGHurtMin = right.nWGHurtMin; ;
rhs.nWGDefendMax = right.nWGDefendMax; ;
rhs.nWGDefendMin = right.nWGDefendMin; ;
// Magic
rhs.nItemBaseMagicCount = right.nItemBaseMagicCount;
rhs.nItemMagicCount = right.nItemMagicCount;
for (int nIndex = 0; nIndex != 8; ++nIndex)
rhs.bItemMagicSige[nIndex] = right.bItemMagicSige[nIndex];
for (int nIndex = 0; nIndex != 8; ++nIndex)
GiveItemMagicSon(right.ItemMagicSon[nIndex], ref rhs.ItemMagicSon[nIndex]);
// SpeicalMagic son
rhs.nRemainMagicValue = right.nRemainMagicValue;
rhs.nMagicSonCount = right.nMagicSonCount;
for (int nIndex = 0; nIndex != 400; ++nIndex)
GiveItemMagicSon(right.ItemSpeMagicSon[nIndex], ref rhs.ItemSpeMagicSon[nIndex]);
}
private void InitItemEntry(ref ItemEntry rhs)
{
// show list
rhs.nLevel = 0;
rhs.strType = "";
rhs.strSubType = "";
rhs.strQuality = "";
rhs.strSchool = "";
// show text
rhs.nMagicNowValue = 0;
rhs.nMagicTotalValue = 0;
rhs.nMagicBaseValue = 0;
rhs.nWGHurtMax = 0;
rhs.nWGHurtMin = 0;
rhs.nWGDefendMax = 0;
rhs.nWGDefendMin = 0;
// Magic
rhs.nItemBaseMagicCount = 0;
rhs.nItemMagicCount = 0;
rhs.bItemMagicSige = new bool[8];
rhs.ItemMagicSon = new MagicAttribute[8];
for (int nIndex = 0; nIndex != 8; ++nIndex)
rhs.bItemMagicSige[nIndex] = false;
for (int nIndex = 0; nIndex != 8; ++nIndex)
InitItemMagicSon(ref rhs.ItemMagicSon[nIndex]);
// SpeicalMagic son
rhs.nRemainMagicValue = 0;
rhs.nMagicSonCount = 0;
rhs.ItemSpeMagicSon = new MagicAttribute[400];
for (int nIndex = 0; nIndex != 400; ++nIndex)
InitItemMagicSon(ref rhs.ItemSpeMagicSon[nIndex]);
}
public void CanUseItemFromStockItem()
{
var stockItem = new StockItem();
_mockItemEntries = new List <ItemEntry>()
{
ItemEntry.Create(stockItem.StockItemId, 15, 3.50m, DateTime.Now.AddDays(14)),
ItemEntry.Create(stockItem.StockItemId, 20, 2.50m, DateTime.Now.AddDays(14))
};
stockItem.AddItemEntries(_mockItemEntries);
Assert.AreEqual(35, stockItem.TotalOnHand);
stockItem.UseStockItem();
Assert.AreEqual(34, stockItem.TotalOnHand);
}
/// <summary>
/// Adds a new item to a bag slot if there is room.
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public bool AddBag(ItemEntry item)
{
for (int i = 0; i < bagItems.values.Length; i++)
{
if (bagItems.values[i] == null)
{
Debug.Log("Placed Item at pos " + i);
bagItems.values[i] = item;
return(true);
}
}
Debug.Log("Not enough room.");
return(false);
}
public void DisplayedStach()
{
for (int index = 0; index < container.container_item_entry.Length; index++)
{
ItemEntry itemEntry = container.container_item_entry[index];
if (!ReferenceEquals(itemEntry, null))
{
StachItemSlots[index].ITEM = itemEntry.item_pickup;
}
else
{
StachItemSlots[index].ITEM = null;
}
}
}
private void ApplyOffsets()
{
// Store all queued items. Iterate via index as subsequent calls append to the list.
for (int i = 0; i < _savedItems.Count; i++)
{
ItemEntry entry = _savedItems[i];
if (entry.Target != null)
{
continue; // Ignore if it has already been written (list or dict elements).
}
Align(4);
switch (entry.Type)
{
case ItemEntryType.List:
IEnumerable <IResData> list = (IEnumerable <IResData>)entry.Data;
// Check if the first item has already been written by a previous dict.
if (TryGetItemEntry(list.First(), ItemEntryType.ResData, out ItemEntry firstElement))
{
entry.Target = firstElement.Target;
}
else
{
entry.Target = (uint)Position;
CurrentIndex = 0;
foreach (IResData element in list)
{
_savedItems.Add(new ItemEntry(element, ItemEntryType.ResData, target: (uint)Position,
index: CurrentIndex));
element.Save(this);
CurrentIndex++;
}
}
break;
case ItemEntryType.Dict:
case ItemEntryType.ResData:
entry.Target = (uint)Position;
CurrentIndex = entry.Index;
((IResData)entry.Data).Save(this);
break;
case ItemEntryType.Custom:
entry.Target = (uint)Position;
entry.Callback.Invoke();
break;
}
}
}
public SheetEntryPage(ItemEntry entry, int passingColumn)
{
InitializeComponent();
//passing variables
column = passingColumn;
itemCode = entry.ItemCode;
itemDescription = entry.ItemDescription;
unitOfMeasure = entry.UnitOfMeasure;
itemMaterial = entry.ItemMaterial;
itemWeight = entry.ItemWeight;
itemBasePrice = entry.ItemBasePrice;
itemSurface = entry.ItemSurface;
itemColor = entry.ItemColor;
//Bindings
itemBinding.Text = entry.ItemDescription.ToString();
}
public void UpdateItem(string guid, int id, int count)
{
if (count > 0)
{
itemDictionary[guid] = new ItemEntry()
{
guid = guid,
id = id,
count = count,
};
}
else
{
itemDictionary.Remove(guid);
}
}
public Item GetItemInside(int currentTime, int age)
{
List <ItemEntry> mergedTimeline = GetMergedTimeline(currentTime);
for (int i = 0, count = mergedTimeline.Count; i < count; i++)
{
ItemEntry entry = mergedTimeline[i];
if (entry.age == age)
{
return(entry.item);
}
}
return(null);
}
public override bool ParadoxCheck(int currentTime)
{
ItemEntry entry = GameManager.Instance.itemTimeline.GetLatestFixedEntry(currentTime, itemContainer.age, itemContainerIndex);
Box box = entry.item as Box;
if (box != null)
{
if (box.GetItems()[0] == null)
{
return(false);
}
}
return(true);
}
public static DroppedItemData doPlayerItemCollection(ItemManager mgr, long x, long y, long z, Vector3 off, float magRange, float magStrength, float range, int maxStack, Player p)
{
PlayerInventory inv = p.mInventory;
int id = ItemEntry.GetIDFromKey("ReikaKalseki.ItemMagnet", true);
//FUtil.log("Has magnet "+id+" : "+inv.GetSuitAndInventoryItemCount(id));
float pwr = config.getFloat(FTConfig.ConfigEntries.MAGNET_COST);
if (SurvivalPowerPanel.mrSuitPower >= pwr && id > 0 && inv.GetSuitAndInventoryItemCount(id) > 0) //TODO cache this for performance
{
range *= 6;
magRange *= 6;
SurvivalPowerPanel.mrSuitPower -= pwr;
}
DroppedItemData droppedItem = mgr.UpdateCollection(x, y, z, off, magRange, magStrength, range, maxStack);
return(droppedItem);
}
public void AddItem(ItemEntry entry)
{
var hasItem = FindSlotWithItem(entry.ItemName);
if (hasItem >= 0)
{
AddItemCount(hasItem, entry.ItemCount);
}
else
{
int freeSlot = FindFirstFreeSlot();
if (freeSlot >= 0)
{
Items[freeSlot] = entry;
}
}
}
private void AddEntry(int price, string name)
{
ItemEntry ie = new ItemEntry {
price = price, name = name
};
string path = Application.dataPath + "/Data/ShopItems.json";
string jsonString = File.ReadAllText(path);
Items i = JsonUtility.FromJson <Items>(jsonString);
i.item_entry_list.Add(ie);
string json = JsonUtility.ToJson(i);
File.WriteAllText(path, json);
}
public override void ResetValues()
{
base.ResetValues();
item = null;
type = UpgradeType.UPGRADE;
rank = 1;
cost = 0;
scrap = 0;
power = 0;
hit = 0;
crit = 0;
charges = 0;
costValue = 0;
}
private void Initializing()
{
_totalItem = 0;
bool isOpen = _placesController.PlacesDic[_placeId].IsOpen;
if (isOpen)
{
ItemEntry[] container_item_entry = new ItemEntry[_inventoryContainer.Container_size];
container_item_entry = _inventoryContainer.container_item_entry;
_itemShopGenerator.ClearTemplate();
for (int index = 0; index < container_item_entry.Length; index++)
{
if (!ReferenceEquals(container_item_entry[index], null))
{
string itemId = container_item_entry[index].item_pickup.Id;
int itemAmount = 1;
_totalItem += itemAmount;
ItemPickUp_Template itemPickUp_Template = _itemTemplateController.ItemTemplateDic[itemId];
string itemName = itemPickUp_Template.ItemName;
Sprite itemIcon = itemPickUp_Template.ItemIcon;
string itemType = ConvertType.GetStringItemType(itemPickUp_Template.ItemType, itemPickUp_Template.SubType);
int itemSellingPrice = itemPickUp_Template.SellingPrice;
string itemDescription = itemPickUp_Template.ItemDescription;
List <ItemPropertyAmount> itemPropertyAmounts = itemPickUp_Template.ItemProperties;
_itemShopGenerator.CreateTemplate(new ItemShop(itemId, itemAmount, itemName, index, itemIcon, itemType, itemSellingPrice, itemDescription, itemPropertyAmounts));
}
}
if (itemsParent != null && itemsParent.childCount > 0)
{
itemsParent.GetComponentsInChildren(includeInactive: true, result: baseItemShopSlots);
for (int index = 0; index < baseItemShopSlots.Count; index++)
{
baseItemShopSlots[index].OnPointEnterSellingEvent.AddListener(OnPointEnterHandler);
baseItemShopSlots[index].OnPointExitSellingEvent.AddListener(OnPointExitEventHandler);
}
}
}
CheckInvIsEmpty();
}
/// <summary>
/// Colors the item name according to rarity.
/// </summary>
/// <param name="item"></param>
void ColorByRarity(ItemEntry item)
{
switch (item.rarity)
{
case ItemEntry.Rarity.GREEN:
item.itemName = "<color=#3BD248FF>" + item.itemName + "</color>";
break;
case ItemEntry.Rarity.BLUE:
item.itemName = "<color=#2F5DE5FF>" + item.itemName + "</color>";
break;
case ItemEntry.Rarity.PURPLE:
item.itemName = "<color=#F91DF3FF>" + item.itemName + "</color>";
break;
}
}
public static bool IsResearchable(ItemBase i)
{
if (i is ItemCubeStack)
{
TerrainDataEntry terrainDataEntry = global::TerrainData.mEntries[(i as ItemCubeStack).mCubeType];
return(terrainDataEntry != null && terrainDataEntry.DecomposeValue > 0);
}
else if (i.mnItemID > 0 && i.mnItemID < ItemEntry.mEntries.Length)
{
ItemEntry itemEntry = ItemEntry.mEntries[i.mnItemID];
return(itemEntry != null && itemEntry.DecomposeValue > 0);
}
else
{
return(false);
}
}
public JsonResult Update(ItemEntry VE)
{
int code = VE.ITEM.ITEM_CD;
var Q = DB.ITEM.Where(M => M.ITEM_CD == code).FirstOrDefault();
string ext = Path.GetExtension(VE.ITEM.IMG);
string filename = Server.MapPath("~/Content/ItemImage/" + Q.ITEM_CD.ToString() + ext);// path + "/" + id.ToString() + ext;
SaveImage(VE.IMG_FILE, filename);
Q.ITEM_NM = VE.ITEM.ITEM_NM;
Q.ITEM_DESC = VE.ITEM.ITEM_DESC;
Q.IMG = Q.ITEM_CD.ToString() + ext;
Q.PRICE = VE.ITEM.PRICE;
Q.STATUS = VE.ITEM.STATUS;
Q.CATE_CD = VE.ITEM.CATE_CD;
Q.ITEM_TYPE = VE.ITEM.ITEM_TYPE;
DB.SaveChanges();
return(Json("Success", JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Sets the given item in the slot at the index.
/// Equipped items use negative indexing starting at -1
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
private void SetItem(int index, ItemEntry item)
{
if (index < 0)
{
index = -(index + 1);
if (index < equippedItems.values.Length)
{
equippedItems.values[index] = item;
}
}
else
{
if (index < bagItems.values.Length)
{
bagItems.values[index] = item;
}
}
}
private void GenerateStorageList()
{
entryList.ResetList();
int listSize = playerData.items.Count;
for (int i = 0; i < listSize; i++)
{
ItemEntry item = playerData.items[i].item;
int charges = playerData.items[i].charges;
Transform t = Instantiate(entryPrefab, entryListParent);
ItemListEntry entry = entryList.CreateEntry(t);
InventoryTuple tup = new InventoryTuple(item);
tup.UpdateUpgrades(playerData.upgrader);
entry.FillDataSimple(i, tup, charges.ToString(), "");
}
entryPrefab.gameObject.SetActive(false);
ForceCategory(0);
}
public override void CopyValues(ScrObjLibraryEntry other)
{
base.CopyValues(other);
UpgradeEntry up = (UpgradeEntry)other;
item = up.item;
type = up.type;
rank = up.rank;
cost = up.cost;
scrap = up.scrap;
power = up.power;
hit = up.hit;
crit = up.crit;
charges = up.charges;
costValue = up.costValue;
}
/// <summary>
/// Buys the dropped item if applicable.
/// </summary>
/// <param name="start"></param>
public void BuyItem(SlotID start, SlotID dropped)
{
if (dropped.type != SlotType.EQUIP && dropped.type != SlotType.BAG)
{
return;
}
ItemEntry item = GetItem(start);
if (currentMoney.value >= item.cost && !GetItem(dropped) && dropped.CanUse(item))
{
currentMoney.value -= item.cost;
Debug.Log("Bought the item");
SetItem(dropped, item);
// AddBag(item);
buyItemEvent.Invoke();
itemsChanged.Invoke();
}
}
/// <summary>
/// Set ups the save file's information and image
/// </summary>
/// <param name="save"></param>
void SetupSaveFile(int saveIndex)
{
PlayerStatsSaveClass pssc = SaveController.instance.saveFiles.playerSave[saveIndex];
SaveFileButton button = saveFileButtons[saveIndex];
bool newSave = (pssc.playerArea == 0);
button.emptyFile.SetActive(newSave);
button.saveStats.SetActive(!newSave);
if (!isCurrentlySaving.value && newSave && selectedSaveFile == saveIndex)
{
selectedSaveFile = -1;
}
button.SetImage((saveIndex == selectedSaveFile) ? selectedImage : normalImage);
button.currentChapter.text = "Ch. " + pssc.currentChapterIndex;
button.currentArea.text = ((Constants.OverworldArea)pssc.playerArea).ToString();
button.level.text = "Level " + new ExpLevel(pssc.expTotal).level;
button.playTime.text = "Time: " + Constants.PlayTimeFromInt(pssc.playedSeconds, false);
Sprite icon;
for (int i = 0; i < Constants.GEAR_EQUIP_SPACE; i++)
{
icon = emptyEquipSlot;
if (!string.IsNullOrEmpty(pssc.invItemEquip.uuids[i]))
{
ItemEntry item = (ItemEntry)itemLibrary.GetEntry(pssc.invItemEquip.uuids[i]);
icon = item.icon;
}
button.equipments[i].sprite = icon;
}
for (int i = 0; i < Constants.MODULE_EQUIP_SPACE; i++)
{
icon = emptyEquipSlot;
if (!string.IsNullOrEmpty(pssc.invModuleEquip.uuids[i]))
{
Module module = (Module)moduleLibrary.GetEntry(pssc.invModuleEquip.uuids[i]);
icon = module.icon;
}
button.modules[i].sprite = icon;
}
}
public static void GenItem(GameEntity owner, int itemID, int count, bool ident)
{
ItemEntry itemEntry = (ItemEntry)GlobalVars.nwrDB.GetEntry(itemID);
if (itemEntry != null)
{
if (itemEntry.Countable)
{
CreateItem(owner, itemID, ident).Count = (ushort)count;
}
else
{
for (int i = 1; i <= count; i++)
{
CreateItem(owner, itemID, ident);
}
}
}
}
/// <summary>
/// Removes an new/deleted/changed item
/// </summary>
/// <param name="item"></param>
internal void RemoveItem(AccessContextItem item)
{
ItemEntry entry = null;
foreach (var listItem in Items)
{
if (listItem.Key.Item == item)
{
entry = listItem.Key;
break;
}
}
if (null != entry)
{
Items.Remove(entry);
Parent.RaiseNotifyPropertyChanged("ContainsLocalChanges");
}
}
public DataStore(string path)
{
ids = new Dictionary <ushort, ItemEntry>();
stream = new BufferedStream(File.Open(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read));
try
{
stream.Position = stream.Length - sizeof(uint);
using (var reader = new BinaryReader(stream, Encoding.UTF8, true))
{
var position = reader.ReadUInt32();
stream.Position = position;
var count = reader.ReadUInt16();
entries = new ItemEntry[count];
for (var i = 0; i < count; i++)
{
ItemEntry e;
entries[i] = e = new ItemEntry()
{
id = reader.ReadUInt16(),
position = reader.ReadUInt32(),
length = reader.ReadUInt32(),
};
ids[e.id] = e;
if (!hasFree && (i == 0 && entries[i].position > MIN_BLOCK_SIZE || i > 0 && entries[i].position - entries[i - 1].position - entries[i - 1].length > MIN_BLOCK_SIZE))
{
hasFree = true;
}
}
}
}
catch
{
ids.Clear();
entries = new ItemEntry[0];
stream.SetLength(0);
}
}
public ActionResult Menu()
{
ItemEntry VE = new ItemEntry();
VE.ITEMLIST = (from test in DB.ITEM
select new ITEMLIST
{
ITEM_CD = test.ITEM_CD,
ITEM_NM = test.ITEM_NM,
ITEM_DESC = test.ITEM_DESC,
IMG = test.IMG,
PRICE = test.PRICE,
STATUS = test.STATUS,
CATE_CD = test.CATE_CD,
ITEM_TYPE = test.ITEM_TYPE
}).ToList();
return(View(VE));
}
private void OnSpendAmmoHandler(SpendAmmoEventArgs e)
{
//MenuManager.ShowHUDMessage("Event OK", null, true);
var actor = e.Spender;
if (actor == null || (!actor.IsPlayer && !actor.IsPlayerTeammate))
{
//MenuManager.ShowHUDMessage("Not the player", null, true);
return;
}
//MenuManager.ShowHUDMessage("Is the player", null, true);
TESAmmo bestAmmo = null;
ItemEntry ammoItem = null;
foreach (var item in actor.Inventory.Objects)
{
if (item.Template.FormType != FormTypes.Ammo)
{
continue;
}
TESAmmo ammo = item.Template as TESAmmo;
//MenuManager.ShowHUDMessage("Arrow found has " + ammo.AmmoData.Damage + " damage", null, true);
if (bestAmmo == null || bestAmmo.AmmoData.Damage < ammo.AmmoData.Damage)
{
bestAmmo = ammo;
ammoItem = item;
}
}
//MenuManager.ShowHUDMessage("Best Arrow has " + (bestAmmo != null ? bestAmmo.AmmoData.Damage.ToString() : "???") + " damage", null, true);
actor.EquipItem(ammoItem.Template, false, true);
MenuManager.ShowHUDMessage("Equipping arrow " + ammoItem.Template.Name, null, true);
}
// Start is called before the first frame update
void Awake()
{
GetCoins();
coins.text = coins_serializable_value.ToString();
container = transform.Find("Container");
template = container.Find("Template");
template.gameObject.SetActive(false);
// AddEntry(1,"Test");
// RemoveEntryByName("test2");
string path = Application.dataPath + "/Data/ShopItems.json";
string jsonString = File.ReadAllText(path);
Items it = JsonUtility.FromJson <Items>(jsonString);
// Sort by price
for (int i = 0; i < it.item_entry_list.Count; i++)
{
for (int j = i + 1; j < it.item_entry_list.Count; j++)
{
if (it.item_entry_list[j].price > it.item_entry_list[i].price)
{
ItemEntry temp = it.item_entry_list[i];
it.item_entry_list[i] = it.item_entry_list[j];
it.item_entry_list[j] = temp;
}
}
}
item_transform_list = new List <Transform>();
foreach (ItemEntry ie in it.item_entry_list)
{
CreateItemEntry(ie, container, item_transform_list);
}
}
/// <summary>
/// Get an index decrement info instance
/// </summary>
/// <param name="entry">target item</param>
/// <param name="autoCreateNew">auto create new if not exists</param>
/// <returns>ItemIndexDecrement instance or null(if not autoCreateNew)</returns>
internal ItemIndexDecrement GetIndexDecrement(ItemEntry entry, bool autoCreateNew)
{
foreach (var item in _decrementMemory)
{
if (item.Item == entry)
{
return(item);
}
}
if (autoCreateNew)
{
ItemIndexDecrement newDecrement = new ItemIndexDecrement(entry);
_decrementMemory.Add(newDecrement);
return(newDecrement);
}
else
{
return(null);
}
}
public override void Swap(int origin_item_entry, int target_item_entry)
{
base.Swap(origin_item_entry, target_item_entry);
ItemEntry temp_item_entry = container_item_entry[origin_item_entry];
//target to origin
if (container_item_entry[target_item_entry] != null)
{
container_item_entry[origin_item_entry] = container_item_entry[target_item_entry];
container_item_entry[origin_item_entry].slot_index = container_item_entry[target_item_entry].slot_index;
}
else
{
container_item_entry[origin_item_entry] = null;
}
//origin to targen
container_item_entry[target_item_entry] = temp_item_entry;
container_item_entry[target_item_entry].slot_index = temp_item_entry.slot_index;
NotificationEvents();
}
public int ForgeItem(EntityList ingredients, int itemID)
{
float sum = 0F;
MaterialKind i = MaterialKind.mk_None;
int result = CheckForgeIngredients(ingredients, ref sum, ref i);
if (result != RC_Ok)
{
if (result == RC_DifferentMetals)
{
// dummy
}
}
else
{
int num = ingredients.Count;
for (int j = 0; j < num; j++)
{
Item item = (Item)ingredients.GetItem(j);
fPlayer.DeleteItem(item);
}
ingredients.Clear();
if (itemID == GlobalVars.iid_Ingot)
{
AddForgeItem(GlobalVars.iid_Ingot, sum, i);
}
else
{
ItemEntry iEntry = (ItemEntry)GlobalVars.nwrDB.GetEntry(itemID);
AddForgeItem(itemID, iEntry.Weight, i);
float rem = ((sum - iEntry.Weight));
if (rem > 0f)
{
AddForgeItem(GlobalVars.iid_Ingot, rem, i);
}
}
}
return(result);
}
internal ItemIndexDecrement(ItemEntry item)
{
Item = item;
}
private static void LoadItems(string path,
ItemEntry[] entries)
{
using (FileStream bin = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read)) {
using (BinaryReader binReader = new BinaryReader(bin)) {
BinaryFileReader reader = new BinaryFileReader(binReader);
try {
LoadItems(reader, entries);
} finally {
reader.Close();
}
}
}
}
private static void LoadItems(BinaryFileReader reader,
ItemEntry[] entries)
{
for (int i = 0; i < entries.Length; ++i) {
ItemEntry entry = entries[i];
Item item = (Item)entry.Object;
if (item == null)
continue;
reader.Seek(entry.Position, SeekOrigin.Begin);
try {
m_LoadingType = entry.TypeName;
item.Deserialize(reader);
} catch (Exception e) {
log.Error(String.Format("failed to load item {0}", item),
e);
item.Delete();
entries[i].Clear();
++m_LoadErrors;
continue;
}
if (reader.Position != entry.Position + entry.Length) {
log.ErrorFormat("Bad deserialize on item {0}, type {1}: position={2}, should be {3}",
entry.Serial, entry.TypeName,
reader.Position, entry.Position + entry.Length);
item.Delete();
entries[i].Clear();
++m_LoadErrors;
}
}
}
private static ItemEntry[] LoadItemIndex(BinaryReader idxReader,
EntityType[] types)
{
int count = idxReader.ReadInt32(), skipped = 0;
object[] ctorArgs = new object[1];
m_Items = new Hashtable((count * 11) / 10);
ItemEntry[] entries = new ItemEntry[count];
for (int i = 0; i < count; ++i) {
int typeID = idxReader.ReadInt32();
Serial serial = (Serial)idxReader.ReadInt32();
long pos = idxReader.ReadInt64();
int length = idxReader.ReadInt32();
if (serial == Serial.MinusOne ||
typeID < 0 || typeID >= types.Length) {
++skipped;
continue;
}
EntityType type = types[typeID];
if (type.Constructor == null) {
++skipped;
continue;
}
Item item = null;
try {
ctorArgs[0] = serial;
item = (Item)type.Constructor.Invoke(ctorArgs);
} catch (Exception e) {
log.Error(String.Format("Error while creating item {0} of type {1}",
serial, type.Name),
e);
++skipped;
continue;
}
entries[i] = new ItemEntry(item, typeID, type.Name, pos, length);
AddItem(item);
}
if (skipped > 0) {
log.WarnFormat("{0} items were skipped", skipped);
m_LoadErrors += skipped;
}
return entries;
}
private static ItemEntry[] LoadItemIndex(BinaryReader idxReader,
EntityType[] types)
{
int count = idxReader.ReadInt32();
object[] ctorArgs = new object[1];
m_Items = new Hashtable(count);
ItemEntry[] entries = new ItemEntry[count];
for (int i = 0; i < count; ++i) {
int typeID = idxReader.ReadInt32();
int serial = idxReader.ReadInt32();
long pos = idxReader.ReadInt64();
int length = idxReader.ReadInt32();
EntityType type = types[typeID];
if (type.Constructor == null)
continue;
Item item = null;
try {
ctorArgs[0] = (Serial)serial;
item = (Item)type.Constructor.Invoke(ctorArgs);
} catch {
}
if (item != null) {
entries[i] = new ItemEntry(item, typeID, type.Name, pos, length);
AddItem(item);
}
}
return entries;
}
/// <summary>
/// Get an index decrement info instance
/// </summary>
/// <param name="entry">target item</param>
/// <param name="autoCreateNew">auto create new if not exists</param>
/// <returns>ItemIndexDecrement instance or null(if not autoCreateNew)</returns>
internal ItemIndexDecrement GetIndexDecrement(ItemEntry entry, bool autoCreateNew)
{
foreach (var item in _decrementMemory)
{
if (item.Item == entry)
return item;
}
if (autoCreateNew)
{
ItemIndexDecrement newDecrement = new ItemIndexDecrement(entry);
_decrementMemory.Add(newDecrement);
return newDecrement;
}
else
return null;
}
