/// <summary>
/// Initializes a new instance of the <see cref="DestinyEntitiesItemsDestinyItemInstanceComponent" /> class.
/// </summary>
/// <param name="DamageType">If the item has a damage type, this is the item's current damage type..</param>
/// <param name="DamageTypeHash">The current damage type's hash, so you can look up localized info and icons for it..</param>
/// <param name="PrimaryStat">The item stat that we consider to be \"primary\" for the item. For instance, this would be \"Attack\" for Weapons or \"Defense\" for armor..</param>
/// <param name="ItemLevel">The Item's \"Level\" has the most significant bearing on its stats, such as Light and Power..</param>
/// <param name="Quality">The \"Quality\" of the item has a lesser - but still impactful - bearing on stats like Light and Power..</param>
/// <param name="IsEquipped">Is the item currently equipped on the given character?.</param>
/// <param name="CanEquip">If this is an equippable item, you can check it here. There are permanent as well as transitory reasons why an item might not be able to be equipped: check cannotEquipReason for details..</param>
/// <param name="EquipRequiredLevel">If the item cannot be equipped until you reach a certain level, that level will be reflected here..</param>
/// <param name="UnlockHashesRequiredToEquip">Sometimes, there are limitations to equipping that are represented by character-level flags called \"unlocks\". This is a list of flags that they need in order to equip the item that the character has not met. Use these to look up the descriptions to show in your UI by looking up the relevant DestinyUnlockDefinitions for the hashes..</param>
/// <param name="CannotEquipReason">If you cannot equip the item, this is a flags enum that enumerates all of the reasons why you couldn't equip the item. You may need to refine your UI further by using unlockHashesRequiredToEquip and equipRequiredLevel..</param>
public DestinyEntitiesItemsDestinyItemInstanceComponent(DestinyDamageType DamageType = default(DestinyDamageType), uint?DamageTypeHash = default(uint?), DestinyDestinyStat PrimaryStat = default(DestinyDestinyStat), int?ItemLevel = default(int?), int?Quality = default(int?), bool?IsEquipped = default(bool?), bool?CanEquip = default(bool?), int?EquipRequiredLevel = default(int?), List <uint?> UnlockHashesRequiredToEquip = default(List <uint?>), DestinyEquipFailureReason CannotEquipReason = default(DestinyEquipFailureReason))
{
this.DamageType = DamageType;
this.DamageTypeHash = DamageTypeHash;
this.PrimaryStat = PrimaryStat;
this.ItemLevel = ItemLevel;
this.Quality = Quality;
this.IsEquipped = IsEquipped;
this.CanEquip = CanEquip;
this.EquipRequiredLevel = EquipRequiredLevel;
this.UnlockHashesRequiredToEquip = UnlockHashesRequiredToEquip;
this.CannotEquipReason = CannotEquipReason;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyDamageTypeDefinition" /> class.
/// </summary>
/// <param name="DisplayProperties">The description of the damage type, icon etc....</param>
/// <param name="TransparentIconPath">A variant of the icon that is transparent and colorless..</param>
/// <param name="ShowIcon">If TRUE, the game shows this damage type's icon. Otherwise, it doesn't. Whether you show it or not is up to you..</param>
/// <param name="EnumValue">We have an enumeration for damage types for quick reference. This is the current definition's damage type enum value..</param>
/// <param name="Hash">The unique identifier for this entity. Guaranteed to be unique for the type of entity, but not globally. When entities refer to each other in Destiny content, it is this hash that they are referring to..</param>
/// <param name="Index">The index of the entity as it was found in the investment tables..</param>
/// <param name="Redacted">If this is true, then there is an entity with this identifier/type combination, but BNet is not yet allowed to show it. Sorry!.</param>
public DestinyDefinitionsDestinyDamageTypeDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), string TransparentIconPath = default(string), bool?ShowIcon = default(bool?), DestinyDamageType EnumValue = default(DestinyDamageType), uint?Hash = default(uint?), int?Index = default(int?), bool?Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.TransparentIconPath = TransparentIconPath;
this.ShowIcon = ShowIcon;
this.EnumValue = EnumValue;
this.Hash = Hash;
this.Index = Index;
this.Redacted = Redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyItemTalentGridBlockDefinition" /> class.
/// </summary>
/// <param name="TalentGridHash">The hash identifier of the DestinyTalentGridDefinition attached to this item..</param>
/// <param name="ItemDetailString">This is meant to be a subtitle for looking at the talent grid. In practice, somewhat frustratingly, this always merely says the localized word for \"Details\". Great. Maybe it'll have more if talent grids ever get used for more than builds and subclasses again..</param>
/// <param name="BuildName">A shortcut string identifier for the \"build\" in question, if this talent grid has an associated build. Doesn't map to anything we can expose at the moment..</param>
/// <param name="HudDamageType">If the talent grid implies a damage type, this is the enum value for that damage type..</param>
/// <param name="HudIcon">If the talent grid has a special icon that's shown in the game UI (like builds, funny that), this is the identifier for that icon. Sadly, we don't actually get that icon right now. I'll be looking to replace this with a path to the actual icon itself..</param>
public DestinyDefinitionsDestinyItemTalentGridBlockDefinition(uint?TalentGridHash = default(uint?), string ItemDetailString = default(string), string BuildName = default(string), DestinyDamageType HudDamageType = default(DestinyDamageType), string HudIcon = default(string))
{
this.TalentGridHash = TalentGridHash;
this.ItemDetailString = ItemDetailString;
this.BuildName = BuildName;
this.HudDamageType = HudDamageType;
this.HudIcon = HudIcon;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinySandboxPerkDefinition" /> class.
/// </summary>
/// <param name="DisplayProperties">These display properties are by no means guaranteed to be populated. Usually when it is, it's only because we back-filled them with the displayProperties of some Talent Node or Plug item that happened to be uniquely providing that perk..</param>
/// <param name="PerkIdentifier">The string identifier for the perk..</param>
/// <param name="IsDisplayable">If true, you can actually show the perk in the UI. Otherwise, it doesn't have useful player-facing information..</param>
/// <param name="DamageType">If this perk grants a damage type to a weapon, the damage type will be defined here. Unless you have a compelling reason to use this enum value, use the damageTypeHash instead to look up the actual DestinyDamageTypeDefinition..</param>
/// <param name="DamageTypeHash">The hash identifier for looking up the DestinyDamageTypeDefinition, if this perk has a damage type. This is preferred over using the damageType enumeration value, which has been left purely because it is occasionally convenient..</param>
/// <param name="PerkGroups">An old holdover from the original Armory, this was an attempt to group perks by functionality. It is as yet unpopulated, and there will be quite a bit of work needed to restore it to its former working order..</param>
/// <param name="Hash">The unique identifier for this entity. Guaranteed to be unique for the type of entity, but not globally. When entities refer to each other in Destiny content, it is this hash that they are referring to..</param>
/// <param name="Index">The index of the entity as it was found in the investment tables..</param>
/// <param name="Redacted">If this is true, then there is an entity with this identifier/type combination, but BNet is not yet allowed to show it. Sorry!.</param>
public DestinyDefinitionsDestinySandboxPerkDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), string PerkIdentifier = default(string), bool?IsDisplayable = default(bool?), DestinyDamageType DamageType = default(DestinyDamageType), uint?DamageTypeHash = default(uint?), DestinyDefinitionsDestinyTalentNodeStepGroups PerkGroups = default(DestinyDefinitionsDestinyTalentNodeStepGroups), uint?Hash = default(uint?), int?Index = default(int?), bool?Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.PerkIdentifier = PerkIdentifier;
this.IsDisplayable = IsDisplayable;
this.DamageType = DamageType;
this.DamageTypeHash = DamageTypeHash;
this.PerkGroups = PerkGroups;
this.Hash = Hash;
this.Index = Index;
this.Redacted = Redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyNodeStepDefinition" /> class.
/// </summary>
/// <param name="DisplayProperties">These are the display properties actually used to render the Talent Node. The currently active step's displayProperties are shown..</param>
/// <param name="StepIndex">The index of this step in the list of Steps on the Talent Node. Unfortunately, this is the closest thing we have to an identifier for the Step: steps are not provided a content version agnostic identifier. This means that, when you are dealing with talent nodes, you will need to first ensure that you have the latest version of content..</param>
/// <param name="NodeStepHash">The hash of this node step. Unfortunately, while it can be used to uniquely identify the step within a node, it is also content version dependent and should not be relied on without ensuring you have the latest vesion of content..</param>
/// <param name="InteractionDescription">If you can interact with this node in some way, this is the localized description of that interaction..</param>
/// <param name="DamageType">An enum representing a damage type granted by activating this step, if any..</param>
/// <param name="DamageTypeHash">If the step provides a damage type, this will be the hash identifier used to look up the damage type's DestinyDamageTypeDefinition..</param>
/// <param name="ActivationRequirement">If the step has requirements for activation (they almost always do, if nothing else than for the Talent Grid's Progression to have reached a certain level), they will be defined here..</param>
/// <param name="CanActivateNextStep">There was a time when talent nodes could be activated multiple times, and the effects of subsequent Steps would be compounded on each other, essentially \"upgrading\" the node. We have moved away from this, but theoretically the capability still exists. I continue to return this in case it is used in the future: if true and this step is the current step in the node, you are allowed to activate the node a second time to receive the benefits of the next step in the node, which will then become the active step..</param>
/// <param name="NextStepIndex">The stepIndex of the next step in the talent node, or -1 if this is the last step or if the next step to be chosen is random. This doesn't really matter anymore unless canActivateNextStep begins to be used again..</param>
/// <param name="IsNextStepRandom">If true, the next step to be chosen is random, and if you're allowed to activate the next step. (if canActivateNextStep = true).</param>
/// <param name="PerkHashes">The list of hash identifiers for Perks (DestinySandboxPerkDefinition) that are applied when this step is active. Perks provide a variety of benefits and modifications - examine DestinySandboxPerkDefinition to learn more..</param>
/// <param name="StartProgressionBarAtProgress">When the Talent Grid's progression reaches this value, the circular \"progress bar\" that surrounds the talent node should be shown. This also indicates the lower bound of said progress bar, with the upper bound being the progress required to reach activationRequirement.gridLevel. (at some point I should precalculate the upper bound and put it in the definition to save people time).</param>
/// <param name="StatHashes">When the step provides stat benefits on the item or character, this is the list of hash identifiers for stats (DestinyStatDefinition) that are provided..</param>
/// <param name="AffectsQuality">If this is true, the step affects the item's Quality in some way. See DestinyInventoryItemDefinition for more information about the meaning of Quality. I already made a joke about Zen and the Art of Motorcycle Maintenance elsewhere in the documentation, so I will avoid doing it again. Oops too late.</param>
/// <param name="StepGroups">In Destiny 1, the Armory's Perk Filtering was driven by a concept of TalentNodeStepGroups: categorizations of talent nodes based on their functionality. While the Armory isn't a BNet-facing thing for now, and the new Armory will need to account for Sockets rather than Talent Nodes, this categorization capability feels useful enough to still keep around..</param>
/// <param name="AffectsLevel">If true, this step can affect the level of the item. See DestinyInventoryItemDefintion for more information about item levels and their effect on stats..</param>
/// <param name="SocketReplacements">If this step is activated, this will be a list of information used to replace socket items with new Plugs. See DestinyInventoryItemDefinition for more information about sockets and plugs..</param>
public DestinyDefinitionsDestinyNodeStepDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), int?StepIndex = default(int?), uint?NodeStepHash = default(uint?), string InteractionDescription = default(string), DestinyDamageType DamageType = default(DestinyDamageType), uint?DamageTypeHash = default(uint?), DestinyDefinitionsDestinyNodeActivationRequirement ActivationRequirement = default(DestinyDefinitionsDestinyNodeActivationRequirement), bool?CanActivateNextStep = default(bool?), int?NextStepIndex = default(int?), bool?IsNextStepRandom = default(bool?), List <uint?> PerkHashes = default(List <uint?>), int?StartProgressionBarAtProgress = default(int?), List <uint?> StatHashes = default(List <uint?>), bool?AffectsQuality = default(bool?), DestinyDefinitionsDestinyTalentNodeStepGroups StepGroups = default(DestinyDefinitionsDestinyTalentNodeStepGroups), bool?AffectsLevel = default(bool?), List <DestinyDefinitionsDestinyNodeSocketReplaceResponse> SocketReplacements = default(List <DestinyDefinitionsDestinyNodeSocketReplaceResponse>))
{
this.DisplayProperties = DisplayProperties;
this.StepIndex = StepIndex;
this.NodeStepHash = NodeStepHash;
this.InteractionDescription = InteractionDescription;
this.DamageType = DamageType;
this.DamageTypeHash = DamageTypeHash;
this.ActivationRequirement = ActivationRequirement;
this.CanActivateNextStep = CanActivateNextStep;
this.NextStepIndex = NextStepIndex;
this.IsNextStepRandom = IsNextStepRandom;
this.PerkHashes = PerkHashes;
this.StartProgressionBarAtProgress = StartProgressionBarAtProgress;
this.StatHashes = StatHashes;
this.AffectsQuality = AffectsQuality;
this.StepGroups = StepGroups;
this.AffectsLevel = AffectsLevel;
this.SocketReplacements = SocketReplacements;
}
