Namespace IdleKit.Gameplay

Classes

ActivityTrackingService

A tailor made solution to keep track of the time in ITimerService when the user returns from a paused or terminated app.

Upon the user's return, tha tracker will first set the time to the timestamp on record TimeModified. Then it will attempt to catch up the time in the current by stepping through interesting points in time denoted by EndTime and evaluate all the ITimerListener at that time.

AdvanceStageLoadPhase

This ILoadPhase is responsible for moving the player to the next available IStage in the IContent.

AdvanceStageStateAction

AnalyticsTrackingServiceBase

The AnalyticsTrackingServiceBase sets up common functionality that all analytics tracking services require.

AscensionAvailableAction

IAction fired when the CanAscend() goes from false to true

AscensionAvailableActivationCondition

AscensionAvailableActivationConditionData

AscensionAvailableActivationConditionDataAsset

AscensionCompleteActivationCondition

AscensionCompleteActivationConditionData

AscensionCompleteActivationConditionDataAsset

AscensionCompleteStateAction

AscensionPowerModifierFormula

AscensionPowerModifierFormulaData

AscensionPowerModifierFormulaDataAsset

AscensionReward

AscensionReward is a type of IReward that contains multiple other IReward such as CurrencyReward. These child IReward are contained within one or many AscensionRewardGroup. When the AscensionReward is claimed, the AscensionScoreRequired of each AscensionRewardGroup is queried. If the player has met the requirement then each of the child IReward within the AscensionRewardGroup is granted.

AscensionRewardData

AscensionRewardDataAsset

AscensionStartAction

AssetToPathAttribute

AutoCollectState

AutomateGeneratorActivationCondition

AutomateGeneratorActivationConditionData

AutomateGeneratorActivationConditionDataAsset

AutomateGeneratorsGoal

A Goal that is complete when a player automates one or more IGeneratorEntity in the IStage.

This Goal is similar to the AutomateGeneratorTypeGoal but doesn't target a specific IGeneratorEntity.

Each automation of a Generator progresses the IGoal by 1 unit until the target Amount is reached at which point the IGoal is complete.

Any Generator in the Stage that is already automated prior to this Goal being activated will count towards the completion of the Goal.

See AutomateGeneratorsGoalData.

AutomateGeneratorsGoalData

Contains the IGoalData associated with AutomateGeneratorsGoal

AutomateGeneratorsGoalDataAsset

AutomateGeneratorStateAction

Automates a target Generator and removes the automation cost from the player

AutomateGeneratorTrigger

AutomateGeneratorTriggerData

AutomateGeneratorTriggerDataAsset

AutomateGeneratorTypeGoal

A Goal that is complete when a player automates one or more instances of a specified IGeneratorEntity.

Any IGeneratorEntity with a Id that matches the GeneratorId will be targeted by the Goal. This is opposed to the AutomateGeneratorsGoal which does not target any specific IGeneratorEntity.

Each automation of a target IGeneratorEntity progresses the IGoal by 1 until the target Amount is reached at which point the Goal is complete.

Any target IGeneratorEntity that is already automated prior to this Goal being activated will count towards the completion of the Goal.

See AutomateGeneratorTypeGoalData.

AutomateGeneratorTypeGoalData

Contains the IGoalData associated with AutomateGeneratorTypeGoal

AutomateGeneratorTypeGoalDataAsset

AutomationAvailableActivationCondition

AutomationAvailableActivationConditionData

AutomationAvailableActivationConditionDataAsset

Avatar

Each avatar is represented withing IdleKit with an instance of this class.

AvatarCollection

AvatarCollectionData

AvatarCollectionDataAsset

AvatarCollectionSavedData

AvatarService

AvatarsUnlockReward

AvatarsUnlockRewardData

AvatarUnlockData

AvatarUnlockRewardDataAsset

BaseAmountToken

BaseCollectorAction

The base type for all IBaseCollectorEntity related IActions.

BaseCollectorBalanceData

BaseCollectorBalanceDataAsset<TBaseCollectorBalanceData>

BaseCollectorData

BaseCollectorEntity

BaseCollectorEntityData

BaseCollectorEntitySavedData

BaseCollectorInitializedAction

BaseCollectorPayoutChangedAction

BaseCollectorSpeedChangedAction

BaseCollectorStateChangedAction

BaseContentDataLoadPhase

The base LoadPhaseBase class that loads the IKManifest from the Beamable portal, bind the IKManifest and add the IData referenced by the IKManifest into the IDataService.

BaseMultipleDataProvider

Required to wrap multiple IDataProvider objects coming from Beamable. IdleKit currently only works when data is loaded as a single chunk per tag. If it is loaded individually services will attempt to load entities before their data dependencies are added to the IDataService

BasePlotPointAction

BasePlotPointActionData

BasePlotPointActionDataAsset<TData>

BasePlotPointActivationCondition<TPlotPointActivationConditionData>

BasePlotPointActivationConditionData

BasePlotPointActivationConditionDataAsset<TData>

BasePlotPointController

BaseRandomCurrencyReward<TData>

This base class contains common functionality for rewards that pull from a list of ICurrencys. See RandomObtainedCurrencyReward and RandomUnobtainedCurrencyReward for example use.

BaseRandomCurrencyRewardData

BaseSavedData

Beamable

A class for wrapping Beamable's server interactions. Interacts with Beamable's API to retrieve and manipulate data on Beamable's servers

BeamableEventsUpdatedAction

BeamableIAPService

A class for wrapping Beamable's server interactions with the IAP Purchasing Service. Interacts with Beamable's API to manipulate data on Beamable's servers

BeamableSerializer

This serializer uses a combination of Beamable Cloud Storage and Inventory to save content state. Some content needs to be saved to the Cloud Storage because it is not IdleKit "Content" but rather classes that need to store state. IUserSavedData and SerializedDataCache are examples of these. EventSettingsSavedData can't use Inventory because its asset doesn't extend IKItemContent<TInterface, TConcrete>

Boost

BoostData

BoostDataAsset

BoostSavedData

BuyBaseCollectorStateAction

Removes the buy Currency from the player and changes the generator state to Produce

BuyCollectorStateAction

BuyFromStoreCollectionStateAction

Purchase an IUpgradeableCurrency from the IStoreUpgradeableCurrencyCollection.

BuyGeneratorActivationCondition

BuyGeneratorActivationConditionData

BuyGeneratorActivationConditionDataAsset

BuyGeneratorStateAction

BuyGeneratorTriggerData

BuyGeneratorTriggerDataAsset

BuyGeneratorTypeGoal

A Goal which is complete when one or more instances of a specific IGeneratorEntity type are purchased by the player.

Any IGeneratorEntity with a Id that matches the IGeneratorEntity Id specified on the BuyGeneratorTypeGoalData will be targeted by the Goal.

Each purchase of a targeted IGeneratorEntity will progress the Goal by 1 unit up until the target Amount is met at which point the Goal is complete.

Any target IGeneratorEntity that is purchased prior to this Goal being activated will count towards the target Amount.

BuyGeneratorTypeGoalData

Contains the IGoalData associated with BuyGeneratorTypeGoal

BuyGeneratorTypeGoalDataAsset

BuyStoreRewardStateAction

Grants rewards for a purchased IStoreReward

CheckPromosLoadphase

ClaimEventRankRewardsStateAction

Grants rewards based on the players leaderboard rank and flags rank rewards as having been collected.

ClaimEventRewardsStateAction

Flags the IEventContent as complete in the associated IEventSettings and grants rewards for completed IMilestones.

ClaimGoalStateAction

ClaimGoalsTrigger

ClaimGoalsTriggerData

ClaimGoalsTriggerDataAsset

ClaimMilestoneTrackRewardsStateAction

ClaimNumGoalsTrigger

ClaimNumGoalsTriggerData

ClaimNumGoalsTriggerDataAsset

ClaimNumGoalsTriggerProgressStateAction

ClaimNumGoalsTriggerSavedData

ClaimStoreTimedRewardStateAction

The IStateAction to grant an IStoreTimedReward.

ClaimTimedTrackRewardsStateAction

ClearContentAction

ClearContentIdLoadPhase

This ILoadPhase clears the currently loaded IdleKit.Core.IContentData.Id from the IUserSavedData.

ClearContentIdStateAction

Clear the IContent's id the user was playing on.

ClearContentLoadPhase

This ILoadPhase takes a loaded IContent and clears it in preparation for loading the next IContent.

ClearEventsSavedDataStateAction

Clear all the IContent specific ISavedData associated with IEventSettings that have been completed.

CollectCurrenciesWithTagsGoal

A IGoal which is complete when a certain amount of one or more target ICurrency have been collected by the player.

The target ICurrency are specified via one or more Tag Ids. At runtime these Tag Ids are resolved into one or more ICurrency. The TargetAllTags is used to specify whether a target ICurrency needs to contain all, or just one of the Tag Ids specified in TargetTagIds.

Each time the player collects units of the target ICurrency the IGoal is progressed by the number of collected units. For example, if the player collected 100 units of Soft ICurrency, and the IGoal was targeting that ICurrency, the progress would be incremented by 100. This continues until the target amount has been reached at which point the IGoal is complete.

Only ICurrency collected after the IGoal has become active counts towards the progression of the IGoal. See CollectCurrenciesWithTagsGoalData

CollectCurrenciesWithTagsGoalData

Contains the IGoalData associated with the CollectCurrenciesWithTagsGoal

CollectCurrenciesWithTagsGoalDataAsset

CollectCurrencyTypeGoal

A IGoal that is complete when the player accumulates a certain number of units of one or more instances of a specified ICurrency type.

Any ICurrency with a Id that matches the Id specified via CurrencyId will be targeted by the Goal.

Each time the player collects units of the target ICurrency the IGoal is progressed by the number of collected units. For example, if the player collected 100 units of Soft ICurrency, and the IGoal was targeting instances of that ICurrency type, the progress would be incremented by 100. This continues until the target amount has been reached at which point the IGoal is complete.

Only ICurrency collected after the IGoal has become active counts towards the progression of the IGoal.

See CollectCurrencyTypeGoalData

CollectCurrencyTypeGoalData

Contains the IGoalData associated with CollectCurrencyTypeGoal

CollectCurrencyTypeGoalDataAsset

CollectFromBaseCollectorStateAction

Adds the generated Currency to the players persistent data and begins production again

CollectFromCollectorStateAction

CollectFromCollectorTypeGoal

A IGoal that is complete when the player collects from one or more instances of a specified ICollectorEntity.

This IGoal targets all ICollectorEntitys if the Any flag is set to true. Otherwise, it targets the ICollectorEntitys with a id that matches the ICollectorEntity Id specified on the CollectorId.

