/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyPlaceDefinition" /> 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 DestinyDefinitionsDestinyPlaceDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), uint?Hash = default(uint?), 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="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), uint?Hash = default(uint?), 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="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), uint?UiCategoryStyle = default(uint?), uint?Hash = default(uint?), int?Index = default(int?), bool?Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.UiCategoryStyle = UiCategoryStyle;
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), DestinyDefinitionsDestinyRewardSourceCategory Category = default(DestinyDefinitionsDestinyRewardSourceCategory), uint?Hash = default(uint?), 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="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), uint?Hash = default(uint?), 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="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), uint?Hash = default(uint?), 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="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="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), DestinyDestinyRace RaceType = default(DestinyDestinyRace), Dictionary <string, string> GenderedRaceNames = default(Dictionary <string, string>), uint?Hash = default(uint?), int?Index = default(int?), bool?Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.RaceType = RaceType;
this.GenderedRaceNames = GenderedRaceNames;
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="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), DestinyDestinyStatAggregationType AggregationType = default(DestinyDestinyStatAggregationType), bool?HasComputedBlock = default(bool?), uint?Hash = default(uint?), int?Index = default(int?), bool?Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.AggregationType = AggregationType;
this.HasComputedBlock = HasComputedBlock;
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="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), uint?EquipmentCategoryHash = default(uint?), uint?BucketTypeHash = default(uint?), bool?ApplyCustomArtDyes = default(bool?), uint?Hash = default(uint?), int?Index = default(int?), bool?Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.EquipmentCategoryHash = EquipmentCategoryHash;
this.BucketTypeHash = BucketTypeHash;
this.ApplyCustomArtDyes = ApplyCustomArtDyes;
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?), 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="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">Visibility.</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>), uint?SocketCategoryHash = default(uint?), DestinyDestinySocketVisibility Visibility = default(DestinyDestinySocketVisibility), uint?Hash = default(uint?), int?Index = default(int?), bool?Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.InsertAction = InsertAction;
this.PlugWhitelist = PlugWhitelist;
this.SocketCategoryHash = SocketCategoryHash;
this.Visibility = Visibility;
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?), 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="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..</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), uint?PlaceHash = default(uint?), uint?DefaultFreeroamActivityHash = default(uint?), List <DestinyDefinitionsDestinyActivityGraphListEntryDefinition> ActivityGraphEntries = default(List <DestinyDefinitionsDestinyActivityGraphListEntryDefinition>), List <DestinyDefinitionsDestinyDestinationBubbleSettingDefinition> BubbleSettings = default(List <DestinyDefinitionsDestinyDestinationBubbleSettingDefinition>), List <DestinyDefinitionsDestinyBubbleDefinition> Bubbles = default(List <DestinyDefinitionsDestinyBubbleDefinition>), uint?Hash = default(uint?), 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="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="BackgroundImagePath">The relative path to the background image, for use in a banner..</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="RewardVendorPreviewCategoryHashes">For the faction reward vendor, the category hashes to be shown as reward previews..</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), uint?ProgressionHash = default(uint?), string BackgroundImagePath = default(string), Dictionary <string, uint?> TokenValues = default(Dictionary <string, uint?>), uint?RewardItemHash = default(uint?), uint?RewardVendorHash = default(uint?), List <uint?> RewardVendorPreviewCategoryHashes = default(List <uint?>), uint?Hash = default(uint?), int?Index = default(int?), bool?Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.ProgressionHash = ProgressionHash;
this.BackgroundImagePath = BackgroundImagePath;
this.TokenValues = TokenValues;
this.RewardItemHash = RewardItemHash;
this.RewardVendorHash = RewardVendorHash;
this.RewardVendorPreviewCategoryHashes = RewardVendorPreviewCategoryHashes;
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="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), uint?SpawnPoint = default(uint?), uint?DestinationHash = default(uint?), uint?ActivityHash = default(uint?), uint?ActivityGraphHash = default(uint?), uint?ActivityGraphNodeHash = default(uint?), uint?ActivityBubbleName = default(uint?), uint?ActivityPathBundle = default(uint?), uint?ActivityPathDestination = default(uint?), DestinyDestinyActivityNavPointType NavPointType = default(DestinyDestinyActivityNavPointType), List <int?> WorldPosition = default(List <int?>))
{
this.DisplayProperties = DisplayProperties;
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="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), DestinyBucketScope Scope = default(DestinyBucketScope), DestinyBucketCategory Category = default(DestinyBucketCategory), int? BucketOrder = default(int?), int? ItemCount = default(int?), DestinyItemLocation Location = default(DestinyItemLocation), bool? HasTransferDestination = default(bool?), bool? Enabled = default(bool?), bool? Fifo = default(bool?), uint? Hash = default(uint?), 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="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="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="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?), uint?LocationHash = default(uint?), bool?AllowNegativeValue = default(bool?), bool?AllowValueChangeWhenCompleted = default(bool?), bool?IsCountingDownward = default(bool?), DestinyDestinyUnlockValueUIStyle ValueStyle = default(DestinyDestinyUnlockValueUIStyle), string ProgressDescription = default(string), DestinyDefinitionsDestinyObjectivePerkEntryDefinition Perks = default(DestinyDefinitionsDestinyObjectivePerkEntryDefinition), DestinyDefinitionsDestinyObjectiveStatEntryDefinition Stats = default(DestinyDefinitionsDestinyObjectiveStatEntryDefinition), uint?Hash = default(uint?), int?Index = default(int?), bool?Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.CompletionValue = CompletionValue;
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.Hash = Hash;
this.Index = Index;
this.Redacted = Redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyItemCategoryDefinition" /> class.
/// </summary>
/// <param name="DisplayProperties">DisplayProperties.</param>
/// <param name="Visible">If True, this category should be visible in UI. Sometimes we make categories that we don't think are interesting externally. It's up to you if you want to skip on showing them..</param>
/// <param name="ShortTitle">A shortened version of the title. The reason why we have this is because the Armory in German had titles that were too long to display in our UI, so these were localized abbreviated versions of those categories. The property still exists today, even though the Armory doesn't exist for D2... yet..</param>
/// <param name="ItemTypeRegex">The janky regular expression we used against the item type to try and discern whether the item belongs to this category..</param>
/// <param name="ItemTypeRegexNot">If the item type matches this janky regex, it does *not* belong to this category..</param>
/// <param name="OriginBucketIdentifier">If the item belongs to this bucket, it does belong to this category..</param>
/// <param name="GrantDestinyItemType">If an item belongs to this category, it will also receive this item type. This is now how DestinyItemType is populated for items: it used to be an even jankier process, but that's a story that requires more alcohol..</param>
/// <param name="GrantDestinySubType">If an item belongs to this category, it will also receive this subtype enum value. I know what you're thinking - what if it belongs to multiple categories that provide sub-types? The last one processed wins, as is the case with all of these \"grant\" enums. Now you can see one reason why we moved away from these enums... but they're so convenient when they work, aren't they?.</param>
/// <param name="GrantDestinyClass">If an item belongs to this category, it will also get this class restriction enum value. See the other \"grant\"-prefixed properties on this definition for my color commentary..</param>
/// <param name="GroupedCategoryHashes">If this category is a \"parent\" category of other categories, those children will have their hashes listed in rendering order here, and can be looked up using these hashes against DestinyItemCategoryDefinition. In this way, you can build up a visual hierarchy of item categories. That's what we did, and you can do it too. I believe in you. Yes, you, Carl. (I hope someone named Carl reads this someday).</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 DestinyDefinitionsDestinyItemCategoryDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), bool?Visible = default(bool?), string ShortTitle = default(string), string ItemTypeRegex = default(string), string ItemTypeRegexNot = default(string), string OriginBucketIdentifier = default(string), DestinyDestinyItemType GrantDestinyItemType = default(DestinyDestinyItemType), DestinyDestinyItemSubType GrantDestinySubType = default(DestinyDestinyItemSubType), DestinyDestinyClass GrantDestinyClass = default(DestinyDestinyClass), List <uint?> GroupedCategoryHashes = default(List <uint?>), uint?Hash = default(uint?), int?Index = default(int?), bool?Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.Visible = Visible;
this.ShortTitle = ShortTitle;
this.ItemTypeRegex = ItemTypeRegex;
this.ItemTypeRegexNot = ItemTypeRegexNot;
this.OriginBucketIdentifier = OriginBucketIdentifier;
this.GrantDestinyItemType = GrantDestinyItemType;
this.GrantDestinySubType = GrantDestinySubType;
this.GrantDestinyClass = GrantDestinyClass;
this.GroupedCategoryHashes = GroupedCategoryHashes;
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), DestinyHistoricalStatsDefinitionsDestinyActivityModeType ModeType = default(DestinyHistoricalStatsDefinitionsDestinyActivityModeType), DestinyDestinyActivityModeCategory ActivityModeCategory = default(DestinyDestinyActivityModeCategory), bool?IsTeamBased = default(bool?), bool?IsAggregateMode = default(bool?), List <uint?> ParentHashes = default(List <uint?>), string FriendlyName = default(string), Dictionary <string, DestinyHistoricalStatsDefinitionsDestinyActivityModeType> ActivityModeMappings = default(Dictionary <string, DestinyHistoricalStatsDefinitionsDestinyActivityModeType>), bool?Display = default(bool?), int?Order = default(int?), uint?Hash = default(uint?), 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="DestinyDefinitionsMilestonesDestinyMilestoneDefinition" /> class.
/// </summary>
/// <param name="DisplayProperties">DisplayProperties.</param>
/// <param name="Image">A custom image someone made just for the milestone. Isn't that special?.</param>
/// <param name="MilestoneType">An enumeration listing one of the possible types of milestones. Check out the DestinyMilestoneType enum for more info!.</param>
/// <param name="Recruitable">If True, then the Milestone has been integrated with BNet's recruiting feature..</param>
/// <param name="FriendlyName">If the milestone has a friendly identifier for association with other features - such as Recruiting - that identifier can be found here. This is \"friendly\" in that it looks better in a URL than whatever the identifier for the Milestone actually is..</param>
/// <param name="ShowInExplorer">If TRUE, this entry should be returned in the list of milestones for the \"Explore Destiny\" (i.e. new BNet homepage) features of Bungie.net (as long as the underlying event is active).</param>
/// <param name="HasPredictableDates">A shortcut for clients - and the server - to understand whether we can predict the start and end dates for this event. In practice, there are multiple ways that an event could have predictable date ranges, but not all events will be able to be predicted via any mechanism (for instance, events that are manually triggered on and off).</param>
/// <param name="Quests">The full set of possible Quests that give the overview of the Milestone event/activity in question. Only one of these can be active at a time for a given Conceptual Milestone, but many of them may be \"available\" for the user to choose from. (for instance, with Milestones you can choose from the three available Quests, but only one can be active at a time) Keyed by the quest item..</param>
/// <param name="Rewards">If this milestone can provide rewards, this will define the categories into which the individual reward entries are placed..</param>
/// <param name="VendorsDisplayTitle">If you're going to show Vendors for the Milestone, you can use this as a localized \"header\" for the section where you show that vendor data. It'll provide a more context-relevant clue about what the vendor's role is in the Milestone..</param>
/// <param name="Vendors">Sometimes, milestones will have rewards provided by Vendors. This definition gives the information needed to understand which vendors are relevant, the order in which they should be returned if order matters, and the conditions under which the Vendor is relevant to the user..</param>
/// <param name="Values">Sometimes, milestones will have arbitrary values associated with them that are of interest to us or to third party developers. This is the collection of those values' definitions, keyed by the identifier of the value and providing useful definition information such as localizable names and descriptions for the value..</param>
/// <param name="IsInGameMilestone">Some milestones are explicit objectives that you can see and interact with in the game. Some milestones are more conceptual, built by BNet to help advise you on activities and events that happen in-game but that aren't explicitly shown in game as Milestones. If this is TRUE, you can see this as a milestone in the game. If this is FALSE, it's an event or activity you can participate in, but you won't see it as a Milestone in the game's UI..</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 DestinyDefinitionsMilestonesDestinyMilestoneDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), string Image = default(string), DestinyDefinitionsMilestonesDestinyMilestoneType MilestoneType = default(DestinyDefinitionsMilestonesDestinyMilestoneType), bool?Recruitable = default(bool?), string FriendlyName = default(string), bool?ShowInExplorer = default(bool?), bool?HasPredictableDates = default(bool?), Dictionary <string, DestinyDefinitionsMilestonesDestinyMilestoneQuestDefinition> Quests = default(Dictionary <string, DestinyDefinitionsMilestonesDestinyMilestoneQuestDefinition>), Dictionary <string, DestinyDefinitionsMilestonesDestinyMilestoneRewardCategoryDefinition> Rewards = default(Dictionary <string, DestinyDefinitionsMilestonesDestinyMilestoneRewardCategoryDefinition>), string VendorsDisplayTitle = default(string), List <DestinyDefinitionsMilestonesDestinyMilestoneVendorDefinition> Vendors = default(List <DestinyDefinitionsMilestonesDestinyMilestoneVendorDefinition>), Dictionary <string, DestinyDefinitionsMilestonesDestinyMilestoneValueDefinition> Values = default(Dictionary <string, DestinyDefinitionsMilestonesDestinyMilestoneValueDefinition>), bool?IsInGameMilestone = default(bool?), uint?Hash = default(uint?), int?Index = default(int?), bool?Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.Image = Image;
this.MilestoneType = MilestoneType;
this.Recruitable = Recruitable;
this.FriendlyName = FriendlyName;
this.ShowInExplorer = ShowInExplorer;
this.HasPredictableDates = HasPredictableDates;
this.Quests = Quests;
this.Rewards = Rewards;
this.VendorsDisplayTitle = VendorsDisplayTitle;
this.Vendors = Vendors;
this.Values = Values;
this.IsInGameMilestone = IsInGameMilestone;
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;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyStatOverrideDefinition" /> class.
/// </summary>
/// <param name="StatHash">The hash identifier of the stat whose display properties are being overridden..</param>
/// <param name="DisplayProperties">The display properties to show instead of the base DestinyStatDefinition display properties..</param>
public DestinyDefinitionsDestinyStatOverrideDefinition(uint?StatHash = default(uint?), DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition))
{
this.StatHash = StatHash;
this.DisplayProperties = DisplayProperties;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyDisplayCategoryDefinition" /> class.
/// </summary>
/// <param name="Identifier">A string identifier for the display category..</param>
/// <param name="DisplayProperties">DisplayProperties.</param>
public DestinyDefinitionsDestinyDisplayCategoryDefinition(string Identifier = default(string), DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition))
{
this.Identifier = Identifier;
this.DisplayProperties = DisplayProperties;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyDestinationBubbleSettingDefinition" /> class.
/// </summary>
/// <param name="DisplayProperties">DisplayProperties.</param>
public DestinyDefinitionsDestinyDestinationBubbleSettingDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition))
{
this.DisplayProperties = DisplayProperties;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsMilestonesDestinyMilestoneRewardCategoryDefinition" /> class.
/// </summary>
/// <param name="CategoryHash">Identifies the reward category. Only guaranteed unique within this specific component!.</param>
/// <param name="CategoryIdentifier">The string identifier for the category, if you want to use it for some end. Guaranteed unique within the specific component..</param>
/// <param name="DisplayProperties">Hopefully this is obvious by now..</param>
/// <param name="RewardEntries">If this milestone can provide rewards, this will define the sets of rewards that can be earned, the conditions under which they can be acquired, internal data that we'll use at runtime to determine whether you've already earned or redeemed this set of rewards, and the category that this reward should be placed under..</param>
/// <param name="Order">If you want to use BNet's recommended order for rendering categories programmatically, use this value and compare it to other categories to determine the order in which they should be rendered. I don't feel great about putting this here, I won't lie..</param>
public DestinyDefinitionsMilestonesDestinyMilestoneRewardCategoryDefinition(uint?CategoryHash = default(uint?), string CategoryIdentifier = default(string), DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), Dictionary <string, DestinyDefinitionsMilestonesDestinyMilestoneRewardEntryDefinition> RewardEntries = default(Dictionary <string, DestinyDefinitionsMilestonesDestinyMilestoneRewardEntryDefinition>), int?Order = default(int?))
{
this.CategoryHash = CategoryHash;
this.CategoryIdentifier = CategoryIdentifier;
this.DisplayProperties = DisplayProperties;
this.RewardEntries = RewardEntries;
this.Order = Order;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyEntitySearchResultItem" /> class.
/// </summary>
/// <param name="Hash">The hash identifier of the entity. You will use this to look up the DestinyDefinition relevant for the entity found..</param>
/// <param name="EntityType">The type of entity, returned as a string matching the DestinyDefinition's contract class name. You'll have to have your own mapping from class names to actually looking up those definitions in the manifest databases..</param>
/// <param name="DisplayProperties">Basic display properties on the entity, so you don't have to look up the definition to show basic results for the item..</param>
/// <param name="Weight">The ranking value for sorting that we calculated using our relevance formula. This will hopefully get better with time and iteration..</param>
public DestinyDefinitionsDestinyEntitySearchResultItem(uint?Hash = default(uint?), string EntityType = default(string), DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), double?Weight = default(double?))
{
this.Hash = Hash;
this.EntityType = EntityType;
this.DisplayProperties = DisplayProperties;
this.Weight = Weight;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsMilestonesDestinyMilestoneRewardEntryDefinition" /> class.
/// </summary>
/// <param name="RewardEntryHash">The identifier for this reward entry. Runtime data will refer to reward entries by this hash. Only guaranteed unique within the specific Milestone..</param>
/// <param name="RewardEntryIdentifier">The string identifier, if you care about it. Only guaranteed unique within the specific Milestone..</param>
/// <param name="Items">The items you will get as rewards, and how much of it you'll get..</param>
/// <param name="VendorHash">If this reward is redeemed at a Vendor, this is the hash of the Vendor to go to in order to redeem the reward. Use this hash to look up the DestinyVendorDefinition..</param>
/// <param name="DisplayProperties">For us to bother returning this info, we should be able to return some kind of information about why these rewards are grouped together. This is ideally that information. Look at how confident I am that this will always remain true..</param>
/// <param name="Order">If you want to follow BNet's ordering of these rewards, use this number within a given category to order the rewards. Yeah, I know. I feel dirty too..</param>
public DestinyDefinitionsMilestonesDestinyMilestoneRewardEntryDefinition(uint?RewardEntryHash = default(uint?), string RewardEntryIdentifier = default(string), List <DestinyDestinyItemQuantity> Items = default(List <DestinyDestinyItemQuantity>), uint?VendorHash = default(uint?), DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), int?Order = default(int?))
{
this.RewardEntryHash = RewardEntryHash;
this.RewardEntryIdentifier = RewardEntryIdentifier;
this.Items = Items;
this.VendorHash = VendorHash;
this.DisplayProperties = DisplayProperties;
this.Order = Order;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyVendorInventoryFlyoutDefinition" /> class.
/// </summary>
/// <param name="LockedDescription">If the flyout is locked, this is the reason why..</param>
/// <param name="DisplayProperties">The title and other common properties of the flyout..</param>
/// <param name="Buckets">A list of inventory buckets and other metadata to show on the screen..</param>
/// <param name="FlyoutId">An identifier for the flyout, in case anything else needs to refer to them..</param>
/// <param name="SuppressNewness">If this is true, don't show any of the glistening \"this is a new item\" UI elements, like we show on the inventory items themselves in in-game UI..</param>
public DestinyDefinitionsDestinyVendorInventoryFlyoutDefinition(string LockedDescription = default(string), DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), List <DestinyDefinitionsDestinyVendorInventoryFlyoutBucketDefinition> Buckets = default(List <DestinyDefinitionsDestinyVendorInventoryFlyoutBucketDefinition>), uint?FlyoutId = default(uint?), bool?SuppressNewness = default(bool?))
{
this.LockedDescription = LockedDescription;
this.DisplayProperties = DisplayProperties;
this.Buckets = Buckets;
this.FlyoutId = FlyoutId;
this.SuppressNewness = SuppressNewness;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsMilestonesDestinyMilestoneValueDefinition" /> class.
/// </summary>
/// <param name="Key">Key.</param>
/// <param name="DisplayProperties">DisplayProperties.</param>
public DestinyDefinitionsMilestonesDestinyMilestoneValueDefinition(string Key = default(string), DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition))
{
this.Key = Key;
this.DisplayProperties = DisplayProperties;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDirectorDestinyActivityGraphNodeDefinition" /> class.
/// </summary>
/// <param name="NodeId">An identifier for the Activity Graph Node, only guaranteed to be unique within its parent Activity Graph..</param>
/// <param name="OverrideDisplay">The node *may* have display properties that override the active Activity's display properties..</param>
/// <param name="Position">The position on the map for this node..</param>
/// <param name="FeaturingStates">The node may have various visual accents placed on it, or styles applied. These are the list of possible styles that the Node can have. The game iterates through each, looking for the first one that passes a check of the required game/character/account state in order to show that style, and then renders the node in that style..</param>
/// <param name="Activities">The node may have various possible activities that could be active for it, however only one may be active at a time. See the DestinyActivityGraphNodeActivityDefinition for details..</param>
public DestinyDefinitionsDirectorDestinyActivityGraphNodeDefinition(uint?NodeId = default(uint?), DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition OverrideDisplay = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), DestinyDefinitionsCommonDestinyPositionDefinition Position = default(DestinyDefinitionsCommonDestinyPositionDefinition), List <DestinyDefinitionsDirectorDestinyActivityGraphNodeFeaturingStateDefinition> FeaturingStates = default(List <DestinyDefinitionsDirectorDestinyActivityGraphNodeFeaturingStateDefinition>), List <DestinyDefinitionsDirectorDestinyActivityGraphNodeActivityDefinition> Activities = default(List <DestinyDefinitionsDirectorDestinyActivityGraphNodeActivityDefinition>))
{
this.NodeId = NodeId;
this.OverrideDisplay = OverrideDisplay;
this.Position = Position;
this.FeaturingStates = FeaturingStates;
this.Activities = Activities;
}
