internal TalentGridNodeStep(NodeActivationRequirement activationRequirement, bool affectsLevel, bool affectsQuality, bool canActivateNextStep,
DamageType damageType, DestinyDefinitionDisplayProperties displayProperties, string interactionDescription, bool isNextStepRandom, int nextStepIndex,
uint nodeStepHash, uint[] perkHashes, int startProgressionBarAtProgress, uint[] statHashes, int stepIndex, int truePropertyIndex, int trueStepIndex,
uint?damageTypeHash, TalentNodeStepGroups stepGroups, NodeSocketReplaceResponse[] socketReplacements)
{
ActivationRequirement = activationRequirement;
AffectsLevel = affectsLevel;
AffectsQuality = affectsQuality;
CanActivateNextStep = canActivateNextStep;
DamageTypeEnumValue = damageType;
DisplayProperties = displayProperties;
InteractionDescription = interactionDescription;
IsNextStepRandom = isNextStepRandom;
NextStepIndex = nextStepIndex;
NodeStepHash = nodeStepHash;
Perks = perkHashes.DefinitionsAsReadOnlyOrEmpty <DestinySandboxPerkDefinition>(DefinitionsEnum.DestinySandboxPerkDefinition);
StartProgressionBarAtProgress = startProgressionBarAtProgress;
Stats = statHashes.DefinitionsAsReadOnlyOrEmpty <DestinyStatDefinition>(DefinitionsEnum.DestinyStatDefinition);
StepIndex = stepIndex;
TruePropertyIndex = truePropertyIndex;
TrueStepIndex = trueStepIndex;
DamageType = new DefinitionHashPointer <DestinyDamageTypeDefinition>(damageTypeHash, DefinitionsEnum.DestinyDamageTypeDefinition);
StepGroups = stepGroups;
SocketReplacements = socketReplacements.AsReadOnlyOrEmpty();
}
internal DestinyMaterialRequirement(uint itemHash, bool deleteOnAction, int count, bool omitFromRequirements)
{
Item = new DefinitionHashPointer <DestinyInventoryItemDefinition>(itemHash, DefinitionsEnum.DestinyInventoryItemDefinition);
DeleteOnAction = deleteOnAction;
Count = count;
OmitFromRequirements = omitFromRequirements;
}
internal ActivityChallengeEntry(ActivityItemRewardEntry[] dummyRewards, int inhibitRewardsUnlockHash, uint objectiveHash, uint rewardSiteHash)
{
DummyRewards = dummyRewards.AsReadOnlyOrEmpty();
InhibitRewardsUnlockHash = inhibitRewardsUnlockHash;
Objective = new DefinitionHashPointer <DestinyObjectiveDefinition>(objectiveHash, DefinitionsEnum.DestinyObjectiveDefinition);
RewardSiteHash = rewardSiteHash;
}
public override void Write(
Utf8JsonWriter writer,
DefinitionHashPointer <T> value,
JsonSerializerOptions options)
{
JsonSerializer.Serialize(writer, value.Hash, options);
}
internal TalentGridNode(bool autoUnlocks, int binaryPairNodeIndex, int column, uint exclusiveSetHash, uint?groupHash, int groupScopeIndex, bool ignoreForCompletion,
bool isRandom, bool isRandomRepurchasable, bool isRealStepSelectionRandom, bool lastStepRepeats, string layoutIdentifier, uint loreHash, uint nodeHash,
int nodeIndex, string nodeStyleIdentifier, uint originalNodeHash, int[] prerequisiteNodeIndexes, int randomStartProgressionBarAtProgression, int row,
TalentGridNodeStep[] steps, int talentNodeTypes, NodeActivationRequirement randomActivationRequirement, uint[] exclusiveWithNodeHashes)
{
AutoUnlocks = autoUnlocks;
BinaryPairNodeIndex = binaryPairNodeIndex;
Column = column;
ExclusiveSetHash = exclusiveSetHash;
GroupHash = groupHash;
GroupScopeIndex = groupScopeIndex;
IgnoreForCompletion = ignoreForCompletion;
IsRandom = isRandom;
IsRandomRepurchasable = isRandomRepurchasable;
IsRealStepSelectionRandom = isRealStepSelectionRandom;
LastStepRepeats = lastStepRepeats;
LayoutIdentifier = layoutIdentifier;
Lore = new DefinitionHashPointer <DestinyLoreDefinition>(loreHash, DefinitionsEnum.DestinyLoreDefinition);
NodeHash = nodeHash;
NodeIndex = nodeIndex;
NodeStyleIdentifier = nodeStyleIdentifier;
OriginalNodeHash = originalNodeHash;
PrerequisiteNodeIndexes = prerequisiteNodeIndexes.AsReadOnlyOrEmpty();
RandomStartProgressionBarAtProgression = randomStartProgressionBarAtProgression;
Row = row;
Steps = steps.AsReadOnlyOrEmpty();
TalentNodeTypes = talentNodeTypes;
RandomActivationRequirement = randomActivationRequirement;
ExclusiveWithNodeHashes = exclusiveWithNodeHashes.AsReadOnlyOrEmpty();
}
internal InventoryItemPlugBlock(uint actionRewardItemOverrideHash, uint actionRewardSiteHash, PlugUiStyles alternatePlugStyle, string alternateUiPlugLabel,
bool applyStatsToSocketOwnerItem, uint enabledMaterialRequirementHash, InventoryItemPlugBlockRule[] enabledRules, uint insertionMaterialRequirementHash,
InventoryItemPlugBlockRule[] insertionRules, bool isDummyPlug, bool onActionRecreateSelf, PlugAvailabilityMode plugAvailability, uint plugCategoryHash,
string plugCategoryIdentifier, PlugUiStyles plugStyle, uint previewItemOverrideHash, string uiPlugLabel, InventoryItemPlugBlockParentItemOverride parentItemOverride,
InventoryItemPlugBlockEnergyCapacity energyCapacity, InventoryItemPlugBlockEnergyCost energyCost)
{
ActionRewardItemOverrideHash = actionRewardItemOverrideHash;
ActionRewardItemOverrideHash = actionRewardSiteHash;
AlternatePlugStyle = alternatePlugStyle;
AlternateUiPlugLabel = alternateUiPlugLabel;
ApplyStatsToSocketOwnerItem = applyStatsToSocketOwnerItem;
EnabledMaterialRequirement = new DefinitionHashPointer <DestinyMaterialRequirementSetDefinition>(enabledMaterialRequirementHash, DefinitionsEnum.DestinyMaterialRequirementSetDefinition);
EnabledRules = enabledRules.AsReadOnlyOrEmpty();
InsertionMaterialRequirement = new DefinitionHashPointer <DestinyMaterialRequirementSetDefinition>(insertionMaterialRequirementHash, DefinitionsEnum.DestinyMaterialRequirementSetDefinition);
InsertionRules = insertionRules.AsReadOnlyOrEmpty();
IsDummyPlug = isDummyPlug;
OnActionRecreateSelf = onActionRecreateSelf;
PlugAvailability = plugAvailability;
PlugCategory = new DefinitionHashPointer <DestinyItemCategoryDefinition>(plugCategoryHash, DefinitionsEnum.DestinyItemCategoryDefinition);
PlugCategoryIdentifier = plugCategoryIdentifier;
PlugStyle = plugStyle;
PreviewItemOverride = new DefinitionHashPointer <DestinyInventoryItemDefinition>(previewItemOverrideHash, DefinitionsEnum.DestinyInventoryItemDefinition);
UiPlugLabel = uiPlugLabel;
ParentItemOverride = parentItemOverride;
EnergyCapacity = energyCapacity;
EnergyCost = energyCost;
}
internal DestinyProfileTransitoryPartyMember(long membershipId, uint emblemHash, string displayName, DestinyPartyMemberStates status)
{
MembershipId = membershipId;
Emblem = new DefinitionHashPointer <DestinyInventoryItemDefinition>(emblemHash, DefinitionsEnum.DestinyInventoryItemDefinition);
DisplayName = displayName;
Status = status;
}
internal DestinyArtifactCharacterScoped(uint artifactHash, int pointsUsed, int resetCount, DestinyArtifactTier[] tiers)
{
Artifact = new DefinitionHashPointer <DestinyArtifactDefinition>(artifactHash, DefinitionsEnum.DestinyArtifactDefinition);
PointsUsed = pointsUsed;
ResetCount = resetCount;
Tiers = tiers.AsReadOnlyOrEmpty();
}
internal RecordStateInfo(uint claimedUnlockHash, uint completeUnlockHash, int featuredPriority, string obscuredString)
{
ClaimedUnlock = new DefinitionHashPointer <DestinyUnlockDefinition>(claimedUnlockHash, DefinitionsEnum.DestinyUnlockDefinition);
CompleteUnlock = new DefinitionHashPointer <DestinyUnlockDefinition>(completeUnlockHash, DefinitionsEnum.DestinyUnlockDefinition);
FeaturedPriority = featuredPriority;
ObscuredString = obscuredString;
}
internal DestinyPerkReference(uint perkHash, string iconPath, bool isActive, bool visible)
{
Perk = new DefinitionHashPointer <DestinySandboxPerkDefinition>(perkHash, DefinitionsEnum.DestinySandboxPerkDefinition);
IconPath = iconPath;
IsActive = isActive;
IsVisible = visible;
}
internal UnlockEventUnlock(uint unlockHash, int selectedValue, int clearedValue, uint unlockValueHash)
{
Unlock = new DefinitionHashPointer <DestinyUnlockDefinition>(unlockHash, DefinitionsEnum.DestinyUnlockDefinition);
SelectedValue = selectedValue;
ClearedValue = clearedValue;
UnlockValue = new DefinitionHashPointer <DestinyUnlockValueDefinition>(unlockValueHash, DefinitionsEnum.DestinyUnlockValueDefinition);
}
internal DestinyRecordDefinition(DestinyDefinitionDisplayProperties displayProperties, RecordCompletionInfo completionInfo, RecordExpirationInfo expirationInfo,
RecordIntervalInfo intervalInfo, uint[] objectiveHashes, uint[] parentNodeHashes, PresentationNodeType presentationNodeType,
RecordValueStyle recordValueStyle, RecordRequirements requirements, Scope scope, RecordStateInfo stateInfo, RecordTitleInfo titleInfo,
uint[] traitHashes, string[] traitIds, DestinyItemQuantity[] rewardItems, uint loreHash, RecordPresentationInfo presentationInfo, bool forTitleGilding,
bool blacklisted, uint hash, int index, bool redacted)
{
DisplayProperties = displayProperties;
CompletionInfo = completionInfo;
ExpirationInfo = expirationInfo;
IntervalInfo = intervalInfo;
PresentationNodeType = presentationNodeType;
RecordValueStyle = recordValueStyle;
Requirements = requirements;
Scope = scope;
StateInfo = stateInfo;
TitleInfo = titleInfo;
TraitIds = traitIds.AsReadOnlyOrEmpty();
Objectives = objectiveHashes.DefinitionsAsReadOnlyOrEmpty <DestinyObjectiveDefinition>(DefinitionsEnum.DestinyObjectiveDefinition);
ParentNodes = parentNodeHashes.DefinitionsAsReadOnlyOrEmpty <DestinyPresentationNodeDefinition>(DefinitionsEnum.DestinyPresentationNodeDefinition);
Traits = traitHashes.DefinitionsAsReadOnlyOrEmpty <DestinyTraitDefinition>(DefinitionsEnum.DestinyTraitDefinition);
RewardItems = rewardItems.AsReadOnlyOrEmpty();
Lore = new DefinitionHashPointer <DestinyLoreDefinition>(loreHash, DefinitionsEnum.DestinyLoreDefinition);
Blacklisted = blacklisted;
Hash = hash;
Index = index;
Redacted = redacted;
PresentationInfo = presentationInfo;
ForTitleGilding = forTitleGilding;
}
internal DestinyItemTalentGridComponent(uint talentGridHash, DestinyTalentNode[] nodes, bool isGridComplete, DestinyProgression gridProgression)
{
TalentGrid = new DefinitionHashPointer <DestinyTalentGridDefinition>(talentGridHash, DefinitionsEnum.DestinyTalentGridDefinition);
Nodes = nodes.AsReadOnlyOrEmpty();
IsGridComplete = isGridComplete;
GridProgression = gridProgression;
}
internal DestinyObjectiveDefinition(DestinyDefinitionDisplayProperties displayProperties, bool allowNegativeValue, bool allowOvercompletion, bool allowValueChangeWhenCompleted,
ObjectiveUnlockValueUIStyle completedValueStyle, int completionValue, ObjectiveUnlockValueUIStyle inProgressValueStyle, bool isCountingDownward, bool isDisplayOnlyObjective, uint locationHash,
int minimumVisibilityThreshold, ObjectivePerks perks, string progressDescription, Scope scope, bool showValueOnComplete, ObjectiveStats stats, ObjectiveUnlockValueUIStyle valueStyle,
bool blacklisted, uint hash, int index, bool redacted)
{
DisplayProperties = displayProperties;
AllowNegativeValue = allowNegativeValue;
AllowOvercompletion = allowOvercompletion;
AllowValueChangeWhenCompleted = allowValueChangeWhenCompleted;
CompletedValueStyle = completedValueStyle;
CompletionValue = completionValue;
InProgressValueStyle = inProgressValueStyle;
IsCountingDownward = isCountingDownward;
IsDisplayOnlyObjective = isDisplayOnlyObjective;
Location = new DefinitionHashPointer <DestinyLocationDefinition>(locationHash, DefinitionsEnum.DestinyLocationDefinition);
MinimumVisibilityThreshold = minimumVisibilityThreshold;
Perks = perks;
ProgressDescription = progressDescription;
Scope = scope;
ShowValueOnComplete = showValueOnComplete;
Stats = stats;
ValueStyle = valueStyle;
Blacklisted = blacklisted;
Hash = hash;
Index = index;
Redacted = redacted;
}
internal DestinyCharacterComponent(long membershipId, BungieMembershipType membershipType, long characterId, DateTime dateLastPlayed,
long minutesPlayedThisSession, long minutesPlayedTotal, int light, Dictionary <uint, int> stats, uint raceHash, uint genderHash,
uint classHash, DestinyRaceType raceType, DestinyClassType classType, DestinyGenderTypes genderType, string emblemPath,
string emblemBackgroundPath, uint emblemHash, DestinyColor emblemColor, DestinyProgression levelProgression,
int baseCharacterLevel, double percentToNextLevel, uint?titleRecordHash)
{
MembershipId = membershipId;
MembershipType = membershipType;
CharacterId = characterId;
DateLastPlayed = dateLastPlayed;
MinutesPlayedThisSession = minutesPlayedThisSession;
MinutesPlayedTotal = minutesPlayedTotal;
Light = light;
Stats = stats.AsReadOnlyDictionaryWithDefinitionKeyOrEmpty <DestinyStatDefinition, int>(DefinitionsEnum.DestinyStatDefinition);
Race = new DefinitionHashPointer <DestinyRaceDefinition>(raceHash, DefinitionsEnum.DestinyRaceDefinition);
Gender = new DefinitionHashPointer <DestinyGenderDefinition>(genderHash, DefinitionsEnum.DestinyGenderDefinition);
Class = new DefinitionHashPointer <DestinyClassDefinition>(classHash, DefinitionsEnum.DestinyClassDefinition);
RaceType = raceType;
ClassType = classType;
GenderType = genderType;
EmblemPath = emblemPath;
EmblemBackgroundPath = emblemBackgroundPath;
Emblem = new DefinitionHashPointer <DestinyInventoryItemDefinition>(emblemHash, DefinitionsEnum.DestinyInventoryItemDefinition);
EmblemColor = emblemColor;
LevelProgression = levelProgression;
BaseCharacterLevel = baseCharacterLevel;
PercentToNextLevel = percentToNextLevel;
TitleRecord = new DefinitionHashPointer <DestinyRecordDefinition>(titleRecordHash, DefinitionsEnum.DestinyRecordDefinition);
}
private PublicMilestoneActivity(uint activityHash, List <uint> challengeObjectiveHashes, List <uint> phaseHashes, Dictionary <uint, bool> booleanActivityOptions,
List <uint> modifierHashes)
{
Activity = new DefinitionHashPointer <DestinyActivityDefinition>(activityHash, DefinitionsEnum.DestinyActivityDefinition);
ChallengeObjectives = new List <DefinitionHashPointer <DestinyObjectiveDefinition> >();
if (challengeObjectiveHashes != null)
{
foreach (var challengeObjectiveHash in challengeObjectiveHashes)
{
ChallengeObjectives.Add(new DefinitionHashPointer <DestinyObjectiveDefinition>(challengeObjectiveHash, DefinitionsEnum.DestinyObjectiveDefinition));
}
}
PhaseHashes = phaseHashes;
BooleanActivityOptions = booleanActivityOptions;
//BooleanActivityOptions = new Dictionary<DefinitionHashPointer<DestinyObjectiveDefinition>, bool>();
//if (booleanActivityOptions != null)
//{
// foreach (var booleanActivityOption in booleanActivityOptions)
// {
// BooleanActivityOptions.Add(new DefinitionHashPointer<DestinyObjectiveDefinition>(booleanActivityOption.Key, "DestinyObjectiveDefinition", "en"), booleanActivityOption.Value);
// }
//}
Modifiers = new List <DefinitionHashPointer <DestinyActivityModifierDefinition> >();
if (modifierHashes != null)
{
foreach (var modifierHash in modifierHashes)
{
Modifiers.Add(new DefinitionHashPointer <DestinyActivityModifierDefinition>(modifierHash, DefinitionsEnum.DestinyActivityModifierDefinition));
}
}
}
internal DestinyCharacterCustomizationOptionDefinition(DestinyDefinitionDisplayProperties displayProperties, uint genderHash, uint raceHash,
CharacterCustomizationOptionColorOptions decalColorOptions,
CharacterCustomizationOptionColorOptions decalOptions, CharacterCustomizationOptionColorOptions eyeColorOptions,
uint[] faceOptionCinematicHostPatternIds, CharacterCustomizationOptionColorOptions faceOptions,
CharacterCustomizationOptionColorOptionsWithMultipleValues featureColorOptions, CharacterCustomizationOptionColorOptions featureOptions,
CharacterCustomizationOptionColorOptionsWithMultipleValues hairColorOptions, CharacterCustomizationOptionColorOptions hairOptions,
CharacterCustomizationOptionColorOptions helmetPreferences, CharacterCustomizationOptionColorOptions lipColorOptions,
CharacterCustomizationOptionColorOptions personalityOptions, CharacterCustomizationOptionColorOptions skinColorOptions,
bool blacklisted, uint hash, int index, bool redacted)
{
DisplayProperties = displayProperties;
Gender = new DefinitionHashPointer <DestinyGenderDefinition>(genderHash, DefinitionsEnum.DestinyGenderDefinition);
Race = new DefinitionHashPointer <DestinyRaceDefinition>(raceHash, DefinitionsEnum.DestinyRaceDefinition);
DecalColorOptions = decalColorOptions;
DecalOptions = decalOptions;
EyeColorOptions = eyeColorOptions;
FaceOptionCinematicHostPatternIds = faceOptionCinematicHostPatternIds.AsReadOnlyOrEmpty();
FaceOptions = faceOptions;
FeatureColorOptions = featureColorOptions;
FeatureOptions = featureOptions;
HairColorOptions = hairColorOptions;
HairOptions = hairOptions;
HelmetPreferences = helmetPreferences;
LipColorOptions = lipColorOptions;
PersonalityOptions = personalityOptions;
SkinColorOptions = skinColorOptions;
Blacklisted = blacklisted;
Hash = hash;
Index = index;
Redacted = redacted;
}
internal SandboxPatternFilter(Dictionary <string, int> arrangementIndexByStatValue, uint artArrangementRegionHash, int artArrangementRegionIndex, uint statHash)
{
ArrangementIndexByStatValue = arrangementIndexByStatValue.AsReadOnlyDictionaryOrEmpty();
ArtArrangementRegionHash = artArrangementRegionHash;
ArtArrangementRegionIndex = artArrangementRegionIndex;
Stat = new DefinitionHashPointer <DestinyStatDefinition>(statHash, DefinitionsEnum.DestinyStatDefinition);
}
internal DestinyPresentationNodeDefinition(DestinyDefinitionDisplayProperties displayProperties, PresentationChildNode children, bool disableChildSubscreenNavigation,
PresentationDisplayStyle displayStyle, int maxCategoryRecordScore, int nodeType, uint?objectiveHash, uint[] parentNodeHashes, PresentationNodeType presentationNodeType,
PresentationNodeRequirement requirements, Scope scope, int screenStyle, uint[] traitHashes, string[] traitIds, string originalIcon, string rootViewIcon,
uint?completionRecordHash, bool blacklisted, uint hash, int index, bool redacted)
{
DisplayProperties = displayProperties;
Children = children;
DisableChildSubscreenNavigation = disableChildSubscreenNavigation;
DisplayStyle = displayStyle;
MaxCategoryRecordScore = maxCategoryRecordScore;
NodeType = nodeType;
Objective = new DefinitionHashPointer <DestinyObjectiveDefinition>(objectiveHash, DefinitionsEnum.DestinyObjectiveDefinition);
ParentNodes = parentNodeHashes.DefinitionsAsReadOnlyOrEmpty <DestinyPresentationNodeDefinition>(DefinitionsEnum.DestinyPresentationNodeDefinition);
PresentationNodeType = presentationNodeType;
Requirements = requirements;
Scope = scope;
ScreenStyle = screenStyle;
Traits = traitHashes.DefinitionsAsReadOnlyOrEmpty <DestinyTraitDefinition>(DefinitionsEnum.DestinyTraitDefinition);
TraitIds = traitIds.AsReadOnlyOrEmpty();
Blacklisted = blacklisted;
Hash = hash;
Index = index;
Redacted = redacted;
OriginalIcon = originalIcon;
RootViewIcon = rootViewIcon;
CompletionRecord = new DefinitionHashPointer <DestinyRecordDefinition>(completionRecordHash, DefinitionsEnum.DestinyRecordDefinition);
}
internal DestinyItemSocketState(uint?plugHash, bool isEnabled, bool isVisible, int[] enableFailIndexes)
{
Plug = new DefinitionHashPointer <DestinyInventoryItemDefinition>(plugHash, DefinitionsEnum.DestinyInventoryItemDefinition);
IsEnabled = isEnabled;
IsVisible = isVisible;
EnableFailIndexes = enableFailIndexes.AsReadOnlyOrEmpty();
}
internal StatGroupScaledStat(bool displayAsNumeric, StatGroupInterpolation[] displayInterpolation, int maximumValue, uint statHash)
{
DisplayAsNumeric = displayAsNumeric;
DisplayInterpolation = displayInterpolation.AsReadOnlyOrEmpty();
MaximumValue = maximumValue;
Stat = new DefinitionHashPointer <DestinyStatDefinition>(statHash, DefinitionsEnum.DestinyStatDefinition);
}
internal DestinyCollectiblesComponent(Dictionary <uint, DestinyCollectibleComponent> collectibles, uint collectionCategoriesRootNodeHash,
uint collectionBadgesRootNodeHash)
{
Collectibles = collectibles.AsReadOnlyDictionaryWithDefinitionKeyOrEmpty <DestinyCollectibleDefinition, DestinyCollectibleComponent>(DefinitionsEnum.DestinyCollectibleDefinition);
CollectionCategoriesRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(collectionCategoriesRootNodeHash, DefinitionsEnum.DestinyPresentationNodeDefinition);
CollectionBadgesRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(collectionBadgesRootNodeHash, DefinitionsEnum.DestinyPresentationNodeDefinition);
}
internal BungieNetDestiny2CoreSettings(uint collectionRootNode, uint badgesRootNode, uint recordsRootNode, uint medalsRootNode, uint metricsRootNode,
uint activeTriumphsRootNodeHash, uint activeSealsRootNodeHash, uint legacyTriumphsRootNodeHash, uint legacySealsRootNodeHash, uint medalsRootNodeHash,
uint exoticCatalystsRootNodeHash, uint loreRootNodeHash, uint[] currentRankProgressionHashes, string undiscoveredCollectibleImage, string ammoTypeHeavyIcon,
string ammoTypeSpecialIcon, string ammoTypePrimaryIcon, uint currentSeasonalArtifactHash, uint?currentSeasonHash, uint[] futureSeasonHashes, uint[] pastSeasonHashes)
{
CollectionRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(collectionRootNode, DefinitionsEnum.DestinyPresentationNodeDefinition);
BadgesRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(badgesRootNode, DefinitionsEnum.DestinyPresentationNodeDefinition);
RecordsRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(recordsRootNode, DefinitionsEnum.DestinyPresentationNodeDefinition);
SealsRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(medalsRootNode, DefinitionsEnum.DestinyPresentationNodeDefinition);
MetricsRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(metricsRootNode, DefinitionsEnum.DestinyPresentationNodeDefinition);
ActiveTriumphsRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(activeTriumphsRootNodeHash, DefinitionsEnum.DestinyPresentationNodeDefinition);
ActiveSealsRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(activeSealsRootNodeHash, DefinitionsEnum.DestinyPresentationNodeDefinition);
LegacyTriumphsRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(legacyTriumphsRootNodeHash, DefinitionsEnum.DestinyPresentationNodeDefinition);
LegacySealsRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(legacySealsRootNodeHash, DefinitionsEnum.DestinyPresentationNodeDefinition);
MedalsRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(medalsRootNodeHash, DefinitionsEnum.DestinyPresentationNodeDefinition);
ExoticCatalystsRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(exoticCatalystsRootNodeHash, DefinitionsEnum.DestinyPresentationNodeDefinition);
LoreRootNode = new DefinitionHashPointer <DestinyPresentationNodeDefinition>(loreRootNodeHash, DefinitionsEnum.DestinyPresentationNodeDefinition);
CurrentRankProgressions = currentRankProgressionHashes.DefinitionsAsReadOnlyOrEmpty <DestinyProgressionDefinition>(DefinitionsEnum.DestinyProgressionDefinition);
UndiscoveredCollectibleImage = undiscoveredCollectibleImage;
AmmoTypeHeavyIcon = ammoTypeHeavyIcon;
AmmoTypeSpecialIcon = ammoTypeSpecialIcon;
AmmoTypePrimaryIcon = ammoTypePrimaryIcon;
CurrentSeasonalArtifact = new DefinitionHashPointer <DestinyArtifactDefinition>(currentSeasonalArtifactHash, DefinitionsEnum.DestinyArtifactDefinition);
СurrentSeason = new DefinitionHashPointer <DestinySeasonDefinition>(currentSeasonHash, DefinitionsEnum.DestinySeasonDefinition);
FutureSeasons = futureSeasonHashes.DefinitionsAsReadOnlyOrEmpty <DestinySeasonDefinition>(DefinitionsEnum.DestinySeasonDefinition);
PastSeasons = pastSeasonHashes.DefinitionsAsReadOnlyOrEmpty <DestinySeasonDefinition>(DefinitionsEnum.DestinySeasonDefinition);
}
internal VendorItemQuantity(int scalarDenominator, uint itemHash, int quantity, long?itemInstanceId)
{
ScalarDenominator = scalarDenominator;
Item = new DefinitionHashPointer <DestinyInventoryItemDefinition>(itemHash, DefinitionsEnum.DestinyInventoryItemDefinition);
Quantity = quantity;
ItemInstanceId = itemInstanceId;
}
internal PlugSetReusablePlugItem(double weight, double alternateWeight, uint plugItemHash, bool currentlyCanRoll)
{
Weight = weight;
AlternateWeight = alternateWeight;
PlugItem = new DefinitionHashPointer <DestinyInventoryItemDefinition>(plugItemHash, DefinitionsEnum.DestinyInventoryItemDefinition);
CurrentlyCanRoll = currentlyCanRoll;
}
public override void Write(Utf8JsonWriter writer, DefinitionHashPointer <T> value,
JsonSerializerOptions options)
{
if (value.Hash.HasValue)
{
writer.WriteNumber("hash", value.Hash.Value);
}
}
internal MilestoneItem(uint itemHash, int quantity, long?itemInstanceId, int?vendorItemIndex, uint?vendorHash)
{
Item = new DefinitionHashPointer <DestinyInventoryItemDefinition>(itemHash, DefinitionsEnum.DestinyInventoryItemDefinition);
Quantity = quantity;
ItemInstanceId = itemInstanceId;
VendorItemIndex = vendorItemIndex;
Vendor = new DefinitionHashPointer <DestinyVendorDefinition>(vendorHash, DefinitionsEnum.DestinyVendorDefinition);
}
internal TalentGridGroup(uint groupHash, uint loreHash, uint[] nodeHashes, uint[] opposingGroupHashes, uint[] opposingNodeHashes)
{
GroupHash = groupHash;
Lore = new DefinitionHashPointer <DestinyLoreDefinition>(loreHash, DefinitionsEnum.DestinyLoreDefinition);
NodeHashes = nodeHashes.AsReadOnlyOrEmpty();
OpposingGroupHashes = opposingGroupHashes.AsReadOnlyOrEmpty();
OpposingNodeHashes = opposingNodeHashes.AsReadOnlyOrEmpty();
}
internal InventoryItemTalentGrid(DamageType hudDamageType, string itemDetailString, uint talentGridHash, string buildName, string hudIcon)
{
HudDamageType = hudDamageType;
ItemDetailString = itemDetailString;
TalentGrid = new DefinitionHashPointer <DestinyTalentGridDefinition>(talentGridHash, DefinitionsEnum.DestinyTalentGridDefinition);
BuildName = buildName;
HudIcon = hudIcon;
}
internal RecordTitleInfo(bool hasTitle, Dictionary <DestinyGenderTypes, string> titlesByGender, Dictionary <uint, string> titlesByGenderHash,
uint?gildingTrackingRecordHash)
{
HasTitle = hasTitle;
TitlesByGender = titlesByGender.AsReadOnlyDictionaryOrEmpty();
TitlesByGenderHash = titlesByGenderHash.AsReadOnlyDictionaryWithDefinitionKeyOrEmpty <DestinyGenderDefinition, string>(DefinitionsEnum.DestinyGenderDefinition);
GildingTrackingRecord = new DefinitionHashPointer <DestinyRecordDefinition>(gildingTrackingRecordHash, DefinitionsEnum.DestinyRecordDefinition);
}