The IGoal progresses by 1 unit every time a targeted ICollectorEntity is collected from until the target amount is reached at which point the Goal is complete.

Only collections that occur after the IGoal becomes active will count towards progress of the IGoal.

CollectFromCollectorTypeGoalData

Contains the IGoalData associated with CollectFromCollectorTypeGoal

CollectFromCollectorTypeGoalDataAsset

CollectFromGeneratorStateAction

CollectFromGeneratorTypeGoal

A IGoal that is complete when the player collects from one or more instances of a specified IGeneratorEntity.

This IGoal targets all IGeneratorEntitys if the Any flag is set to true. Otherwise, it targets the IGeneratorEntitys with a id that matches the IGeneratorEntity Id specified on the GeneratorId.

The IGoal progresses by 1 unit every time a targeted IGeneratorEntity is collected from until the target amount is reached at which point the Goal is complete.

Only collections that occur after the IGoal becomes active will count towards progress of the IGoal.

CollectFromGeneratorTypeGoalData

Contains the IGoalData associated with CollectFromGeneratorTypeGoal

CollectFromGeneratorTypeGoalDataAsset

CollectGoal<TGoalData>

An abstract IGoal type which is used as the base of all ICurrency collection related IGoals.

Derived Collect Goals implementations should specify their target ICurrency by implementing the IsEligible(ICurrency) method.

The amount of ICurrency the player must collect. Specified via Amount, implemented for derived IGoals.

Each time a target ICurrency is collected by the player, the progress will be incremented by that amount until the target amount is reached.

Only ICurrency collected after the IGoal has become active counts towards the progression of CollectGoal<TGoalData>.

CollectionPurchaseInfo

A CollectionPurchaseInfo contains the Id for a IUpgradeableCurrency and the number of times it has been purchased in the IStoreUpgradeableCurrencyCollection. This info is used to calculate the ramping cost of the IUpgradeableCurrency while it is available for purchase.

CollectionReward

Rewards that grant a collection of rewards

CollectionRewardData

CollectionRewardDataAsset

CollectorBalanceData

CollectorBalanceDataAsset

CollectorData

CollectorDataAsset

CollectorEntity

CollectorEntityData

CollectorEntityDataAsset

CollectorInitializedAction

Called each time Initialize() is called

CollectorPayoutChangedAction

Called each time the ICollectorEntity updates its Payout

CollectorPayoutModifierFormula

CollectorPayoutModifierFormulaData

CollectorPayoutModifierFormulaDataAsset

CollectorSpeedChangedAction

Called each time the ICollectorEntity updates its Speed

CollectorSpeedModifierFormula

CollectorSpeedModifierFormulaData

CollectorSpeedModifierFormulaDataAsset

CollectorStateChangedAction

Called each time the ICollectorEntity changes IGeneratorState

CollectRewardTypeGoal

A IGoal that is completed once the player is granted one or more instances of a specific IReward.

Any IReward with a Id that matches the Id specified on the TargetRewardId.

The IGoal progresses by 1 every time a target IReward is granted to the player until the target amount is reached at which point the IGoal is complete.

Only IReward granted after the IGoal becomes active will count towards progress of the IGoal.

See CollectRewardTypeGoalData

CollectRewardTypeGoalData

Contains the IGoalData associated with CollectRewardTypeGoal

CollectRewardTypeGoalDataAsset

CollectUpgradeableCurrencyTypeGoal

A IGoal that is complete when the player accumulates a certain number of units of one or more instances of a specified IUpgradeableCurrency type. This is the same as CollectCurrencyTypeGoal but must target an IUpgradeableCurrency.

Any IUpgradeableCurrency with a Id that matches the Id specified via CurrencyId will be targeted by the Goal.

Each time the player collects units of the target IUpgradeableCurrency the IGoal is progressed by the number of collected units. For example, if the player collected 10 units of a Character IUpgradeableCurrency, and the IGoal was targeting instances of that IUpgradeableCurrency type, the progress would be incremented by 10. This continues until the target amount has been reached at which point the IGoal is complete.

Only IUpgradeableCurrency collected after the IGoal has become active counts towards the progression of the Goal.

See CollectUpgradeableCurrencyTypeGoalData

CollectUpgradeableCurrencyTypeGoalData

Contains the IGoalData associated with CollectUpgradeableCurrencyTypeGoal

CollectUpgradeableCurrencyTypeGoalDataAsset

CompleteMilestoneTrackStateAction

Content

ContentAction

Base type for IContent related actions

ContentData

ContentDataAsset

ContentInitializedAction

ContentProgressionAnalyticsTrackingService

The ContentProgressionAnalyticsTrackingService is responsible for subscribing to different kinds of content progress and converting them to analytics events logged through the IAnalyticsService.

ContentSavedData

CreateGoalStateAction

Sets the Goals target progression target If the Goal is dynamic the remote server will generate the progression target (not yet implemented)

Currency

CurrencyAction

Base type for all ICurrency related actions

CurrencyAvailableAction

Used when an ICurrency Available status is changed.

CurrencyAvailableActivationCondition

CurrencyAvailableActivationConditionData

CurrencyAvailableActivationConditionDataAsset

CurrencyAvailableTrigger

CurrencyAvailableTriggerData

CurrencyAvailableTriggerDataAsset

CurrencyChangeAnalyticsTrackingService

The CurrencyChangeAnalyticsTrackingService is responsible for subscribing to different kinds of currency changes and converting them to analytics events logged through the IAnalyticsService.

CurrencyChangedAction

Broadcast whenever the ICurrency and its ICurrencySavedData amount changes

CurrencyData

CurrencyDataAsset

CurrencyException

CurrencyNotFoundException

CurrencyObtainedAction

Used when an ICurrency Obtained status is changed.

CurrencyObtainedActivationCondition

CurrencyObtainedActivationConditionData

CurrencyObtainedActivationConditionDataAsset

CurrencyObtainedTrigger

CurrencyObtainedTriggerData

CurrencyObtainedTriggerDataAsset

CurrencyReward

IReward that grant a ICurrency specified by Min and Max.

CurrencyRewardData

CurrencyRewardDataAsset

CurrencySavedData

CurrencyService

CurrencyUnlockReward

This IReward is meant to be used to make a single ICurrency available. If the target ICurrency is already obtained, a fallback amount will be rewarded instead.

CurrencyUnlockRewardData

CurrencyUnlockRewardDataAsset

DataException

DataNotFoundException

DynamicCollectCurrenciesWithTagsGoal

A IGoal that is complete when the player collects a dynamically calculated number of units of one or more ICurrency. This allows designers to create Goals that require the player to idle for an approximate period of time.

The target amount is calculated based on the sum of the payout-per-millisecond of each currently automated IGeneratorEntity multiplied by a number of seconds specified via Amount. For example, if the player had two automated generators each outputting a payout-per-second of 5 and 7,200 as the number of seconds (2 hours) then the IGoal would require the player to collect 36,000,000‬ units of the specified ICurrency.

Note: Because it is likely that the player will automated more IGeneratorEntitys or hit more IGeneratorUnitTargetDatas while the IGoal is active, it's likely the player will complete the IGoal before the exact number of seconds specified via Amount have elapsed.

The target ICurrencys are specified via one or more Tag Ids via TargetTagIds. At runtime these Tag Ids are resolved into one or more ICurrency. The TargetAllTags flag is used to specify whether a target ICurrency needs to contain all, or just one of the specified Tag Ids.

Each time the player collects units of the target ICurrency the IGoal is progressed by the number of collected units.

Only units of ICurrency collected after the IGoal becomes active count towards the progress of the IGoal. The target amount of the IGoal will not vary after it becomes active (ie. IGeneratorEntity automated after the IGoal activation will have no effect on the target).

DynamicCollectCurrenciesWithTagsGoalData

Contains the IGoalData associated with DynamicCollectCurrenciesWithTagsGoal

DynamicCollectCurrenciesWithTagsGoalDataAsset

DynamicCollectCurrencyTypeGoal

A Goal that is complete when the player collects a dynamically calculated number of units of one or more ICurrency. This allows designers to create Goals that require the player to idle for an approximate period of time.

The target amount is calculated based on the sum of the payout-per-millisecond of each currently automated IGeneratorEntity multiplied by a number of seconds specified via DynamicCollectCurrencyTypeGoalData.amount. For example, if the player had two automated generators each outputting a payout-per-millisecond of 5 and 7,200 as the number of seconds (2 hours) then the Goal would require the player to collect 36,000,000‬ units of the specified ICurrency.

Because it is likely that the player will automated more IGeneratorEntity or hit more IGeneratorUnitTargetDatas while the Goal is active, it's likely the player will complete the Goal before the exact number of seconds specified via Amount have elapsed.

Any ICurrency with a Id that matches the Id specified via CurrencyId will be targeted by the Goal.

Each time the player collects units of the target ICurrency the Goal is progressed by the number of collected units.

Only units of ICurrency collected after the Goal becomes active count towards the progress of the Goal. The target amount of the Goal will not vary after it becomes active (ie. IGeneratorEntity automated after the Goal activation will have no effect on the target).

DynamicCollectCurrencyTypeGoalData

Contains the IGoalData associated with DynamicCollectCurrencyTypeGoal

DynamicCollectCurrencyTypeGoalDataAsset

DynamicCollectGoal<TGoalData>

An abstract IGoal type which is used as the base of all dynamically calculated ICurrency collection related IGoals.

Derived DynamicCollectGoal implementations should specify their target IGeneratorEntitys by implementing the DynamicCollectGoal.isEligible method.

The target amount is calculated based on the sum of the payout-per-second of each eligible automated IGeneratorEntity multiplied by a number of seconds accessed via Duration. For example, if the player had two automated generators each outputting a payout-per-second of 5000 and 7,200 as the number of seconds (2 hours) then the Goal would require the player to collect 36,000,000‬ units of ICurrency. If no IGeneratorEntitys are automated, the target is based on the average payout-per-millisecond of each purchased IGeneratorEntity. If no IGeneratorEntitys are purchased, an InvalidGoalDataException will be thrown.

Each time the player collects units of the target ICurrencys the IGoal is progressed by the number of collected units.

Only units of ICurrencys collected after the IGoal becomes active count towards the progress of the IGoal. The target amount of the IGoal will not vary after it becomes active (ie. Generators automated after the IGoal activation will have no effect on the target).

Because it is likely that the player will automated more IGeneratorEntitys or hit more IGeneratorUnitTargetData" while the IGoal is active, it's likely the player will complete the IGoal before the exact number of seconds specified via DynamicCollectCurrencyTypeGoalData.amount have elapsed.

EntityAction

Base type for IEntity related actions

EntityAddedAction

