public override void Initialize()
{
FindModules <AnimationModule>().ForEach(a => Animations.Add(a, new AnimationController(services.Make <AnimationModule>(a), services)));
FindModules <CharacterAnimationModule>().ForEach(a => CharacterAnimations.Add(a, new CharacterAnimationController(services.Make <CharacterAnimationModule>(a), services)));
FindModules <CharacterModule>().ForEach(a => Characters.Add(a, new CharacterController(services.Make <CharacterModule>(a), services)));
FindModules <ItemModule>().ForEach(a => Items.Add(a, new ItemController(services.Make <ItemModule>(a), services)));
FindModules <InventoryItemModule>().ForEach(a => InventoryItems.Add(a, new InventoryItemController(services.Make <InventoryItemModule>(a), services)));
FindModules <RoomModule>().ForEach(a => Rooms.Add(a, new RoomController(services.Make <RoomModule>(a), services)));
PreInitialize();
Animations.Values.ForEach(a => a.PreInitialize());
CharacterAnimations.Values.ForEach(c => c.PreInitialize());
Characters.Values.ForEach(c => c.PreInitialize());
Items.Values.ForEach(i => i.PreInitialize());
InventoryItems.Values.ForEach(i => i.PreInitialize());
Rooms.Values.ForEach(r => r.PreInitialize());
Animations.Values.ForEach(a => a.Initialize());
CharacterAnimations.Values.ForEach(c => c.Initialize());
Characters.Values.ForEach(c => c.Initialize());
Items.Values.ForEach(i => i.Initialize());
InventoryItems.Values.ForEach(i => i.Initialize());
Rooms.Values.ForEach(r => r.Initialize());
base.Initialize();
}
//This method ensures that anything which is added to the inventory
//will actually appear on the list. This method is tightly coupled to the model
//and if new IInventoryItems are created it will be necessary to rewrite this model.
private void InventoryItem_ItemSaved(object sender, EventArgs e)
{
//throw new NotImplementedException();
if ((sender as IDataStoreItem).ID == 0)
{
InventoryItems.Add(sender as IDataStoreItem);
}
if (sender is Generator)
{
Generator g = sender as Generator;
if (g.Elutions.Where(x => x.ID == 0).Any())
{
foreach (Elution t in g.Elutions.Where(x => x.ID == 0))
{
InventoryItems.Add(t);
}
}
}
if (sender is BaseBulkDose)
{
BaseBulkDose bd = sender as BaseBulkDose;
foreach (BaseUnitDose ud in bd.UnitDoses.Where(x => x.ID == 0))
{
InventoryItems.Add(ud);
}
}
resetView();
(sender as IDataStoreItem).ItemSaving -= InventoryItem_ItemSaved;
}
public void OnUpdateClick()
{
foreach (var item in ViewModel.InventoryList)
{
InventoryItems.Add(item);
}
}
/// <summary>
/// Implementação de <see cref="IInventory.Add(int, int)"/>
/// </summary>
public void Add(int uid, int amount)
{
var item = GameService.Items.FirstOrDefault(o => o.UniqueID == uid);
// TODO: Pensar em uma forma melhor de lidar com esses casos
if (item == null)
{
return;
}
if (item.GetAttributeValue <bool>(Attribute.STACKABLE))
{
var itemInventory = InventoryItems.FirstOrDefault(o => o.UniqueID == uid);
if (itemInventory == null)
{
item = AddAmount(item, amount);
if (item.GetAttributeValue <int>(Attribute.AMOUNT) == 0)
{
return;
}
InventoryItems.Add(item);
GameUI.RefreshInventory();
return;
}
var itemInventoryIndex = InventoryItems.IndexOf(itemInventory);
InventoryItems[itemInventoryIndex] = AddAmount(itemInventory, amount);
GameUI.RefreshInventory();
return;
}
if (!CanPick(uid, amount))
{
return;
}
for (var i = 0; i < amount; i++)
{
if (!CanPick(uid, 1))
{
continue;
}
var nonStack = AddAmount(item, 1);
if (nonStack.GetAttributeValue <int>(Attribute.AMOUNT) == 0)
{
continue;
}
InventoryItems.Add(nonStack);
}
GameUI.RefreshInventory();
}
private void InventoryItemAdded(object sender, NewDataStoreItemEventArgs e)
{
InventoryItems.Add(e.NewItem);
if (e.NewItem is Generator)
{
NumberOfElutionsToday++;
}
}
public bool AddInventoryItem(KeyValuePair <InventoryItem, ItemType> item)
{
if (InventoryItems.Count < InventoryItemSizeMax)
{
InventoryItems.Add(item);
return(true);
}
return(false);
}
public bool BuyItem(ShopItem shopItem)
{
if (TryPay(shopItem.Price))
{
InventoryItems.Add(new InventoryItem(shopItem));
return(true);
}
return(false);
}
private Miner(string name, int taterTokens)
{
Name = name;
TaterTokens = taterTokens;
InventoryItems.Add(new InventoryItem
{
Count = 0,
Item = Game.Gateway.GameItems.GetAll().First(gi => gi.Id == 3)
});
}
public void AddItem(IInventoryItem item)
{
if (!InventoryItems.Any(i => i.Name.Equals(item.Name) && i.Category.Equals(item.Category)))
{
InventoryItems.Add(item);
}
else
{
throw new Exception(string.Format("Item {0} in {1} category is already in the inventory", item.Name, item.Category));
}
}
/// <summary>
/// Parses the response received from the server.
/// </summary>
protected override void UnpackResponse()
{
base.UnpackResponse();
// Create the streams we will be reading from.
MemoryStream responseStream = new MemoryStream(m_responsePayload);
BinaryReader responseReader = new BinaryReader(responseStream, Encoding.Unicode);
// Try to unpack the data.
try
{
// Seek past return code.
responseReader.BaseStream.Seek(sizeof(int), SeekOrigin.Begin);
//count
ushort numberOfItems = responseReader.ReadUInt16();
for (int i = 0; i < numberOfItems; i++)
{
var itemId = 0;
var productName = string.Empty;
//serial numbers
ushort stringLen = responseReader.ReadUInt16();
string serialNumber = new string(responseReader.ReadChars(stringLen));
if (m_getAdditionalDetails)
{
//product name
stringLen = responseReader.ReadUInt16();
productName = new string(responseReader.ReadChars(stringLen));
}
//create inventory item
var item = new Tuple <string, string>(serialNumber, productName);
//add to list
InventoryItems.Add(item);
}
}
catch (EndOfStreamException e)
{
throw new MessageWrongSizeException("Get Inventory Serial Numbers", e);
}
catch (Exception e)
{
throw new ServerException("Get Inventory Serial Numbers", e);
}
// Close the streams.
responseReader.Close();
}
private void BtnAddDetail_Click(object sender, EventArgs e)
{
if (cmbDetailItems.SelectedIndex == -1)
{
MessageBox.Show("Please select a detail item");
return;
}
InventoryItem item = _context.InventoryItems.FirstOrDefault(i => i.ID == (int)cmbDetailItems.SelectedValue);
if (!InventoryItems.Any(i => i.ID == item.ID))
{
InventoryItems.Add(item);
}
}
public void InsertBonusShipRazerClaw()
{
foreach (var item in InventoryItems)
{
var shipBuilder = item.ItemObjectBuilder as MyMwcObjectBuilder_SmallShip;
if (shipBuilder != null && shipBuilder.ShipType == MyMwcObjectBuilder_SmallShip_TypesEnum.RAZORCLAW)
{
return;
}
}
var razorBuilder = MyMwcObjectBuilder_SmallShip_Player.CreateDefaultShip(MyMwcObjectBuilder_SmallShip_TypesEnum.RAZORCLAW, MyMwcObjectBuilder_FactionEnum.Rainiers, 100);
razorBuilder.Inventory.MaxItems = 60;
InventoryItems.Add(new MyMwcObjectBuilder_InventoryItem(razorBuilder, 1));
}
public void AddToInventory(Item pItem)
{
try
{
locker.WaitOne();
if (InventoryItems.ContainsKey((byte)pItem.Slot))
{
InventoryItems[(byte)pItem.Slot].Delete(); //removes from DB
InventoryItems.Remove((byte)pItem.Slot);
}
InventoryItems.Add((byte)pItem.Slot, pItem);
}
finally
{
locker.ReleaseMutex();
}
}
/// <summary>
/// We will look at the InventoryItems if the current text in the textbox is in the ListView
/// we just need to add to the count, if not we need to add to the InventoryItems
/// </summary>
private void AddItemToList()
{
if (InventoryItems.Any(p => p.Name == InputName) && InventoryItems.Count > 0)
{
InventoryItems.First(x => x.Name == InputName).ItemCount++;
}
else
{
if (string.IsNullOrEmpty(InputName))
{
MessageBox.Show("Please enter an item in the text box");
return;
}
InventoryItems.Add(new InventoryItem()
{
Name = InputName, ItemCount = 1
});
}
Item = new InventoryItem();
}
private void CreateItem(IList <string> tokens)
{
var item = new InventoryItem {
Character = Character, ItemId = int.Parse(tokens[1]), StackSize = int.Parse(tokens[2])
};
InventoryItems.Add(item);
//TODO: Check if inventory is full.
var snapshot = new Snapshot();
snapshot.SetType(SnapshotType.CREATEITEM);
snapshot.WriteInt32(Character.GetHashCode()); //TODO: Change to generated id.
snapshot.WriteByte(0); //Bag Id
item.Serialize(snapshot);
snapshot.WriteByte(1); //Item Count
snapshot.WriteByte(item.Slot); //Item Slot
snapshot.WriteInt16((short)item.StackSize); //Item Stack Size
Send(snapshot);
}
public async void GetShoppingList()
{
var temp = new ObservableCollection <InventoryItem>();
try
{
temp = await _backendConnection.GetInventoryItemListByType(3);
}
catch (ApiException e)
{
MessageBox.Show($"Fejl {e.StatusCode}", "Error!");
}
catch (HttpRequestException exception)
{
MessageBox.Show($"Der er ingen forbindele til serveren", "Error!");
}
finally
{
foreach (var inventoryItem in temp)
{
InventoryItems.Add(inventoryItem);
}
}
}
public void SeedInventoryItem(InventoryItem item)
{
InventoryItems.Add(item);
}
public void AddInventoryItem(IDataStoreItem item)
{
InventoryItems.Add(item);
}
/// <summary>
/// Adds item to inventory.
/// </summary>
public void AddItem(Item item)
{
InventoryItems.Add(new InventoryItem {
Item = item, Inventory = this
});
}
public override void GetData()
{
base.GetData();
KitDefinitions = DesktopApplication.Librarian.GetItems(typeof(KitDefinition), new List <RetrievalCriteria>());
Radiopharmaceuticals = DesktopApplication.Librarian.GetItems(typeof(Chemical), new List <RetrievalCriteria>());
RetrievalCriteria rcMin = new RetrievalCriteria("DateAdded", CriteraType.GreaterThan, BulkDoseDateMinimum);
List <RetrievalCriteria> rcList = new List <RetrievalCriteria>();
rcList.Add(rcMin);
InventoryItems = DesktopApplication.Librarian.GetItems(typeof(BaseBulkDose), rcList);
foreach (IDataStoreItem d in InventoryItems)
{
(d as BaseBulkDose).UnitDoseDrawn += InventoryItemAdded;
if (d is Elution && (d as Elution).CalibrationDate.Date == DateTime.Today)
{
//&& (d as Elution).CalibrationDate.Date == DateTime.Today
NumberOfElutionsToday++;
ActivityOfElutionsToday = ActivityOfElutionsToday + ((d as Elution).CurrentActivity);
if ((d as IInventory).Expired)
{
DisposableItems++;
DisposableActivity += (d as BaseRadioactiveInventoryItem).CurrentActivity;
}
}
else if (d is ReconstitutedColdKit)
{
NumberOfColdKitsToday++;
ActivityOfColdKitsToday += (d as ReconstitutedColdKit).CurrentActivity;
if ((d as IInventory).Expired)
{
DisposableItems++;
DisposableActivity += (d as BaseRadioactiveInventoryItem).CurrentActivity;
}
}
}
rcMin = new RetrievalCriteria("DateAdded", CriteraType.GreaterThan, UnitDoseDateMinimum);
rcList.Clear();
rcList.Add(rcMin);
foreach (IDataStoreItem d in DesktopApplication.Librarian.GetItems(typeof(BaseUnitDose), rcList))
{
InventoryItems.Add(d);
NumberOfUnitDosesToday++;
ActivityOfUnitDosesToday += (d as BaseUnitDose).CurrentActivity;
if ((d as IInventory).Expired)
{
DisposableItems++;
DisposableActivity += (d as BaseRadioactiveInventoryItem).CurrentActivity;
}
}
rcMin = new RetrievalCriteria("DateAdded", CriteraType.GreaterThan, GeneratorDateMinimum);
rcList.Clear();
rcList.Add(rcMin);
foreach (IDataStoreItem d in DesktopApplication.Librarian.GetItems(typeof(Generator), rcList))
{
InventoryItems.Add(d);
(d as Generator).GeneratorEluted += InventoryItemAdded;
}
rcMin = new RetrievalCriteria("DateAdded", CriteraType.GreaterThan, ColdKitDateMinimum);
rcList.Clear();
rcList.Add(rcMin);
foreach (IDataStoreItem d in DesktopApplication.Librarian.GetItems(typeof(Kit), rcList))
{
InventoryItems.Add(d);
(d as Kit).ColdKitReconstituted += InventoryItemAdded;
}
foreach (IDataStoreItem d in InventoryItems)
{
(d as IInventory).ItemDisposed += RadiopharmacyModule_ItemDeleted;
(d as IInventory).ItemUnDisposed += RadiopharmacyModule_ItemUnDisposed;
}
var isotopes = Platform.Retriever.RetrieveItems(typeof(Isotope), new List <RetrievalCriteria>());
System.Diagnostics.Debug.WriteLine("Isotopes.count = " + isotopes.Count);
foreach (var i in isotopes)
{
IsotopeLevel lvl = new IsotopeLevel();
lvl.Isotope = (Isotope)i;
lvl.CurrentActivity = InventoryItems.Where(x => x is BaseRadioactiveInventoryItem).Where(y => (y as BaseRadioactiveInventoryItem).Disposed == DisposalStatus.NotDisposed && (y as BaseRadioactiveInventoryItem).Isotope == i).Sum(z => (z as BaseRadioactiveInventoryItem).CurrentActivity);
if (lvl.CurrentActivity > 0)
{
IsotopeLevels.Add(lvl);
}
}
try
{
var a = Platform.Retriever.RetrieveItems(typeof(BaseUnitDose)).Where(x => (x as BaseUnitDose).Disposed == DisposalStatus.NotDisposed && (x as BaseUnitDose).Expired == true);
var b = Platform.Retriever.RetrieveItems(typeof(BaseBulkDose)).Where(x => (x as BaseBulkDose).Disposed == DisposalStatus.NotDisposed && (x as BaseBulkDose).Expired == true);
var c = Platform.Retriever.RetrieveItems(typeof(Generator)).Where(x => (x as BaseBulkDose).Disposed == DisposalStatus.NotDisposed && (x as BaseBulkDose).Expired == true);
NumberOfExpiredItems = a.Count();
NumberOfExpiredItems += b.Count();
NumberOfExpiredItems += c.Count();
ActivityOfExpiredItems = a.Select(x => (x as BaseRadioactiveInventoryItem).CurrentActivity).Sum();
ActivityOfExpiredItems += b.Select(x => (x as BaseRadioactiveInventoryItem).CurrentActivity).Sum();
ActivityOfExpiredItems += c.Select(x => (x as BaseRadioactiveInventoryItem).CurrentActivity).Sum();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Exception: " + ex.Message);
}
}
public void AddItem(ItemVM selectedItem)
{
Gold -= selectedItem.Price;
InventoryItems.Add(selectedItem);
UpdateStats();
}
public void LoadFull(ZoneCharacter pChar)
{
try
{
locker.WaitOne();
DataTable items = null;
using (var dbClient = Program.CharDBManager.GetClient())
{
items = dbClient.ReadDataTable("SELECT * FROM items WHERE Owner=" + pChar.ID + "");
}
//we load all equippeditem
if (items != null)
{
foreach (DataRow row in items.Rows)
{
var loaded = Item.LoadItem(row);
loaded.Owner = (uint)pChar.ID;
loaded.UpgradeStats = new UpgradeStats();
if (loaded.IsEquipped)
{
loaded.Slot = (sbyte)loaded.ItemInfo.Slot;
EquippedItems.Add(loaded);
}
else
{
InventoryItems.Add((byte)loaded.Slot, loaded);
}
}
}
//we load inventory slots
if (items != null)
{
foreach (DataRow row in items.Rows)
{
var loaded = Item.LoadItem(row);
/* if (loaded.ItemInfo.Class == ItemClass.Rider)
* {
* Mount mount = Data.DataProvider.Instance.GetMountByItemID(loaded.ID);
* if (mount != null)
* {
* loaded.Mount = mount;
* loaded.Mount.Food = GetDataTypes.GetUshort(row["fuelcount"]);
* loaded.Mount.ItemSlot = (byte)loaded.Slot;
* }
* this.AddToInventory(loaded);
* }
* else
* {*/
AddToInventory(loaded);
//}
}
}
}
finally
{
locker.ReleaseMutex();
}
}
private static void Add(string columnNameKey, string id, string description)
{
InventoryItemModel inventoryItem = new InventoryItemModel(columnNameKey, id, description);
InventoryItems.Add(inventoryItem);
}
public void AddModel(InventoryItemModel item, string value)
{
item.DisplayValue = value;
InventoryItems.Add(item);
}
