Namespace IdleKit.Core

Classes

ActionService

A basic implementation of IActionService that handles IAction and IStateAction. One can extend this class to perform IStateAction that requires asynchronous server-side validations.

ActionService.ListenerPriorityComparer

AddressableAssetReference<TAsset>

This implementation of IAssetService uses Unity's Addressable Assets as a backend. Assets are managed in the Addressable Asset Settings via the Addressables Editor Windows and this service loads and unloads them from there. Assets loaded with this service are injected the first time they are loaded if possible.

AppInformation

Returns information about the application. Extend this class to customize the provided information.

ApplyLoggingConfigPhase

This ILoadPhase will apply a ILoggingConfig to the Logging module.

It expects that the following methods have already been called: Initialize(IIKLogger, ILoggingConfig, IEnvironmentConfig) It also requires that the IDataService has been initialized.

AssemblyUtility

The methods in this class can be slow and could impact performance if used during runtime. It is recommended to avoid using this class at runtime.

AssetReferenceMissingKeyException

AssetsInvalidReferenceException

AssetsLogging

AssetsMissingComponentException

AssetsMissingKeyException

AssetsNotLoadedException

AssetsNotSupportedException

AssetsNullAssetException

AsyncHelper

This class should be used for code that needs to run over multiple frames.

AsyncHelper.CoroutineRunner

AsyncLogging

AsyncOperationKeyInUseException

BindDataPhase

Binding

An implementation of IBinding

BindingException

An exception that is fired when IBinding conflicts are detected while they are being bound or resolved.

BindingService

An abstract class that has consolidated Bind<TContract>() and Unbind<TContract>() logic specific to IdleKit. When an object with an id is bound or unbound in IdleKit, bindings associated with all the object's parent classes and interfaces (except IInjectable and Object) using the same id would also be created.

CachedProvider

Provides an instance using the IProvider. Unlike the other IProvider, the CachedProvider keeps track of the WasCached so it does not get injected when GetInstance() is called again.

CleanupServicesPhase

ComponentAssetReference<T>

ComponentReference

ComponentReference<T>

Container

An implementation of the IResolver, IBinder, and IContainer

Context

A base implementation of the IContext. Override this class to provide your own Container and Installer.

CoreConstants

CoreExtensions

CoreFilesystemException

CoreInstaller

CoreNotSupportedException

DataLogging

DataService

This implementation of IDataService caches data under all Types possible. Once data has been added you can access it via any base or interface Types that also implement IData. This service does not handle any direct loading or unloading operations for data, however by passing a ISingleDataProvider<TOutputData> or IMultipleDataProvider<TOutputData> you can have the provider load the data asynchronously when this attempts to retrieve it.

DataStoreLogging

DataStoreMissingKeyException

DataStoreMissingValueException

DataStoreNullKeyException

DefaultLogger

EnvironmentAssetReference

EnvironmentConfig

EnvironmentConfigAsset

GuidReferenceableAttribute

Attribute that associates EntityData with its respective EntityDataAsset. For example: between ICurrencyData and its counter part CurrencyDataAsset below. In addition, this also helps to locate the EntityData from another EntityDataAsset.

GuidReferenceAttribute

Attribute that links a type to an identifier. It is used by the GuidReferenceHelper to link data together without using a hard reference. It should be used on string fields that represent the datas id. Ultimately, this id is later used by the IDataService to look up the data.

InitializeAddressablesPhase

InitializeServicesPhase

InjectGameObjectsPhase

Injector

An implementation of IInjector

Installer

A base implementation of the interface IInstaller. Override this class to create your own implementation of the IInstaller.

InstanceProvider

Provides an instance using the _object injected in the constructor.

InvalidDataException

InvalidSequenceableException

InvalidSequenceStateException

InvalidServiceException

ListenerPriority

Predefined constants to set as priority in IActionService.

The higher the priority the earlier the listener will be called when an IAction from the IActionService is dispatched.

LoadAssetReferencesPhase