Called when the IEntity is added to the IContainer and resolved by the .

EntityInitializedAction

Called after the IEntity is added to the IContainer and Initialize() has been called.

EntityLoaderService

Implements the IEntityLoaderService and utilizes the base BindingService functionality when an IEntity is loaded or unloaded.

EntityRemovedAction

Called when the IEntity is removed from the IContainer

EntityResolver

EventCompletedTrigger

EventCompletedTriggerData

EventCompletedTriggerDataAsset

EventContent

EventContentData

EventContentDataAsset

EventEndedStateAction

Marks the IEventSettings as complete.

EventLeaderboardsService

EventPhaseStartedStateAction

EventService

EventSettings

EventSettingsData

EventSettingsDataAsset

EventSettingsSavedData

EventStartedStateAction

Sets the start time of the Event in the IEventSettings saved data.

EventStartedTrigger

EventStartedTriggerData

EventStartedTriggerDataAsset

EventStateAction

Exchange

ExchangeAction

The base type for all actions triggered during an exchange

ExchangeRateMultiplier

ExchangeRateMultiplierData

ExchangeRateMultiplierDataAsset

FunctionToken

GachaItem

GachaOddsService

A basic implementation of a gacha odds generation system. GachaOddsService handles calculating the odds of the rewards from within a GachaReward.

GachaReward

Gacha is a kind of IReward contains multiple IRewardData.id. Each GachaReward static data contains multiple GachaSlot. Each GachaSlot contains a list of GachaItems with different probability. CalculatePayouts() will calculate one reward per GachaSlot and reward them to the player.

GachaRewardData

Contains data associated with the IGachaReward

GachaRewardDataAsset

GachaSlot

An implementation of IGachaSlot that contains a list of GachaItem each containing a weight value. The weights from the GachaItem are used in the weighted random selection that results in granting of an IReward from the selected IGachaItem.

GeneratorAvailableActivationCondition

GeneratorAvailableActivationConditionData

GeneratorAvailableActivationConditionDataAsset

GeneratorBalanceData

GeneratorBalanceDataAsset

GeneratorData

GeneratorDataAsset

GeneratorEntity

GeneratorEntityData

All related data that makes a playable IGeneratorEntity. Decouples the IGeneratorBalanceData and IGeneratorUnitTargetSequence from the GeneratorData, allowing the re-use of rewards and balance.

GeneratorEntityDataAsset

GeneratorEntitySavedData

GeneratorException

GeneratorInitializedAction

Called each time IGeneratorEntity.Initialize is called

GeneratorModifierIndexChangedAction

Fired when a ModifierIndexChangedAction is caused by a generator collected enough units to hit a IGeneratorEntity Unit Target.

GeneratorNotFoundException

GeneratorPayoutChangedAction

Called each time the IGeneratorEntity updates its Payout

GeneratorPayoutModifierFormula

GeneratorPayoutModifierFormulaData

GeneratorPayoutModifierFormulaDataAsset

GeneratorSpeedChangedAction

Called each time the IGeneratorEntity updates its Speed

GeneratorSpeedModifierFormula

GeneratorSpeedModifierFormulaData

GeneratorSpeedModifierFormulaDataAsset

GeneratorStateChangedAction

Called each time the IGeneratorEntity changes IGeneratorState

GeneratorStateType

The String associated with a particular IGeneratorState. This is done so it would be faster to check the GeneratorStateType instead of the type of the IGeneratorState at runtime. This should only be used in UI code.

GeneratorUnitCostModifierFormula

GeneratorUnitCostModifierFormulaData

GeneratorUnitCostModifierFormulaDataAsset

GeneratorUnitTargetData

GeneratorUnitTargetDataAsset

GeneratorUnitTargetHitStateAction

Handles the Generator hitting GeneratorUnitTargets and rewards the player for any that are hit

GeneratorUnitTargetSequence

GeneratorUnitTargetSequenceData

GeneratorUnitTargetSequenceDataAsset

GenericIAP

GenericIAPData

GenericIAPDataAsset

GenericIAPSavedData

GetGeneratorUnitsForAllGeneratorsGoal

A IGoal that is complete when the player buys a specified number of units for a certain number of IGeneratorEntity within the IStage.

The IGoal progresses by 1 whenever a IGeneratorEntity reaches the target number of units specified via Amount. For example, a IGoal could be authored that requires the player to get all 5 IGeneratorEntity within the IGeneratorEntity to 100 units/customers.

IGeneratorEntity units that have been accumulated before the IGoal becomes active will count towards the target. IGeneratorEntitys that are purchased by the player after the IGoal becomes active will also still be eligible for contribution toward the target.

GetGeneratorUnitsForAllGeneratorsGoalData

Contains the IGoalData for GetGeneratorUnitsForAllGeneratorsGoal

GetGeneratorUnitsForAllGeneratorsGoalDataAsset

GetGeneratorUnitsForGeneratorsGoal

A IGoal that is complete when the player buys a certain number of units for a specified number of IGeneratorEntity.

Any active IGeneratorEntity within the current IStage.

The IGoal progresses by 1 whenever a IGeneratorEntity reaches the target number of units until the specified number of IGeneratorEntity have reached that many customers at which point the IGoal is complete.

IGeneratorEntity units that have been accumulated before the IGoal becomes active will count towards the target. A IGeneratorEntity purchased by the player after the IGoal becomes active will also still be eligible for contribution toward the target. See GetGeneratorUnitsForGeneratorsGoalData

GetGeneratorUnitsForGeneratorsGoalData

Contains the IGoalData for GetGeneratorUnitsForGeneratorsGoal

GetGeneratorUnitsForGeneratorsGoalDataAsset

GetGeneratorUnitsForGeneratorTypeGoal

A IGoal that is complete when the player buys a specified number of units for one or more instances of a specified IGeneratorEntity.

Any IGeneratorEntity with a Id that matches the Id specified via GeneratorId will be targeted by the IGoal.

The IGoal progresses by 1 whenever a targeted IGeneratorEntity reaches the target number of units specified via Amount. For example, a IGoal could be authored that requires the player to get a specific IGeneratorEntity to 100 units/customers.

IGeneratorEntity units that have been accumulated before the IGoal becomes active will count towards the target. Any IGeneratorEntity purchased by the player after the IGoal becomes active will also still be eligible for contribution toward the target.

GetGeneratorUnitsForGeneratorTypeGoalData

Contains the IGoalData for GetGeneratorUnitsForGeneratorTypeGoal

GetGeneratorUnitsForGeneratorTypeGoalDataAsset

GetTotalGeneratorUnitsGoal

A Goal that is complete when a specified number of units have been purchased from all IGeneratorEntitys combined.

All IGeneratorEntitys within the current IStage.

Each time the player purchases units for a IGeneratorEntity the Goal will be progressed by the number of units purchased. The Goal will also be progressed by a single unit whenever a IGeneratorEntity is purchased as a IGeneratorEntity has one unit by default. Once the target number of units have been reached the Goal is complete.

IGeneratorEntity units that have been accumulated before the Goal becomes active will count towards the target. A IGeneratorEntity purchased by the player after the Goal becomes active will also still be eligible for contribution toward the target.

GetTotalGeneratorUnitsGoalData

Contains the IGoalData for GetTotalGeneratorUnitsGoal

GetTotalGeneratorUnitsGoalDataAsset

GetUpgradesForCurrencyTypeGoal

A IGoal that is complete when the player upgrades any instances of a IUpgradeableCurrency with a specific Id.

The target IUpgradeableCurrency is specified by it's Id via GetUpgradesForCurrencyTypeGoalData.currencyId

Each time the player upgrades the target IUpgradeableCurrency the progress of the IGoal will be set to the level of the IUpgradeableCurrency. Once the target amount is met, the IGoal is complete.

Levels of IUpgradeableCurrency that have been reached due to upgrades prior to the IGoal becoming active will still count towards the IGoal progress.

See GetUpgradesForCurrencyTypeGoalData

GetUpgradesForCurrencyTypeGoalData

Contains the IGoalData for GetUpgradesForCurrencyTypeGoal

GetUpgradesForCurrencyTypeGoalDataAsset

GlobalTrack

GlobalTrackData

GlobalTrackDataAsset

Goal<TGoalData>

An abstract IGoal base type that provides much of the common functionality used by concrete Goal implementations.

The target is specified by the derived implementations of Goal<TGoalData>. The target amount is specified via the implementation of Amount. The progress of the Goal<TGoalData> is set each time ProgressGoal(Double) or SetProgressGoal(Double) is called from the derived implementations.

GoalAction

Base IAction for other actions fired from IGoals

GoalActivatedAction

GoalClaimedActivationCondition

GoalClaimedActivationConditionData

GoalClaimedActivationConditionDataAsset

GoalData

GoalDataAsset<TGoalData>

GoalException

GoalNotFoundException

GoalReadyToClaimActivationCondition

GoalReadyToClaimActivationConditionData

GoalReadyToClaimActivationConditionDataAsset

GoalSavedData

GoalTrack

A ITrack of IGoals in its ActivatableIds. The player progresses through the track by completing the IGoals sequentially. The active IGoal must be completed and claimed to activate the next IGoal in the ITrack.

GoalTrackData

GoalTrackDataAsset

GrantGoalRewardStateAction

GrantPayoutsStateAction

GrantRewardStateAction

HitGeneratorUnitTargetsGoal

A Goal that is complete when a specified number of IGeneratorUnitTargetData have been hit by the player.

Any IGeneratorEntity within the current IStage will be targeted.

Each time the player hits a IGeneratorUnitTargetData the progress will be incremented. If the player hits multiple IGeneratorUnitTargetData in one purchase, the progress will be incremented by the number of targets hit. Once the target amount is met, the Goal is complete.

The target amount is relative to the current IGeneratorUnitTargetData of a IGeneratorEntity when the Goal becomes active. For example, if the player has one active IGeneratorEntity at a IGeneratorUnitTargetData level of 5, getting to level 6 would complete a Goal with a target amount of 1.

Only IGeneratorUnitTargetData levels hit after the Goal becomes active will count towards the target progress.

HitGeneratorUnitTargetsGoalData

Contains the IGoalData for HitGeneratorUnitTargetsGoal

HitGeneratorUnitTargetsGoalDataAsset

IAPFailedAction

IdleKitInitializedAction

Action fired after all IdleKit Entities and Services have been initialized.

IKContent<TInterface, TConcrete>

A base IdleKit implementation of Beamables Beamable.Common.Content. This is used on IEntity objects that do not have any associated ISavedData.

IKEventContent<TInterface, TConcrete>

A base IdleKit implementation of Beamable's Beamable.Common.Content.EventContent

IKInstaller

