public void UserCantShopWithoutMoney()
{
_session.Character.Gold = 500000;
var items = new List <ItemDto>
{
new Item {
Type = NoscorePocketType.Etc, VNum = 1, IsSoldable = true, Price = 500000
}
};
var itemBuilder = new ItemProvider(items,
new List <IEventHandler <Item, Tuple <InventoryItemInstance, UseItemPacket> > >());
var list = new ConcurrentDictionary <int, ShopItem>();
list.TryAdd(0, new ShopItem {
Slot = 0, ItemInstance = itemBuilder.Create(1, -1), Type = 0
});
var shop = new Shop
{
ShopItems = list
};
_session.Character.Buy(shop, 0, 99);
var packet = (SMemoPacket)_session.LastPackets.FirstOrDefault(s => s is SMemoPacket);
Assert.IsTrue(packet.Message ==
Language.Instance.GetMessageFromKey(LanguageKey.NOT_ENOUGH_MONEY, _session.Account.Language));
}
public void UserCantShopMoreThanQuantityNonExistingSlot()
{
_session.Character.Gold = 9999999999;
var items = new List <ItemDto>
{
new Item {
Type = NoscorePocketType.Etc, VNum = 1, IsSoldable = true, Price = 500000
}
};
var itemBuilder = new ItemProvider(items,
new List <IEventHandler <Item, Tuple <InventoryItemInstance, UseItemPacket> > >());
var list = new ConcurrentDictionary <int, ShopItem>();
list.TryAdd(0, new ShopItem {
Slot = 0, ItemInstance = itemBuilder.Create(1, -1), Type = 0, Amount = 98
});
var shop = new Shop
{
ShopItems = list
};
_session.Character.Buy(shop, 0, 99);
Assert.IsNull(_session.LastPackets.FirstOrDefault());
}
private static RegionMarketOrders GetRegionMarketOrders(long regionId, int itemLimit = -1, bool cacheOnly = false)
{
RegionMarketOrders result = new RegionMarketOrders();
result.RegionId = regionId;
var items = ItemProvider.Items();
if (itemLimit > -1)
{
items = items.Take(itemLimit).ToDictionary(pair => pair.Key, pair => pair.Value);
}
List <Task <ItemMarketOrders> > allTasks = new List <Task <ItemMarketOrders> >();
foreach (var item in items)
{
allTasks.Add(GetItemMarketOrdersAsync(regionId, item.Key, cacheOnly));
}
Task.WaitAll(allTasks.ToArray());
foreach (var task in allTasks)
{
result.ItemMarketOrders.Add(task.Result);
}
return(result);
}
public GetItemByPathArgs([NotNull] ItemProvider defaultProvider, [NotNull] string itemPath, [NotNull] Language language, [NotNull] Version version, [NotNull] Database database, SecurityCheck securityCheck)
: base(defaultProvider, language, version, database, securityCheck)
{
Assert.ArgumentNotNull(itemPath, "itemPath");
this.itemPath = itemPath;
}
/// <summary>
/// Creates a new scrapbook response.
/// </summary>
/// <param name="args">The response arguments.</param>
/// <param name="serverUri">The server's <see cref="Uri"/>.</param>
/// <exception cref="ArgumentException">When the arguments have not a minimum length of 1.</exception>
/// <exception cref="ArgumentNullException">When serverUri is null.</exception>
public ScrapbookResponse(string[] args, Uri serverUri)
: base(args)
{
if (Args.Length < 1) throw new ArgumentException("The arguments must have a minimum length of 1.", "args");
if (serverUri == null) throw new ArgumentNullException("serverUri");
Items = new List<IScrapbookItem>();
var itemProvider = new ItemProvider(serverUri);
var byteArray = Convert.FromBase64String(Args.First());
var scrapbookContent = new List<int>();
foreach (var b in byteArray)
{
scrapbookContent.Add((b & 128)/128);
scrapbookContent.Add((b & 64)/64);
scrapbookContent.Add((b & 32)/32);
scrapbookContent.Add((b & 16)/16);
scrapbookContent.Add((b & 8)/8);
scrapbookContent.Add((b & 4)/4);
scrapbookContent.Add((b & 2)/2);
scrapbookContent.Add(b & 1);
}
Items.AddRange(itemProvider.CreateMonsterItems(scrapbookContent));
Items.AddRange(itemProvider.CreateValuableItems(scrapbookContent));
Items.AddRange(itemProvider.CreateWarriorItems(scrapbookContent));
Items.AddRange(itemProvider.CreateMageOrScoutItems<MageItem>(scrapbookContent));
Items.AddRange(itemProvider.CreateMageOrScoutItems<ScoutItem>(scrapbookContent));
}
/// <summary>
/// Initializes a new instance of the <see cref="ItemProviderTests"/> class.
/// </summary>
public ItemProviderTests()
{
itemProvider = new Mock <ItemProvider>("test");
itemProvider.CallBase = true;
mockProvider = new MockItemProvider("mock");
}
public void UserCanShopReput()
{
_session.Character.Reput = 500000;
var items = new List <Item>
{
new Item {
Type = PocketType.Etc, VNum = 1, IsSoldable = true, ReputPrice = 1
},
};
var itemBuilder = new ItemProvider(items, new List <IHandler <Item, Tuple <IItemInstance, UseItemPacket> > >());
_session.Character.ItemProvider = itemBuilder;
var list = new ConcurrentDictionary <int, ShopItem>();
list.TryAdd(0, new ShopItem {
Slot = 0, ItemInstance = itemBuilder.Create(1, -1), Type = 0
});
var shop = new Shop
{
ShopItems = list
};
_session.Character.Inventory.AddItemToPocket(itemBuilder.Create(1, 1, 999), PocketType.Etc, 0);
_session.Character.Inventory.AddItemToPocket(itemBuilder.Create(1, 2, 999), PocketType.Etc, 1);
_session.Character.Inventory.AddItemToPocket(itemBuilder.Create(1, 3, 1), PocketType.Etc, 2);
_session.Character.Buy(shop, 0, 998);
Assert.IsTrue(_session.Character.Inventory.All(s => s.Value.Amount == 999));
Assert.IsTrue(_session.Character.Reput == 499002);
}
public EveMarketHistoryDataAnalysis GetAnalysis(int itemLimit)
{
var data = _eveMarketData.RegionMarketHistories;
var baseRegionId = 10000002; //Jita
var baseRegionData = data.FirstOrDefault(h => h.RegionId == baseRegionId);
data.Remove(baseRegionData);
EveMarketHistoryDataAnalysis result = new EveMarketHistoryDataAnalysis();
foreach (var regionDataHistory in data)
{
var itemMarketHistories = regionDataHistory.ItemMarketHistories;
var regionComparison = new RegionItemHistoryComparison
{
BaseRegionId = baseRegionId,
RegionId = regionDataHistory.RegionId
};
result.RegionComparisons.Add(regionComparison);
if (itemLimit > -1)
{
itemMarketHistories = itemMarketHistories.Take(itemLimit).ToList();
}
foreach (var itemMarketHistory in itemMarketHistories)
{
try
{
var itemComparison = new ItemHistoryComparison();
var history = itemMarketHistory.MarketHistory[itemMarketHistory.MarketHistory.Length - 1];
var baseHistories = baseRegionData.ItemMarketHistories.Where(h => h.ItemId == itemMarketHistory.ItemId).FirstOrDefault();
var baseHistory = baseHistories.MarketHistory[baseHistories.MarketHistory.Length - 1];
itemComparison.BaseRegionId = baseRegionId;
itemComparison.ItemId = itemMarketHistory.ItemId;
itemComparison.RegionId = regionComparison.RegionId;
itemComparison.AveragePrice = history.average;
itemComparison.BaseAveragePrice = baseHistory.average;
itemComparison.ItemName = ItemProvider.Items()[itemComparison.ItemId].Replace(',', ' ');
itemComparison.Volume = history.volume;
itemComparison.BaseVolume = baseHistory.volume;
regionComparison.ItemComparisons.Add(itemComparison);
}
catch (NullReferenceException)
{
continue;
}
catch (IndexOutOfRangeException)
{
continue;
}
}
}
return(result);
}
public async Task UserCantShopWithoutReputAsync()
{
_session !.Character.Reput = 500000;
var items = new List <ItemDto>
{
new Item {
Type = NoscorePocketType.Etc, VNum = 1, IsSoldable = true, ReputPrice = 500000
}
};
var itemBuilder = new ItemProvider(items,
new List <IEventHandler <Item, Tuple <InventoryItemInstance, UseItemPacket> > >(), Logger);
var list = new ConcurrentDictionary <int, ShopItem>();
list.TryAdd(0, new ShopItem {
Slot = 0, ItemInstance = itemBuilder.Create(1, -1), Type = 0
});
var shop = new Shop
{
ShopItems = list
};
await _session.Character.BuyAsync(shop, 0, 99).ConfigureAwait(false);
var packet = (SMemoPacket?)_session.LastPackets.FirstOrDefault(s => s is SMemoPacket);
Assert.IsTrue(packet?.Message ==
GameLanguage.Instance.GetMessageFromKey(LanguageKey.NOT_ENOUGH_REPUT, _session.Account.Language));
}
/// <summary>
/// Places items in the dungeon
/// </summary>
/// <param name="worldRef">The world in which to place the items</param>
/// <param name="prosperity">The prosperity of the world, the lower the better</param>
/// <returns>The items placed</returns>
public static List <ItemInstance> PlaceItems(WorldInstance worldRef, int prosperity = 50)
{
List <ItemInstance> placedItems = new List <ItemInstance>();
int dungeonArea = worldRef.Tiles.GetLength(0) * worldRef.Tiles.GetLength(1);
int itemsToPlace = dungeonArea / prosperity;
List <Vector2Int> unavailablePoints = new List <Vector2Int>();
foreach (JoyObject wall in worldRef.Walls.Values)
{
unavailablePoints.Add(wall.WorldPosition);
}
for (int i = 0; i < itemsToPlace; i++)
{
Vector2Int point = new Vector2Int(RNG.Roll(1, worldRef.Tiles.GetLength(0) - 1), RNG.Roll(1, worldRef.Tiles.GetLength(1) - 1));
while (unavailablePoints.Contains(point))
{
point = new Vector2Int(RNG.Roll(1, worldRef.Tiles.GetLength(0) - 1), RNG.Roll(1, worldRef.Tiles.GetLength(1) - 1));
}
ItemInstance item = ItemProvider.RandomItem(false);
item.Move(point);
placedItems.Add(item);
}
return(placedItems);
}
public async Task UserCanNotShopNonExistingSlotAsync()
{
_session !.Character.Gold = 9999999999;
var items = new List <ItemDto>
{
new Item {
Type = NoscorePocketType.Etc, VNum = 1, IsSoldable = true, Price = 500000
}
};
var itemBuilder = new ItemProvider(items,
new List <IEventHandler <Item, Tuple <InventoryItemInstance, UseItemPacket> > >(), Logger);
var list = new ConcurrentDictionary <int, ShopItem>();
list.TryAdd(0, new ShopItem {
Slot = 0, ItemInstance = itemBuilder.Create(1, -1), Type = 0
});
var shop = new Shop
{
ShopItems = list
};
await _session.Character.BuyAsync(shop, 1, 99).ConfigureAwait(false);
Assert.IsNull(_session.LastPackets.FirstOrDefault());
}
public object ComputeFieldValue(IIndexable indexable)
{
var item = ItemProvider.Get(indexable);
if (item == null)
{
return(null);
}
if (!ShouldIndexItem(item))
{
return(null);
}
var dataSources =
Globals.LinkDatabase.GetReferences(item)
.Where(link => ShouldProcessLink(link, item))
.Select(link => link.GetTargetItem())
.Where(targetItem => targetItem != null)
.Distinct();
var result = new StringBuilder();
foreach (var dataSource in dataSources.Where(ShouldIndexDataSource))
{
IndexItemFields(dataSource, result);
foreach (var childItem in dataSource.Children.ToArray())
{
IndexItemFields(childItem, result);
}
}
return(result.ToString());
}
public void UserCanNotSellNotSoldable()
{
var items = new List <ItemDto>
{
new Item {
Type = PocketType.Etc, VNum = 1, IsSoldable = false
},
};
var itemBuilder = new ItemProvider(items, new List <IHandler <Item, Tuple <IItemInstance, UseItemPacket> > >());
_session.Character.Inventory.AddItemToPocket(itemBuilder.Create(1, 1), PocketType.Etc, 0);
_session.Character.Inventory.AddItemToPocket(itemBuilder.Create(1, 2), PocketType.Etc, 1);
_session.Character.Inventory.AddItemToPocket(itemBuilder.Create(1, 3), PocketType.Etc, 2);
_session.Character.MapInstance = _instanceProvider.GetBaseMapById(1);
_handler.SellShop(new SellPacket {
Slot = 0, Amount = 1, Data = (short)PocketType.Etc
});
var packet = (SMemoPacket)_session.LastPacket;
Assert.IsTrue(packet.Message ==
Language.Instance.GetMessageFromKey(LanguageKey.ITEM_NOT_SOLDABLE, _session.Account.Language));
Assert.IsTrue(_session.Character.Gold == 0);
Assert.IsNotNull(_session.Character.Inventory.LoadBySlotAndType <IItemInstance>(0, PocketType.Etc));
}
private static RegionMarketHistory GetRegionMarketHistory(long regionId, bool cacheOnly, int itemLimit)
{
RegionMarketHistory result = new RegionMarketHistory();
result.RegionId = regionId;
var items = ItemProvider.Items();
if (itemLimit > -1)
{
items = items.Take(itemLimit).ToDictionary(pair => pair.Key, pair => pair.Value);
}
List <Task <ItemMarketHistory> > marketHistoryTasks = new List <Task <ItemMarketHistory> >();
foreach (var item in items)
{
marketHistoryTasks.Add(GetItemMarketHistoryAsync(regionId, item.Key, cacheOnly));
}
Task.WaitAll(marketHistoryTasks.ToArray());
foreach (var task in marketHistoryTasks)
{
result.ItemMarketHistories.Add(task.Result);
}
return(result);
}
public void UserCantShopWithoutPlace()
{
_session.Character.Gold = 500000;
var items = new List <Item>
{
new Item {
Type = PocketType.Etc, VNum = 1, IsSoldable = true, Price = 1
},
};
var itemBuilder = new ItemProvider(items, new List <IHandler <Item, Tuple <IItemInstance, UseItemPacket> > >());
_session.Character.ItemProvider = itemBuilder;
var list = new ConcurrentDictionary <int, ShopItem>();
list.TryAdd(0, new ShopItem {
Slot = 0, ItemInstance = itemBuilder.Create(1, -1), Type = 0
});
var shop = new Shop
{
ShopItems = list
};
_session.Character.Inventory.AddItemToPocket(itemBuilder.Create(1, 1, 999), PocketType.Etc, 0);
_session.Character.Inventory.AddItemToPocket(itemBuilder.Create(1, 2, 999), PocketType.Etc, 1);
_session.Character.Inventory.AddItemToPocket(itemBuilder.Create(1, 3, 999), PocketType.Etc, 2);
_session.Character.Buy(shop, 0, 999);
var packet = (MsgPacket)_session.LastPacket;
Assert.IsTrue(packet.Message == Language.Instance.GetMessageFromKey(LanguageKey.NOT_ENOUGH_PLACE, _session.Account.Language));
}
public async Task UserCanNotSellNotSoldableAsync()
{
var items = new List <ItemDto>
{
new Item {
Type = NoscorePocketType.Etc, VNum = 1, IsSoldable = false
}
};
var itemBuilder = new ItemProvider(items,
new List <IEventHandler <Item, Tuple <InventoryItemInstance, UseItemPacket> > >(), _logger);
_session !.Character.InventoryService !.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 1), 0),
NoscorePocketType.Etc, 0);
_session.Character.InventoryService.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 2), 0),
NoscorePocketType.Etc, 1);
_session.Character.InventoryService.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 3), 0),
NoscorePocketType.Etc, 2);
_session.Character.MapInstance = _instanceProvider !.GetBaseMapById(1);
await _sellPacketHandler !.ExecuteAsync(new SellPacket {
Slot = 0, Amount = 1, Data = (short)NoscorePocketType.Etc
},
_session).ConfigureAwait(false);
var packet = (SMemoPacket?)_session.LastPackets.FirstOrDefault(s => s is SMemoPacket);
Assert.IsTrue(packet?.Message ==
GameLanguage.Instance.GetMessageFromKey(LanguageKey.ITEM_NOT_SOLDABLE, _session.Account.Language));
Assert.IsTrue(_session.Character.Gold == 0);
Assert.IsNotNull(_session.Character.InventoryService.LoadBySlotAndType(0, NoscorePocketType.Etc));
}
void Update()
{
Search(); //Called when searching is set to true
//Begin search
if (isTouchingItemProvider == true && Input.GetButtonDown("Interact") && searching == false)
{
if (IP.checkedThisProvider == false)
{
searching = true;
FindObjectOfType <AudioManager>().Play("Searching");
}
}
//Cancel search
else if (isTouchingItemProvider == true && Input.GetButtonDown("Interact") && searching == true)
{
EndSearch(true);
}
//Cancel search
else if (isTouchingItemProvider == false && searching == true)
{
EndSearch(true);
IP = null;
closedObject = null;
openedObject = null;
}
}
public byte[] GetResourceContents(ItemIdentifier itemId, Type itemType, Resource resource, string revisionAlias)
{
if (revisionAlias != null)
{
//check if the resource has already been packaged before
resource.ResourceContents = resource.ToByteArray(Core.Settings.revisionsPath + "/" + revisionAlias + "/" +
Core.Settings.ResourcesFolderName);
if (resource.ResourceContents != null)
{
return(resource.ResourceContents);
}
}
ItemProvider provider = null;
if (!string.IsNullOrEmpty(resource.ExtractToPath) && itemType != null)
{
provider = Umbraco.Courier.Core.ProviderModel.ItemProviderCollection.Instance.GetProvider(itemId.ProviderId, Database, ExecutionContext);
ResolutionManager.Instance.PackagingResource(itemId, itemType, resource, provider);
}
resource.ResourceContents = resource.ToByteArray("~/");
//if (!string.IsNullOrEmpty(resource.ExtractToPath) && itemType != null)
// ResolutionManager.Instance.PackagedResource(itemId, itemType, resource, provider);
return(resource.ResourceContents);
}
public GetItemByIdArgs([NotNull] ItemProvider defaultProvider, [NotNull] ID itemId, [NotNull] Language language, [NotNull] Version version, [NotNull] Database database, SecurityCheck securityCheck)
: base(defaultProvider, language, version, database, securityCheck)
{
Assert.ArgumentNotNull(itemId, "itemId");
this.itemId = itemId;
}
public async Task UserCanNotSellInExchangeAsync()
{
_session !.Character.InShop = true;
var items = new List <ItemDto>
{
new Item {
Type = NoscorePocketType.Etc, VNum = 1, IsTradable = true
}
};
var itemBuilder = new ItemProvider(items,
new List <IEventHandler <Item, Tuple <InventoryItemInstance, UseItemPacket> > >(), _logger);
_session.Character.InventoryService !.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 1), 0),
NoscorePocketType.Etc, 0);
_session.Character.InventoryService.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 2), 0),
NoscorePocketType.Etc, 1);
_session.Character.InventoryService.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 3), 0),
NoscorePocketType.Etc, 2);
_session.Character.MapInstance = _instanceProvider !.GetBaseMapById(1);
await _sellPacketHandler !.ExecuteAsync(new SellPacket {
Slot = 0, Amount = 1, Data = (short)NoscorePocketType.Etc
},
_session).ConfigureAwait(false);
Assert.IsTrue(_session.Character.Gold == 0);
Assert.IsNotNull(_session.Character.InventoryService.LoadBySlotAndType(0, NoscorePocketType.Etc));
}
public void Setup()
{
var items = new List <ItemDto>
{
new Item {
Type = PocketType.Main, VNum = 1012
},
new Item {
Type = PocketType.Main, VNum = 1013
},
new Item {
Type = PocketType.Equipment, VNum = 1, ItemType = ItemType.Weapon
},
new Item {
Type = PocketType.Equipment, VNum = 2, ItemType = ItemType.Weapon
},
new Item {
Type = PocketType.Equipment, VNum = 912, ItemType = ItemType.Specialist
},
new Item {
Type = PocketType.Equipment, VNum = 924, ItemType = ItemType.Fashion
}
};
_itemProvider = new ItemProvider(items, new List <IHandler <Item, Tuple <IItemInstance, UseItemPacket> > >());
Inventory = new InventoryService(items, new WorldConfiguration {
BackpackSize = 3, MaxItemAmount = 999
}, _logger);
}
public SaveItemArgs([NotNull] ItemProvider defaultProvider, [NotNull] Item item)
: base(defaultProvider)
{
Assert.ArgumentNotNull(item, "item");
this.item = item;
}
private static void InitGameData()
{
using (var fs = new WzFileSystem {
BaseDir = Constants.GameDataPath
})
{
fs.Init(Constants.GameDataPath + @"img\Data");
var sw = new Stopwatch();
sw.Start();
Task.WaitAll(Task.Run(() => { StringData = new StringProvider(fs); }),
Task.Run(() => { EquipTemplates = new EquipProvider(fs); }),
Task.Run(() => { ItemOptionTemplates = new ItemOptionProvider(fs); }),
Task.Run(() => { ItemTemplates = new ItemProvider(fs); }),
Task.Run(() => { QuestTemplates = new QuestProvider(fs); }),
Task.Run(() => { MobSkillTemplates = new MobSkillProvider(fs); }),
Task.Run(() => { SkillTemplates = new SkillProvider(fs); }),
Task.Run(() => { ItemMakeTemplates = new ItemMakeProvider(fs); }),
Task.Run(() => { CommodityProvider = new CashCommodityProvider(fs); }),
Task.Run(() => { PackageProvider = new CashPackageProvider(fs); }),
Task.Run(() => { NpcTemplates = new NpcProvider(fs); }),
Task.Run(() => { ReactorTemplates = new ReactorProvider(fs); }),
Task.Run(() => { MapTemplates = new MapProvider(fs); }),
Task.Run(() => { MobTemplates = new MobProvider(fs); })
);
sw.Stop();
Log.Info("Startup seconds elapsed: " + sw.ElapsedMilliseconds / 1000);
}
}
private async void button1_Click(object sender, EventArgs e)
{
string searchTerm = txtSearchTerm.Text.TrimEnd().ToLower();
var region = (KeyValuePair <long, string>)ddlRegion.SelectedItem;
var items = ItemProvider.Items().Where(i => i.Value.ToLower().Equals(searchTerm));
if (items.Count() > 1)
{
MessageBox.Show($"Found more than one result for { searchTerm }");
return;
}
else if (items.Count() == 0)
{
MessageBox.Show($"No results found for { searchTerm }");
return;
}
var item = items.FirstOrDefault();
var orders = await MarketOrderProvider.GetItemMarketOrdersAsync(region.Key, item.Key);
var buyOrders = orders.MarketOrders.Where(o => o.is_buy_order).OrderByDescending(o => o.price).ToList();
var sellOrders = orders.MarketOrders.Where(o => !o.is_buy_order).OrderBy(o => o.price).ToList();
BindingList <MarketOrder> buyOrderBindingList = new BindingList <MarketOrder>(buyOrders);
BindingList <MarketOrder> sellOrderBindingList = new BindingList <MarketOrder>(sellOrders);
dgvBuyOrders.DataSource = buyOrderBindingList;
dgvSellOrders.DataSource = sellOrderBindingList;
dgvBuyOrders.Columns[6].DefaultCellStyle.Format = "c";
dgvSellOrders.Columns[6].DefaultCellStyle.Format = "c";
}
public void UserCanSell()
{
var items = new List <ItemDto>
{
new Item {
Type = NoscorePocketType.Etc, VNum = 1, IsSoldable = true, Price = 500000
}
};
var itemBuilder = new ItemProvider(items,
new List <IEventHandler <Item, Tuple <InventoryItemInstance, UseItemPacket> > >());
_session.Character.InventoryService.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 1), 0),
NoscorePocketType.Etc, 0);
_session.Character.InventoryService.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 2), 0),
NoscorePocketType.Etc, 1);
_session.Character.InventoryService.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 3), 0),
NoscorePocketType.Etc, 2);
_session.Character.MapInstance = _instanceProvider.GetBaseMapById(1);
_sellPacketHandler.Execute(new SellPacket {
Slot = 0, Amount = 1, Data = (short)NoscorePocketType.Etc
},
_session);
Assert.IsTrue(_session.Character.Gold > 0);
Assert.IsNull(_session.Character.InventoryService.LoadBySlotAndType(0, NoscorePocketType.Etc));
}
private BChunk BuildIndexChunk()
{
backup.AddHubNotificationEvent(704, "", "");
BChunk iChunk = new BChunk(/*backup.TaskId, */ backup.Index.FullName, backup.Index.FullName, backup.TaskId); //string name, int bsid, string bPath, string snapPath)
try{
//iChunk.Add(FileProvider.GetFile(index.FullName));
iChunk.Add(new MinimalFsItem(backup.Index.FullName));
if (backup.DataFlags.HasFlag(DataProcessingFlags.CDedup)) // backup the deduplication database
{
iChunk.Add(ItemProvider.GetProvider().GetItemByPath(DedupIndex.Instance().IndexDBName));
}
/*string sumHash;
* using(FileStream cksumFS = new FileStream(backup.Index.FullName, FileMode.Open, FileAccess.Read)){
* sumHash = BitConverter.ToString(SHA1.Create().ComputeHash(cksumFS));
* iChunk.Sum = sumHash;
* }*/
iChunk.Sum = IndexManager.CheckSumIndex(backup.TaskId, (backup.Level != BackupLevel.Full));
// register for session received, to process index transfer
User.StorageSessionReceivedEvent += new User.StorageSessionReceivedHandler(this.SendIndex);
User.AskIndexDest(backup.TaskId, backup.Index.Name, iChunk.Sum);
Logger.Append(Severity.DEBUG, "Asked index destination to hub");
return(iChunk);
}
catch (Exception e) {
Logger.Append(Severity.ERROR, "Couldn't checksum index and/or ask destination to hub: " + e.Message + "---" + e.StackTrace);
backup.AddHubNotificationEvent(808, e.Message, "");
}
return(null);
}
public void UserCantShopWithoutReput()
{
_session.Character.Reput = 500000;
var items = new List <Item>
{
new Item {
Type = PocketType.Etc, VNum = 1, IsSoldable = true, ReputPrice = 500000
},
};
var itemBuilder = new ItemProvider(items, new List <IHandler <Item, Tuple <IItemInstance, UseItemPacket> > >());
var list = new ConcurrentDictionary <int, ShopItem>();
list.TryAdd(0, new ShopItem {
Slot = 0, ItemInstance = itemBuilder.Create(1, -1), Type = 0
});
var shop = new Shop
{
ShopItems = list
};
_session.Character.Buy(shop, 0, 99);
var packet = (SMemoPacket)_session.LastPacket;
Assert.IsTrue(packet.Message == Language.Instance.GetMessageFromKey(LanguageKey.NOT_ENOUGH_REPUT, _session.Account.Language));
}
public async Task UserCanNotCreateShopWithMissingAmountItemAsync()
{
var items = new List <ItemDto>
{
new Item {
Type = NoscorePocketType.Etc, VNum = 1
}
};
var itemBuilder = new ItemProvider(items,
new List <IEventHandler <Item, Tuple <InventoryItemInstance, UseItemPacket> > >(), Logger);
_session !.Character.InventoryService !.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 1), 0),
NoscorePocketType.Etc, 0);
_session.Character.InventoryService.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 1), 0),
NoscorePocketType.Etc, 1);
_session.Character.InventoryService.AddItemToPocket(InventoryItemInstance.Create(itemBuilder.Create(1, 1), 0),
NoscorePocketType.Etc, 2);
_session.Character.MapInstance = TestHelpers.Instance.MapInstanceProvider.GetBaseMapById(1);
await _mShopPacketHandler !.ExecuteAsync(_shopPacket, _session).ConfigureAwait(false);
Assert.IsNull(_session.Character.Shop);
var packet = (SayPacket?)_session.LastPackets.FirstOrDefault(s => s is SayPacket);
Assert.IsTrue(packet?.Message ==
GameLanguage.Instance.GetMessageFromKey(LanguageKey.SHOP_ONLY_TRADABLE_ITEMS, _session.Account.Language));
}
/// <summary>
/// Callback for highlighting a new item.
/// Updates the text box on the main form.
/// </summary>
/// <param name="sender">sender object</param>
/// <param name="e">SackPanelEventArgs data</param>
private void NewItemHighlightedCallback(object sender, SackPanelEventArgs e)
{
Item item = e.Item;
SackCollection sack = e.Sack;
SackPanel sackPanel = (SackPanel)sender;
if (item == null)
{
// Only do something if this sack is the "owner" of the current item highlighted.
if (sack == this.lastSackHighlighted)
{
this.itemText.Text = string.Empty;
// hide the tooltip
this.tooltipText = null;
this.tooltip.ChangeText(this.tooltipText);
}
}
else
{
string text = ItemProvider.ToFriendlyName(item);
Color color = ItemGfxHelper.GetColorTag(item, text);
text = Item.ClipColorTag(text);
this.itemText.ForeColor = color;
this.itemText.Text = text;
string attributes = ItemHtmlHelper.GetAttributes(item, true); // true means hide uninteresting attributes
string setitems = ItemHtmlHelper.GetItemSetString(item);
string reqs = ItemHtmlHelper.GetRequirements(item);
// combine the 2
if (reqs.Length < 1)
{
this.tooltipText = attributes;
}
else if (setitems.Length < 1)
{
string reqTitle = HtmlHelper.MakeSafeForHtml("?Requirements?");
reqTitle = string.Format(CultureInfo.InvariantCulture, "<font size=+2 color={0}>{1}</font><br>", HtmlHelper.HtmlColor(ItemGfxHelper.GetColor(ItemStyle.Potion)), reqTitle);
string separator = string.Format(CultureInfo.InvariantCulture, "<hr color={0}><br>", HtmlHelper.HtmlColor(ItemGfxHelper.GetColor(ItemStyle.Broken)));
this.tooltipText = string.Concat(attributes, separator, reqs);
}
else
{
string reqTitle = HtmlHelper.MakeSafeForHtml("?Requirements?");
reqTitle = string.Format(CultureInfo.InvariantCulture, "<font size=+2 color={0}>{1}</font><br>", HtmlHelper.HtmlColor(ItemGfxHelper.GetColor(ItemStyle.Potion)), reqTitle);
string separator1 = string.Format(CultureInfo.InvariantCulture, "<hr color={0}>", HtmlHelper.HtmlColor(ItemGfxHelper.GetColor(ItemStyle.Broken)));
string separator2 = string.Format(CultureInfo.InvariantCulture, "<hr color={0}><br>", HtmlHelper.HtmlColor(ItemGfxHelper.GetColor(ItemStyle.Broken)));
this.tooltipText = string.Concat(attributes, separator1, setitems, separator2, reqs);
}
// show tooltip
this.tooltipText = string.Concat(HtmlHelper.TooltipBodyTag(Database.DB.Scale), this.tooltipText);
this.tooltip.ChangeText(this.tooltipText);
}
this.lastSackHighlighted = sack;
this.lastSackPanelHighlighted = sackPanel;
}
/// <summary>
/// Loads the item properties
/// </summary>
private void LoadProperties()
{
this.Data = ItemProvider.GetFriendlyNames(this.Item, FriendlyNamesExtraScopes.ItemFullDisplay, this.checkBoxFilterExtraInfo.Checked);
// ItemName
this.labelItemName.ForeColor = this.Data.Item.GetColor(Data.BaseItemInfoDescription);
this.labelItemName.Text = this.Data.FullName.RemoveAllTQTags();
// Base Item Attributes
if (this.Data.BaseAttributes.Any())
{
this.flowLayoutBaseItemProperties.Controls.Clear();
foreach (var prop in this.Data.BaseAttributes)
{
this.flowLayoutBaseItemProperties.Controls.Add(ItemTooltip.MakeRow(prop));
}
this.flowLayoutBaseItemProperties.Show();
this.labelBaseItemProperties.Show();
}
else
{
this.flowLayoutBaseItemProperties.Hide();
this.labelBaseItemProperties.Hide();
}
// Prefix Attributes
if (this.Data.PrefixAttributes.Any())
{
this.flowLayoutPrefixProperties.Controls.Clear();
foreach (var prop in this.Data.PrefixAttributes)
{
this.flowLayoutPrefixProperties.Controls.Add(ItemTooltip.MakeRow(prop));
}
this.flowLayoutPrefixProperties.Show();
this.labelPrefixProperties.Show();
}
else
{
this.flowLayoutPrefixProperties.Hide();
this.labelPrefixProperties.Hide();
}
// Suffix Attributes
if (this.Data.SuffixAttributes.Any())
{
this.flowLayoutSuffixProperties.Controls.Clear();
foreach (var prop in this.Data.SuffixAttributes)
{
this.flowLayoutSuffixProperties.Controls.Add(ItemTooltip.MakeRow(prop));
}
this.flowLayoutSuffixProperties.Show();
this.labelSuffixProperties.Show();
}
else
{
this.flowLayoutSuffixProperties.Hide();
this.labelSuffixProperties.Hide();
}
}
/// <summary>
/// Removes a relic from the item
/// </summary>
private void SplitItemAndRelic()
{
// pull out the relic
Item relic = ItemProvider.RemoveRelic(this.dragInfo.Item);
this.dragInfo.MarkModified(relic);
Refresh();
}
public void CreateMageOrScoutItemsShouldNotContainScoutItemsWithEmptyUri()
{
// Arrange
var sut = new ItemProvider(TestConstants.ValidServerUri);
// Act
var scoutItems = sut.CreateMageOrScoutItems<ScoutItem>(TestConstants.ValidAlbumContent.ToList());
// Assert
scoutItems.Should().NotContain(i => i.ImageUri == null);
}
public void CreateInventoryShouldNotContainAnyItemsWithEmptyUri()
{
// Arrange
var sut = new ItemProvider(TestConstants.ValidServerUri);
var sg = new Savegame(TestConstants.ValidSavegameString);
// Act
var inventory = sut.CreateInventory(sg);
// Assert
inventory.AllItems.Should().NotContain(i => i.ImageUri == null);
}
public void CreateInventoryShouldReturnInventoryWith15Items()
{
// Arrange
var sut = new ItemProvider(TestConstants.ValidServerUri);
var sg = new Savegame(TestConstants.ValidSavegameString);
// Act
var inventory = sut.CreateInventory(sg);
// Assert
inventory.AllItems.Count().Should().Be(15);
}
/// <summary>
/// Creates a new <see cref="Character" /> instance, calculated from a <see cref="CharacterResponse" />. The character's loaded status is initially set to true.
/// </summary>
/// <param name="response">The <see cref="CharacterResponse" /> from which arguments the <see cref="Character" /> is going to calculated.</param>
/// <param name="username">The username of the character.</param>
/// <param name="session">The session, where the character is going to be attatched to.</param>
/// <param name="serverUri">The server <see cref="Uri"/>.</param>
/// <exception cref="ArgumentNullException">When savegame is empty or username is null or empty.</exception>
/// <exception cref="ArgumentException">When session or response is null.</exception>
public Character(ICharacterResponse response, string username, ISession session, Uri serverUri)
{
if (response == null)
throw new ArgumentNullException("response");
if (string.IsNullOrWhiteSpace(username))
throw new ArgumentException("Username must not be null or empty.", "username");
if (response.Savegame == null)
throw new ArgumentException("Character response must contain a savegame.", "response");
if (session == null)
throw new ArgumentNullException("session");
_username = username;
_session = session;
_guild = response.Guild;
_itemProvider = new ItemProvider(serverUri);
LoadFromSavegame(response.Savegame);
IsLoaded = true;
}
public void CreateMageOrScoutItemsThrowsExceptionWithInvalidTypeParameter()
{
// Arrange
var sut = new ItemProvider(TestConstants.ValidServerUri);
// Act
Action createInvalidItems = () => sut.CreateMageOrScoutItems<MonsterItem>(TestConstants.ValidAlbumContent.ToList());
// Assert
createInvalidItems.ShouldThrow<ArgumentException>()
.Where(e => e.Message == "TScrapbookItem be of type MageItem or ScoutItem.");
}
/// <summary>
/// Mocks the item provider.
/// </summary>
protected virtual void MockItemProvider()
{
var itemProvider = new ItemProvider();
ProviderHelper<ItemProvider, ItemProviderCollection>.DefaultProvider = itemProvider;
itemProvider.Initialize("mock", new NameValueCollection());
}
private object ResolvePropertyItemData(
Item item,
ItemProvider itemProvider,
object value,
string propertyEditorAlias,
string propertyTypeAlias,
Guid dataTypeGuid,
Direction direction = Direction.Packaging)
{
// create a 'fake' item for Courier to process
var fakeItem = new ContentPropertyData
{
ItemId = item.ItemId,
Name = string.Format("{0} [{1}: {2} ({3})]", item.Name, EditorAlias, propertyEditorAlias, propertyTypeAlias),
Data = new List<ContentProperty>
{
new ContentProperty
{
Alias = propertyTypeAlias,
DataType = dataTypeGuid,
PropertyEditorAlias = propertyEditorAlias,
Value = value
}
}
};
if (direction == Direction.Packaging)
{
try
{
// run the 'fake' item through Courier's data resolvers
ResolutionManager.Instance.PackagingItem(fakeItem, itemProvider);
}
catch (Exception ex)
{
CourierLogHelper.Error<MortarDataResolver>(string.Concat("Error packaging data value: ", fakeItem.Name), ex);
}
// pass up the dependencies
if (fakeItem.Dependencies != null && fakeItem.Dependencies.Count > 0)
item.Dependencies.AddRange(fakeItem.Dependencies);
// pass up the resources
if (fakeItem.Resources != null && fakeItem.Resources.Count > 0)
item.Resources.AddRange(fakeItem.Resources);
}
else if (direction == Direction.Extracting)
{
try
{
// run the 'fake' item through Courier's data resolvers
ResolutionManager.Instance.ExtractingItem(fakeItem, itemProvider);
item.Status = ItemStatus.NeedPostProcessing;
item.PostProcess = true;
}
catch (Exception ex)
{
CourierLogHelper.Error<MortarDataResolver>(string.Concat("Error extracting data value: ", fakeItem.Name), ex);
}
}
// return the resolved data from the 'fake' item
if (fakeItem.Data != null && fakeItem.Data.Any())
return fakeItem.Data.FirstOrDefault().Value;
return value;
}
private JObject ResolveMultiplePropertyItemData(
Item item,
ItemProvider itemProvider,
object rawValue,
string docTypeAlias,
Direction direction)
{
// if we return a `null`, then JSON serialization will throw an `ArgumentNullException`,
// so we return an empty `JObject` instead.
var defaultValue = new JObject();
if (rawValue == null)
return defaultValue;
var rawJson = rawValue.ToString();
if (string.IsNullOrWhiteSpace(rawJson))
return defaultValue;
var jobj = JObject.Parse(rawJson);
if (jobj == null)
return defaultValue;
var propertyItemData = new Dictionary<string, object>();
var propertyValues = jobj.ToObject<Dictionary<string, object>>();
var documentType = ExecutionContext.DatabasePersistence.RetrieveItem<DocumentType>(new ItemIdentifier(docTypeAlias, ItemProviderIds.documentTypeItemProviderGuid));
if (documentType == null)
return jobj;
foreach (var propertyValue in propertyValues)
{
if (propertyValue.Key.InvariantEquals("name"))
{
propertyItemData.Add(propertyValue.Key, propertyValue.Value);
continue;
}
var propertyType = documentType.Properties.FirstOrDefault(x => x.Alias.InvariantEquals(propertyValue.Key));
if (propertyType == null)
continue;
var dataType = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>(
new ItemIdentifier(propertyType.DataTypeDefinitionId.ToString(),
ItemProviderIds.dataTypeItemProviderGuid));
if (dataType == null)
continue;
var dataTypeGuid = propertyType.DataTypeDefinitionId;
var propertyTypeAlias = propertyType.Alias;
var propertyEditorAlias = dataType.PropertyEditorAlias;
var value = ResolvePropertyItemData(
item,
itemProvider,
propertyValue.Value,
propertyEditorAlias,
propertyTypeAlias,
dataTypeGuid,
direction);
propertyItemData.Add(propertyValue.Key, value);
}
return JObject.FromObject(propertyItemData);
}
public void CreateMonsterItemsShouldReturn252MonsterItems()
{
// Arrange
var sut = new ItemProvider(TestConstants.ValidServerUri);
// Act
var monsterItems = sut.CreateMonsterItems(TestConstants.ValidAlbumContent.ToList());
// Assert
monsterItems.Count().Should().Be(252);
}
public void CreateMonsterItemsShouldReturnNoItemWithTheSameText()
{
// Arrange
var sut = new ItemProvider(TestConstants.ValidServerUri);
// Act
var monsterItems = sut.CreateMonsterItems(TestConstants.ValidAlbumContent.ToList());
// Assert
var monsterItemTexts = monsterItems.Select(i => i.Text).ToList();
monsterItemTexts.Count.Should().Be(monsterItemTexts.Distinct().Count());
}
public void CreateValuableItemsShouldReturn246ValuableItems()
{
// Arrange
var sut = new ItemProvider(TestConstants.ValidServerUri);
// Act
var valuableItems = sut.CreateValuableItems(TestConstants.ValidAlbumContent.ToList());
// Assert
valuableItems.Count().Should().Be(246);
}
public void CreateWarriorItemsShouldReturn506WarriorItems()
{
// Arrange
var sut = new ItemProvider(TestConstants.ValidServerUri);
// Act
var warriorItems = sut.CreateWarriorItems(TestConstants.ValidAlbumContent.ToList());
// Assert
warriorItems.Count().Should().Be(506);
}
public void CreateMageOrScoutItemsShouldReturn348MageItems()
{
// Arrange
var sut = new ItemProvider(TestConstants.ValidServerUri);
// Act
var mageItems = sut.CreateMageOrScoutItems<MageItem>(TestConstants.ValidAlbumContent.ToList());
// Assert
mageItems.Count().Should().Be(348);
}
