/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyActivityTypeDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</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 DestinyDefinitionsDestinyActivityTypeDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyProgressionMappingDefinition" /> class.
/// </summary>
/// <param name="displayProperties">Infrequently defined in practice. Defer to the individual progressions' display properties..</param>
/// <param name="displayUnits">The localized unit of measurement for progression across the progressions defined in this mapping. Unfortunately, this is very infrequently defined. Defer to the individual progressions' display units..</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 DestinyDefinitionsDestinyProgressionMappingDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), string displayUnits = default(string), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.DisplayUnits = displayUnits;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsBreakerTypesDestinyBreakerTypeDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="enumValue">We have an enumeration for Breaker types for quick reference. This is the current definition's breaker 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 DestinyDefinitionsBreakerTypesDestinyBreakerTypeDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), int enumValue = default(int), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.EnumValue = enumValue;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyRewardSourceDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="category">Sources are grouped into categories: common ways that items are provided. I hope to see this expand in Destiny 2 once we have time to generate accurate reward source data..</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 DestinyDefinitionsDestinyRewardSourceDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), int category = default(int), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.Category = category;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsReportingDestinyReportReasonCategoryDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="reasons">The specific reasons for the report under this category..</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 DestinyDefinitionsReportingDestinyReportReasonCategoryDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), Dictionary <string, DestinyDefinitionsReportingDestinyReportReasonDefinition> reasons = default(Dictionary <string, DestinyDefinitionsReportingDestinyReportReasonDefinition>), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.Reasons = reasons;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsLoreDestinyLoreDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="subtitle">subtitle.</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 DestinyDefinitionsLoreDestinyLoreDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), string subtitle = default(string), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.Subtitle = subtitle;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsItemsDestinyItemTierTypeDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="infusionProcess">If this tier defines infusion properties, they will be contained here..</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 DestinyDefinitionsItemsDestinyItemTierTypeDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), DestinyDefinitionsItemsDestinyItemTierTypeInfusionBlock infusionProcess = default(DestinyDefinitionsItemsDestinyItemTierTypeInfusionBlock), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.InfusionProcess = infusionProcess;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsSocketsDestinySocketCategoryDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="uiCategoryStyle">A string hinting to the game's UI system about how the sockets in this category should be displayed. BNet doesn't use it: it's up to you to find valid values and make your own special UI if you want to honor this category style..</param>
/// <param name="categoryStyle">Same as uiCategoryStyle, but in a more usable enumeration form..</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 DestinyDefinitionsSocketsDestinySocketCategoryDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), long uiCategoryStyle = default(long), int categoryStyle = default(int), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.UiCategoryStyle = uiCategoryStyle;
this.CategoryStyle = categoryStyle;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsSocketsDestinyPlugSetDefinition" /> class.
/// </summary>
/// <param name="displayProperties">If you want to show these plugs in isolation, these are the display properties for them..</param>
/// <param name="reusablePlugItems">This is a list of pre-determined plugs that can be plugged into this socket, without the character having the plug in their inventory. If this list is populated, you will not be allowed to plug an arbitrary item in the socket: you will only be able to choose from one of these reusable plugs..</param>
/// <param name="isFakePlugSet">Mostly for our debugging or reporting bugs, BNet is making \"fake\" plug sets in a desperate effort to reduce socket sizes. If this is true, the plug set was generated by BNet: if it looks wrong, that's a good indicator that it's bungie.net that f****d this up..</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 DestinyDefinitionsSocketsDestinyPlugSetDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), List <DestinyDefinitionsDestinyItemSocketEntryPlugItemRandomizedDefinition> reusablePlugItems = default(List <DestinyDefinitionsDestinyItemSocketEntryPlugItemRandomizedDefinition>), bool isFakePlugSet = default(bool), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.ReusablePlugItems = reusablePlugItems;
this.IsFakePlugSet = isFakePlugSet;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsArtifactsDestinyArtifactDefinition" /> class.
/// </summary>
/// <param name="displayProperties">Any basic display info we know about the Artifact. Currently sourced from a related inventory item, but the source of this data is subject to change..</param>
/// <param name="translationBlock">Any Geometry/3D info we know about the Artifact. Currently sourced from a related inventory item's gearset information, but the source of this data is subject to change..</param>
/// <param name="tiers">Any Tier/Rank data related to this artifact, listed in display order. Currently sourced from a Vendor, but this source is subject to change..</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 DestinyDefinitionsArtifactsDestinyArtifactDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), DestinyDefinitionsDestinyItemTranslationBlockDefinition translationBlock = default(DestinyDefinitionsDestinyItemTranslationBlockDefinition), List <DestinyDefinitionsArtifactsDestinyArtifactTierDefinition> tiers = default(List <DestinyDefinitionsArtifactsDestinyArtifactTierDefinition>), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.TranslationBlock = translationBlock;
this.Tiers = tiers;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsSeasonsDestinySeasonPassDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="rewardProgressionHash">This is the progression definition related to the progression for the initial levels 1-100 that provide item rewards for the Season pass. Further experience after you reach the limit is provided in the \"Prestige\" progression referred to by prestigeProgressionHash..</param>
/// <param name="prestigeProgressionHash">I know what you're thinking, but I promise we're not going to duplicate and drown you. Instead, we're giving you sweet, sweet power bonuses. Prestige progression is further progression that you can make on the Season pass after you gain max ranks, that will ultimately increase your power/light level over the theoretical limit..</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 DestinyDefinitionsSeasonsDestinySeasonPassDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), long rewardProgressionHash = default(long), long prestigeProgressionHash = default(long), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.RewardProgressionHash = rewardProgressionHash;
this.PrestigeProgressionHash = prestigeProgressionHash;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsTraitsDestinyTraitDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="traitCategoryId">traitCategoryId.</param>
/// <param name="traitCategoryHash">traitCategoryHash.</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 DestinyDefinitionsTraitsDestinyTraitDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), string traitCategoryId = default(string), long traitCategoryHash = default(long), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.TraitCategoryId = traitCategoryId;
this.TraitCategoryHash = traitCategoryHash;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyRaceDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="raceType">An enumeration defining the existing, known Races/Species for player characters. This value will be the enum value matching this definition..</param>
/// <param name="genderedRaceNames">A localized string referring to the singular form of the Race's name when referred to in gendered form. Keyed by the DestinyGender..</param>
/// <param name="genderedRaceNamesByGenderHash">genderedRaceNamesByGenderHash.</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 DestinyDefinitionsDestinyRaceDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), int raceType = default(int), Dictionary <string, string> genderedRaceNames = default(Dictionary <string, string>), Dictionary <string, string> genderedRaceNamesByGenderHash = default(Dictionary <string, string>), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.RaceType = raceType;
this.GenderedRaceNames = genderedRaceNames;
this.GenderedRaceNamesByGenderHash = genderedRaceNamesByGenderHash;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsChecklistsDestinyChecklistDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="viewActionString">A localized string prompting you to view the checklist..</param>
/// <param name="scope">Indicates whether you will find this checklist on the Profile or Character components..</param>
/// <param name="entries">The individual checklist items. Gotta catch 'em all..</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 DestinyDefinitionsChecklistsDestinyChecklistDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), string viewActionString = default(string), int scope = default(int), List <DestinyDefinitionsChecklistsDestinyChecklistEntryDefinition> entries = default(List <DestinyDefinitionsChecklistsDestinyChecklistEntryDefinition>), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.ViewActionString = viewActionString;
this.Scope = scope;
this.Entries = entries;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyStatDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="aggregationType">Stats can exist on a character or an item, and they may potentially be aggregated in different ways. The DestinyStatAggregationType enum value indicates the way that this stat is being aggregated..</param>
/// <param name="hasComputedBlock">True if the stat is computed rather than being delivered as a raw value on items. For instance, the Light stat in Destiny 1 was a computed stat..</param>
/// <param name="statCategory">The category of the stat, according to the game..</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 DestinyDefinitionsDestinyStatDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), int aggregationType = default(int), bool hasComputedBlock = default(bool), int statCategory = default(int), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.AggregationType = aggregationType;
this.HasComputedBlock = hasComputedBlock;
this.StatCategory = statCategory;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <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), int enumValue = default(int), long hash = default(long), 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="DestinyDefinitionsDestinyEquipmentSlotDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="equipmentCategoryHash">These technically point to \"Equipment Category Definitions\". But don't get excited. There's nothing of significant value in those definitions, so I didn't bother to expose them. You can use the hash here to group equipment slots by common functionality, which serves the same purpose as if we had the Equipment Category definitions exposed..</param>
/// <param name="bucketTypeHash">The inventory bucket that owns this equipment slot..</param>
/// <param name="applyCustomArtDyes">If True, equipped items should have their custom art dyes applied when rendering the item. Otherwise, custom art dyes on an item should be ignored if the item is equipped in this slot..</param>
/// <param name="artDyeChannels">The Art Dye Channels that apply to this equipment slot..</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 DestinyDefinitionsDestinyEquipmentSlotDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), long equipmentCategoryHash = default(long), long bucketTypeHash = default(long), bool applyCustomArtDyes = default(bool), List <DestinyDefinitionsDestinyArtDyeReference> artDyeChannels = default(List <DestinyDefinitionsDestinyArtDyeReference>), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.EquipmentCategoryHash = equipmentCategoryHash;
this.BucketTypeHash = bucketTypeHash;
this.ApplyCustomArtDyes = applyCustomArtDyes;
this.ArtDyeChannels = artDyeChannels;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyFactionDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="progressionHash">The hash identifier for the DestinyProgressionDefinition that indicates the character's relationship with this faction in terms of experience and levels..</param>
/// <param name="tokenValues">The faction token item hashes, and their respective progression values..</param>
/// <param name="rewardItemHash">The faction reward item hash, usually an engram..</param>
/// <param name="rewardVendorHash">The faction reward vendor hash, used for faction engram previews..</param>
/// <param name="vendors">List of vendors that are associated with this faction. The last vendor that passes the unlock flag checks is the one that should be shown..</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 DestinyDefinitionsDestinyFactionDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), long progressionHash = default(long), Dictionary <string, long> tokenValues = default(Dictionary <string, long>), long rewardItemHash = default(long), long rewardVendorHash = default(long), List <DestinyDefinitionsDestinyFactionVendorDefinition> vendors = default(List <DestinyDefinitionsDestinyFactionVendorDefinition>), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.ProgressionHash = progressionHash;
this.TokenValues = tokenValues;
this.RewardItemHash = rewardItemHash;
this.RewardVendorHash = rewardVendorHash;
this.Vendors = vendors;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyDestinationDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="placeHash">The place that \"owns\" this Destination. Use this hash to look up the DestinyPlaceDefinition..</param>
/// <param name="defaultFreeroamActivityHash">If this Destination has a default Free-Roam activity, this is the hash for that Activity. Use it to look up the DestinyActivityDefintion..</param>
/// <param name="activityGraphEntries">If the Destination has default Activity Graphs (i.e. \"Map\") that should be shown in the director, this is the list of those Graphs. At most, only one should be active at any given time for a Destination: these would represent, for example, different variants on a Map if the Destination is changing on a macro level based on game state..</param>
/// <param name="bubbleSettings">A Destination may have many \"Bubbles\" zones with human readable properties. We don't get as much info as I'd like about them - I'd love to return info like where on the map they are located - but at least this gives you the name of those bubbles. bubbleSettings and bubbles both have the identical number of entries, and you should match up their indexes to provide matching bubble and bubbleSettings data. DEPRECATED - Just use bubbles, it now has this data..</param>
/// <param name="bubbles">This provides the unique identifiers for every bubble in the destination (only guaranteed unique within the destination), and any intrinsic properties of the bubble. bubbleSettings and bubbles both have the identical number of entries, and you should match up their indexes to provide matching bubble and bubbleSettings data..</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 DestinyDefinitionsDestinyDestinationDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), long placeHash = default(long), long defaultFreeroamActivityHash = default(long), List <DestinyDefinitionsDestinyActivityGraphListEntryDefinition> activityGraphEntries = default(List <DestinyDefinitionsDestinyActivityGraphListEntryDefinition>), List <DestinyDefinitionsDestinyDestinationBubbleSettingDefinition> bubbleSettings = default(List <DestinyDefinitionsDestinyDestinationBubbleSettingDefinition>), List <DestinyDefinitionsDestinyBubbleDefinition> bubbles = default(List <DestinyDefinitionsDestinyBubbleDefinition>), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.PlaceHash = placeHash;
this.DefaultFreeroamActivityHash = defaultFreeroamActivityHash;
this.ActivityGraphEntries = activityGraphEntries;
this.BubbleSettings = bubbleSettings;
this.Bubbles = bubbles;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <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), int damageType = default(int), long damageTypeHash = default(long), DestinyDefinitionsDestinyTalentNodeStepGroups perkGroups = default(DestinyDefinitionsDestinyTalentNodeStepGroups), long hash = default(long), 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="DestinyDefinitionsMetricsDestinyMetricDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="trackingObjectiveHash">trackingObjectiveHash.</param>
/// <param name="lowerValueIsBetter">lowerValueIsBetter.</param>
/// <param name="presentationNodeType">presentationNodeType.</param>
/// <param name="traitIds">traitIds.</param>
/// <param name="traitHashes">traitHashes.</param>
/// <param name="parentNodeHashes">A quick reference to presentation nodes that have this node as a child. Presentation nodes can be parented under multiple parents..</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 DestinyDefinitionsMetricsDestinyMetricDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), long trackingObjectiveHash = default(long), bool lowerValueIsBetter = default(bool), int presentationNodeType = default(int), List <string> traitIds = default(List <string>), List <long> traitHashes = default(List <long>), List <long> parentNodeHashes = default(List <long>), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.TrackingObjectiveHash = trackingObjectiveHash;
this.LowerValueIsBetter = lowerValueIsBetter;
this.PresentationNodeType = presentationNodeType;
this.TraitIds = traitIds;
this.TraitHashes = traitHashes;
this.ParentNodeHashes = parentNodeHashes;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyInventoryBucketDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="scope">Where the bucket is found. 0 = Character, 1 = Account.</param>
/// <param name="category">An enum value for what items can be found in the bucket. See the BucketCategory enum for more details..</param>
/// <param name="bucketOrder">Use this property to provide a quick-and-dirty recommended ordering for buckets in the UI. Most UIs will likely want to forsake this for something more custom and manual..</param>
/// <param name="itemCount">The maximum # of item \"slots\" in a bucket. A slot is a given combination of item + quantity. For instance, a Weapon will always take up a single slot, and always have a quantity of 1. But a material could take up only a single slot with hundreds of quantity..</param>
/// <param name="location">Sometimes, inventory buckets represent conceptual \"locations\" in the game that might not be expected. This value indicates the conceptual location of the bucket, regardless of where it is actually contained on the character/account. See ItemLocation for details. Note that location includes the Vault and the Postmaster (both of whom being just inventory buckets with additional actions that can be performed on them through a Vendor).</param>
/// <param name="hasTransferDestination">If TRUE, there is at least one Vendor that can transfer items to/from this bucket. See the DestinyVendorDefinition's acceptedItems property for more information on how transferring works..</param>
/// <param name="enabled">If True, this bucket is enabled. Disabled buckets may include buckets that were included for test purposes, or that were going to be used but then were abandoned but never removed from content *cough*..</param>
/// <param name="fifo">if a FIFO bucket fills up, it will delete the oldest item from said bucket when a new item tries to be added to it. If this is FALSE, the bucket will not allow new items to be placed in it until room is made by the user manually deleting items from it. You can see an example of this with the Postmaster's bucket..</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 DestinyDefinitionsDestinyInventoryBucketDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), int scope = default(int), int category = default(int), int bucketOrder = default(int), int itemCount = default(int), int location = default(int), bool hasTransferDestination = default(bool), bool enabled = default(bool), bool fifo = default(bool), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.Scope = scope;
this.Category = category;
this.BucketOrder = bucketOrder;
this.ItemCount = itemCount;
this.Location = location;
this.HasTransferDestination = hasTransferDestination;
this.Enabled = enabled;
this.Fifo = fifo;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsSeasonsDestinySeasonDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="backgroundImagePath">backgroundImagePath.</param>
/// <param name="seasonNumber">seasonNumber.</param>
/// <param name="startDate">startDate.</param>
/// <param name="endDate">endDate.</param>
/// <param name="seasonPassHash">seasonPassHash.</param>
/// <param name="seasonPassProgressionHash">seasonPassProgressionHash.</param>
/// <param name="artifactItemHash">artifactItemHash.</param>
/// <param name="sealPresentationNodeHash">sealPresentationNodeHash.</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 DestinyDefinitionsSeasonsDestinySeasonDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), string backgroundImagePath = default(string), int seasonNumber = default(int), DateTime startDate = default(DateTime), DateTime endDate = default(DateTime), long seasonPassHash = default(long), long seasonPassProgressionHash = default(long), long artifactItemHash = default(long), long sealPresentationNodeHash = default(long), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.BackgroundImagePath = backgroundImagePath;
this.SeasonNumber = seasonNumber;
this.StartDate = startDate;
this.EndDate = endDate;
this.SeasonPassHash = seasonPassHash;
this.SeasonPassProgressionHash = seasonPassProgressionHash;
this.ArtifactItemHash = artifactItemHash;
this.SealPresentationNodeHash = sealPresentationNodeHash;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyActivityModeDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="pgcrImage">If this activity mode has a related PGCR image, this will be the path to said image..</param>
/// <param name="modeType">The Enumeration value for this Activity Mode. Pass this identifier into Stats endpoints to get aggregate stats for this mode..</param>
/// <param name="activityModeCategory">The type of play being performed in broad terms (PVP, PVE).</param>
/// <param name="isTeamBased">If True, this mode has oppositional teams fighting against each other rather than \"Free-For-All\" or Co-operative modes of play. Note that Aggregate modes are never marked as team based, even if they happen to be team based at the moment. At any time, an aggregate whose subordinates are only team based could be changed so that one or more aren't team based, and then this boolean won't make much sense (the aggregation would become \"sometimes team based\"). Let's not deal with that right now..</param>
/// <param name="isAggregateMode">If true, this mode is an aggregation of other, more specific modes rather than being a mode in itself. This includes modes that group Features/Events rather than Gameplay, such as Trials of The Nine: Trials of the Nine being an Event that is interesting to see aggregate data for, but when you play the activities within Trials of the Nine they are more specific activity modes such as Clash..</param>
/// <param name="parentHashes">The hash identifiers of the DestinyActivityModeDefinitions that represent all of the \"parent\" modes for this mode. For instance, the Nightfall Mode is also a member of AllStrikes and AllPvE..</param>
/// <param name="friendlyName">A Friendly identifier you can use for referring to this Activity Mode. We really only used this in our URLs, so... you know, take that for whatever it's worth..</param>
/// <param name="activityModeMappings">If this exists, the mode has specific Activities (referred to by the Key) that should instead map to other Activity Modes when they are played. This was useful in D1 for Private Matches, where we wanted to have Private Matches as an activity mode while still referring to the specific mode being played..</param>
/// <param name="display">If FALSE, we want to ignore this type when we're showing activity modes in BNet UI. It will still be returned in case 3rd parties want to use it for any purpose..</param>
/// <param name="order">The relative ordering of activity modes..</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 DestinyDefinitionsDestinyActivityModeDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), string pgcrImage = default(string), int modeType = default(int), int activityModeCategory = default(int), bool isTeamBased = default(bool), bool isAggregateMode = default(bool), List <long> parentHashes = default(List <long>), string friendlyName = default(string), Dictionary <string, int> activityModeMappings = default(Dictionary <string, int>), bool display = default(bool), int order = default(int), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.PgcrImage = pgcrImage;
this.ModeType = modeType;
this.ActivityModeCategory = activityModeCategory;
this.IsTeamBased = isTeamBased;
this.IsAggregateMode = isAggregateMode;
this.ParentHashes = parentHashes;
this.FriendlyName = friendlyName;
this.ActivityModeMappings = activityModeMappings;
this.Display = display;
this.Order = order;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyLocationReleaseDefinition" /> class.
/// </summary>
/// <param name="displayProperties">Sadly, these don't appear to be populated anymore (ever?).</param>
/// <param name="smallTransparentIcon">smallTransparentIcon.</param>
/// <param name="mapIcon">mapIcon.</param>
/// <param name="largeTransparentIcon">largeTransparentIcon.</param>
/// <param name="spawnPoint">If we had map information, this spawnPoint would be interesting. But sadly, we don't have that info..</param>
/// <param name="destinationHash">The Destination being pointed to by this location..</param>
/// <param name="activityHash">The Activity being pointed to by this location..</param>
/// <param name="activityGraphHash">The Activity Graph being pointed to by this location..</param>
/// <param name="activityGraphNodeHash">The Activity Graph Node being pointed to by this location. (Remember that Activity Graph Node hashes are only unique within an Activity Graph: so use the combination to find the node being spoken of).</param>
/// <param name="activityBubbleName">The Activity Bubble within the Destination. Look this up in the DestinyDestinationDefinition's bubbles and bubbleSettings properties..</param>
/// <param name="activityPathBundle">If we had map information, this would tell us something cool about the path this location wants you to take. I wish we had map information..</param>
/// <param name="activityPathDestination">If we had map information, this would tell us about path information related to destination on the map. Sad. Maybe you can do something cool with it. Go to town man..</param>
/// <param name="navPointType">The type of Nav Point that this represents. See the enumeration for more info..</param>
/// <param name="worldPosition">Looks like it should be the position on the map, but sadly it does not look populated... yet?.</param>
public DestinyDefinitionsDestinyLocationReleaseDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), string smallTransparentIcon = default(string), string mapIcon = default(string), string largeTransparentIcon = default(string), long spawnPoint = default(long), long destinationHash = default(long), long activityHash = default(long), long activityGraphHash = default(long), long activityGraphNodeHash = default(long), long activityBubbleName = default(long), long activityPathBundle = default(long), long activityPathDestination = default(long), int navPointType = default(int), List <int> worldPosition = default(List <int>))
{
this.DisplayProperties = displayProperties;
this.SmallTransparentIcon = smallTransparentIcon;
this.MapIcon = mapIcon;
this.LargeTransparentIcon = largeTransparentIcon;
this.SpawnPoint = spawnPoint;
this.DestinationHash = destinationHash;
this.ActivityHash = activityHash;
this.ActivityGraphHash = activityGraphHash;
this.ActivityGraphNodeHash = activityGraphNodeHash;
this.ActivityBubbleName = activityBubbleName;
this.ActivityPathBundle = activityPathBundle;
this.ActivityPathDestination = activityPathDestination;
this.NavPointType = navPointType;
this.WorldPosition = worldPosition;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsSocketsDestinySocketTypeDefinition" /> class.
/// </summary>
/// <param name="displayProperties">There are fields for this display data, but they appear to be unpopulated as of now. I am not sure where in the UI these would show if they even were populated, but I will continue to return this data in case it becomes useful..</param>
/// <param name="insertAction">Defines what happens when a plug is inserted into sockets of this type..</param>
/// <param name="plugWhitelist">A list of Plug \"Categories\" that are allowed to be plugged into sockets of this type. These should be compared against a given plug item's DestinyInventoryItemDefinition.plug.plugCategoryHash, which indicates the plug item's category. If the plug's category matches any whitelisted plug, or if the whitelist is empty, it is allowed to be inserted..</param>
/// <param name="socketCategoryHash">socketCategoryHash.</param>
/// <param name="visibility">Sometimes a socket isn't visible. These are some of the conditions under which sockets of this type are not visible. Unfortunately, the truth of visibility is much, much more complex. Best to rely on the live data for whether the socket is visible and enabled..</param>
/// <param name="alwaysRandomizeSockets">alwaysRandomizeSockets.</param>
/// <param name="isPreviewEnabled">isPreviewEnabled.</param>
/// <param name="hideDuplicateReusablePlugs">hideDuplicateReusablePlugs.</param>
/// <param name="overridesUiAppearance">This property indicates if the socket type determines whether Emblem icons and nameplates should be overridden by the inserted plug item's icon and nameplate..</param>
/// <param name="avoidDuplicatesOnInitialization">avoidDuplicatesOnInitialization.</param>
/// <param name="currencyScalars">currencyScalars.</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 DestinyDefinitionsSocketsDestinySocketTypeDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), DestinyDefinitionsSocketsDestinyInsertPlugActionDefinition insertAction = default(DestinyDefinitionsSocketsDestinyInsertPlugActionDefinition), List <DestinyDefinitionsSocketsDestinyPlugWhitelistEntryDefinition> plugWhitelist = default(List <DestinyDefinitionsSocketsDestinyPlugWhitelistEntryDefinition>), long socketCategoryHash = default(long), int visibility = default(int), bool alwaysRandomizeSockets = default(bool), bool isPreviewEnabled = default(bool), bool hideDuplicateReusablePlugs = default(bool), bool overridesUiAppearance = default(bool), bool avoidDuplicatesOnInitialization = default(bool), List <DestinyDefinitionsSocketsDestinySocketTypeScalarMaterialRequirementEntry> currencyScalars = default(List <DestinyDefinitionsSocketsDestinySocketTypeScalarMaterialRequirementEntry>), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.InsertAction = insertAction;
this.PlugWhitelist = plugWhitelist;
this.SocketCategoryHash = socketCategoryHash;
this.Visibility = visibility;
this.AlwaysRandomizeSockets = alwaysRandomizeSockets;
this.IsPreviewEnabled = isPreviewEnabled;
this.HideDuplicateReusablePlugs = hideDuplicateReusablePlugs;
this.OverridesUiAppearance = overridesUiAppearance;
this.AvoidDuplicatesOnInitialization = avoidDuplicatesOnInitialization;
this.CurrencyScalars = currencyScalars;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsCollectiblesDestinyCollectibleDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="scope">Indicates whether the state of this Collectible is determined on a per-character or on an account-wide basis..</param>
/// <param name="sourceString">A human readable string for a hint about how to acquire the item..</param>
/// <param name="sourceHash">This is a hash identifier we are building on the BNet side in an attempt to let people group collectibles by similar sources. I can't promise that it's going to be 100% accurate, but if the designers were consistent in assigning the same source strings to items with the same sources, it *ought to* be. No promises though. This hash also doesn't relate to an actual definition, just to note: we've got nothing useful other than the source string for this data..</param>
/// <param name="itemHash">itemHash.</param>
/// <param name="acquisitionInfo">acquisitionInfo.</param>
/// <param name="stateInfo">stateInfo.</param>
/// <param name="presentationInfo">presentationInfo.</param>
/// <param name="presentationNodeType">presentationNodeType.</param>
/// <param name="traitIds">traitIds.</param>
/// <param name="traitHashes">traitHashes.</param>
/// <param name="parentNodeHashes">A quick reference to presentation nodes that have this node as a child. Presentation nodes can be parented under multiple parents..</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 DestinyDefinitionsCollectiblesDestinyCollectibleDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), int scope = default(int), string sourceString = default(string), long sourceHash = default(long), long itemHash = default(long), DestinyDefinitionsCollectiblesDestinyCollectibleAcquisitionBlock acquisitionInfo = default(DestinyDefinitionsCollectiblesDestinyCollectibleAcquisitionBlock), DestinyDefinitionsCollectiblesDestinyCollectibleStateBlock stateInfo = default(DestinyDefinitionsCollectiblesDestinyCollectibleStateBlock), DestinyDefinitionsPresentationDestinyPresentationChildBlock presentationInfo = default(DestinyDefinitionsPresentationDestinyPresentationChildBlock), int presentationNodeType = default(int), List <string> traitIds = default(List <string>), List <long> traitHashes = default(List <long>), List <long> parentNodeHashes = default(List <long>), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.Scope = scope;
this.SourceString = sourceString;
this.SourceHash = sourceHash;
this.ItemHash = itemHash;
this.AcquisitionInfo = acquisitionInfo;
this.StateInfo = stateInfo;
this.PresentationInfo = presentationInfo;
this.PresentationNodeType = presentationNodeType;
this.TraitIds = traitIds;
this.TraitHashes = traitHashes;
this.ParentNodeHashes = parentNodeHashes;
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), 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="DestinyDefinitionsPresentationDestinyPresentationNodeDefinition" /> class.
/// </summary>
/// <param name="displayProperties">displayProperties.</param>
/// <param name="originalIcon">The original icon for this presentation node, before we futzed with it..</param>
/// <param name="rootViewIcon">Some presentation nodes are meant to be explicitly shown on the \"root\" or \"entry\" screens for the feature to which they are related. You should use this icon when showing them on such a view, if you have a similar \"entry point\" view in your UI. If you don't have a UI, then I guess it doesn't matter either way does it?.</param>
/// <param name="nodeType">nodeType.</param>
/// <param name="scope">Indicates whether this presentation node's state is determined on a per-character or on an account-wide basis..</param>
/// <param name="objectiveHash">If this presentation node shows a related objective (for instance, if it tracks the progress of its children), the objective being tracked is indicated here..</param>
/// <param name="completionRecordHash">If this presentation node has an associated \"Record\" that you can accomplish for completing its children, this is the identifier of that Record..</param>
/// <param name="children">The child entities contained by this presentation node..</param>
/// <param name="displayStyle">A hint for how to display this presentation node when it's shown in a list..</param>
/// <param name="screenStyle">A hint for how to display this presentation node when it's shown in its own detail screen..</param>
/// <param name="requirements">The requirements for being able to interact with this presentation node and its children..</param>
/// <param name="disableChildSubscreenNavigation">If this presentation node has children, but the game doesn't let you inspect the details of those children, that is indicated here..</param>
/// <param name="presentationNodeType">presentationNodeType.</param>
/// <param name="traitIds">traitIds.</param>
/// <param name="traitHashes">traitHashes.</param>
/// <param name="parentNodeHashes">A quick reference to presentation nodes that have this node as a child. Presentation nodes can be parented under multiple parents..</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 DestinyDefinitionsPresentationDestinyPresentationNodeDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), string originalIcon = default(string), string rootViewIcon = default(string), int nodeType = default(int), int scope = default(int), long objectiveHash = default(long), long completionRecordHash = default(long), DestinyDefinitionsPresentationDestinyPresentationNodeChildrenBlock children = default(DestinyDefinitionsPresentationDestinyPresentationNodeChildrenBlock), int displayStyle = default(int), int screenStyle = default(int), DestinyDefinitionsPresentationDestinyPresentationNodeRequirementsBlock requirements = default(DestinyDefinitionsPresentationDestinyPresentationNodeRequirementsBlock), bool disableChildSubscreenNavigation = default(bool), int presentationNodeType = default(int), List <string> traitIds = default(List <string>), List <long> traitHashes = default(List <long>), List <long> parentNodeHashes = default(List <long>), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.OriginalIcon = originalIcon;
this.RootViewIcon = rootViewIcon;
this.NodeType = nodeType;
this.Scope = scope;
this.ObjectiveHash = objectiveHash;
this.CompletionRecordHash = completionRecordHash;
this.Children = children;
this.DisplayStyle = displayStyle;
this.ScreenStyle = screenStyle;
this.Requirements = requirements;
this.DisableChildSubscreenNavigation = disableChildSubscreenNavigation;
this.PresentationNodeType = presentationNodeType;
this.TraitIds = traitIds;
this.TraitHashes = traitHashes;
this.ParentNodeHashes = parentNodeHashes;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyObjectiveDefinition" /> class.
/// </summary>
/// <param name="displayProperties">Ideally, this should tell you what your task is. I'm not going to lie to you though. Sometimes this doesn't have useful information at all. Which sucks, but there's nothing either of us can do about it..</param>
/// <param name="completionValue">The value that the unlock value defined in unlockValueHash must reach in order for the objective to be considered Completed. Used in calculating progress and completion status..</param>
/// <param name="scope">A shortcut for determining the most restrictive gating that this Objective is set to use. This includes both the dynamic determination of progress and of completion values. See the DestinyGatingScope enum's documentation for more details..</param>
/// <param name="locationHash">OPTIONAL: a hash identifier for the location at which this objective must be accomplished, if there is a location defined. Look up the DestinyLocationDefinition for this hash for that additional location info..</param>
/// <param name="allowNegativeValue">If true, the value is allowed to go negative..</param>
/// <param name="allowValueChangeWhenCompleted">If true, you can effectively \"un-complete\" this objective if you lose progress after crossing the completion threshold. If False, once you complete the task it will remain completed forever by locking the value..</param>
/// <param name="isCountingDownward">If true, completion means having an unlock value less than or equal to the completionValue. If False, completion means having an unlock value greater than or equal to the completionValue..</param>
/// <param name="valueStyle">The UI style applied to the objective. It's an enum, take a look at DestinyUnlockValueUIStyle for details of the possible styles. Use this info as you wish to customize your UI..</param>
/// <param name="progressDescription">Text to describe the progress bar..</param>
/// <param name="perks">If this objective enables Perks intrinsically, the conditions for that enabling are defined here..</param>
/// <param name="stats">If this objective enables modifications on a player's stats intrinsically, the conditions are defined here..</param>
/// <param name="minimumVisibilityThreshold">If nonzero, this is the minimum value at which the objective's progression should be shown. Otherwise, don't show it yet..</param>
/// <param name="allowOvercompletion">If True, the progress will continue even beyond the point where the objective met its minimum completion requirements. Your UI will have to accommodate it..</param>
/// <param name="showValueOnComplete">If True, you should continue showing the progression value in the UI after it's complete. I mean, we already do that in BNet anyways, but if you want to be better behaved than us you could honor this flag..</param>
/// <param name="completedValueStyle">The style to use when the objective is completed..</param>
/// <param name="inProgressValueStyle">The style to use when the objective is still in progress..</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 DestinyDefinitionsDestinyObjectiveDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition displayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), int completionValue = default(int), int scope = default(int), long locationHash = default(long), bool allowNegativeValue = default(bool), bool allowValueChangeWhenCompleted = default(bool), bool isCountingDownward = default(bool), int valueStyle = default(int), string progressDescription = default(string), DestinyDefinitionsDestinyObjectivePerkEntryDefinition perks = default(DestinyDefinitionsDestinyObjectivePerkEntryDefinition), DestinyDefinitionsDestinyObjectiveStatEntryDefinition stats = default(DestinyDefinitionsDestinyObjectiveStatEntryDefinition), int minimumVisibilityThreshold = default(int), bool allowOvercompletion = default(bool), bool showValueOnComplete = default(bool), int completedValueStyle = default(int), int inProgressValueStyle = default(int), long hash = default(long), int index = default(int), bool redacted = default(bool))
{
this.DisplayProperties = displayProperties;
this.CompletionValue = completionValue;
this.Scope = scope;
this.LocationHash = locationHash;
this.AllowNegativeValue = allowNegativeValue;
this.AllowValueChangeWhenCompleted = allowValueChangeWhenCompleted;
this.IsCountingDownward = isCountingDownward;
this.ValueStyle = valueStyle;
this.ProgressDescription = progressDescription;
this.Perks = perks;
this.Stats = stats;
this.MinimumVisibilityThreshold = minimumVisibilityThreshold;
this.AllowOvercompletion = allowOvercompletion;
this.ShowValueOnComplete = showValueOnComplete;
this.CompletedValueStyle = completedValueStyle;
this.InProgressValueStyle = inProgressValueStyle;
this.Hash = hash;
this.Index = index;
this.Redacted = redacted;
}