IdleKit's implementation of the Installer that does not contain MonoBehaviour associated IBindings. Extend this class to override the functionality to specify additional non MonoBehaviour based IBindings.

IKItemContent<TInterface, TConcrete>

A base IdleKit implementation of Beamable's Beamable.Common.Inventory.ItemContent

IKManifest

A specialized Beamable compatible manifest that keeps track of all item and currency contents.

IKManifestRef

IKMonoInstaller

IdleKit's implementation of the MonoInstaller that contains MonoBehaviour associated IBindings. Extend this class to override the functionality to specify additional MonoBehaviour based IBindings.

IncrementGeneratorUnitStateAction

Removes the increment generatorUnit cost from the player and increments the generatorUnit on the target Generator

InitializeUserLoadPhase

This ILoadPhase should run any required initialization logic on the IUserSavedData. IsNew can be checked here for running conditional logic on new users.

InvalidFormulaException

InvalidGeneratorSpeedException

InvalidGeneratorUnitException

InvalidGoalDataException

InvalidRewardClaimException

InvalidUpgradeRequirementException

LeaderboardEntry

LeaderboardsService

LeaderboardsTools

LeftParenToken

LoadContentDataLoadPhase

Loads one or more IDataProvider objects and binds the data to the IContainer.

LoadContentLoadPhase

This ILoadPhase should initialize and load a IContent based on the current IUserSavedData.

LogLastActiveTimeStateAction

MakeAnyTradeGoal

A IGoal that is complete when a specified number of ITrade have been made by the player.

Any ITrade that is made while the IGoal is active is targeted by the IGoal.

The number of ITrade that must be made by the player to complete the IGoal, specified via MakeAnyTradeGoalData.amount.

Each time the player accepts a ITrade the progression will be incremented by 1. Once the target amount is met, the IGoal is complete.

Any ITrade that is made available to the player after the IGoal becomes active will still contribute to the progression.

Extends the base MakeTradeGoal<TGoalData> by overriding IsEligible(ITrade) to always return true. This makes the IGoal target all ITrades.

MakeAnyTradeGoalData

Contains the IGoalData for MakeTradeTypeGoal

MakeAnyTradeGoalDataAsset

MakeExchangeStateAction

Performs a missing resources exchange by modifying ICurrency amounts based on the requested input and output CurrencyAmounts

MakeTradeGoal<TGoalData>

An abstract base type for all ITrade related Goals.

The target is specified by the derived implementation of MakeTradeGoal<TGoalData>. The target amount is specified via the derived implementation of Amount. The MakeTradeGoal<TGoalData> will be progressed by 1 each time a target ITrade is made.

MakeTradeTypeGoal

A Goal that is complete when a targeted ITrade has been made by the player.

Any ITrade with the target Id that matches the Id specified via TradeId will be targeted.

The number of times the target ITrade must be made by the player to complete the Goal, usually 1. Specified via Amount.

Each time the player accepts the targeted ITrade the progression will be incremented by 1. Once the target amount is met, the Goal is complete.

Any @"IdleKit.ITrade?text=Trades" made prior to the Goal becoming active will not count toward it's completion.

Extends MakeTradeGoal<TGoalData> by implementing IsEligible(ITrade) to check that the ITrade argument passed has the same Id as the one specified in MakeTradeTypeGoalData.

See MakeTradeTypeGoalData.

MakeTradeTypeGoalData

Contains the IGoalData for MakeTradeTypeGoal

MakeTradeTypeGoalDataAsset

Milestone

TODO: This class is very similar to Goal<TGoalData>

MilestoneAction

Base type for IMilestone related actions

MilestoneClaimableAction

MilestoneCompletedActivationCondition

MilestoneCompletedActivationConditionData

MilestoneCompletedActivationConditionDataAsset

MilestoneCompletionInfo

A MilestoneCompletionInfo contains the Id for a IMilestone and the timestamp it is complete. The timestamp can be in the future if it has been estimated or the actual timestamp when the IMilestone was achieved".

MilestoneData

MilestoneDataAsset

MilestoneException

MilestoneNotFoundException

MilestoneRewardPair

This data pairs IMilestones with IRewards. The IEventService uses this data to reward the correct data when in the IContent that rewards are claimed.

MilestoneSavedData

MilestonesCompletedTrigger

MilestonesCompletedTriggerData

MilestonesCompletedTriggerDataAsset

MilestonesCompletedTriggerProgressStateAction

MilestonesCompletedTriggerSavedData

MilestoneTrack

A ITrack of IMilestones in its ActivatableIds. The player progresses through the track by completing the IMilestones sequentially. When the active IMilestone is completed, the next IMilestone in the track is activated. The rewards for the completed IMilestones are awarded when the MilestoneTrack is completed or deactivated.

MilestoneTrackData

MilestoneTrackDataAsset

MilestoneTrackSavedData

ModifierAction

The base type for all IModifier and IModifierService related IAction

ModifierCache

The ModifierCache keeps a dictionary of IModifiersplit into modifierGroupType of IModifierGroupData and the ModifiableId they affect.

This cache gets updated any time an IModifier is registered.

ModifierChangedAction

Base type for any IAction that signals when an IdleKit.Core.IModifier's state has altered.

ModifierData

ModifierFormula

ModifierFormulaData

ModifierFormulaDataAsset<TModifierFormulaData>

ModifierFormulaParser

This parser implements the Shunting-yard Algorithm and Reverse Polish Notation to take a formula written like "3 + ( 45 / 3 ) - 4" and parse it down to a single result.

ModifierGroupData

ModifierGroupDataAsset

ModifierGroupToken

ModifierIndexChangedAction

Fired when a modifier's ModifierDataIndex will change

ModifierRegisteredAction

Fired on ModifierService.RegisterModifier calls.

ModifierService

ModifierService.DummyModifierFormula

ModifierService.DummyModifierFormula is returned by GetModifierFormula(Type) if a IModifierFormula of the specified type cannot be found.

ModifierToggledAction

Fired whenever a IModifier is activated/deactivated via CanBeApplied.

ModifierUnregisteredAction

Fired on ModifierService.UnregisterModifier calls.

NetworkConnectionStatusService

NetworkStatusChangedAction

NewContentStateAction

Sets the target Content as the currently active Content for the player

NewStageStateAction

Gives the player the starting Currency and flags this Stage as started in the players persistent data

NewUserStateAction

Changes the player's IsNew flag to false

NextFramePlotPointAction

NextFramePlotPointActionData

NextFramePlotPointActionDataAsset

NonConsumableItem

NonConsumableItemData

NonConsumableItemDataAsset

NonConsumableItemSavedData

NumGoalsClaimedActivationCondition

NumGoalsClaimedActivationConditionData

NumGoalsClaimedActivationConditionDataAsset

NumTradesMadeActivationCondition

NumTradesMadeActivationConditionData

NumTradesMadeActivationConditionDataAsset

OfflineAction

OfflineProgressEndAction

OfflineProgressStartAction

OperatorToken

PanPlotPointAction

PanPlotPointActionData

PanPlotPointActionDataAsset

PassiveGoalTrack

A ITrack of IGoals in its ActivatableIds. The player progresses through the track by completing the IGoals sequentially. Once the active IGoal's CanClaim is true, the next IGoal in the ITrack is activated.

PassiveGoalTrackData

PassiveGoalTrackDataAsset

PaymentVerification

The fields here don't have the a "_" at the beginning because the class is is used to Serialize/Unserialized to Json and the final json uses the field's name as a property name.

PaymentVerificationConfig

PaymentVerificationConfigAsset

PayoutProjection

PlotPointActivatorData

PlotPointActorPool

PlotPointBaseActor

PlotPointBaseActorData

PlotPointController

PlotPointDataNotFoundException

Exception thrown by the IPlotPointDataProvider when a given piece of IPlotPointData can't be found

PlotPointDataProvider

PlotPointFrameData

PlotPointFrameDataAsset

PlotPointFramePlayedAction

The IAction is triggered when an IPlotPointFrameData is played. It would then be possible to resume playing from a specific frame inside the current IPlotPointSequenceData.

PlotPointImageActor

PlotPointImageActorData

PlotPointLayerResolver

PlotPointsClearedAction

The IAction is triggered when all the IPlotPointData related to the current IStage have been cleared.

This is usually the results of AdvanceStage() or IContent switching.

PlotPointSequenceAction

PlotPointSequenceCollectionData

PlotPointSequenceCollectionDataAsset

PlotPointSequenceCollectionSavedData

PlotPointSequenceCompletedAction

The IAction is triggered when the active IPlotPointSequenceData playback has been completed.

PlotPointSequenceData

PlotPointSequenceDataAsset

PlotPointSequenceEndedAction

The IAction is triggered when the active IPlotPointSequenceData playback has ended with or without its playback completion.

PlotPointSequenceEndedActivationCondition

PlotPointSequenceEndedActivationConditionData

PlotPointSequenceEndedActivationConditionDataAsset

PlotPointSequenceLoadedAction

The IAction is triggered when the active IPlotPointSequenceData is loaded and ready to be played.

PlotPointSequenceQueuedAction

The IAction is triggered when an IPlotPointSequenceData is queued to be played after its associated IPlotPointActivationCondition is triggered.

PlotPointSequenceStartedAction

The IAction is triggered when the active IPlotPointSequenceData playback has started.

PlotPointSequenceStoppedAction

PlotPointService

PlotPointsLoadedAction

The IAction is triggered when all the IPlotPointData related to the current IStage have been loaded.

PlotPointSpeechBubbleActor

PlotPointSpeechBubbleActorData

PlotPointTextActor

PlotPointTextActorData

PostSerializationAction

The action that gets sent after the ISavedData are serialized.

PreClearContentAction

PreSerializationAction

The action that gets sent before the ISavedData are serialized.

ProcessEventsSavedDataLoadPhase

This ILoadPhase is responsible for processing ISavedData related to all IEventSettings.

ProduceState

ProgressGoalStateAction

Increment the Progression associated with an IGoal

ProgressMilestoneStateAction

ProgressTrackStateAction

ProjectionCalculator

ProjectionService

Promo

PromoData

PromoDataAsset

PromoSavedData

PromoService

PurchasePayload

RandomObtainedCurrencyReward

Rewards that grant a random ICurrency that has the matching ITagData between Min and Max values.

The reward Currency's Available and Obtained have to be true for the Currency to be considered as a possible reward.

If set in the IRandomObtainedCurrencyRewardData, this will attempt to use a fallback Reward if it does not meet the criteria for claiming.

RandomObtainedCurrencyRewardData

Contains data associated with the RandomObtainedCurrencyReward

RandomObtainedCurrencyRewardDataAsset

RandomService

RandomUnobtainedCurrencyReward