This ILoadPhase will call LoadAssetReferences<TAsset>(IEnumerable<IAssetReference<TAsset>>, Action<List<TAsset>>) with the provided asset key. Once the assets have been loaded, an optional callback with a list of the loaded assets will be broadcast. This phase is only required if you are using an implementation of IAssetService that requires loading. It can be a nice way to manage preloading assets so they can be synchronously accessed later.

LoadAssetsPhase

This ILoadPhase will call LoadAssets(String, Action<List<Object>>) with the provided asset key. Once the assets have been loaded, an optional callback with a list of the loaded assets will be broadcast. This phase is only required if you are using an implementation of IAssetService that requires loading. It can be a nice way to manage preloading assets so they can be synchronously accessed later.

LoadDataPhase

This ILoadPhase will retrieve data from the IAssetService and add it to the IDataService. It supports IMultipleDataProvider<TOutputData>, ISingleDataProvider<TOutputData> and IData assets.

Loader

LoadingLogging

LoadPhaseBase

It is recommended to avoid using Inject(IResolver) to resolve dependencies in ILoadPhase objects and instead resolve dependencies when the phase is started using the cached IResolver. This can avoid issues where the dependency in question has not been bound to the container when the ILoadPhase is created.

LogCategory

LoggingConfig

LoggingConfigAsset

LoggingConfigAssetReference

LoggingEnvironmentConfig

LoggingEnvironmentConfigAsset

LoggingEnvironmentConfigAssetReference

LoggingMissingReferenceException

LoggingUninitializedException

Logs

The IdleKit logging class. Use this to output log messages and handle exceptions. It is configurable per IEnvironmentConfig by creating ILoggingEnvironmentConfig objects.

MethodProvider

Provides an instance using the _funcProvider method injected in the constructor.

MonoContext

An implementation of the IContext based on MonoBehaviour. This should be attached to a GameObject that has the _installer linked via the Unity inspector.

MonoInstaller

A MonoBehaviour based implementation of the interface IInstaller. Override this class to create your own MonoBehaviour based IInstaller. This should be linked via the Unity inspector for MonoContext.

ParallelLoadPhaseCollection

ParallelSequenceableCollectionBase<TSequenceable>

PlayerPrefsDataStoreService

PlayerPrefsDataStoreService.DataWrapper<TValue>

PrefabAssetReference

PrefabReference

ReadOnlyAttribute

This attribute allows a serialized field to appear in the Unity Inspector while not being editable.

ReflectionUtility

RemoveDataPhase

RemoveDataProvidersPhase

ScriptableObjectAssetReference<TAsset>

ScriptableObjectBaseData<TInterface, TConcrete>

Extend this class to reduce the amount of boilerplate required for a ScriptableObject based IDataProvider. This version is meant to contain a single IData object. See ScriptableObjectBaseDataCollection<TInterface, TConcrete> for a version that uses IMultipleDataProvider<TOutputData>.

ScriptableObjectBaseDataCollection<TInterface, TConcrete>

Extend this class to reduce the amount of boilerplate required for a ScriptableObject based IDataProvider. This version is meant to contain multiple IData objects. See ScriptableObjectBaseData<TInterface, TConcrete> for a version that uses ISingleDataProvider<TOutputData>.

ScriptableObjectReference<T>

SequenceableBase

SequencerBase<TSequenceable>

SequencesLogging

SerializableDictionary<K, V>

A serializable form of a Dictionary.

SerializedType

A class that converts a Type into a serializable object.

ServiceBase

ServiceUtility

StaticDataAddedAction

Sent when new data is added to the IDataService

StaticDataRemovedAction

Sent when static data is removed from IDataService

StripFromStackTraceAttribute

Will remove any method with this attribute from a custom stack trace.

TaskExtensions

TimeUtility

ToggleableFloat

A float that can have various behaviours applied when its value is set.

ToggleableSetting

An object that can optionally apply various behaviour to its value when changed. We have included various implementations of this. For example: ToggleableTransformFloat is a float that can be set to override, add or multiply when the value is changed.

ToggleableSetting<T>

A base class for ToggleableSetting<T> objects.

ToggleableTransformFloat

A float that can have various behaviours applied when its value is set.

ToggleableTransformVector2

A Vector2 that can have various behaviours applied when its value is set.

