public override bool UseItem(Player player)
{
var mymod = (LicensesMod)this.mod;
int savings;
int oldStack = this.item.stack;
ItemDefinition randItemDef = this.AttemptToLicenseRandomItem(player, out savings);
if (randItemDef == null)
{
Main.NewText("No items of the given tier left to license.", Color.Red);
return(false);
}
int targetRarity = WildcardLicenseItem.ComputeTargetRarityOfLicenseStackSize(oldStack);
Color color = ItemRarityAttributeHelpers.RarityColor[targetRarity];
string randItemName = ItemAttributeHelpers.GetQualifiedName(randItemDef.Type);
string msg = randItemName + " licensed";
if (savings > 0)
{
msg += " - " + savings + " discounted";
}
PlayerMessages.AddPlayerLabel(player, msg, color, 2 * 60, true);
Main.NewText(msg, color);
if (LicensesMod.Config.DebugModeInfo)
{
LogHelpers.Alert(randItemName + " unlocked");
}
return(true);
}
////////////////
internal void TrialLicenseItemByDefinition(ItemDefinition itemDef, bool playSound)
{
var mymod = (LicensesMod)this.mod;
if (this.TrialLicensedItem != null)
{
string itemName = ItemAttributeHelpers.GetQualifiedName(this.TrialLicensedItem.Type);
Main.NewText(itemName + " trial cancelled.", Color.Yellow);
if (!this.LicensedItems.Contains(itemDef))
{
NihilismAPI.UnsetItemWhitelistEntry(this.TrialLicensedItem, true);
}
}
this.TrialLicensedItems.Add(itemDef);
this.TrialLicensedItem = itemDef;
NihilismAPI.SetItemWhitelistEntry(itemDef, true);
Timers.UnsetTimer("LicensesTrialPeriod");
Timers.SetTimer("LicensesTrialPeriod", LicensesMod.Config.TrialLicenseDurationInTicks, () => {
var myplayer = (LicensesPlayer)TmlHelpers.SafelyGetModPlayer(Main.LocalPlayer, mymod, "LicensesPlayer");
if (!myplayer.LicensedItems.Contains(itemDef))
{
string itemName = ItemAttributeHelpers.GetQualifiedName(itemDef.Type);
Main.NewText(itemName + " trial has expired.", Color.Yellow);
NihilismAPI.UnsetItemWhitelistEntry(itemDef, true);
myplayer.TrialLicensedItem = null;
}
return(false);
});
if (playSound)
{
Main.PlaySound(SoundID.Unlock, player.position);
}
}
////////////////
/// <summary>
/// Gets the "qualified" name (the name the player sees) of a given entity.
/// </summary>
/// <param name="ent"></param>
/// <returns></returns>
public static string GetQualifiedName(Entity ent)
{
if (ent is Item)
{
return(ItemAttributeHelpers.GetQualifiedName((Item)ent));
}
if (ent is NPC)
{
return(NPCAttributeHelpers.GetQualifiedName((NPC)ent));
}
if (ent is Projectile)
{
return(ProjectileAttributeHelpers.GetQualifiedName((Projectile)ent));
}
if (ent is Player)
{
return(((Player)ent).name);
}
return("...a " + ent.GetType().Name);
}
////////////////
public void UpdateChatWithTip()
{
if (this.CurrentChat != WanderingGhostNPC.ChatText)
{
return;
}
var mymod = (IntrinsicsMod)this.mod;
int itemCount = mymod.Config.TradeItemContractTatters.Count;
ItemDefinition itemDef = mymod.Config.TradeItemContractTatters
.Keys
.ToArray()
[Main.rand.Next(itemCount)];
if (itemDef.Type == 0)
{
return;
}
string itemName = ItemAttributeHelpers.GetQualifiedName(itemDef.Type);
this.CurrentChat = "..." + itemName + "...";
Main.npcChatText = this.CurrentChat;
}
internal static void DefineItemWeaponGroups1(IList <EntityGroupMatcherDefinition <Item> > defs)
{
// Weapon Classes
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Ranged Weapon", null,
new ItemGroupMatcher((item, grps) => {
return(item.ranged);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Magic Weapon", null,
new ItemGroupMatcher((item, grps) => {
return(item.magic);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Melee Weapon", null,
new ItemGroupMatcher((item, grps) => {
return(item.melee);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Thrown Weapon", null,
new ItemGroupMatcher((item, grps) => {
return(item.thrown);
})
));
// Melee Sub Classes
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Swingable", null,
new ItemGroupMatcher((item, grps) => {
return(item.melee && item.useStyle == 1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Thrustable", null,
new ItemGroupMatcher((item, grps) => {
return(item.melee && item.useStyle == 5);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Flail", null,
new ItemGroupMatcher((item, grps) => {
if (!item.melee || item.useStyle != 5)
{
return(false);
}
if (item.type == ItemID.Anchor)
{
return(true);
}
if (item.shoot == 0)
{
return(false);
}
var projPool = ModHelpersMod.Instance.EntityGroups.GetProjPool();
switch (projPool[item.shoot].aiStyle)
{
case 15: // Standard
case 13: // Chain Knife, Boxing Glove
case 69: // Flairon
case 75: // Solar Eruption
return(true);
}
return(false);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Boomerang", null,
new ItemGroupMatcher((item, grps) => {
if (!item.melee || item.useStyle != 1)
{
return(false);
}
if (item.type == ItemID.FlyingKnife)
{
return(true);
}
if (item.shoot == 0)
{
return(false);
}
var projPool = ModHelpersMod.Instance.EntityGroups.GetProjPool();
switch (projPool[item.shoot].aiStyle)
{
case 3: // Boomerangs
case 15: // Thorn Chakram
return(true);
}
return(false);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Yoyo", null,
new ItemGroupMatcher((item, grps) => {
return(ItemAttributeHelpers.IsYoyo(item));
})
));
// Magic Sub Classes
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Magic Staff Or Scepter Or Wand", null,
new ItemGroupMatcher((item, grps) => {
if (!item.magic)
{
return(false);
}
string name = ItemAttributeHelpers.GetQualifiedName(item);
return(name.Contains("Staff") ||
name.Contains("Scepter") ||
name.Contains("Wand"));
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Magic Rod", null,
new ItemGroupMatcher((item, grps) => {
if (!item.magic)
{
return(false);
}
string name = ItemAttributeHelpers.GetQualifiedName(item);
return(name.Contains("Rod"));
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Magic Gun", null,
new ItemGroupMatcher((item, grps) => {
if (!item.magic)
{
return(false);
}
switch (item.type)
{
case ItemID.LeafBlower:
return(true);
}
string name = ItemAttributeHelpers.GetQualifiedName(item);
return(name.Contains("Gun") ||
name.Contains("Rifle") ||
name.Contains("Ray") ||
name.Contains("Cannon") ||
name.Contains("Laser"));
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Magic Tome", null,
new ItemGroupMatcher((item, grps) => {
if (!item.magic)
{
return(false);
}
switch (item.type)
{
case ItemID.DemonScythe:
case ItemID.WaterBolt:
case ItemID.LunarFlareBook:
case ItemID.MagnetSphere:
case ItemID.RazorbladeTyphoon:
return(true);
}
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.SpellTome, 1 }
});
if (has)
{
return(true);
}
string name = ItemAttributeHelpers.GetQualifiedName(item);
return(name.Contains("Book") ||
name.Contains("Tome"));
})
));
// Ranged Sub Classes
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Ranger Gun", null,
new ItemGroupMatcher((item, grps) => {
if (!item.ranged)
{
return(false);
}
return(item.useAmmo == AmmoID.Bullet ||
item.useAmmo == AmmoID.CandyCorn ||
item.useAmmo == AmmoID.Coin);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Ranger Bow", null,
new ItemGroupMatcher((item, grps) => {
if (!item.ranged)
{
return(false);
}
return(item.useAmmo == AmmoID.Arrow ||
item.useAmmo == AmmoID.Stake);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Ranger Launcher", null,
new ItemGroupMatcher((item, grps) => {
if (!item.ranged)
{
return(false);
}
return(item.useAmmo == AmmoID.Rocket ||
item.useAmmo == AmmoID.StyngerBolt ||
item.useAmmo == AmmoID.JackOLantern ||
item.useAmmo == AmmoID.NailFriendly);
})
));
// Summon Sub Classes
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Minion Summon Item", null,
new ItemGroupMatcher((item, grps) => {
return(item.summon && !item.sentry);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Sentry Summon Item", null,
new ItemGroupMatcher((item, grps) => {
return(item.summon && item.sentry);
})
));
// Vanity Classes
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Vanity Accessory", null,
new ItemGroupMatcher((item, grps) => {
if (!item.vanity)
{
return(false);
}
return(item.accessory);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Vanity Garment", null,
new ItemGroupMatcher((item, grps) => {
if (!item.vanity)
{
return(false);
}
return(!item.accessory);
})
));
}
internal static void DefineItemEquipmentGroups3(IList <EntityGroupMatcherDefinition <Item> > defs)
{
// Equipment Tiers
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Tiki Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
string name = ItemAttributeHelpers.GetQualifiedName(item);
if (!hasEquip || !name.Contains("Tiki"))
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Cactus Equipment",
new string[] { "Any Equipment", },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.Cactus, 1 }
});
if (!has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Plain Wood Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.Wood, 2 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Boreal Wood Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.BorealWood, 2 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Palm Wood Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.PalmWood, 2 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Rich Mahogany Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.RichMahogany, 2 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Ebonwood Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.Ebonwood, 2 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Shadewood Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.Shadewood, 2 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Pearlwood Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.Pearlwood, 2 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Dynasty Wood Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.DynastyWood, 2 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Spooky Wood Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.SpookyWood, 2 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Tin Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.TinBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Copper Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.CopperBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Iron Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.IronBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Lead Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.LeadBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Silver Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.SilverBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Tungsten Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.TungstenBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Gold Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.GoldBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Platinum Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.PlatinumBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Meteor Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.MeteoriteBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Demonite Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.DemoniteBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Crimtane Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.CrimtaneBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Jungle Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.JungleSpores, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Bee Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.BeeWax, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Bone Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.Bone, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Hellstone Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.HellstoneBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Cobalt Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.CobaltBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Palladium Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.PalladiumBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Mythril Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.MythrilBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Orichalcum Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.OrichalcumBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Adamantite Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.AdamantiteBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Titanium Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.TitaniumBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Frost Core Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.FrostCore, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Forbidden Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.AncientBattleArmorMaterial, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Hallow Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.HallowedBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Chlorophyte Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.ChlorophyteBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Shroomite Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.ShroomiteBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Spectre Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.SpectreBar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Shell Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has1 = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.BeetleShell, 1 }
});
var has2 = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.TurtleShell, 1 }
});
if (!hasEquip || (!has1 && !has2))
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Nebula Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.FragmentNebula, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Vortex Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.FragmentVortex, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Solar Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.FragmentSolar, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Stardust Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.FragmentStardust, 1 }
});
if (!hasEquip || !has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
defs.Add(new EntityGroupMatcherDefinition <Item>(
"Any Luminite Ore Equipment",
new string[] { "Any Equipment" },
new ItemGroupMatcher((item, grps) => {
var anyEquipItemDefs = grps["Any Equipment"].ToDictionary(kv => kv, kv => 1);
bool hasEquip = RecipeHelpers.ItemHasIngredients(item.type, anyEquipItemDefs);
var has = RecipeHelpers.ItemHasIngredients(item.type, new Dictionary <int, int> {
{ ItemID.LunarBar, 1 }
});
if (!has)
{
return(false);
}
return(item.createTile == -1 && item.createWall == -1);
})
));
}
private void RunLicenseCheckForItem(Item item)
{
if (item == null || item.IsAir)
{
this.LicenseMode = 0;
return;
}
// If the item is a type of License, we engage the respective mode:
if (item.type == ModContent.ItemType <LicenseItem>())
{
this.LicenseMode = 1;
return;
}
if (item.type == ModContent.ItemType <TrialLicenseItem>())
{
this.LicenseMode = 2;
return;
}
string realItemName = ItemAttributeHelpers.GetQualifiedName(item);
ItemDefinition itemDef = new ItemDefinition(item.type);
bool isTrialed = this.TrialLicensedItems.Contains(itemDef);
bool isLicensed = this.LicensedItems.Contains(itemDef) ||
LicensesMod.Config.FreeStarterItems.Contains(itemDef);
// When the item is NOT licenses, we apply the licensing effect to the item, if we can:
switch (this.LicenseMode)
{
case 1:
this.LicenseMode = 0;
if (!isLicensed)
{
if (LicenseItem.AttemptToLicenseItem(this.player, item))
{
Main.NewText(item.Name + " is now usable.", Color.Lime);
}
else
{
int needed = LicenseItem.ComputeCost(item);
Main.NewText("Not enough licenses for " + realItemName + ": " + needed + " needed", Color.Red);
}
}
else
{
Main.NewText(item.Name + " is already licensed.", Color.Yellow);
}
break;
case 2:
this.LicenseMode = 0;
if (!isLicensed && (!isTrialed || !LicensesMod.Config.TrialLicenseOncePerItem))
{
if (TrialLicenseItem.AttemptToTemporaryLicenseItem(this.player, item))
{
Main.NewText(realItemName + " is now licensed for " + (LicensesMod.Config.TrialLicenseDurationInTicks / 60) + " seconds.", Color.LimeGreen);
}
else
{
int needed = LicenseItem.ComputeCost(item);
Main.NewText("Not enough trial licenses for " + realItemName + ": " + needed + " needed", Color.Red);
}
}
else
{
if (isLicensed)
{
Main.NewText(item.Name + " is already licensed.", Color.Yellow);
}
else if (isTrialed)
{
Main.NewText(item.Name + " has already been trialed.", Color.Yellow);
}
}
break;
}
}