Rewards that grant a random ICurrency that has the matching ITagData between Min and Max values.

The reward Currency's Available has to be true, and it's Obtained has to be false for the Currency to be considered as a possible reward.

If set in the IRandomUnobtainedCurrencyRewardData, this will attempt to use a fallback Reward if it does not meet the criteria for claiming.

RandomUnobtainedCurrencyRewardData

Contains data associated with the RandomUnobtainedCurrencyReward

RandomUnobtainedCurrencyRewardDataAsset

RarityData

RarityDataAsset

ReceiptValidation

Class which contains helper functions for verification of receipts created through Unity's IAP Service.

ReceiptValidationFailureResponse

ReceiptValidationSuccessResponse

RemoveContentDataLoadPhase

Removes the data from one or more IDataProvider objects and unbinds the data from the IContainer.

ResetEntitySavedDataStateAction

ResetUserLoadPhase

Resets all user save data that is saved on Beamable. A new user will be created next time the app is loaded.

RewardAction

The base type for all IReward related IAction types.

RewardDataAsset<TInterfaceRewardData, TConcreteRewardData>

RewardException

RewardGrantedAction

Can be used to track whenever a IReward has been granted to the player.

RewardNotFoundException

RewardService

A simple implementation of the IRewardService.

SavedDataIndex

SerializationAction

Base class of all IAction related to serialization of ISavedData

SerializationService

This SerializationService is in charge of serialize other ISavedData on a timed interval. It is also in charge of tracking TimeModified.

SerializedDataCache

SetAvailableCurrenciesStateAction

SetContentIdLoadPhase

This ILoadPhase determines which IContent to load based on the IUserSavedData and active IEventSettings.

SetContentStateAction

Set the IContent's id the user is going to play on. This needs to be set before all IService and the actual IContent are loaded.

SetEventEndTimeStateAction

SetGoalProgressStateAction

Set directly the Progression associated with an IGoal.

SetMilestoneCompletionInfoStateAction

A IStateAction that is used to set projected IMilestone completion times in IEventSettingsSavedData.

SetMilestoneProgressStateAction

SetPlotPointPlaybackAvailabilityAction

Enable or disable playback of any IPlotPointSequenceData. It is important to remember to re-enable the playback after it has been disabled.

SimpleJsonSerializer

A simple local Json implementation of the ISerializer it saves all the ISavedData at the _path.

SimpleSerializer

A dummy ISerializer that just stores ISavedData in memory. This is only used for unit tests and examples.

SpendCurrenciesWithTagsGoal

A Goal that is complete when the player spends a certain amount of the specified ICurrency.

The target ICurrencys are specified with one or more Tag Ids via TagConsumerData. At runtime these Tag Ids are resolved into one or more ICurrency. The TargetAll flag is used to specify whether a target ICurrency needs to contain all, or just one of the specified Tag Ids.

The total amount of ICurrency that the player must spend to complete the Goal. If multiple ICurrency are specified via the target Tag Ids then it is the cumulative spend between all of these ICurrencys. Specified via Amount.

Each time the player spends any of the target ICurrency the progression is incremented by the number of units of ICurrency spent.

Any ICurrency spent prior to the Goal becoming active will not count toward it's completion.

Extends the base SpendGoal by implementing SpendGoal.IsEligible to check for any currency contains the Tag Ids specified in SpendCurrenciesWithTagsGoalData.

See SpendCurrenciesWithTagsGoalData

SpendCurrenciesWithTagsGoalData

Contains the IGoalData for SpendCurrencyTypeGoal

SpendCurrenciesWithTagsGoalDataAsset

SpendCurrencyTypeGoal

A Goal that is complete when the player spends a certain amount of a specific ICurrency.

The Id ICurrency must match the Id specified via CurrencyId.

The amount of ICurrency that the player must spend to complete the Goal is specified via Amount.

Each time the player spends any of the target ICurrency the progression is incremented by the number of units of ICurrency spent.

Any ICurrency spent prior to the Goal becoming active will not count toward it's completion.

Extends the base SpendGoal by implementing SpendGoal.IsEligible to check that a currency matches the Id specified via SpendCurrencyTypeGoalData.

See SpendCurrencyTypeGoalData

SpendCurrencyTypeGoalData

Contains the IGoalData for SpendCurrencyTypeGoal

SpendCurrencyTypeGoalDataAsset

SpendGoal<TGoalData>

An abstract base type that extends CollectGoal<TGoalData> and should be used for all IGoals related to spending ICurrency.

The target is specified by the derived implementation of IsEligible(ICurrency). The target amount is specified via the derived implementation of Amount`. The Goal will be progressed by the amount of target ICurrency spent by the player.

The SpendGoal extends the CollectGoal<TGoalData> by overriding the behaviour of OnCurrencyChanged(CurrencyChangedAction) to progress the Goal based on the spending (rather than collecting) of ICurrency.

Stage

StageAction

Base IAction for other actions fired from IStages

StageAdvancedAction

StageData

StageDataAsset

StageInitializedAction

Fired after an IStage has been fully set up and is ready to run the game

StageInitializedActivationCondition

StageInitializedActivationConditionData

StageInitializedActivationConditionDataAsset

StageSavedData

StageStartTrigger

StageStartTriggerData

StageStartTriggerDataAsset

StandardContent

StandardContentData

StandardContentDataAsset

StandardContentFeatures

StandardContentSavedData

StandardEventContent

StandardEventContentData

This class was overridden to add the extended IStandardEventContentData onto EventContentData.

StandardEventContentDataAsset

StandardInstaller

StandardMonoInstaller

An IKMonoInstaller that utilize the StandardInstaller as its IIKInstaller.

Startup

StoreCollectionRefreshedStateAction

Set the refresh time of the IStoreUpgradeableCurrencyCollection.

StoreReward

StoreRewardData

StoreRewardDataAsset

StoreService

StoreTimedReward

StoreTimedRewardAvailableAction

Sent when the IStoreTimedReward is available to be claimed

StoreTimedRewardData

StoreTimedRewardDataAsset

StoreTimedRewardInitializeStateAction

Set timestamp of the IStoreTimedReward.

StoreTimedRewardSavedData

StoreTimedRewardStartAction

Sent when the StoreTimedReward has been subscribed to the ITimerService

StoreTimedRewardUnlockedStateAction

StoreUpgradeableCurrencyCollection

StoreUpgradeableCurrencyCollectionData

StoreUpgradeableCurrencyCollectionDataAsset

StoreUpgradeableCurrencyCollectionSavedData

TagConsumerData

TagData

TagDataAsset

TagException

TagNotFoundException

TagService

TimedActivatable<TActivatable>

An ITimedActivatable that provides timer functionality to activate and deactivate its Activatable.

TimedActivatableAction

Base IAction for other actions fired from ITimedActivatables

TimedActivatableData

TimedActivatableDataAsset<TTimedActivatableData>

TimedActivatableEndedAction

TimedActivatableSavedData

TimedBoost

TimedBoostData

TimedBoostDataAsset

TimedBoostSavedData

TimedGoalTrack

TimedGoalTrackData

TimedGoalTrackDataAsset

TimedMilestoneTrack

TimedMilestoneTrackData

TimedMilestoneTrackDataAsset

TimedTrack<TTrack>

TimedTrackData

TimedTrackDataAsset<TTimedTrackData>

TimedTrackSavedData

TimeLeftInEventTrigger

TimeLeftInEventTriggerData

TimeLeftInEventTriggerDataAsset

TimeLeftInEventTriggerSavedData

TimerService

An implementation of ITimerService where time can be advanced both manually or via OnUpdate.

TimerService.ListenerPriorityComparer

TimerSubscription

An implementation of ITimerSubscription that contains multiple overridden constructors to make it easier for objects that have different time information to work with the ITimerService easily.

TimerUtil

TimeSkipReward

TimeSkipRewardData

TimeSkipRewardDataAsset

ToggleActivatableStateAction

Set active status of a IActivatable.

ToggleActiveTradeStateAction

ToggleAvailableStateAction

Set the target Unlockable's availability. Once the IUnlockable becomes available it then can be considered for rewards like RandomObtainedCurrencyReward and RandomUnobtainedCurrencyReward.

ToggleBoostStateAction

Enable or disable an IBoost for the player.

ToggleMilestoneStateAction

TogglePromoReadyStateAction

ToggleTimedActivatableStateAction

Set active status and timestamp of a ITimedActivatable.

ToggleTimedBoostStateAction

A derived version of ModifierToggledAction that is used when toggling a TimedBoost.

ToggleTimeLeftInEventTriggeredStateAction

ToggleTrackStateAction

Track<TActivatable>

An abstract ITrack base type that provides much of the common functionality used by concrete Track implementations.

The activation and deactivation of the currently active IActivatable is specified by the derived implementations of Track<TActivatable>.

TrackAction

Base IAction for other actions fired from ITracks

TrackCompletedAction

TrackData

TrackDataAsset<TInterfaceTrackData, TTrackData>

TrackSavedData

TrackService

Trade

TradeAcceptedAction

TradeAction

TradeData

The static data associated with a Trade Entity.

TradeDataAsset

TradeDeclinedAction

TradeException

TradeNotFoundException

TradeService

Trigger

TriggerCompletedAction

TriggerData

UpgradeableCurrency

UpgradeableCurrencyData

UpgradeableCurrencyDataAsset

UpgradeableCurrencyRequirement

UpgradeableCurrencyRequirement is used in IGeneratorBalanceData to specify the IUpgradeableCurrency and its level required for IGeneratorEntity purchase and automation.

UpgradeableCurrencySavedData

UpgradeAnyCurrencyGoal

A Goal that is complete when the player gets a certain number of upgrades for any IUpgradeableCurrency.

Targets any IUpgradeableCurrency. The number of upgrades the player must make to any IUpgradeableCurrency is specified via Amount.

Each time the player upgrades a IUpgradeableCurrency the progression is incremented by 1.

Any upgrades to IUpgradeableCurrency made prior to the Goal becoming active will not count toward it's completion.

Extends the base UpgradeGoal by implementing UpgradeGoal.IsValid to check that an IUpgradeableCurrency can be upgraded.

See UpgradeAnyCurrencyGoalData

UpgradeAnyCurrencyGoalData

Contains the IGoalData for UpgradeAnyCurrencyGoal

UpgradeAnyCurrencyGoalDataAsset

UpgradeCurrenciesWithTagsGoal

A IGoal that is complete when the player gets a certain number of upgrades for one or more IUpgradeableCurrency.

The target IUpgradeableCurrency are specified with one or more Tag Ids via TagConsumerData. At runtime these Tag Ids are resolved into one or more IUpgradeableCurrency. The TargetAll flag is used to specify whether a target IUpgradeableCurrency needs to contain all, or just one of the specified Tag Ids.

The cumulative number of upgrades the player must make to the target IUpgradeableCurrency after which the IGoal is complete. Specified via Amount.

Each time the player upgrades a target IUpgradeableCurrency the progression is incremented by 1.

Any upgrades to target IUpgradeableCurrency made prior to the IGoal becoming active will not count toward it's completion.

This IGoal provides similar functionality to UpgradeAnyCurrencyGoal but allows for specific IUpgradeableCurrency to be targeted via Tags.

See UpgradeCurrenciesWithTagsGoalData

UpgradeCurrenciesWithTagsGoalData

UpgradeCurrenciesWithTagsGoalDataAsset

UpgradeCurrencyStateAction

Removes the upgrade costs from the player and changes the upgrade level on the target Entity

UpgradeException

UpgradeGoal<TGoalData>

An abstract base type that provides much of the shared functionality for IUpgradeableCurrency upgrade related Goals.

The target is specified by the derived implementation of IsValid(IUpgradeableCurrency)`. The target number of upgrades is specified via the derived implementation of Amount. The IGoal will be progressed by 1 each time a target IUpgradeableCurrency is upgraded by the player.