ToggleableTransformVector3

A Vector3 that can have various behaviours applied when its value is set.

ToggleableVector2

A Vector2 that can have various behaviours applied when its value is set.

ToggleableVector3

A Vector3 that can have various behaviours applied when its value is set.

TransformFloat

A float that can have various behaviours applied when its value is set.

TransformSetting

TransformSetting<T>

Base class for objects that will have behaviour defined by TransformBehaviour.

TransformVector2

A Vector2 that can have various behaviours applied when its value is set.

TransformVector3

A Vector3 that can have various behaviours applied when its value is set.

TransientProvider

Provides an instance using the Type injected in the constructor and Activator to create a new instance every time.

TypeConstraintAttribute

Constrains a property to a range of Types.

TypedResolver<T>

UnityAction

UnityEventListener

An Unity MonoBehaviour implementation of the IUnityEventListener

UnityFixedUpdatedAction

UnityLateUpdatedAction

UnityPausedAction

UnityTerminatedAction

UnityUpdatedAction

UnloadAssetReferencesPhase

This ILoadPhase will call UnloadAssets(String) with the provided asset key. Once the assets have been loaded, an optional callback with a list of the loaded assets will be broadcast. This phase is only required if you are using an implementation of IAssetService that requires loading. It can be a nice way to manage preloading assets so they can be synchronously accessed later.

UnloadAssetsPhase

This ILoadPhase will call UnloadAssets(String) with the provided asset key. This phase is only required if you are using an implementation of IAssetService that requires loading / unloading.

UnsupportedSequenceStateException

VectorUtility

Structs

AsyncHelper.CoroutineData

BindIndex

Provides the index that can be used to lookup the IBinding in Container. This is based on a Type and id Object.

LogEntry

Contains a single log entry and config regarding the entry.

SerializableDateTime

A serializable version of DateTime.

Interfaces

IAction

An IAction in IdleKit contains the following properties:

an IAction does not alter saved data, use an IStateAction if saved data is going to be altered
an IAction perform no direct operations
an IAction can contain optional parameters such as the caller
an IAction is only dispatched once, and is fire and forget

Any object can fire and receive any IAction as long as they Subscribe<T>(Action<T>, Int32) to it.

Any IActions that affect the player's persistent data directly should instead be an IStateAction. This is to allow for the possibility of sending the calls to a remote server for validation.

IActionResolver

A specialized abstracted version of ITypedResolver<T> that only allows resolving of IAction granting limited accesses to the IContainer.

IActionService

An IService that defines either an implementation for (un)subscribing listeners, and dispatching of IActions.

IAppInformation

A collection of common application details.

IAssetReference<TAsset>

An Asset Reference is meant to be used like a "load on demand" container for an asset. It should allow for easy asset assignment and loading / unloading. The referenced asset should not be loaded into memory until the load methods are used.

IAssetService

This service is used to load and unload assets. These assets can be anything from basic objects to prefabs and ScriptableObject data. Assets are stored under a provided key. This key can be passed through the various methods to help identify what assets to work with.

IAuthenticator

This authenticator is used to sign a collection of data with a secret key and return that data in string form. Web requests will be the main user of authenticators.

IBinder

Allows the creation and deletion of IBinding which is a mapping contract that contains optional information between a Type and a provider IProvider of a dependency denoted by the Type.

IBinding

IBinding allows mapping of a contract type ContractType to an IProvider that provides the dependency for the type. It contains extra information that enables the IResolver to locate the correct IBinding and IProvider. IBinding also contains convenient methods that allow us to chain method calls.

    container.Bind<IEventService>().To<EventService>().AsSingle().Conclude();

ICompletable

An interface used to indicate completion of such operation.

IContainer

The combination of IResolver and IBinder and this should only be used in an IContext. Most of the time classes that require the dependency should only be using an IResolver to resolve the dependency. This is following the principle of Interface Segregation.

IContext

The IContext class hosts the dependency IContainer and the blueprints of most of the dependencies to its contract types. It uses the IInstaller during Bind() and Unbind() to setup and teardown the dependency graph in the IContainer.

