/// <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), long nodeStepHash = default(long), string interactionDescription = default(string), int damageType = default(int), long damageTypeHash = default(long), DestinyDefinitionsDestinyNodeActivationRequirement activationRequirement = default(DestinyDefinitionsDestinyNodeActivationRequirement), bool canActivateNextStep = default(bool), int nextStepIndex = default(int), bool isNextStepRandom = default(bool), List <long> perkHashes = default(List <long>), int startProgressionBarAtProgress = default(int), List <long> statHashes = default(List <long>), 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;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyTalentNodeDefinition" /> class.
/// </summary>
/// <param name="nodeIndex">The index into the DestinyTalentGridDefinition's \"nodes\" property where this node is located. Used to uniquely identify the node within the Talent Grid. Note that this is content version dependent: make sure you have the latest version of content before trying to use these properties..</param>
/// <param name="nodeHash">The hash identifier for the node, which unfortunately is also content version dependent but can be (and ideally, should be) used instead of the nodeIndex to uniquely identify the node. The two exist side-by-side for backcompat reasons due to the Great Talent Node Restructuring of Destiny 1, and I ran out of time to remove one of them and standardize on the other. Sorry!.</param>
/// <param name="row">The visual \"row\" where the node should be shown in the UI. If negative, then the node is hidden..</param>
/// <param name="column">The visual \"column\" where the node should be shown in the UI. If negative, the node is hidden..</param>
/// <param name="prerequisiteNodeIndexes">Indexes into the DestinyTalentGridDefinition.nodes property for any nodes that must be activated before this one is allowed to be activated. I would have liked to change this to hashes for Destiny 2, but we have run out of time..</param>
/// <param name="binaryPairNodeIndex">At one point, Talent Nodes supported the idea of \"Binary Pairs\": nodes that overlapped each other visually, and where activating one deactivated the other. They ended up not being used, mostly because Exclusive Sets are *almost* a superset of this concept, but the potential for it to be used still exists in theory. If this is ever used, this will be the index into the DestinyTalentGridDefinition.nodes property for the node that is the binary pair match to this node. Activating one deactivates the other..</param>
/// <param name="autoUnlocks">If true, this node will automatically unlock when the Talent Grid's level reaches the required level of the current step of this node..</param>
/// <param name="lastStepRepeats">At one point, Nodes were going to be able to be activated multiple times, changing the current step and potentially piling on multiple effects from the previously activated steps. This property would indicate if the last step could be activated multiple times. This is not currently used, but it isn't out of the question that this could end up being used again in a theoretical future..</param>
/// <param name="isRandom">If this is true, the node's step is determined randomly rather than the first step being chosen..</param>
/// <param name="randomActivationRequirement">At one point, you were going to be able to repurchase talent nodes that had random steps, to \"re-roll\" the current step of the node (and thus change the properties of your item). This was to be the activation requirement for performing that re-roll. The system still exists to do this, as far as I know, so it may yet come back around!.</param>
/// <param name="isRandomRepurchasable">If this is true, the node can be \"re-rolled\" to acquire a different random current step. This is not used, but still exists for a theoretical future of talent grids..</param>
/// <param name="steps">At this point, \"steps\" have been obfuscated into conceptual entities, aggregating the underlying notions of \"properties\" and \"true steps\". If you need to know a step as it truly exists - such as when recreating Node logic when processing Vendor data - you'll have to use the \"realSteps\" property below..</param>
/// <param name="exclusiveWithNodeHashes">The nodeHash values for nodes that are in an Exclusive Set with this node. See DestinyTalentGridDefinition.exclusiveSets for more info about exclusive sets. Again, note that these are nodeHashes and *not* nodeIndexes..</param>
/// <param name="randomStartProgressionBarAtProgression">If the node's step is randomly selected, this is the amount of the Talent Grid's progression experience at which the progression bar for the node should be shown..</param>
/// <param name="layoutIdentifier">A string identifier for a custom visual layout to apply to this talent node. Unfortunately, we do not have any data for rendering these custom layouts. It will be up to you to interpret these strings and change your UI if you want to have custom UI matching these layouts..</param>
/// <param name="groupHash">As of Destiny 2, nodes can exist as part of \"Exclusive Groups\". These differ from exclusive sets in that, within the group, many nodes can be activated. But the act of activating any node in the group will cause \"opposing\" nodes (nodes in groups that are not allowed to be activated at the same time as this group) to deactivate. See DestinyTalentExclusiveGroup for more information on the details. This is an identifier for this node's group, if it is part of one..</param>
/// <param name="loreHash">Talent nodes can be associated with a piece of Lore, generally rendered in a tooltip. This is the hash identifier of the lore element to show, if there is one to be show..</param>
/// <param name="nodeStyleIdentifier">Comes from the talent grid node style: this identifier should be used to determine how to render the node in the UI..</param>
/// <param name="ignoreForCompletion">Comes from the talent grid node style: if true, then this node should be ignored for determining whether the grid is complete..</param>
public DestinyDefinitionsDestinyTalentNodeDefinition(int nodeIndex = default(int), long nodeHash = default(long), int row = default(int), int column = default(int), List <int> prerequisiteNodeIndexes = default(List <int>), int binaryPairNodeIndex = default(int), bool autoUnlocks = default(bool), bool lastStepRepeats = default(bool), bool isRandom = default(bool), DestinyDefinitionsDestinyNodeActivationRequirement randomActivationRequirement = default(DestinyDefinitionsDestinyNodeActivationRequirement), bool isRandomRepurchasable = default(bool), List <DestinyDefinitionsDestinyNodeStepDefinition> steps = default(List <DestinyDefinitionsDestinyNodeStepDefinition>), List <long> exclusiveWithNodeHashes = default(List <long>), int randomStartProgressionBarAtProgression = default(int), string layoutIdentifier = default(string), long groupHash = default(long), long loreHash = default(long), string nodeStyleIdentifier = default(string), bool ignoreForCompletion = default(bool))
{
this.NodeIndex = nodeIndex;
this.NodeHash = nodeHash;
this.Row = row;
this.Column = column;
this.PrerequisiteNodeIndexes = prerequisiteNodeIndexes;
this.BinaryPairNodeIndex = binaryPairNodeIndex;
this.AutoUnlocks = autoUnlocks;
this.LastStepRepeats = lastStepRepeats;
this.IsRandom = isRandom;
this.RandomActivationRequirement = randomActivationRequirement;
this.IsRandomRepurchasable = isRandomRepurchasable;
this.Steps = steps;
this.ExclusiveWithNodeHashes = exclusiveWithNodeHashes;
this.RandomStartProgressionBarAtProgression = randomStartProgressionBarAtProgression;
this.LayoutIdentifier = layoutIdentifier;
this.GroupHash = groupHash;
this.LoreHash = loreHash;
this.NodeStyleIdentifier = nodeStyleIdentifier;
this.IgnoreForCompletion = ignoreForCompletion;
}