UpgradeLevelData

Contains an array of upgrade requirements

UpgradeRequirement

Defines a ICurrency or IUpgradeableCurrency cost required to upgrade

UserAcquisitionAnalyticsTrackingService

The UserAcquisitionAnalyticsTrackingService is responsible for subscribing to actions related to user acquisition and logging analytics events using the IAnalyticsService.

UserSavedData

UserSavedData.LastActivityTime

ValueToken

WaitPlotPointAction

WaitPlotPointActionData

WaitPlotPointActionDataAsset

WaitToBuyState

WaitToCollectState

WWWExtensions

Structs

AscensionRewardGroup

A reward group contains a list of rewardIds and a certain AscensionScoreRequired is required before the IReward can be granted.

CurrencyAmount

A wrapper class that contains a ICurrency and its amount.

GachaOdds

GachaOdds is a data container of a IGachaSlot slot within an GachaReward. Contains references to rewardId, chance, slot, and the item itself.

Interfaces

IActivatable

An IActivatable is an IEntity that can be activated, deactivated and reset, such as an ITrack.

IActivatableData

Contains the IEntityData associated with a certain IActivatable.

IAscensionReward

An IReward that is used during ascension. The AscensionScore can be used to determine what IRewards the user should receive.

IAscensionRewardData

The data associated with an IAscensionReward

IAutoCollectState

While in this IGeneratorState the associated IGeneratorEntity will collect generated ICurrency without any player input

IAvatarCollection

A collection of avatar objects with their sources. Used to separate avatars thematically and for easier management of a large amounts of avatars. A whole collection can be unlocked for the player, as well as individual avatars within it. The containing IAvatarCollection must be Unlocked and Obtained for the player to unlock individual Avatars.

IAvatarCollectionData

An IEntityData associated with an IAvatarCollection.

IAvatarCollectionDataAsset<TData>

The asset that contains IAvatarCollectionData.

IAvatarCollectionSavedData

ISavedData associated with an IAvatarCollection.

IAvatarService

An responsible for quick access to s.

IAvatarsUnlockReward

A type of IReward intended to unlock specific Avatars and/or IAvatarCollections for the player.

IAvatarsUnlockRewardData

IEntityData associated with an IAvatarsUnlockReward.

IBaseCollectorBalanceData

Contains the balance data shared between IGeneratorBalanceData and ICollectorBalanceData. See IGeneratorEntity. See ICollectorEntity.

IBaseCollectorBalanceDataAsset<TData>

The asset that contains the IBaseCollectorBalanceData.

IBaseCollectorData

Contains the data shared between IGeneratorData and ICollectorData. See IGeneratorEntity. See ICollectorEntity.

IBaseCollectorDataAsset<TData>

The asset that contains the IBaseCollectorData.

IBaseCollectorEntity

The primary purpose of any IBaseCollectorEntity is to produce an amount PayoutAmount of IPayoutEntity at a set interval, both defined inside the IBaseCollectorBalanceData.

IStages can have 0 or more IBaseCollectorEntitys. IBaseCollectorEntitys must be Buy() before they begin generating IPayoutEntity.

Once they are purchased (see Buy()) they will slowly progress over time based on their speed until they are ready to Collect(Int64).

IBaseCollectorEntityData

Contains the identifying data for an IGeneratorEntity or ICollectorEntity. These fields are used to define which IBaseCollectorData and IBaseCollectorBalanceData should be used.

IBaseCollectorEntityDataAsset<TData>

The asset that contains the IBaseCollectorEntityData

IBaseCollectorEntitySavedData

The ISavedData associated with a given IBaseCollectorEntity.

IBoost

A class that provides IModifier functionality that doesn't need to be tied to a specific entity and is, instead, its own entity.

IBoostData

Contains the data associated with a certain IBoost, which includes the data associated with the extended IModifier

IBoostDataAsset<TData>

The asset that contains the IBoostData

IBoostSavedData

Saved data associated with a given IBoost

ICollectionReward

ICollectionRewardData

The data associated with ICollectionRewards.

ICollectorBalanceData

A set of ICollectorEntity balance properties used for a specific ICollectorEntity.

ICollectorBalanceDataAsset<TData>

The asset that contains the ICollectorBalanceData

ICollectorData

Contains the definition of a specific ICollectorEntity. This is best described as, "which collector is this?" This is the data that is likely to be constant when building ICollectorEntityData. The ICollectorBalanceData is likely to change from IStage to IStage, unlike the ICollectorData. See ICollectorEntity.

ICollectorDataAsset<TData>

The asset that contains the ICollectorData

ICollectorEntity

A Collector generates IPayoutEntity. IStages can have 0 or more ICollectorEntitys.

An interface extending the IBaseCollectorEntity providing the base functionality.

ICollectorEntityData

Contains the IEntityData associated with a certain ICollectorEntity.

ICollectorEntityDataAsset<TData>

The asset that contains the ICollectorEntityData

IConnectionStatusService

A service intended for monitoring IdleKit's backend server connection status. The service works by evaluating the results of a number of recent chose backend service network requests to determine the health of the connection.

IContent

IContent defines game play data that a player could play through and their current progress/state in that content set. IContent allows the player to play IStages that are accessible from this IContent. IContents should be able to switch to other IContents with a different theme, game mode, etc.

IContentData

Contains data associated with a specific IContent

IContentDataAsset<TData>

The asset that contains the IContentData

IContentSavedData

Saved data for IContent

ICurrency

ICurrencyData

Contains the data associated with a specific ICurrency

ICurrencyDataAsset<TData>

The asset that contains the ICurrencyData

ICurrencyReward

A basic IReward that can reward a range of ICurrency. IRangeRewardData

ICurrencyRewardData

The data associated with ICurrencyReward. See IRangeRewardData for additional information.

ICurrencySavedData

Saved data for ICurrency.

ICurrencyService

This IService manages all ICurrency controllers in the active IContent

ICurrencyUnlockReward

A basic IReward that can reward a range of ICurrency. This reward is meant to be used to "unlock" currencies and make them begin to appear in the IRandomObtainedCurrencyReward currency pools.

ICurrencyUnlockRewardData

The data associated with ICurrencyUnlockReward.

ICustomPayoutReward

A type of IReward which can run its own custom logic to pay out the player. An example of this can be see in the IAvatarsUnlockReward.

IDynamicGoal

An IGoal that will dynamically determine TargetProgression at runtime, as opposed to the non dynamic IGoal that determines the target from its IGoalData.

IDynamicGoalData

The IGoalData associated with an IDynamicGoal

IEntity

The definition of a controller (this) to a model (IEntityData). Each entity in IdleKit has a IEntity, IEntityData, IGuidReferenceableAsset, and an optional ISavedData.

IEntityData

Where IData defines data that should be serialized and later loaded, IEntityData adds a definition that this data will be the data model to a IEntity.

An IEntityData may have it's own raw data or be a group of Ids to load that, together, provide the data required by the IEntitymade in CreateEntity().

IEntityLoaderService

Defines an IService that allows for loading of any IEntity.

The IEntityLoaderService makes the assumption that the IData associated with the Entity being loaded has been stored inside the IDataService.

IEntityResolver

A specialized abstracted version of IdleKit.Core.ITypedResolver{T} that only allows resolving of IEntity granting limited accesses to the IContainer.

IEventContent

IEventContent is an extension of IContent that allows for tracking progression with IMilestones. IEventContent works with IEventSettings to allow progression towards IReward defined in IMilestones.

IEventContentData

Contains data associated with a specific IEventContent.

IEventContentDataAsset<TData>

The asset that contains the IEventContentData

IEventLeaderboardsService

Responsible for retrieving and setting information for leaderboards automatically generated for each active EventSettings.

IEventService

This IService helps with retrieving all or a particular IEventSettings.

IEventSettings

The IEventSettings is used to map IRewards between an IEventContents IMilestones and another IContent.

It is recommended that this data be globally accessible in all IContent to reduce the risk of save or IReward claiming issues. Using this global mapping across IContent allows for only one set of IContent and associated data to be loaded at a time.

IEventSettingsData

Contains data associated with a specific IEventSettings.

IEventSettingsDataAsset<TData>

The asset that contains the IEventSettingsData

IEventSettingsSavedData

ISavedData for IEventSettings.

IExchangeable

An entity that has a value, or values, associated with it that can be used to perform exchanges.

IExchangeRateMultiplier

Allows an exchange rate to be calculated between two IExchangeable objects.

IExchangeRateMultiplierData

Contains the data associated with a certain IExchangeRateMultiplier

IExchangeRateMultiplierDataAsset<TData>

The asset that contains the IExchangeRateMultiplierData

IFallbackRewardData

A IReward that can fallback to a different one when it's contents cannot be rewarded.

IGachaItem

One possible item within a IGachaSlot each IGachaItem contains an IReward.

IGachaReward

A specific IReward that grants random IRewards to the player using the weights that GachaRewardData specifies.

IGachaRewardData

Contains the data associated with a specific IGachaReward

IGachaSlot

IGachaSlot are contained by IGachaReward. Each IGachaSlot contains a list of IGachaItem, each contains a single IReward. In the end, one IRewardfrom the IGachaSlot will be chosen based on the implementation.

IGeneratorBalanceData

A set of IGeneratorEntity balance properties used for a specific IGeneratorEntity.

IGeneratorBalanceDataAsset<TData>

The asset that contains the IGeneratorBalanceData

IGeneratorData