IData

The most basic requirements of serialized data in IdleKit which are later loaded by the IDataService.

IDataProvider

Wraps one or more data objects and allows access to them. Useful for separating data from ScriptableObjects for unit tests. This is meant to act as a base interface for more derived interfaces that work with data in various ways.

IDataService

This service caches IData objects and provides access to them. Data can be added to or removed from it as simple IData objects or as IDataProvider objects. A Type is passed as an argument or generic parameter to allow for implementations to manage their cache with it.

IDataStoreService

This service is meant to act as a simple key/value store. Using this service makes it easy to store information for other objects to look up. Depending on the implementation, this information could be serialized or not.

dataStoreService.Set("foo", "bar"); dataStoreService.Get("foo") = "bar" dataStoreService.Get("foo", "default") = "bar" dataStoreService.Get("invalid", "default") = "default"

IEnvironmentConfig

A wrapper for development environment data. This is used by services to separate config between different environments. This allows you to have one configuration on a dev environment and another in production. See ILoggingEnvironmentConfig for an example of this.

IGuidReferenceableAsset

The based interface for all IData related data assets. This is only used when we do not (need to) specify the type of the IData in the editor code.

IGuidReferenceableAsset<TData>

The interface implemented by all IDatas data assets. This interface that marks a ScriptableObject (or other serialized type) as a holder of IData. The concrete implementation must contain a GuidReferenceableAttribute if you wish to use the Unity asset GuidReference tool in IdleKit.

IIKLogger

Handles all of IdleKits logging and exceptions.

IInjectable

The IInjectable interface enable a class to have its dependencies injected by the IInjector in the form of an IResolver.

IInjector

The IInjector injects the dependencies into the object.

IInstaller

An IInstaller is used by the IContext to Install(IContainer) and Uninstall(IContainer) the IBinding to the IContainer.

ILoader

A ILoader is used to load content over time. This content is broken up into a collection of ILoadPhase objects. These get queued and loaded in the foreground or background.

ILoadPhase

A ISequenceable object meant to be used with a ILoader to handle loading content over time.

ILogCategory

Used to separate logging into groups that can be customized or toggled.

ILoggingConfig

A collection of ILoggingEnvironmentConfig objects, and a means of getting one relevant to the IEnvironmentConfig you are using.

ILoggingEnvironmentConfig

Logging configuration for a specific IEnvironmentConfig.

IMultipleDataProvider<TOutputData>

This interface should be used to provide access to a set of IData objects.

IParallelSequenceCollection<TSequenceable>

This is meant to be used to run multiple ISequenceable objects in parallel.

IProgressable

An interface used to indicate progress of operation.

IProgressCompletable

An interface used to indicate progress of operation and completion of such operation.

IProvider

IProvider provides an instance for the IBinding that contains this IProvider.

IResolver

An IResolver enables the dependency to be resolved based on the contract type and an optional id. This interface should not be cached in any object unless its a service level object.

ISequenceable

A ISequenceable object is run in a queue by a ISequencer<TSequenceable>. These objects can be run sequentially or in parallel with other ISequenceable objects.

ISequencer<TSequenceable>

An ISequencer<TSequenceable> queues and runs a collection of ISequenceable objects. These objects can be run sequentially or in parallel as the queue is processed.

IService

All IdleKit Services implement this interface. A Service handles logic involving different components or externally communication with non-IdleKit domains.

ISingleDataProvider<TOutputData>

This interface should be used to provide access to a single IData object.

IStateAction

An IStateAction is an IAction with the following rules:

signifies the intent to alter save data for a user
processes that do not lead to save data changes should not be in this class
Apply() may involve different IServices and objects
is dispatched as an IAction after performing Apply()

ITypedResolver<T>

A specialized interface version of IResolver that only allows resolving of T granting limited accesses to the IContainer.

IUnityEventListener

An interface that handles receiving platform or game engine specific events that do not originate from the IdleKit such as the Update(), FixedUpdate(), and ApplicationPause() events from the Unity engine.

The "events" mentioned here should not to be mistaken with IdleKit's IAction) and do not use the IActionService as this is an external facing class.