Contains the definition of a specific IGeneratorEntity. This is best described as, "which generator is this?" This is the data that is likely to be constant when building IGeneratorEntityData. The IGeneratorBalanceData and IGeneratorUnitTargetSequenceData are likely to change from IStage to IStage, unlike the IGeneratorData. See IGeneratorEntity. Because of this, you will likely use the id DataId as your ModifiableId instead of the controller's Id like most entities.

IGeneratorDataAsset<TData>

The asset that contains the IGeneratorData

IGeneratorEntity

A version of IBaseCollectorEntity that Automate() and allows the player to purchase generator units. Upon purchasing enough generator units the IGeneratorEntity would reach various IGeneratorUnitTargetData, that would grant additional IReward and modify the GetPayoutAmount(Boolean, IModifier[]) or GetDuration(Boolean, IModifier[]) that are defined in the GeneratorUnitTargetSequence.

IGeneratorEntityData

Contains the data associated with a specific IGeneratorEntity in a specific IStage. Each IGeneratorEntityData contains properties related to an IGeneratorUnitTargetSequenceData. For properties related to an IGeneratorEntity's payout, see IGeneratorBalanceData.

IGeneratorEntityDataAsset<TData>

The asset that contains the IGeneratorEntityData

IGeneratorEntitySavedData

Saved data for IGeneratorEntity.

IGeneratorState

IBaseCollectorEntity can be in various IGeneratorState. IAutoCollectState IProduceState IWaitToBuyState IWaitToCollectState

IGeneratorUnitTargetData

A numerical threshold for IGeneratorEntity Units that will give the player a IReward (and apply a IModifier to the IGeneratorEntity). An example would include getting 1000 customers for a Business/Generator which would result in a IGachaReward and a x5 modifier being applied to the IGeneratorEntity's payouts.

IGeneratorUnitTargetDataAsset<TData>

The asset that contains the IGeneratorUnitTargetData

IGeneratorUnitTargetSequence

Contains a sequential collection of IGeneratorUnitTargetDatas that are progressed through as the player buys IGeneratorEntity units.

IGeneratorUnitTargetSequenceData

Contains the data associated with a GeneratorUnitTargetSequence IGeneratorUnitTargetSequence

IGeneratorUnitTargetSequenceDataAsset<TData>

The asset that contains the IGeneratorUnitTargetSequenceData

IGenericIAP

An IEntity that is used for in app purchases

IGenericIAPData

Contains the IEntityData associated with a certain IGenericIAP.

IGenericIAPDataAsset<TData>

The asset that contains the IGenericIAPData

IGenericIAPSavedData

Saved data associated with a given IPromo

IGlobalTrack

A global ITrack which contains an ITrack. It overrides the regular ITrack's reward claiming logic to ensure its rewards are only claimable in one IContent, while the Track's IActivatables can still progress in different IContents.

IGlobalTrackData

Contains the IEntityData associated with a certain IGlobalTrack.

IGlobalTrackDataAsset<TData>

The asset that contains the IGlobalTrackData

IGoal

An IGoal is an IActivatable that is contained in an ITrack or one or more sequences in an IStage. The player can make progress towards an IGoals progression target. Once an IGoal progression target has been hit the IGoal can be claimed and the player can be rewarded.

IGoalData

Contains the data associated with a IGoal.

IGoalDataAsset<TData>

The asset that contains the IGoalData

IGoalSavedData

The ISavedData for ActiveGoals. There will be one pre active IGoal.

IGoalTrack

An ITrack whose list of IActivatables are IGoals.

IGoalTrackData

The data associated with a IGoalTrack.

IIKInstaller

An IdleKit specific version of the IInstaller containing methods to help bind or unbind IdleKit specific IAction, IService, and ILoadPhase.

IIKMonoInstaller

A MonoBehaviour version of the interface IIKInstaller.

ILeaderboardsService

Service intended for manipulating and retrieving data from player leaderboards.

IMilestone

IMilestones are IActivatables used to track progression through a IEventContent. Once a IMilestone has been completed, its associated rewards can be claimed.

IMilestoneData

Contains the IEntityData associated with a specific IMilestone.

IMilestoneDataAsset<TData>

The asset that contains the IMilestoneData

IMilestoneSavedData

Saved data for IMilestone.

IMilestoneTrack

An ITrack whose list of IActivatables are IMilestones.

IMilestoneTrackData

The data associated with a IMilestoneTrack.

IMilestoneTrackSavedData

The ISavedData associated with the IMilestoneTrack

IModifiable

A controller that implements this interface becomes a valid target for IModifier to affect. When currency, speed or other attribute of the IModifiable objects are being calculated, the IModifierData on the IModifier object would be applied. IModifiableData IModifier IModifierDataCollection

IModifiableData

This interface has to be implemented by the IEntityData class associated to the IEntity class that implements IModifiable. See IModifiable See IModifier See IModifierDataCollection

IModifier

An Entity that can modify values on the other Entities, specifically IModifiables. It is generally paired with IUpgradeable in order to ramp up modifiers as level increases. See IModifierDataCollection. See IModifiable. See IModifiableData. See IModifierService.

IModifierCache

A helper class that caches IModifiers for quick lookups.

IModifierData

IModifierDataCollection associated with its IModifier would contains multiple ModifierData. Each of the ModifierData would allow the IModifier to know how to affect the IModifiable.

IModifierDataCollection

Defines additional fields required by an entity's IEntityData if that entity has implemented IModifier's The values in this data are applied to the targets such as IStage and IGeneratorEntity that implement IModifiable See IModifier

IModifierFormula

This is used by the IStage and IGeneratorEntity to apply numeric logic against groups of IModifier objects. Given a target IModifiable this formula returns a value that represents the amount that all referenced IModifierData objects grouped by IModifierGroupData resolve down to. As of 1.0, IModifierFormulas are binded as singletons so there is the assumption only one instance of a type of IModifierFormula and IModifierFormulaData is available. IModifierFormulaData.formula = "base * 4 + ( modifierGroupId1 * modifierGroupId2 )"

The above formula would replace "base" with baseAmount. It would also collect all IModifierData objects that target the referenced IModifierGroupData ids and resolve those amounts down to a single value per IModifierGroupData. Those values are injected in place of the ids. The result is a completely numeric formula that can then be parsed by the IModifierFormulaParser.

IModifierFormulaData

The data associated with a IModifierFormula

IModifierFormulaDataAsset<TData>

The data asset associated with IModifierFormulaData

IModifierFormulaParser

Parses a formula provided by IModifierFormula and returns a value

IModifierGroupData

A group of IModifierData objects for use in IModifierFormula parsing. Groups are created inversely by targeting the IModifierGroupData in the IModifierData objects.

IModifierGroupDataAsset<TData>

The data asset associated with IModifierGroupData

IModifierService

This IService manages and applies the IModifier and IModifiable.

INonConsumableItem

A basic sample of a non-consumable item.

INonConsumableItemData

Contains the data associated with a specific INonConsumableItem

INonConsumableItemDataAsset<TData>

The asset that contains the INonConsumableItemData

INonConsumableItemSavedData

Saved data for INonConsumableItem

IPaymentVerification

Interface to expose the Payment verification Data

IPaymentVerificationConfig

Interface to expose specific properties related to the Payment Verification workflow.

IPayoutEntity

An IEntity that can be granted to the player either as an IBaseCollectorEntity output or a reward associated with completing certain in-game action.

IPayoutEntityData

Marker interface for the IEntityData associated with an IPayoutEntity. This is only used in referencing IGuidReferenceableAsset.

IPayoutProjection

This utility class represents the global payout rates per-millisecond for each ICurrency in the game up until the TimeExpired timestamp. TimeExpired represents the timestamp at which a payout rate changes, such as a ITimedBoost expiring.

IPlotPointAction

IPlotPointFrameDatas contain a series of Plot Point Actions which can perform various animation and logical operations

IPlotPointActionData

Contains the data associated with a specific IPlotPointAction

IPlotPointActionDataAsset

The data asset associated with IPlotPointActionData

IPlotPointActivationCondition

IPlotPointActivationConditionData

Contains the data associated with a IPlotPointActivationCondition

IPlotPointActivationConditionDataAsset

The data asset associated with IPlotPointActivationConditionData

IPlotPointActivatorData

Associates IPlotPointActivationConditionDatas with IPlotPointSequenceDatas

IPlotPointActor

Plot Point Frames contain a collection of Plot Point Actors which represent visual elements in the scene

IPlotPointActorData

A bundle of data used for populating an IPlotPointActor

IPlotPointController

This class is responsible for the visual representation of the IPlotPointSequenceData.

IPlotPointData

Interface for all forms of IData associated with Plot Points

IPlotPointDataAsset

The base interface for all IPlotPointData related data assets. This is only used when we do not (need to) specify the type of the PlotPointData that this IGuidReferenceableAsset contains in editor code.

IPlotPointDataAsset<TPlotPointData>

The interface for all IPlotPointData related data asset. This is implemented by all IPlotPointData's data asset classes.

IPlotPointDataProvider

Data provider for storing and retrieving various instances of IPlotPointData

IPlotPointFrameData

Frames are discrete collections of data that tell the IPlotPointController what visuals to display and what actions to perform

IPlotPointFrameDataAsset

The data asset associated with IPlotPointFrameData

IPlotPointSequenceCollectionData

Container class, associated with an IStage and a collection of IPlotPointActivatorDatas

IPlotPointSequenceCollectionDataAsset

The data asset associated with IPlotPointSequenceCollectionData

IPlotPointSequenceCollectionSavedData

Saved data for IPlotPointSequenceCollectionData, used to prevent the same plot points from activating multiple times

IPlotPointSequenceData

A collection of IPlotPointFrameData ids

IPlotPointSequenceDataAsset

The data asset associated with IPlotPointSequenceData

IPlotPointService

IService for managing all plot point related classes during runtime including LoadPlotPoints() and CleanupPlotPoints(Boolean)

IProduceState

While in this IGeneratorState, the associated IGeneratorEntity and move to a different IGeneratorState when it is done.

IProjectionCalculator

The helper class utilized by the IProjectionService that performs the actual projection calculations.

IProjectionService

A IService that is used to get projections of CurrencyAmount earned with respect to time, using the current global ICurrency payout per millisecond, and vice versa.

IPromo

An IEntity that can be shown to the player when some conditions are met.

IPromoData

Contains the IEntityData associated with a certain IPromo.

IPromoDataAsset<TData>

The asset that contains the IPromoData

IPromoSavedData

Saved data associated with a given IPromo

IPromoService

IPurchasePayload

An interface to expose the fields of the Purchase Payload after making an IAP

IRandomObtainedCurrencyReward

A IReward that can reward a random ICurrency based on a set of ITagConsumerData. The ICurrency must be available and obtained to show up in the pool of valid rewards.

IRandomObtainedCurrencyRewardData

The data associated with IRandomObtainedCurrencyRewards.

IRandomService

This IService manages generation of random values. This service's functionality could be overriden so that the seeds and/or random values are generated server-side.

IRandomUnobtainedCurrencyReward

A IReward that can reward a random ICurrency based on a set of ITagConsumerData. The ICurrency must be available but not obtained to show up in the pool of valid rewards.

IRandomUnobtainedCurrencyRewardData

The data associated with IRandomUnobtainedCurrencyRewards.

IRandomWeighted

IRangeRewardData

A IReward that gives a ranged amount.

IRarityData

This class currently acts as a special ITagData that can be identified by its type. For example, a RarityData is treated as a ITagData where only one can be applied to a single ICurrency. This is opposed to ICurrency tags where a single ICurrency can hold many ITagDatas. Them being separate types is also helpful for allowing the GuidReferenceAttribute control which of the two types can show up in which dropdowns in the Unity Inspector.

IRarityDataAsset<TData>

The asset that contains the IRarityData

IReceiptValidation

IReceiptValidationFailureResponse

Dto to expose the failed serialized response of the Verification Payment

IReceiptValidationSuccessResponse

Dto to expose the success serialized response of the Verification Payment

IReward

IRewards are generally associated to with IGeneratorUnitTargetSequences and IGoals. They can be claimed when a target is hit in a IGeneratorUnitTargetSequence, when a IGoal is completed, or any other feats a player performs that give out awards. The IRewards can be deterministic, random, or even a IGachaReward.

IRewardData

The data associated with a IReward.

IRewardDataAsset<TData>

The asset that contains the IRewardData

IRewardService

This IService handles the loading and provides convenient way to fetch any IReward

ISavedData

The definition of an object that saves and loads the persistent state of an IEntity.

This is an optional component of the IEntity structure if the IEntityData implementation also extends ISavedDataProvider.

ISavedDataProvider

The IData class that implements this interface implies that it is able to create an ISavedData.

ISerializer

Interface for serializing the data whether it is local or remote.

IStage

A IStage contains collections of IGeneratorEntitys and IGoals. A player progresses through a IStage by using the IGeneratorEntitys to generate ICurrency and completing IGoals. Once enough Goals have been completed the player can ascend to the next IStage.

IStageData

The data associated with a IStage.

IStageDataAsset<TData>

The asset that contains the IStageData

IStageSavedData

Saved data for a IStage.

IStandardContent

IStandardContent extends the basic IContent but adds ITrade, IStoreTimedReward, and IBoost functionality that are common in idle games.

IStandardContentData

Contains data associated with a specific IStandardContent.

IStandardContentDataAsset<TData>

The IContentDataAsset<TData> that contains the IStandardContentData

IStandardContentFeatures

A component interface utilize by the IStandardContent that provides additional functionality such as ITrade, IStoreTimedReward, and IBoost functionality that are common in idle games.

IStandardContentSavedData

ISavedData for IStandardContent.

IStandardEventContent

IStandardEventContent extends the basic IEventContent but adds additional functionality from IStandardContent.

IStandardEventContentData

The IEventContentData for the IStandardEventContent.

IStandardEventContentDataAsset<TData>

The IEventContentDataAsset<TData> that contains the IStandardEventContentData.

IStartup

This class should handle starting the game. It also provides some access to IContent related data to use when determining what IContent to load.

IStoreEntity

An IStoreEntity is an IEntity that can be purchased from the store. IStoreEntitys are loaded by the IStoreService.

IStoreEntityData

Contains the IEntityData associated with a certain IStoreEntity.

IStoreReward

A specific IStoreEntity that grants an IReward to the player when it is purchased using virtual currency in the Store.

IStoreRewardData

Contains the IEntityData associated with a certain IStoreReward.

IStoreRewardDataAsset<TData>

The asset that contains the IStoreRewardData

IStoreService

This IService handles the loading of IEntitys in the Store and provides convenient ways to fetch these entities by type.

IStoreTimedReward

An IReward that the player can claim periodically within the store.

IStoreTimedRewardData

The IEntityData associated with the IStoreTimedReward.

IStoreTimedRewardSavedData

The ISavedData associated with the IStoreTimedReward

IStoreUpgradeableCurrencyCollection

An IStoreEntity that provides a collection of Available and Obtained IUpgradeableCurrencys that the player can purchase using ICurrency in the Store. The IStoreUpgradeableCurrencyCollection is defined per IStage and regularly refreshes after a specified duration.

IStoreUpgradeableCurrencyCollectionData

Contains the IEntityData associated with a certain IStoreUpgradeableCurrencyCollection.

IStoreUpgradeableCurrencyCollectionDataAsset<TData>

The asset that contains the IStoreUpgradeableCurrencyCollectionData

IStoreUpgradeableCurrencyCollectionSavedData

Saved data associated with a given IStoreUpgradeableCurrencyCollection

ITagConsumerData

A utility interface that can be used by the IEntityData of any Entity which looks up other IEntity by Tag Id.

ITagData

ITagDatas are used to give an object a qualifier to be compared to. See TagDatas.

ITagDataAsset<TData>

The asset that contains the ITagData

ITaggedEntity

An IEntity that contains TagDatas information, that will be used when an another IEntity attempts any ITagData targeting logic.

ITaggedEntityData

An interface that specifies that the IEntityData must contain a list of TagIds referring to certain ITagDatas.

ITagRewardData

A IReward that uses ITagConsumerData to filter the potential ICurrencys it can grant.

ITagService

A centralized IService that deals with all ITagData related logic.

ITimedActivatable

A controller that has timer functionality to activate and deactivate an IActivatable.

ITimedActivatableData

Contains the data associated with a certain ITimedActivatable.

ITimedActivatableDataAsset<TData>

The asset that contains the ITimedActivatableData.

ITimedActivatableSavedData

Contains the ISavedData associated with a certain ITimedActivatable.

ITimedBoost

A class that provides IModifier functionality that doesn't need to be tied to a specific entity and is, instead, its own entity. Activation and deactivation of the IModifier is controlled via a subscription to the ITimerService.

ITimedBoostData

Contains the data associated with a certain ITimedBoost, which includes the data associated with the extended IModifier

ITimedBoostDataAsset<TData>

The asset that contains the ITimedBoostData

ITimedBoostSavedData

Saved data associated with a given ITimedBoost

ITimedTrack

An ITimedActivatable whose Activatable is an ITrack.

ITimedTrackData

The data associated with a ITimedTrack.

ITimedTrackDataAsset<TData>

The asset that contains the ITimedTrackData

ITimedTrackSavedData

The ISavedData associated with the ITimedTrack

ITimerListener

A class that is able to receive updates and event callbacks from the ITimerService. This class wraps an ITimerSubscription that contains subscription information.

ITimerService

ITimerService manages the Subscribe(ITimerListener) and Unsubscribe(ITimerListener) of ITimerListeners and notify them when time updates or timed events happen.

ITimerSubscription

This interface contains all the timer subscription information necessary for an ITimerListener to be used inside the ITimerService. It is intentional that only Duration and StartTimestamp as the other time related getters just calculate of those values.

ITimeSkipReward

ITimeSkipReward is an IReward that grants the player their projected amount of ICurrency earnings based on the Duration specified. ITimeSkipRewards can only be claimed if there are IPayoutProjections, i.e. automated IGeneratorEntitys.

ITimeSkipRewardData

The data associated with a ITimeSkipReward.

IToken

ITrack

An ITrack contains a list of IActivatables. A player progresses through the ITrack by completing the individual IActivatables sequentially. See Activatables.

ITrackData

Contains the IEntityData associated with a certain ITrack.

ITrackDataAsset<TData>

The asset that contains the ITrackData.

ITrackSavedData

Contains the ISavedData associated with a certain ITrack.

ITrackService

This IService helps with loading and retrieving ITracks.

ITrade

ITrades provide functionality allowing a player to exchange one ICurrency for another. The input and output ICurrencys that make up a ITrade are specified via tag Ids held in the ITradeData. This allows for multiple input and output ICurrencys to be specified on each ITrade. For example, a ITrade could be authored to exchange any ICurrencys tagged with both "Common" and "Generator" for a certain amount of "Soft" ICurrency.

ITradeData

Contains the IEntityData associated with a certain ITrade.

ITradeDataAsset<TData>

The asset that contains the ITradeData

ITradeService

ITrigger

A condition for an IPromo to be triggered by.

ITriggerData

Contains the IEntityData associated with a certain ITrigger.

ITriggerDataAsset<TData>

The asset that contains the ITriggerData

IUnlockable

Marks an IEntity as an IUnlockable so that the entity can be disabled during some in-game functions, such as a ICurrency that cannot be granted until it is Available or forcefully Obtained through a tutorial.

IUnlockableSavedData

Defines additional fields for a ISavedData that is associated with an IEntity that implements IUnlockable

IUpgradeable

This interface can be implemented by Entities that can be upgraded. An Upgradeable Entity will have to track an upgrade level which can be used to retrieve relevant data. In IdleKit, IUpgradeables are generally also IModifiers, tying UpgradeLevel progression to the ModifierDataIndex progression.

IUpgradeableCurrency

A more complex currency that can be upgraded and modify other Entities based on its upgrade level.

IUpgradeableCurrencyData

Contains the data associated with an IUpgradeableCurrency

IUpgradeableCurrencyDataAsset<TData>

The asset that contains the IUpgradeableCurrencyData

IUpgradeableCurrencySavedData

Saved data for IUpgradeableCurrency

IUpgradeableData

Contains the data associated to an Upgradeable Entity IUpgradeable

IUpgradeableSavedData

Saved data for IUpgradeable

IUpgradeLevelData

Contains an array of IUpgradeRequirements. Used by IUpgradeables to decide when an upgrade is available.

IUpgradeRequirement

Defines a cost required to upgrade an IUpgradeable Entity such as a ICurrency or IUpgradeableCurrency

IUserSavedData

ISavedData for the Player/User not related to any IEntity. This can be used to store all player preference in the future.

IWaitToBuyState

While in this IGeneratorState the associated IGeneratorEntity can only be purchased by the player

IWaitToCollectState

While in this IGeneratorState the generated ICurrency created by associated IGeneratorEntity can be collected by the player

Enums

ModifierGroupOperation

NetworkConnectionStatus

PlotPointActionState

The potential states of an action

PlotPointLayer

Delegates

BaseActorDataSetHandler

FramePlayedHandler

FrameSetHandler

SequenceCompletedHandler

SequenceEndedHandler

SequenceLoadedHandler

SequenceQueuedHandler

SequenceStartedHandler