sts2

Releases the cached TextParagraph to free text server RIDs at exit. Uses Dispose() (not Free()) because TextParagraph is RefCounted. Nulled to guard against AdjustFontSize running during Godot's quit frames.

Unfortunately, there's no way to override the setting of text for a Label. So if you want the text size to automatically adjust after being updated during gameplay, you must use this method instead of setting the Text property directly.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'DisposeCachedParagraph' method.

Cached name for the '_Ready' method.

Cached name for the 'RefreshFont' method.

Cached name for the '_Notification' method.

Cached name for the 'SetTextAutoSize' method.

Cached name for the 'SetFontSize' method.

Cached name for the 'AdjustFontSize' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'AutoSizeEnabled' property.

Cached name for the 'MinFontSize' property.

Cached name for the 'MaxFontSize' property.

Cached name for the '_autoSizeEnabled' field.

Cached name for the '_minFontSize' field.

Cached name for the '_maxFontSize' field.

Cached name for the '_lastSetSize' field.

Cached name for the '_lastAdjustedSize' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This is the result of a very long investigation into what I believe is ultimately a Godot bug. Here's an explanation of the issue for future reference. MegaLabel uses TextParagraph to auto-size. In order to use this method, MegaLabel must grab the current font whenever it auto-sizes. Auto-sizing happens in response to many different events, including when the game is quitting (this is caused by how Godot works, it's not intentional). When we're auto-sizing in response to quitting and we try to grab the current font, if we have no font override (meaning the font is just defined in the theme, or nowhere at all), the game beach-balls on macOS. If we do have a font override (even if it's the exact same font as in the theme), it works perfectly. This feels to me like either a reference counting bug, or an issue with the resource serialization lifecycle timing. I believe we can fix it with an engine patch, and once we do, we can remove this check. In the meantime though, this will keep us from creating a MegaLabel without a font override.

This does a crude parsing of BBcode tags and text into a format usable by the EstimateTextSize function. The version of EsimateTextSize that takes a string can be used with RichTextLabel.GetParsedText. However, this will strip images and ignore their size, which is problematic when we are using energy icons in text. If EstimateTextSize is called multiple times, call this only once to minimize performance impact. Note that the return value of this is cached! We only expect this to be called once, for the results to be used, and then for it to be called again.

String with bbcode tags. The parsed tags and text from the bbcode string.

Estimates the size of some text with bbcode in it.

Cached paragraph object that can be reused through multiple calls to this function. The parsed bbcode text obtained from ParseBbcode. The font to use. The font size to use. The maximum width of a line before wrapping. The spacing between lines. Estimated size of the text.

Checks if some text with bbcode in it is too big for the passed size.

Cached paragraph object that can be reused through multiple calls to this function. The parsed bbcode text obtained from ParseBbcode. The font to use. The font size to use. The spacing between lines. The size to check against. If false, allows the size to be greater than the X size of the rect. If false, allows the size to be greater than the Y size of the rect. Whether or not the text would overrun rectSize when rendered.

Estimates the size of some text. Should be called only on text with no bbcode in it.

Cached paragraph object that can be reused through multiple calls to this function. The text whose size will be estimated. The font to use. The font size to use. The maximum width of a line before wrapping. The spacing between lines. If true, line wrapping is accounted for. Estimated size of the text.

Checks if some text with no bbcode in it is too big for the passed size.

Cached paragraph object that can be reused through multiple calls to this function. The text whose size will be estimated. The font to use. The font size to use. The spacing between lines. The size to check against. Whether or not we allow the text to be wrapped. Whether or not the text would overrun rectSize when rendered.

Releases the cached TextParagraph to free text server RIDs at exit. Uses Dispose() (not Free()) because TextParagraph is RefCounted. Nulled to guard against AdjustFontSize running during Godot's quit frames.

Unfortunately, there's no way to override the setting of text for a Label. So if you want the text size to automatically adjust after being updated during gameplay, you must use this method instead of setting the Text property directly.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'DisposeCachedParagraph' method.

Cached name for the '_Ready' method.

Cached name for the 'RefreshFont' method.

Cached name for the '_Notification' method.

Cached name for the 'InstallEffectsIfNeeded' method.

Cached name for the 'HasEffect' method.

Cached name for the 'SetTextAutoSize' method.

Cached name for the 'AdjustFontSize' method.

Cached name for the 'SetFontSize' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'AutoSizeEnabled' property.

Cached name for the 'MinFontSize' property.

Cached name for the 'MaxFontSize' property.

Cached name for the 'IsVerticallyBound' property.

Cached name for the 'IsHorizontallyBound' property.

Cached name for the 'Text' property.

Cached name for the '_isAutoSizeEnabled' field.

Cached name for the '_minFontSize' field.

Cached name for the '_maxFontSize' field.

Cached name for the '_lastSetSize' field.

Cached name for the '_isVerticallyBound' field.

Cached name for the '_isHorizontallyBound' field.

Cached name for the '_needsResize' field.

Cached name for the '_effectsInstalled' field.

Cached name for the '_lastAdjustedSize' field.

Cached name for the '_isAutoSizing' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Central source of truth for Godot theme property names. These names are defined by Godot and must match exactly. Tests verify these constants are valid against the current Godot version. Using StringName for efficiency since Godot's theme methods take StringName parameters.

Theme property names for Label nodes.

Theme property names for RichTextLabel nodes. Note: RichTextLabel uses different names than Label (e.g., "line_separation" vs "line_spacing").

All font size property names for RichTextLabel. Used when setting all font sizes to the same value.

Theme property names for Control nodes (shared across many control types).

Theme property names for MarginContainer nodes.

Theme property names for HBoxContainer and VBoxContainer nodes.

Theme property names for FlowContainer nodes.

Theme property names for TextEdit nodes.

Theme property names for LineEdit nodes.

Is this a looping animation?

If this is a looping animation, has it already looped at least once?

Mark that this animation has looped at least once.

This class is responsible for preloading and caching assets. It solves a problem where we want to load whole groups of assets, but we also want to eliminate duplicate loads of the same asset. This class is thread-safe.

Gets the current count of missed cache assets (loaded outside preloading).

Gets the asset if it is cached, otherwise falls back to loading it.

Marks an asset as failed so that synchronous fallback loading does not re-attempt it. This prevents repeated native crashes in the Godot resource parser when files are missing or corrupted.

Clears and unloads all missed cache assets. Should be called at safe boundaries like returning to the main menu to prevent unbounded memory growth.

The paths of all the assets that need to be loaded. This starts out containing every asset that needs to be loaded, and then is gradually emptied as ResourceLoader loads assets.

The paths of all the assets that are in the middle of being loaded. Assets are dequeued from and enqueued here in .

The paths of all the assets that are finished loading. Assets are dequeued from and enqueued here in when ResourceLoader.LoadThreadedGetStatus finds that an asset has finished loading. Assets are dequeued from here and added to the cache in .

VFX scenes are loaded one at a time after other assets finish. Loading them concurrently causes "Another resource is loaded from path" errors because many VFX scenes share the same ext_resources (materials, textures) and Godot's threaded loader races on shared sub-resource loading.

Load VFX scenes one at a time via the async threaded loader. Many VFX scenes share ext_resources (e.g. canvas_item_material_additive_shared.tres is used by 162 scenes), and loading them concurrently causes Godot's threaded loader to race on shared sub-resource paths.

The asset sets tend to get really large so this class just holds the big statically defined sets so they don't clutter the PreloadManager class.

Minimal assets needed to display main menu immediately after logo animation. Does NOT include compendium screens, character select, or other submenus.

Manages texture atlases by parsing .tpsheet files and creating AtlasTextures on demand. Thread-safe via ConcurrentDictionary caching.

Atlases needed before main menu scene loads. Their .tres files are referenced by scene ext_resources and must be loaded before Godot's scene deserializer encounters them.

Loads all known atlases. Call during initialization.

Loads only atlases referenced by scene ext_resources. Must be called before any scenes load.

Loads a single atlas by parsing its .tpsheet file and loading PNG textures. Thread-safe: uses lock to prevent duplicate loading work.

Gets an AtlasTexture for the specified sprite, creating and caching it if needed.

Atlas name (e.g., "relic_atlas") Sprite name without extension (e.g., "anchor_small") The AtlasTexture, or null if not found

Checks if a sprite exists in the specified atlas.

Gets the number of sprites in a loaded atlas.

Checks if an atlas has been loaded.

Clears all loaded atlases and cached sprites. Useful for testing.

ResourceFormatLoader that intercepts .sprites/ paths and returns AtlasTextures from AtlasManager. Handles paths like: res://images/atlases/relic_atlas.sprites/anchor.tres

Parses a sprite path to extract atlas and sprite names. Example: res://images/atlases/relic_atlas.sprites/anchor.tres Returns: ("relic_atlas", "anchor")

Returns the fallback path for a sprite not found in the atlas. Different atlases have different fallback conventions.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_GetRecognizedExtensions' method.

Cached name for the '_HandlesType' method.

Cached name for the '_GetResourceType' method.

Cached name for the '_RecognizePath' method.

Cached name for the '_Exists' method.

Cached name for the '_Load' method.

Cached name for the '_GetDependencies' method.

Cached name for the 'IsSpritePath' method.

Cached name for the 'HasFallback' method.

Cached name for the 'LoadFallback' method.

Cached name for the 'GetFallbackPath' method.

Cached name for the 'GetRelicFallbackPath' method.

Cached name for the 'GetPowerFallbackPath' method.

Cached name for the 'GetCardFallbackPath' method.

Cached name for the 'GetPotionFallbackPath' method.

Cached name for the 'GetMissingTexture' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

This class manages the caching and preloading of assets for the game.

Set this to false to disable preloading of assets. This can speed up iteration times. Assets will still be unloaded when we think they are out of use.

This method loads only the logo animation. The logo animation will be unloaded as soon as LoadMainMenuAssets is called, which is what we want. The assets are loaded synchronously.

Loads only the essential assets needed to display the main menu. Call this while the logo animation is playing for faster main menu display.

Loads all common and main menu assets including compendium screens, character select, etc. Call this in background after main menu is displayed.

This method is only used when starting the game, it loads the main menu assets. Otherwise, we use the LoadCommonAndMainMenuAssets method.

This method is the magic for preloading assets. It unloads assets that are no longer needed and loads assets that are needed. It does this through a basic set subtraction algorithm to determine what assets are not needed and can be unloaded and what assets are needed and not yet loaded (this avoids loading assets that already exist in memory).

Root structure for TexturePacker .tpsheet files.

A single texture page in the atlas (multi-page atlases have multiple entries).

Individual sprite within a texture page.

Audio manager for use with temporary sound effects (hopefully they make it into FMOD someday).

Play a sound.

The name of the audio sample file in res://debug_audio to play. Include the file extension. The volume to play the sound at. 0 is muted, 2 is 2x the volume. The randomized pitch variance with which to play the sound. An integer ID. If this is a one-shot sound, then the value can be ignored. If the sound is looping, or you wish to stop the sound early, pass this value to Stop to stop the sound from playing.

Stops all currently playing sounds

Stops a sound.

The ID returned from the Play call of the sound you wish to stop. Amount of time that the sound will fade to zero before stopping.

Sets the volume of the master bus.

Volume from 0-1.

Sets the volume of the SFX bus.

Volume from 0-1.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Play' method.

Cached name for the 'StopAll' method.

Cached name for the 'Stop' method.

Cached name for the 'StopInternalById' method.

Cached name for the 'StopInternal' method.

Cached name for the 'SetMasterAudioVolume' method.

Cached name for the 'SetSfxAudioVolume' method.

Cached name for the 'PlayerFinished' method.

Cached name for the 'GetRandomPitchScale' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_nextId' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Set of FMOD sfx that are used more globally (vs being tied to a specific creature of vfx). Any Temporary Sfx or Sfx not using FMOD should be put into TmpSfx.cs

Configuration constants for AutoSlay timeouts and settings.

Maximum time for a complete run.

Default timeout for room handlers.

Default timeout for screen handlers.

Timeout for waiting for game instance to initialize.

Timeout for waiting for run state to initialize.

Timeout for waiting for nodes to appear.

Timeout for waiting for map screen.

Polling interval for condition checks.

Delay between button interactions.

Maximum floor to play to (floor 49 is the final boss).

Watchdog timeout. If no progress for this long, dump state and fail.

Interval for periodic state logging when stuck detection is active.

Main orchestrator for AutoSlay. Runs the game automatically for smoke testing.

Static flag indicating if AutoSlay is currently running.

Gets the current watchdog instance (for WaitHelper integration).

Starts an AutoSlay run with the given seed.

Stops the current AutoSlay run.

Gets the current overlay screen cast to the expected type.

Structured logging for AutoSlay with consistent prefixes for easy filtering. Writes to both the standard Godot log and a dedicated autoslay.log file.

Opens the log file for writing. Call at start of autoslay run.

Closes the log file. Call at end of autoslay run.

Exception thrown when AutoSlay times out waiting for a condition or progress. Filtered from Sentry since these are expected during automated testing.

Base interface for all AutoSlay handlers.

Timeout for this handler.

Executes the handler logic.

Handler for a specific room type.

The room types this handler can handle.

Handler for a specific overlay screen type.

The screen type this handler can handle.

Handles combat rooms (Monster, Elite, Boss). Applies massive defensive buffs and plays all cards each turn.

Handles event rooms by selecting random choices. Some events trigger combat mid-event (e.g., DenseVegetation's "Rest" option). This handler detects and handles those combats before returning to the event.

Waits for event options to become available.

True if the event was fully handled (custom events), false if options loop should run.

Handles the FakeMerchant custom event. This event uses NProceedButton instead of NEventOptionButton. We simply click the proceed button to leave.

Handles Ancient events which require clicking through dialogue before options appear.

Handles rest site rooms by selecting a random rest option.

Handles shop rooms by attempting to buy every affordable item.

Handles treasure rooms by opening the chest, picking relics, and proceeding.

Handles post-combat victory rooms where the proceed button is displayed.

Handles the card reward selection screen after combat.

Handles bundle card selection screens.

Handles in-combat card selection screens (e.g., from Attack Potion).

Handles relic selection screens (e.g., from Jewelry Box event).

Handles the Crystal Sphere minigame event screen. Uses divinations by clicking cells, then clicks proceed. Note: When divinations run out, a rewards screen opens automatically. The drain loop will handle that, then this handler runs again to click proceed.

Handles the deck card selection screen (removal, transform, etc). The screen has two confirm buttons: one for the main grid, and one in the preview container. When selecting exactly MaxSelect cards, the screen auto-shows the preview, so we need to click the preview confirm button, not the main one.

Handles the deck enchant selection screen.

Handles the deck transform selection screen.

Handles the deck upgrade selection screen.

Handles the game over screen (shown after victory or death). Clicks through the summary to return to main menu.

Handles map screen navigation between rooms.

Handles the rewards screen after combat.

Handles simple card selection screens. Some screens require multiple card selections and/or manual confirmation.

Handles automatic card selection during AutoSlay runs. Randomly selects cards when the game would normally show a selection UI.

Randomly selects cards from the available options based on the selector preferences.

Randomly selects a card reward from the available options.

UI interaction utilities for AutoSlay.

Clicks a clickable control by directly emitting the Released signal. This bypasses hover/focus/pause checks that can fail in headless/automated testing.

Finds all nodes of a specific type under a parent node recursively.

Finds the first node of a specific type under a parent node.

Async waiting utilities for AutoSlay.

Waits until a condition becomes true, with timeout. Also checks the watchdog periodically to detect stuck states.

Waits for a node to exist at the given path.

Dumps scene tree context when a wait times out, to help debug what's actually there.

Waits for a task to complete while periodically checking the watchdog.

Runs a task with a timeout, combining with an existing cancellation token.

Watchdog that detects when AutoSlay gets stuck and dumps diagnostic state.

Resets the watchdog timer. Call this whenever meaningful progress is made.

Checks if the watchdog has timed out. Call this periodically (e.g., in WaitHelper). Throws TimeoutException if no progress for too long.

Dumps the current game state for debugging.

Captures memory and resource snapshots during AutoSlay runs, logging deltas from a baseline to detect memory/resource leaks.

C# bindings for SpineAnimation.

C# bindings for SpineAnimationState.

Returns the name of the animation currently playing on the given track, or null if no track is active. Value-only so no transient wrapper escapes; the native reads are kept GC-safe by the GC.KeepAlive in MegaSpineBinding.Call (PRG-6985).

Returns the duration of the animation currently playing on the given track, or null if no track is active. See .

C# bindings for SpineBone.

C# bindings for SpineBoneData.

C# bindings for SpineEvent.

C# bindings for SpineEventData.

C# bindings for SpineSkeleton.

C# bindings for SpineSkeletonDataResource.

Whether this skeleton defines an animation with the given name. Returns a bool rather than the animation so no transient wrapper escapes to callers, which would invite the GC-unsafe chain this binding is hardened against (PRG-6985).

Names of every animation this skeleton defines. Returns the names rather than the wrappers so no transient escapes to callers, keeping the GC-unsafe read chain unrepresentable through this API (PRG-6985).

C# bindings for SpineSkin.

C# bindings for SpineSlotNode.

Base class for C# Spine bindings.

Lifetime gotcha for any wrapper around a native-created RefCounted, not just Spine: while the managed wrapper is the sole owner, Godot gives it a weak GCHandle, so the GC can finalize it (freeing the native object) the moment no managed code will read it again, even mid-call into native. The classic trigger is an unrooted temporary in a chain like wrapper.GetX().GetName(): GetX() returns a fresh sole-owned wrapper, collectible while the native GetName() is still using its pointer. Use-after-free on the finalizer thread. The defense is the choke point in Call below, which keeps the receiver rooted via GC.KeepAlive across every native call routed through it, plus value-returning accessors so transient wrappers never escape. Keep that pattern in any new binding of this kind. See GC.KeepAlive (https://learn.microsoft.com/dotnet/api/system.gc.keepalive) and PRG-6985.

The Spine GodotObject that this binding wraps. ONLY USE THIS TO PASS TO OTHER SPINE API METHODS! If you want to call methods directly on this object, you probably want to add a method binding for the relevant MegaSpineBinding subclass instead.

The name of this class in the Spine API (https://en.esotericsoftware.com/spine-api-reference).

The methods from the Spine API (https://en.esotericsoftware.com/spine-api-reference) that this binding exposes.

The signals from the Spine API (https://en.esotericsoftware.com/spine-api-reference) that this binding exposes.

Connect to the specified signal on the bound Spine object.

Name of the signal to connect to. Callable to connect to the signal.

Disconnect from the specified signal on the bound Spine object.

Name of the signal to disconnect from. Callable to disconnect from the signal.

Call the specified method on the bound Spine object

Name of method to call. Arguments to pass to the method. Value returned by the bound Spine object, cast to the expected type.

C# bindings for SpineSprite.

Helper method for the lazy

Returns the animation state, throwing a descriptive error if it does not exist yet. Prefer / in code that can run before the SpineSprite is ready (e.g. a child node's _Ready, which Godot runs before the parent SpineSprite has built its skeleton). Failing fast here turns the old opaque NullReferenceException (from driving a null-wrapped state) into a clear, actionable message.

Returns the animation state, or null if it has not been created yet. The skeleton (and with it the animation state) may not exist when this is called before the SpineSprite has finished initializing, which happens when a child node's _Ready() runs first: Godot invokes _Ready() bottom-up (children before parents). Prefer this over in code that can run during that window, since GetAnimationState() would wrap a null object and throw on first use.

True once the SpineSprite has finished initializing and it is safe to drive its animations. This gates on the skeleton existing (get_skeleton returns null until the skeleton data has loaded, the same null-skeleton condition NCreatureVisuals checks to detect a failed load) and additionally confirms the animation state object we drive exists. It returns false during the window where a child node's _Ready() runs before the parent SpineSprite is ready, because Godot invokes _Ready() bottom-up and the skeleton loads asynchronously.

C# bindings for SpineTrackEntry.

Name of this entry's animation. Returns the value rather than the wrapper so no transient escapes; the native read is kept GC-safe by the GC.KeepAlive in MegaSpineBinding.Call (PRG-6985).

Duration of this entry's animation. See .

Null-safe wrapper for spine animation operations. No-ops when the underlying MegaSprite is null (e.g. when skeleton data failed to load). This eliminates the need for null-guards at every call site.

Name of the animation currently playing on the given track, or null if the sprite is null or no track is active. See MegaAnimationState.GetCurrentAnimationName (PRG-6985).

Duration of the animation currently playing on the given track, or null if the sprite is null or no track is active. See .

If non-null, then the default sort when displayed in the selector will use this comparer. Otherwise, cards will be displayed as ordered in the list. In most cases the order passed to the CardSelectCmd must be stable across machines. Therefore, we have to do any culture-variant sorts on the frontend only. This is currently only supported when using FromSimpleGrid.

If set, card previews displayed during the selection will be unaffected by any external powers or hooks. This includes enchantments and afflictions! Only applies to hand card selections.

If set, energy/star cost color highlighting will be suppressed for cards that wouldn't be able to be played due to insufficient energy/stars. Only applicable to hand card selection.

If set, cards that pass the predicate will glow gold. Only applicable to hand card selection.

Fired after combat is set up. Note that this happens a little bit before combat actually begins.

Fired when combat ends.

Fired when combat is won.

Fired whenever the arrangement of creatures in the combat changes. Specifically, when: * A creature is added. * A creature is removed. * A creature's position changes.

Fired whenever a new turn starts.

Fired whenever a turn ends.

Fired whenever a player ends their turn. Remember that, in multiplayer, this is not the same as switching to the enemy's turn.

Fired whenever a player un-does the end of their turn.

Fired when all players have fully committed to ending turn and all player actions are done (including end of turn hooks like Well-Laid Plans), but before the player hand flush.

Fired when the local player's actions become disabled or enabled.

True while is setting up the player turn but has not yet moved to the Play phase. Guarded by .

If a card ends the turn while is true (e.g. Void Form auto-played by Whispering Earring during the AutoPrePlay phase), the end-of-turn transition is stored in this field and run only once has caused us to move to the Play phase, so it never runs concurrently with the end of StartTurn (this would be a race condition, and could leave the turn-transition sequence stuck mid-way, never advancing to the next turn). A normal end-turn happens after the Play phase has started, so it is never deferred. Guarded by .

WARNING: ONLY USE THIS IN TESTS! See .

THIS IS TEMPORARY AND SHOULD ONLY BE USED IN TESTS

Set to true when the player should not be able to interact with their hand or any potions.

The list of players in the current turn that are taking an extra turn. Normally empty; only non-empty if there are players that used extra-turn-taking effects like . Returns a snapshot copy for thread safety.

Sets to the same value for all players.

True when the enemy turn has started (TurnStarted has fired for the enemy side). Set right before TurnStarted fires for enemy turns, cleared when switching to player turn.

Set to true in the time between when all players are ready to begin the enemy turn and when the enemy turn begins.

Set to true in the time during phase one of the end of the player's turn.

Is the combat currently in progress? True when the combat is done being initialized and has fully started. False when: * The combat is first being initialized. * The combat is ending (the last monster has been killed). * We're in a non-combat room.

Is a new combat currently being set up? True from the start of until flips true in . During this window is still false, so it lets callers distinguish "combat is starting" (where combat hooks that run during setup, like the initial deck shuffle, must still fire) from "combat is over or ending".

True while a or a effect body is currently executing for , including nested auto-plays (e.g. a Sly card auto-played when discarded). Used to avoid premature hand-empty triggers while that player's effect is mid-resolution.

Marks the start of a or effect body for , incrementing their effect-nesting depth. Must be paired with a in a finally block so the depth stays balanced even if the effect throws or the player dies mid-play.

Marks the end of a or effect body for , decrementing their effect-nesting depth (and removing the entry once it reaches zero). Pairs with ; call it from a finally block.

Is combat about to end due to player death? True when LoseCombat() has been called but the loss hasn't been processed yet. This allows effects to bail out early while still letting the current action complete.

Is the combat in the process of ending (but still in progress)? True when combat is in progress but all the enemies are dead, and there is nothing stopping combat from ending (e.g. Phrog Parasite spawning in new enemies). Also true when a pending loss is waiting to be processed. False when * Combat is in progress and 1+ primary enemies are still alive. * Combat is not in progress.

Has this combat ended (or is it in the process of ending)? When you want to skip/cancel an effect because combat is not in progress, you should usually use this instead of or !, because they can return unexpected results at certain boundary points.

Awaits the player's setup task, then runs the auto-pre-play hooks, transitioning the player's phase from -> -> . The setup await ensures a player whose setup is paused (making a ) stays in until their setup actually completes.

Sets up a player's turn by resetting energy, drawing cards, and firing start-of-turn hooks. If the player's turn start executes a player choice (e.g. Mayhem plays Cosmic Indifference), then the entire sequence is paused for this player. However, other players' turn start sequences may continue, and they may play cards while this is occuring.

The player whose turn to setup. The player choice context to pass to hooks that take it.

Called in EndPlayerTurnAction to indicate that the player is ready to execute end-of-turn events.

The player that readied up. In multiplayer, notes if the player is allowed to back out of ending their turn. Optional action to execute during the enemy turn. This is useful for tests.

Runs any end-of-turn transition that was deferred while the player turn was being set up (see ). Must be called on every exit path of the player-turn setup in so a deferred transition is never dropped.

Call this when the end turn button is pressed to disable local player actions until the start of the next turn. In multiplayer, this prevents the player from playing cards after they have ended turn. In both SP and MP, this prevents the player from playing cards before the AfterTurnStart hook has run. It's important that we do this when the end turn button is pressed, instead of when the EndTurnAction is processed, because the player might try to execute actions while the end turn action is waiting in the queue. This is a little fragile; if actions do slip through in MP, it has the potential to cause a state divergence. Revisit if needed - we might need to discard actions on the host side (which ends up being way more complicated).

Called in ReadyToBeginEnemyTurnAction to indicate that the player is ready to switch to the monster turn (or extra player turn, if necessary). Note that this is called automatically, and is not player-driven.

The player that is ready to switch sides. Optional action to execute during the enemy turn. This is useful for tests. True if the passed player has hit the end turn button, and the next player turn has not yet begun.

Called after both the Creature has been added to the room _and_ the NCreature is spawned.

Check for the player's hand to be empty and run the appropriate hooks if it is. We can't just do this check every time the hand size changes, because sometimes we're in the middle of a sequence of effects and we want to wait to check until they're all done. For example, if we have and the last card in our hand is and we play it, we have to wait to check hand size until Pommel Strike is done being played, otherwise we'll draw two cards (one when your hand becomes "empty" immediately after Pommel Strike moves to the Play pile, and another after Pommel Strike's draw command executes). So, instead of automatically doing this check every time the hand size changes, we manually check after a card is played, and after a potion is used, since these are the two ways a player can manually interact with combat state (besides ending turn, which should not trigger an empty hand check). If we ever add more ways, we should add this check in those too, and update this comment.

Object that keeps context of the action this is called from. Player whose hand we want to check.

Reset the combat manager to prepare for the next combat.

Usually true. Only pass false if we're exiting the game completely.

Marks combat as pending loss. The actual loss processing happens at the next safe point (in CheckWinCondition) to avoid race conditions where effects try to run after IsInProgress is false.

Processes a pending combat loss. Called from CheckWinCondition at safe points.

DO NOT CALL THIS unless you're in this class or ModelTest.

DO NOT CALL THIS unless you're in this class or ModelTest. This calls all end-of-turn hooks that could require player choices to be made.

Executes turn end hooks for a player. If player choice occurs during this method, it uses the passed choice context. This way, each player's turn end runs independently of all others.

DO NOT CALL THIS unless you're in this class or ModelTest. This does all the player state cleanup for the end of their turn. It must not call any hooks that might cause player choices to occur.

DO NOT CALL THIS unless you're in this class or ModelTest. This switches from the player side to the enemy side, handling extra player turns if necessary.

Optional action to execute during the enemy turn. This is useful for tests.

Pause combat.

Un-pause combat.

Returns true if the passed player is taking part in the current player turn. Returns false if some player is taking an extra turn, and it's not us. If it is not the player turn, then this returns false.

WARNING: ONLY CALL THIS IN TESTS! Force the specified card to be moved to the top of the next shuffle. Useful for tests for shuffle tests where the first card drawn afterwards matters.

Card to force to the top.

WARNING: ONLY CALL THIS IN TESTS! Clear the forced specified card to be moved to the top of the next shuffle. Useful for tests for shuffle tests where the first card drawn afterwards matters.

An object containing all of the state that represents the current combat. Some state details are derived from higher-level objects. For example: * All players in the combat state are derived by checking the Player property of all the creatures. * All cards in the combat state are derived by checking the combat piles of all those players.

The state of the run that this combat exists in. Will be in gameplay and in some test/debug scenarios.

Fired whenever the arrangement of creatures in the combat changes. Specifically, when: * A creature is added. * A creature is removed. * A creature's index changes.

This is the ID that will be assigned to the next spawned creature's CombatId field. If we receive an action targeting a creature with an ID less than this one, then it must either be in the creature list or it had died at some point in the past. If we receive an action targeting a creature with an ID greater than or equal to this one, then it has yet to spawn (or there is some other error).

Get all creatures on the Allies side.

Get all creatures on the Enemies side.

Get all creatures in the combat on all sides.

Get all the player creatures in the combat.

Get all players in the combat.

List of custom modifiers applied to this combat, usually via daily or custom runs.

List badge models, used when unlocking badges.

The model used to scale various things (block, power application) in multiplayer.

The round of combat that we're on in this combat. A "round" encompasses both the player's turn and the enemy's turn. This starts at 1, so it should never be 0.

The side that is active in this combat. A round starts with the player side being active, then switches to the enemy side after all players have ended their turn. When the enemy turn ends, the current side changes back to the player side, and the round number is incremented.

A list of creatures that escaped (were removed without dying) during the encounter. Used when rewards are given.

All cards that have been created within this state. This allows us to keep track of "floating" cards that have not been added to any piles (like fake cards in upgrade previews).

See .

See .

WARNING: If you're specifically intending to create a clone in combat for an effect like , you should use instead. See .

See .

Does this state contain the specified card?

Add a player's creature on the Allies side.

Creates a new creature from a monster in this combat state. After you create the creature, you should call AddCreature to add it to combat. This can be done immediately or after some time.

Attaches an existing creature to this combat state without adding it to the combat. This sets up the creature to be added to combat without actually putting it into the combat (i.e. it's not targeted by cards that hit all enemies, powers don't proc on it, etc). For players and almost all monsters, this is called just before adding their creature to the combat. Currently, the Doormaker is the only creature that doesn't get added to combat immediately after this is called.

Call this to remove a creature that escaped rather than dying.

Removes the creature from combat.

The creature that will be removed. If true, then the creature cannot be re-added to the combat state.

Get the creature with the specified combat ID. Null if not found.

Get the creature with the specified combat ID. If the creature doesn't exist, keep checking for a while before timing out and returning null.

Combat ID of the creature to get. How long to wait for the creature to appear. Specified Creature, or null if it doesn't exist and we've waited long enough.

Get all the creatures on the specified side.

Get all the creatures on the currently-active side.

Get all opponents of a creature.

Get all teammates of a creature, including the creature itself.

Get all hittable enemies. See for a definition. NOTE: We shouldn't add too many methods like this, this one is just extremely common because it's used for AOE and random attack targeting.

Get all the models that should have combat hooks called on them.

Adds a creature to the combat. This should almost always be called right after CreateCreature. Until this is called, creatures cannot be targeted and their powers will not be triggered. It is separate so that creatures can be removed from combat and re-added to it later. Currently, this is only used in the Doormaker combat.

The creature to add to the combat.

Fired whenever any part of the combat's state changes (card changes piles, power applied/removed, damage dealt, block gained/lost, etc.).

Notify the world that something in the combat state changed.

The name of the method that triggered this.

A history of most events that have happened in combat. Each entry should be logged immediately after the event occurs, but before its AfterX hook is executed. For example, a CardPlayedEntry is logged immediately after the card is played, but before AfterCardPlayed is executed.

Who performed this action? Even if this was a player-specific action (like drawing a card or gaining energy), this will be the player's creature. Null if the action was not performed by any creature, like when a player loses HP from Royal Poison.

What round was it when this action occurred? See and to understand the difference between the two.

Which side's turn was it when this action occurred? This will not always be the same as Actor.Side. For example, if you attack a monster with Thorns, the entry for the Thorns damage will have Actor.Side = Monster (since the monster is the one dealing damage back), but CurrentSide will be Player (since it's the player's turn).

The history object that this entry is in.

The turn numbers of all the players in combat when this action occurred.

Did this action happen during the current turn?

Did this action happen during the specified player's last turn?

The instance of the card play that finished.

Tracks if the card was Ethereal at the time it was played. This is a HACK in order to make work. If we end up with more WasX properties like this, we should add some sort of snapshot mechanism so that represents the state of the card at the time it was played.

The instance of the card play that started.

Tracks every time a creature receives damage.

The state of the run that this combat exists in. Will be in gameplay and in some test/debug scenarios.

Fired whenever the arrangement of creatures in the combat changes. Specifically, when: * A creature is added. * A creature is removed. * A creature's index changes.

Get all creatures on the Allies side.

Get all creatures on the Enemies side.

Get all creatures in the combat on all sides.

Get all the player creatures in the combat.

Get all players in the combat.

List of custom modifiers applied to this combat, usually via daily or custom runs.

The model used to scale various things (block, power application) in multiplayer.

BE CAREFUL! You usually want instead of this. The round of combat that we're on in this combat. A "round" encompasses both the player's turn (or turns if a player takes an extra turn) and the enemy's turn. This starts at 1, so it should never be 0.

The side that is active in this combat. A round starts with the player side being active, then switches to the enemy side after all players have ended their turn. When the enemy turn ends, the current side changes back to the player side, and the round number is incremented.

A list of creatures that escaped (were removed without dying) during the encounter. Used when rewards are given.

See .

See .

WARNING: If you're specifically intending to create a clone in combat for an effect like , you should use instead. See .

See .

Does this state contain the specified card?

Add a player's creature on the Allies side.

Creates a new creature from a monster in this combat state. After you create the creature, you should call AddCreature to add it to combat. This can be done immediately or after some time.

Call this to remove a creature that escaped rather than dying.

Removes the creature from combat.

The creature that will be removed. If true, then the creature cannot be re-added to the combat state.

Get the creature with the specified combat ID. Null if not found.

Get the creature with the specified combat ID. If the creature doesn't exist, keep checking for a while before timing out and returning null.

Combat ID of the creature to get. How long to wait for the creature to appear. Specified Creature, or null if it doesn't exist and we've waited long enough.

Get all the creatures on the specified side.

Get all the creatures on the currently-active side.

Get all opponents of a creature.

Get all teammates of a creature, including the creature itself.

Get all hittable enemies. See for a definition. NOTE: We shouldn't add too many methods like this, this one is just extremely common because it's used for AOE and random attack targeting.

Get all the models that should have combat hooks called on them.

Adds a creature to the combat. This should almost always be called right after CreateCreature. Until this is called, creatures cannot be targeted and their powers will not be triggered. It is separate so that creatures can be removed from combat and re-added to it later. Currently, this is only used in the Doormaker combat.

The creature to add to the combat.

Returns true if this represents a live combat. If this is false, then you should only trust that whatever object you retrieved this combat state from (like a Creature) exists, and not any other object, like other Creatures or the NCombatRoom.

Marks the phase of the player's turn in combat.

No phase. Used when combat is not in progress and during the enemy's turn.

The start of the turn. The player is in this phase from the moment combat switches over from the enemy's turn until the player is allowed to play cards. This encompasses many things, including: - Block clear - - Start-of-turn orb passive triggers - Energy reset - Hand draw

The phase of the turn where start-of-turn auto-play effects happen. This is when is called. Examples: - - -

The phase of the turn where the player is allowed to manually play cards and use potions. In this phase, hooks only happen in response to player actions.

The phase of the turn where end-of-turn auto-play effects happen. This is when is called. Examples: - -

The end of the turn. The player is in this phase from the moment all players have hit "end turn" and all queued cards have finished playing until combat switches over to the enemy's turn. This encompasses many things, including: - - End-of-turn orb passive triggers - Hand flush -

A "builder" command that allows you to chain method calls to build up the property of an attack. This pattern is very similar to how Godot Tweens are built up.

The creature performing this attack. It's safe to assume this is non-null once the attack is being executed.

The model that this attack comes from, such as an attack card.

The amount of damage that this attack will deal on each hit. This will be ignored if is set.

Dynamic var that calculates how much damage each hit does. Used for cards that do dynamic amounts of damage based on combat state, like . Settings this will cause to be ignored.

The number of hits this attack should do. The actual number of hits may be modified by hooks. If you need to check the final number of hits, check after the attack has been executed.

The source of this attack. Without this, we have to glean it from some combination of Attacker and ModelSource, which can get tricky in cases like Osty attacks.

Set for single target attacks. Is null for AOE attacks.

The creatures being targeted by this attack. For random attacks, this contains all possible targets, and for custom attacks using , this will be empty. After the attack has been executed, you can check to see which targets were actually hit.

The ValueProps of the damage that this attack deals.

Whether this attack is targeting a single creature.

Whether this attack is targeting multiple creatures.

Whether this attack is randomly targeted.

The resulting instances of damage from this attack. Each inner list is from an individual hit from this attack (so if we have a multi-attack, we have multiple lists) This will start out empty, and will be populated after finishes running.

fast, standard

Create a new attack command.

The amount of damage this attack should deal on each hit.

Create a new attack command

Dynamic var that calculates how much damage each hit does. Used for cards that do dynamic amounts of damage based on combat state, like .

Set the attack to come from the specified card. This also automatically sets the attacker as the card's owner, and the attacker animation name/delay to the card owner's defaults.

Card that the attack came from.

Set the attack to come from the specified monster.

Monster that the attack came from.

Set the attack to target the specified creature.

Creature for the attack to target.

Set the attack to target the opponents of the Attacker. Differs from TargetingAll because the list of targets is refreshed between every hit meaning that new creatures added to the combat will become valid targets

Combat state that we will be pulling the opponents from

Sets the attack to target random opponents of the attacker. A new random target will be chosen on each hit.

Combat state that we will be pulling the opponents from Whether the same target can be hit multiple times. In real gameplay, we pretty much always want this to be true, but we pass false sometimes for testing.

Set the attack to deal unpowered damage. WARNING: 99% of the time, when unpowered damage is dealt, it shouldn't be considered an attack (like via ). However, occasionally we want to do a real attack that skips powers (like ), so this is useful there.

Set the attack to play the specified animation on the attacker.

Name of the animation trigger. Amount of time to wait for the animation to complete before proceeding. Optional custom creature to visually display as the attacker in this animation. Good for attacks like where we want a pet to animate for the attack, even though the actual attack is coming from the attack's owner. If this is left null, the attack's owning creature will play the animation.

Logic to execute after the attacker animation plays. Good for one-offs. Note: If you find yourself calling this with the same logic in many different attacks, consider making a first-class builder method for the logic instead.

Set the attack to play the specified VFX/SFX on attacker.

File path of the VFX. File path of the SFX. Temporary SFX file path. If the attack uses temporary non-FMOD SFX, pass this instead of sfx using keyword args.

Set the attack to add the specified custom VFX node to the combat VFX container when the owner attacks.

Set a wait time before each hit and hit VFX/SFX. Uses the same wait time signature as .

Set the attack to play the specified VFX/SFX on the target(s) when they're hit.

File path of the VFX. File path of the SFX. Temporary SFX file path. If the attack uses temporary non-FMOD SFX, pass this instead of sfx using keyword args.

If this attack hits multiple creatures, this sets the hit VFX to spawn on each creature rather than on the side.

If there is a hit VFX set, this makes it spawn at the creature's base rather than its center.

Set the attack to add the specified custom VFX node to the combat VFX container when the target(s) are hit.

Set the attack to only play animations/VFX/SFX once, even on a multi-hit. Good for situations where a single bespoke attack animation illustrates multiple hits.

Set the number of hits this attack should do.

The number of times this attack should hit.

Logic to execute before each instance of damage is dealt. Good for one-offs. Note: If you find yourself calling this with the same logic in many different attacks, consider making a first-class builder method for the logic instead.

Creates an attack context for grouping multiple damage calls as a single attack. Use with `await using` to automatically call BeforeAttack and AfterAttack hooks.

The current combat state The context that is signalled in the event of a player choice. The card that is the source of this attack An AttackContext ready for use with await using

Execute this attack. If you forget to set some required values (like attacker or target), this will error.

The context that is signalled in the event of a player choice. If null, a is used. This should only be done when a monster is attacking.

NEVER CALL THIS FROM MODELS, only in system code where you know exactly what you're doing. Increment the number of hits this attack should do.

NEVER CALL THIS FROM MODELS, only in system code where you know exactly what you're doing. Add a set of DamageResults to the list of results for this attack.

A context for grouping multiple damage calls as a single attack for hook purposes. Use with C#'s `await using` statement to automatically call BeforeAttack and AfterAttack hooks.

Private constructor. Use to create instances.

Creates a new AttackContext and calls the BeforeAttack hook.

The current combat state The context that is signalled in the event of a player choice. The card that is the source of this attack An initialized AttackContext ready for use with await using

Add to the list of hits that have been done within the context of this attack.

DamageResults from the hit.

Disposes the context and calls the AfterAttack hook. This is automatically called when exiting an await using block.

Automatically play a card for free. Used for non-player-choice card playing effects.

Examples of where this would be used: * Havoc ("Play the top card of your Draw Pile and Exhaust it.") * Duplication Potion ("This turn, your next card is played twice.") The context that is signalled in the event of a player choice. Card to autoplay. Target for the autoplay. Will be randomized if null. Type of autoplay. Certain checks may be bypassed for different autoplay types. If true, skip capturing the X value for X-cost cards and X-star cost cards. Use this when the caller has already spent energy/stars via SpendResources, which sets CapturedXValue to the energy spent and stars spent. Skip card pile visuals (tween to/from pile, smoke puff VFX, etc).

Discard a card. WARNING: If you're discarding multiple cards at once for an effect like Concentrate or Gambler's Brew, do NOT use this method inside a loop, because the timing of the Sly effect will be incorrect. Instead, use the overload of this method that takes an IEnumerable.

The context that is signalled in the event of a player choice. Card to discard.

Discard multiple cards.

The context that is signalled in the event of a player choice. Cards to discard.

Discard cards, then draw cards. Unlike calling followed by , this will wait to trigger the discard-related hooks until after the draw is complete. Good for effects like .

The context that is signalled in the event of a player choice. Cards to discard. Number of cards to draw.

Downgrades a card to its base form. Keeps things like enchantments and conditions.

Card to downgrade.

Exhaust a card. Note: do NOT make a bulk version of this; the hooks for one exhausted card should fully run before the next card starts exhausting.

The context that is signalled in the event of a player choice. Card to exhaust. Was this Exhaust caused by Ethereal? This should always be false except the specific case in . Skip card pile visuals (tween to/from pile, smoke puff VFX, etc).

Upgrade a card. Use this for actually upgrading a card, not for previewing an upgrade, because it won't highlight value changes.

Card to upgrade. How the upgraded card is displayed to the player.

Upgrade a set of cards. Use this for actually upgrading cards, not for previewing upgrades, because it won't highlight value changes.

Cards to upgrade. How multiple cards are aligned if previewed together.

Transform a card to another randomly-selected card.

Card to transform from. RNG to use for random card. How the transformed card is displayed to the player. The replacement card.

Transform a card into a new card of the specified type.

Card to transform from. How the transformed card is displayed to the player. Card type to transform to. The replacement card.

Transform a card to another card.

Card to transform from. Card to transform to. How the transformed card is displayed to the player. The replacement card.

Comparer to sort a list of CardPile and card index in ascending card index order.

Transforms several cards to other cards.

Cards to transform. Random number generator to use when choosing from random options. How the transformed cards are displayed to the player. The replacement card.

Apply an Enchantment to a card.

Card to enchant. Amount of the enchantment to apply. Type of enchantment to apply. Enchantment that was applied, or null if it failed.

Apply an Enchantment to a card. Use this for actually enchanting a card, not for previewing an enchantment, because it won't highlight value changes.

Enchantment to apply. Card to enchant. Amount of the enchantment to apply. Enchantment that was applied, or null if it failed.

Clear a card's Enchantment if it has one.

Card whose enchantment we want to clear.

Apply Afflictions to cards and show it to the owning player if they are the local player.

Cards to afflict. Amount of the affliction to apply. The style of preview to use. Type of affliction to apply. Afflictions that were applied.

Apply an Affliction to a card.

Card to afflict. Amount of the affliction to apply. Type of affliction to apply. Affliction that was applied, or null if it failed.

Apply an Affliction to a card.

Affliction to apply. Card to afflict. Amount of the affliction to apply. Affliction that was applied, or null if it failed.

Clear a card's Affliction if it has one.

Card whose affliction we want to clear.

Apply keywords to a card.

Card to apply keyword too. keywords to apply.

Apply Sly to a card for the current turn only.

Card to apply single-turn Sly to.

Creates a set of NCards that spawn in the middle of the screen, then fly to the pile they're in. Useful for when you want to preview cards that are being added to a pile.

Card to preview. How long the card lingers before it goes off screen How multiple cards are aligned if previewed together.

Creates a set of NCards that spawn in the middle of the screen, then fly to the pile they're in. Useful for when you want to preview cards that are being added to a pile.

Cards to preview. How long the card lingers before it goes off screen How multiple cards are aligned if previewed together.

Remove a card from the deck and play an animation.

Card to remove. Whether to show a preview of the card being removed.

Remove cards from the deck and play an animation.

Cards to remove. Whether to show a preview of the card being removed.

Remove a card from combat and play an animation. This will remove the card from any combat pile () it's in, but not from the player's deck.

Card to remove. Skip card pile visuals (tween to/from pile, smoke puff VFX, etc).

Remove cards from combat and play an animation. This will remove the cards from any combat pile () they're in, but not from the player's deck.

Cards to remove. Skip card pile visuals (tween to/from pile, smoke puff VFX, etc).

Adds a new card into one of the combat piles. Card must have just been generated (ie shivs, infernal blade generation, attack potion). We do this, instead of a regular add, because this adds the generated card entry to the combat history.

Card to add. Type of pile to add the card to. Player that created this card if there is one Optional position in the pile to add the cards to. Defaults to bottom.

Adds a new card into one of the combat piles. Card must have just been generated (ie shivs, infernal blade generation, attack potion). We do this, instead of a regular add, because this adds the generated card entry to the combat history.

Cards to add. Type of pile to add the card to. Player that created this card if ther is one Optional position in the pile to add the cards to. Defaults to bottom.

Add a card to a pile.

Card to add. Type of pile to add the card to. Optional position in the pile to add the cards to. Defaults to bottom. The model that cloned this card, if applicable. Used to prevent copy effects from recursing. Skip card pile visuals (tween to/from pile, smoke puff VFX, etc).

Add a card to a pile.

Card to add. Pile to add the card to. Optional position in the pile to add the cards to. Defaults to bottom. The model that cloned this card, if applicable. Used to prevent copy effects from recursing. Skip card pile visuals (tween to/from pile, smoke puff VFX, etc).

Add multiple cards to a pile.

Cards to add. Type of pile to add the cards to. Optional position in the pile to add the cards to. Defaults to bottom. The model that cloned this card, if applicable. Used to prevent copy effects from recursing. Skip card pile visuals (tween to/from pile, smoke puff VFX, etc).

Add multiple cards to a pile.

Cards to add. Pile to add the cards to. Optional position in the pile to add the cards to. Defaults to bottom. The model that cloned this card, if applicable. Used to prevent copy effects from recursing. Skip card pile visuals (tween to/from pile, smoke puff VFX, etc).

Add a card to the play pile during manual card play. This is a highly simplified version of that makes a bunch of assumptions, and also that doesn't wait on its tweens. This makes most card plays feel more responsive. Autoplay from effects like don't use this, because they need to wait on their tweens.

Draw a card.

The context with which to handle player choices. Player who the hand and draw pile belongs to. Card that was drawn, or null if no cards were drawn.

Draw cards.

The context with which to handle player choices. Number of cards to draw. Player who the hand and draw pile belongs to. If this draw happened as part of the initial card draws at the start of your turn. Cards that were drawn.

Shuffle the player's discard pile into their draw pile.

The context that is signalled in the event of a player choice. Player whose piles we should shuffle.

Play cards directly from the draw pile. If the draw pile becomes empty before the specified number of cards are played, the discard pile will automatically be shuffled into it.

The context that is signalled in the event of a player choice. Player whose draw pile we should play from. Number of cards to play. Position to play the cards from. Whether or not to force the played cards to be exhausted after.

Shuffle the specified player's discard pile into their draw pile IF their draw pile is currently empty. If their draw pile has at least one card in it OR their discard pile is empty, this method will do nothing.

The first time the discard pile is shuffled into the draw pile, the Shuffle FTUE shows up

Clears all active selectors. Call this during run cleanup to prevent selectors leaked by stuck async tasks (e.g., WhisperingEarring mid-auto-play when a run ends) from affecting subsequent runs.

The currently active automated card selector. Used by tests, AutoSlay, and gameplay effects that auto-play cards (e.g., WhisperingEarring). When set, card selection UI is bypassed and cards are selected automatically. Returns the top of the stack, or null if empty.

Sets the automated card selector for the duration of the returned scope. Disposing the scope clears all selectors. Throws if a selector is already active (use PushSelector for stacking behavior).

Pushes a new selector onto the stack. When disposed, the previous selector is restored. Use this when you need temporary selector behavior (e.g., WhisperingEarring's auto-play).

TEST ONLY! Temporarily pops the top of the selector stack so tests can exercise the network-synchronized card-selection branches that are otherwise bypassed when a selector is active. Returns a no-op scope if the stack is already empty.

Used by to conform to the normal interface when there's no card selector.

Used by to temporarily suspend the current card selector so it can be restored later.

Reports a potential softlock to Sentry and logs an error. Called when a selection screen would have been shown with 0 options, which would leave the player stuck. The caller returns empty to gracefully recover, but the underlying cause is still a bug that should be investigated and fixed.

Begins card selection for the given player, selecting from a small list. Only works with a small number of cards (right now 3 or fewer). Good for in-combat card generator effects like Attack Potion. If the player is the local player, this brings up the card selection screen. If the player is a remote player, this waits for that player to select a card.

The context to signal when player choice has begun and ended. Cards to show. The player that is picking cards. Whether or not the card choice can be skipped. NOTE: If we add any more params like this, we should probably refactor it to use CardSelectorPrefs. The card that was selected.

Begins card selection for the given player, selecting from a grid. Intended for cards that the player will add to their deck. Supports flashing modifications of the card creation by relics over the card. If the player is the local player, this brings up the card selection screen. If the player is a remote player, this waits for that player to select a card.

The context to use when signalling player choice. Cards to show in the grid, including any modifications applied to those cards. The player that is picking cards. CardSelectorPrefs The selected cards.

Begins card selection for the given player, selecting from a grid. Good for selecting cards from potentially large lists (draw/discard pile, "any Ironclad card", etc.) without any extra bespoke UI (no upgrade/enchant previews, etc.). If the player is the local player, this brings up the card selection screen. If the player is a remote player, this waits for that player to select a card.

The context to use when signalling player choice. Cards to show in the grid. It is copied after passed. The player that is picking cards. CardSelectorPrefs The selected cards.

Select from the upgradable cards in the player's deck. Shows an upgrade preview before returning. Good for "select a card to upgrade" screens (Rest Site smith, some events, etc.).

Player whose deck to show. CardSelectorPrefs Selected cards.

Select from the transformable cards in the player's deck. Shows a transform preview before returning. Good for "select a card to upgrade" screens (Rest Site smith, some events, etc.).

Player whose deck to show. CardSelectorPrefs A delegate that is called to get the possible transformations for a card. If unsupplied, it will use the default transformation (the card is transformed to any other card from the same pool). Selected cards.

Select from the enchantable cards in the player's deck. Shows an enchant preview before returning. Good for "select a card to enchant" screens (events, etc.).

Player whose deck to show. Enchantment to apply to the card. Amount of the enchantment to apply to the card. CardSelectorPrefs Selected cards.

Select from the enchantable cards in the player's deck. Shows an enchant preview before returning. Good for "select a card to enchant" screens (events, etc.).

Player whose deck to show. Enchantment to apply to the card. Amount of the enchantment to apply to the card. Additional filter which should return true for cards that should be included in the selection. CardSelectorPrefs Selected cards.

Select from the enchantable cards in the player's deck. Shows an enchant preview before returning. Good for "select a card to enchant" screens (events, etc.).

Cards to select from. All must be in the player's deck and enchantable. Enchantment to apply to the card. Amount of the enchantment to apply to the card. CardSelectorPrefs Selected cards.

Select from removable cards in the player's deck. Good for "select a card to remove" screens like the Merchant's card removal option.

Player whose deck to remove from. CardSelectorPrefs Optional filter to exclude certain cards (like hiding un-upgradable cards for the Magic Pot relic). Note: We already automatically hide unremovable cards, so this filter doesn't have to worry about that. Selected cards.

A generic select screen for the cards in the player's deck. Shows a card selection before returning. Does not include upgrading, transforming, or applying enchantments to cards, as those have special UI

Player whose deck to select from. CardSelectorPrefs Optional filter to exclude certain cards (like un-removable cards from the deck card removal screen). Optional func to define the sort order of the cards. Selected cards.

Begins card selection, targeting a specific player's hand. If the player is the local player, this brings up the card selection screen. If the player is a remote player, this waits for that player to select a card. Good for simple hand selection without any extra bespoke UI (no upgrade/enchant previews, etc.).

The context to use when signalling player choice. Player whose hand to select from. CardSelectorPrefs Function describing which cards can be selected. All can be selected if null. Model that kicked off the hand selection. The card that was chosen by the given player.

Begins card selection for discarding, targeting a specific player's hand. If the player is the local player, this brings up the card selection screen. If the player is a remote player, this waits for that player to select a card.

The context to use when signalling player choice. Player whose hand to select from. CardSelectorPrefs Function describing which cards can be selected. All can be selected if null. Model that kicked off the hand selection. The card that was chosen by the given player.

Begins card selection for upgrading, targeting a specific player's hand. If the player is the local player, this brings up the card selection screen. If the player is a remote player, this waits for that player to select a card. Good for in-combat hand upgrades like Armaments.

The context to use when signalling player choice. Player whose hand to select from. Model that kicked off the selection. The card that was chosen by the given player.

Get a list of canonical CardModels from the Choose a Bundle screen.

Player choosing the bundle. Bundles for them to choose from. Chosen bundle.

Waits for a specified amount of time. This should be used over Task.Delay for all gameplay-related waits because it uses a Godot timer. That means, unlike Task.Delay, this will respect timescale (e.g. for hitpause) and lag.

The amount of seconds to wait. If combat is about to end and this is false, the wait will be skipped.

Waits for a specified amount of time. This should be used over Task.Delay for all gameplay-related waits because it uses a Godot timer. That means, unlike Task.Delay, this will respect timescale (e.g. for hitpause) and lag.

The amount of seconds to wait. If the cancel token requests cancellation, the wait will immediately end. If combat is about to end and this is false, the wait will be skipped.

Wait cmd which can specify the exact timings for each FastModeType.

Damage a creature.

The context that is signalled in the event of a player choice. Creature to damage. DamageVar containing the amount of damage they are taking and the properties of the damage. Card that dealt the damage. Optional. A set of damage results. Can be multiple if another creature absorbs some damage (like Osty via DieForYou).

Damage a creature.

The context that is signalled in the event of a player choice. Creature to damage. Amount of damage it is taking. Properties of the damage. Card that dealt the damage. Optional. A set of damage results. Can be multiple if another creature absorbs some damage (like Osty via DieForYou).

Damage a set of creatures.

The context that is signalled in the event of a player choice. Creatures to damage. DamageVar containing the amount of damage they are taking and the properties of the damage. Creature who dealt the damage. A set of damage results.

Damage a set of creatures.

The context that is signalled in the event of a player choice. Creatures to damage. Amount of damage they are taking. Properties of the damage. Creature who dealt the damage. A set of damage results.

Damage a creature.

The context that is signalled in the event of a player choice. Creature to damage. DamageVar containing the amount of damage they are taking and the properties of the damage. Creature who dealt the damage. Optional. A set of damage results. Can be multiple if another creature absorbs some damage (like Osty via DieForYou).

Damage a creature.

The context that is signalled in the event of a player choice. Creature to damage. Amount of damage it is taking. Properties of the damage. Creature who dealt the damage. Optional. A set of damage results. Can be multiple if another creature absorbs some damage (like Osty via DieForYou).

Damage a creature.

The context that is signalled in the event of a player choice. Creature to damage. DamageVar containing the amount of damage they are taking and the properties of the damage. Creature who dealt the damage. Optional. Card that dealt the damage. Optional. A set of damage results. Can be multiple if another creature absorbs some damage (like Osty via DieForYou).

Damage a creature.

The context that is signalled in the event of a player choice. Creature to damage. Amount of damage it is taking. Properties of the damage. Creature who dealt the damage. Optional. Card that dealt the damage. Optional. A set of damage results. Can be multiple if another creature absorbs some damage (like Osty via DieForYou).

Damage a set of creatures.

The context that is signalled in the event of a player choice. Creatures to damage. DamageVar containing the amount of damage they are taking and the properties of the damage. Creature who dealt the damage. Optional. Card that dealt the damage. Optional. A set of damage results.

Damage a set of creatures.

The context that is signalled in the event of a player choice. Creatures to damage. Amount of damage they are taking. Properties of the damage. Creature who dealt the damage. Optional. Card that dealt the damage. Optional. A set of damage results.

Kill the specified creature. NOTE: ALL creatures on the opposing side are considered the killer of this creature, no matter who struck the killing blow.

Creature to kill. Whether or not to force the death (blocking death prevention by effects like Fairy in a Bottle). Usually false, but true in certain built-in cases like abandoning a run.

Kill the specified creatures. NOTE: ALL creatures on the opposing side are considered the killer of these creatures, no matter who struck the killing blow.

Creatures to kill. Whether or not to force the death (blocking death prevention by effects like Fairy in a Bottle). Usually false, but true in certain built-in cases like abandoning a run.

Kill the specified creature without checking win condition. For internal use only, when we know we will be checking the win condition later.

Removes creature from combat without killing it and marks it escaped in the combat state. Used for things like the EscapeArtist power.

Make the specified creature gain the specified amount of block.

Creature that should gain block. BlockVar containing the amount of block they should gain, and the properties of the block. The CardPlay that caused the block gain. Null if it was not directly caused by a card play. If true, the wait that is performed after block gain is very small. Should be used in scenarios where block gain happens quickly in sequence (e.g. After Image, Barnacled Pipe). The amount of block that the creature gained after all modifications were applied.

Make the specified creature gain the specified amount of block.

Creature that should gain block. Amount of block they should gain. Properties of the block. The CardPlay that caused the block gain. Null if it was not directly caused by a card play. If true, the wait that is performed after block gain is very small. Should be used in scenarios where block gain happens quickly in sequence (e.g. After Image, Barnacled Pipe). The amount of block that the creature gained after all modifications were applied.

Heal a creature.

Creature to heal. Amount to heal them by. Whether or not to show the heal animation. True by default, and you should leave this true even if you're using it outside of combat (like when healing a player at the rest site). Only set it to false if you explicitly want the heal animation to not play even while in combat.

Set a creature's current HP to a new value.

Creature whose HP we're setting. New amount of HP they should have.

Increase a creature's maximum HP.

Creature to add max HP to. Amount of max HP to add.

Decrease a creature's maximum HP.

The context that is signalled in the event of a player choice. Creature to remove max HP from. Amount of max HP to remove. Whether or not this max HP loss is coming from a card. Used to determine whether effects like should trigger.

Set a creature's maximum HP to a new value.

Creature whose max HP we're setting. New amount of max HP they should have. The amount that the creature's max HP changed by. A positive number means their max HP increased, a negative number means it decreased.

Set a creature's maximum AND current HP to a new value.

Creature whose max/current HP we're setting. New amount of max/current HP they should have.

Stun the specified creature, performing no logic during their stunned turn.

Creature to stun. ID of the move that the creature should perform the turn after they perform stunMove. If null or empty, this will default to the last move they performed.

Stun the specified creature, performing the specified logic during their stunned turn.

Creature to stun. Logic for the move that the stunned creature will "perform". ID of the move that the creature should perform the turn after they perform stunMove. If null or empty, this will default to the last move they performed.

Trigger an animation on the specified creature.

Creature to animate. Name of the animation trigger. Number of seconds to wait after starting the animation.

Perform an attack. See for how to chain methods to set the attacking card/creature, targets, and more.

Amount of damage that each hit does. Resulting AttackCommand.

Perform an attack whose damage is calculated by a . Used for cards that do dynamic amounts of damage based on combat state, like . This uses special logic to ensure that intermediate values are floored at the appropriate time.

Dynamic var that calculates how much damage each hit does. Resulting AttackCommand.

Applies Forge to the player. Adds Sovereign Blade to their hand if they haven't forged this combat, and adds the amount of damage to it.

Amount of damage to add to Forge. Player to give the stars to. Model that caused the forging All of the player's un-Exhausted Sovereign Blade cards.

Add orb slots to a creature.

Player to add orb slots to. Number of orb slots to add.

Remove orb slots from the creature. Starts from the back of the list. Orb slots with orbs already in them are also removed.

Player to remove orb slots from. Number of orb slots to remove.

Channel an orb of the specified type.

The context with which to handle player choices. Player who is channeling the orb. Type of orb to channel.

Channel an orb.

The context with which to handle player choices. Orb to channel. Player who is channeling the orb.

Evoke the orb.

The context with which to handle player choices. Player whose next orb we're evoking. orb being evoked. Whether or not to dequeue the orb from the creature's orb queue after evoking (usually true).

Summon Osty with the specified number of HP. If the specified creature already owns an instance of Osty, raise Osty's max HP by the specified number instead.

The context with which to handle player choices. The player who is summoning. The number of HP that Osty should be summoned with (or that should be added to the existing Osty instance). The model that this Summon came from. For example, and pass themselves here. Null if the Summon did not come from any model (generally only relevant in tests). The result of the summon.

Increase the current amount of energy that the player has.

Amount of energy to give. Player to give the energy to.

Decrease the current amount of energy that the player has.

Amount of energy to remove. Player to remove the energy from.

Set the player to have a specific amount of energy.

New amount of energy. Player whose energy we're setting.

Increase the current amount of stars that the player has.

Amount of stars to give. Player to give the stars to.

Decrease the current amount of stars that the player has.

Amount of stars to remove. Player to remove the stars from.

Set the player to have a specific amount of stars.

New amount of stars. Player whose stars we're setting.

Increase the current amount of gold that the player has.

Amount of gold to give. Player to give the gold to. Was the gold stolen back from an enemy.

Decrease the current amount of gold that the player has.

Amount of gold to lose. Player to take the gold from. How the player lost the gold

Set the player to have a specific amount of gold.

New amount of gold. Player whose gold we're setting.

Give the player a new pet (aww).

Player to give the pet to. Type of pet to give them.

Give the player a new pet (aww).

Pet creature to give to the player. Player to give the pet to.

Heal the player as if they were resting at a rest site.

Player to heal. If true, we'll play the default rest site SFX.

Ends the turn for a given player.

Player who is ending their turn If the player is allowed to un-end their turn, particularly in multiplayer. Optional action to execute during the enemy turn. This is useful for tests.

We try to Procure the potion. Can fail if the potions bar is full.

Potion to be added Player who is getting the potion Slot at which to add the potion. If -1, the potion will be added in the first available slot. Potion if it is added successfully. Returns null if it failed.

Apply a power to multiple creatures.

The context that is signalled in the event of a player choice. Creatures to apply the power to. Amount of the power to apply. Creature applying the power. Optional card that is applying the power. Pass true if no flashes should play for this power application. Type of power to apply. The power that was applied. Can be null if: * Combat is over. * Something blocked application (like Artifact). * The power's amount was changed to 0 (like if you had 3 Strength and applied -3 Strength).

Apply a power to a creature.

The context that is signalled in the event of a player choice. Creature to apply the power to. Amount of the power to apply. Creature applying the power. Optional card that is applying the power. Pass true if no flashes should play for this power application. Type of power to apply. The power that was applied. Can be null if: * Combat is over. * Something blocked application (like Artifact). * The power's amount was changed to 0 (like if you had 3 Strength and applied -3 Strength).

Apply a power to a creature.

The context that is signalled in the event of a player choice. Power to apply. Creature to apply the power to. Amount of the power to apply. Creature applying the power. Optional card that is applying the power. Pass true if no flashes should play for this power application.

Looks for a valid existing instance for a given power within the target for the sake of adjusting the amount on them.

Decrement the amount of a power by 1.

Power to decrement.

Tick down the amount of a duration-based power (Vulnerable, Weak, etc.). Similar to Decrement, but respects some extra rules about turn ordering.

Power to tick down.

Modify the amount of a power.

The context that is signalled in the event of a player choice. Power to modify. Amount to modify it by (can be positive or negative). Creature applying the power. Optional card that is modifying the power amount. Pass true if no flashes should play for this power application. The new amount of the power. For example, if you have 1 Strength and modify it by 3, this will return 4.

Remove a power.

Creature to remove the power from. Type of power to remove.

Remove a power.

Power to remove.

Give a relic to the player.

Player to give the relic to. Type of relic to obtain. RelicModel

Give a relic to the player.

Relic to obtain. Player to give the relic to. index in the relic list we want to add our relic to. Default of -1 means that we append it to the end of the relic list. RelicModel

Remove a relic from its owner.

Relic to remove.

Replace a relic with another relic

Relic to remove. Relic to obtain. RelicModel

Melts a relic. A melted relic remains in your inventory, but is unusable.

Relic to melt.

Offers rewards generated for the end of a combat or treasure room. If the player is not the local player, nothing happens. The rewards screen generated by this cmd will show the proceed button after all rewards are taken, and all input into the room will be blocked.

The player to whom we are offering rewards. The room to generate rewards for.

Offers a custom set of rewards, usually from a relic or event. If the player is not the local player, nothing happens. The rewards may be changed by hooks, like Molten Egg or Ruby Earrings. The rewards screen generated by this cmd will not show the proceed button after all rewards are taken. The rewards screen will disappear and the player will be allowed to click into the room again.

The player to whom we are offering rewards. The list of rewards to offer the player.

Same as , except the rewards are not offered to the player.

Same as , except the rewards are not offered to the player.

Plays the correct swoosh sfx depending on the pile the carf came from and is going to

Creates a speech bubble. Used when a creature talks/screams/whispers to you. Generally during combat

Calculates how many characters in a string without the bbcode. Also strips out new line, brackets, optionals. Example: [jitter][gold]Money![/gold][/jitter] [sine][orange]Money![/orange][/sine] returns Money!Money! -> 12 characters -> 1.2 second speech bubble

Creates a thought bubble

The Net ID of the local player.

Get the local player from the specified player collection. Note that the run state is a player collection.

Thrown if the local player is not found.

Get the local player from the specified serializable run.

Thrown if the local player is not found.

Get the local player from the specified combat state.

Thrown if the local player is not found.

Get the local player from the specified list of players.

Get the local player's creature from the specified list of creatures.

Is the specified player the local player?

Is the specified creature the local player's creature?

Is the local player in the specified list of players?

Is the local player's creature in the specified list of creatures?

Does the specified card belong to the local player?

Does the specified potion belong to the local player?

Does the specified relic belong to the local player?

Does the specified event belong to the local player?

Maps controller specific behavior for different types of controllers. - used to override certain default controller inputs based on the controller types (ie, ps5 controllers use the touchpad to open the map) - Used to dynamically update the hotkey icons depending on what type of controller you are using.

The mapping between Steam Input Actions (defined in the vdf file), and the default controller input they correspond to.

The default map between controller inputs and specific in game commands. We have this because inputs can vary between controller types (ex: On ps4 controllers, we use the touchpad instead of the back/share button to open the map.

Different types of controllers that have differences in their default input.

A little helper for uploading the score at the end of a daily run.

Uploads a score to the daily leaderboard for the given time.

Figures out whether we should upload a score to the passed leaderboard. If any player in the run has already submitted a score, then this returns false.

Date to retrieve the leaderboard for. All fields other than year/month/day are ignored. Count of players to retrieve the leaderboard for. The name of the leaderboard used for the passed date and player count.

Static class for interfacing with MegaCrit's time server.

Begins fetching the time from the time server. After this, RequestTimeTask is non-null.

The time that was returned from the time server.

The local time at which we requested the time from the server.

Hashes assemblies to aid in mod detection.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the 'GenerateMap' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Skip intro logo and timeline requirement for faster dev iteration. Set via STS2_DEV_SKIP environment variable.

Should packed images be ignored in favor of the original image version? Set this to true to enable, but make sure to set it back to false before committing, or else you will get a test failure.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the 'ReloadLayers' method.

Cached name for the 'UpdateLayers' method.

Cached name for the 'AddLayer' method.

Cached name for the 'ToLayerName' method.

Cached name for the 'ClearLayers' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'VisibleLayer' property.

Cached name for the 'ReloadLayersCallable' property.

Cached name for the '_layerA' field.

Cached name for the '_layerB' field.

Cached name for the '_layerC' field.

Cached name for the '_visibleLayer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the '_Input' method.

Cached name for the 'GetRandomColor' method.

Cached name for the 'TestFunctionA' method.

Cached name for the 'TestFunctionB' method.

Cached name for the 'TestFunctionC' method.

Cached name for the 'SpawnVfx' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_backCombatVfxContainer' field.

Cached name for the '_combatVfxContainer' field.

Cached name for the '_env' field.

Cached name for the '_playerTopPosition' field.

Cached name for the '_playerPosition' field.

Cached name for the '_playerGroundPosition' field.

Cached name for the '_enemyTopPosition' field.

Cached name for the '_enemyPosition' field.

Cached name for the '_enemyGroundPosition' field.

Cached name for the '_defectEyePosition' field.

Cached name for the '_lowHpBorderVfx' field.

Cached name for the '_gaseousScreenVfx' field.

Cached name for the '_shiftPressed' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A helper script to spawn vfx in whole_screen_vfx_playground

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Spawn' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

This is used strictly for debugging CardTrailVfx and related

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

At some point in the future, logs system info. Getting system info takes a little while, about 1s on my Windows machine. This fetches the info asynchronously and then logs it once it's all done. Only logs on release builds to avoid cluttering dev logs.

Gets a string containing diagnostic system info for logging.

Represents release information for the game.

The commit hash.

The release version number.

The release date in git's iso8601 format

The branch name.

A hash of the contents of the main STS2 assembly, at build-time.

Custom JsonConverter for DateTime to handle the specific format in the JSON.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

The default associated with a default instance.

The source-generated options associated with this context.

Manages the loading and access of release information.

Gets the singleton instance of ReleaseInfoManager.

Gets the loaded release information.

Gets the game version as a semantic version, parsed from ReleaseInfo.version.

Loads the release configuration.

Gets possible paths for the release info file.

Implementation of semver. Mostly used for comparing versions. https://semver.org

Manages Sentry .NET SDK initialization and error reporting for C# exceptions. This complements the GDExtension SDK which handles native crashes.

Disables GDExtension Sentry event capture when mods are detected. Called right after ModManager.Initialize to prevent mod errors from being reported through the GDExtension before AfterGameInit has a chance to shut everything down. Sets the sample callable to always return false instead of calling close(), because the native SDK should not be closed until the application is shutting down.

Initializes the Sentry .NET SDK. Should be called early in game startup. Disabled in editor (unless headless), uses "playtesters" environment with release_info, "development" without.

Configures sampling rate based on the Steam branch. Call after Steam initializes. Shuts down Sentry entirely for non-Steam builds (null branch).

Adds a breadcrumb for tracking user actions leading up to an error.

Captures an exception and sends it to Sentry. Attaches current game state context for debugging. Respects user consent settings.

Captures an exception with additional scope configuration. AttachGameState is called first, then the caller's configureScope action.

Captures a message and sends it to Sentry. Respects user consent settings.

Sets a tag on the current scope for filtering in Sentry.

Sets extra context data on the current scope.

Initializes Sentry for testing purposes, bypassing editor and release checks. Only use from dev console commands.

Shuts down the Sentry SDK gracefully. Should be called when the game exits.

Attaches current game state to the Sentry scope for debugging context. Collects scene, run info, and combat state when available.

Returns true if the Sentry service should shutdown after we've finished initializing the game. This should only return false for things that don't change during the runtime of the game. We shutdown the service rather than filtering events so that crashes (which can't get filtered) don't get sent for modded games.

Provides argument completion candidates for console commands. Commands should override this method to provide context-aware completion suggestions. Returns an empty result by default for commands that don't require argument completion.

The player invoking the command Current command arguments being typed Completion result containing candidates and context information

Creates a completion result for command arguments with explicit separation of completed vs partial arguments. This makes the completion logic clear and prevents bugs from implicit argument slicing.

All possible completion candidates Arguments that are already fully typed (e.g., ["OFFERING"] when completing second arg) The argument currently being typed (e.g., "de" when typing "deck") The type of completion being performed Optional custom matching predicate (defaults to StartsWith) CompletionResult with filtered candidates and completion prefix

Builds the command prefix from completed arguments (not including the partial arg being typed). Example: BuildPrefix(["OFFERING"]) returns "card OFFERING "

Parses a string into an enum value, rejecting numeric strings and undefined values. Use this instead of Enum.TryParse to avoid accepting raw integers as valid enum values.

Calculates the common completion string from filtered candidates. Single match gets trailing space, multiple matches get longest common prefix.

Console commands which kills the player

Builds a ZIP of logs and saves tailored for the feedback upload path. Unlike , this excludes the screenshot (already sent as a separate multipart part) and inactive profiles. Only the most recent run history file is included.

Best-effort collection of Linux core dumps via systemd-coredump. Silently does nothing if coredumpctl is unavailable or no dumps are found.

Returns all save files in the account directory. Includes everything to ensure we capture info that might give clues for debugging, including old migrations or other unexpected files.

Reads text from a stream, truncating to the tail if it exceeds . When truncated, skips past any partial UTF-8 character and partial line at the seek point, then prepends a truncation marker.

A readable, seekable stream containing UTF-8 text. Maximum bytes to read from the tail. 0 means no limit. The full or truncated text content.

Console commands which gives the player godmode.

Console commands which manipulate the player's current gold.

Console commands which manipulate the player's current health.

remove_card console cmd. Attempts to remove a card from both Hand and Deck at the same time.

Debug console command for testing Sentry integration.

Force initializes Sentry for testing purposes, bypassing normal checks.

A command that toggles the 0 - 9 hotkeys for hiding UI and +/- for controlling speed

A command that lets you jump to any room on the map.

Console commands which causes the player to win the combat

Gets structured completion results for interactive selection

Call this to attempt to execute a command that is issued locally. If the command must be networked and a run is in progress, a GameAction will be enqueued to all peers before the command is executed.

The command input by the player.

Call this when a networked console command is received. You are expected to await CmdResult.task.

The player that sent the command. The command input by the player.

Encapsulates all state for interactive tab completion in the dev console.

Should this dialogue be added to the pool of dialogues that can be repeated on future visits? Can be set manually or auto-populated from loc keys via the "r" suffix (e.g., "1-0r.ancient").

What visit should this dialogue be shown on? This can be combined with to show a dialogue on the Nth visit, and then add it to the pool of repeating dialogues for visits after that.

0: Show this dialogue on this character's first visit to this ancient. 1: Show this dialogue on this character's second visit to this ancient. 4: Show this dialogue on this character's fifth visit to this ancient. null: Show this dialogue on any visit to this ancient.

For Architect dialogues, who should attack at the start?

For Architect dialogues, who should attack at the end?

Create a new dialogue. The number of SFX you pass controls how many lines this dialogue has.

The paths to the SFX that should be played when this dialogue is shown. Each SFX corresponds to a line in the dialogue. Passing an empty string for a given line indicates that no dialogue should be played for it, but you must pass some string for every line. For example, if you have a single-line dialogue with no SFX, call `new AncientDialogue("")`. If you called `new AncientDialogue()`, you'd create a dialogue with 0 lines.

Populate this dialogue's lines with the correct loc keys. IsRepeating is derived from the presence of the "r" suffix in the first line's loc key. Speaker is derived from which key suffix exists in the JSON: ".ancient" or ".char".

The ID entry for the ancient that this line is for. The ID entry for the character that this line is for. Can also be "ANY" for character-agnostic dialogues, or "firstVisitEver" for the dialogue that should be shown the first time you ever visit this ancient (regardless of character). The index of this dialogue in the list of dialogues for this ancient and character.

The text that should be shown for this line of dialogue.

The text that should be shown on the "Next" button that goes with this line of dialogue. Null for the last line in a dialogue.

The speaker of this line of dialogue.

The path to the SFX that should be played when this line of dialogue is shown. Empty string means no SFX.

Get the path to the SFX to play for this line of dialogue. Returns a fallback if the SFX path is empty.

Represents the complete dialogue configuration for an ancient, organized by category. Each ancient defines its dialogues explicitly in C# via . Keys use X-Y format where X is the dialogue index within a collection and Y is the line index within a dialogue. Each line key ends with ".ancient" or ".char" to indicate the speaker. The speaker is derived from which key exists in the JSON at PopulateLocKeys time. Dialogues that should be added to the "repeating" pool encode their repeating status in the loc keys by appending "r" to the X-Y component. For example, "1-0r.ancient" indicates a repeating dialogue line. When detects the "r" suffix on the first line, it automatically sets to true. For example: "DARV.talk.IRONCLAD.0-0.ancient": "Dialogue 1, line 1 (ancient speaks)", "DARV.talk.IRONCLAD.0-1.char": "Dialogue 1, line 2 (character speaks)", "DARV.talk.IRONCLAD.0-2.ancient": "Dialogue 1, line 3 (ancient speaks)", "DARV.talk.IRONCLAD.1-0r.ancient": "Dialogue 2, line 1 (ancient speaks, repeating)", "Next" button text must also be supplied for every line except the last line in each dialogue. Repeating dialogues use the "r" suffix on their next keys as well. For example: "DARV.talk.IRONCLAD.0-0.ancient": "Dialogue 1, line 1", "DARV.talk.IRONCLAD.0-0.next": "Respond", "DARV.talk.IRONCLAD.0-1.char": "Dialogue 1, line 2", "DARV.talk.IRONCLAD.0-1.next": "Continue", "DARV.talk.IRONCLAD.0-2.ancient": "Dialogue 1, line 3", "DARV.talk.IRONCLAD.1-0r.ancient": "Dialogue 2, line 1 (repeating)", "DARV.talk.IRONCLAD.1-0r.next": "Acknowledge", "DARV.talk.IRONCLAD.1-1r.ancient": "Dialogue 2, line 2 (repeating)",

First time ANY character visits this ancient (global once-only). Shown when totalAncientVisits == 0. If null, this ancient has no first-visit-ever dialogue (for example, The Architect). Example key: "DARV.talk.firstVisitEver.0-0.ancient"

Per-character dialogues. Each carries its own and metadata to determine when it should be shown. Example key: "DARV.talk.IRONCLAD.0-0.ancient"

Character-agnostic dialogues. Used as fallback when no visit-specific dialogue applies. Example key: "DARV.talk.ANY.0-0.ancient"

Get every dialogue in this set.

Get valid dialogues for the specified character and visit counts. Returns a collection of dialogue sequences; the caller picks one randomly. Priority order: 1. FirstVisitEverDialogue (totalVisits == 0) 2. Visit-specific dialogues for this character (matching VisitIndex) 3. Visit-specific character-agnostic dialogues (matching VisitIndex) 4. Repeating pool (character-specific + character-agnostic IsRepeating)

The ID of the character visiting this ancient. Number of times this character has previously visited this ancient. Total number of visits to this ancient across all characters. Whether character-agnostic repeating dialogues are allowed. See . A collection of valid dialogue sequences to choose from.

Auto-derives and LocStrings for every line based on its position in the dialogue structure. Keys use X-Y format where X is the dialogue index within a collection and Y is the line index within a dialogue.

No speaker. This should never be set, it just gives us a neutral default.

The Ancient (Neow, Darv, etc.) is speaking.

The player character (Ironclad, Silent, etc.) is speaking.

Who should attack during The Architect dialogue?

No attacks should occur during the specified portion of the dialogue.

The Player attacks.

The Architect attacks.

The player attacks, then the Architect immediately attacks back.

Manages ascension logic for runs. Responsible for tracking ascension levels and applying ascension effects.

The maximum ascension level allowed in the game.

The current ascension level for the run.

Create a new AscensionManager with the specified ascension level.

The ascension level for this run.

Create a new AscensionManager with the specified ascension level.

The ascension level enum value for this run.

Check if a given ascension level is active in the current run.

The ascension level to check. True if the specified level is active.

Apply ascension effects to a player based on the current ascension level.

The player to apply effects to.

Manages the extra, non card, options in a card reward screen. i.e. Skip (default option), Sacrifice (for Pael Wing), Heal +2 (for Dream Catcher)

Action to perform when the alternative option is selected.

The action to take after the alternate reward is selected. See the values for more information.

Generates a list of extra options to use for the next card reward screen. This list will include extra options added by models like the Pael Wing relic if the player has them.

The reward for which alternatives are being generated. List of rest extra options options.

"Normal" cost. Colored white.

The current cost is modified to above normal. Colored blue.

The current cost is modified to at/below normal. Colored green.

The card cannot be played because the player does not have enough resources.

Encapsulates all energy cost related properties and methods for a CardModel. This class handles base energy costs, local and global modifications, and energy cost calculations.

This card's local cost modifiers. See for details on how this works.

This card's "official" starting energy cost. This is what would appear on the card if it was printed out on paper.

Whether this card has an energy cost of X. X-cost-cards automatically spend all of the player's remaining energy when played, and their effect is multiplied by the amount spent.

Was this card's energy cost just recently upgraded? This is mainly used to show upgrade preview values in green. This should be cleared after the upgrade is complete.

Does this energy cost have any local modifiers? See for details.

Get this card's energy cost, including the specified modifier types. See for details on what types are available.

The amount of energy most recently spent to play this X-cost card. Used when duplicating X-cost cards, to make sure the duplicates are played with the same value. WARNING: Only use this for calculations related to energy spent. If you're using this to calculate a cost-X-energy card's effect, use instead, as it will take X-value modifications (like ) into account.

Get the amount of energy that should be spent to play this card. * For X-cost cards, this is the amount of energy that its owner has. * For normal cards, this is the current cost including all modifiers (see with ) clamped to 0. The game uses this value when actually spending the energy to play the card. Additionally, this is useful for effects that need to know how much WOULD be spent to play the card without actually playing it, such as .

Get the "resolved" cost of this card. This can mean one of two things: * For X-cost cards, this is the captured X-cost value (see ). * For normal cards, this is the current cost including all modifiers (see with ) clamped to 0. This is useful for effects that need to know the card's cost AFTER it was played, such as . For normal cards, these effects just care about the card's current cost (including all modifiers). For X-cost cards, these effects care about the X-value that was set for the card when it was played.

Set this cost to the specified amount until the card is played.

says "Reduce the cost of all cards in your Discard Pile to 0 until played." New cost. Whether this modifier should only be included in the cost calculation if it would lower the current cost. See for details.

Set this cost to the specified amount until the end of the current turn OR until the card is played, whichever comes first. Note that the text of these effects will just say "this turn"; the "or until played" part is left implicit because it's wordy and rarely relevant.

says "Reduce the cost of ALL cards in your Hand to 0 this turn." New cost. Whether this modifier should only be included in the cost calculation if it would lower the current cost. See for details.

BE CAREFUL USING THIS! You usually want instead. Set this cost to the specified amount until the end of the current turn. Note that most effects that say "this turn" really mean "this turn or until played". This method should only be used for the few effects that should last for multiple plays in the same turn.

says "This card costs 0 if Osty has attacked this turn." New cost. Whether this modifier should only be included in the cost calculation if it would lower the current cost. See for details.

Set this cost to the specified amount for the rest of the combat.

+ says "Reduce the cost of ALL cards in your Hand to 1 this combat." New cost. Whether this modifier should only be included in the cost calculation if it would lower the current cost. See for details.

Add the specified amount to this cost until the card is played.

says "If this card is in your hand at the end of turn, reduce its cost by 1 until it is played." Amount to add to the cost. Whether this modifier should only be included in the cost calculation if it would lower the current cost. See for details.

Add the specified amount to this cost until the end of the current turn OR until the card is played, whichever comes first. Note that the text of these effects will just say "this turn"; the "or until played" part is left implicit because it's wordy and rarely relevant.

None yet. Update this if we add one! Amount to add to the cost. Whether this modifier should only be included in the cost calculation if it would lower the current cost. See for details.

BE CAREFUL USING THIS! You usually want instead. Add the specified amount to this cost until the end of the current turn. Note that most effects that say "this turn" really mean "this turn or until played". This method should only be used for the few effects that should last for multiple plays in the same turn.

says "Costs 1 less for each Skill played this turn." Amount to add to the cost. Whether this modifier should only be included in the cost calculation if it would lower the current cost. See for details.

Add the specified amount to this cost for the rest of the combat.

says "Whenever you draw this card, lower its cost by 1 this combat." Amount to add to the cost. Whether this modifier should only be included in the cost calculation if it would lower the current cost. See for details.

Clear local cost modifiers that should last until the end of the turn.

True if any modifiers were cleared and EnergyCostChanged should be invoked.

Clear local cost modifiers that should last until the card is played.

True if any modifiers were cleared and EnergyCostChanged should be invoked.

Upgrade the energy cost of this card by the specified amount.

Amount to add to the current cost (usually negative).

Finalize an upgrade after calling UpgradeEnergyCostBy. This clears out state that is used for displaying an upgrade preview.

Reset energy cost to base values during downgrade.

BE VERY CAREFUL USING THIS! This is mainly meant for internal usage. The only external usage of this should be in .

Create a deep clone of this EnergyCostInfo for the specified card.

The card that will own the cloned EnergyCostInfo. A deep clone of this EnergyCostInfo.

Card Keywords are extra "automatic behaviors" you can add to a card, which also automatically add some extra text to the card's description. Examples of things that SHOULD be CardKeywords: * Exhaust: automatically exhausts when played, puts "Exhaust" in the card description. * Unplayable: blocks the card from being played, puts "Unplayable" in the card description. Examples of things that should NOT be CardKeywords: * Strike: this has no logic or extra text, just tells Perfected Strike (and some other models) that it's a Strike card. * Block: while this is used on cards that have "Block" in their descriptions, it doesn't automatically add it, nor does it automatically grant block; it's just for HoverTips and effects that care about which cards give block (like the Nimble enchantment, which should only apply to cards that give block).

All the keywords that should be added before the card's description. Order matters here. If a card has multiple keywords, they will appear in this order.

All the keywords that should be added after the card's description. Order matters here. If a card has multiple keywords, they will appear in this order.

Manages card restrictions based on how many players there are in a run.

This is functionally a constant but is a property for modding ergonomics.

Randomize the order of the cards in this pile. Do NOT call this when your intention is to do a standard shuffle action. Use instead. This is primarily meant for randomizing the order of the draw pile when a combat first starts.

Add a card to the bottom of this pile.

Card to add. Index to insert the card into. -1 will cause it to be added to the end ("bottom"). If true, no events will be called. Thrown if this specific CardModel instance is already in the pile.

Remove a card from this pile.

Card to remove. If set to true, no events will be sent to update the UI. Thrown if this specific CardModel instance is not in the pile.

Move a card to the bottom of this pile. The card must already be in this pile. This does not send any events to update the UI, so you should only use this in combination with other methods that do.

Card that we're moving to the bottom.

Move a card to the top of this pile. The card must already be in this pile. This does not send any events to update the UI, so you should only use this in combination with other methods that do.

Card that we're moving to the top.

Represents a single instance of a card being played. This is important for distinguishing between multiple plays of the same card during the same turn.

The card that was played.

The creature that was targeted by the card. Null for un-targeted cards.

The pile that the card should be put in after this play is over.

Info about the resources used during this card play.

Whether this card is being auto-played. False when the player plays the card manually from their hand. True when played automatically by an effect like .

The index of the current card play relative to playCount. Usually 0, but when a card has an effect like Replay, the second play will have playIndex=1, the third will have playIndex=2, etc.

The total number of times this card is going to be played. Usually 1, but when a card has an effect like Replay, it will be higher (Replay 1 will have playCount=2, Replay 2 will have playCount=3, etc.). You can compare this with playCount to see if you're on the final play of the card.

Is this the first card play in the series? Usually true, but when a card has an effect like Replay, this will only be true on the card's first play. For example, if a card has Replay 2, this will be true for its first CardPlay and false for the last two.

Is this the last card play in the series? Usually true, but when a card has an effect like Replay, this will only be true on the card's last play. For example, if a card has Replay 2, this will be false for its first two CardPlays and true for the third.

Do not calculate any previews. This should be used on the backend when doing actual value calculations.

Calculate the "normal" previews (extra damage from , etc.) This should be the default when calculating a card's visuals.

Calculate previews as if the card were being upgraded. This is used in and similar areas.

Calculate previews as if multiple creatures were being targeted at once. This is relevant for cards that target all/random enemies, where all those enemies may have the same power that would apply to the card. For example, if all enemies have , attacks should preview the extra damage. If one enemy has it and another does not, attacks should not preview the extra damage. This is used in and similar areas.

Gets the next highest rarity. Basic -> Common -> Uncommon -> Rare -> Common. Intended to be used in a loop with a blacklist. Be careful not to get into an infinite loop if the blacklist is full.

A card that has no scope. Used in places like the Card Library. Should never be used during a run (even things like upgrade previews should have a scope).

A card that exists for an entire run. Cards in the player's deck have the Run scope, as do cards offered at the merchant, during end-of-combat rewards, shown in the upgrade preview at the rest site, etc.

A card that exists for a single combat. Cards in the player's draw/discard/exhaust/hand piles have the Combat scope, as do cards generated by effects like , shown in the upgrade preview for , etc.

Card Tags are behavior-less metadata that other models can use to look things up. A card tag should NEVER automatically add behavior to a specific card, which means non-model areas of the codebase should probably never reference individual ones. If you're here to try and add automatic behavior to a card, check out CardKeyword instead. The proper way to use Card Tags is for other models to look them up to power their own behavior. For example, Perfected Strike ("Deal 6 damage. Deals 2 additional damage for ALL your cards containing 'Strike'.") can look up all cards with the Strike keyword to determine how much extra damage to deal.

Makes this card a "Strike" card (, , etc). Used by effects that apply to Strikes, generally in tandem with a Basic rarity check (like ), but also sometimes without (like and ).

Makes this card a "Defend" card (, , etc). Used by effects that apply to Defends, generally in tandem with a Basic rarity check (like ), but also sometimes without (like ).

Makes this card a "Minion" card (, , etc). Used by effects that apply to Minion cards, like .

Makes this card an "Osty Attack" card (, , etc).

Makes this card a "Shiv" card ().

Represents a transformation of one card in a pile to another card which replaces the original card in the same pile. If Replacement is set, then it will be used as a direct replacement. If ReplacementOptions is set, then a random card will be chosen from one of those options.

Whether the original card is in combat at construction time. Captured here because the card may be removed from its pile before GetReplacement is called, which would make CombatState null.

An enum representing the types of modifiers that should be included when calculating a card's energy cost.

No modifiers at all. This will just return the card's unmodified energy cost. What is the difference between this and ? A card's canonical cost is what would be "printed" on the card if it was printed out on paper, which means it cannot include _permanent_ modifications. The most prolific permanent modification is an upgrade; cards like reduce their cost by 1 when upgraded. This change will be reflected when using , but not when calling .

Include any modifiers that have been applied directly to the card. These modifiers live locally on the card itself, and will persist regardless of changes to other models in the combat state.

See for examples.

Include any modifiers that are persistently applied by other models in the global game state, and that may change or wear off based on changes to other models in the game state.

, which applies a persistent "cost 1 more energy" modifier to all cards in the player's hand. This effect will wear off if Enthralled leaves the player's hand.

Include all modifiers.

An enum representing the types of sources that should be included when calculating a card's keywords. This mirrors ; see that type for the analogous local-vs-global distinction on energy cost.

No sources at all. This returns an empty set.

Include keywords that have been applied directly to the card. These live locally on the card itself (canonical keywords plus local minus local ), and persist regardless of changes to other models in the combat state. applies Ethereal this way.

Include keywords that are persistently granted by other models in the combat state, and that wear off when that source changes or leaves. These are never stored on the card; they are computed on demand. grants Ethereal this way for as long as it exists.

Include all sources.

A class representing a single local modifier to a card's cost. A 's contains a list of these local modifiers, which are executed in the order they were applied to determine the card's final cost (before global modifiers if requested). For example, imagine the following scenario: You have a card with a base cost of 5. The following sequence of events occurs: 1. An effect sets the card's cost to 2 (absolute) for the whole combat. 2. Another effect increases the card's cost by 1 (relative) for the whole combat. 3. Another effect sets the card's cost to 0 (absolute) just for this turn. 4. Another effect increases the card's cost by 1 (relative) for the whole combat. The CardEnergyCost's list of local modifiers would look like this: [ LocalCostModifier(2, Absolute, WholeCombat), LocalCostModifier(1, Relative, WholeCombat), LocalCostModifier(0, Absolute, ThisTurn), LocalCostModifier(1, Relative, WholeCombat) ] And the card's calculated cost would be 1. Then, after the turn ends, the LocalCostModifier(0, Absolute, ThisTurn) modifier would wear off, and the list of local modifiers would look like this: [ LocalCostModifier(2, Absolute, WholeCombat), LocalCostModifier(1, Relative, WholeCombat), LocalCostModifier(1, Relative, WholeCombat) ] And the card's calculated cost would be 4.

This modifier's amount. For , this is the cost that the card should be set to. For , this is the amount that the card's cost should be offset by.

What algorithm should be used to apply this modifier to its card's cost.

When should this modifier wear off? Depending on this value, the modifier may wear off after certain game events. For example, a modifier with will wear off after the card is played.

Should this modifier only be included in the cost calculation if it would lower the cost? Usually false, but true for effects that have the word "Reduce" in them. If you're not sure whether to set this to true or false, check if the effect uses the word "Reduce". If it does, set it to true. If not, set it to false. If you're still not sure, read the example below. If you're still not sure, set it to false.

says "Reduce the cost of ALL cards in your Hand to 1". If you have a 3-cost card in your hand that's been temporarily reduced to 0 via other s, should not raise it up to 1. However, once the other modifiers wear off, should kick in and reduce the cost to 1.

Modify the passed cost.

How long an should last.

This modifier should wear off when combat ends. Used for effects like and .

This modifier should wear off when the turn ends. Used for effects like and .

This modifier should wear off when the card is played. Used for effects like .

What algorithm should be used to apply a to a card's cost.

The card's local cost should be reset to this specific value.

The card's current local cost should be offset by this amount.

Used for determining which Card Pile. Useful when flying cards around, knowing if a card is in your Hand or in the Discard Pile and things like that.

Where cards are drawn from.

Where cards are manually played from.

Where cards are discarded/flushed to.

Where cards are exhausted to.

A temporary pile that a card lives in while it's mid-play, so that it isn't counted towards your hand or your discard pile.

Where cards live between rooms. When a new combat starts, all cards in here are cloned into your draw pile, so modifications to cards in combat won't modify cards in here.

Is this pile a combat pile? Combat piles are: Hand Draw Discard Exhaust Play

Pile to check. Whether or not it's a combat pile.

The amount of energy that was spent when playing this card.

The amount of energy that this card cost when it was played. Note that this is not necessarily the same as . For example, if you auto-play a 3-energy-cost card, this will be 3, while will be 0.

The number of stars that were spent when playing this card.

The number of stars that this card cost when it was played. Note that this is not necessarily the same as . For example, if you auto-play a 3-star-cost card, this will be 3, while will be 0.

Can only target self. No target selection.

Can target any enemy. Target selection is performed to determine the enemy.

Targets all enemies. No target selection.

Targets all enemies. No target selection.

Targets any player. In multiplayer, target selection is performed to determine the player. In singleplayer, no target selection is performed.

Targets any ally (any player excluding itself). In multiplayer, target selection is performed to determine the player. You should not see this in singleplayer.

Targets all allies. No target selection.

Target selection is performed, but no creature target is expected. Currently only used by to target the merchant, which is not a creature.

Targets the local player's Osty

Represents a card cost that should only exist temporarily. Used for effects that set a card's cost to a specific value. For effects that modify a card's existing cost by a certain amount, see . Used for both temporary energy and star card costs.

The amount that this card's cost is set to.

Should this temporary cost be cleared when the turn ends? This is true for effects that say something like "It costs N _this turn_" (like Attack Potion).

Should this temporary cost be cleared when the card is played? This is true for effects that say something like "It costs N _until played_" (like King's Gambit), AND for effects that say something like "It costs N _this turn_" (like Attack Potion).

A temporary cost that is cleared only when the card is played.

A temporary cost that is cleared when the card is played OR at the end of the current turn, whichever comes first.

A temporary cost that remains for the entire combat.

Represents a card cost offset that should only exist temporarily. Used for effects that modify a card's cost by a certain amount. For effects that set a card's cost to a specific value, see .

The amount that this card's cost is modified by. Positive for cost increases, negative for cost decreases.

Should this temporary cost offset be cleared when the turn ends? This is true for effects that say something like "It costs N more _this turn_".

Should this temporary cost offset be cleared when the card is played? This is true for effects that say something like "It costs N more _until played_", AND for effects that say something like "It costs N more _this turn_".

A temporary cost offset that is cleared only when the card is played.

A temporary cost offset that is cleared when the card is played OR at the end of the current turn, whichever comes first.

A temporary cost offset that remains for the entire combat.

The card has the Unplayable keyword, or its UnplayableThisTurn flag is set to true.

Something like Normality is blocking the card from being played.

The card itself has a built-in reason that is blocking its play, like how Grand Finale can't be played unless your draw pile is empty.

You don't have enough energy to play the card.

You don't have enough stars to play the card.

You have no living allies you can target.

Represents a character's gender for grammatical purposes. These do not necessarily align with the character's gender identity. For example, in French, a nonbinary character may want to use any of these options, but there is no grammatical gender specifically for "nonbinary" in French.

The CombatState that this creature exists in. Never null for monsters. Will be null for players when outside of combat.

Use this when displaying the name to the player.

Use this when logging the name of the creature. It avoids logging player names directly.

How should this creature's health bar be displayed? This is mostly for visuals, although a few gameplay effects (like ) check it to see if the creature can currently take damage.

The player that owns this pet. Returns null if this creature is not a pet.

Is this creature a pet?

Get all the pets that belong to this creature.

Is this creature a primary enemy? A primary enemy can stay alive all alone. A secondary enemy will automatically die unless there's also a living primary enemy. Most enemies are primary enemies. Enemies with powers like or are secondary.

Is this creature a secondary enemy? See for detailed definitions.

Is this creature hittable? A hittable creature is alive and can be "hit" by effects. This is different from targetable; an un-targetable creature can still be hit by AOE effects.

Can this creature have powers applied to it? A creature can have powers applied to it if it's in combat and can be "hit" by effects. This is different from targetable; an un-targetable creature can have powers applied to it. It's also different from hittable; a creature is not hittable if it's dead, but dead creatures can still have powers applied to them.

Called when the creature is first added to combat.

DO NOT CALL UNLESS YOU KNOW EXACTLY WHAT YOU'RE DOING. Hooks and everything are all done in CreatureCmd.Damage, so there needs to be a really good reason to want to avoid them.

Amount of damage to be dealt to this creature's block. Damage props How much damage was blocked.

DO NOT CALL UNLESS YOU KNOW EXACTLY WHAT YOU'RE DOING. Hooks and everything are all done in CreatureCmd.Damage, so there needs to be a really good reason to want to avoid them.

Amount of damage to be dealt to this creature's HP. Value props for the damage. Result of the damage.

Stun this creature. You should probably be calling instead.

Logic for the move that the stunned creature will "perform". ID of the move that the creature should perform the turn after they perform stunMove. If null or empty, this will default to the last move they performed.

NEVER CALL THIS! ONLY PowerModel.ApplyInternal should be calling this.

Power to apply.

NEVER CALL THIS! ONLY PowerModel.Amount should be calling this.

Power to modify. How much the power has changed. Whether or not VFX should be displayed for this power.

NEVER CALL THIS! ONLY PowerModel.RemoveInternal should be calling this.

Power to remove.

NEVER CALL THIS UNLESS YOU KNOW WHAT YOU'RE DOING! This skips the AfterRemoved call for powers.

Powers that should not be removed.

Helper function to get the percent hp of a creature (0 - 1).

A class containing a bunch of meta-info about an instance of damage that was dealt to a creature. See comments on individual properties for more details and examples.

The creature that received the damage.

The value props of the damage that was dealt.

The amount of damage that was blocked by the target.

X deals 10 damage to Y, who has 15 Block. BlockedDamage = 10. X deals 20 damage to Y, who has 15 Block. BlockedDamage = 15. X deals 20 damage to Y, who has 20 Block. BlockedDamage = 20. X deals 20 damage to Y, who has 0 Block. BlockedDamage = 20.

The amount of damage that the target received after blocking all that it could.

X deals 10 damage to Y, who has 15 Block. UnblockedDamage = 0. X deals 20 damage to Y, who has 15 Block. UnblockedDamage = 5. X deals 20 damage to Y, who has 20 Block. UnblockedDamage = 0. X deals 20 damage to Y, who has 0 Block. UnblockedDamage = 20.

If the target was killed, this will be the amount of extra damage that the target received after their HP dropped to 0.

X deals 10 damage to Y, who has 15 HP. OverkillDamage = 0. X deals 10 damage to Y, who has 10 HP. OverkillDamage = 0. X deals 10 damage to Y, who has 5 HP. OverkillDamage = 5.

The total amount of damage that the target received, including both blocked and unblocked.

X deals 10 damage to Y, who has 15 Block. TotalDamage = 10. X deals 20 damage to Y, who has 15 Block. TotalDamage = 20. X deals 20 damage to Y, who has 20 Block. TotalDamage = 20. X deals 20 damage to Y, who has 0 Block. TotalDamage = 20.

Whether the creature's block was broken by this instance of damage. Note: If possible, you should prefer using the AfterBlockBroken hook instead of checking this, as non-damage sources like Expose can remove block.

X deals 10 damage to Y, who has 15 Block. WasBlockBroken = false. X deals 20 damage to Y, who has 15 Block. WasBlockBroken = true. X deals 20 damage to Y, who has 20 Block. WasBlockBroken = true. X deals 20 damage to Y, who has 0 Block. WasBlockBroken = false.

Whether the entirety of this instance of damage was blocked.

X deals 10 damage to Y, who has 15 Block. WasFullyBlocked = true. X deals 20 damage to Y, who has 15 Block. WasFullyBlocked = false. X deals 20 damage to Y, who has 20 Block. WasFullyBlocked = true. X deals 20 damage to Y, who has 0 Block. WasFullyBlocked = false.

Was the creature that took damage killed by it? Note: This will return true even if the creature was resurrected afterwards (Fairy in a Bottle, etc.).

X deals 10 damage to Y, who has 15 HP. WasTargetKilled = false. X deals 20 damage to Y, who has 15 HP. WasTargetKilled = true. X deals 20 damage to Y, who has 20 HP. WasTargetKilled = true. X deals 20 damage to Y, who has 20 HP and Fairy in a Bottle. WasTargetKilled = true.

Normal HP display (red background with poison/doom overlays, Current/Max HP numbers).

Purple "infinite" background with Current/Max HP numbers.

Purple "infinite" background with infinity symbol instead of Current/Max HP numbers.

Does this HP display indicate infinite HP?

Does this HP display show Current/Max HP numbers?

A class containing meta-info about the result of a Summon.

The creature that was summoned. Null if something blocks the summon.

The amount that they were summoned for. 0 if something blocks the summon.

Utility object representing a random enchantment that may be applied to a card.

Utility object representing a random enchantment that may be applied to a card.

Used to help flavor how the gold was lost in the Map History.

Gold was spent in a transaction. Typically from a shop.

Gold was lost without involving another entity (i.e. dropping it down a hole in an event).

Gold was taken by someone (i.e. )

Manages a buy-able card in the merchant shop.

Manages the card removal option of a merchant shop

Lines for when the player enters the merchant room.

Lines for when the player throws a at the merchant.

Lines for when the player is dead. Rare, but can happen in multiplayer if one player is dead and the others go to the merchant.

Lines for when the player opens the merchant's inventory.

Get all the valid lines for a given purchase status.

Represents purchasable entry in the merchant shop. Wrapped in an NMerchant_Node that manages the UI interactions.

Subclass-specific logic for purchasing the item in the entry.

Inventory that the entry is being purchased in. Whether or not the cost should be ignored Tuple containing whether or not the purchase was successful and the amount of gold spent.

Subclass-specific logic for clearing the entry after a purchase.

Subclass-specific logic for restocking the entry after a purchase if the player has an effect like .

Manages a purchasable potion in the merchant shop.

Manages a purchasable relic in the merchant shop

The purchase was successful.

The purchase failed due to lack of gold.

The purchase failed due to lack of space in the player's inventory.

The purchase failed because some external effect prevented it (like for a potion purchase).

The purchase failed because the Merchant does not have this slot stocked.

An IComparer which sorts a collection of models into the same order. The HookBus keeps a collection of models. In multiplayer, these models may be added or removed in different orders based on the peer. However, we need these models to execute their hooks in the exact same order across all peers to maintain determinism.

For when the player is choosing from a set of canonical cards, like the cards generated by Attack Potion.

For when the player is choosing from a set of mutable cards in a combat pile, like the cards in your hand when you play Survivor.

For when the player is choosing from a set of mutable cards in a player's deck, like when you choose the Smith option at a rest site.

For when the player is choosing from a set of mutable cards. Should be used any time we want the player to choose from a set of cards that may be modified from their canonical version (like if they're upgraded or enchanted).

For when the player is targeting players outside of combat, and the decision point is synced.

For when the player is choosing an option out of a deterministically generated list of options.

We're not in combat.

We're in combat, and the player is fully in control.

We're in combat, and we're in phase one of ending the turn. Queues are unpaused during this time to allow generated hook actions (like Well-Laid Plans) to execute, but all other types of actions will be automatically canceled to prevent interleaving of actions with hooks.

We're in combat, and the player is not fully in control. This encapsulates the enemy turn and the draw phase of the player's turn.

Class for holding extra info to display in multiplayer errors if the error is a ConnectionFailureReason.

The mods that the host has that we are missing on our end. Only set on ConnectionFailureReason.ModMismatch.

The mods that we have that are missing on the host's end. Only set on ConnectionFailureReason.ModMismatch.

Sent in the InitialGameInfoMessage. If a client receives this, then they will be disconnected shortly after receiving the message, and they should show a relevant error. This is used specifically during connection. See DisconnectionReason for generic disconnection reasons.

The lobby has reached the maximum number of players.

The host loaded from a save file and the client attempting to join is not one of the players in the save.

The run is already in progress and the client attempting to join is not one of the players in the run.

The host's game version does not match ours.

Either the host has mods that we don't have, or we have mods that the host doesn't have.

Canceled if in the queue when we reach the end of combat, or if it is enqueued while we are not in combat.

Canceled if in the queue when we reach the end of combat, or if it is enqueued while we are not in combat. If it is requested to be enqueued outside of the player's play phase, the request is deferred until it becomes the play phase for the local player. This is used for things like card plays and potion uses so that they occur only after the player turn is completely set up.

Not canceled at the end of combat. If the action reaches the front of queue during combat, it will not be executed until the combat ends.

Not canceled at the end of combat, and can be executed at any time (in or out of combat).

A list of reasons for which we may be disconnected from a remote host. Each of these is associated with a particular error message that we can show to the user. It's likely that this list will expand over time.

No reason was passed.

Normal quit (Host save and quit or quit the application).

Normal quit at the end of the run. Signals to clients they should not also quit the application.

Host abandoned the game without saving it.

We were forcibly removed from the game.

Tried to join a user that is not currently in a multiplayer game.

The user cancelled the join flow before it was completed.

The lobby we tried to connect to is full.

The run is already in progress, and rejoining is not implemented.

The run was loaded from a save file, and the player attempting to connect is not in the save.

The host's version does not match the client's.

You are banned from the lobby, you have blocked someone in the lobby, or someone in the lobby blocked you.

Our state, as a client, diverged from the host's during combat.

The client did not send the lobby join handshake response in time. Different from an internet timeout, as that is below the application layer.

Either the host had mods that we didn't have, or we had mods that the host didn't have.

Couldn't connect to the session, likely because of internet issues.

Connection timed out.

Internal error, like an exception or a similar local bug.

Network issue that we are not sure how to diagnose.

Too many attempts to do the same thing. Player should try again in a bit.

Generic transient issue. Player should try again later.

Hosting the game failed.

Couldn't make secure connection (Steam BadCert and BadCrypt). Most common cause is out-of-sync clocks.

Contains information about why a network operation failed, or why we disconnected from a multiplayer session. Prefer passing this instead of NetError, as this contains more information about the underlying error that might have been mapped to our NetError.

Returns a disconnection reason mapped from the underlying transport disconnection reason.

Returns a string with more human-readable details about the underlying cause of the disconnection. This is suitable for displaying to users as long as platform requirements allow plain error codes in messages.

Returns a string that should not be displayed to the user. Use this in debug logs.

All the combat-relevant state from the Player class. Includes most state except: - Rewards and Shop RNG counters (stripped out in FromRun) - Rarity odds

Serializable version of PlayerChoiceResult, representing the result of a choice the player made mid-combat.

Used in multiplayer to sync which screen the player is on.

Whichever room is the current room (e.g. the combat room, or the rest site).

Map screen.

Settings screen.

Compendium screen.

Deck view screen.

Any combat card pile screen (exhaust, draw).

Simple card view screen, e.g. when viewing cards that were transformed by Rebirth

Any card selection screen (Survivor card selection, smith card selection, event card selection).

Run history screen shown at the end of a run.

The Pause menu (ESC during gameplay).

Any reward offer screen.

The send feedback screen.

The shared relic picking screen at the treasure room.

The expanded state displayed when a remote player is clicked.

The state of the multiplayer game that the client is joining.

Extra fields that are used for specific pieces of content per-player.

The number of times the player has removed a card from their deck in the card shop. The card removal price increases each time, so we need to track this across the whole run.

Points earned in the event. We can't save these immediately to SerializableProgress because, otherwise, the player would be able to exit the client, reload the event, and accumulate more points. We can't write to SerializableProgress and wait for something else to save it, because it only saves at the end of a run. So, we have to save this to the run data and let SaveManager accumulate the points into SerializableProgress at the end of the run.

Whether or not the player unlocked the CCCCombo badge.

How much damage the player dealt, aggregated among all combats.

How many debuffs the player applied to enemies, aggregated among all combats.

Player-scoped RNG set. Note that this state is not deterministic outside of combat, events and rest sites This is initialized with a seed of 0, but is updated to a real seed when added to a .

Player-scoped odds set. Note that this state is not deterministic outside of combat, events and rest sites. This is initialized with a seed of 0, but is updated to a real seed when added to a .

Player-scoped relic grab bag. See for the difference between this and the shared grab bag. Note that this state is not deterministic outside of combat, events and rest sites.

The set of unlocks the player entered the run with. This serves several purposes: - In multiplayer, this keeps track of each player's unlocks so that we generate only cards/potions/relics that the player has unlocked. - In both singleplayer and multiplayer, unlocking epochs outside of the run does not change the unlocks in a run that you load. The unlocks are saved into the run save file.

The state of the run that the player is in. Will usually be an instance of , but will be in some spots for testing, debugging, or one-off combat scenarios. You should never have to check for this though, as should always behave appropriately.

This is almost equivalent to Creature.IsAlive, except for a brief period of time between when the player's HP reaches zero and when DieInternal is called. It is used to allow hooks that prevent death to run before the player is fully considered dead. This is on Player and not Creature because monsters use a different mechanism for death prevention. Since creatures are always removed from combat after they are fully dead, their powers are always iterated, and we rely on creature removal to remove their powers from Hook. Players are different - they stick around after they are fully dead, and so we rely on this flag to stop model iteration.

Get this player's Osty pet Creature. If Osty is not in combat, this will return null. If Osty is dead, this will return the dead Osty Creature instance. Note: If you want to check that Osty is both present in combat and alive, use . If you want to check that Osty is missing from combat or dead, use .

Is Osty present in combat and alive?

Is Osty missing from combat or dead?

The player's character's max ascension level when the run started. We need to keep track of this in order to properly show the "ascension unlocked" message when winning a run.

Has this player's inventory been populated? A player object is initially created unpopulated, but the various populating methods should be called before the run they're in has fully been launched.

Create a new player for use at the start of a new run. The player's inventory will be populated with the chosen character's starting cards, relics, etc., but these models will not work properly until the player is added to a and/or .

The set of unlocks the player entered the run with. ID for uniquely identifying this player in multiplayer games. The type of the character that the player is playing as. A new player with an empty inventory.

Create a new player for use at the start of a new run. The player's inventory will be populated with the chosen character's starting cards, relics, etc., but these models will not work properly until the player is added to a and/or .

The character that the player is playing as. The set of unlocks the player entered the run with. ID for uniquely identifying this player in multiplayer games. A new player with an empty inventory.

Load a player from a SerializablePlayer. The player's inventory will be populated with the cards, relics, etc. from the SerializablePlayer., but these models will not work properly until the player is added to a and/or .

NEVER CALL THIS! Only RelicCmd.Obtain and save/load stuff should be calling this.

Relic to add. Index at which relic should be inserted. -1 means at the end. If true, RelicObtained will not be called.

NEVER CALL THIS! ONLY RelicCmd.Remove should be calling this.

Relic to remove. If true, RelicRemoved will not be called.

NEVER CALL THIS! ONLY RelicCmd.Melt should be calling this.

Relic to melt.

Get one of this player's relics. If the player has multiple of the same type of relic, just get the first one. If the player has none of this type of relic, returns null.

Type of relic to get. Matching relic.

Returns the slot index of the potion in the player's belt, or -1 if it is not in the belt.

Returns the potion at the slot index, or throws if the index is out of range.

Increases the maximum amount of potions the player can hold.

The increased count of maximum amount of potions the player can carry.

Decreases the maximum amount of potions the player can hold.

The decreased count of maximum amount of potions the player can carry.

NEVER CALL THIS! ONLY save/load stuff should be calling this.

The new maximum amount of potions the player can carry.

NEVER CALL THIS! ONLY PotionCmd.Procure and save/load stuff should be calling this.

Potion to add. Slot at which to add the potion. If -1, the potion will be added in the first available slot. If true, no events will be called.

NEVER CALL THIS! ONLY PotionModel.Discard should be calling this.

Potion to discard. If true, PotionDiscarded will not be called.

NEVER CALL THIS! ONLY PotionModel.Remove should be calling this.

Used potion to remove.

Populates the character's starting deck to start a new game.

Populates a player's existing deck. This can be from a multiplayer sync or from a save file.

Cards to load. Whether or not to emit events. If loading from a multiplayer sync, we don't want to emit events.

Loads a player's existing relic set. This can be from the player's starting relics, from a multiplayer sync, or from a save file.

Relics to load. Whether or not to emit events. If loading from a multiplayer sync, we don't want to emit events.

Loads a player's existing potion set. This can be from a multiplayer sync or from a save file.

Cards to load. Whether or not to emit events. If loading from a multiplayer sync, we don't want to emit events.

Resets the player's combat state to an empty state. This will leave the player with no cards in combat, so you should usually call after.

Populates the player's combat state with everything they should get at the start of combat. For example, this clones all the cards from their deck into their draw pile in a random order.

Revives the player before the combat ends, in multiplayer only. Should only trigger when combat ends with other players alive. It is very important to do this _before_ combat ends instead of after. If the player is still dead during HookBus.AfterCombatEnd, their relics will not be subscribed to the HookBus, and relics which rely on AfterCombatEnd to reset state will not be reset for the next combat. See: Centennial Puzzle, Captain's Wheel, or any other relics that use AfterCombatEnd.

Called after combat ends, giving the player the opportunity to do things like clear out their combat state and other combat teardown stuff.

Called from Creature when the player reaches zero health, after all hooks that prevent death are called, as well as .

Called from Creature when the player changes from a dead state to a non-dead state. This is _not_ called in the scenario when death is prevented, e.g. by Fairy in a Bottle. Likely only called in multiplayer scenarios - players cannot revive in singleplayer (remember that death prevention is different).

The turn number that this player is currently on. This is different from ; if a player takes an extra turn after their current one, this will be incremented, while the round number will not. This number can also be different between players in multiplayer. If one player takes an extra turn (due to an effect like ), their turn number will increment, but other players' will not. This starts at 1, so it should never be 0.

The current phase of this player's turn. when combat is not in progress and during the enemy's turn. See for the meaning of each phase. Managed by and .

Increment this player's current turn number. See for details on turn number versus .

NEVER CALL THIS! ONLY and save/load stuff should be calling this.

Pet to add.

Get one of this player's pets. If the player has multiple of the same type of pet, just get the first one. If the player has none of this type of pet, returns null.

Type of pet to get. Matching pet.

The reason that we are unable to add potions to a player

An instanced power adds a new instance of itself when it's applied, rather than stacking on existing instances. For example, is instanced, since if you play a second , you want another power ticking down from 3.

Creates one instance per applier. Additional applications from the same applier stack onto that applier's existing instance rather than creating a new one. For example, needs individual instances for each player that applies it, BUT instances from the same player should stack

Amount is visible, and must be manually incremented/decremented via an action.

Amount is hidden, and is always 1.

Heals the player's creature and offers rewards if applicable. This is public because calls it for mimicking rest site heals (for example, for 's Rest option).

Called when a targetable node (rest site character, player state display) is hovered.

Called when a targetable node (rest site character, player state display) is unhovered.

Translates a node target to a player. The node target can be a character at the rest site or a remote player's state display at the top-left.

Base config class for rest site button options.

Whether this option is usable or not. You can still hover it for info.

Generates a list of rest site options to use for the next rest site. This list will include extra options added by models like the Shovel relic if the player has them. Calling this may increment RNG counters and make other run state changes.

List of rest site options.

Logic to run when this option is selected.

Whether or not the option was "successful". Usually true, but false in certain cases (like if Smith is chosen and no upgradable cards are available).

Runs only for the owning player after the option is selected.

Runs only for non-owning players after the option is selected.

After the alternate reward button is pressed, end card selection, but don't complete it - the player may re-enter card selection. Used for the skip button.

After the alternate reward button is pressed, end card selection and complete the card reward - the player may not go back and select the reward. Used for the Sacrifice button.

After the alternate reward button is pressed, nothing happens. The reward screen stays up and the player is allowed to select a reward. Used when card rewards are rerolled.

This is only null if type is Skipped.

Generates a relic fight and returns it as a relic picking result. The relic fight follows these rules: - It's a rock-paper-scissors game. - Each round, each player rolls a move using the generateMove function that is passed. - If there are not exactly two distinct moves rolled, then the round ends in a tie. - If there are two distinct moves rolled, everyone who rolled the losing move is eliminated. - The game plays rounds until there is only one player left, who is awarded the relic.

The players involved in the fight. The relic that will be awarded to the winning player. Method that is called once per player every round to generate moves for each player. The result of the fight. The `fight` member is guaranteed to be non-null and contain at least one round.

A single player voted for the relic, and that player received the relic.

Multiple players voted for the relic. The details of the fight are in the fight member.

No player voted for the relic. The player that received it was a loser of a fight.

No player voted for the relic, and no player got the relic because they skipped over it.

Enemy was spawned at combat start, and their HP bar should animate in after a randomized small delay

Enemy was spawned in a new space during combat, and their HP bar should animate in immediately, but slowly

Enemy already exists and we're animating its HP bar in from a hidden state

Represents how visible a piece of content (RelicModel, PotionModel) is to the player.

Invalid sentinel value.

The content is both unlocked and has been seen by the player in a run.

The content has been unlocked, but has not yet been seen by the player in a run.

The content is locked (behind an epoch) and cannot be seen.

Some UI elements are shared between screens in multiplayer UI. This enumeration describes what mode they should be placed in depending on what screen is currently open.

Invalid!

We are starting a new singleplayer game. Max and preferred ascension is per-character. Custom modifiers are modifiable.

We are hosting a new multiplayer game. In multiplayer, preferred ascension is per-player. Max ascension is the minimum of the ascensions of all the players in the lobby. The player is able to change the ascension and any custom modifiers.

We have joined a new multiplayer game. In client mode, the player is not able to change the ascension or custom modifiers. When the host changes either the clients simply reflect what the host has set.

We have either hosted or joined a multiplayer game loaded from save file. When loading a multiplayer game, no players are able to change any run data. Note that this does not include singleplayer loads - those simply go straight to the run with no intermediate screen.

Represents a cell on the grid for the Crystal SphereMinigame

If true, then this cell is still obscured by fog.

The items that are on the grid for the Crystal Sphere minigame

Places an item randomly on the minigame's grid

Returns true if this coordinate is a valid place to put this item

Grid we are doing the placement on Potential X coord we are validating Potential Y coord we are validating

Set of items on the grid

Items revealed by the player. Rewards for these items are given to the player once the minigame is completed

The cell that we are currently hovered over.

The cells that are highlighted on the board. This is separate from HoveredCell because we can highlight multiple cells at once depending on the tool

Ends the minigames early. Used if the event is force closed via save/quit or closing the application

Decreases the FogValue of a CrystalSphereCell at the given x,y coordinate by amount

X coordinate the cell we want to affect is at Y coordinate the cell we want to affect is at

Returns if all the cells an item occupies are visible

The item we are checking is fully visible

The standard event layout type. At the time I wrote this (10/1/2024), this layout aligns text and buttons to the right side of the screen. It shows full-screen static art in the background, with the focal point on the left side of the screen.

An event layout type that looks like a combat, with the players on one side and monsters on the other. No other elements of combat (cards, health bars, etc.) appear in these events, they just look like combat.

The event layout type used for the Ancients at the beginning of acts. At the time I wrote this (10/1/2024), this layout aligns text and buttons to the bottom-middle of the screen. It shows a Spine animation in the background, with the focal point on the tip-middle of the screen.

A totally custom scene. We use this when we want to show events that don't follow any standard layout.

Create a new event option.

The event that this option belongs to. The function that will run when the option is chosen. Option title. Option description. Localization key prefix for this option. Does not include ".title" or ".description". HoverTips that should be shown when hovering this option.

Create a new event option.

The event that this option belongs to. The function that will run when the option is chosen. Localization key prefix for this option. Does not include ".title" or ".description". HoverTips that should be shown when hovering this option.

Create a new event option.

The event that this option belongs to. The function that will run when the option is chosen. Localization key prefix for this option. Does not include ".title" or ".description". HoverTips that should be shown when hovering this option.

Create a new event option.

The event that this option belongs to. The function that will run when the option is chosen. Localization key prefix for this option. Does not include ".title" or ".description". Whether this option should be disabled after clicking it. Usually true, but false for options that have a confirmation dialog that can be canceled, so the option can be re-clicked after. Whether this option is a "proceed" button. HoverTips that should be shown when hovering this option.

Associates a relic with this event option. Should be called on custom ancient event options that give relics so that they show up in the correct category in the relic library.

Associates a relic with this event option. Should be called on custom ancient event options that give relics so that they show up in the correct category in the relic library.

Typically, the title of the event is used for the name shown in the run history and uploaded to metrics. This method overrides the name used.

Causes the event option to flash red if the player's HP is below the damage value passed.

Causes the event option to flash red if the player's Max HP is below the value passed.

Causes the event option to flash red when the passed function returns true.

Certain event options have dynamic titles that vary based on the DynamicVars passed to the loc string. By default, LocString DynamicVars are not saved to the save file. If this is called, those variables will be saved to the run history so that the title can be correctly displayed. This should only be used with specific events, as saving variables often saves lots of unnecessary data.

Gets a random selection of elements from an IEnumerable.

Type of elements in the IEnumerable. IEnumerable to get random elements from. Maximum number of elements that should be in the new IEnumerable. Random number generator to use for shuffling. New IEnumerable with random elements.

Adds a random Shuffle method to any List. https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle This shuffle is "stable", meaning the result is independent of the initial order of the list. If two lists containing the same items in different orders are shuffled, the results will always be the same, so long as the passed rng is the same.

Type of elements in the list. List to shuffle. Random number generator to use for sorting Self.

Adds a random Shuffle method to any List. https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle This shuffle is "unstable", meaning the result is dependent on the initial order of the list. If two lists containing the same items in different orders are shuffled, the results may be different even if the passed rng is the same.

Type of elements in the list. List to shuffle. Random number generator to use for sorting Self.

Determines the index of a specific item in the IReadOnlyList.

The IReadOnlyList to locate the object in. The object to locate in the IReadOnlyList. Type of elements in the list. The index of if found in the list; otherwise, -1.

Finds the first index of an item that matches the specified predicate in the IReadOnlyList.

The IReadOnlyList to locate the object in. The Predicate{T} delegate that defines the conditions of the element to search for. Type of elements in the list. The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, -1.

Creates a card to display to the player at the merchant. Takes in a card type, and rarity is rolled.

The player for which we're creating cards to display. The cards to pull from. The card type to generate.

Creates a set of cards to display to the player at the merchant. The rarity of cards are affected by the source.

The player for which we're creating cards to display. The cards to pull from. The card rarity to generate. This rarity may be modified by hooks.

Creates a set of cards for the player to choose 1 from. The rarity of cards are affected by the source.

The player for which we're creating rewards. How many choices to offer (usually 3). The options to use when creating the cards.

Get a set of distinct cards for use in combat generation effects like Attack Potion or Discovery.

The owner of the newly created cards. Cards to choose from. Number of cards to get. RNG to use. Mutable cards owned by the player and created within its combat state, for combat generation effects.

Get a set of cards for use in combat generation effects like Calamity. Can include multiple of the same card, unlike .

The owner of the newly created cards. Cards to choose from. Number of cards to get. RNG to use. Cards for combat generation effects.

Filter out cards that should not be included in combat card generation effects like Attack Potion or Discovery.

Cards to filter. Cards for combat generation effects.

Get the default set of cards that the specified card should be able to be transformed into.

Card that will be transformed. Whether the transformation is happening in combat. The set of cards that the card can be transformed into.

Create a random potion while out of combat. This can get any potion from the valid potion pools, including potions that can do restricted things like heal the player.

Player to create a potion for. RNG to use to determine what potion to create. Canonical potions that should be blocked from being generated. Newly-created potion.

Create random potions while out of combat. This can get any potion from the valid potion pools, including potions that can do restricted things like heal the player.

Player to create a potion for. How many potions you want to generate. RNG to use to determine what potion to create. Canonical potions that should be blocked from being generated. Newly-created potion.

Create a random potion while in combat. This can get any potion from the valid potion pools, except potions that cannot be generated in combat (like healing potions).

Player to create a potion for. RNG to use to determine what potion to create. Canonical potions that should be blocked from being generated. Newly-created potion.

Roll rarity and pull the next matching relic from the front of the list. The pulled relic will never be seen again on this run. Used by most relic reward sources (elite combat rewards etc).

RelicModel

Pull the next matching relic from the front of the list. The pulled relic will never be seen again on this run. Used by most relic reward sources (elite combat rewards etc).

The player for which we're obtaining a relic. Rarity of the relic we want. Filter for what relics are allowed. RelicModel

Roll rarity and pull the next matching relic from the back of the list. The pulled relic will never be seen again on this run. Used in shops.

The player for which we're obtaining a relic. RelicModel

Pull the next matching relic from the back of the list. The pulled relic will never be seen again on this run. Used in shops.

The player for which we're obtaining a relic. Rarity of the relic we want. Only relics that match the filter will be allowed to be returned. RelicModel

Responsible for pulling actions from the PlayerActionQueueSet and executing them.

WARNING: You probably want to use CombatManager.Pause() instead. Only use this if you want to pause player actions WITHOUT pausing the rest of combat. Pause the ActionQueue.

WARNING: You probably want to use CombatManager.Unpause() instead. Only use this if you want to un-pause player actions WITHOUT un-pausing the rest of combat. Unpause the ActionQueue.

Returns a task which finishes execution when there are no tasks left to execute. If there is no currently executing task, then this returns a completed task.

Cancel the whole queue.

This action is enqueued when the player chooses to discard a potion from their belt. It runs both in combat and outside of combat.

True if the player discarded a potion in combat, false otherwise. The player may discard a potion at any time. However, there's a specific situation in which order of GameAction enqueues matters when out-of-combat: if the player discards a potion post-combat while another player is still executing the player turn. If the action is set to GameActionType.Any, it will be executed during combat, before the enemy turn.

This action is enqueued when the player presses the "End Turn" button in the UI. It begins the process of ending a player's turn. Notes: * This action only marks the player as ready to end turn, and encapsulates only that action. It does not block the queue while turns are ending. * SwitchSidesAction is enqueued after this one, and acts as a synchronization point for players who are ready to enter phase 2 of turn ending.

A GameAction is a thin wrapper around an async task that should be run in response to player input. THIS IS DIFFERENT from GameActions in STS1 (and the original Unity version of STS2). In STS1, a GameAction represented a small unit of game logic, like dealing damage, gaining block, etc. In STS2, these small units of logic are handled by Commands (see the MegaCrit.Sts2.Core.Commands namespace). A GameAction WRAPS these commands, and should ONLY be used for player input. Examples of things that SHOULD be wrapped in a game action: * Playing a card. * Drinking a potion. * Clicking the "end player turn" button. Examples of things that should NOT be wrapped in a game action: * Dealing damage (this can happen as PART of a game action, but never directly from player input). * Gaining block (same reason). * Applying a power to a creature (same reason). * A monster making a move (once the player's turn ends, monster moves are run in sequence. They wait on each other to execute, but never on player input, so no GameActions are necessary).

The type of game action, which dictates cancellation and enqueuing timings. See comments in the enum for details.

Called when the GameAction is fully run to completion, but just before we complete _completionSource. This timing is important for checksum generation.

Called when the GameAction is fully run to completion.

Called just before the GameAction begins execution for the first time. Not called when the GameAction is resumed.

Called when the GameAction is cancelled.

Called when the GameAction is paused for player choice.

Called when the GameAction is ready to resume after player choice.

Called when the GameAction resumes execution after player choice.

Use this to wait for the GameAction to be fully completed.

See CombatManagerMultiplayerTest.

An action enqueued by the host after all players have issued a vote at the map screen. This needs to be enqueued, instead of depending on everyone picking the same map point, because a random map point may be chosen in the event that two or more map points receive the same number of votes. We do not depend on RNGs being deterministic outside of combat.

Contains one action queue per player. We use multiple action queues to resolve the following scenario: - One player queues up three or more card plays, the second of which requires player choice - Their queue blocks on the player choice. The third action awaits completion of the player choice - Other players may freely queue card plays to their queues and have them executed

Only use this if you really know what you're doing! Improper use can lead to state divergence. Enqueues an action directly to the owner's action queue.

The action to enqueue.

Returns true if a GameAction is player driven, false if it is emitted automatically. If this ends up being used in a few different places, it can be moved somewhere else; for now, it's obscure enough that it should only be used here.

Returns the next action on top of a player's queue that should be executed. Selection works like this: - If any player's queue is awaiting a player choice, then that queue is skipped. - Otherwise, we return the action with the minimum ID (the first queued by the host) at the top of any player's queue. This method should not be called when an action is already being executed.

Pauses an action for player choice. The action will be removed from the ActionExecutor and a new action will be allowed to execute, if there are any actions that are ready. To resume the action after this is called, call RequestResumeActionAfterPlayerChoice.

The GameAction to pause. Whether to cancel card play actions that enter the queue while obtaining player choice. Thrown if the action is not at the front of the owner's action queue.

Returns a task which completes when all player queues are empty. Be careful of running this in tests that involve player choice! If actions are not resumed, the task will never complete.

Pauses execution of all actions on all player queues, including those that are queued after this is called. Note that this does not pause execution of the currently executing action - only those that come after it.

Cancels all manual combat actions that are enqueued to all queues. Manual combat actions are any GameActions that have ActionType != GameActionType.NonCombat and ActionType != GameActionType.Any, and are manually played by the player (i.e. everything except for GenericHookGameAction and ReadyToSwitchToEnemyTurnAction). The flag becomes unset when either PauseAllPlayerQueues or UnpauseAllPlayerQueues is called. See the comments in EnqueueWithoutSynchronizing for why this is necessary.

Returns true if the action queue for the given player is paused.

Resumes execution of all player queues without synchronization. It's fine to call this at the end of combat, but call this very carefully during combat, as incorrect usage can lead to state divergences.

Cancels all combat actions on the queue and continues cancelling them until CombatStarted is called.

Allows combat actions to be added to player queues.

Cancels all non-executing actions for a specific player's queue.

Cancel all queued actions of the specified type owned by a specific player. Used when we are selecting a card, e.g. for Survivor, but cards have been queued up for play. Note that this does not cancel the action at the front of the queue if it is executing. This is private because the timing must be synchronized with action enqueues across peers.

Type of actions to cancel. The owner of the actions to cancel. If non-null, only actions with ID less than this value will be cancelled.

Resumes a GameAction after a player choice. This should never be called anywhere other than ActionQueueSynchronizer.

Obtains an action by its ID.

Obtains an action queue by its owner's ID.

Removes an action from the front of its owner's queue. Should be called when an action finishes execution.

Used in replays so that we start with the correct action ID when replaying actions.

The ID to assign to the next action.

Checks if all action queues are empty and sets the completion source for tests that wait.

Called when an action is enqueued or resumed. It is extremely important that this message is called deterministically across all peers. Action IDs are not synchronized across the network; since all action messages (enqueue/resume) are received in the same order that they are sent, we can trust that all peers will generate the same action IDs. Note that we re-assign an ID to an action when it becomes ready. The reason we do this is to avoid subtle timing bugs with message ready timings. Re-assigning the ID to an ID that is greater than all actions currently in the queue ensures that the existing actions in the queue will execute in a deterministic fashion, and the newly ready action will execute after them.

Responsible for synchronizing actions across all peers in a deterministically-ordered manner.

This list contains actions that were queued during the enemy turn or draw phase, but can only be executed during the player's play phase.

Next ID assigned to hook actions. Exposed only so the combat replay writer has access to it.

Current combat state. Dictates the paused state of queues.

Call this when combat begins, ends, or the turn changes within combat. Certain actions, like card plays or potion usages, should always occur after the hooks that execute at the start of the player turn. However, the player is able to queue these actions before their turn actually starts. The synchronizer holds onto those actions until the start of the player turn, and then it sends all of them out.

The new combat state.

Main entry point for enqueueing a GameAction. If you are the host, the GameAction is directly enqueued, and a message is sent to notify clients about the action. If you are the client, the GameAction is not enqueued. Instead, a message is sent to the host to request that the action be enqueued. The host sends back a confirmation, preserving ordering of the action queues.

Requests that a GenericHookGameAction be enqueued. Hook game actions are a little different than normal game actions. They contain arbitrary logic that is executed as part of a hook. Since hooks are executed on all peers, we can identify the actions by an incrementing ID. If on host, the action is immediately enqueued and a message is sent to clients. If on client, a message is sent to the host, and the host sends a message back to confirm that the message is enqueued.

Requests that an action, paused for player choice, be resumed. If on the host, the action is immediately resumed and a message is sent to clients indicating this. If on a client, a message is sent to the host to ensure correct ordering, and the host sends a message back to confirm resumption of the action.

The GameAction to resume.

Resumes a GameAction after a player choice. This call is synchronized, so it should only be called from the host or in response to messages.

Called on the host when a client wishes to resume an action after a player choice is made.

Called on the client when a host resumes an action.

This should only ever be called outside this class in replay playback!

For use when we don't care if player choice blocks the task. In almost all combat-related scenarios, we use HookPlayerChoiceContext to unblock other player queues when a player choice is made. However, there are several scenarios in which we can't do so: - Relic AfterObtained callbacks. The only way these can occur during combat is via console. - Enemy turn. When it's the enemy turn, we want to block the rest of the enemy turn from executing until after the player has finished making their choice. This should only happen in very rare circumstances, like when Centennial Puzzle triggers, drawing a Seeking Strike which is then autoplayed via Hellraiser. In all other circumstances, you should prefer either HookPlayerChoiceContext or ThrowingPlayerChoiceContext, depending on the situation.

A player choice context for use in hooks that do not run as part of a GameAction. When player choice is required, a new game action is created and enqueued directly to the player's action queue. From there, flow proceeds like a normal game action. No game action is created if player choice is not requested.

The GameActionType to assign to the GameAction generated by this context, if any. Currently, only Combat and CombatPlayPhaseOnly are supported. Many hooks can execute outside of the player turn. For example, we allow the following: - Centennial Puzzle triggers on the enemy turn - Hellraiser triggers Seeker Strike - Seeker Strike causes a player choice However, for actions that start just before the player turn, we must wait until the player turn before executing them. Otherwise, we may run into ordering issues on remote players. For full context, see the HookPlayerChoiceContextTest.

Most hooks take a PlayerChoiceContext as an argument and return a Task. However, this player choice context must know about the task in SignalPlayerChoiceBegun, when it is time to create a GameAction. There is no way to pass the Task to this method in the constructor, as the Task is not created yet. Thus, this method should be called after the hook returns the Task, for two reasons: - To assign the Task to this context - To wait for the synchronous parts of the hook to complete

True if the task was completed, false if it was paused.

ONLY USE THIS IF YOU KNOW WHAT YOU'RE DOING! This waits for the task to complete, _or_ for some content in the task to call SignalPlayerChoiceBegun. In most cases, AssignTaskAndWaitForPauseOrCompletion should be used. This should only be used when we don't yet have the full task to assign to the GameAction that would be generated during SignalPlayerChoiceBegun.

True if the task was completed, false if it was paused.

At the end of all hooks that involve models, the ExecutionFinished event must be executed to update some visuals for things that are listening to changes to the model. This task wraps the hook and calls ExecutionFinished at the end of it, if a model is involved with the hook.

A stack of models that are involved with this choice context. A model can invoke other models to do some work, and those models can invoke a player choice. For example, a may autoplay a Sly'd . In these cases, when we display the context to remote players, we want to show the as the model that is involved in the choice, not the .

Add a new model to the top of the context stack. For example, while is executing, it will be at the top of the context stack. If it discards a card with , then the Sly'd card should be pushed to the top of the context stack.

Synchronizes player choices that are gathered in the middle of a model's execution. Examples: * The card picked for discarding when playing Survivor * The card chosen to add to hand when playing Discovery * The card chosen to add to hand at the beginning of combat from Toolbox The basic scheme here is: * All players (local and remote) generate an ID for the selection. * The owning player brings up the card selection UI on their side. * Once the owning player has made a choice, they send a message to all other players with the selection ID indicating what they chose.

Reserves a choice ID to be passed to SyncLocalChoice or WaitForLocalChoice. If called during combat, this must be done in a deterministic context (i.e. before a GameAction is paused) so that checksums match up after action execution. SyncLocalChoice and WaitForRemoteChoice can be called outside of deterministic contexts (i.e. while a GameAction is paused and executing locally).

The player for which the choice ID will be reserved.

Sync a locally-chosen player choice with other peers. This should be called whenever a player choice is made by the local player. In tandem, WaitForRemoteChoice should be awaited on all remote peers.

The player that chose the player choice. Should always be the local player. The ID of the choice, reserved through ReserveChoiceId. The result of the player choice.

Waits for a choice to be received from a remote peer. This should be called on all remote peers whenever we expect a player choice to be made. On the machine of the player who is making a choice, SyncLocalChoice should be called.

The player for whom we are awaiting a choice. The choice ID to await, obtained through ReserveChoiceId. The result of the player choice that was made.

For use when we are quite certain that no path will ever result in a player choice call deeper in the callstack. This is currently used in a few scenarios: - In events, where we're out-of-combat, and so player choice cannot occur. - In tests where we are certain that calling a cmd will not trigger a player choice. - In Sleight of Flesh Power's trigger, to prevent having to pass PlayerChoiceContext to PowerCmd.Apply. (This could change if we find out that player choice can be triggered in that scenario.)

Enqueued when a player picks a relic at a multiplayer treasure room.

Used to inject a relic picking synchronizer in tests.

Get the creature that this action is targeting. Null for un-targeted cards.

We override this to handle the case where some external action (like showing the hand selection screen) needs to cancel queued card plays.

Represents the result of a choice that the player makes while playing a card or using a potion. For example, it could contain the choice of card to discard during a Survivor play, or the choice of card to add to hand at the beginning of combat from Toolbox.

Returns the selection assuming that it was a single canonical card. Will be null if the player skipped the choice.

Thrown if the selection was not a canonical card.

Returns the selection assuming that it was a collection of canonical cards.

Thrown if the selection was not a collection of combat cards.

Returns the selection assuming that it was a collection of combat cards.

Thrown if the selection was not a collection of combat cards.

Returns the selection assuming that it was a collection of deck cards.

Thrown if the selection was not a collection of deck cards.

Returns the selection assuming that it was a single mutable card without owner. Will be null if the player skipped the choice.

Thrown if the selection was not a mutable card without owner.

Returns the selection assuming that it was a collection of mutable cards without owners.

Thrown if the selection was not a collection of mutable cards without owners.

Returns a set of card models based on the type passed.

The type of selection that the remote player chose. Thrown if the selection was not of the passed type.

Returns the selection assuming that it is a player.

Thrown if the selection was not a player.

Returns the selection assuming that it is a non-null index.

Thrown if the selection was not an index.

Returns the selection as an index, or null if there is no index.

Thrown if the selection was not an index.

Returns the selection assuming that it is a list of indexes.

Thrown if the selection was not a list of indexes.

Generates a player choice result from a serialized network data. Remember that player choices may involve cards that are created within combat! For example, if a remote player plays a Survivor which discards a Shiv that was just created using a Blade Dance, it is possible to receive an exception from this method if it is called at a point before the Shiv was created. It is the responsibility of the caller to ensure that this is not the case.

This action indicates that the player is ready to proceed to phase two of the end of the turn, where player state cleanup and switching to the next side occurs. It comes after EndPlayerTurnAction. Note that this action is automatically enqueued without player intervention.

This action is enqueued when the player presses the "End Turn" button in the UI. It begins the process of ending a player's turn. Notes: * This action only marks the player as ready to end turn, and encapsulates only that action. It does not block the queue while turns are ending. * SwitchSidesAction is enqueued after this one, and acts as a synchronization point for players who are ready to enter phase 2 of turn ending.

Constructor to use for constructing the UsePotionAction outside of serialization.

The potion which will be used. The target which the player is using the potion on. Pass null if the potion is not targeted. Pass true if the potion was played during combat. The GameAction will be cancelled at the end of combat if it is still enqueued.

Constructor to use when deserializing a NetUsePotionAction. Should not be used in other circumstances.

The player who sent us the action. The index of the potion that will be used. The combat ID of the target. The NetID of the player that is targeted, if the potion was used outside of combat. Whether or not combat was in progress when the potion was used.

An action enqueued at the map screen when the player picks/votes for a map coord to move to. Once all players have selected a map coord, the host decides which map coord to move to based on the votes. It then enqueues MoveToMapCoordAction which triggers entering the room. This action may be enqueued multiple times with the same origin location, and should overwrite which coord the owning player is voting for. If it is enqueued after MoveToMapCoordAction has already been executed, then it should be ignored.

The player who is voting.

The location that the player is currently at while casting the vote.

The player's vote. If null, any existing votes for the player should be cancelled.

An action enqueued at the rewards screen when the player is ready to move to the next act. Once a player receives actions from all other players indicating that they're ready to move to the next act, then the player should begin transitioning to the next act.

The player who is voting.

Return a different value depending on whether the given ascension is higher or lower than the current ascension of the run.

The value that we use for ascensions below the ascensionThreshold The value that we use for ascensions above the ascensionThreshold The value that we use for ascensions below the ascensionThreshold

4:3

21:9

Used for safe floating point comparisons with pixel values on a 4K screen.

Easing function enums

Constant Pi.

Constant Pi / 2.

Interpolate using the specified function.

Modeled after the line y = x

Modeled after the parabola y = x^2

Modeled after the parabola y = -x^2 + 2x

Modeled after the piecewise quadratic y = (1/2)((2x)^2) ; [0, 0.5) y = -(1/2)((2x-1)*(2x-3) - 1) ; [0.5, 1]

Modeled after the cubic y = x^3

Modeled after the cubic y = (x - 1)^3 + 1

Modeled after the piecewise cubic y = (1/2)((2x)^3) ; [0, 0.5) y = (1/2)((2x-2)^3 + 2) ; [0.5, 1]

Modeled after the quartic x^4

Modeled after the quartic y = 1 - (x - 1)^4

Modeled after the piecewise quartic y = (1/2)((2x)^4) ; [0, 0.5) y = -(1/2)((2x-2)^4 - 2) ; [0.5, 1]

Modeled after the quintic y = x^5

Modeled after the quintic y = (x - 1)^5 + 1

Modeled after the piecewise quintic y = (1/2)((2x)^5) ; [0, 0.5) y = (1/2)((2x-2)^5 + 2) ; [0.5, 1]

Modeled after quarter-cycle of sine wave

Modeled after quarter-cycle of sine wave (different phase)

Modeled after half sine wave

Modeled after shifted quadrant IV of unit circle

Modeled after shifted quadrant II of unit circle

Modeled after the piecewise circular function y = (1/2)(1 - Mathf.Sqrt(1 - 4x^2)) ; [0, 0.5) y = (1/2)(Mathf.Sqrt(-(2x - 3)*(2x - 1)) + 1) ; [0.5, 1]

Modeled after the exponential function y = 2^(10(x - 1))

Modeled after the exponential function y = -2^(-10x) + 1

Modeled after the piecewise exponential y = (1/2)2^(10(2x - 1)) ; [0,0.5) y = -(1/2)*2^(-10(2x - 1))) + 1 ; [0.5,1]

Modeled after the damped sine wave y = sin(13pi/2*x)*Mathf.Pow(2, 10 * (x - 1))

Modeled after the damped sine wave y = sin(-13pi/2*(x + 1))*Mathf.Pow(2, -10x) + 1

Modeled after the piecewise exponentially-damped sine wave: y = (1/2)*sin(13pi/2*(2*x))*Mathf.Pow(2, 10 * ((2*x) - 1)) ; [0,0.5) y = (1/2)*(sin(-13pi/2*((2x-1)+1))*Mathf.Pow(2,-10(2*x-1)) + 2) ; [0.5, 1]

Lerps an object beyond the target destination and brings it back

Lerps an object beyond the target destination and brings it back

Lerps an object beyond the target destination and brings it back

Get the string that should be used as the prefix for a model's energy icon path. The logic here is a little more complicated than you'd expect; it's easy if it's a card in the player's deck during a run (just use the owner's card pool), but it gets trickier before the card is in the deck (like in card rewards) or outside of a run entirely (like in the card library).

Model whose energy icon we want.

Get the string that should be used as the specified model's energy icon path. The logic here is a little more complicated than you'd expect; it's easy if it's a card in the player's deck during a run (just use the owner's card pool), but it gets trickier before the card is in the deck (like in card rewards) or outside of a run entirely (like in the card library).

Model whose energy icon we want.

Get the string that should be used as the energy icon path for the specified prefix.

A generic collection that allows the caller to grab random elements with weighted probabilities.

Imagine the following code: GrabBag{string} bag = new GrabBag{string}(); bag.Add("dog", 1); bag.Add("cat", 1); bag.Add("fish", 2); bag.add("lion", 0.5); bag.add("tiger", 0.5); string result = bag.Grab(); In the above code, 5 elements are added to a grab bag with differing weights, then a random one is chosen. If the above code were run 100 times, the results should be: * "dog" approximately 20 times * "cat" approximately 20 times * "fish" approximately 40 times (twice as many as dog or cat, since it has a weight of 2 instead of 1) * "lion" approximately 10 times (half as many as dog or cat, since it has a weight of 0.5 instead of 1) * "tiger" approximately 10 times (half as many as dog or cat, since it has a weight of 0.5 instead of 1) Type of elements contained by GrabBag.

Add an element with a specified weight.

Element to add. Amount to weight the element.

Grab a random element from the bag, respecting weights.

Generator to grab the random roll from. Predicate that must be matched by the returned element. Randomly-chosen element. Null if the bag is empty.

Grab a random element from the bag, respecting weights. Remove it after grabbing.

Generator to grab the random roll from. Predicate that must be matched by the returned element. Randomly-chosen element. Null if the bag is empty.

Returns where belongs among once both are ordered by : the count of present cards (excluding the target itself) that precede the target in pile order. Callers use this to turn a backend-pile position into a child index for a container that may be missing some of the pile's cards (selected, awaiting play, or being dragged). Each absent card that precedes the target inflates the raw pile index past the target's real slot; once enough precede it the index exceeds the live child count and Godot rejects the move with "Invalid new child index" (PRG-6847). The result cannot exceed the number of present cards, so when is exactly the container's current children it is a valid child index by construction; correctness depends on the caller passing that set.

The full backend pile order. The cards whose holders are currently in the container, in any order. The card being (re)inserted. The insert index, or -1 if the target is not in the pile (caller should skip the move).

Returns the position of a card when given the total number of cards in the hand (handSize) and the index of the card you want the position of.

Returns the angle of a card when given the total number of cards in the hand (handSize) and the index of the card you want the position of.

Returns the expected Scale of a card should be based on how many cards are in your hand.

Get the path to the image with the specified "inner" path.

The image's inner path. For example, for "images/cards/bash.png", pass "cards/bash.png". The full path to the image.

Get the path to the icon for the specified map point and room type.

The type of map point that the room is in. The type of room. (Optional) The model ID corresponding to room. This is for bosses and ancients, which have unique icons. The full path to the image

Get the path to the icon outline for the specified map point and room type.

The type of map point that the room is in. The type of room. (Optional) The model ID corresponding to room. This is for bosses and ancients, which have unique icons. The full path to the image

A set of static math functions which are missing from Godot's Mathf.

Linearly scales the input value from the source range [from1, to1] to the target range [from2, to2].

Bezier Curve curve function.

Clamps a Vector2, only if both X and Y are equal values.

Gradually changes a value towards a desired goal over time.

The current value The target value The current velocity. This should start at zero, be stored somewhere, and passed to this method every frame. The approximate amount of time it will take to reach the target. Smaller values mean that we'll reach the target value faster. The last process time. Maximum speed we'll move towards the target. New value after interpolation.

Gradually changes a value towards a desired goal over time.

The current value The target value The current velocity. This should start at zero, be stored somewhere, and passed to this method every frame. The approximate amount of time it will take to reach the target. Smaller values mean that we'll reach the target value faster. The last process time. Maximum speed we'll move towards the target. New value after interpolation.

Get the color that should be used for the text in a card's energy cost. Depends on a whole bunch of tricky rules, see comments and tests for details. WARNING: If you make a change to this method, you should probably make a similar change to , or write a comment explaining why the two methods are different.

Card whose energy cost color we want. Combat state that the color depends on. Null outside of combat (like in the Card Library). Energy cost color for the specified card in the specified combat state.

Get the color that should be used for the text in a card's star cost. Depends on a whole bunch of tricky rules, see comments and tests for details. WARNING: If you make a change to this method, you should probably make a similar change to , or write a comment explaining why the two methods are different.

Card whose star cost color we want. Combat state that the color depends on. Null outside of combat (like in the Card Library). Star cost color for the specified card in the specified combat state.

Contains methods that are called as part of initialization. The methods are called both in normal startup and in test mode, so only call things that need to be done in both.

Initializes stuff that has to happen very early. This gets called in both tests and in real games!! Only do stuff that needs to happen in both here.

Essential initialization needed before main menu can display. Loads only ui_atlas and core systems (settings, mods, localization, model DB init).

Deferred initialization that can run after main menu is displayed. Loads remaining atlases and runs expensive precomputation.

Really big for games, but not big enough to come close to overflowing int!

A few utility methods for accessing types via reflection. In general, you should avoid using this, as it does not work on console platforms (or anywhere that NativeAOT is required). You can check for support with SubtypesAvailable. Only use this in scenarios where it is required (e.g. for modding).

Get the path to the scene with the specified "inner" path.

The scene's inner path. For example, for "scenes/ui/button.tscn", pass "ui/button". The full path to the scene.

Load the packed scene with the specified "inner" path.

The scene's inner path. For example, for "scenes/ui/button.tscn", pass "ui/button". The PackedScene.

Instantiate the scene with the specified "inner" path.

The scene's inner path. For example, for "scenes/ui/button.tscn", pass "ui/button". The type to cast to. Should be a descendant of . The instantiated scene.

How much we travel per scrollWheel tick. Probably better to get the expected scroll distance from the OS.

How much we travel per touchpad gesture tick.

How fast we lerp to the target position when dragging.

How close we need to be to the target position before we snap to it.

How fast we bounce back after scrolling past the edge of the screen.

Get the amount of scroll drag that should be added for a given scroll event.

Invokes with 's animation state once it exists, waiting across frames if necessary. Godot runs _Ready() bottom-up (children before parents) and a SpineSprite builds its skeleton asynchronously, so a VFX node can run before the SpineSprite it drives has created its animation state. Driving the animation state in that window throws a NullReferenceException and leaves the VFX uninitialized (PRG-6982). Use this for any animation-state setup that runs from _Ready, whether is the node's parent or a child/sibling sub-sprite. If the skeleton never loads (e.g. asset load failure, which NCreatureVisuals handles by disabling the spine), simply never runs, and a one-time warning is logged once the wait grows implausibly long. The wait also stops if or 's node leaves the tree or is freed. The sprite can be freed independently of the host (e.g. NOrb frees and recreates its sprite on orb replacement while the NOrb node itself stays in the tree).

Pattern:
([A-Za-z0-9]|\\G(?!^))([A-Z])
Explanation:
○ 1st capture group.
○ Match with 2 alternative expressions.
○ Match a character in the set [0-9A-Za-z].
○ Match a sequence of expressions.
○ Match if at the start position.
○ Zero-width negative lookahead.
○ Match if at the beginning of the string.
○ 2nd capture group.
○ Match a character in the set [A-Z].
Pattern:
(.*?)_([a-zA-Z0-9])
Explanation:
○ 1st capture group.
○ Match a character other than '\n' lazily any number of times.
○ Match '_'.
○ 2nd capture group.
○ Match a character in the set [0-9A-Za-z].
Pattern:
\\s+
Explanation:
○ Match a whitespace character atomically at least once.
Pattern:
[^A-Z0-9_]
Explanation:
○ Match a character in the set [^0-9A-Z_].


Trims whitespace, converts newlines to spaces, and squashes multiple whitespace characters in a row down to a single space.

Good for writing multi-line indented verbatim strings (https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/verbatim) and having them output in a natural way. The string to compact. A compacted copy of .

Get a deterministic hash representation of a string. Unlike GetHashCode(), it is guaranteed to be the same even across program executions. This is NOT guaranteed to be unique or cryptographically safe or anything like that. Its only guarantee is to be deterministic. Algorithm lifted from https://andrewlock.net/why-is-string-gethashcode-different-each-time-i-run-my-program-in-net-core/

String to hash. Hash value.

Returns a number as a string with radix applied based on set language. i.e. one-thousand seven-hundred fifty-five returns 1,755. However, in some languages returns 1.755. Used when we show BIG numbers in the stats screen. Maybe leaderboards, I dunno.

Helps render text like "119/670" In case there are different ratio formats in other languages.

Simple helper to capitalize the first character of a given string. Does not work with multiple words. Improve and add exceptions if its use case expands.

Removes the bbcode tags from the given string

Replaces brackets with [lb] and [rb] so they are not interpreted as bbcode tags.

Color reference class for this specific game, Slay the Spire 2. If a color is a one-off, it probably doesn't need to be live here.

Runs a task without awaiting it. Prefer using this over calling the task-returning method and then discarding the task, as that causes exceptions not to be logged.

Runs all the tasks at once and returns a task whose result is equivalent to the first task completed. Prefer using this over Task.WhenAny, as that returns a Task that is always successful.

A static class containing all of the gameplay hooks.

Iterates combat hook listeners, but yields nothing if combat is over or ending (CombatManager.IsOverOrEnding) when the dispatch begins. Most combat hooks should use this instead of directly, so a hook dispatched after combat has started ending fires for no one (for example after a Strike that Hellraiser plays automatically kills the last enemy while cards are still being drawn). The check is evaluated once, when enumeration begins, not per listener. A dispatch that begins while combat is live therefore runs every listener even if one of them ends combat partway through. That is intentional: combat teardown is deferred to the next safe point (CheckWinCondition), so the state stays intact for the rest of the dispatch, and rechecking per listener would drop the remaining ones in listener order (for example a Joss Paper increment that should still count when Charon's Ashes lands the killing blow on an exhaust). Combat setup (CombatManager.IsStarting) is exempt: IsInProgress is still false then, so IsOverOrEnding is true, but hooks that run during setup, such as the initial deck shuffle (ModifyShuffleOrder with isInitialShuffle true), must still reach listeners. A few hooks intentionally call directly because they are part of the kill, death, or combat end sequence itself, where yielding nothing would break that sequence. Each such hook documents the reason in its own summary.

See .

See .

See .

See . Dispatched directly, not through the IterateCombatHookListeners guard: it fires from the same damage event that ends combat (the killing hit), so it must still resolve for that hit.

See .

See .

See .

See .

See .

See . This takes a player choice context as an argument because it needs to block combat flow if a player choice is encountered.

See . This takes a player choice context as an argument because it needs to block combat flow if a player choice is encountered.

See .

See . This takes a player choice context as an argument because it needs to block combat flow if a player choice is encountered.

See .

See .

See . Dispatched directly, not through the IterateCombatHookListeners guard: it completes resolution of the card that caused the kill.

See .

See .

See .

See .

See . Dispatched directly, not through the IterateCombatHookListeners guard: it only fires for creatures added during combat (creatures present when combat starts take a different path, before IsInProgress is set), and a creature added while combat is ending can affect whether it should actually end, so that decision is not overridden here.

See .

See . Dispatched directly, not through the IterateCombatHookListeners guard: it fires from the same damage event that ends combat (the killing hit), so it must still resolve for that hit.

See .

See .

See .

See .

See .

See . Dispatched directly, not through the IterateCombatHookListeners guard: it runs during death resolution, which proceeds while combat is ending.

See .

See .

See .

See .

See .

See . This takes a player choice context as an argument because it needs to block combat flow if a player choice is encountered.

See . This takes a player choice context as an argument because it needs to block combat flow if a player choice is encountered.

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See . This takes a player choice context as an argument because it needs to block combat flow if a player choice is encountered.

See .

See .

See .

See .

See . This takes a player choice context as an argument because it needs to block combat flow if a player choice is encountered.

See .

See .

See .

See .

See and .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

Run the requested HP-loss-modification hook phases on . In CreatureCmd.Damage the two phases are invoked separately because damage redirection (Osty) sits between them and may change the target. Callers that have no redirection step (e.g. damage previews) should pass . See and .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See and .

See .

See .

See .

See .

See .

See .

See .

See .

See . Dispatched directly, not through the IterateCombatHookListeners guard: it runs during damage resolution, which proceeds while combat is ending.

See .

See .

See .

See .

See .

See .

See .

See .

See .

See . Dispatched directly, not through the IterateCombatHookListeners guard: it is a predicate that drives the decision of whether a creature is removed after death, so suppressing it while combat is ending would drop the votes it collects.

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See .

See . Dispatched directly, not through the IterateCombatHookListeners guard: it is a predicate that drives the decision of whether combat ends, so suppressing it while combat is ending would drop the votes it collects.

See .

See .

See .

Represents which phase(s) of HP-loss-modification hooks should be run for a given HP loss. In CreatureCmd.Damage, the two phases bracket damage redirection (Osty), so they are invoked separately with potentially different targets. Callers that don't deal with redirection (like damage previews) can use to apply both phases at once.

Hooks that modify HP loss before damage is redirected from Necrobinder to Osty. Including this will cause and to be called.

Hooks that modify HP loss after damage is redirected from Necrobinder to Osty. Including this will cause and to be called.

Include all HP-loss-modification hooks. Use when there is no redirection step between phases (e.g. damage previews).

Represents the type(s) of ModifyDamage hooks that should be run for a given instance of damage.

Additive damage hooks from effects like . Including this will cause and to be called. At the time of this writing (5/15/2026), we never use this type alone. If that changes, please update this comment.

Multiplicative damage hooks from effects like . Including this will cause and to be called. At the time of this writing (5/15/2026), we never use this type alone. If that changes, please update this comment.

Damage-capping hooks from effects like . Including this will cause to be called. At the time of this writing (5/15/2026), we never use this type alone. If that changes, please update this comment.

Include all ModifyDamage hooks. Most back-end ModifyDamage hook calls will use this.

Defines whether or now we want to word wrap the description text on the hover tip node or if we want the text to stretch the HoverTip horizontally. This is useful for situations like our map point entry hover tips in the run history screen, that can be pretty long.

Create a HoverTip from a PowerModel.

Power to create the HoverTip for. string to use in the description field. Whether or not the power description is "smart". For example, when the Strength HoverTip is displayed on the Body Slam card, it should be "dumb" because it's just referring to the concept of Strength, rather than a specific amount. On the flip side, when the Strength HoverTip is displayed when hovering over a creature with 3 Strength, it should be "smart" because it's referring to an instance of 3 Strength.

We prefer to align HoverTips to be on the right-hand side of the hovered element. However, if we can't fit the HoverTip we left align.

Generate a HoverTip-sized preview of the specified power along with the power's hovertips.

Generate a HoverTip-sized preview of the specified card along with the card's hovertips.

CardModel subclass HoverTip card preview

Generate a HoverTip-sized preview of the specified card.

Whether the card should appear upgraded. CardModel subclass HoverTip card preview

Generate a HoverTip-sized preview of the specified card. Note: You should usually use the generic version of this method. Only use this version if you need to modify the base version of the card (like to show an upgrade or something).

CardModel to preview Whether the card should appear upgraded. HoverTip card preview

The canonical model that this HoverTip is for. Null for HoverTips that are unrelated to a model (static, card keyword, etc.).

Tries to add the tip to the list if the list doesn't already contain a tip of the same type that is equal or smarter than it.

List we are trying to add to. Tip we are trying to add.

HoverTip tags that don't correspond to a model (i.e. powers/relics) See for example usage.

A reference to a platform-specific leaderboard.

Interface for platform leaderboard implementations. Note: This is currently modeled after Steam's leaderboard API. As we add other platforms, I expect the interface to change heavily or need refactoring. For documentation on individual methods, look at LeaderboardManager, which replicates these methods exactly.

Abstracted leaderboard entry returned by querying the leaderboard API.

Rank on the leaderboard reported from the API.

Name of the user who submitted the entry.

ID of the user who submitted the entry.

The score of the submission.

Other player IDs present in the run when this score was submitted.

Facade for platform-specific leaderboard operations. Currently only Steam is supported in production; NullLeaderboardStrategy is used for dev/offline. The current implementation uses a sentinel score hack for multiplayer dailies (see ScoreUtility.clientScore) which is Steam-specific and will need revisiting when integrating other platforms' leaderboard APIs.

This should be called after all platform initialization is completed.

Obtains the leaderboard with the specified name. If it doesn't exist, it is created first.

Obtains the leaderboard with the specified name. If it doesn't exist, null is returned.

Uploads a score associated with the local player.

The leaderboard to upload to, obtained from GetLeaderboard. The score to upload. User IDs to associate with the score. These will be returned with the leaderboard entry in future queries, but note that you can only query for the score based on the submitting player.

Queries the given leaderboard.

The leaderboard to query, obtained from GetLeaderboard. The type of query. The index at which to start the query. The amount of results from the start index to return. The token to use when requesting cancellation. A task which will result in the entries queried.

Queries the given leaderboard, only returning entries for the passed users (if they exist).

The leaderboard to query, obtained from GetLeaderboard. List of platform identifiers to query the leaderboard for. The token to use when requesting cancellation. A task which will result in the entries queried.

Obtains the number of entries in the given leaderboard.

A method used in debugging. This will throw if the leaderboard is pointing to an actual backend. Rank is ignored. Score will be used to sort the entries.

Query globally. Indexes control the range of the query.

Query around the current user. Indexes are relative to the user.

Query the user's friends. Indexes are ignored.

Create a new . This will only work if the owner is a whose also has a and a . Note: For cards whose values are entirely dynamic and have no base value (like ), you should use a of 0 and a of 1.

Create a new . This will only work if the owner is a whose also has a and a . Note: For cards whose values are entirely dynamic and have no base value (like ), you should use a of 0 and a of 1.

Set this damage to come from Osty.

A special type of DynamicVar that is used for cards that include a calculation in their base behavior. For example, uses a subclass of this () for its 6 base damage + 2 extra damage for each Strike.

Set the function that will be used for the multiplier value of this var. This will be multiplied by the value. This is the "dynamic" part of the calculation, and will often be based on something in the CombatState.

says: "Deal 6 damage, plus 2 additional damage for ALL your cards containing "Strike"." In this case, the extra multiplier is the number of cards containing "Strike". Function that will be used to calculate the extra multiplier value. Argument 1 is the card instance that this calculation is occurring on. Argument 2 is the creature that is being targeted for this calculation (null when there is no target).

Calculate this var's value based on the specified target. Effects that target multiple creatures (or no creatures) should pass null for the target.

Re-run the calculations to determine if any of the dependent values have been upgraded or enchanted.

Get the DynamicVar that should be used for this calculation's base value.

Get the DynamicVar that should be used for this calculation's extra value.

A special version of that is used to represent base value in a calculated value card. For example, uses this for its 6 base damage.

A special version of that is used to represent extra value in a calculated value card. For example, uses this for its 2 extra damage done for each Strike.

The model that "owns" this DynamicVar.

The base value of this DynamicVar. This represents the actual value of the variable before any updates from external sources. This is the value that should be used when performing calculations that will modify the game's state. Other values (like PreviewValue) are for display only, to inform the player about what the value will be after external modifications.

The value of this DynamicVar after being modified by a , but before any other hooks have been run. The vast majority of the time, this will be the same as BaseValue. Only CardModels with enchantments will have a different EnchantedValue than BaseValue (and even then, only for enchantments that modify the variable in question). This exists because, in the eyes of the player, a card's enchantment is a "part of the card", so we need to be able to display the enchanted value without coloring it like it's being buffed by an effect. NOTE: If we ever add another effect that needs to be displayed as "part of the card", we should rename this to be more generic.

The value that should be displayed to the player when viewing something that uses this DynamicVar. This will often be the same as BaseValue, but it is modified in places like to show the player the final value after all modifications. Do NOT use this value for performing calculations that will modify the game's state. It's for display only.

Was this DynamicVar just recently upgraded? This is mainly used to show upgrade preview values in green. This should be cleared after the upgrade is complete.

Reset all values to the base value.

Set the model that "owns" this DynamicVar.

Update this var's preview value based on hooks (i.e. damage, block, and powers). This is so powers and relic modifications to these values can be reflected in card descriptions. This should only be called on DynamicVars owned by CardModels.

Card that this var is being displayed on. Usually matches , but for DynamicVars on enchantments, this is the card that the enchantment is on. The mode that this preview is being shown in. Creature who this card is targeting. Null if there is no target Whether the global hooks (defined in ) should be run. If false, only hooks will be run.

Increase the base value by the specified amount, and mark it as recently upgraded.

"Finalize" a recent upgrade, so it is no longer considered recently upgraded.

Get a highlighted version of this variable's preview value. Normally, if the preview value is higher than the base value, color it green. If lower, red. If equal, default. Sometimes, we do the inverse (green for lower, red for higher), for cases where a lower value is good.

Whether or not to flip the highlight logic. Highlighted preview value.

Initialize this DynamicVarSet with a model that "owns" the vars. This must be called in a separate method, because some DynamicVars are dependent on the model's DynamicVarSet, so we can't call this until the model's DynamicVarSet property has been set.

Recalculate all calculated vars to determine if any of the dependent values have been upgraded or enchanted.

A special version of that is used to represent extra damage done by a calculated damage card. For example, uses this for its 2 extra damage done for each Strike.

Set this damage to come from Osty.

DamageVar variant used exclusively by Osty. Utilizes buffs, debuffs on Osty like Strength and Weak

Applies locale-specific font substitution if the current language requires it.

Manages locale-specific font substitution for languages that require different fonts (e.g., CJK languages that need fonts with appropriate glyph coverage).

Languages that require font substitution. Key is language code, value is the set of font paths for that language.

Cached font resources, keyed by language code then font type.

Returns true if the given language requires font substitution.

Gets the substitute font for the given type based on the current locale. Returns null if no substitution is needed.

Gets the font for the specified language and type, loading and caching if necessary.

A set of paths that can be used for substitution for a given language.

Get the path for a given font type.

What type of font to get the path for (Regular, Bold, etc.) The path to the font, or null if not found.

Font types that can be substituted based on locale.

Formats numeric types with locale-aware thousand separators (N0) by default. Named formatters (diff, energyIcons, etc.) take priority over this auto-detect formatter.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

The default associated with a default instance.

The source-generated options associated with this context.

Weblate project slug used in nested export structure.

Maps Weblate language codes to game's 3-letter language codes. Keep in sync with ci/scripts/weblate.py LANGUAGES dictionary.

Maps game's 3-letter language codes to Weblate language codes.

Dictionary counting the number of keys in each language set. We don't want to calculate this dynamically, as it would involve loading a large number of JSON tables, so this is loaded from a pre-computed JSON file. Re-generate it with the script 'localization/gen_completion.py'.

User-accessible directory for localization overrides. Translators can place modified JSON files here to test their translations without rebuilding the game. Path resolves to: %AppData%/SlayTheSpire2/localization_override/ on Windows. Override files are validated for SmartFormat syntax errors during load. Invalid entries are logged to console and skipped (game uses base localization as fallback). Check console output or game logs for validation errors.

Indicates whether any localization override files were loaded from the user override directory. Useful for debugging and UI indicators.

List of validation errors found in localization override files. Populated during LoadTablesFromPath() when override files contain JSON parsing errors or invalid SmartFormat syntax.

Initialize the singleton LocManager. This is favored over a static constructor so that we can precisely control the initialization time relative to other steps (mods must be initialized before this).

Converts our three-letter code to a CultureInfo. Most of our language codes are ISO 639-2 language codes, but not all of them.

This is where we explicitly load the localization formatters we need and only the ones we need.

Converts text to W/w characters for localization debugging while preserving template expressions {like:this} and BBCode [tags].

Updates what language is being used for translation. Note that, since this is called temporarily sometimes, that it does not update the settings save file.

The three-letter code of the language to load. These are based on ISO 639-2, but are not all actual 639-2 codes because they don't map exactly to what we need.

Overrides the current language with english. When we upload metrics, we always want to use the english locale. Importantly, we also don't allow overriding of any sort in this mode (no localization override). This method also caches the english tables so that we don't have to re-load them the next time we do this.

Tries to load and validate an override file, merging valid entries into the LocTable.

Absolute path to the override JSON file. The LocTable to merge validated entries into. List to append any validation errors to. True if the file was found and at least partially loaded, false if not found.

Tries to load overrides from Weblate's nested export structure. Weblate exports as: {overrideDir}/{project}/{component}/{weblateCode}/{filename} Example: localization_override/slaythespire2/cards/de/cards.json

The globalized path to the override directory. The game's 3-letter language code (e.g., "deu"). The localization filename (e.g., "cards.json"). The LocTable to merge validated entries into. List to append any validation errors to. True if a nested override was found and loaded, false otherwise.

A Localized String, uses: https://github.com/axuno/SmartFormat

A Localized String, uses: https://github.com/axuno/SmartFormat

Returns a formatted string, ie: "Deal 6 damage." rather than: "Deal {Damage:diff()} damage."

Returns the raw text in the JSON file, ie: "Deal {Damage:diff()} damage." rather than: "Deal 6 damage."

Helper function to grab a random LocString with a given key prefix. Example: If there are multiple entries of MAP_POINT_HISTORY.abandon in run_history.json and you want to get a random LocString: The JSON would be constructed like: "MAP_POINT_HISTORY.abandon.0": "{character} had simply given up.", "MAP_POINT_HISTORY.abandon.1": "{character} was tired...", "MAP_POINT_HISTORY.abandon.2": "{character} abandoned {pronounPossessive} destiny.", You can grab a random entry via: LocString abandonMessage = LocString.GetRandomKey("run_history", "MAP_POINT_HISTORY.abandon");

Name of the table to pull the keys from. Prefix for the keys we want. Optional rng. Chaotic will be used if not specified. Random LocString with the specified key prefix.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

The default associated with a default instance.

The source-generated options associated with this context.

Serializes the variables of a LocString to JSON. Not all DynamicVar types are supported, so use with caution.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'UpdateLocalization' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'LocalizationTable' property.

Cached name for the 'LocalizationKey' property.

Cached name for the '_localizationTable' field.

Cached name for the '_localizationKey' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Represents a validation error found in a localization override file.

Represents a validation error found in a localization override file.

Validates SmartFormat syntax in localization strings. Used to catch format string errors early during override file loading.

Validates a SmartFormat format string for syntax errors.

The format string to validate The error message if validation fails, or null if valid True if the format string is syntactically valid, false otherwise

Prints to stdout. It should be used when loading operations are happening.

Prints to stdout. Debug information which is useful for debugging. It should be used for verbose text.

Prints to stdout. Debug information which is useful for debugging. It should be used for verbose text.

Prints to stdout. It should be used for general information which is useful for debugging.

Prints to stderr without a stacktrace. It should be used for non-critical issues which we should be aware of or could indicate an issue.

Prints a stacktrace to stderr. It should be used for critical issue which should also not block the continuation of the game.

Prints to stdout. It should be used when loading operations are happening.

Prints to stdout. Debug information which is useful for debugging. It should be used for verbose text.

Prints to stdout. Debug information which is useful for debugging. It should be used for verbose text.

Prints to stdout. It should be used for general information which is useful for debugging.

Prints to stderr without a stacktrace. It should be used for non-critical issues which we should be aware of or could indicate an issue.

Prints a stacktrace to stderr. It should be used for critical issue which should also not block the continuation of the game.

Pattern:
\\b76561\\d{12}\\b
Explanation:
○ Match if at a word boundary.
○ Match the string "76561".
○ Match a Unicode digit exactly 12 times.
○ Match if at a word boundary.


Handles the creation of map points for a map.

The second boss map point for Double Boss mode (Ascension 10+). Null if not in double boss mode.

A simple struct representing the row and column that a given map point is on in the map.

Detects and removes duplicate path segments from act maps. Both StandardActMap and SpoilsActMap use this after point type assignment to eliminate redundant paths that share the same sequence of point types.

Prunes duplicate segments, then repairs any point types that fell below their target count. Since repair can create new duplicates, loops until stable (up to 3 iterations).

After pruning removes nodes, some point types may fall below their target count. This repairs the map by replacing monsters with the missing types.

The map to repair. Target counts for each point type. Random number generator used for replacement selection. Validates whether a type can be placed at a given point. true if any repairs were made (indicating re-pruning may be needed)

Runs the full prune loop (up to 50 iterations) to remove duplicate segments.

Is used to let Models that modify a map after it is generated to ensure that we don't modify this point. Is set by the ActMap if false (ie StandardActMap.AssignPointTypes).

Represents a type of point that can appear on the map. This is subtly different from RoomType. Please see for more details.

Whether the map generation MapPointType assignment ignores the rules or follows the rules.

These helper methods make the map more clean looking and less cluttered together which should help with some of the complaints. Some might look like there's a lot of looping, but I profiled them and all these public static methods run together take 0 ms on my computer.

Creates a copy of the given grid that is “centered” by shifting all the nodes left or right if two of the leftmost or rightmost columns are empty. The MapPoint objects are not modified; they are simply placed into different cells.

The original grid to be centered. A grid (modified in place) with nodes moved to center the map.

This method straightens out the path if there's a single line

Returns true if every cell in the given column is null.

The grid to check. The column index. True if the column is empty; otherwise, false.

Returns a set of column indices allowed for a neighbor at the specified column. Allowed positions are the same column, one column to the left, and one column to the right.

The reference column. Total number of columns in the grid. A set of allowed column indices.

Computes the set of allowed column indices for a given node based on its parents' and children’s positions. For each parent or child, the node must be in the same column or one column to the left or right. The final allowed set is the intersection of these constraints.

The MapPoint to evaluate. Total number of columns in the grid. A set of allowed column indices.

Spreads adjacent MapPoints in the grid by moving nodes to positions that maximize the gap between neighbors, subject to connectivity constraints.

The grid containing MapPoints. The transformed grid.

Computes the minimal horizontal gap from a candidate column to any other node in the same row. If there are no other nodes in the row, returns int.MaxValue.

The candidate column for the node. All nodes in the row. The node being moved. The minimum column distance to any other node.

Get all the points on the map that are reachable from the specified point.

The state of the current run. The current point that the players are at.

A map specifically for tests that allows you to specify the size and contents of the map.

Creates a new point with the specified type at the specified coordinates.

A single-point map specifically used for tests.

An empty map used as a placeholder before a real map is generated.

An ActMap that is reconstructed from saved data rather than generated from RNG. This ensures map topology is preserved even if map generation code changes. This single class handles all map types (Standard, Spoils, GoldenPath) because the concrete type only matters during generation. After generation, all maps are simply grids of MapPoints with connections. The serialization captures the complete topology, making the original generation algorithm irrelevant for restoration.

An hourglass-shaped map where all paths converge through a single centered treasure node. Used when SpoilsMap card is active in Act 2. This map is generated from scratch rather than post-processing StandardActMap. The hourglass structure requires fundamentally different path topology. All paths must converge through a single centered treasure node, with rows narrowing towards the treasure then widening after. Post-processing would require deleting most nodes and rewiring all edges, which is roughly as complex as generating from scratch. Keeping these implementations separate makes both easier to understand. StandardActMap stays clean, and the hourglass-specific constraints live here explicitly instead of being tangled up in post-processing logic. Each can evolve independently. The tradeoff is this duplicates some map generation logic (~400 lines). If StandardActMap's core rules change (adjacency constraints, parent/child limits, point type placement), we'll need to manually sync those changes here. Tests in SpoilsActMapTest verify the core map invariants hold.

Creates a map used only when the player has the .

The run state for this run. If passed, replaces the default point counts used to generate the map.

Flags this map to generate elite nodes where the treasure nodes would be in the middle of the act map. Is set in the constructor, typically for the Warden Ascension (replace act 3 chests with elites)

Creates a standard map used for most acts.

The rng for the map. The act to generate the map for In multiplayer, we remove one node from each map. Replaces the treasure row with elites. This is for the Warden ascension. Whether this act has a second boss (Double Boss ascension mode) Overrides the map point type counts from the map passed in Used for tests, should always be true if used for gameplay logic

Assigns point types to the map by row to ensure that the point types are more evenly distributed.

Point types left to be assigned. Rows of map points to assign the types to. These point types cannot be in the lower part of the map These point types cannot be in the upper part of the map These cannot be 2 times in a row. These cannot be 2 times in a row. These cannot be 2 times in a row. Checks if a point type is valid by ensuring it doesn't appear twice in a row among children Only these point types are allowed to be siblings These point types cannot be siblings of each other.

A file IO abstraction layer for use with ModManager. It's a little different than ISaveStore, which is scoped only to a specific directory. This class allows global access to the filesystem.

Information about a loaded mod.

Where the mod originated from.

Path where the mod files are located.

Whether the mod was loaded, and if it was not loaded, why. Since there's no way to unload mods while the game is running, this value cannot change after the initial mod initialization occurs. Even if the mod is set to disabled in SettingsSave, this value is the true source of whether or not the mod was loaded into the game.

The mod manifest.

The version parsed from the mod manifest. Null if the version is not present or is not a valid semantic version.

The C# assembly loaded with the mod, if any.

If null, then no errors occurred while loading the mod. If this is set, then there was an error loading the mod that should be displayed.

Some helper methods for modding.

Called by mods to add their models to a pool. Throws if the pool has already concatenated models to that pool (i.e. the mod was too late in calling this method).

The pool type to add to. The model to add to the pool.

Called by a pool when it is ready to add modded content to its pool of content.

The pool that is consuming the content. The current pool of content. The model type of the content that should have been added by mods. A new pool with all modded content concatenated to pool.

Called by mods when they wish to provide custom model types to a RunState when IterateHookListeners is called.

An ID to identify the subscription. Usually the name of the mod. The delegate provided by the mod, which returns the models to iterate over.

Called by mods when they wish to provide custom model types to a CombatState when IterateHookListeners is called.

An ID to identify the subscription. Usually the name of the mod. The delegate provided by the mod, which returns the models to iterate over.

Called by RunState when it is iterating hook listeners, so that custom mod AbstractModel types have hooks called on them.

The RunState which is iterating hook listeners. All the model types from all subscribing mods who wish to receive hooks.

Called by CombatState when it is iterating hook listeners, so that custom mod AbstractModel types have hooks called on them.

The CombatState which is iterating hook listeners. All the model types from all subscribing mods who wish to receive hooks.

Declares a class as the main entry point for the mod. If this is present, then upon loading the mod, we'll call the method named initializerMethod within the class. Otherwise, we'll create a harmony instance for the mod and call Harmony.PatchAll.

Mod was successfully loaded.

We tried to load the mod but it failed to load.

We didn't try to load the mod because the user has not enabled mod loading, or this specific mod is marked as disabled in SettingsSave.

We didn't try to load the mod because the user has this mod loaded both via Steam and local mods directory.

We didn't try to load the mod because it was added too late.

Called when a new mod is detected. Use this to display a warning at runtime if the user adds new mods.

Used by mods to hook into the metrics upload process. This is unused by STS2 code. It is only used by mods, and is called when we would ordinarily upload metrics.

Loads all mods from the appropriate directories. This includes the "mods" directory next to the executable, as well as Steam workshop files. This should be called as early as possible in the game's initialization process so that downstream classes (ModelDb, LocManager) pick up the changes that the mods apply.

Sorts mods so that dependencies are loaded before the mods that depend on them (topological sort). Uses Kahn's algorithm: https://en.wikipedia.org/wiki/Topological_sorting#Kahn's_algorithm How it works: 1. Build a graph: count each mod's dependencies (in-degree) and track reverse edges (dependentsMap). 2. Seed a frontier queue with all mods that have zero dependencies (they're ready to load). 3. Dequeue a mod, add it to the sorted output, and decrement the in-degree of each mod that depends on it. When a mod's in-degree reaches zero, all its dependencies are satisfied, so enqueue it. 4. When the queue is empty, any mod NOT in the sorted output is part of a dependency cycle (its in-degree never reached zero because it's waiting on something that's waiting on it). For mods with no dependency relationship between them, we use a PriorityQueue keyed by the user's manual ordering (from settings) to keep the sort stable.

If the user has subscribed to a mod via Steam workshop and also has it in their local directory, we never want to load the Steam mod. This is to help mod developers in development.

Recurses through the directory and reads all the mod PCKs and DLLs in it, putting it in the _mods list. We allow mods in directories to give modders a little slack in how they organize their files. Pass the newMods list if you wish to get the mods that have been newly read.

Decides whether is supported by a Steam Workshop item, given the supported game-version ranges Steam reports for it. Each range is a (min, max) pair of branch names ordered oldest to newest (see ); an empty string is a documented open-ended bound (empty min = no lower bound, empty max = no upper bound, both empty = every branch). Returns the newest supported branch seen so the caller can surface it in an error message. Pure and side-effect free so it can be unit tested without Steam.

Calls the mod initializer on a type that has the ModInitializerAttribute on it.

Returns the filenames of all the loc tables available in loaded mods for the given language and filename. For example, if "eng" and "cards.json" are provided, this returns all mods that supply a cards.json in english.

Returns a list of the names of all loaded mods that affect gameplay. For multiplayer - used to compare mods between different players.

Returns a list of the names of all loaded mods that do not affect gameplay.

Resolves assemblies loaded by mods that may have a different version. When writing a mod DLL, the implementer may target a STS2 DLL that does not match the current version. When the dotnet runtime attempts to load the DLL, it tries to strictly match the version. Usually, we don't really need it to - a lot of our APIs don't change that often. Attaching this method to the AssemblyResolve event allows us to force dotnet to resolve the assembly to the correct one.

Called by the metrics uploader when metrics would be uploaded, but are not because there are mods present.

ModManager is not yet initialized.

ModManager is fully initialized. It may or may not have loaded mods.

ModManager skipped initialization for some reason: - We're in test mode - This is an AOT build - nomods command line argument was passed

Represents the JSON file which defines mod manifests.

Where a mod was loaded from.

The mod is located in the mods directory next to the executable.

The mod was loaded from Steam Workshop.

Represents a mod in the settings save. Used for: - Representing manual load order - Disabling/enabling mods

Fires when a hook on this model has finished executing. This event is a little unreliable, so you should only use it for UI things that can't be done any other way.

The category ID of the model, as reported by ModelIdSerializationCache. Used in the deterministic sort in DeterministicModelComparer for speed purposes; it's much faster to compare integers than strings.

The entry ID of the model, as reported by ModelIdSerializationCache. Used in the deterministic sort in DeterministicModelComparer for speed purposes; it's much faster to compare integers than strings.

Ensures that this model instance is mutable. Throws an exception if it's canonical. Use this in places where you want to ensure that you have a "real" model that you can use in combat and modify. WARNING: If you're getting an exception from here, don't just convert the model to mutable at the top level of the stack trace. Instead, find the root of where the model is coming from and convert it there, so the correct instance is used in the correct places. For example, canonical CardModels throw an exception if you try to add them to a pile, but you shouldn't just convert the CardModel to mutable in CardPile.AddCard(). Instead, find where that card was created and convert it there.

Ensures that this model instance is canonical. Throws an exception if it's mutable. Use this in places where you want a reference to the "concept" of a model. For example, CardPools only hold canonical CardModels.

Get a "clone" of this model, preserving its mutability status. This is useful in more backend-ish areas of the codebase, where a model can either be mutable or canonical, and we don't want to create a new mutable clone if we currently have a reference to the canonical instance.

If this instance of the model is canonical, this method just returns itself. If this instance of the model is mutable, it returns another mutable clone.

WARNING: You almost always want to use `ToMutable()` or `ClonePreservingMutability()` instead, since we usually don't want to make mutable clones of already-mutable models. Get a mutable "clone" of this model. This is useful in very generalized spots where we could either have a mutable or canonical model, and we want a mutable clone regardless.

A mutable clone of this model.

Called after cloning to clean up shallow-copied references. IMPORTANT: MemberwiseClone() creates shallow copies of all fields, including event delegates. Subclasses that declare events MUST override this method and set all events to null, otherwise clones will fire events to the original's subscribers (correctness bug) and may prevent garbage collection through retained delegate references (memory leak).

See .

Whether or not this model should have combat hooks called on it. For example, AfterCardPlayed is only relevant in combat, and should be called on models that want to "listen" to the combat (powers, relics, cards in a combat pile, enchantments on those cards, etc.), but not on models that are disconnected from combat (cards in your deck, enchantments in your deck, etc.). Conversely, AfterRoomEntered is relevant outside of combat, and should be called on all models. Similarly, AfterDamageReceived is relevant outside of combat (since damage can be received in events and other non-combat rooms), so it should be called on all models.

Runs after a player enters a new act.

Runs after a model prevents a card from being added to the player's deck.

Card that would've been added.

Runs before a creature attacks. For a multi-attack, this will run once before any hits are done (as opposed to BeforeDamageGiven, which will run before each hit).

The attack command that will be executed.

Runs after a creature attacks. For a multi-attack, this will run once after all hits are done (as opposed to AfterDamageGiven, which will run after each hit).

The context that is signalled in the event of a player choice. The attack command that was executed.

Runs after the phase of a player's turn has been entered. Effects that auto-play cards at the end of a player's turn should use this hook. See for examples. Combat-only hook.

The context that is signalled in the event of a player choice. Player whose phase was entered.

CAREFUL! You should usually use AfterAutoPrePlayPhaseEntered instead of this. Runs after the phase of a player's turn has been entered. Effects that auto-play cards at the start of a player's turn should use this hook. See for examples. Combat-only hook.

The context that is signalled in the event of a player choice. Player whose phase was entered.

Runs after the phase of a player's turn has been entered. Effects that auto-play cards at the start of a player's turn should use this hook. See for examples. Combat-only hook.

The context that is signalled in the event of a player choice. Player whose phase was entered.

CAREFUL! You should usually use AfterAutoPrePlayPhaseEntered instead of this. Runs after the phase of a player's turn has been entered. Effects that auto-play cards at the start of a player's turn should use this hook. See for examples. Combat-only hook.

The context that is signalled in the event of a player choice. Player whose phase was entered.

Runs after a creature's block has been cleared at the beginning of their round. Combat-only hook.

Creature whose block was reset.

Runs before a creature gains block. Combat-only hook.

Creature that will gain block. Amount of block they will gain. ValueProps for the block they will gain. Optional card that will add the block.

Runs after a creature gains block. Combat-only hook.

Creature that gained block. Amount of block they gained. ValueProps for the block they gained. Optional card that added the block.

Runs after a creature's block is completely removed. Prefer this over checking result.WasBlockBroken in AfterDamageReceived, as block can be broken by non-damage, like Expose. Combat-only hook.

Creature that gained block.

Runs after a card moves from one pile to another. NOTE: The new pile can be determined by just checking card.Pile.

Card that changed piles. Type of the card's previous pile The model that cloned this card, if applicable. Used to prevent copy effects from recursing.

CAREFUL! You should usually use AfterCardChangedPiles instead of this. Runs after a card moves from one pile to another. Works just like AfterCardChangedPiles, but runs after it. NOTE: The new pile can be determined by just checking card.Pile.

Card that changed piles. Type of the card's previous pile The model that cloned this card, if applicable. Used to prevent copy effects from recursing.

Runs after a card is discarded. Combat-only hook.

The context that is signalled in the event of a player choice. Card that was discarded.

CAREFUL! You should usually use AfterCardDrawn instead of this. Runs after a card is drawn. Combat-only hook. Works just like AfterCardDrawn, but runs before it.

The context that is signalled in the event of a player choice. Card that was drawn. If this draw happened as part of the initial card draws at the start of your turn.

Runs after a card is drawn. Combat-only hook.

The context that is signalled in the event of a player choice. Card that was drawn. If this draw happened as part of the initial card draws at the start of your turn.

Runs after a card is put into a combat pile (see details on combat piles). Combat-only hook.

Card that was put into a combat pile.

Runs after a player generated a card for combat pile. This is different from AfterCardEnteredCombat because the player explicitly generated it themselves, excluding status cards that are applied by enemies. Combat-only hook.

Card that was put into a combat pile. The player that created the card True if this card is being added by an effect from the player (like ). False if an enemy is adding it (like a monster giving you a curse).

Runs after a card is exhausted. Combat-only hook.

The context that is signalled in the event of a player choice. Card that was exhausted. Was this Exhaust caused by Ethereal?

Runs before a card is automatically played by another card. Combat-only hook.

Card that will be played. Creature that will be targeted. The method of autoplay.

Runs before a card is played. Combat-only hook.

Runs after a card is played. Combat-only hook.

CAREFUL! You should usually use AfterCardPlayed instead of this. Runs after a card is played. Works just like AfterCardPlayed, but runs after it. Combat-only hook.

Runs before combat starts. Note: This may sound like a combat-only hook, but combat start is relevant to non-combat models (like a deck card that transforms when you start your third combat).

CAREFUL! You should usually use BeforeCombatStart instead of this. Runs before combat starts. Note: This may sound like a combat-only hook, but combat start is relevant to non-combat models (like a deck card that transforms when you start your third combat). Works just like BeforeCombatStart, but runs after it.

Runs after combat ends. Note: This may sound like a combat-only hook, but combat end is relevant to non-combat models (like Guilty).

The room where the combat ended.

CAREFUL! You should usually use AfterCombatVictory instead of this. Runs after combat ends in a player victory. Note: This may sound like a combat-only hook, but combat victory is relevant to non-combat models (like a deck card that transforms after 3 combat victories). Works just like AfterCombatVictory, but runs before it.

The room where the player won the combat.

Runs after combat ends in a player victory. Note: This may sound like a combat-only hook, but combat victory is relevant to non-combat models (like a deck card that transforms after 3 combat victories).

The room where the player won the combat.

Runs after a new creature is added to combat.

Creature that was added to combat.

Runs after a creature's HP changes for any reason (damage, heal, HP loss, etc).

Creature whose HP changed. Amount that the creature's HP changed by. A negative amount represents damage, while a positive amount represents healing.

Runs after a creature might dealt damage. Note: Even if the actual damage amount is 0 (due to block or something else), this will still be called.

The context that is signalled in the event of a player choice. Creature who dealt the damage. Results from the damage they dealt. ValueProp for damage. Creature who received the damage. Optional card that dealt the damage.

Runs before a creature might receive damage. Note: Even if the actual damage amount will be 0 (due to Weak or something else), this will still be called.

The context that is signalled in the event of a player choice. Creature who will receive the damage. Amount of damage they will receive. ValueProp for damage. Creature who will be dealt the damage. Optional card that will deal the damage.

Runs after a creature might receive damage. Note: Even if the actual damage amount is 0 (due to block or something else), this will still be called.

The context that is signalled in the event of a player choice. Creature who received the damage. Results from the damage they received. ValueProp for damage. Creature who dealt the damage. Optional card that dealt the damage.

CAREFUL! You should usually use AfterDamageReceived instead of this. Runs after a creature might receive damage. Works just like AfterDamageReceived, but runs after it. Note: Even if the actual damage amount is 0 (due to block or something else), this will still be called.

The context that is signalled in the event of a player choice. Creature who received the damage. Results from the damage they received. ValueProp for damage. Creature who dealt the damage. Optional card that dealt the damage.

Runs before a creature dies. Note: This will run even if some effect (like Fairy in a Bottle) would prevent the creature's death.

Creature who is about to die.

Runs after a creature dies.

The context that is signalled in the event of a player choice. Creature who died. Whether the creature's removal from combat was prevented. Usually false, but true for things like reviving powers. Number of seconds the creature's death animation will last. Good for delaying visuals until the animation is over.

Runs after creatures died to Doom. Combat-only hook.

The context that is signalled in the event of a player choice. The creatures that died to Doom.

Runs after the player's energy is reset at the beginning of their turn. Combat-only hook.

Player whose energy is reset.

CAREFUL! You should usually use AfterEnergyReset instead of this. Runs after the player's energy is reset at the beginning of their turn. Combat-only hook. Works just like AfterEnergyReset, but runs after it.

Player whose energy is reset.

Runs after the player's energy is spent. Combat-only hook.

Card that spent the energy was spent on. Amount of energy that was spent.

Runs before a card is removed from your deck.

Card that is being removed.

Runs before a player's hand is flushed at the end of their turn. Combat-only hook.

The context that is signalled in the event of a player choice. Player whose hand will be flushed.

CAREFUL! You should usually use BeforeFlush instead of this. Runs before a player's hand is flushed at the end of their turn. Combat-only hook. Works just like BeforeFlush, but runs after it.

The context that is signalled in the event of a player choice. Player whose hand will be flushed.

Runs after a player's hand is flushed at the end of their turn.

The context that is signalled in the event of a player choice. Player whose hand was flushed. Cards that were discarded during the flush. Cards that were retained during the flush.

Runs after the player gains gold.

Player who gained the gold.

Runs before the player draws their hand at the beginning of their turn. Combat-only hook.

The player who is about to draw cards. The context that is signalled in the event of a player choice. The CombatState that the hand draw will occur in.

CAREFUL! You should usually use BeforeHandDraw instead of this. Runs before the player draws their hand at the beginning of their turn. Combat-only hook. Works just like BeforeHandDraw, but runs after it.

The player who is about to draw cards. The context that is signalled in the event of a player choice. The CombatState that the hand draw will occur in.

Runs after the player's hand becomes empty. Combat-only hook.

The context that is signalled in the event of a player choice. Player whose hand was emptied.

Runs after a player purchase an item from the shop.

Player who purchased the item. Item that was purchased. Amount of gold that was spent to purchase the item.

Runs after a map is generated for an act.

The generated map. The act index for which the map was generated.

Runs after the amount of block was modified. Combat-only hook.

The amount of block after all modifications have been applied. Card that added the block. CardPlay that added block. Null if the block is not associated with a CardPlay. This can be null even if is not null, because this is also called to preview block values on cards that are in your hand and haven't been played yet.

Runs after the play count of a card was modified.

Card whose play count was modified.

Runs after the result pile of a played card was modified.

Card whose result pile was modified. Final pile type that the card will be put in. Final position in the pile that the card will be put in.

Runs after the trigger count of an orb was modified.

Orb whose trigger count was modified.

Runs after the play count of a card was modified.

Runs after the amount of damage was modified.

Runs after the amount of energy to gain was modified.

Runs after the amount of gold to gain was modified.

Player who is about to gain gold. The modified amount of gold they will gain.

Runs after the number of cards drawn at the beginning of the player's turn was modified. Combat-only hook.

Runs after card draw was prevented. Combat-only hook.

Runs after the amount of HP a creature should lose (before Osty redirection) was modified.

Runs after the amount of HP a creature should lose (after Osty redirection) was modified.

Runs after a power has its amount modified during application. Combat-only hook.

Power whose amount was modified.

Runs after a power has its amount modified during application. Combat-only hook.

Power whose amount was modified.

Runs after a list of rewards has its contents modified.

Runs after player channeled an orb

The context that is signalled in the event of a player choice. Player who channeled the orb. Orb that was channeled.

Runs after player evokes a orb

The context that is signalled in the event of a player choice. Orb that was evoked. who the orb affected

Runs after Osty is revived.

The osty that was revived

Runs before a potion is used. Note: This only invokes for relics when out of combat.

Potion that will be used. Creature that will be targeted.

Runs after a potion is used. Note: This only invokes for relics when out of combat.

Potion that was used. Creature that was targeted.

Runs after a potion is discarded. Note: This only invokes for relics when out of combat.

Potion that was used.

Runs after a potion is procured. Note: This only invokes for relics when out of combat.

Potion that was used.

Runs before a power's amount is changed, whether it's a new power being added or an existing power's amount being changed. Combat-only hook.

Power that will be applied. Amount of the power that will be added. The creature that the power will be added to (Optional) The creature that will change the power amount. Null if the change is not caused by a creature (usually in tests). Optional card that is changing the power amount.

Runs after a power's amount is changed, whether it's a new power being added or an existing power's amount being changed. Combat-only hook.

The context that is signalled in the event of a player choice. Power that was applied. Amount of the power that was added (Optional) The creature that changed the power amount. Null if the change was not caused by a creature (usually in tests). (Optional) The card that changed the power amount. Null if the change was not caused by a card.

Runs after a power prevents the creature from clearing block. Combat-only hook.

Model that prevented the block clear. Creature whose block clear was prevented.

Runs after this model prevents a creature's death.

Creature whose death was prevented.

After player rests at a rest site.

Player that rested. Is a mimicked rest site heal? Used in spots that mimicking a rest site heal, but are not actual rest site heals. For example: mimicks a rest site heal when you select certain options. This should count as a rest site heal for , but not for .

After player smiths at a rest site.

Player that smithed.

Runs after a player successfully takes a reward from the reward screen.

Player who took the reward. The reward taken.

Runs before a player enters a room.

Room that will be entered.

Runs after a player enters a room. For "start of combat" effects that should execute before the start of the first turn (like applying powers), you should use this hook with a "room is CombatRoom" check. For "start of combat" effects that should execute after the start of the first turn (like dealing damage or gaining block), you should use with a RoundNumber check instead.

Room that was entered.

Runs after a player shuffles their draw pile. Combat-only hook.

The context that is signalled in the event of a player choice. Player who shuffled.

Runs after a player spends stars on something. Combat-only hook.

Amount of stars that were spent. Player that spent the stars.

Runs after a player gains stars. Combat-only hook.

Amount of stars that were gained. Player that gained the stars.

Runs after a player triggers a Forge effect, increasing the damage of Sovereign Blade. Combat-only hook.

Amount of forge that was triggered. Player that triggered the forge. The abstract model that triggered the forging

Runs after a player summons. Combat-only hook.

The context that is signalled in the event of a player choice. Player that summoned. Amount that was summoned.

Runs after the player takes an extra turn. Combat-only hook. Player that took the extra turn.

WARNING: ONLY DO VFX/SFX THINGS IN THIS HOOK. It is not meant for things that affect game state. Runs after attempting to target this creature with a card is blocked.

Creature who blocked the targeting.

Runs before the start of a side's turn, before any effects like energy reset or card draw. Combat-only hook.

Side whose turn is about to start. Creatures participating in this turn. If a player is taking an extra turn in multiplayer, other players may be missing from this list, and the models they own should usually exit early in this case. State of the combat that the turn is about to start in in.

Runs after the start of a side's turn. For "start of combat" effects that should execute after the start of the first turn (like dealing damage or gaining block), you should use this hook with a RoundNumber check. For "start of combat" effects that should execute before the start of the first turn (like applying powers), you should use with a "room is CombatRoom" check instead. should be used for any hooks that trigger a player choice. Combat-only hook.

Side whose turn started. Creatures participating in this turn. If a player is taking an extra turn in multiplayer, other players may be missing from this list, and the models they own should usually exit early in this case. State of the combat that the turn is about to start in in.

CAREFUL! You should usually use AfterSideTurnStart instead of this. Runs after the start of a side's turn. For "start of combat" effects that should execute after the start of the first turn (like dealing damage or gaining block), you should use this hook with a RoundNumber check. For "start of combat" effects that should execute before the start of the first turn (like applying powers), you should use with a "room is CombatRoom" check instead. should be used for any hooks that trigger a player choice. Combat-only hook.

Side whose turn started. Creatures participating in this turn. If a player is taking an extra turn in multiplayer, other players may be missing from this list, and the models they own should usually exit early in this case. State of the combat that the turn is about to start in in.

CAREFUL! You should usually use AfterPlayerTurnStart instead of this. Runs after the start of a player's turn. Most of the time, this and are interchangeable. However, if you need to make a player choice call, do it here. Otherwise, problems will arise when draw effects that trigger player choice (e.g. Mayhem, Stratagem) interact with the hook. Works just like AfterPlayerTurnStart, but runs before it. Combat-only hook.

The context that is signalled in the event of a player choice. Player whose turn started.

Runs after the start of a player's turn. Most of the time, this and are interchangeable. However, if you need to make a player choice call, do it here. Otherwise, problems will arise when draw effects that trigger player choice (e.g. Mayhem, Stratagem) interact with the hook. Combat-only hook.

The context that is signalled in the event of a player choice. Player whose turn started.

CAREFUL! You should usually use AfterPlayerTurnStart instead of this. Runs after the start of a player's turn. Most of the time, this and are interchangeable. However, if you need to make a player choice call, do it here. Otherwise, problems will arise when draw effects that trigger player choice (e.g. Mayhem, Stratagem) interact with the hook. Works just like AfterPlayerTurnStart, but runs after it. Combat-only hook.

The context that is signalled in the event of a player choice. Player whose turn started.

CAREFUL! You should usually use BeforeSideTurnEnd or BeforeSideTurnEndEarly instead of this. Runs before the end of a side's turn. Works just like BeforeSideTurnEnd and BeforeSideTurnEndEarly, but runs before either of them. Combat-only hook.

The context that is signalled in the event of a player choice. Side whose turn ended. Creatures who participated in this turn. If a player took an extra turn in multiplayer, other players may be missing from this list, and the models they own should usually exit early in this case.

CAREFUL! You should usually use BeforeSideTurnEnd instead of this. Runs before the end of a side's turn. Works just like BeforeSideTurnEnd, but runs before it. Combat-only hook.

The context that is signalled in the event of a player choice. Side whose turn ended. Creatures who participated in this turn. If a player took an extra turn in multiplayer, other players may be missing from this list, and the models they own should usually exit early in this case.

Runs before the end of a side's turn. Combat-only hook.

The context that is signalled in the event of a player choice. Side whose turn ended. Creatures who participated in this turn. If a player took an extra turn in multiplayer, other players may be missing from this list, and the models they own should usually exit early in this case.

Runs after the end of a side's turn. Note: Enemy-damaging effects (Bedlam Beacon, The Bomb, etc) should NOT go in here. Put them in BeforeSideTurnEnd instead. Self-damaging effects (Acid Dust, Magic Bomb, etc) can go in here. Combat-only hook.

The context that is signalled in the event of a player choice. Side whose turn ended. Creatures who participated in this turn. If a player took an extra turn in multiplayer, other players may be missing from this list, and the models they own should usually exit early in this case.

CAREFUL! You should usually use AfterSideTurnEnd instead of this. Runs after the end of a side's turn. Note: Enemy-damaging effects (Bedlam Beacon, The Bomb, etc) should NOT go in here. Put them in BeforeSideTurnEnd instead. Self-damaging effects (Acid Dust, Magic Bomb, etc) can go in here. Combat-only hook.

The context that is signalled in the event of a player choice. Side whose turn ended. Creatures who participated in this turn. If a player took an extra turn in multiplayer, other players may be missing from this list, and the models they own should usually exit early in this case.

Modify the number of times the specified attack will hit.

Attack whose hit count we're modifying. The current number of times this attack should hit. The new number of times this attack should hit.

Add to the amount of block that will be gained. Use this for effects that add amounts to existing block, like and .

Creature who will gain the block. Initial amount of block. ValueProp for the block. Card that will be adding the block. Null if the block is coming from something other than a card (like a Relic). CardPlay that will be adding the block. Null if the block is not associated with a CardPlay. This can be null even if is not null, because this is also called to preview block values on cards that are in your hand and haven't been played yet. Amount of block to be added.

Multiply the amount of damage that will be gained. Use this for effects that multiply existing block by some amount, like and .

Creature who will receive the block. Initial amount of block. ValueProp for the block. Card that will be adding the block. Null if the block is coming from something other than a card (like a Relic). CardPlay that will be adding the block. Null if the block is not associated with a CardPlay. This can be null even if is not null, because this is also called to preview block values on cards that are in your hand and haven't been played yet. Amount that the block should be multiplied by.

Modify the number of times the currently-being-played card will be played. Good for "Your next card is played twice" effects.

The card that is being played. The number of times it should be played. Creature this card is targeting The new number of times this card should be played.

Modify the pile that the card will be put in after it is played, and the position it will have in that pile.

The card that is being played. Whether this card is being auto-played. False when the player plays the card manually from their hand. True when played automatically by an effect like . Info about the resources used when playing this card. The type of pile that the card will currently be put in. The position that the card will currently be put into in pileType. The new type of pile that this card should be put in, and the position it should have.

Modify the number of times an orb's passive will fire. Doesn't trigger if the passive is fired manually (ie loop).

Orb whose passive is being triggered. The number of times the orb's passive should be triggered.

Modify the cards reward options before a card reward is generated from them. You may remove cards, add cards, or add duplicate cards (to increase the chances of that card showing up) to the card pool.

The player who is being offered rewards. What the card rewards are being generated for.

CAREFUL! You should usually use instead of this. Modify the cards reward options before a card reward is generated from them. You may remove cards, add cards, or add duplicate cards (to increase the chances of that card showing up) to the card pool.

The player who is being offered rewards. What the card rewards are being generated for.

Modify the odds of a card reward being offered upgraded.

Player who is being offered rewards. Card reward. Initial odds of it being upgraded. New odds of it being upgraded.

Add to the amount of damage that will be dealt. Use this for effects that add amounts to existing damage, like and .

Creature who will receive the damage. Current amount of damage that will be dealt. ValueProp for damage. Creature who will deal the damage. Card that will be dealing the damage. Amount of damage to be added.

Set the maximum amount of damage that will be dealt in a single hit.

Creature who will receive the damage. ValueProp for damage. Creature who will deal the damage. Card that will be dealing the damage.

Multiply the amount of damage that will be dealt. Use this for effects that multiply existing damage by some amount, like and .

Creature who will receive the damage. Current amount of damage that will be dealt. ValueProp for damage. Creature who will deal the damage. Card that will be dealing the damage. Amount that the damage should be multiplied by.

When the player is about to gain energy, modify the amount that they should gain.

Player who will gain energy. Original amount of energy they would gain. New amount of energy to gain.

When the player is about to gain gold, modify the amount that they should gain.

Player who will gain gold. Original amount of gold they would gain. New amount of gold to gain.

Modify the dungeon map before it is set up.

Run state. The generated map. The act index for which the map was generated.

Annotate the dungeon map after all topology-replacing hooks have run. Must not replace the map (i.e., return a different ActMap instance) because this hook also runs on saved maps during multiplayer reconnect, where the topology must be preserved. Use this for quest markers, metadata, etc. To replace the map, use .

Run state. The generated map. The act index for which the map was generated.

Modify the amount of cards the player should draw at the start of their turn.

Player who will draw the cards. Original number of cards that would be drawn. New amount of cards to be drawn.

CAREFUL! You should usually use ModifyHandDraw instead of this. Modify the amount of cards the player should draw at the start of their turn.

Player who will draw the cards. Original number of cards that would be drawn. New amount of cards to be drawn.

Modify the amount of HP that will be lost by the target. This runs when damage is being dealt, after block is applied. This runs BEFORE damage is redirected from Necrobinder to Osty. If you want to modify damage AFTER this redirection, use . Note: Only causes damage redirection. If we ever get a second source of damage redirection, we should rename this method to be more general.

Creature who will lose HP. Original amount of HP to be lost. ValueProp for amount. Creature who will be causing the HP loss. Card that will be causing the HP loss. New amount of HP to be lost.

CAREFUL! You should usually use ModifyHpLostBeforeOsty instead of this. Modify the amount of HP that will be lost by the target. This runs when damage is being dealt, after block is applied. This runs BEFORE damage is redirected from Necrobinder to Osty. If you want to modify damage AFTER this redirection, use . Note: Only causes damage redirection. If we ever get a second source of damage redirection, we should rename this method to be more general.

Creature who will lose HP. Original amount of HP to be lost. ValueProp for amount. Creature who will be causing the HP loss. Card that will be causing the HP loss. New amount of HP to be lost.

Modify the amount of HP that will be lost by the target. This runs when damage is being dealt, after block is applied. This runs AFTER damage is redirected from Necrobinder to Osty. If you want to modify damage BEFORE this redirection, use . Note: Only causes damage redirection. If we ever get a second source of damage redirection, we should rename this method to be more general.

Creature who will lose HP. Original amount of HP to be lost. ValueProp for amount. Creature who will be causing the HP loss. Card that will be causing the HP loss. New amount of HP to be lost.

CAREFUL! You should usually use ModifyHpLostAfterOsty instead of this. Modify the amount of HP that will be lost by the target. This runs when damage is being dealt, after block is applied. This runs AFTER damage is redirected from Necrobinder to Osty. If you want to modify damage BEFORE this redirection, use . Note: Only causes damage redirection. If we ever get a second source of damage redirection, we should rename this method to be more general.

Creature who will lose HP. Original amount of HP to be lost. ValueProp for amount. Creature who will be causing the HP loss. Card that will be causing the HP loss. New amount of HP to be lost.

Modify the max energy a player has.

Player who we are modifying. Current amount of max energy they have.

Modify the cards available in the merchant's card pool. You may remove cards, add cards, or add duplicate cards (to increase the chances of that card showing up).

The player who is at the merchant. The original options in the card pool. The modified card pool.

Modify the rarity of a merchant card entry

The player who is at the merchant. Original rarity of the merchant card entry. New rarity.

Modify the cards created to sell at the merchant.

Player who is at the merchant CardCreationResults created to sell at the merchant. Note that they could already have been modified by another source.

Modify the cost of items at the merchant.

The player who is at the merchant. the merchant entry we are modifying the price for Original cost of the merchant item. New cost of the merchant item.

Modify orb value for this creature.

Orb we are modifying. Original value that the orb would use for its action. New value that the orb should use for its action.

Add to the amount of a power that will be applied by a creature. Use this for effects that add a flat amount to the power, like . This runs before .

The power that will be applied. Creature who will be applying the power. Current amount of the power to be applied. Optional creature who the power will be applied to. Optional card that applied the power. Amount to add to the power.

Multiply the amount of a power that will be applied by a creature. Use this for effects that scale the power, like . This runs after .

The power that will be applied. Creature who will be applying the power. Current amount of the power to be applied (after additive modifiers). Optional creature who the power will be applied to. Optional card that applied the power. Amount that the power should be multiplied by.

Modify the amount to be healed at the rest site.

Creature who will be healing (usually the player, but Osty when playing Necrobinder). The original amount that would be healed. The new amount to be healed.

Modify the order in which cards are shuffled into the player's draw pile.

Player whose draw pile is being shuffled. Cards that are being shuffled. Modifications made to this list will be reflected in the draw pile. True if this is the initial shuffle at the start of combat, false if this is a reshuffle during combat.

Modify the amount of a Summon.

Player who is doing the summoning. Amount that is being summoned. The model that this Summon came from. For example, and pass themselves here. Null if the Summon did not come from any model (generally only relevant in tests). The new amount to be summoned.

Modify the creature that will receive unblocked damage.

Creature who will receive the damage. Amount of damage to be dealt. ValueProp for amount. Creature who will be dealing the damage. New creature to receive the unblocked damage.

Modify the current event for an event room

The currently rolled event. New event

Modify the room types that can be rolled when the player enters an unknown location.

Room types that can be rolled. New set of room types that can be rolled.

When a room type is not chosen as the resolved room for an unknown map point, this modifies the increased odds that it will show up the next time.

The room type whose odds are being increased. The amount the room would increase odds without modification. The modified odds increase.

Modify the X-value used for an X-cost card's effect.

Card whose X-value we're modifying Original X-value that we're modifying. The new X-value to use.

Runs before a card is added to deck to give relics an opportunity to modify the card. Note that this can be run as part of transformation as well. The new owner can be determined by checking card.Owner.

Card that was put into a deck. New card that should be put into the deck instead.

NOTE: You probably want to use TryModifyCardBeingAddedToDeck instead! Runs before a card is added to deck to give relics an opportunity to modify the card. Note that this can be run as part of transformation as well. The new owner can be determined by checking card.Owner.

Card that was put into a deck. New card that should be put into the deck instead.

Modify the alternative options (options other than picking a card offered in a card reward). Ex: Skip, Heal +2 (Dream Catcher), Sacrifice (Pael Wing).

Player to whom we are presenting the options. The reward that is being displayed. Card reward alternatives. Whether the alternatives were modified.

Modifies the options for a card reward.

The player receiving the rewards. Options in the card reward. How the original cards were created.

CAREFUL! You should usually use TryModifyCardRewardOptions instead of this. Modifies the options for a card reward.

The player receiving the rewards. Options in the card reward. How the original cards were created.

Modify the amount of energy that a card will cost during combat. This will never be called while outside of combat.

Card whose energy cost we're modifying. Original energy cost. Modified energy cost. Whether the energy cost was modified

CAREFUL! You should usually use TryModifyEnergyCostInCombat instead of this. Modify the amount of energy that a card will cost during combat. This will never be called while outside of combat.

Card whose energy cost we're modifying. Original energy cost. Modified energy cost. Whether the energy cost was modified

Add or remove keywords on a card during combat. This is the global counterpart to the local keywords stored on the card itself (see ), and works just like does for energy cost: a model contributes keywords for as long as it exists, with no explicit cleanup needed when it's removed. This will never be called while outside of combat. Mutate in place (add or remove).

Card whose keywords we're modifying. The card's current keyword set, to be mutated in place. Whether the keyword set was modified.

Modify the amount of star that a card will cost.

Card whose star cost we're modifying. Original star cost. Modified star cost. Whether the energy cost was modified

Modify the amount of a power that will be applied to the target.

Canonical power that will be applied. Creature who the power will be applied to. Original amount of the power to be applied. Optional creature who will be applying the power. New amount of the power to be applied. Whether the amount was modified.

Modify the options offered to the player when they enter a rest site.

Player who owns the rest site options Rest site options Whether the options were modified.

Modify the rewards received when resting at the rest site. Normally this is empty.

The player being offered rewards. The rewards offered to the player. Is a mimicked rest site heal? Used in spots that mimicking a rest site heal, but are not actual rest site heals. For example: mimicks a rest site heal when you select certain options. This should count as a rest site heal for , but not for . Whether the rewards were modified.

Modify the rewards offered to the player. Remember that rewards can be generated in several ways: - As part of the end of an encounter - By relics like Orrery - At a rest site by Tiny Mailbox or Dreamcatcher - By an event like The Future of Potions

The player being offered rewards. The rewards offered to the player. The room which the rewards are generated for. If this is null, then the rewards were generated as part of something that wasn't room completion (e.g. an event choice or a relic pickup). Whether the rewards were modified.

CAREFUL! You should usually use TryModifyRewards instead of this. Modify the rewards offered to the player after completing a particular room/encounter. Works just like TryModifyRewards, but runs after it.

The player being offered rewards. Rewards The room which the rewards are generated for. If this is null, then the rewards were generated as part of something that wasn't room completion (e.g. an event choice or a relic pickup). Whether the rewards were modified.

Modify the extra text that will be displayed when the player heals at the rest site. Most implementors use this to add extra lines of text.

The player who is at the rest site. The current extra text that will be displayed. The new extra text that will be displayed.

If a card would be added to the player's deck, should it still be?

Card to be added. Whether to allow it.

Should we allow the specified affliction to be added to this card?

Card to be afflicted. Affliction that would be added to the card. Whether to allow the affliction.

Should we allow the player to speak to this Ancient? Used by things like the Wax Choker relic.

Player speaking to the Ancient. Ancient the player is trying to speak to. Whether to allow it.

If an effect would normally hit a creature, should it still? See for how hitting differs from targeting.

Creature who we want to hit.

If a player tries to target a creature, should they be allowed to?

Creature who we want to target. Whether to allow player to target creature.

Called after a reward is selected at the rewards screen to determine whether or not we should close the rewards screen.

Player to whom we are presenting the options. The reward that is being displayed. True to allow the player to continue to select rewards, false otherwise.

If a creature's block is about to be cleared, should it still be cleared?

Creature whose block is about to be cleared. Whether the creature's block should still be cleared.

If a creature is about to die, should they still?

Creature who is about to die. Whether the creature should still die.

CAREFUL! You should usually use ShouldDie instead of this. If a creature is about to die, should they still? Works just like ShouldDie, but runs after it.

Creature who is about to die. Whether the creature should still die.

After the player selects a Rest Site option, should we still disable the rest of them?

Whether to disable remaining Rest Site options.

If a player is about to draw cards, should they still?

Player is about to draw cards. draw is part of the initial hand draw at the start of your turn. Whether the player should still draw cards.

If Ethereal is about to trigger for a card, should it still?

The card that is about to be Exhausted due to Ethereal. Whether the card should still be Exhausted.

If a player is about to flush their hand, should they still?

Player who is about to flush their hand. Whether the player should still flush their hand.

If a player is about to gain stars, should they still?

Amount of stars they would gain. Player who is about to gain stars. Whether the player should still gain stars.

If a player is about to receive treasure from a treasure room, should they?

Player who is about to receive the treasure. Whether the player should receive the treasure.

If a player is about to pay an energy cost that they don't have enough energy for, should they be allowed to spend stars to pay for the excess energy cost?

Player who is about to spend energy. Whether the player can spend stars to pay for the excess energy cost.

If a card is about to be played, should it still?

Card that is about to be played The type of autoplay this card play is (ie played by echo form). None if its not an auto play. Whether the card should still be played.

If the player's energy is about to be reset, should it be reset? If not, the player's max energy is still added on to the current amount.

Whether the player's energy should be reset.

If the player is attempting to proceed to the next point on the map, should they be allowed to?

Whether to allow it.

If the player would procure the specified potion, should they still?

Potion we are procuring. Player trying to procure the potion. Whether to allow it.

If the power should be removed after the creature has died. For things like Calcify which can prevent this.

Whether the power should be removed on death

If the player has just purchased something from the merchant, should the now-empty entry be refilled?

Entry that might be refilled. Player who is at the merchant. Whether the merchant entry should be refilled.

At the merchant, should the player be allowed to remove cards?

Player who is at the merchant. True if the player should be allowed to remove cards, false otherwise.

If this creature just died, should it be removed from combat? Usually true, but things like reviving powers should return false so they can revive the creature later.

Creature that died. Whether the creature should be removed from combat.

If all enemies are dead, should we stop combat from ending? This should be set to true when all enemies are dead but new enemies are about to spawn.

Whether combat should be marked as about to end

If the player should be allowed to take an extra turn.

Player ending turn. Whether to allow it.

If true is returned from this hook, a potion will always be generated in the rewards for the room, no matter what.

Player who is receiving the reward. Type of room that the reward is being offered in.

When the player is able to choose a map point, should they be allowed to choose any map point in the next row?

Model which listens to events and unlocks an achievement when conditions are met. Note only combat-related achievements are unlocked this way. Some are unlocked via calls from nodes. Look at all uses of AchievementsUtil.Unlock to find all achievement unlocks.

Grants an achievement when the player exhausts a large number of cards in a single turn.

Grants an achievement when a player deals a large amount of damage in a single blow.

Grants an achievement when a player applies a large amount of Doom to a single creature.

Grants an achievement when the player applies a large amount of Strength to Osty.

Grants an achievement when the player forges a Sovereign Blade which deals a large amount of damage.

Grants an achievement when the player obtains a large number of Stars.

Grants an achievement when a player plays a large number of Sly cards from a single card.

Grants an achievement when the player applies a large amount of poison to a single creature.

The index where the act can appear when the list of acts is generated. 0 => first act, 1 => second act, 2 => third act. Returns negative if this act should never be organically shown to the player.

Whether this is the default unlocked act. For example, Overgrowth is unlocked by default, but Underdocks is not.

Color of the dots on the map after you've traveled through them. Also affects the color of the Boss and Ancient nodes.

Color of the dots on the map for paths you haven't traveled. Also affects the color of the Boss node before you get adjacent to it.

The number of rooms we have for an act, not including any external modifications (ie multiplayer) NOTE: this excludes the boss room or ancient room

Returns the number of rooms we have for an act accounting for if we are in multiplayer or not. NOTE: this excludes the boss room or ancient room

Returns the number of floors for this act, which includes the boss floor and ancient floor

All the monster encounters in this act. Do not put conditional checks in here.

Generates every encounter that is in this act. Overriden in subclasses, but should only be called once by so it can be cached.

Returns true if the act is unlocked given the passed unlock state, false otherwise.

All the weak monster encounters in this act.

All the regular (non-weak) monster encounters in this act.

All the elite monster encounters in this act.

All the boss encounters in this act.

All the monsters you can encounter in this act.

The path for this act's Treasure Chest Spine animation resource.

The normal (non-stroke) skin name for this act's chest.

The stroke-outline skin name for this act's chest.

Overridden by ActModel to define what order bosses should be encountered in.

All the Ancients that are available in this act. Ignores Unlocks/Epoch state. Does not include shared Ancients.

The subset of shared Ancients that will be available in a mutable act instance. Will differ from run to run.

All the events that are available in this act (ignores Unlocks/Epoch state). Does not include shared events.

Returns every Ancient in this act that the player has unlocked.

Set the subset of shared Ancients that will be available in a mutable act instance. Generally called in , and will differ from run to run.

Called after a load. Re-generates specific rooms if necessary.

The boss encounter that has been rolled for this mutable instance of the act.

The second boss encounter for Double Boss mode (Ascension 10+), if set.

Whether this act has a second boss (Double Boss ascension mode).

The Ancient event that has been rolled for this mutable instance of the act.

Creates the map for this act.

Get a list of random ActModels. The ActModel at index 0 will be Act 1, index 1 will be Act 2, etc. This list is not _truly_ random; a given ActModel will only be rolled for the act index it belongs in. For example, Overgrowth may or may not be at index 0, but it will never be at index 1 or 2.

Rng to use for randomly rolling alternate acts. The object to use for checking unlock state. Set to true if we are in a multiplayer run. Disables checking local progress save for alt acts. Randomized list of acts.

Get the default list of ActModels. Act 1 (index 0) is . Act 2 is . Act 3 is .

Get the card that this is afflicting. This is almost never null, so we leave it as non-nullable to make it easier to use. If you really need to check for null, use .

Get the CombatState of the card that this is afflicting. Will never be null, since Afflictions are combat-only.

Can this afflict Unplayable cards? Usually true, because Unplayable cards sometimes have Sly and we might want the affliction's effect to still trigger. Some exceptions for when it doesn't make sense (like one that makes the card cost more energy).

Checks whether the specified card can be afflicted with this affliction. For example, Ringing can only afflict attacks, so this will return true if an Attack is passed, but false if a Skill is passed. Note: Do not override this method to REMOVE restrictions, just to ADD them. When you override it, make sure to call `base.CanAfflict`, and then add your own restrictions afterwards. You can also override some other methods to add specific types of restrictions (check AfflictionModel.cs for details).

Card to check validity of. Whether or not the specified card is valid to afflict with this.

Chooses random targets out of a set of cards to afflict.

The RNG set to use. Does not use Card.Owner because we may be the canonical version. The possible cards to afflict. Number of cards to afflict. The cards to afflict.

Remove this affliction from its card. Should only be called by and in tests.

Most of this Affliction's logic lives in .

This Affliction has no logic of its own. All logic lives in .

Most of this Affliction's logic lives in .

Most of this Affliction's logic lives in .

Most of this Affliction's logic lives in .

This Affliction has no logic of its own. All logic lives in .

Most of this Affliction's logic lives in .

Define the dialogue structure for this ancient. Each subclass must implement this to specify dialogues for all categories (first meeting, repeating, etc.).

Convenience method to get a character's dictionary key from its type. Usage: CharKey<Ironclad>() returns "IRONCLAD".

The characters for whom the "any character" dialogue options shouldn't be shown. For example, 's "any character" dialogue is friendly, but they don't trust the , so we blacklist them so we don't show these friendly dialogue options for them.

The color of the speech bubble in the Ancient events during Ancient Dialogue.

The initial options generated when entering an instance of this Ancient event. Will always be null in canonical events.

The icon used for this Ancient in the Run History screen. Also used in other spots, like .

The amount of health the player healed upon entering this ancient.

Generate an event option from a relic. This overload also generates an onChosen callback that makes the player obtain the specified relic and then finishes the event.

Name of the page that this option is in, for metrics/gameinfo and loc. INITIAL by default. custom page path that this choice goes to next Relic whose title, description, and HoverTips should be used for the event option.

Generate an event option from a relic. This overload also generates an onChosen callback that makes the player obtain the specified relic and then finishes the event. See for more details.

Model which listens to events and keeps track of stats for badges. This holds no backing data for the badge itself. See for that. Only a few badges use this because most unlocks can be computed from the SerializedRun at the end of the run. Badge could probably get merged into this at some point, but be wary, because the IDs don't match up with the IDs generated for models.

Data class for Badges. This is the actual backing class with the data for the badge. BadgeModel only exists to listen to combat events.

By default, a badge requires you to win to obtain it.

Given a Badge's Rarity, returns the appropriate asset that's used to hold the badge icon.

The rarity used by Badges in the Run Summary screen. The rarity is based on how hard they are to get and reward bonus points the harder they are. Used for tiebreakers amongst players who have a tied score in the Leaderboards.

Won with a deck of 40, 60, or 100 or more cards.

Won with a deck of 40, 60, or 100 or more cards.

Play 20 cards in a single turn.

Play 20 cards in a single turn.

Play 20 cards in a single turn.

Won with 5 or more Curses.

Won with 5 or more Curses.

The player who dealt the most damage in a multiplayer game gets this badge.

The player who dealt the most damage in a multiplayer game gets this badge.

Keeps track of how many debuffs a player has applied.

Obtained both fake and real Snecko Eyes.

Obtained both fake and real Snecko Eyes.

Defeat X Elites. The more you kill, the higher the rarity.

Defeat X Elites. The more you kill, the higher the rarity.

Won with Max HP reduced to less than half of your starting HP.

Won with Max HP reduced to less than half of your starting HP.

Increased Max HP by a great amount and won.

Increased Max HP by a great amount and won.

For each time you Mend in multiplayer, you get a higher tier badge!

For each time you Mend in multiplayer, you get a higher tier badge!

Every card in the deck is unique (excluding Starters).

Every card in the deck is unique (excluding Starters).

Deck contains 5+ of the same card

Deck contains 5+ of the same card

Have 25 or more relics on death (win or lose).

Have 25 or more relics on death (win or lose).

Spent more than 1,000 Gold at the Merchant (aggregate).

Spent more than 1,000 Gold at the Merchant (aggregate).

Win a run with 200, 400, 600 gold remaining.

Win a run with 200, 400, 600 gold remaining.

Traveled to 15 or more ? rooms.

Traveled to 15 or more ? rooms.

Defeat a boss without taking damage.

Defeat a boss without taking damage.

The player rested at every rest site and won.

The player rested at every rest site and won.

The player won a run without ever resting.

The player won a run without ever resting.

The faster you win a run, the better the badge!

The faster you win a run, the better the badge!

Won with 1 Max HP.

Won with 1 Max HP.

Won a run with 20, 10, 5 or fewer cards.

Won a run with 20, 10, 5 or fewer cards.

THIS BADGE IS CURRENTLY NOT IN USE Deal more than 100 damage with a single card. DESIGN NOTE: Not a great badge because it overvalues a specific archetype.

THIS BADGE IS CURRENTLY NOT IN USE Deal more than 100 damage with a single card. DESIGN NOTE: Not a great badge because it overvalues a specific archetype.

Encapsulates the data needed to play an animation and accompanied sfx for a "move" for a given creature in the Bestiary.

These values are constructor parameters rather than abstract properties to avoid virtual dispatch. Most cards have constant values for these properties, so storing them in fields eliminates the overhead of virtual method calls on every access. Cards with dynamic behavior (e.g., MadScience) can still override the virtual properties.

Manages card restrictions based on how many players there are in a run.

Visually what pool we want the card to be from. Normally this is the same as the regular pool. It is not the case when we want it to be part of one pool, but look like its from another pool ie Trash Heap cards are event cards, but we want the colors to reflect their original character cards from sts1

Get the Player that this card belongs to. Will technically be null on a canonical card model and in certain edge-case timing moments (end of combat before transitioning to the next room), but we should rarely be checking that, so we leave this as non-nullable for convenience in 99% of cases. If you really need to check for null, override the warning with a comment.

The pile which this card is in. Can be null when used by Card HoverTips, Card Rewards, Card Library, things like that.

This card's "official" starting energy cost. This is what would appear on the card if it was printed out on paper. Note: If you want to check a card's canonical energy cost, use instead.

Whether this card has an energy cost of X. X-cost-cards automatically spend all of the player's remaining energy when played, and their effect is multiplied by the amount spent. Note: This exists on CardModel for the purposes of overriding in subclasses. If you want to check if a card has an energy cost of X, use instead.

WARNING: Only use this in tests. Set this card's energy cost.

All energy-cost-related information and logic about this card.

Internal method for to invoke the EnergyCostChanged event.

Resolve this card's X energy value. Takes modifications to X values (like ) into account.

The number of extra times this card's logic should be executed when it's played, excluding any effects from other models. Defaults to 0, but various effects can permanently set this to a higher value.

The number of extra times this card's logic should be executed when it's played, including any effects from this card's enchantment if it has one.

Was this card's star cost just recently upgraded? This is mainly used to show upgrade preview values in green. This should be cleared after the upgrade is complete.

Get this card's current star cost. This works just like passing but for stars, and with one exception. If the card had no star cost (it was negative) and it is temporarily set to zero, then we still treat the card as if it has no star cost, so that it still doesn't show up on the card.

The amount of stars most recently spent to play this card. Used when duplicating X-cost cards, to make sure the duplicates are played with the same value. WARNING: Only use this for calculations related to stars spent. If you're using this to calculate a cost-X-stars card's effect, use instead, as it will take X-value modifications (like ) into account.

Resolve this card's X star value. Takes modifications to X values (like ) into account.

Defines who what creature we should be targeting/highlighting. Some examples: - AnyEnemy means that this is a single target attack. - AllEnemies: this is an AOE attack so highlight all valid enemies - Self: This is a power applied to the player, highlight the players character

The keywords applied directly to this card: its canonical keywords, plus any added by , minus any removed by . This is the persistent, instance-owned keyword state; it is what gets cloned, and is unaffected by other models in the combat state. See for more details.

This card's current keywords, including both local keywords () and any global keywords () granted by other models in the combat state (e.g. Ethereal from ). See .

Get this card's keywords, including the specified source types. This mirrors : local keywords live on the card, while global keywords are computed on demand from other models in the combat state and are never stored.

This card's tags. See for details on how to use these. NOTE: The current implementation assumes a card's tags will never change. If we ever need to dynamically add or remove tags after creation, change this to work more like Keywords.

This is used for cards like Havoc and Cinder to mark cards that should be sent to the exhaust pile instead of the discard pile on their next play. TODO: This might be kind of a hacky solution. We should look into other ways to pass this info along.

Should this card be retained this turn? True if the card has the Retain keyword, or if some effect like Well-Laid Plans has made it retain for a single turn and it's still that turn.

Is this card Sly this turn? True if the card has the Sly keyword, or if some effect like Hand Trick has made it Sly for a single turn.

Whether or not playing this card can heal the player or their pets, either directly (like Feed) or by giving you something else that can heal you (like Alchemize giving you a Regen Potion). Used primarily to filter cards out of random in-combat generation effects, to avoid making annoying "optimal play" behavior.

Used to filter cards out of modifier pools. Ancient curses and Ascender's Bane should not be generated by Cursed Run.

Manages if and how a card will Evoke an Orb. Applies to cards like Dualcast, which say "Evoke your next Orb". Does NOT apply to cards that may evoke an Orb as a side-effect (like Zap's channeling causing an Orb to evoke). Used primarily to visually update the numbers displayed on your Orbs to reflect their Evoke values while dragging a card.

Whether or not playing this card gains you block immediately. True for cards like Defend and Survivor. False for cards like Shadowmeld (which doesn't gain you block until you play an attack after). Used for things like filtering the Nimble enchantment's targets. Also automatically sets the block HoverTip. Note: Don't convert this into a CardTag. It's used by the system for automatic Osty targeting behavior.

Is this card one of the basic Strikes or Defends that you start the game with? Used for things like Pandora's Box that only operate on these specific starter cards.

The card that this is a clone of. Null when this card is not a clone (which is most of the time). Clones are exactly the same as any other type of card, we just keep track of the original to make some effects easier to implement (like ).

Whether or not this card is considered a clone. See for more info on clones.

The card that this is a duplicate of. Null when this card is not a duplicate (which is most of the time). Dupes behave slightly differently from original cards in some situations. For example: * After playing a dupe, it is sent to the Limbo pile, rather than Discard/Exhaust. * Dupes cannot be further duplicated by effects like Duplication Potion. * If an X-cost card is duped, the dupe retains the X-value from the original.

Whether or not this card is considered a duplicate. See for more info on dupes.

Is this card currently appearing as a previewed upgrade in ? And if so, what type of upgrade preview is it? This is to facilitate having upgrade previews reflect power values from the player in combat (i.e. Armaments).

Override this property to add extra conditions to check before allowing play. For example, Grand Finale is only playable if your draw pile is empty, so it would override this.

Set via constructor parameter to block a card from appearing in the Card Library screen.

Override this property to add conditions to check to determine whether to show a gold glow on this card. For example, Evil Eye adds 6 extra block if you've exhausted a card this turn, so it would override this.

Override this property to add conditions to check to determine whether to show a red glow on this card. For example, Normality should glow red when it blocks card plays.

Is this card currently appearing as a previewed enchanted card in ?

Index of the play currently in progress while this card is being played (0 = first play, 1 = first Replay, etc.). Lets damage previews reflect mid-Replay state before the current play's History entry has been logged.

Set to true when this card is removed from the combat/run state (happens pretty rarely, like when a card is transformed or removed from the player's deck). Set to false when the card is added _back_ to the combat/run state (even more rarely, like when steals a card and then you add it back to your deck later).

The state of the run that this card exists in. Null for cards that exist outside of a run (in the Compendium, in preview HoverTips, etc.)

The state of the combat that this card exists in. Null for cards that exist outside of a combat (deck cards, cards offered in rewards or at events, etc.)

The lowest-level scope that this card exists in. Combat takes precedence over run, since all cards in a run have a , but cards that have been added to combat also have a CombatState. Note: For operations that need a scope during combat, we check the owner's CombatState as a fallback because CombatState is null for cards in non-combat piles (like the deck).

Extra logic that should be run after the card is created (NOT during deserialization). At this point, the card will have an owner, and will be in a or .

Extra logic that should be run after deserializing. This should rarely be overridden, just for very unusual cards like .

Upgrade the star cost of this card by the specified amount. This is meant to be called in OnUpgrade.

Amount to add to the current cost (usually negative).

Set this card to be retained this turn. Will be cleared at the end of the turn.

Set this card to be Sly this turn. Will be cleared at the end of the turn.

Updates the dynamic variables of this card based on hooks (i.e damage, block, and powers). This is so powers and relic modifications to these values can be reflected in card descriptions.

The type of preview to show in the card's visuals. See for details. Creature who this card is targeting, if it exists. The dynamic variables for this card.

Add an Enchantment to this card.

You should generally use CardCommands.Enchant instead of this method. If you do use this method, you may need to call after. Enchantment to add. Amount to set on the added enchantment.

Add an Affliction to this card.

You should generally use CardCmd.Afflict instead of this method. Affliction to add. Amount to set on the added affliction Whether or not adding the affliction was successful.

Get this card's current star cost, including all modifiers. Usually, this will just be the same as CurrentStarCost, but there are 2 exceptions: 1. X-cost cards will return the amount of stars that will be spent to play them instead of a 0 placeholder value. 2. Effects that modify star costs will be reflected here.

Current energy cost including modifiers.

Does this card have an energy or star (or both) cost? Used by effects that make cards totally free (no energy OR star cost), to avoid selecting cards that are already free.

Whether to include global modifiers in the cost. See for details.

Override this method for when this card is played.

The CardPlay that is being executed.

Override this method to add VFX that should run the moment the mouse is released when playing this card. This is different from OnPlay, which is meant for game logic (dealing damage, gaining block, etc.), and won't run until the card play action is dequeued from the action queue. WARNING: Don't put any game logic in here! It might do things you don't expect.

Creature that this card is targeting. Should be null for un-targeted cards.

Override this method with logic for when this card is upgraded. To upgrade a card's dynamic vars, use . To upgrade a card's energy cost, use .

Override this property to run this card's when the player ends the turn with this card in their hand.

Override this method for when the player ends the turn with this card in their hand. NOTES: * You must also override to return true. * While this method is being run, this card will be in the Play pile. * After this method is run, this card will be added to the Discard pile.

The choice context to use in the event of a player choice.

Can this card be played with the specified creature as the target?

Creature for this card to target. Null when attempting to play with no target (like Defend). Whether the card can be played with the specified target.

Can this card be played?

Can this card be played?

Out param containing the reason that this card cannot be played (None if it can be played). First model that made this card unable to be played (null if there is no preventer). Whether this card can be played.

Returns true if target is valid for this card. NOTE: This operates differently than potions! Do not try to unify this with PotionModel.IsValidTarget unless you change UI targeting; namely, PotionModel's TargetType.Self passes a target, whereas this one doesn't.

Spend the resources required to play this card.

The energy and stars spent.

Run all the logic for playing this card.

The context that is signalled in the event of a player choice. The creature that this card is targeting. Null for un-targeted cards. Whether this card is being auto-played. False when the player plays the card manually from their hand. True when played automatically by an effect like . Info about the resources used when playing this card. Skip card pile visuals (tween to/from pile, smoke puff VFX, etc).

Generate the number of times this card's OnPlay effects should be executed when it's played. Runs hooks to modify the play count, including state-modifying hooks like . This means you can only run this method in situations where it's okay to modify combat state (i.e. not as part of previews).

The combat state that this card is being played in. The creature that this card is targeting. Null for un-targeted cards.

Plays the VFX which makes the card swirl and fly into the player. Should only be done for power cards.

Get the pile that this card should be moved to after being played.

Send the card to the correct pile after it was attempted to be played while unplayable. This is the same as MoveCardToResultPileAfterPlay with one important exception: Power cards do not get sent to Limbo, and instead get sent to the discard.

WARNING: If you're thinking of calling this from inside a model, you probably want instead. Upgrade this card. This does not run any hooks.

Finalize an upgrade after calling UpgradeInternal. This clears out state that is used for displaying an upgrade preview.

Gives cards a chance to add extra "cleanup" logic for downgrades. No-op by default.

Create a clone of this card. Clones must only be created in combat; for run-level clones, see . See for more info on clones, and the difference between a clone and a dupe.

Create a dupe of this card. See for more info on dupes, and the difference between a clone and a dupe.

Create a CardModel from a SerializableCard. Be careful calling this! Make sure all callers eventually use to add the card to the correct scope.

Returns all card-related asset paths for a run.

Cards can define VFX that are displayed in combat here. These are not preloaded when only the card would be displayed, e.g. in the compendium.

The color of the card back when viewing a card from this pool in the Run History screen.

The color of the outline of the text in this card's Energy UI. It must blend with the energy icon of this card!

Get every card in this pool (ignores Unlocks/Epoch state).

Get the IDs of every card in this pool (ignores Unlocks/Epoch state).

Generates every card in this pool (ignores Unlocks/Epoch state). Overridden in subclasses, but should only be called once by so it can be cached.

Returns every card in this pool that the player has unlocked. This excludes cards that haven't been unlocked via certain epochs. We also can filter cards based on whether they are allowed to appear during a singleplayer or multiplayer run. Used to filter cards through unlocked epochs. Used to filter cards based on if this is a singleplayer or multiplayer run.

Returns a list of cards but prunes out cards if the associated Epochs aren't revealed.

Is this a colorless card pool? False for card pools that are associated with a specific character (like ), true for other card pools (like or ).

We use Early here to prevent it from double-triggering if another auto-pre-play phase effect (like ) also causes it to Exhaust.

Placeholder event if we can't find the card we are looking for (such as in the case that it's been deprecated)

Placeholder event if we can't find the card we are looking for (such as in the case that it's been deprecated)

ONLY USE THIS IN TESTS!

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

Used for tests.

ONLY USE THIS IN TESTS!

Required so we can restore the extra damage amount after a downgrade (ie Magiknight)

Create new Soul cards, owned by the specified player, and add them to their hand.

Player who will own the Soul cards. Number of Soul cards to create. CombatState to create the Soul cards in. The newly-created Soul cards.

Create new Soul cards, owned by the specified player.

Player who will own the Soul cards. Number of Soul cards to create. CombatState to create the Soul cards in. The newly-created Soul cards. Dynamic TargetType based on whether the player has . Dynamic GainsBlock based on whether the player has .

ONLY USE THIS IN TESTS!

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

The only difference between the starting Strike cards are portrait, attack vfx, and color.

Yes, Ultimate Defend counts as a Defend for the purposes of effects like .

Is this a playable character? True for the characters that can be played in the game. False for test characters (), meta-characters (), etc.

The name of the character. e.g. Ironclad, Silent, etc.

The name of the character in object form. This is the same as Title in english, but may be different in other languages. For example,

Color used when rendering this character's name in the Statistics screen.

The gender of the character for grammatical purposes.

What character do you need to do a run with to unlock this one? Returns null if there is no pre-requisite character.

The color of the speech bubble during Ancient dialogues.

Color of speech bubbles when the character talks (e.g. to the Architect)

Assets required for the character select screen

Assets required for the run.

Get the VFX paths to use when this character is attacking .

Add details about this character to the given LocString.

Get the text to show on the character selection screen that explains how to unlock this character.

Placeholder character for if we can't find the character we are looking for (like if it's been deprecated).

Ironclad starts out unlocked. You'll always unlock Silent by doing a run with Ironclad since he's the only character you start out with, but technically you unlock her by doing a run with any character.

Set this to true to sort the card to the bottom of the draw pile at the beginning of combat.

Get the card that this is enchanting. This is almost never null, so we leave it as non-nullable to make it easier to use. If you really need to check for null, use .

Does this enchantment have a card?

Checks whether the specified card can be enchanted with this enchantment. For example, Sharp can only enchant attacks, so this will return true if an Attack is passed, but false if a Skill is passed. Note: Do not override this method to REMOVE restrictions, just to ADD them. When you override it, make sure to call `base.CanEnchant`, and then add your own restrictions afterwards. You can also override some other methods to add specific types of restrictions (check EnchantmentModel.cs for details).

Card to check validity of. Whether or not the specified card is valid to enchant with this.

Override this property to add conditions to check to determine whether to show a gold glow on this card.

Override this property to add conditions to check to determine whether to show a red glow on this card. For example, Corrupted causes the card to glow red if it will kill you.

WARNING: If you're thinking of calling this from inside a model, you probably want instead. Apply this enchantment to the specified card. This does not run any hooks.

Card to enchant. Amount for the enchantment.

Run this enchantment's modification logic on the enchanted card. You usually want to call first. This is called after a card is first enchanted, and after it is deserialized. It is also called when an enchantment's modification logic needs to be refreshed. For example, after a card is downgraded, its DamageVars will be reset to their original values. If the card is enchanted with Sharp, we need to re-execute its modification logic so the card's damage will still be increased. It is NOT called when a card is cloned, because the enchantments effects will already be reflected in the card's values.

Modify the card that this is enchanting. Use this for enchantments that do things similar to upgrades, like change the values of a card's DynamicVars (Sharp), change a card's keywords (Royally Approved), change a card's energy cost (Tezcatara's Ember), etc. To modify a card's energy cost, use .

Add to the amount of block that this enchantment's card gains. This hook runs BEFORE all other block modification hooks. Enchantments MUST use this hook instead of .

The original amount of block that would be gained. The amount to add to the block gain.

Modify the amount of block that this enchantment's card gains. This hook runs BEFORE all other block modification hooks. Enchantments MUST use this hook instead of .

The original amount of block that would be gained. The amount to multiply the block gain by.

Add to the amount of damage that this enchantment's card does. This hook runs BEFORE all other damage modification hooks. Enchantments MUST use this hook instead of .

The amount of damage that would be dealt. ValueProp for damage. Amount of damage to be added.

Multiply the amount of damage that this enchantment's card does. This hook runs BEFORE all other damage modification hooks. Enchantments MUST use this hook instead of .

The amount of damage that would be dealt. ValueProp for damage. Amount that the damage should be multiplied by.

Modify the number of times this enchantment's card is played. This hook runs BEFORE all other card play count modification hooks. Enchantments MUST use this hook instead of .

The original number of times this card would be played. The new number of times this card should be played.

This enchantment doesn't actually do anything on its own. Instead it is reference by cloneRestSiteOption when its looking for cards to duplicate.

An encounter represents a single combat encounter. It can be a weak encounter, normal enemies, elites, boss fight, or enemies you fight during an event. Encounters may be made up of one or more monsters and the enemies the player fights may not always be the same due to randomization of that encounter.

A per-encounter RNG that we can use to do random rolls in the encounter (for things like monster HP) independently of the run's centralized RNG. This is safe to do in encounters because we don't need to keep track of a given encounter's RNG state once it's over. The private backing field for this can be null, but by the time this is being accessed by subclasses, it should always be set. If it's not, you're doing something wrong.

Is this one of the weak encounters that we start acts with?

Should this encounter give combat rewards when it's over? Usually true, but many event-specific encounters set this to false.

The description for this encounter's custom reward. For example, uses a to give you your stolen card back, and we use this field to specify the "Take your stolen card back" text for the reward button.

Is this an encounter that's used for debugging, testing, etc.?

Have this encounter's monsters been generated yet? Used for delayed-start combats (like combat-style events that can transition to combats) to make sure we don't try to re-generated already generated monsters when the actual combat starts.

Generate the monsters that the players should fight in this encounter.

The that this encounter exists in. Used for things like generating a deterministic RNG, etc.

Returns a list of (mutable) monsters in this encounter, along with the slot they should be placed in. This should only be used when generating a real encounter, not when generating the hypothetical monsters that could be in the encounter. For that, use AllPossibleMonsters.

A list of all the monsters that were present in this encounter. This counts monsters that were initially spawned in the encounter, as well as monsters that were summoned during it.

Should the players be fully centered in the encounter? Usually this is false, because we want to leave padding in the center for card plays. However, in certain situations (like "surrounded" combats), we want to fully center the players and just live with them being temporarily covered by played cards.

Used for pre-loading boss map assets

Randomize the per-encounter RNG. Should only be used for debugging (like in the `encounter` console command) to keep from rolling the same

Get the message to show when the specified character loses in this encounter.

Character that lost.

The proportion (0-1) of gold rewards the players receive when this encounter's combat ends. Defaults to the fraction of spawned enemies that were defeated rather than escaped. Override for encounters with bespoke escape/reward rules (e.g. ).

Override to persist encounter-specific state when saving a pre-finished combat room.

Override to restore encounter-specific state when loading a pre-finished combat room.

Called when a creature is spawned during combat. If it's an enemy, it's added to the SpawnedEnemies list.

Represents an encounter that has been removed from the game. Mostly used for the run history.

Whether GremlinMerc stole at least some gold this combat. Set by when the merc dies and its stolen gold is transferred to Fat Gremlin.

Deterministic events send out a checksum at their end. It's skipped for non-deterministic ones. - All standard events should be deterministic - All shared events are combat-related, and we don't trust end-of-combat rewards to be deterministic - One-off events which grant rewards are non-deterministic, such as Crystal Sphere

Get the owner of this particular event instance. When players enter an event in a multiplayer run, a separate EventModel instance is created with each player as the owner. Only the event owned by the local player is displayed in , but the other instances still exist on each player's device, so keep that in mind when using this property. Will be null in canonical events.

In non-shared events, multiplayer players may choose options independently. In shared events, multiplayer players vote on an option. Then, the top-voted option is executed for all players. There is no difference in singleplayer. All events that transition to other rooms (e.g. Dense Vegetation) must be shared.

The encounter that should be displayed when entering this event. Only relevant when is .

Generated via for combat-style events.

Generated via for combat-style events.

Wrapper around abstract GenerateInitialOptions, similar to . Making this virtual lets us change initial option generation behavior in entire categories of events (like Ancient events), while still letting concrete event subclasses override the inner GenerateInitialOptions method.

Defensively protect against misconfigured events with null options.

Used by to stop the initial options from showing until the initial animations have played. Probably worth coming up with a more robust solution after EA release.

Whether or not this event is allowed to be entered based on the specified combat state. This will usually just return true, but some events require special conditions. For example, can only be entered if you have 5+ relics and you're on act 2+.

A per-event RNG that we can use to do random rolls in the event independently of the run's centralized RNG. This is safe to do in events because we don't need to keep track of a given event's RNG state once it's over. Null in canonical events, but we should never be using it there, so we mark it as non-nullable.

Get all the EventOption LocStrings shown on the initial page. Used by NGameInfoUploader to upload info about the game for lookup elsewhere. Override in events with unusually dynamic options like .

Create the scene that will be used for this event.

The node that is being shown for this event. Null for canonical events, and before a mutable event has been initialized.

Create the visuals for the combat room that will be used for this event. Only relevant to events.

Gets called when entering an Event. Useful for setting ambient vfx, changing music, etc

Gets called when an event is resumed. This should handle setting up the appropriate next page. This happens when the player was in an event, entered a new room (NOT a new ), and then finished that room, causing them to resume the event room. This is most common in events where a choice can start a combat, like Dense Vegetation's Rest + Fight choice.

The room that was exited before this was resumed.

Call this from an event option function when the event is all finished and the player should be able to proceed.

The description to set on the event room.

Virtual function for events to hook onto if they need to do stuff before the event starts.

Virtual function for events to hook onto if they need to do stuff after the event starts.

Virtual function for events to hook onto if they need to do stuff when the event ends.

Ensures OnEventFinished is called exactly once, preventing double-cleanup.

Call this from an event option function when the event's description and options change to new ones.

The new description to set on the event room. The new choices to present to the player.

Enter an encounter, then return to this event once the encounter is finished.

Extra rewards to give the player in addition to the encounter's normal rewards. Whether to resume this event after the encounter is finished. Usually true, but some events (like ) have no more options after combat ends, so they pass false to directly proceed to the next map point after combat ends.

Enter an encounter, then return to this event once the encounter is finished.

The mutable model of the encounter to start. Extra rewards to give the player in addition to the encounter's normal rewards. Whether to resume this event after the encounter is finished. Usually true, but some events (like ) have no more options after combat ends, so they pass false to directly proceed to the next map point after combat ends.

Generate an event option from a relic.

By default, the passed relic's title and description will be used as the title/description for this option. However, if events.json contains a {optionKey}.title and/or {optionKey}.description entry, they'll override the relic's associated field. For example, at the time of this writing, Pael's "Liquify" option grants the relic. We want this option's title to be "Liquify" (not ), but we want its description to be 's description. So, we pass textKey=PAEL.pages.INITIAL.options.LIQUIFY, and we add "PAEL.pages.INITIAL.options.LIQUIFY.title": "Liquify" to events.json, but we don't add a ".description" entry. Function to execute when this option is chosen Name of the page that this option is in, for metrics/gameinfo and loc. INITIAL by default. Relic whose title, description, and HoverTips should be used for the event option.

Generate an event option from a relic. See for more details.

Generate a key for the specified option.

Name of this option, for metrics/gameinfo and loc.

Generate a key for the specified page and option.

Name of this option, for metrics/gameinfo and loc. Name of the page that this option is in, for metrics/gameinfo and loc.

The player opted for 135 Gold rather than Pollinous Core + 7 damage

The player takes damage and gets the relic.

The top option. Get a random one without taking damage.

Choose 1 of 2

Choose 1 of 3

Player chose to bottle the water and get a Glowwater Potion.

Player chose to climb the Lighthouse. They lose Max HP and get the Fresnel Lens relic.

Generates a list of possible dishes and uses a weighted roll to determine a dish. Lots of exceptions and info here.

Player chose not to partake in the feast. Sad.

Note: don't add to this list, it's a combat reward, not a relic you can buy.

Used to end the enemies punching each other.

Only appears in Act 2 and requires all players to have at least 1 potion

This ancient's "any character" dialogue is friendly, but they don't trust the , so we blacklist them so we don't show these friendly dialogue options for them.

A "rider" is an additional effect that accompanies the card's base effect. The MadScience card has a base effect (deal damage, gain block, or apply a power) plus a rider effect chosen by the player during the TinkerTime event. Each card type (Attack/Skill/Power) has three possible riders to choose from.

Helper function because we create this event's descriptions dynamically

The name of the energy color that models in this pool should use.

The canonical model that applies this power.

for

The canonical power that this power internally applies.

for

Set the next application of this power to not actually be applied. This is used when debuffs are copied to other creatures by effects like . In these cases, the internal debuff gets copied along with this power, and upon copying, it should not apply the internal debuff again.

Returns every single class that subclasses AbstractModel. Prefer this over using AbstractModelSubtypes.All because it also returns models in mods.

Initializes the ModelDb. Note that the alternative is to initialize in a static initializer, but if we do this we don't control the time at which it gets initialized, and it usually happens at a bad time during gameplay.

Injects a model into the ModelDb. Should only be used in tests and mods.

The type to inject.

Removes a model from the ModelDb. Should only be used in tests and mods.

The type to remove.

Assigns IDs to all canonical models in the model database. This must happen after Init (i.e. the AbstractModel constructors); otherwise, there is a circular dependency between the static constructor and the ModelIdSerializationCache.

Precomputes a bunch of model data to speed up operations later.

Every Affliction defined in the game code, including mock ones for testing.

Every Enchantment defined in the game code, including mock ones for testing.

Get all the cards in the game (ignores Unlocks/Epoch state). Be careful using this, it includes cards that you shouldn't be able to randomly roll for rewards.

Get all the card pools in the game. Ignores Unlocks/Epoch state.

The card pools that are shared across all characters. WARNING: Do NOT add TestCardPool to this list, or test cards might accidentally appear in-game.

Get all the card pools in the game that belong to specific characters.

Get all the characters in the game (ignores Unlocks/Epoch state).

Get all the events in the game that don't belong to a specific act.

Get all the ancients in the game. Ignores Unlocks/Epoch state.

Get all the ancients in the game that don't belong to a specific act. Notably, we only have 1 right now. That's Darv.

Get all the events in the game (ignores Unlocks/Epoch state).

Returns a list of every possible Monster in the game.

Get all the encounters in the game.

Get all the potions in the game. Be careful using this, it includes potions that you shouldn't be able to randomly roll for rewards.

Get all the potion pools in the game.

Get all the potion pools in the game that belong to specific characters.

Get all the relic pools in the game that belong to specific characters.

Get all the potion pools in the game that are shared between all characters.

Get all the relics in the game (ignores Unlocks/Epoch state). Be careful using this, it includes relics that you shouldn't be able to randomly roll for rewards.

Get all the relic pools in the game.

Get all the relic pools in the game that belong to specific characters.

Get all the relic pools in the game that are shared between all characters.

All acts in the game. Note that callers depend on this list being sorted by act index, then by default/non-default. If you need a different ordering, feel free to change this or split into another list somewhere.

Run-lifetime model which alters the run for daily and custom runs.

If true, the player's deck will be cleared before AfterRunInitialized is called.

Get the additional text that this modifier should add to the "heal" option at the rest site. Returns null for modifiers that add no additional text.

Called after a new run is created with the modifier. Only called for new runs, not loaded ones.

Called after a run is loaded with the modifier.

If this returns a non-null function, the modifier is presented as an option at Neow. The function is called when the option is chosen. The option will have the modifier's title and description.

The event model for which the option should be generated.

A special hook for modifiers that is called right after the run is created for the first time. Used for initializing things like the relic bags. Note that this is not called when a run is loaded from save.

A special hook for modifiers that is called right after the run is loaded. Used for initializing things that are not serialized like base room odds. Note that this is not called when a run is created from scratch without loading.

Returns true if this is equivalent to the passed modifier. By default, two ModifierModels are considered equivalent if they are of the same type. The CharacterCards modifier overrides this to ensure that the character property is equal as well.

At time of death, a SubViewport is created with the bounds of the creature's spine body in its current pose. If the creature needs additional padding (usually because the death animation changes its bounds), this property can be adjusted so that the spawned SubViewport is larger.

For specific creatures that are very close, this value can be made some positive value so that their health bars do not overlap each other.

This RNG should be used for things that are nice to have synced between players. It should be deterministic as long as you only use it in deterministic contexts. It should ONLY be set in .

Run-scoped RNG set for the run that this monster is in.

Should the default fade animation be played after this monster dies? Usually true, but false for monsters with certain special death animations (Decimillipede, etc.) or that we want to keep around after death (Osty, etc.).

Used for creatures where we can't rely on the length of their death animations to delay the rewards screen. For example, 's and 's visuals are part of the combat background.

The creature that represents this monster in combat. Will technically be null on a canonical monster model, but we should never be checking that, so we leave this as non-nullable for convenience.

The CombatState that this monster's creature exists in. Will technically be null on a canonical monster model, but we should never be checking that, so we leave this as non-nullable for convenience.

Get this monster's move state machine. Null for canonical monster models.

Logic to run after the monster is first added to the combat room. No-op by default.

Logic to run after the monster is removed from the combat room. No-op by default.

Destroys the monster's move state machine.

Called when this monster is about to die to Doom. Primarily used set up the creature visuals for the Doom vfx (ie hiding nodes that have additive materials)

Helper to get the move name label for the Bestiary entry.

Monster class exists to connect this to the correct monster visual scene. All logic lives in the .

Monster class exists to connect this to the correct monster visual scene. All logic lives in the .

Monster class exists to connect this to the correct monster visual scene. All logic lives in the .

Represents a monster that has been removed from the game. Mostly used for the run history.

For cards that specifically come from Knowledge Demon's Curse of Knowledge move. Unlike normal cards, these have an immediate effect when chosen by the player.

The priorities used to determine which card to steal from the player's deck.

Track how many times call for backup has happened this combat. This is so we can limit it to 3.

Set to true when this is removed from a player's orb queue.

NOTE: Unlike other models' DynamicDescription, this doesn't include any variables. Someone should probably do that but it's a bit larger of a refactor than I want to do right now

Get the CombatState of the orb's owner. Will never be null, since orbs are combat-only.

This orb is for testing only. When this orb is Evoked, it removes its owner from combat, simulating the player exiting the run while an orb is evoking.

Get the player that owns this relic. Will technically be null on a canonical relic model, but we should never be checking that, so we leave this as non-nullable for convenience.

Whether or not using this potion can heal the player or their pets (like Fruit Juice), or do other restricted actions (like Fairy in a Bottle's resurrection). Used primarily to filter potions out of random in-combat generation effects, to avoid making annoying "optimal play" behavior.

Whether or not this potion passes its custom usability check. By default, there are no custom checks, so this always returns true. Subclasses can override this to add custom checks.

makes sure that we're either in combat, at the Merchant, or in the event.

Set to true when this potion is removed from a player's potion belt.

Remove this potion as part of using it.

Returns true if target is valid for this potion. NOTE: This operates differently than cards! Do not try to unify this with CardModel.IsValidTarget unless you change UI targeting; namely, CardModel's TargetType.Self does not pass a target, whereas potions do.

Ensure that the target is valid (non-null) for a targeted potion.

Thrown if the target is null.

Get every potion in this pool (ignores Unlocks/Epoch state).

Get the ID of every potion in this pool (ignores Unlocks/Epoch state).

Generates every potion in this pool (ignores Unlocks/Epoch state). Overriden in subclasses, but should only be called once by so it can be cached.

Returns every potion in this pool that the player has unlocked. By default, this is just AllPotions, but can be overriden in subclasses to remove potions that should be locked under certain conditions.

Only return the Potions if the associated Epoch is revealed. NOTE: This needs to be updated if a character has more than 3 potions. See: Defect4Epoch.cs

Only return the Potions if the associated Epoch is revealed. NOTE: This needs to be updated if a character has more than 3 potions. See: Ironclad4Epoch.cs

Used for test-only potions.

Only return the Potions if the associated Epoch is revealed.

Only return the Potions if the associated Epoch is revealed. NOTE: This needs to be updated if a character has more than 3 potions. See: Regent4Epoch.cs

Returns a list of Potions but prunes out any potions if the associated Epochs aren't revealed.

Only return the Potions if the associated Epoch is revealed. NOTE: This needs to be updated if a character has more than 3 potions. See: Silent4Epoch.cs

Used for generated potions that should not be automatically generated in rewards or shops.

Represents a potion that has been removed from the game. Mostly used for the run history.

This should never be executed directly by . It is only triggered by .

Tries to grab the merchant button and its parent screen context from the Shop/Fake shop room. Used for Foul Potion targeting.

NOTE: Unlike other models' DynamicDescription, this doesn't include any variables. Someone should probably do that but it's a bit larger of a refactor than I want to do right now

Should this power be visible? Don't make this virtual, use instead if you need to override.

Should this power be visible? Usually true, but overridden to false for powers that want to stay hidden and perform extra logic behind the scenes.

Should this power play VFX when applied/removed/flashed? Usually true for visible powers, but overridden to false for powers that don't want to be so "loud", like Osty's Die For You power.

The amount this power had at the beginning of the current turn. Updated at the very start of each turn before any hooks run. Useful for powers that should only trigger if they were present at turn start, preventing same-turn activation when applied mid-turn (e.g., via auto-play effects).

The color to use for this power's Amount label. Usually red for debuffs and cream for all other powers, but can be overridden for special cases.

Should this power be removed from its owner due to an amount change? Most powers are removed when they go below 0. Powers that allow negative amounts (Strength, DexterityPower, etc.) should be removed when they reach exactly 0.

This enables the behavior of duration-type powers (Vulnerable, Weak, etc.) ticking down at the end of the monster side turn, but skipping the first tick if a monster applied the power to the player.

Get the Creature that this power is on. Will technically be null on a canonical power model, but we should never be checking that, so we leave this as non-nullable for convenience.

The CombatState that this power's owner exists in. Will technically be null on a canonical power model, but we should never be checking that, so we leave this as non-nullable for convenience.

Get the Creature that this power targets. For most powers, this is null. It is used on instanced powers that each target a player in multiplayer.

"Public" data about this power. These data are visible everywhere else in the game. They can be displayed in localization entries, read/written by other callers, and if you clone this power, all these vars will be cloned along with it. If you have "private" data that should be invisible to the rest of the game, use .

If set to true, this power's amount will automatically be multiplied by the player count when applied.

If ShouldScaleInMultiplayer is true, this will be called before the power is applied to any enemies. Unless overridden, it applies a default scaling based on the number of players and . Be sure to use the passed combat state rather than CombatState, as it will not be set in time.

The combat state which will own the power. The creature applying the power. The amount of the power that is being applied. The target receiving the power. The card applying the power, if any. The modified amount to apply.

Initialize any internal data used by this power.

"Private" data that lives behind-the-scenes to make this power work as expected. These data are isolated to this instance of the power. They cannot be displayed in localization entries, and they will be reset on clones of this power. If you want to set data that is meant to be cloned and displayed in localization, use .

Hook that runs just before this power is first applied to its owner. Does not run if the owner already has this power, and its amount was just changed.

The creature to which this power is about to be applied. The amount of the power that is about to be applied. The creature that applied the power, if any. The card that applied the power, if any.

Hook that runs after this power is first applied to its owner. Does not run if the owner already has this power, and its amount was just changed.

Hook that runs after this power is removed from its owner. The owner of this power before it was removed.

Should this power be removed after its owner dies? Usually true, but false for powers that do things like revive their owner.

Should this power's owner's death trigger effects with the Fatal keyword like ? Usually true, but false for and a few other powers.

Hook that allows this power to classify the enemy as primary or secondary. See for detailed definitions.

This power doesn't actually do anything on its own. Instead, the Poison power checks for this power and re-triggers itself if it's there.

This is so the Test Subject doesn't receive powers while it is reviving

Keep track of the cards we've seen played and the power amount at the time they were played. This lets After Image avoid triggering on cards that started play before it was applied, and avoid gaining extra block on multiple plays of After Image.

This is just a marker power for to check for.

This is just a marker power for to check for.

Prevents Beacon of Hope from triggering if it already has triggered for this instance of block. This is to prevent Beacon of Hope infinitely triggering against another player Beacon of Hope.

We do this in AfterCardPlayed instead of AfterStarsSpent because stars are spent at the beginning of the card play, but Black Hole should trigger after the card is played.

We use Late because other effects may reduce damage taken to 0 too, and it's more player-friendly for them to trigger first so that this power doesn't have to decrement.

Draw an extra card at the beginning of your next N turns. This is distinct from due to its stacking behavior.

If Ethereal cards are exhausted at turn end, we want to give the resulting cards to the player after the flush occurs. In STS1 this is handled because the card draws are put on the queue, but here we have to manually defer.

cuts damage received in half.

This is so Osty won't receive powers while it is dead

Kill the specified creatures with the power. All creatures being killed in a given Doom trigger (side turn finish, , etc) should be passed at the same time here, otherwise we can miss Fatal triggers for reviving powers like . This does extra stuff in addition to a normal call: * Plays special VFX. * Runs . It's in a public method so effects like can use it.

Will the owner of this power die to Doom at the end of their turn?

Draw an extra N cards at the beginning of your next turn. This is distinct from due to its stacking behavior.

Just a visual timer for when will escape.

This power doesn't actually do anything on its own. Instead, the card checks for its existence and modifies its targeting.

Keep track of the cards we've seen played and the power amount at the time they were played. This lets Gravity avoid triggering on cards that started play before it was applied, and avoid applying extra damage on multiple plays of Gravity Well.

Ethereal is granted globally for as long as this power exists, gated on the card being afflicted with . When this power is removed, it stops contributing here automatically, so any Ethereal from another source (e.g. ) is left untouched.

Illusions keep their buffs (including IllusionPower itself) after dying. We ignore Temporary powers (ie temp strength down from dark shackles or dying star) so that the temp powers they are applying also go away

This is so the owner doesn't receive powers while it is reviving.

Caps damage received at 1. Note: the HP loss logic is already handled by , the duplicated logic here is for block loss and preview logic on targeted attacks.

Note: the HP loss logic is already handled by , the duplicated logic here is for block loss and preview logic on targeted attacks.

We do this in AfterEnergyReset instead of BeforeSideTurnStart so the player will still get benefits from orbs that might be evoked to make room for the new Lightning Orb. Specifically: - 's energy gain could be lost to energy reset if this triggered earlier. - 's block gain could be lost to block clear if this triggered earlier.

This gives the attacker 1 block after every attack. A multi-hit attack should still only gain 1 block.

Test-only power that records at the moment each turn lifecycle hook fires. Tests should call before each scenario and read after.

Optional callback invoked during . Useful for multiplayer tests that need to inspect other players' phases at the moment a hook fires.

Keep track of the cards we've seen played and the power amount at the time they were played. This lets Monologue avoid triggering on cards that started play before it was applied, and avoid gaining extra block on multiple plays of Monologue.

This will be null for the moment after this power is applied but before this is set by Nightmare.OnPlay. For all current use cases, this means we should never see this being null. However, if we needed to override AfterApplied in here in the future, this would be null in it, so let's leave this nullable for future-proofing.

Keep track of the cards we've seen played and the power amount at the time they were played. This lets Oblivion avoid triggering on itself.

We track this so we don't count the Panache card towards itself.

This power doesn't actually do anything on its own. Instead, the card checks for its existence and modifies its block.

We want enemies that start with Plating to also start combat with block.

We do this in early so that it triggers before end-of-turn damage effects.

makes Poison trigger extra times, but it should never trigger more times than the amount of Poison we have. Since the power is applied to players, enemy creatures need to look to them (their opponents) to figure out the trigger count.

Executed when Decimillipede Segment is reattaching at the end of its turn.

This is so the Decimillipede Segment doesn't receive powers while it is reviving

Killing Decimillipede Segment shouldn't trigger fatal unless all other segments are dead too.

This power doesn't actually do anything on its own. Instead, Sovereign blade cards checks for this power and and changes its behavior based off of that

Keep track of the cards we've seen played and the power amount at the time they were played. This lets Serpent Form avoid triggering on cards that started play before it was applied, and avoid dealing extra damage on multiple plays of Serpent Form.

Has the owner gained block from Skittish this turn? Skittish should only trigger once per turn, so we can skip when this is true.

Keep track of the Power cards we've seen played and the power amount at the time they were played. This lets Storm avoid triggering on cards that started play before it was applied, and avoid channeling extra lightning on multiple plays of Storm.

Keep track of the cards we've seen played and the power amount at the time they were played. This lets Strangle avoid triggering on itself, especially when stacking.

Keep track of the Power cards we've seen played and the power amount at the time they were played. This lets SubroutinePower avoid triggering on cards that started play before it was applied, and avoid granting extra energy on multiple plays of Subroutine.

This class represents a buff/debuff that gives/takes dexterity. We never instantiate this directly. See for context around how this is used.

The canonical model that applies this power. For example, .

If this power is supposed to apply negative dexterity, make this false

Shorthand indicating the sign of the amount to apply

If this is true, the next application of this power will not be applied. This is used when debuffs are copied by Misery. The negative gets copied along with this power, and upon copying, it should not apply negative down again.

This class represents a buff/debuff that gives/takes focus. We never instantiate this directly. See for context around how this is used.

The canonical model that applies this power. For example, .

If this power is supposed to apply negative Focus, make this false

Shorthand indicating the sign of the amount to apply

If this is true, the next application of this power will not be applied. This is used when debuffs are copied by Misery. The negative gets copied along with this power, and upon copying, it should not apply negative down again.

This class represents a buff/debuff that gives/takes strength. This class is never instantiated directly. Instead, it is subclassed and those classes represent the buff/debuff. Every model that grants a temporary strength power creates an associated power that subclasses this. For example, FlexPotion has FlexPotionPower which grants strength and then takes it away at the end of the turn. This used to be called Strength Down (or Restore Strength for negative strength) and be its own power. We switched to this model so make the UX more clear for players; both Strength and Temporary Strength are a buff.

The canonical model that applies this power. For example, .

If this power is supposed to apply negative strength, make this false

Shorthand indicating the sign of the amount to apply

If this is true, the next application of this power will not be applied. This is used when debuffs are copied by Misery. The negative gets copied along with this power, and upon copying, it should not apply negative down again.

Set the amount of damage that this instance of The Bomb will deal. This is necessary because Amount is used to track the number of turns left until exploding.

Amount of damage to deal

This power acts as a visual indicator to the player that the Hunt card was successful. The actual behavior lives in .

Set the amount of block that this instance of Toric Toughness will deal. This is necessary because Amount is used to track the number of turns left.

Amount of block to gain

HACK: If Void Form is the first card played in a turn, there's a brief period before the turn is auto-ended where we show a zero energy cost on all cards. To avoid this, we max out cardsPlayedThisTurn, which doesn't matter anyways since the turn is ending.

Multiplies damage received by 1.5x.

We use BeforeFlushLate instead of BeforeFlush here so that the player can have full information about the other BeforeFlush effects before choosing a card to retain.

Get the additional text that this relic should add to the "heal" option at the rest site. Returns null for relics that add no additional text.

Get the player that owns this relic. Will technically be null on a canonical relic model, but we should never be checking that, so we leave this as non-nullable for convenience.

Is this a relic with a limited number of uses that have all been used up? Good example: Matryoshka after opening 2 chests. Bad example: Strawberry (no "uses", just used immediately upon pickup).

Does this relic have an "upon pickup" effect? Example: Strawberry.

Does this relic spawn pets? Example: Byrdpip.

Can multiple instances of this relic be stacked? Example: Circlet.

See the Wax Choker relic for more info on this.

Whether or not this relic is allowed to be rolled based on the current game state. This will usually just return true, but some relics require special conditions.

Whether or not this is allowed at Neow. Only applies to Neow relics. Doing this because Kaledioscope needs the potential owning player.

Helper for relics that should stop spawning at the Act 3 treasure chest or later. These relics provide diminishing value late in a run.

Returns all extra hovertips, excluding the HoverTip for the relic itself. Useful for event options which replicate the relic description exactly in the option description.

Set to true when this relic is removed from a player's relic inventory (happens very rarely).

This should be called when the relic icon changes so the icon paths are uncached.

Get every relic in this pool (ignores Unlocks/Epoch state).

Get the ID of every relic in this pool (ignores Unlocks/Epoch state).

Generates every relic in this pool (ignores Unlocks/Epoch state). Overridden in subclasses, but should only be called once by so it can be cached.

Returns every relic in this pool that the player has unlocked. By default, this is just AllRelics, but can be overriden in subclasses to remove relics that should be locked under certain conditions.

Sets up transcendent starter card for given player.

Player we are getting the trasncendent card for. Returns false if the player doesn't have the base starter card to transcend.

Note: We can't use because we may be taking "trample" damage from Osty. The ModifyDamageX hooks will have already run for that initial damage to Osty, and we currently can't re-run them for the trample damage.

We use AfterEnergyResetLate instead of or because we want to allow effects that check for Osty's existence (like ) to run before we summon Osty.

Represents a relic that has been removed from the game. Mostly used for the run history.

This uses the _very early_ hook because it needs to check the player's block before triggers (otherwise, will prevent this relic's block gain), and in turn needs to run early so it can give you block before you take damage from another end-of-turn effect.

If Ethereal cards are exhausted at turn end, we want to give the resulting cards to the player after the flush occurs. In STS1 this is handled because the card draws are put on the queue, but here we have to manually defer.

50% chance of Looming Fruit having the cornucopia. This chance is LOCKED for each player indefinitely. Players will only know if there's a cornucopia or not by seeing OTHER player's Looming Fruit.

This uses the _very early_ hook because it needs to check the player's block before triggers (otherwise, will prevent this relic's block gain), and in turn needs to run early so it can give you block before you take damage from another end-of-turn effect.

If two players both have Pael's Eye in multiplayer, and only one player uses it, then only that player gets a turn. In this case, we force the other player not to draw any cards and we auto-end their turn. But even though they haven't played any cards, that "turn" shouldn't count towards Pael's Eye for them.

DO NOT USE, this is only public for tests.

This is public so we can call it from save tests.

Checks if random bundles can be generated for the given player. Requires at least 4 unlocked commons and 2 unlocked uncommons.

Generates 2 random bundles for the player. Each bundle contains 2 commons and 1 uncommon. All 6 cards across both bundles are unique. For Defect, each bundle has a 1% chance to be 3x Claw instead.

Sets up the upgraded starter relic based off of the player.

The player who we are upgrading the starter relic for Returns false if player doesn't have the original starter relic. Don't trigger before hand draw or after hand flush, because if a card is autoplayed during this time, the player's hand will always be empty, so Unceasing Top will always draw.

This relic doesn't actually _do_ anything; Doom checks for its existence and makes enemy Doom trigger at the start of the enemy's turn instead of the end of the enemy's turn (so enemies die before they can attack).

If we've doubled an and now we're trying to double its internal debuff, skip it so we don't double-dip.

If we've doubled , we don't also want to double negative , because that'll end up quadrupling it.

Card selector used by Vakuu (via WhisperingEarring) during auto-play. Selects cards in row-major order (top-left to bottom-right).

We do this in Late because we want this to trigger after all other triggers fire (i.e. ).

Gets the target for a card during Vakuu's auto-play. Enemies: leftmost first. Allies: random.

Scales block gained by enemies.

The that this model is scaling. Should always be set when creating a run, so we mark it as non-nullable.

The CombatState that this model is scaling. Only set when we are in combat.

Initialize with the specified .

A model which is instantiated once for an entire run. Currently only one for multiplayer scaling.

The data backend for intents. See NIntent.cs to update visuals

A special HoverTip override for the StunIntent so that it can be used in a static context ie: for the Whistle card.

Responsible for synchronizing all players' combat states before combat begins.

Handles a combat synchronization message from another peer. Remember that this can be called even before StartSync and must queue the data for the next time we sync.

Handles a RNG synchronization message from the host. Remember that this can be called even before StartSync and must queue the data for the next time we sync.

Called when a peer disconnects from the lobby. Used to check if we should complete the sync now that they've been disconnected.

Sends a message syncing our combat state to all other players. This should be called early before beginning animations for entering a combat room. Then, WaitForSync should be called just before entering the combat room. Between this and WaitForSync, no player or RNG state should be modified.

Waits for all other players' combat data to be received. StartSync must be called exactly once before this is called.

Checks if synchronization is complete and sets the result on the sync completion source if we are all done. This should be called every time we receive some sync data from a peer.

Calculates checksums, sends them to peers, and validates received checksums to ensure there are no state divergences during deterministic execution (currently: during combat, after events, and after rest sites).

Main entry point for this class. Generates a checksum of the full combat state for validation against peers'. On host, the checksum is saved for comparison against those received from clients. On clients, the checksum is saved and sent to the host for validation. This should be called the exact same amount of times for every peer, otherwise false positive mismatches will be generated.

Called on the host when a client sends a message containing the checksum for their current game state.

Called on client when the host sends a message indicating that the client's state has diverged from the host's. Also called on the host when the client receives the host's message, so that the host knows what state the client was in and can log both.

Call this to obtain checksum data that may be sent over the network with a message.

Called when an event room is entered.

The canonical version of the event that will be started. If the event is already pre-finished A method to call to inject some debug code right after the model is cloned. The mutable model instances will be passed to the method.

Received during shared events. Records a player's vote for a given event option.

Records a player's vote. Called in response to a remote player's message, or immediately when the local player votes for a shared event option.

Called on the host when all votes for a shared event page are received. Decides which event option should be chosen and notifies all clients of the option chosen.

Called on clients when the host receives all player votes and decides on an event option to choose.

Called on all peers during non-shared events when one peer selects an event option.

Called when the local player selects an event option button. During shared events, this votes for the event option. During non-shared events, this immediately executes the option and sends the event option to all other peers.

The index of the event option that was chosen.

Executes the shared event option on all players' event model instances and clears player votes.

Executes the given event option for a given player.

Awaits all in-flight event option tasks. Called before the room exit checksum to ensure that all players' event handlers have finished mutating state. Without this, a peer whose local event finished quickly (e.g. Touch a Mirror) can exit the room while a remote player's slow handler (e.g. Shatter's per-card deck duplication loop) is still running, causing the checksum to capture incomplete state.

Handles miscellaneous multiplayer messages that are for game feel and fun.

Provides additional host-related methods on top of the default game service.

Represents an abstraction of the networking API used to send and receive messages. Host/join methods are specific to the game manager type on purpose, as those cannot be abstracted. However, once connected, this interface can be used as a generic way to send/receive messages regardless of whether we are a host or a client.

The player ID of the local player.

True when the net service is in a state where it can send messages.

True if the last call to SetGameLoading was called with true, false otherwise.

Called when the network connection is disconnected and the sockets are disposed. On host, this occurs when we stop hosting. On clients, this can occur when we quit, our connection drops, or the host disconnects from us.

The type of manager this is (host, client, or singleplayer).

The networking backend we are using to connect to players. Note that if we ever consider cross-platform, this likely needs to be contained in the player ID, not here.

Sends a message to a specific peer. Note that this should only be used as a host.

The message to send. The specific player to send to.

Sends a message to all connected peers. On the host, this sends a message to all clients. On a client, this sends a message to only the host, but if the message has the broadcast flag set, the host will replicate it to all other clients.

The message to send.

Registers a message handler delegate which will be called when a message of type T is received.

The delegate to call.

Unregisters a message handler delegate that was previously registered. Does nothing if it was not registered.

The delegate to unregister.

Method which should be called at regular intervals. Messages, connections, or disconnections will not be processed unless this is called.

Disconnects us from all connected peers.

The reason to pass to the remote end to indicate why we quit. If false, then the connection is allowed to wait until messages are finished sending. Otherwise, the connection is terminated immediately.

Returns the connection statistics for a given peer.

DO NOT use this directly in most circumstances! Instead, use NetLoadingHandle. Tells the net service that the game is in a loading state, and that Update may be called irregularly. See for why this is needed.

Begins buffering all messages. When the game is transitioning from one state to another, it will unregister and register message handlers. If this takes time, then there's a chance that a message will be sent during this window that the game doesn't know how to handle yet. This method should be called with true after a sync point and then false after the game is ready to handle messages again.

Returns a unique identifier for the lobby that this service is connected to. Returns null if the net service is not yet connected. This returns a platform-specific identifier for use with rich presence. Feel free to refactor later if more info or more specific info is needed.

Delegate which is called when a message is received.

The message type. The message that was received. The sender of the message.

Provides additional host-related methods on top of the default game service.

Event called when a new client connects to the host.

Event called when a client disconnects from the host, either voluntarily or because we disconnected them.

Disconnects a client from the host.

The client to disconnect. Why the client is being disconnected. If true, the client will be forcibly disconnected. The reason may not make it to the client.

Marks a client as ready to receive broadcasted messages. During the initial setup process, we don't want clients to receive broadcast messages as they may not be ready for them. Call this when initial setup is done.

Object which manages the join flow for the local player, who joins as a client.

Begins the join flow. This task returns either a JoinResult with the final message in the join flow, for use initializing the run or the Lobby in the case of a rejoin or a join, respectively.

The object to use when initializing the connection. Scene tree to use for hooking into update. ClientConnectionFailedException if the join fails. In this case, you should not use NetService. An error should be shown to the user and they may try to join again.

Handles callbacks generated by the .

Called when a new player has connected. This includes the local player (even the host). If we are a client newly connecting to a host, and there are already players in the lobby, then this is called once for each player that is already in the lobby.

The ID of the newly connected player.

Called when another player has left the lobby.

The ID of the player who has left.

Called when everyone is ready on the host. If this returns true, then the run will begin. Otherwise, the host will be un-readied and the run will not begin until the host re-readies.

Called when the run begins, on both host and client. When calling CloseAndBeginRun on the host, you should wait for this call to actually begin the run.

Called when a player readies or un-readies.

Called when the local player has been disconnected from the lobby. Information about why we were disconnected.

Handles callbacks generated by the .

Called when a player is attempting to rejoin the game. This should return a fully-filled ClientRejoinResponseMessage with the current game state.

Called when the local player has been disconnected from the lobby.

Called when the run has been abandoned by the host. Note that LocalPlayerDisconnected will still be called in this case with NetError.Quit.

Handles callbacks generated by the .

Called when a new player has connected. This includes the local player (even the host).

The newly connected player.

Called when a lobby player's state has changed (e.g. their chosen character has changed).

The player whose state has changed. This is only set to true when the player has changed due to the lobby resolving the random character to the real one when the run is beginning.

Called when the host has changed the ascension level, on both host and client.

Called when the host has changed the custom seed, on both host and client.

Called when the host has changed the modifiers, on both host and client.

Called when a client joins with a lower max ascension level than the previous one, on both host and client. Also called when the character changes in a singleplayer game, changing the max ascension.

Called when another player has left the lobby.

The player who has left.

Called when the run begins, on both host and client. When calling CloseAndBeginRun on the host, you should wait for this call to actually begin the run.

The seed used to start the run. The acts used to start the run. The modifiers used to start the run.

Called when the local player has been disconnected from the lobby. Information about why we were disconnected.

Class which handles the connection flow for players resuming a run from a save file. This exists before Run, giving players an opportunity to all join before the run is resumed. Only connections from players in the loaded save file will be accepted; all other connections will be denied. handles player connection and disconnection after the run begins.

If we are the host, this is the amount of time we give clients to send the handshake response in milliseconds. Public for tests.

This should be called to cleanup the lobby before exiting the lobby screen.

If true, the net service will be disconnected. Pass true if the lobby is being closed rather than transitioning to a run. If disconnectSession is true, this is the error that is sent to clients.

Should be called when the lobby opens on the host player's side to generate the host's lobby player.

Class which handles disconnection and reconnection while a run is in progress. or are used to initialize the run. Once the run is in progress, those instances go away and this class takes over their responsibilities. Connections from players that are not currently in the run will be denied. Only players that existed in the run may reconnect to the RunLobby.

Creates the RunLobby.

The type of run that was started. Net service used to send/receive messages. The lobby listener which receives callbacks from this lobby. Queryable collection of players. The connected player IDs. Note that this may be different than the IDs contained in the player collection if we launched a saved game, but not everyone in the save rejoined.

This should be called to cleanup the lobby before exiting the run.

Class which handles the connection flow for players beginning a new run. Exists before Run does, and provides player data to start a multiplayer run. handles player connection and disconnection after the run begins.

If we are the host, this is the amount of time we give clients to send the handshake response in milliseconds. Public for tests.

TEMPORARY way for the host to manually specify which ActModel they want for act 1.

This should be called to cleanup the lobby before exiting the lobby screen.

If true, the net service will be disconnected. Pass true if the lobby is being closed rather than transitioning to a run. If disconnectSession is true, this is the error that is sent to clients.

Should be called when the lobby opens on the host player's side to generate the host's lobby player.

For use in tests and internally in this class.

Updates the preferred Ascension.

Sets the character chosen by the local player and replicates that to all peers.

Sets the seed to use for the run. This can only be called as host or singleplayer. Calling it on the client will throw an exception and have no effect. The seed is synced to the clients for display use, but the final seed that is used is sent in the .

Sets the modifiers to use for the run. This can only be called as host or singleplayer. Calling it on the client will throw an exception and have no effect. The seed is synced to the clients for display use, but the final seed that is used is sent in the .

Sets the local player to be ready or unready and syncs the state to all peers. This is called for both Singleplayer and Multiplayer (singleplayer uses a local lobby).

Sets the ascension level. Should only be called on the host.

Each time we generate a map, this counter goes up. It is used to keep track of multiplayer map votes and to discard map votes that are for old maps.

Represents a player's vote for the map coordinate to move to next. Used in multiplayer to tally player votes and move on to the one that the majority have voted for.

How many map generations have occurred before this map vote was received. Used to invalidate map votes for old maps, in the case that a map was generated multiple times for the same act. See Golden Compass.

The coordinate within the map the player has voted for.

A utility class for marking the start and end of a loading sequence. Basically just equivalent of calling NetService.SetGameLoading with true, and then false at the end of the scope. Construct one of these with a using statement any time we enter a long loading sequence to let the networking layer know that the game's framerate might dip. If you don't do this, we might accidentally display a "waiting for connection from host" overlay because messages aren't being processed.

A synchronizer for a few one-off scenarios that don't fit in any other synchronizer. This should be used pretty rarely, and we should be on the lookout for patterns that emerge with new content.

Does merchant card removal for the local player.

The cost, in gold, that we should deduct from the player's gold count. If false, you are required to remove a card A task that completes when the player finishes the removal flow. Result is true if the player removed a card, false otherwise.

Should be called after a player opens the chest in the treasure room to synchronize gold gain and other effects.

The amount of gold given to the player.

Special one-off logic for Spoils Map. If more stuff ends up going here, make this a hook

The amount of gold given by spoils map, if any.

Special one-off logic for presenting crystal sphere rewards to the player, and notifying other players that crystal sphere rewards are beginning for the local player.

A bundle of data that resolves to a model that a player is hovering. This intermediate structure is necessary because references to models may not yet be available at the time that we receive the hover data. For example: - Player 1 is in fast mode, plays Alchemize, and hovers the resulting potion - Player 2 is in slow mode, and is still in the middle of the enemy turn when player 1 hovers the potion

Works with the PeerInputSynchronizer to synchronize the intent shown over the player's head during combat. Note that this doesn't do any message sending itself - PeerInputSynchronizer does the message sending and handling to reduce bandwidth. This is here only to separate out some of the state tracking from PeerInputSynchronizer.

Utilities to help with transforming mouse position from screen coordinates to a normalized position suitable for syncing mouse positions across various aspect ratios.

Synchronizes our local mouse state with peers and remote peers' with ours.

Event fired when we first add a PeerInputState for a player. This occurs when a player emits a , or when we attempt to get the input state for a player.

Event fired when a player disconnects, and their input state is removed.

Event fired when any part of a player's input state is changed.

Event fired only when a player emits a PeerInputMessage with a new screen type. The second argument is the old screen type.

If this is unset, Time.GetTicksMsec is used to check how much time has passed. This is used to mock time passing for tests.

If this is unset, Task.Delay is used to buffer messages. This is used to mock time passing for tests.

If this is unset, Task.Yield is used to wait a moment before messages are sent. This is used to mock time passing for tests.

The player to whom this state belongs.

The mouse position of the player.

True if the player's mouse is held down, false otherwise.

Which screen this player is looking at.

The combat model the player is hovering over. Should only be non-null in combat.

True if the player is in combat and is currently in targeting mode (drawing the targeting arrow), false otherwise.

True if the player is currently using a controller.

Tracks the position of the current focused control. Only valid if isUsingController is true.

Sync the local mouse position to other clients. This should be called any time the mouse position changes - the message will be buffered and sent at regular intervals.

The screen position of the mouse. The root control, used to normalize mouse coordinates across different resolutions and aspect ratios.

Sync the position of the currently focused control node with other clients.

the screen position of the currently focused control node The root control, used to normalize mouse coordinates across different resolutions and aspect ratios.

Sync whether or not the local player is using a controller.

Sync the local mouse down state with other clients (so they show the correct cursor).

True if the mouse is down, false otherwise.

Sync the topmost overlay/capstone on the local player's screen to other peers.

The topmost overlay/capstone on the local player's screen.

ONLY the HoveredModelTracker should call this! You likely want to call one of the HoveredModelTracker methods instead. Sync the model that the player is currently hovering.

The model that the local player is hovering.

Sync whether or not the player is currently in targeting mode.

True if we're currently displaying the targeting arrow locally, false otherwise.

Sends a sync message if enough time has passed since the last one, or buffers it to be sent otherwise.

Override the normalization calculation for the mouse cursor position. On screens like the Map screen, synchronizing cursor position based on screen position is not correct. This method allows you to override the translation from net position to screen position and vice versa.

The object to use when translating cursor positions.

Stop overriding the normalization calculation for the mouse cursor position. Should be called after StartOverridingCursorPositioning when the screen is exited.

Returns the control-space position of a given player within the given control. If the player is using a mouse, then this would be the mouse's position If the player is using the controller, then this would be the position of the control node that that player is currently focused on (this is currently only set up for the treasure room). Different resolutions and aspect ratios are all mapped to the same 1920x1080 reference resolution in control- space. Essentially, the position returned by this method can be used set the position property on a Control with a cursor image as rootControl's child and have it look approximately the same across all peers.

Player for which the mouse cursor position should be obtained. The root control to position the mouse cursor relative to. Should only be null in tests. True if the given player is holding the mouse down, false otherwise. The top-most overlay or capstone that the given player is looking at.

WARNING: You probably want HoveredModelTracker methods instead!

Info about what model the player is hovering. True if the player is currently in combat targeting mode, false otherwise.

Removes the player state from the synchronizer if it exists and notifies listeners. Note that, if the player is still connected to the session and sends a PeerInputMessage, the state will be re-created, so this method should be called as late as possible in the disconnection flow.

The player that left the game.

Keeps track of the local player's screen state and synchronizes it to remote peers via the PeerInputSynchronizer.

Callable.From() creates a new delegate each call, so we store it to ensure IsConnected() can match the same instance used to Connect(). This prevents Godot's "signal already connected" error when the rewards screen re-emerges as the top overlay after another overlay is pushed on top and later popped.

The map is not an overlay or a capstone, it's part of .

The shared relic picking screen at the treasure room is not an overlay or a capstone, it's part of the state of the room, so it needs to get synchronized manually.

Handles miscellaneous multiplayer messages that are for game feel and fun.

Sends a hover message if enough time has passed since the last one, or buffers it to be sent otherwise.

Synchronizer responsible for executing reward set behavior for each player. When any player generates a reward from any source (end of combat, relics, events), the RewardsSet calls into this synchronizer. Then, as the owning player selects or skips rewards, they send messages to all other players indicating which rewards they took. This synchronizer handles those messages.

Reward state for each player. There is one for each player in _playerCollection, in the same order.

Denotes how a reward set was completed.

All the rewards in the set were taken.

Some (or all) of the rewards in the set were skipped.

Represents a message that was sent for a remote player about a reward set that has not yet spawned for the local player. For example, if players have differing combat speeds, one player may reach the end of combat before us, and begin taking their rewards. This will start sending messages, but our local NCombatUi will not have begun the rewards process yet, so we need to buffer the remote messages for when it does.

Reward state for a given player. Contains a stack of reward sets.

The reward sets the player is currently choosing from. Players can have multiple rewards screens up because relics, when taken from a rewards screen, may themselves spawn new rewards screens. This acts like a stack.

If messages are received for a reward before it is started locally, then they will be buffered here until the reward set is spawned.

Completed reward IDs, for bookkeeping purposes.

The next ID to assign the rewards set for the given player.

State of a single reward set.

The set of rewards.

The completion source to complete when the rewards are all taken, or when they are skipped.

Begin tracking a rewards set. This is called when a reward set is spawned and offered to the owning player.

The rewards set to track. A Task which completes when the player is done taking the rewards.

Selects a reward locally. Throws if the reward is not owned by the local player.

The reward to select. A Task which completes when the player finishes with the reward. See .

Skips the current rewards that the local player is looking at.

Called when a remote player selects a reward.

Called when a remote player skips the remaining the rewards in a set. This is NOT called when the player skips post-combat rewards. handles that case. This is only called if a player explicitly hits the "skip" button, which can only occur if the rewards are a non-room reward (e.g. Orrery).

Selects the reward at the specified index for the given player's top-most rewards screen.

Selects the passed reward for the given reward set. Takes care of completing the reward set if all rewards have been obtained.

If all rewards in the passed state are successfully complete, then the set is marked as complete.

Skips all rewards in reward set on the top of the stack for the given player, completing the reward set.

Skips all rewards in the passed reward set, completing the reward set.

Marks a rewards set as complete (or skipped), popping it off the owning player's stack.

Returns true if the passed reward set has been completed.

Returns true if the passed reward set ID has been completed for the given player.

Skips all remaining rewards for all players.

Gets all the next reward IDs in player slot order.

Temporary synchronizer that tells other players about rewards that a player receives in non-deterministic contexts Currently only used at the merchant.

Does card removal for the given player WITHOUT syncing it. This is a temporary bridge method for things that already execute deterministically (card removal rewards) and things that don't (merchant card removal).

Responsible for holding messages that are not destined for the current map point, and waiting until that map point is entered before processing those messages. We may be slow to transition to a new map point (e.g. because of loading delays), and messages from other peers may come in before we're ready to receive them. Note that it is important that queued messages are sent out in the order that they were received.

This should be called whenever the run location changes. If messages are blocked waiting for a location change, then they will be sent to registered message handlers in the order that they were received.

Registers a message handler for map targeted messages. s should be registered here instead of directly to the INetGameHandler; otherwise, they may be received at the wrong time.

The delegate to call when the message type is received or when we enter a new location and a message for that location is enqueued.

Unregisters a message handler for map targeted messages.

Internal method which either sends the message to the handler, or enqueues it if the message is not destined for a location we have already visited.

Synchronizes treasure room shared relic picking in multiplayer. After opening the treasure chest, players are presented with multiple relics. They may vote on any one of the relics to take. After all players cast a vote: - If only one player votes for a relic, then that player gets the relic. - If multiple players have voted for a relic, they play rock-paper-scissors. The winning player gets the relic. - If no one has voted for a relic, a random loser of a rock-paper-scissors game gets the relic.

Set to true if the player skips the relic in singleplayer.

Index of relic voted on. If null, then player skipped.

If true, then the player has voted. False if the player has not yet picked an option.

Call this when the treasure room is opened to generate the relics that are selected. CurrentRelics will be null until this is called.

Little semantic sugar which calls PickRelicLocally with null.

Called when the local player chooses a relic to vote for. Note that this immediately invokes `VotesChanged` with the new vote. However, the vote is not confirmed until the resulting action round-trips to the host.

The index of the relic in CurrentRelics that the player voted for, or null if the player chose to skip.

Called when any player (local or remote) has voted for a relic.

The player that voted. The index of the relic in CurrentRelics that the player voted for.

Called when the room is exited. Used to avoid emitting an error in the legitimate case where the player never completes relic picking in singleplayer.

Returns the relic that the player is currently voting for. If the player has not yet voted for a relic, then null is returned.

Completes relic picking immediately with no relics awarded. Called when the chest is empty (e.g., due to SilverCrucible).

If treasure room rarity should be forced because the player is currently playing a tutorial run, this returns a non-null rarity. Otherwise, the rarity is randomized.

Sent from the host to clients to indicate that a GameAction has been enqueued. This is one of the most important messages in the game. The game assumes that: - These messages are sent and received reliably - These messages are received in the order that they are sent - These messages are ordered correctly with ResumeActionAfterPlayerChoiceMessages

Sent when a player begins removing a card at the merchant.

Sent from clients to host when a checksum is generated. The host should validate the checksum. No action is needed if the checksum matches the host's, but if it does not, a StateDivergenceMessage should be generated and sent to the client.

Sent when a state divergence is detected due to the host and client checksums mismatching. First this is sent from host to client, then it is sent from client to host.

Sent when a player clears their drawings at the map screen.

Sent when a player has ended their turn and presses the "Ping" button to annoy other players.

Sent when a player begins drawing a line, updates the position of the line drawing, or ends drawing a line.

Sent when a player presses the pencil button at the bottom-left of the map screen.

Sent when a player clicks on a map coordinate that they've already voted on.

Sent when a player uses the reaction wheel to send a reaction.

Sent from the host to clients to indicate that a GenericHookGameAction has been enqueued. This is slightly different than ActionEnqueuedMessage. The Action itself is not serialized, because it is difficult to serialize every different action that could be executed by a hook. Since hooks are executed by every player, we instead map the hook to an incrementing integer that is the same across all peers, and use that to identify which hook will be assigned to the GameAction that is created.

Sent when a player begins removing a card at the merchant.

Broadcast from a peer to all other peers when that peer has made a choice in combat.

Sent from clients to host when they initiate a GameAction. The GameAction must not be enqueued until the host sends back an ActionEnqueuedMessage, to preserve determinism.

Sent from the clients to host too request that a hook action be enqueued. It is implicitly assumed that the owner of the hook action to be enqueued is the sender. This is slightly different than RequestEnqueueActionMessage. The Action itself is not serialized, because it is difficult to serialize every different action that could be executed by a hook. Since hooks are executed by every player, we instead map the hook to an incrementing integer that is the same across all peers, and use that to identify which hook will be assigned to the GameAction that is created.

Requests that the action currently paused on the sender's action queue be resumed. The action ID sent must be an action that is in the WaitingForPlayerChoice state. The GameAction should not be resumed until the host sends back a ResumeActionAfterPlayerChoiceMessage.

Sent from the host to the client. Informs clients that an action has been resumed after it was placed in the WaitingForPlayerChoice state. Note that this message and ActionEnqueuedMessage must be received in the same order that they are sent.

Sent by the host to all clients when the host abandons the run. The clients should also abandon the run.

Used both in events and rest sites to synchronize the option chosen by a player. In events, optionIndex is the index of the currently displayed EventOption to choose. In rest sites, optionIndex is the index of the currently displayed RestSiteOption to choose.

Message sent to update the input state of a remote peer. Input state includes mouse position, mouse down state, and hover info.

Message that is sent when a reward is selected from a rewards screen. This is sent BEFORE obtaining a reward. For instance, when a player selects a card reward, this message is sent before the player finishes selecting the card they wish to choose. The card selection occurs as a separate process.

Message sent when a player chooses to skip the remaining rewards in a set of rewards.

Sent by the host to all clients when votes are received by all players during a shared event. This message specifies the option that all players should execute.

Broadcast from peers to all other peers when they vote on an event option during a shared event. This only records the votes; the host is the one that ultimately chooses the event option and sends it via SharedEventOptionChosenMessage.

Broadcast to all peers at the start of combat to sync player data (deck, HP, max potion slots, etc).

Sent to all clients from host at the start of combat to sync RNG state. TODO: This might not be the right thing to do! If a client has rolled Niche but the host hasn't, and we roll that back, will we end up generating the same RNG again for the same thing?

Sent at a treasure room when a remote player opens the treasure chest.

Sent by a client to the host as their first message, requesting that they join a loaded lobby. Only sent if the lobby was started from a loaded game.

Sent by a host to a client in response to a ClientLoadJoinRequestMessage.

Sent from a newly connected client to the host as the first message in the joining flow.

Sent from the host to a newly joined client in response to their ClientLobbyJoinRequestMessage. On other clients, PlayerJoinedMessage is sent.

List of players already in the lobby.

If the run is a daily, this contains information about the time that the host requested from the time server.

Current ascension that the lobby is set to.

Seed set at time of join. Only non-null if in a custom game. The true seed to use is sent when the run begins.

Modifiers present in the lobby at the time of join.

Sent from the host to the client as the first message after the client connects.

The version of the game the host is running.

A hash of all the IDs in the model database.

A list of all the gameplay-affecting mods that the host has installed, if any.

A list of all the non-gameplay-affecting mods that the host has installed, if any.

What kind of run this is (standard, daily, custom).

What state the run is currently in.

If the host is about to disconnect the client, why.

Returns an InitialGameInfoMessage with the version and idDatabaseHash filled in.

Sent by the host when the chosen ascension level changes.

Sent when the closes and the run begins. Used only in . Lobby uses .

Sent when the lobby closes and the run begins.

Sent by the host when the modifiers in the custom run menu changes.

Broadcast to all peers when a player in the lobby changes their selected character.

Sent by a player when that player is ready to begin the run.

Sent by the host when the overridden seed in the custom run menu changes.

Sent from host to clients when a client has joined. The newly joined client receives ClientSlotGrantedMessage and not this message.

Sent from host to all clients when a client has disconnected from the lobby.

Sent from host to clients when a client has reconnected, either in or during a run. The newly joined client receives ClientRejoinResponseMessage and not this message.

Sent from host to all clients when a client has rejoined the game.

Starts sending broadcasted messages to a peer. When a peer first connects, messages that have ShouldBroadcast set are not sent to that peer. They are only sent to the newly connected peer after this method is called, passing the newly connected peer's ID. This is used to prevent messages from being sent to a peer until the game-level connection flow has been completed.

Holds statistics about a particular connection to a network peer. See for how this class is generally used.

A ring buffer of heartbeat statuses. Heartbeats use a monotonically increasing counter for identification. We use that index to overwrite old heartbeat statuses in this buffer for tracking.

Logger object for this connection

The peer for which this object gathers statistics.

The estimated average round-trip time to the peer.

The estimated average packet loss to the peer. Note that this is the sum of both outbound and inbound packet loss.

The last time (msec) we received a packet from the peer. If the difference between the current time and this is a large value, then we might be about to time out.

True if the remote end is currently loading, and we should not expect consistent packets. Used in conjunction with LastReceivedTime to determine whether we should show a "connection interrupted" overlay.

Generates a heartbeat request to be sent to the peer.

The current time in milliseconds.

Call me when we receive a heartbeat message for the peer.

The message that was received. The current time in milliseconds.

Called when we're about to overwrite a heartbeat status in the ring buffer, and a response to it was never received.

Represents the status of a heartbeat message. See .

The heartbeat index this is tracking.

The time at which this heartbeat was sent.

The time at which this heartbeat was received, or null if it has not been received.

Keeps track of the quality of the connection to each peer, for use in displaying "poor connection" notifications to the user. To estimate connection quality, the following strategy is used: - At regular intervals, a "heartbeat" message is generated and sent to each peer. We record the time at which the message is sent. - When it is received, the peer echoes the heartbeat message back to us. - When we receive the response, we check when it was sent, and adjust our estimated round-trip time (ping) to the peer accordingly (in ). - If we go some time without seeing the echoed message, then we assume the packet is lost. We adjust our estimated packet loss to the peer accordingly. Further work can be done here to estimate jitter, but I don't think we need it for this game.

The time that must elapse before sending another heartbeat packet.

The time that must elapse before we log the connection statistics to the log.

Connection statistics objects, one per peer.

The last time we sent a heartbeat packet.

The last time we logged the connection statistics.

True if the game is in a loading state. See .

This is called when to get the current time. Used to mock time in tests. If null, Time.GetTicksMsec is used.

Gets the current time. Pulls from godot or a mock time source.

Should be called whenever a peer connects. Begins tracking their connection statistics.

Should be called whenever a peer connects. Stops tracking their connection statistics.

Called when the game enters or exits a loading state. This is important to know because, in the middle of loading, NetService.Update can be called at irregular intervals, leading to a much larger-than-normal round-trip time even though the network connection is stable. This info is sent through the HeartbeatResponseMessage, and when it is true, the receiver should not update ping, but still update last received time.

True if the game is in a loading state, false otherwise.

Should be called on a regular basis to send heartbeat messages.

Called whenever a heartbeat request comes in. This just echoes the heartbeat response back to the sender.

Called whenever a response to our heartbeat request comes back. Processes the message and updates our statistics.

Returns the statistics for a given peer.

If set, when this message is sent to the host, it will be echoed to all clients.

Whether this message is transferred reliably or unreliably.

What log level to use when logging info about this message. Almost all messages should be VeryDebug - only set this to Info for messages that are logged very infrequently.

Determines whether a message is buffered when NetMessageBus.SetBufferMessages is called with true. Should almost always be true. Only set to false for messages that can always be properly handled when a connection is valid.

For serializing over the network, to save space, we map the string names statically to integers... ...and vice-versa.

Initializes the serialization cache. Note that the alternative is to initialize in a static initializer, but if we do this we don't control the time at which it gets initialized, and it usually happens at a bad time during gameplay.

Bidirectional map of types to unique integer IDs, for use in serialization.

All classes which implement this type will automatically be mapped by this class.

Obtain the ID for a given type.

The type to map. The integer ID for the type T. Thrown if T does not implement TBase.

Obtain the ID for a given type.

The type to map. The integer ID for the given type. Thrown if type does not implement TBase.

Obtain the type for a given integer ID.

The ID to map to a type. The type for the given ID. True if a type was found for the ID, false otherwise.

Polls an ENetConnection, returning the events that have occurred since the last poll. This wraps ENet.Service into a more digestible method.

The connection to poll. The event we polled from the connection, if any.

Delegate to notify about events.

True this client is connected to a host, false otherwise.

The network ID of the client.

The network ID of the host we are connected to.

Should be called at regular intervals to send and receive messages.

Sends a message to the host.

The byte content of the message. The amount of bytes, starting from index 0, to send from bytes. Method of transfer (reliable or unreliable). The channel to use to send the message.

Disconnects from the host.

THe reason to send to the client accompanying the disconnection. If true, we will be forcibly and immediately disconnected. If false, we are disconnected at some point in the near future.

Returns a unique identifier for the lobby that the client is connected to. Returns null if the client is not yet connected or has been disconnected. This returns a platform-specific identifier for use with rich presence. Feel free to refactor later if more info or more specific info is needed.

Delegate to notify about events.

The IDs of currently connected clients.

True if clients are able to connect and receive messages, false otherwise.

The network ID of the host.

Should be called at regular intervals to send and receive messages.

If called with true, the host will be considered closed. What this means is platform-dependent. On Steam, this prevents other people from seeing the lobby, but existing clients are unaffected.

Sends a message to a specific client.

The ID of the client to send to. The byte content of the message. The amount of bytes, starting from index 0, to send from bytes. Method of transfer (reliable or unreliable). The channel to use to send the message.

Broadcasts a message to all clients.

The byte content of the message. The amount of bytes, starting from index 0, to send from bytes. Method of transfer (reliable or unreliable). The channel to use to send the message.

Disconnects a client.

The ID of the client to disconnect. THe reason to send to the client accompanying the disconnection. If true, the client will be forcibly and immediately disconnected. If false, the client is disconnected at some point in the near future.

Disconnecst all clients and stops listening for new connections.

The reason that the host is shutting down. Sent to connected clients. If true, all clients will be forcibly and immediately disconnected. If false, clients are disconnected at some point in the near future.

Returns a unique identifier for the lobby that this host is advertising. Returns null if the host has stopped or not yet started hosting. This returns a platform-specific identifier for use with rich presence. Feel free to refactor later if more info or more specific info is needed.

Returns the channel that should be used to send a message with the given mode. ENet uses the channel ID to denote priority: https://www.linuxjournal.com/content/network-programming-enet Our reliable messages should be considered higher priority than our unreliable messages.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the 'AttackShake' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_leftSegment' field.

Cached name for the '_speed' field.

Cached name for the '_magnitude' field.

Cached name for the '_originPos' field.

Cached name for the '_noise' field.

Cached name for the '_time' field.

Cached name for the '_decimillipedeStrikeOffset' field.

Cached name for the '_attackTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Will start/stop the animation from an AnimationPlayer depending on if Phobia Mode is on Used in instances where the animation can make people uncomfortable (ie the Infection card overlay)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdatePhobiaMode' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_animationPlayer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A node that automatically plays a single animation on a SpineSprite. There are two conditions that must be true when using this node: 1. This node must be the direct child of a SpineSprite node. 2. The parent SpineSprite must have exactly 1 animation. The animation is started once the parent SpineSprite's skeleton is ready. If condition 2 isn't met, this node will throw an exception.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Starts an sfx that has a continuous FMOD event that is meant to loop ex: Waterfall Giant's ambient sfx. Thieving hopper's hovering sfx.

path of the fmod sfx Whether on not the event uses our standard "loop" parameter to end the loop.

Stops the specified FMOD event that is looping.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the 'PlayLoop' method.

Cached name for the 'StopLoop' method.

Cached name for the 'SetParam' method.

Cached name for the 'StopAllLoops' method.

Cached name for the 'PlayOneShot' method.

Cached name for the 'PlayMusic' method.

Cached name for the 'UpdateMusicParameter' method.

Cached name for the 'StopMusic' method.

Cached name for the 'SetMasterVol' method.

Cached name for the 'SetSfxVol' method.

Cached name for the 'SetAmbienceVol' method.

Cached name for the 'SetBgmVol' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_audioNode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages the music specifically for run. Looking into info such as room type to decided what tracks to transition to.

A resolved act-music change: the track event to play and the bank that contains it.

A resolved act-music change: the track event to play and the bank that contains it.

Resolves which act background track to play for a given run seed, or null when nothing should change. Selection is deterministic in , so a run always picks the same track. Returns null when the act has no music, or when the selected track already equals . The equality check makes a redundant call a no-op instead of stopping and recreating the FMOD event, which restarts the track from the top. Two such calls fire on run start, from NRun._Ready and the act-entry path.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'GetTrack' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdateMusic' method.

Cached name for the 'PlayCustomMusic' method.

Cached name for the 'UpdateCustomTrack' method.

Cached name for the 'StopCustomMusic' method.

Cached name for the 'UpdateAmbience' method.

Cached name for the 'UpdateTrack' method.

Cached name for the 'UpdateMusicParameter' method.

Cached name for the 'ToggleMerchantTrack' method.

Cached name for the 'TriggerEliteSecondPhase' method.

Cached name for the 'TriggerCampfireGoingOut' method.

Cached name for the 'StopMusic' method.

Cached name for the 'LoadActBank' method.

Cached name for the 'UnloadActBanks' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_proxy' field.

Cached name for the '_currentTrack' field.

Cached name for the '_currentAmbience' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

CardHolder is meant to control the animation visuals for cards when they are presented in the PlayerHand, grid screens, card reward screens and so on. Examples include hovering/un-hovering and fancy fanning logic in hand. Clicked/buttonReleased behavior is handled by its parent: CardHolderContainer (ie PlayerHand).

The CardModel that this holder's CardNode is displaying. Null if the holder is empty.

Set whether the card holder may be selected (e.g. clicked by mouse or confirmed by controller). Different than calling _hitbox.Disable, as the card holder can still be focused.

This is used for reducing the number of unnecessary costly instancing and godot tree operations.

Clean up the CardHolder if its NCard is removed. We can get rid of this if we start wanting to reuse CardHolders.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetClickable' method.

Cached name for the 'ConnectSignals' method.

Cached name for the '_GuiInput' method.

Cached name for the 'EmitPressed' method.

Cached name for the 'EmitAltPressed' method.

Cached name for the 'SetCard' method.

Cached name for the 'OnCardReassigned' method.

Cached name for the 'OnMousePressed' method.

Cached name for the 'OnMouseReleased' method.

Cached name for the 'OnFocus' method.

Cached name for the 'CreateHoverTips' method.

Cached name for the 'ClearHoverTips' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'RefreshFocusState' method.

Cached name for the 'DoCardHoverEffects' method.

Cached name for the 'OnChildExitingTree' method.

Cached name for the 'Clear' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'HoverScale' property.

Cached name for the 'SmallScale' property.

Cached name for the 'Hitbox' property.

Cached name for the 'CardNode' property.

Cached name for the 'IsShowingUpgradedCard' property.

Cached name for the 'CanBeFocused' property.

Cached name for the '_hitbox' field.

Cached name for the '_isHovered' field.

Cached name for the '_isFocused' field.

Cached name for the '_hoverTween' field.

Cached name for the '_currentPressedAction' field.

Cached name for the '_isClickable' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Pressed' signal.

Cached name for the 'AltPressed' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ClickedSfx' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'InitPool' method.

Cached name for the 'Create' method.

Cached name for the 'UpdateCardModel' method.

Cached name for the 'OnInstantiated' method.

Cached name for the '_Ready' method.

Cached name for the 'EnsureCardLibraryStatsExists' method.

Cached name for the 'OnCardReassigned' method.

Cached name for the 'SetCard' method.

Cached name for the 'UpdateName' method.

Cached name for the 'OnFocus' method.

Cached name for the 'SetIsPreviewingUpgrade' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnReturnedFromPool' method.

Cached name for the 'OnFreedToPool' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CardLibraryStats' property.

Cached name for the 'IsShowingUpgradedCard' property.

Cached name for the '_isPreviewingUpgrade' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Sets the angle we want this card to be (in degrees). Used when fanning out cards in the hand. Lacks features that normal tweens have.

Sets the target global position we want this card to be at. Used when we want this card to navigate from one position to another without a fixed time frame (non-tween).

Sets the target scale we want this card to be at, it will smoothly get there. Used when we want to lerp this card scale in various screens but lacks features that normal tweens have.

Cancels tweens and sets the Rotation of this CardHolder

Cancels tweens and sets the Scale of this CardHolder

Call if we want to stop animating this CardHolder for any reason (like using separate animators/tweens)

Animates our card to rotate to targetAngle. NOTE: This is NOT a timer-based tween.

Animates our card to scale to targetSize. NOTE: This is NOT a timer-based tween.

Animates our card to move to a specified position. NOTE: This is NOT a timer-based tween.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Clear' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnMousePressed' method.

Cached name for the 'OnMouseReleased' method.

Cached name for the 'DoCardHoverEffects' method.

Cached name for the 'SetIndexLabel' method.

Cached name for the 'SetTargetAngle' method.

Cached name for the 'SetTargetPosition' method.

Cached name for the 'SetTargetScale' method.

Cached name for the 'SetAngleInstantly' method.

Cached name for the 'SetScaleInstantly' method.

Cached name for the 'StopAnimations' method.

Cached name for the 'SetCard' method.

Cached name for the 'UpdateCard' method.

Cached name for the 'BeginDrag' method.

Cached name for the 'CancelDrag' method.

Cached name for the 'SetDefaultTargets' method.

Cached name for the 'Flash' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InSelectMode' property.

Cached name for the 'TargetPosition' property.

Cached name for the 'TargetAngle' property.

Cached name for the 'ShouldGlowGold' property.

Cached name for the 'ShouldGlowRed' property.

Cached name for the '_flash' field.

Cached name for the '_flashTween' field.

Cached name for the '_handIndexLabel' field.

Cached name for the '_targetPosition' field.

Cached name for the '_targetAngle' field.

Cached name for the '_targetScale' field.

Cached name for the '_hand' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'HolderFocused' signal.

Cached name for the 'HolderUnfocused' signal.

Cached name for the 'HolderMouseClicked' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Initialize' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'SetCardScale' method.

Cached name for the 'CreateHoverTips' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'HoverScale' property.

Cached name for the 'SmallScale' property.

Cached name for the 'IsShowingUpgradedCard' property.

Cached name for the '_showHoverTips' field.

Cached name for the '_scaleOnHover' field.

Cached name for the '_originalScale' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'CreateHoverTips' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The visibility of the model. In all cases during a run, this should be ModelVisibility.Visible. When we are showing the card as part of the compendium or other places, the card might show up as unknown (if the player has not seen it) or locked (if the card is locked in the timeline.

Try to find a card's node if it is in the Play or Hand pile. The "Table" here refers to the Play or Hand Pile, where there would be card nodes.

The card to find. The pile to try to find the card in. If null, the card's pile will be used.

WARNING: You usually want to use the Size property on . This is just for if you need the size of an NCard that's not in a holder. Get the current size of this card. Takes scale into account.

Sets the creature that the card is targeting. Necessary to do things like update damage amounts when the target has Vulnerable.

Creature being targeted by the card.

Refreshes this card to show the correct text given the context.

The pile that the card is being viewed in. We can't just use Model.Pile here, because the visual context might not match up. Examples: When a card is being played, it might transition from the play pile to the discard pile while being displayed. If the text to changed in response to this, it would be visually jarring. The type of preview to show in the card's visuals. See for details.

Used when an Enchantment is temporarily disabled on a card. This change is purely visual. For instance, an Enchantment which only triggers once per turn or requires a condition to activate.

Update the color of the card's energy cost. See for details on the rules when the card is in the player's hand. WARNING: If you make a change to this method, you should probably make a similar change to , or write a comment explaining why the two methods are different.

The pile that the card is being viewed in. See UpdateText() for why we need this.

Update the color of the card's star cost. See for details on the rules when the card is in the player's hand. WARNING: If you make a change to this method, you should probably make a similar change to , or write a comment explaining why the two methods are different.

The pile that the card is being viewed in. See UpdateText() for why we need this.

Animates the card cost texts between random costs until settling on the real cost. Used for content that randomizes card costs (ie snecko eye)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'OnInstantiated' method.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'InitPool' method.

Cached name for the 'GetCurrentSize' method.

Cached name for the 'UpdateVisuals' method.

Cached name for the 'ShowUpgradePreview' method.

Cached name for the 'UpdateEnchantmentVisuals' method.

Cached name for the 'OnEnchantmentStatusChanged' method.

Cached name for the 'SetEnchantmentStatus' method.

Cached name for the 'UpdateEnergyCostVisuals' method.

Cached name for the 'SetPretendCardCanBePlayed' method.

Cached name for the 'SetForceUnpoweredPreview' method.

Cached name for the 'UpdateEnergyCostColor' method.

Cached name for the 'UpdateStarCostVisuals' method.

Cached name for the 'UpdateStarCostText' method.

Cached name for the 'UpdateStarCostColor' method.

Cached name for the 'GetCostTextColorInHand' method.

Cached name for the 'GetCostOutlineColorInHand' method.

Cached name for the 'PlayRandomizeCostAnim' method.

Cached name for the 'Reload' method.

Cached name for the 'UpdateTypePlaque' method.

Cached name for the 'UpdateTypePlaqueSizeAndPosition' method.

Cached name for the 'UpdateTitleLabel' method.

Cached name for the 'GetTitleLabelOutlineColor' method.

Cached name for the 'ReloadOverlay' method.

Cached name for the 'OnAfflictionChanged' method.

Cached name for the 'OnEnchantmentChanged' method.

Cached name for the 'GetTitleText' method.

Cached name for the 'ActivateRewardScreenGlow' method.

Cached name for the 'KillRarityGlow' method.

Cached name for the 'AnimCardToPlayPile' method.

Cached name for the 'OnReturnedFromPool' method.

Cached name for the 'OnFreedToPool' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CardHighlight' property.

Cached name for the 'Body' property.

Cached name for the 'Visibility' property.

Cached name for the 'PlayPileTween' property.

Cached name for the 'RandomizeCostTween' property.

Cached name for the 'DisplayingPile' property.

Cached name for the 'EnchantmentTab' property.

Cached name for the 'EnchantmentVfxOverride' property.

Cached name for the 'OverlayContainer' property.

Cached name for the 'CardVfxContainer' property.

Cached name for the '_titleLabel' field.

Cached name for the '_descriptionLabel' field.

Cached name for the '_ancientPortrait' field.

Cached name for the '_portrait' field.

Cached name for the '_frame' field.

Cached name for the '_ancientBorderGlassOverlay' field.

Cached name for the '_ancientBorder' field.

Cached name for the '_ancientBanner' field.

Cached name for the '_ancientTextBg' field.

Cached name for the '_portraitBorder' field.

Cached name for the '_banner' field.

Cached name for the '_lock' field.

Cached name for the '_typePlaque' field.

Cached name for the '_typeLabel' field.

Cached name for the '_portraitCanvasGroup' field.

Cached name for the '_rareGlow' field.

Cached name for the '_uncommonGlow' field.

Cached name for the '_sparkles' field.

Cached name for the '_energyIcon' field.

Cached name for the '_energyLabel' field.

Cached name for the '_unplayableEnergyIcon' field.

Cached name for the '_starIcon' field.

Cached name for the '_starLabel' field.

Cached name for the '_unplayableStarIcon' field.

Cached name for the '_overlayContainer' field.

Cached name for the '_cardOverlay' field.

Cached name for the '_cardVfxContainer' field.

Cached name for the '_enchantmentTab' field.

Cached name for the '_enchantmentVfxOverride' field.

Cached name for the '_enchantmentIcon' field.

Cached name for the '_enchantmentLabel' field.

Cached name for the '_defaultEnchantmentPosition' field.

Cached name for the '_pretendCardCanBePlayed' field.

Cached name for the '_forceUnpoweredPreview' field.

Cached name for the '_portraitBlurMaterial' field.

Cached name for the '_canvasGroupMaskBlurMaterial' field.

Cached name for the '_canvasGroupBlurMaterial' field.

Cached name for the '_canvasGroupMaskMaterial' field.

Cached name for the '_visibility' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ReAddCardNodes' method.

Cached name for the 'OnClicked' method.

Cached name for the 'OnFocused' method.

Cached name for the 'OnUnfocused' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hitbox' property.

Cached name for the '_hoverScale' field.

Cached name for the 'smallScale' field.

Cached name for the '_cardHolder' field.

Cached name for the '_hoverTween' field.

Cached name for the '_cardTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Clicked' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Returns the currently displayed cards. Since the grid only displays chunks of cards at a time, remember that this may not hold all the cards in the grid.

True when the card library is animating or has animated out all cards that were displayed.

Detects mouse click up/down and updates our scroll target accordingly

Detects mouse wheel up/down and updates our scroll target accordingly

Sets the cards to display in the grid. If IsCardLibrary is true, then the old cards will be animated out and the new cards will be animated in.

The set of cards to display. The type of pile we are displaying. Used when updating the text on the cards. The sorting applied to the cards. If non-null, the new cards will not be displayed until this task is finished. Prefer passing it over awaiting it, as the old cards can still animate out while the task is running and hide loading.

Animate the grid out. If this grid is not the card library grid, then this does nothing. If this is called before SetCards, then SetCards will wait for this animation to be completed before the cards animate back in. Otherwise, SetCards itself will call this.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdateScrollLimitBottom' method.

Cached name for the '_GuiInput' method.

Cached name for the '_Process' method.

Cached name for the '_Notification' method.

Cached name for the 'SetScrollPosition' method.

Cached name for the 'SetCanScroll' method.

Cached name for the 'InsetForTopBar' method.

Cached name for the 'ProcessMouseEvent' method.

Cached name for the 'ProcessScrollEvent' method.

Cached name for the 'ProcessGuiFocus' method.

Cached name for the 'UpdateScrollPosition' method.

Cached name for the 'ClearGrid' method.

Cached name for the 'CalculateRowsNeeded' method.

Cached name for the 'InitGrid' method.

Cached name for the 'GetContainedCardsSize' method.

Cached name for the 'ReflowColumns' method.

Cached name for the 'UpdateGridPositions' method.

Cached name for the 'OnHolderPressed' method.

Cached name for the 'OnHolderAltPressed' method.

Cached name for the 'GetTotalRowCount' method.

Cached name for the 'AllocateCardHolders' method.

Cached name for the 'ReallocateAll' method.

Cached name for the 'UpdateGridNavigation' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CanScroll' property.

Cached name for the 'DisplayedRows' property.

Cached name for the 'Columns' property.

Cached name for the 'CardPadding' property.

Cached name for the 'IsCardLibrary' property.

Cached name for the 'ScrollLimitBottom' property.

Cached name for the 'ScrollLimitTop' property.

Cached name for the 'IsAnimatingOut' property.

Cached name for the 'IsShowingUpgrades' property.

Cached name for the 'YOffset' property.

Cached name for the 'CenterGrid' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the 'FocusedControlFromTopBar' property.

Cached name for the '_startDrag' field.

Cached name for the '_targetDrag' field.

Cached name for the '_isDragging' field.

Cached name for the '_scrollingEnabled' field.

Cached name for the '_scrollContainer' field.

Cached name for the '_scrollbarPressed' field.

Cached name for the '_scrollbar' field.

Cached name for the '_slidingWindowCardIndex' field.

Cached name for the '_pileType' field.

Cached name for the '_cardSize' field.

Cached name for the '_cardsAnimatingOutForSetCards' field.

Cached name for the '_isShowingUpgrades' field.

Cached name for the '_lastFocusedHolder' field.

Cached name for the '_needsReinit' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'HolderPressed' signal.

Cached name for the 'HolderAltPressed' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'AnimShow' method.

Cached name for the 'AnimHide' method.

Cached name for the 'AnimHideInstantly' method.

Cached name for the 'AnimFlash' method.

Cached name for the 'GetShaderParameter' method.

Cached name for the 'SetShaderParameter' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_curTween' field.

Cached name for the '_shaderMaterial' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Shows a card's before and after for when they get enchanted.

Helper function to remove any existing preview cards

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'RemoveExistingCards' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_before' field.

Cached name for the '_after' field.

Cached name for the '_arrows' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A simple lookup function to fetch the correct banner color given the rarity of the card. Note that the colors used here are slightly more vivid than in-game to improve legibility. This is because the deck history entries are tiny icons.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetCardPortraitShape' method.

Cached name for the 'SetBannerColor' method.

Cached name for the 'GetBannerColor' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_cardBack' field.

Cached name for the '_cardPortrait' field.

Cached name for the '_cardPortraitShadow' field.

Cached name for the '_cardBanner' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Used in Events. Displays original card on left and a card that rapidly cycles through random cards on the right.

Helper function to remove any existing preview cards

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Uninitialize' method.

Cached name for the 'RemoveExistingCards' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'SelectedCardPosition' property.

Cached name for the '_before' field.

Cached name for the '_after' field.

Cached name for the '_arrows' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Used in Rest Site, Armaments, etc. This is only for upgrades. Not used for previewing enchantments.

Helper function to remove any existing preview cards

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Reload' method.

Cached name for the 'RemoveExistingCards' method.

Cached name for the 'ReturnCard' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'SelectedCardPosition' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_before' field.

Cached name for the '_after' field.

Cached name for the '_arrows' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

An abstract base class in charge of managing the logic for playing a card from your hand. Inherited classes manage card play behavior for different types of inputs. Is created and destroyed on demand.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Start' method.

Cached name for the 'CancelPlayCard' method.

Cached name for the 'OnCancelPlayCard' method.

Cached name for the 'Cleanup' method.

Cached name for the 'OnCreatureHover' method.

Cached name for the 'OnCreatureUnhover' method.

Cached name for the 'CenterCard' method.

Cached name for the 'HideTargetingVisuals' method.

Cached name for the 'ShowMultiCreatureTargetingVisuals' method.

Cached name for the 'AutoDisableCannotPlayCardFtueCheck' method.

Cached name for the 'TryShowEvokingOrbs' method.

Cached name for the 'HideEvokingOrbs' method.

Cached name for the 'ClearTarget' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Holder' property.

Cached name for the 'CardNode' property.

Cached name for the 'CardOwnerNode' property.

Cached name for the '_viewport' field.

Cached name for the '_isTryingToPlayCard' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Finished' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Takes control of card nodes that are about to be played and arranges them in the order of play.

Called after a card is played by the local player. If the card is not yet in the play pile, it tweens the card into its queue position.

The play card action that caused the card to be played. The card holder that was played. The card that was played.

Called when any action is enqueued onto the action queue. Handles cases in which a card is played by a remote player and we want to display the card in the queue.

The action that was enqueued.

After remote player choice is complete, this re-adds the card back into the queue if necessary. Note that this is not called for local player choice - that just sits in the center of the screen.

The card that finished player choice. The action that ran the player choice.

This is a bit of a hack. When a card resumes execution after player choice, there's nothing to tell the card that it needs to animate back to the play pile. We do it here, even though we're not really responsible for the play pile.

Action that finished player choice.

Called when a card play is canceled. When a card play is canceled (e.g. because it's now targeting something invalid), this removes the card from the queue. If the card was a local card, then it is returned to the hand.

The play card action that was canceled.

Called when a card play is canceled. When a card play is canceled (e.g. because it's now targeting something invalid), this removes the card from the queue. If the card was a local card, then it is returned to the hand.

The card node that was cancelled. In rare circumstances, we want to force the card to return to the hand even though it's not in the hand pile. If true is passed, the card holder will be added to the player hand instead of fading away (e.g. as if autoplayed). Only use this if you know what you're doing.

Called just before a card begins execution. For the play pile to properly take control of cards that are in the queue, the queue must reference the exact card that is getting played. In most instances, this is true when the action is enqueued. However, if the card was dynamically created in combat but not yet created on our peer at enqueue time, then it was created with a placeholder card. By this time, it should be available.

The action that is about to be executed.

Called when a card begins execution. The play pile (specifically CardPileCmd.Add) takes control of the NCard when it begins executing. This method relinquishes control of the NCard, but does nothing with the node afterward - it is left where it is, and we expect CardPileCmd.Add to tween it to the play pile position.

The card that was canceled.

Updates a card's visuals (i.e. updates target, updates text).

Removes a specific node from the queue and tweens other cards to their new position. The node is not freed.

Removes a specific card index from the queue and tweens other cards to their new position. The node is not freed.

Tweens all cards to their position/scale in the queue.

Returns the NCard representing the card if it is in the queue. Remember that: - Cards that are being dragged are in the NPlayerHand - Cards that are being executed are in NCombatUi.PlayContainer This only returns cards that are enqueued, but not yet executing.

The card whose node we will return. The node for the card, if it is in the play queue.

Dequeue and hide all cards that are in the queue. This is called when combat ends so that cards don't just hang out.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'RemoveCardFromQueueForCancellation' method.

Cached name for the 'RemoveCardFromQueue' method.

Cached name for the 'TweenAllToQueuePosition' method.

Cached name for the 'AnimOut' method.

Cached name for the 'GetScaleForQueueIndex' method.

Cached name for the 'GetPositionForQueueIndex' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Node script for DrawPile, DiscardPile, and ExhaustPile. Don't extend to more piles! Make bespoke scripts.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'SetAnimInOutPositions' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'AddCard' method.

Cached name for the 'RemoveCard' method.

Cached name for the 'AnimIn' method.

Cached name for the 'AnimOut' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Pile' property.

Cached name for the '_countLabel' field.

Cached name for the '_icon' field.

Cached name for the '_bumpTween' field.

Cached name for the '_currentCount' field.

Cached name for the '_positionTween' field.

Cached name for the '_showPosition' field.

Cached name for the '_hidePosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages a set of s for a given player. Primarily used in , but reused in other screens where we want to be able to check on the combat piles (ie )

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'AnimIn' method.

Cached name for the 'AnimOut' method.

Cached name for the 'Enable' method.

Cached name for the 'Disable' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DrawPile' property.

Cached name for the 'DiscardPile' property.

Cached name for the 'ExhaustPile' property.

Cached name for the '_drawPile' field.

Cached name for the '_discardPile' field.

Cached name for the '_exhaustPile' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Resizes BgContainer of the combat room so it fits well in all aspect ratios. TODO: Expand to adjust for enemy placement.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnWindowChange' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_window' field.

Cached name for the '_bgContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Start of enemy combat banner (for non-boss enemies). Creates a player turn banner as well.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_colorRect' field.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

When switching into peek mode, we move the play container cards off to the side for better visibility. When switching back out, we use the positions in this dictionary to move them back to their original positions.

When switching into peek mode, we shrink the play container cards for better visibility. When switching back out, we use the scales in this dictionary to move them back to their original sizes.

Animates combat UI elements into the scene visually.

Animates the combat UI elements out of the scene visually.

Toggles the visibility of the combat UI

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Deactivate' method.

Cached name for the 'DisconnectSignals' method.

Cached name for the 'AddToPlayContainer' method.

Cached name for the 'AnimIn' method.

Cached name for the 'AnimOut' method.

Cached name for the 'PostCombatCleanUp' method.

Cached name for the 'OnHandSelectModeEntered' method.

Cached name for the 'OnHandSelectModeExited' method.

Cached name for the 'OnPeekButtonReady' method.

Cached name for the 'OnPeekButtonToggled' method.

Cached name for the 'Enable' method.

Cached name for the 'Disable' method.

Cached name for the '_Input' method.

Cached name for the 'DebugHideCombatUi' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'EnergyCounterContainer' property.

Cached name for the 'EndTurnButton' property.

Cached name for the 'PingButton' property.

Cached name for the 'DrawPile' property.

Cached name for the 'DiscardPile' property.

Cached name for the 'ExhaustPile' property.

Cached name for the 'Hand' property.

Cached name for the 'PlayContainer' property.

Cached name for the 'PlayQueue' property.

Cached name for the 'CardPreviewContainer' property.

Cached name for the 'MessyCardPreviewContainer' property.

Cached name for the '_starCounter' field.

Cached name for the '_energyCounter' field.

Cached name for the '_combatPilesContainer' field.

Cached name for the '_playContainerPeekModeTween' field.

Cached name for the '_originalHandChildIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Input' method.

Cached name for the 'Create' method.

Cached name for the 'Start' method.

Cached name for the '_ExitTree' method.

Cached name for the 'DisconnectTargetingSignals' method.

Cached name for the 'MultiCreatureTargeting' method.

Cached name for the 'OnCancelPlayCard' method.

Cached name for the 'Cleanup' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_onCreatureHoverCallable' field.

Cached name for the '_onCreatureUnhoverCallable' field.

Cached name for the '_signalsConnected' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Confirmed' signal.

Cached name for the 'Canceled' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Keeps track of the looping sfx that are owned by this creature (ie thieving hopper's fluttering). We use this as a way to easily cancel all looping sfx when a creature instance is killed or despawned. - The Key is the string field of the sfx we are tracking (ie event://flying_sfx) - The Value is a Tuple, where the first item is the loop param we will use to end the sfx and the second item is the value that we need to set that param to end the sfx. (ie ("loop", 1)). We need to do this because not all sfx loops use the same loop param or loop value to finish the FMOD event (ie waterfall giant uses the same loop param to ramp up how intense it is AND to end the loop).

Called when a creatures hitbox is updated. Called on initialization and things like Osty getting bigger, thieving hopper flying, etc.

The parent node which has the children: Bounds, CenterPos, and IntentPos nodes.

This makes the intents visible again! So let's fade them in.

Helper function to get the top of this creature's hitbox position. Used for spawning vfx or aligning UI elements to a creature's hitbox.

Helper function to get the top of this creature's hitbox position. Used for spawning vfx or aligning UI elements to a creature's hitbox.

Track the block status of another creature. Used for pets who want to show extra UI when their owner has block. For example, Osty tracks Necrobinder's block.

Extra creature (different from _creature) whose block status we want to track in this UI.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ConnectSpineAnimatorSignals' method.

Cached name for the 'UpdateBounds' method.

Cached name for the 'UpdatePhobiaMode' method.

Cached name for the 'UpdateNavigation' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnTargetingStarted' method.

Cached name for the 'SetRemotePlayerFocused' method.

Cached name for the 'HideHoverTips' method.

Cached name for the 'SetAnimationTrigger' method.

Cached name for the 'GetCurrentAnimationLength' method.

Cached name for the 'GetCurrentAnimationTimeRemaining' method.

Cached name for the 'ToggleIsInteractable' method.

Cached name for the 'AnimDisableUi' method.

Cached name for the 'AnimEnableUi' method.

Cached name for the 'StartDeathAnim' method.

Cached name for the 'StartReviveAnim' method.

Cached name for the 'AnimTempRevive' method.

Cached name for the 'ImmediatelySetIdle' method.

Cached name for the 'AnimHideIntent' method.

Cached name for the 'SetScaleAndHue' method.

Cached name for the 'ScaleTo' method.

Cached name for the 'SetDefaultScaleTo' method.

Cached name for the 'OstyScaleToSize' method.

Cached name for the 'AnimShake' method.

Cached name for the 'DoScaleTween' method.

Cached name for the 'SetOrbManagerPosition' method.

Cached name for the 'GetTopOfHitbox' method.

Cached name for the 'GetBottomOfHitbox' method.

Cached name for the 'ShowMultiselectReticle' method.

Cached name for the 'HideMultiselectReticle' method.

Cached name for the 'ShowSingleSelectReticle' method.

Cached name for the 'HideSingleSelectReticle' method.

Cached name for the 'SetupForBestiary' method.

Cached name for the 'StartSfxLoop' method.

Cached name for the 'StopSfxLoop' method.

Cached name for the 'StopAllSfxLoops' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hitbox' property.

Cached name for the 'OrbManager' property.

Cached name for the 'IsInteractable' property.

Cached name for the 'VfxSpawnPosition' property.

Cached name for the 'PowerAppliedVfxSpawnPosition' property.

Cached name for the 'Visuals' property.

Cached name for the 'Body' property.

Cached name for the 'IntentContainer' property.

Cached name for the 'IsPlayingDeathAnimation' property.

Cached name for the 'HasSpineAnimation' property.

Cached name for the 'IsFocused' property.

Cached name for the 'PlayerIntentHandler' property.

Cached name for the '_stateDisplay' field.

Cached name for the '_intentFadeTween' field.

Cached name for the '_shakeTween' field.

Cached name for the '_isRemotePlayerOrPet' field.

Cached name for the '_isInBestiary' field.

Cached name for the '_tempScale' field.

Cached name for the '_scaleTween' field.

Cached name for the '_isInMultiselect' field.

Cached name for the '_selectionReticle' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

See for details.

See for details.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'SubscribeToCreatureEvents' method.

Cached name for the 'DebugToggleVisibility' method.

Cached name for the 'SetCreatureBounds' method.

Cached name for the 'RefreshValues' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Cached name for the 'ShowNameplate' method.

Cached name for the 'HideNameplate' method.

Cached name for the 'HideImmediately' method.

Cached name for the 'AnimateIn' method.

Cached name for the 'AnimateInBlock' method.

Cached name for the 'AnimateOut' method.

Cached name for the 'OnBlockTrackingCreatureBlockChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_powerContainer' field.

Cached name for the '_nameplateContainer' field.

Cached name for the '_nameplateLabel' field.

Cached name for the '_healthBar' field.

Cached name for the '_hpBarHitbox' field.

Cached name for the '_creatureSize' field.

Cached name for the '_showHideTween' field.

Cached name for the '_hoverTween' field.

Cached name for the '_originalPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Position we spawn things like hit vfx. Sometimes the center of the creatures isn't always the center of the visual.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'GetCurrentBody' method.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'SetScaleAndHue' method.

Cached name for the 'IsPlayingHurtAnimation' method.

Cached name for the 'TryApplyLiquidOverlay' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bounds' property.

Cached name for the 'IntentPosition' property.

Cached name for the 'OrbPosition' property.

Cached name for the 'TalkPosition' property.

Cached name for the 'IsSpineNode' property.

Cached name for the 'HasSpineAnimation' property.

Cached name for the 'IsUsingPhobiaModeBody' property.

Cached name for the 'VfxSpawnPosition' property.

Cached name for the 'DefaultScale' property.

Cached name for the '_body' field.

Cached name for the '_phobiaModeBody' field.

Cached name for the '_hue' field.

Cached name for the '_liquidOverlayTimer' field.

Cached name for the '_savedNormalMaterial' field.

Cached name for the '_currentLiquidOverlayMaterial' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Node script for the Discard Pile.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetAnimInOutPositions' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the 'Pile' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Node script for the Draw Pile.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetAnimInOutPositions' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the 'Pile' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

End Turn button. Differs from other buttons as there are several flags which interact with each other and a pulsing vfx: State.Shown: Indicates that this button is press-able. Additionally, flies on screen from the bottom with different behavior from isHidden. State.Disabled: Grayed out and cannot be pressed. State.Hidden: Grayed out and cannot be pressed. Additionally, flies off screen downward with different behavior from isHidden. isShiny: Used when you have no valid cards to play so the button is visually more noticeable. !isShiny: The opposite behavior of above.

Returns true when the player's icon should be displayed above the end turn button, indicating readiness. The icons are only refreshed when _playerIconContainer.RefreshPlayerVotes is called.

Things which occur when the EndTurn button is pressed

Helper because we can call the End Turn button in numerous ways (controller, mouse, long press mouse, etc)

Don't call me >:(

Called at the start of player turn, and when the button re-enables itself if not everyone in multiplayer is ready.

Called when the player presses End Turn or combat ends.

Animates the button out off the screen and disables the button if it is currently enabled.

Animates the button in from off the screen.

Set the state of the button. Use this instead of calling Enable or Disable directly, as the enabled/disabled state of the button can also be controlled by the state of the UI above the button (see RefreshEnabled).

Refreshes whether the button is enabled or not. Should be called when a screen appears/disappears. Use this instead of calling Enable or Disable directly! The enabled/disabled state of the button should be controlled by the button itself.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'StartOrStopPulseVfx' method.

Cached name for the 'GlowPulse' method.

Cached name for the 'OnRelease' method.

Cached name for the 'CallReleaseLogic' method.

Cached name for the 'SecretEndTurnLogicViaFtue' method.

Cached name for the 'ShouldShowPlayableCardsFtue' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'AnimOut' method.

Cached name for the 'AnimIn' method.

Cached name for the 'OnCombatEnded' method.

Cached name for the 'OnFocus' method.

Cached name for the 'HasPlayableCard' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'UpdateShaderV' method.

Cached name for the 'SetState' method.

Cached name for the 'RefreshEnabled' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CanTurnBeEnded' property.

Cached name for the 'ShowPos' property.

Cached name for the 'HidePos' property.

Cached name for the 'Hotkeys' property.

Cached name for the '_state' field.

Cached name for the '_isShiny' field.

Cached name for the '_visuals' field.

Cached name for the '_glowTexture' field.

Cached name for the '_normalTexture' field.

Cached name for the '_image' field.

Cached name for the '_hsv' field.

Cached name for the '_glow' field.

Cached name for the '_glowVfx' field.

Cached name for the '_label' field.

Cached name for the '_combatUi' field.

Cached name for the '_viewport' field.

Cached name for the '_playerIconContainer' field.

Cached name for the '_longPressBar' field.

Cached name for the '_pulseTimer' field.

Cached name for the '_positionTween' field.

Cached name for the '_hoverTween' field.

Cached name for the '_glowVfxTween' field.

Cached name for the '_glowEnableTween' field.

Cached name for the '_endTurnWithNoPlayableCardsCount' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This bar represents the player's progress when clicking or pushing down the End Turn input. When the bar is filled, the turn is ended. This is an option players can enable so they don't accidentally press the End Turn button (useful for touch-devices and people who are simply playing super fast all the time).

Called when the bar is completely filled.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Init' method.

Cached name for the 'StartPress' method.

Cached name for the 'CancelPress' method.

Cached name for the '_Process' method.

Cached name for the 'RecalculateBar' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_outline' field.

Cached name for the '_pressTimer' field.

Cached name for the '_isPressed' field.

Cached name for the '_endTurnButton' field.

Cached name for the '_tween' field.

Cached name for the '_enabled' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Cached name for the 'RefreshLabel' method.

Cached name for the 'OnEnergyChanged' method.

Cached name for the '_Process' method.

Cached name for the 'AnimIn' method.

Cached name for the 'AnimOut' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'OutlineColor' property.

Cached name for the '_label' field.

Cached name for the '_layers' field.

Cached name for the '_rotationLayers' field.

Cached name for the '_backVfx' field.

Cached name for the '_frontVfx' field.

Cached name for the '_animInTween' field.

Cached name for the '_animOutTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Node script for the Exhaust Pile.

The text "bump" animation for pile UI.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'AddCard' method.

Cached name for the 'SetAnimInOutPositions' method.

Cached name for the 'AnimIn' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the 'Pile' property.

Cached name for the '_viewport' field.

Cached name for the '_posOffset' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Controls visual logic for the health bar! This includes the red part, the text, block icon, and handles Poison/Doom. This does NOT control the behavior/layout of Powers.

Linearly interpolates the width of the HP bar based on the reference values.

A reference max HP. The width of the HP bar when the max HP is equal to refMaxHp.

Sets the container size, deferring it to avoid issues. TODO: What issues? I'm not sure, it's from an old commit

Forces the health bar to look right and start/stop animations. Called often, even if the health bar isn't affected.

Determines whether the Block icon should be visible + the color of the health bar if you have Block. Note that the text on the health bar is handled elsewhere -> RefreshText();

The text that displays HP. e.g. 72/72 This logic controls this text's color and its outline as it's affected by having Block, being in lethal due to Poison/Doom, and Invincibility.

Checks if Doom is lethal when it's to trigger next. Poison damage is also incorporated as the creature's HP may drop at the start of their turn and their remaining HP may enter Doom range.

Calculates the width of the foreground given an "amount" which is a ratio of this and the MaxHP. Example: If amount is currentHp. Then if you have 12 currentHP and 50 maxHp, this would return 0.24 (12/50) multiplied by the width of the foreground bar's total length. If the bar is 240px, then we would return 240 x 0.24 as a float.

See for details.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'DebugToggleVisibility' method.

Cached name for the 'UpdateLayoutForCreatureBounds' method.

Cached name for the 'UpdateWidthRelativeToReferenceValue' method.

Cached name for the 'SetHpBarContainerSizeWithOffsets' method.

Cached name for the 'SetHpBarContainerSizeWithOffsetsImmediately' method.

Cached name for the 'RefreshValues' method.

Cached name for the 'RefreshMiddleground' method.

Cached name for the 'RefreshForeground' method.

Cached name for the 'RefreshBlockUi' method.

Cached name for the 'RefreshText' method.

Cached name for the 'IsPoisonLethal' method.

Cached name for the 'IsDoomLethal' method.

Cached name for the 'GetFgWidth' method.

Cached name for the 'FadeOutHpLabel' method.

Cached name for the 'FadeInHpLabel' method.

Cached name for the 'AnimateInBlock' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'MaxFgWidth' property.

Cached name for the 'HpBarContainer' property.

Cached name for the '_hpForegroundContainer' field.

Cached name for the '_hpForeground' field.

Cached name for the '_poisonForeground' field.

Cached name for the '_doomForeground' field.

Cached name for the '_hpMiddleground' field.

Cached name for the '_hpLabel' field.

Cached name for the '_blockContainer' field.

Cached name for the '_blockLabel' field.

Cached name for the '_blockOutline' field.

Cached name for the '_infinityTex' field.

Cached name for the '_blockTween' field.

Cached name for the '_hpLabelFadeTween' field.

Cached name for the '_middlegroundTween' field.

Cached name for the '_originalBlockPosition' field.

Cached name for the '_currentHpOnLastRefresh' field.

Cached name for the '_maxHpOnLastRefresh' field.

Cached name for the '_expectedMaxFgWidth' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the 'DebugToggleVisibility' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdateVisuals' method.

Cached name for the '_Process' method.

Cached name for the 'Create' method.

Cached name for the 'PlayPerform' method.

Cached name for the 'SetFrozen' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_intentHolder' field.

Cached name for the '_intentSprite' field.

Cached name for the '_valueLabel' field.

Cached name for the '_intentParticle' field.

Cached name for the '_timeOffset' field.

Cached name for the '_timeAccumulator' field.

Cached name for the '_isFrozen' field.

Cached name for the '_animationName' field.

Cached name for the '_combatRoom' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

shortcut to cancel the card play. Usually we set this to be the index of the card holder in the hand,

Has the card moved up into the Play Zone? This happens when the card was near the bottom of the screen (meaning you just started dragging it) and then you drag it up higher to start targeting it.

Has the card moved down into the Cancel Zone? This happens when the card was in the Play Zone (meaning you were targeting it) and then you drag it back down to cancel the play. We use a greater value (further down the screen) for the Cancel Zone than the Play Zone because: 1. We want you to have to move the card down a meaningful amount before we stop targeting. 2. For multi-target cards, we want an "intermediate" zone where the card doesn't show targeting visuals but we haven't canceled yet.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Input' method.

Cached name for the 'Start' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'DisconnectTargetingSignals' method.

Cached name for the 'OnCancelPlayCard' method.

Cached name for the 'IsCardInPlayZone' method.

Cached name for the 'IsCardInCancelZone' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'PlayZoneThreshold' property.

Cached name for the 'CancelZoneThreshold' property.

Cached name for the '_hasLeftCardCancelZoneOnce' field.

Cached name for the '_dragStartYPosition' field.

Cached name for the '_isLeftMouseDown' field.

Cached name for the '_onCreatureHoverCallable' field.

Cached name for the '_onCreatureUnhoverCallable' field.

Cached name for the '_signalsConnected' field.

Cached name for the '_cancelShortcut' field.

Cached name for the '_skipStartCardDrag' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This method handles re-hiding the backstop if the peek button is inside an overlay screen and another screen appeared above it and then was removed.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnOverlayStackChanged' method.

Cached name for the 'Wiggle' method.

Cached name for the 'AddTargets' method.

Cached name for the 'SetPeeking' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnCombatRoomReady' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the 'IsPeeking' property.

Cached name for the 'CurrentCardMarker' property.

Cached name for the '_flash' field.

Cached name for the '_visuals' field.

Cached name for the '_hoverTween' field.

Cached name for the '_wiggleTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Toggled' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Ping button. Flies in from off-screen after a short delay when the local player is ready but remote players are not.

Called when the player presses End Turn or combat ends.

Animates the button out off the screen and disables the button if it is currently enabled.

Animates the button in from off the screen.

Set the state of the button. Use this instead of calling Enable or Disable directly, as the enabled/disabled state of the button can also be controlled by the state of the UI above the button (see RefreshEnabled).

Refreshes whether the button is enabled or not. Should be called when a screen appears/disappears. Use this instead of calling Enable or Disable directly! The enabled/disabled state of the button should be controlled by the button itself.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'AnimOut' method.

Cached name for the 'AnimIn' method.

Cached name for the 'OnCombatEnded' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'UpdateShaderV' method.

Cached name for the 'SetState' method.

Cached name for the 'RefreshEnabled' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ShowPos' property.

Cached name for the 'HidePos' property.

Cached name for the 'Hotkeys' property.

Cached name for the '_state' field.

Cached name for the '_visuals' field.

Cached name for the '_image' field.

Cached name for the '_label' field.

Cached name for the '_viewport' field.

Cached name for the '_hsv' field.

Cached name for the '_positionTween' field.

Cached name for the '_hoverTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

If you're dragging a card, it won't be a child of the card holder container for the duration of the drag, so we need to leave an empty space for it in your hand. This index represents where that empty space should be. For example, let's say you start dragging the card in your hand at index 2. Once it's removed from your hand for the drag, the card at index 3 moves to index 2, but visually, we still want to position it at index 3 so we can "leave a space" at index 2. However, the position/angle of the cards at indexes 0 and 1 should be unchanged.

There are two types of cards that are considered "awaiting play": 1. The card you're currently dragging and preparing to play. 2. If you've queued up a bunch of cards for play quickly, all the cards that haven't started playing yet. For example, if I play a Defend, then quickly play 2 Strikes while the Defend's animations are still running, the 2 Strikes are considered "awaiting play" for that time. Cards that are awaiting play exist in a sort of "purgatory" state. From a back-end perspective, they're still in your hand (they count towards hand size, etc.), but on the front-end, they should be floating around somewhere separate from the other cards in your hand. When a holder returns to the hand it is re-inserted at the position matching its model's order in the backend Hand pile (see ), so we do not need to remember its old child index here.

Called whenever we add a card into the hand. Prunes any empty CardHolders and creates a CardHolder for the newly added card.

Remove an NCard and its holder from the hand.

CardModel whose node we want to remove

Translates a card's position in the backend Hand pile into a child index within CardHolderContainer. Cards that are selected, awaiting play, or being dragged stay in the backend Hand pile while their holders are absent from CardHolderContainer (selected holders move to the selected-card container; dragged/queued holders reparent onto the hand itself), so the raw pile index can exceed the live child count and Godot rejects the MoveChild with "Invalid new child index" (PRG-6847). Counting only the holders currently in the container keeps the result within its child range.

The target child index, or -1 if the card is not in the Hand pile (caller should not move).

If the specific model is being played, then cancel it.

Card we are trying to stop from being played

Be sure you know what your doing when you call this function. Should only be used by the NHandCardCountTickbox to toggle on/off the player hand count labels right away.

Call this whenever we gain/lose cards so that we fan out the cards for our players.

Called when a card is clicked in the hand.

CardHolder that was clicked.

Deselect a card when in a Select Mode.

Combat state can change while the player is mid-selection (e.g. another player kills a monster whose power was downgrading our cards). Re-evaluate the filter against the current hand and the currently- selected cards, deselecting anything that no longer qualifies and cancelling the whole selection with an empty result if no valid candidates remain.

Animation for entering combat

Animation when winning combat

Animation when player actions are disabled during player turn

Animation when player actions are re-enabled during player turn

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'IsAwaitingPlay' method.

Cached name for the 'Add' method.

Cached name for the 'AddCardHolder' method.

Cached name for the 'RemoveCardHolder' method.

Cached name for the 'OnHolderFocused' method.

Cached name for the 'OnHolderUnfocused' method.

Cached name for the 'CancelAllCardPlay' method.

Cached name for the 'ReturnHolderToHand' method.

Cached name for the 'ForceRefreshCardIndices' method.

Cached name for the 'RefreshLayout' method.

Cached name for the 'OnPeekButtonToggled' method.

Cached name for the 'UpdateSelectModeCardVisibility' method.

Cached name for the 'CancelHandSelectionIfNecessary' method.

Cached name for the 'OnHolderPressed' method.

Cached name for the 'CanPlayCards' method.

Cached name for the 'AreCardActionsAllowed' method.

Cached name for the 'StartCardPlay' method.

Cached name for the 'SelectCardInSimpleMode' method.

Cached name for the 'SelectCardInUpgradeMode' method.

Cached name for the 'DeselectCard' method.

Cached name for the 'RevalidateSelectionAfterStateChange' method.

Cached name for the 'OnSelectModeConfirmButtonPressed' method.

Cached name for the 'CheckIfSelectionComplete' method.

Cached name for the 'RefreshSelectModeConfirmButton' method.

Cached name for the 'AnimIn' method.

Cached name for the 'AnimOut' method.

Cached name for the 'AnimDisable' method.

Cached name for the 'AnimEnable' method.

Cached name for the 'FlashPlayableHolders' method.

Cached name for the 'OnCardSelected' method.

Cached name for the 'OnCardDeselected' method.

Cached name for the 'UpdateSelectedCardContainer' method.

Cached name for the 'EnableControllerNavigation' method.

Cached name for the 'DisableControllerNavigation' method.

Cached name for the '_UnhandledInput' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CardHolderContainer' property.

Cached name for the 'PeekButton' property.

Cached name for the 'InCardPlay' property.

Cached name for the 'IsInCardSelection' property.

Cached name for the 'CurrentMode' property.

Cached name for the 'HasDraggedHolder' property.

Cached name for the 'FocusedHolder' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_selectCardShortcuts' field.

Cached name for the '_selectModeBackstop' field.

Cached name for the '_upgradePreviewContainer' field.

Cached name for the '_selectedHandCardContainer' field.

Cached name for the '_upgradePreview' field.

Cached name for the '_selectModeConfirmButton' field.

Cached name for the '_selectionHeader' field.

Cached name for the '_currentCardPlay' field.

Cached name for the '_currentMode' field.

Cached name for the '_draggedHolderIndex' field.

Cached name for the '_lastFocusedHolderIdx' field.

Cached name for the '_animEnableTween' field.

Cached name for the '_isDisabled' field.

Cached name for the '_animInTween' field.

Cached name for the '_animOutTween' field.

Cached name for the '_selectedCardScaleTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'ModeChanged' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_turnLabel' field.

Cached name for the '_roundNumber' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Reload' method.

Cached name for the 'OnPulsingStarted' method.

Cached name for the 'OnPulsingStopped' method.

Cached name for the 'RefreshAmount' method.

Cached name for the 'OnDisplayAmountChanged' method.

Cached name for the 'FlashPower' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Cached name for the 'SubscribeToModelEvents' method.

Cached name for the 'UnsubscribeFromModelEvents' method.

Cached name for the 'OnPowerRemoved' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Container' property.

Cached name for the '_icon' field.

Cached name for the '_amountLabel' field.

Cached name for the '_powerFlash' field.

Cached name for the '_animInTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ConnectCreatureSignals' method.

Cached name for the 'SetCreatureBounds' method.

Cached name for the 'UpdatePositions' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the 'StartDrawingFrom' method.

Cached name for the 'StopDrawing' method.

Cached name for the 'UpdateDrawingTo' method.

Cached name for the 'DoTargetingCreatureTween' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_fromPosition' field.

Cached name for the '_toPosition' field.

Cached name for the '_line' field.

Cached name for the '_lineBack' field.

Cached name for the '_tween' field.

Cached name for the '_isTargetingCreature' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Add' method.

Cached name for the 'RefreshHolderPositions' method.

Cached name for the 'DeselectHolder' method.

Cached name for the 'OnFocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hand' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnSelect' method.

Cached name for the 'OnDeselect' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsSelected' property.

Cached name for the '_currentTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ConnectStarsChangedSignal' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Cached name for the 'OnStarsChanged' method.

Cached name for the '_Process' method.

Cached name for the 'UpdateStarCount' method.

Cached name for the 'SetStarCountText' method.

Cached name for the 'UpdateShaderV' method.

Cached name for the 'RefreshVisibility' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_rotationLayers' field.

Cached name for the '_icon' field.

Cached name for the '_hsv' field.

Cached name for the '_lerpingStarCount' field.

Cached name for the '_velocity' field.

Cached name for the '_displayedStarCount' field.

Cached name for the '_hsvTween' field.

Cached name for the '_isListeningToCombatState' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Where the arrow starts from.

Where the arrow tip is trying to be.

Where the arrows tip is currently at. Typically making its way towards the _toPosition, as it lerps between targets. Used only when the game is in controller mode, since in mouse mode we are always tracking the mouse position.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the 'UpdateArrowPosition' method.

Cached name for the 'SetHighlightingOn' method.

Cached name for the 'SetHighlightingOff' method.

Cached name for the 'UpdateSegments' method.

Cached name for the 'StartDrawingFrom' method.

Cached name for the 'StopDrawing' method.

Cached name for the 'UpdateDrawingTo' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'From' property.

Cached name for the '_fromPos' field.

Cached name for the '_fromControl' field.

Cached name for the '_toPosition' field.

Cached name for the '_segments' field.

Cached name for the '_arrowHead' field.

Cached name for the '_arrowHeadTween' field.

Cached name for the '_initialized' field.

Cached name for the '_followMouse' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This is the frame on which the last targeting was cancelled or finished as reported by SceneTree.GetFrame.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the '_Input' method.

Cached name for the '_Process' method.

Cached name for the 'CancelTargeting' method.

Cached name for the 'FinishTargeting' method.

Cached name for the 'AllowedToTargetNode' method.

Cached name for the 'OnNodeHovered' method.

Cached name for the 'OnNodeUnhovered' method.

Cached name for the 'OnCreatureHovered' method.

Cached name for the 'OnCreatureUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsInSelection' property.

Cached name for the 'HoveredNode' property.

Cached name for the 'LastTargetingFinishedFrame' property.

Cached name for the '_targetingArrow' field.

Cached name for the '_targetMode' field.

Cached name for the '_validTargetsType' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'CreatureHovered' signal.

Cached name for the 'CreatureUnhovered' signal.

Cached name for the 'NodeHovered' signal.

Cached name for the 'NodeUnhovered' signal.

Cached name for the 'TargetingBegan' signal.

Cached name for the 'TargetingEnded' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

The Abandon Run confirmation popup to prevent the player from accidentally deleting a run in progress. Used both mid-run and in the main menu. Renders above the capstone screens (above top bar).

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the 'OnYesButtonPressed' method.

Cached name for the 'OnNoButtonPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_verticalPopup' field.

Cached name for the '_mainMenuNode' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Back Button. The Man. The Myth. The Legend.

Call when we want this button to animate in. We refresh a lot of values here as the screen may not have been disposed and we reuse the button. May need to separate this logic into a Refresh() call for organization.

Call when we want this button to hide this button (Disables clickability/hotkeys)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'MoveToHidePosition' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ClickedSfx' property.

Cached name for the 'Hotkeys' property.

Cached name for the 'ControllerIconHotkey' property.

Cached name for the '_outline' field.

Cached name for the '_buttonImage' field.

Cached name for the '_defaultOutlineColor' field.

Cached name for the '_hoveredOutlineColor' field.

Cached name for the '_downColor' field.

Cached name for the '_outlineColor' field.

Cached name for the '_outlineTransparentColor' field.

Cached name for the '_posOffset' field.

Cached name for the '_showPos' field.

Cached name for the '_hidePos' field.

Cached name for the '_hoverTween' field.

Cached name for the '_moveTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ReformatElements' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetHue' method.

Cached name for the 'OnToggle' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'SetLabel' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsDescending' property.

Cached name for the '_isDescending' field.

Cached name for the '_button' field.

Cached name for the '_hsv' field.

Cached name for the '_label' field.

Cached name for the '_sortIcon' field.

Cached name for the '_selectionReticle' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The beige banner which appears on many many screens. Choose a Card!

NOTE: This is set to public for modders as it's a common UI element.

Call this when you want to change the text on an existing banner without animating the banner again.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'AnimateIn' method.

Cached name for the 'AnimateOut' method.

Cached name for the 'ChangeText' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'label' field.

Cached name for the '_labelTween' field.

Cached name for the '_tween' field.

Cached name for the '_showPos' field.

Cached name for the '_hidePos' field.

Cached name for the '_imgOffset' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Confirm Button used in various places to confirm choices, embark on a run, etc. Very useful but not as cool as Back Button but that's life. Use the ButtonReleased Action to handle events.

Call when we want this button to animate in.

Call when we want this button to hide this button (Disables clickability/hotkeys)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OverrideHotkeys' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_outline' field.

Cached name for the '_buttonImage' field.

Cached name for the '_defaultOutlineColor' field.

Cached name for the '_hoveredOutlineColor' field.

Cached name for the '_downColor' field.

Cached name for the '_outlineColor' field.

Cached name for the '_outlineTransparentColor' field.

Cached name for the '_viewport' field.

Cached name for the '_hotkeys' field.

Cached name for the '_posOffset' field.

Cached name for the '_showPos' field.

Cached name for the '_hidePos' field.

Cached name for the '_moveTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The position we warp the mouse to when we switch to controller mode. This is so it no longer hovers over the last control it ws positioned at

Used to reset the mouse position to the last place it was before we swapped to controller mode

Number of frames to ignore mouse motion events after warping the cursor offscreen. WarpMouse generates a synthetic InputEventMouseMotion (via OS event queue, arriving next frame) that would otherwise immediately flip us back to mouse mode.

Minimum relative displacement (squared) to consider a mouse motion event as a warp artifact rather than real user input. No human mouse movement covers 500+ pixels in a single frame.

Fires when we detect that the controller type has changed (ie xbox to ps4).

Checks if the input event is from a mouse and notifies the ui that we are now using mouse input

Checks if the input event is from a controller and notifies the ui that we are now using controller input

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the '_Process' method.

Cached name for the '_Input' method.

Cached name for the 'OnControllerTypeChanged' method.

Cached name for the 'CheckForMouseInput' method.

Cached name for the 'CheckForControllerInput' method.

Cached name for the 'ControlModeChanged' method.

Cached name for the 'OnScreenContextChanged' method.

Cached name for the 'GetHotkeyIcon' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ShouldAllowControllerRebinding' property.

Cached name for the 'IsUsingController' property.

Cached name for the 'ControllerMappingType' property.

Cached name for the '_lastMousePosition' field.

Cached name for the '_skipMouseCheckFrames' field.

Cached name for the '_label' field.

Cached name for the '_notifyTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'ControllerDetected' signal.

Cached name for the 'MouseDetected' signal.

Cached name for the 'ControllerTypeChanged' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Manages the local mouse cursor image and hotspot. Note: You'll see that Image is used all over this class instead of Texture2D. For some reason it's massively faster to use Image rather than Texture2D, so please keep it that way. Cursor images are exported scene dependencies to ensure they're loaded with the scene and won't be disposed.

Call this when you want to show or hide the cursor. Note that if the player is using a controller, the cursor will remain hidden even if show is true.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_Ready' method.

Cached name for the '_Input' method.

Cached name for the 'StopOverridingCursor' method.

Cached name for the 'OverrideCursor' method.

Cached name for the 'UpdateCursor' method.

Cached name for the 'SetIsUsingController' method.

Cached name for the 'SetCursorShown' method.

Cached name for the 'RefreshCursorShown' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CursorTilted' property.

Cached name for the 'CursorNotTilted' property.

Cached name for the 'HotSpot' property.

Cached name for the '_cursorTilted' field.

Cached name for the '_cursorNotTilted' field.

Cached name for the '_cursorInspect' field.

Cached name for the '_overriddenCursorTilted' field.

Cached name for the '_overriddenCursorNotTilted' field.

Cached name for the '_lastSetCursor' field.

Cached name for the '_isDown' field.

Cached name for the '_isUsingController' field.

Cached name for the '_shouldShowCursor' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The disconnection confirmation popup to prevent the player from accidentally leaving a run in progress. Renders above the capstone screens (above top bar).

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'OnYesButtonPressed' method.

Cached name for the 'OnNoButtonPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_header' field.

Cached name for the '_description' field.

Cached name for the '_noButton' field.

Cached name for the '_yesButton' field.

Cached name for the '_mainMenuNode' field.

Cached name for the '_verticalPopup' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Special component used for creating dropdown containers dynamically. Supports scrolling

This is where called whenever this container's layout is modified.

Gets the current content's position and remap + clamps it to position the train so they're in sync.

Given the train's progress from 0 - 1f, sets the targetDragPosition to match so the positions are in sync.

Detects mouse click up/down and updates our scroll target accordingly

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnVisibilityChange' method.

Cached name for the 'RefreshLayout' method.

Cached name for the 'IsScrollbarNeeded' method.

Cached name for the '_Process' method.

Cached name for the 'ProcessGuiFocus' method.

Cached name for the 'UpdateScrollPosition' method.

Cached name for the 'UpdateScrollbar' method.

Cached name for the 'UpdatePositionBasedOnTrain' method.

Cached name for the '_GuiInput' method.

Cached name for the 'ProcessMouseEvent' method.

Cached name for the 'ProcessScrollEvent' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_scrollbar' field.

Cached name for the '_scrollbarTrain' field.

Cached name for the '_dropdownItems' field.

Cached name for the '_maxHeight' field.

Cached name for the '_contentHeight' field.

Cached name for the '_startDragPos' field.

Cached name for the '_targetDragPos' field.

Cached name for the '_scrollLimitBottom' field.

Cached name for the '_isDragging' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Represents a single item within a DropdownList. Must be extended, see NLanguageDropdownItem for an example.

Helper class to access protected method OnUnhover()

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Cached name for the 'UnhoverSelection' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Text' property.

Cached name for the '_highlight' field.

Cached name for the '_label' field.

Cached name for the '_richLabel' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Selected' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

A custom scrollbar component made especially for NDropdownContainer

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'RefreshTrainBounds' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnShow' method.

Cached name for the 'OnPress' method.

Cached name for the '_Input' method.

Cached name for the '_GuiInput' method.

Cached name for the 'ClampTrain' method.

Cached name for the 'SetTrainPositionFromPercentage' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_dropdownContainer' field.

Cached name for the '_train' field.

Cached name for the 'hasControl' field.

Cached name for the '_startDragPos' field.

Cached name for the '_targetDragPos' field.

Cached name for the '_scrollLimitTop' field.

Cached name for the '_scrollLimitBottom' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A popup to let the player know a terrible bug has occurred, and to upload a bug report. The wording should be changed before we release. Renders above the capstone screens (above top bar).

Creates an error popup with hardcoded English text (bypassing localization). Use this when localization may be broken (e.g., showing localization errors).

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'OnOkButtonPressed' method.

Cached name for the 'OnCancelButtonPressed' method.

Cached name for the 'OnReportBugButtonPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_verticalPopup' field.

Cached name for the '_title' field.

Cached name for the '_body' field.

Cached name for the '_showReportBugButton' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Container for run-level global UI elements. Also adjusts the Window size to meet aspect ratio requirements

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'ReparentCard' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'TopBar' property.

Cached name for the 'Overlays' property.

Cached name for the 'CapstoneContainer' property.

Cached name for the 'RelicInventory' property.

Cached name for the 'EventCardPreviewContainer' property.

Cached name for the 'CardPreviewContainer' property.

Cached name for the 'MessyCardPreviewContainer' property.

Cached name for the 'GridCardPreviewContainer' property.

Cached name for the 'AboveTopBarVfxContainer' property.

Cached name for the 'MapScreen' property.

Cached name for the 'MultiplayerPlayerContainer' property.

Cached name for the 'TimeoutOverlay' property.

Cached name for the 'SubmenuStack' property.

Cached name for the 'TargetManager' property.

Cached name for the '_window' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Arrow buttons are used for toggling left and right on several screens. The Man. The Myth. The Legend.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Cached name for the 'UpdateShaderParam' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_icon' field.

Cached name for the '_hsv' field.

Cached name for the '_animTween' field.

Cached name for the '_valueDefault' field.

Cached name for the '_valueHovered' field.

Cached name for the '_hoverScale' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Enforces a max column count on the grid container. Call this before adding elements to the container. Once all cards added have disappeared, the count will reset.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ForceMaxColumnsUntilEmpty' method.

Cached name for the 'ReformatElements' method.

Cached name for the 'CheckAnyChildrenPresent' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Class that manages Hotkeys/shortcuts for various buttons and UI in the game. Manages which buttons get priority if multiple of them share the same Hotkey (typically the last one added gets priority)

we want to block all previous hotkeys while this screen is open New hotkeys can be added on top though. ex: we don't want to be able to hotkey to view our draw pile if the pause menu is open

Screen that is block all previous hotkey input

Removes the all hotkey blockers related to a screen.

Screen that want to remove the hotkey blockage from

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'AddBlockingScreen' method.

Cached name for the 'RemoveBlockingScreen' method.

Cached name for the '_UnhandledInput' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Listens for keyboard and controller inputs, and map them into input events that the UX can listen for (for navigation or hotkeys) That map can be edited to rebind different keyboard/controller inputs to different UX events

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_Ready' method.

Cached name for the '_UnhandledKeyInput' method.

Cached name for the 'ProcessDebugKeyInput' method.

Cached name for the 'ProcessShortcutKeyInput' method.

Cached name for the '_UnhandledInput' method.

Cached name for the 'GetShortcutKey' method.

Cached name for the 'GetHotkeyIcon' method.

Cached name for the 'ModifyShortcutKey' method.

Cached name for the 'ModifyControllerButton' method.

Cached name for the 'ResetToDefaults' method.

Cached name for the 'OnControllerTypeChanged' method.

Cached name for the 'SaveControllerInputMapping' method.

Cached name for the 'SaveKeyboardInputMapping' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ControllerManager' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'InputRebound' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

A card preview container intended to be used when lots and lots of cards are previewed and the player isn't meant to be able to parse every single card. Example usage in the Reflections event

Helper struct to calculate the x and y indices of a sample in the grid Create a sampler with the following parameters: width: each sample's x coordinate will be between [0, width] height: each sample's y coordinate will be between [0, height] radius: each sample will be at least `radius` units away from any other sample, and at most 2 * `radius`. Return a lazy sequence of samples. Adds the sample to the active samples queue and the grid before returning it

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'PositionNewChild' method.

Cached name for the 'ResetSamples' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_resetNewCardTimer' field.

Cached name for the '_currentMaxPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Confirm Button used in various places to confirm choices, embark on a run, etc. Very useful but not as cool as Back Button but that's life. Use the ButtonReleased signal to handle events.

Call when we want this button to animate in.

Call when we want this button to hide this button (Disables clickability/hotkeys)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_buttonImage' field.

Cached name for the '_downColor' field.

Cached name for the '_showPos' field.

Cached name for the '_hidePos' field.

Cached name for the '_moveTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Container for Modal Windows (Confirmation screens, FTUEs, etc). This is rendered above most UI! There can never be two modals active at once. If so, Casey has failed in the UI department.

Used when we create a FTUE or modal popup. We add it to our ModalContainer!

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Add' method.

Cached name for the 'Clear' method.

Cached name for the 'ShowBackstop' method.

Cached name for the 'HideBackstop' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_backstop' field.

Cached name for the '_backstopTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Updates the player votes, animating them in or out based on their presence as reported by _playerVotedDelegate.

Pass false to this to immediately update the container, instead of animating. This is useful when, for example, the turn begins and we don't want characters popping in or out.

Returns the index at which player is shown in this map vote container.

Highlights the player within the container. Used during the map vote randomization animation to show which player is currently being picked.

Bounces all players within the container. Used during the map vote randomization animation to show which map coordinate has been chosen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'RefreshPlayerVotes' method.

Cached name for the 'BouncePlayers' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Whether this is the Yes or No option of the Pop up

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'DisconnectHotkeys' method.

Cached name for the 'SetText' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsYes' property.

Cached name for the 'Hotkeys' property.

Cached name for the '_visuals' field.

Cached name for the '_outline' field.

Cached name for the '_image' field.

Cached name for the '_label' field.

Cached name for the '_tween' field.

Cached name for the '_baseS' field.

Cached name for the '_baseV' field.

Cached name for the '_hsv' field.

Cached name for the '_outlineMaterial' field.

Cached name for the '_isFocused' field.

Cached name for the '_isYes' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Proceed Button. The Man. The Myth. The Legend. A Button.

Call when we want this button to animate in. We refresh a lot of values here as the screen may not have been disposed and we reuse the button. May need to separate this logic into a Refresh() call for organization.

Call when we want this button to hide this button (Disables clickability/hotkeys)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'DebugToggleVisibility' method.

Cached name for the 'SetPulseState' method.

Cached name for the 'StartGlowTween' method.

Cached name for the 'StopGlowTween' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsSkip' property.

Cached name for the 'Hotkeys' property.

Cached name for the 'ShowPos' property.

Cached name for the 'HidePos' property.

Cached name for the '_outline' field.

Cached name for the '_buttonImage' field.

Cached name for the '_label' field.

Cached name for the '_hsv' field.

Cached name for the '_viewport' field.

Cached name for the '_defaultOutlineColor' field.

Cached name for the '_hoveredOutlineColor' field.

Cached name for the '_downColor' field.

Cached name for the '_outlineColor' field.

Cached name for the '_outlineTransparentColor' field.

Cached name for the '_animTween' field.

Cached name for the '_glowTween' field.

Cached name for the '_hoverTween' field.

Cached name for the '_elapsedTime' field.

Cached name for the '_shouldPulse' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SavedGame' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnMouseEntered' method.

Cached name for the 'OnMouseExited' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Pattern:
[\\t\\r\\n]
Explanation:
○ Match a character in the set [\t\n\r].
Pattern:
\\s{2,}
Explanation:
○ Match a whitespace character atomically at least twice.
Pattern:
<.*?>
Explanation:
○ Match '<'.
○ Match a character other than '\n' lazily any number of times.
○ Match '>'.


Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'TextUpdated' method.

Cached name for the 'TextSubmitted' method.

Cached name for the 'ClearText' method.

Cached name for the 'Normalize' method.

Cached name for the 'RemoveHtmlTags' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Text' property.

Cached name for the 'TextArea' property.

Cached name for the '_textArea' field.

Cached name for the '_clearButton' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'QueryChanged' signal.

Cached name for the 'QuerySubmitted' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

A popup ui/modal which is used for the Reset Tutorials confirmation

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnYesButtonPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'VerticalPopup' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_backstop' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Base class for tickboxes. Override me! Note that the hitbox for this Tickbox is its PARENT node, not this node.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnUntick' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnEnable' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsTicked' property.

Cached name for the '_isTicked' field.

Cached name for the '_imageContainer' field.

Cached name for the '_tickedImage' field.

Cached name for the '_notTickedImage' field.

Cached name for the '_hsv' field.

Cached name for the '_tween' field.

Cached name for the '_baseScale' field.

Cached name for the '_hoverScale' field.

Cached name for the '_pressDownScale' field.

Cached name for the '_hoverV' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Toggled' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

A Node script which contains references to all systems which reside in the Top Bar, the bar at the top of the screen which displays gold, health, potions, and various buttons in the top right corner during a run.

A control node that will automatically try to refocus on the current ScreenContext's FocusedControlFromTopBar. Used by things like the nodes in see to dynamically controller navigate from the relic nodes back to the current active screen. Doing it this way circumvents us needing to call ActiveScreenContext.Update whenever we need update the top bar elements navigation back to the active screen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ToggleAnimState' method.

Cached name for the '_Input' method.

Cached name for the 'DebugHideTopBar' method.

Cached name for the 'AnimHide' method.

Cached name for the 'AnimShow' method.

Cached name for the 'MaxPotionsChanged' method.

Cached name for the 'UpdateNavigation' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Map' property.

Cached name for the 'Deck' property.

Cached name for the 'Pause' property.

Cached name for the 'PotionContainer' property.

Cached name for the 'RoomIcon' property.

Cached name for the 'FloorIcon' property.

Cached name for the 'BossIcon' property.

Cached name for the 'Gold' property.

Cached name for the 'Hp' property.

Cached name for the 'Portrait' property.

Cached name for the 'PortraitTip' property.

Cached name for the 'Timer' property.

Cached name for the 'TrailContainer' property.

Cached name for the 'ActiveScreenProxy' property.

Cached name for the '_capstoneContainer' field.

Cached name for the '_modifiersContainer' field.

Cached name for the '_achievementLock' field.

Cached name for the '_ascensionIcon' field.

Cached name for the '_ascensionLabel' field.

Cached name for the '_ascensionHsv' field.

Cached name for the '_hideTween' field.

Cached name for the '_isDebugHidden' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A popup ui/modal which has a Yes and No button. Used for important popups like Abandon Run confirmation and the "Enable Tutorials?" popup.

This is to ensure that the node parameters are set. We have to do this because AddChildSafely may defer the call to add child (and thus defer the _Ready), and can lead to timing issues in NGenericPopup where we try to SetText before the label parameters have been set. While this is a vulnerability that can techinically happen for any node added via AddChildSafely, I think we are seeing a particularly high number of errors here because the vertical popup is bieng created at the start of the game for a startup errors.

Sets the popup text using raw strings instead of localization. Use this when localization may be broken (e.g., showing localization errors).

Initializes the yes button. If this is not called, then the yes button is hidden.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'EnsureNodesAreSet' method.

Cached name for the 'SetText' method.

Cached name for the 'Close' method.

Cached name for the 'HideNoButton' method.

Cached name for the 'DisconnectSignals' method.

Cached name for the 'DisconnectHotkeys' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'TitleLabel' property.

Cached name for the 'BodyLabel' property.

Cached name for the 'YesButton' property.

Cached name for the 'NoButton' property.

Cached name for the '_nodesAreSet' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'AddGame' method.

Cached name for the 'HostButtonPressed' method.

Cached name for the 'SteamHostButtonPressed' method.

Cached name for the 'JoinButtonPressed' method.

Cached name for the 'ReadyButtonPressed' method.

Cached name for the 'Disconnect' method.

Cached name for the 'AfterMultiplayerStarted' method.

Cached name for the 'ChooseReplayToLoad' method.

Cached name for the 'LoadReplay' method.

Cached name for the '_Process' method.

Cached name for the 'AscensionChanged' method.

Cached name for the 'SeedChanged' method.

Cached name for the 'ModifiersChanged' method.

Cached name for the 'MaxAscensionChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_ipField' field.

Cached name for the '_idField' field.

Cached name for the '_readyButton' field.

Cached name for the '_readyIndicator' field.

Cached name for the '_loadingPanel' field.

Cached name for the '_characterPaginator' field.

Cached name for the '_game' field.

Cached name for the '_ignoreReplayModelIdHash' field.

Cached name for the '_beginningRun' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnIndexChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'ScaleBgIfNarrow' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_window' field.

Cached name for the '_infoLabel' field.

Cached name for the '_bg' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages label displays for debug info both in main menu and in run.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'UpdateText' method.

Cached name for the 'OnModdedWarningHovered' method.

Cached name for the 'OnModdedWarningUnhovered' method.

Cached name for the '_Input' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'isMainMenu' field.

Cached name for the '_releaseInfo' field.

Cached name for the '_moddedWarning' field.

Cached name for the '_seed' field.

Cached name for the '_modWarningContainer' field.

Cached name for the '_modWarningLabel' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_EnterTree' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'PrintUsage' method.

Cached name for the '_Input' method.

Cached name for the 'HandleReadlineKeybinding' method.

Cached name for the 'DeleteWordBackward' method.

Cached name for the 'KillToEndOfLine' method.

Cached name for the 'Yank' method.

Cached name for the 'EnableTabBuffer' method.

Cached name for the 'DisableTabBuffer' method.

Cached name for the 'SetBackgroundColor' method.

Cached name for the 'HideGhostText' method.

Cached name for the 'ShowGhostText' method.

Cached name for the 'UpdateGhostText' method.

Cached name for the 'AutocompleteCommand' method.

Cached name for the 'RenderSelectionMenu' method.

Cached name for the 'OnInputTextChanged' method.

Cached name for the 'ExitSelectionMode' method.

Cached name for the 'NavigateSelection' method.

Cached name for the 'AcceptSelection' method.

Cached name for the 'ProcessCommand' method.

Cached name for the 'ShowConsole' method.

Cached name for the 'HideConsole' method.

Cached name for the 'MakeHalfScreen' method.

Cached name for the 'MakeFullScreen' method.

Cached name for the 'OnToggleMaximizeButtonPressed' method.

Cached name for the 'MoveInputCursorToEndOfLine' method.

Cached name for the 'UpdatePromptStyle' method.

Cached name for the 'AddChildToTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_outputBuffer' field.

Cached name for the '_tabBuffer' field.

Cached name for the '_inputContainer' field.

Cached name for the '_inputBuffer' field.

Cached name for the '_promptLabel' field.

Cached name for the '_ghostTextLabel' field.

Cached name for the '_isFullscreen' field.

Cached name for the '_yankBuffer' field.

Cached name for the '_symbolPrompt' field.

Cached name for the '_symbolWarning' field.

Cached name for the '_symbolUp' field.

Cached name for the '_symbolDown' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'HandleMouseRelease' method.

Cached name for the '_GuiInput' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_happy' field.

Cached name for the '_content' field.

Cached name for the '_neutral' field.

Cached name for the '_sad' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'MouseReleased' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Input' method.

Cached name for the 'CheckForHotkey' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_icon' field.

Cached name for the '_label' field.

Cached name for the '_secondsSinceLastUpdate' field.

Cached name for the '_totalParticles' field.

Cached name for the '_updateCount' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Helper class to quickly load screens of the game without having to go through the main menu. Can specify character, room type, and room details in the parameters you want to load into. And then start the scene scene_bootstrapper.tscn

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_openConsole' field.

Cached name for the '_game' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnEntityHighlightUpdated' method.

Cached name for the 'EntityClicked' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_mask' field.

Cached name for the '_hoveredFg' field.

Cached name for the '_fadeTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'PlayStart' method.

Cached name for the 'PlayBad' method.

Cached name for the 'PlayGood' method.

Cached name for the 'PlayEnd' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_dialogueBox' field.

Cached name for the '_tween' field.

Cached name for the '_bubble' field.

Cached name for the '_hsv' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_icon' field.

Cached name for the '_material' field.

Cached name for the '_card' field.

Cached name for the '_cardFrame' field.

Cached name for the '_cardBanner' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Node that manages the orb reveal shader for the Crystal Sphere event

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_material' field.

Cached name for the '_values' field.

Cached name for the '_time' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The UI node for the Crystal Sphere minigame.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetBigDivination' method.

Cached name for the 'SetSmallDivination' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnHoverCell' method.

Cached name for the 'OnUnhoverCell' method.

Cached name for the 'UpdateDivinationsLeft' method.

Cached name for the 'OnMinigameFinished' method.

Cached name for the 'OnProceedButtonPressed' method.

Cached name for the 'AfterOverlayOpened' method.

Cached name for the 'AfterOverlayClosed' method.

Cached name for the 'AfterOverlayShown' method.

Cached name for the 'AfterOverlayHidden' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenType' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_itemsContainer' field.

Cached name for the '_cellContainer' field.

Cached name for the '_bigDivinationButton' field.

Cached name for the '_smallDivinationButton' field.

Cached name for the '_divinationsLeftLabel' field.

Cached name for the '_mask' field.

Cached name for the '_proceedButton' field.

Cached name for the '_instructionsTitleLabel' field.

Cached name for the '_instructionsDescriptionLabel' field.

Cached name for the '_instructionsContainer' field.

Cached name for the '_dialogue' field.

Cached name for the '_fadeTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ToggleMerchantTrack' method.

Cached name for the 'AfterRoomIsLoaded' method.

Cached name for the 'StartCharacterAnimation' method.

Cached name for the 'HideScreen' method.

Cached name for the 'OnMerchantOpened' method.

Cached name for the 'OpenInventory' method.

Cached name for the 'ShowProceedButton' method.

Cached name for the 'OnActiveScreenUpdated' method.

Cached name for the 'BlockInput' method.

Cached name for the 'UnblockInput' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Inventory' property.

Cached name for the 'MerchantButton' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_proceedButton' field.

Cached name for the '_characterContainer' field.

Cached name for the '_inputBlocker' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Represents the animation which plays when players don't all vote for the same shared event option.

Plays the animation if necessary. The animation is not played if all players voted for the same event option. Note that we are using the votes as indicated by the nodes and not by EventSynchronizer. This is on purpose - the votes contained in EventSynchronizer have already been cleared by this point in time.

Hitbox button for Ancient events to continue through any ancient dialogue.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'GetHotkey' method.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnFocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_label' field.

Cached name for the '_arrow' field.

Cached name for the '_loopTween' field.

Cached name for the '_tween' field.

Cached name for the '_isAnimating' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Because the speaker's icon peeks through. This hack makes the icons visible when they animate in.

Special method called when players hover older dialogue lines to view them.

Opposite of FadeInStaleDialogue, hide these stale dialogues again.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'PlaySfx' method.

Cached name for the 'SetAncientAsSpeaker' method.

Cached name for the 'SetCharacterAsSpeaker' method.

Cached name for the 'SetSpeakerIconVisible' method.

Cached name for the 'SetTransparency' method.

Cached name for the 'FadeInStaleDialogue' method.

Cached name for the 'FadeOutStaleDialogue' method.

Cached name for the 'OnAnimInSetVisible' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'HoveredSfx' property.

Cached name for the 'ClickedSfx' property.

Cached name for the '_iconNode' field.

Cached name for the '_tween' field.

Cached name for the '_targetAlpha' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Parent node for the content container. We need this because we want to auto-scroll parts of the content container into view as the player progresses the dialogue.

We temporarily resize this container based on some other things happening in the layout, but we eventually want to restore it to its original height, so we set this during creation.

Contains the dialogue and the option buttons.

The invisible hitbox that the player needs to click inside to advance the dialogue.

The container for the fake "next button". We use this to size the bottom margin of the content container while the button is showing.

The "button" that lets the player advance the dialogue. This is fake because is what's really listening for these clicks. The button is just to let the player know that they can continue, and to show some flavorful text for continuing.

Makes the stale dialogue lines all visible at once.

Returns the stale dialogues to their original opacity.

Is the player on the last line of dialogue?

Used to hide the banner when you open a screen above this (like the map)

Used to show the banner when you return focus to the event room

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'InitializeVisuals' method.

Cached name for the 'AnimateIn' method.

Cached name for the 'OnDialogueLineFocused' method.

Cached name for the 'OnDialogueLineUnfocused' method.

Cached name for the 'ClearDialogue' method.

Cached name for the 'OnSetupComplete' method.

Cached name for the 'AnimateButtonsIn' method.

Cached name for the 'OnDialogueHitboxClicked' method.

Cached name for the 'SetDialogueLineAndAnimate' method.

Cached name for the 'UpdateFakeNextButton' method.

Cached name for the 'HideNameBanner' method.

Cached name for the 'ShowNameBanner' method.

Cached name for the 'UpdateBannerVisibility' method.

Cached name for the 'UpdateHotkeyDisplay' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsDialogueOnLastLine' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_currentDialogueLine' field.

Cached name for the '_ancientBgContainer' field.

Cached name for the '_ancientNameBanner' field.

Cached name for the '_bannerTween' field.

Cached name for the '_contentContainer' field.

Cached name for the '_originalContentContainerHeight' field.

Cached name for the '_content' field.

Cached name for the '_dialogueContainer' field.

Cached name for the '_dialogueHitbox' field.

Cached name for the '_fakeNextButtonContainer' field.

Cached name for the '_fakeNextButton' field.

Cached name for the '_fakeNextButtonControllerIcon' field.

Cached name for the '_fakeNextButtonLabel' field.

Cached name for the '_contentTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetCombatRoomNode' method.

Cached name for the 'InitializeVisuals' method.

Cached name for the 'HideEventVisuals' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'EmbeddedCombatRoom' property.

Cached name for the 'HasCombatStarted' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_combatRoomContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Cached name for the 'SetActive' method.

Cached name for the 'SetHotkeys' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_hsv' field.

Cached name for the '_tween' field.

Cached name for the '_outlineTween' field.

Cached name for the '_label' field.

Cached name for the '_outline' field.

Cached name for the '_customHotkeys' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Container for event VFX nodes (ambient particles, etc.). Can be null in some subclasses.

The label to show when an event is "shared" (see for details). Can be null for event types that can't be shared (like ).

The event description label. Some events (like Ancients) have no descriptions, in which case this will be null.

Adds a child node that's anchored to the portrait. Usually you'd want to add it to VfxContainer, but you can use this method instead if your VFX's position is dependent on the portrait (usually due to resolution stuff)

VFX to add

Removes ALL child nodes from the Portrait, vfx or not. Useful for swapping out vfx if an event has multiple portraits.

Called when this layout is finished being set up. At this point, all the buttons for the initial page should be populated.

Called during a shared event when a player changes the option they voted on.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'InitializeVisuals' method.

Cached name for the 'UpdatePhobiaMode' method.

Cached name for the 'SetPortrait' method.

Cached name for the 'AddVfxAnchoredToPortrait' method.

Cached name for the 'RemoveNodesOnPortrait' method.

Cached name for the 'SetTitle' method.

Cached name for the 'SetDescription' method.

Cached name for the 'AnimateIn' method.

Cached name for the 'ClearOptions' method.

Cached name for the 'OnSetupComplete' method.

Cached name for the 'AnimateButtonsIn' method.

Cached name for the 'DisableEventOptions' method.

Cached name for the '_Input' method.

Cached name for the 'ApplyDebugUiVisibility' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'VfxContainer' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_descriptionTween' field.

Cached name for the '_optionsContainer' field.

Cached name for the '_portrait' field.

Cached name for the '_currentPortraitTex' field.

Cached name for the '_currentPhobiaPortraitTex' field.

Cached name for the '_title' field.

Cached name for the '_sharedEventLabel' field.

Cached name for the '_description' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The nice big buttons that show up in event rooms. NOTE: The Ancient Event Button also uses this same script.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetVisuallyLocked' method.

Cached name for the 'AnimateIn' method.

Cached name for the 'EnableButton' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'GrayOut' method.

Cached name for the 'UpdateShaderParam' method.

Cached name for the 'RefreshVotes' method.

Cached name for the '_ExitTree' method.

Cached name for the 'WillKillPlayer' method.

Cached name for the 'ShowPersistentKillGlow' method.

Cached name for the 'PulseKillGlow' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Index' property.

Cached name for the 'VoteContainer' property.

Cached name for the '_label' field.

Cached name for the '_image' field.

Cached name for the '_outline' field.

Cached name for the '_killGlow' field.

Cached name for the '_confirmFlash' field.

Cached name for the '_hsv' field.

Cached name for the '_playerVoteContainer' field.

Cached name for the '_animInTween' field.

Cached name for the '_flashTween' field.

Cached name for the '_killGlowTween' field.

Cached name for the '_tween' field.

Cached name for the '_buttonColor' field.

Cached name for the '_deathPreventionVfx' field.

Cached name for the '_deathPreventionVfxPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'NoTutorials' method.

Cached name for the 'YesTutorials' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_charSelectScreen' field.

Cached name for the '_verticalPopup' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This is a popup that lets you know that you have unlocked Multiplayer Ascensions and briefly explains it. This is NOT a true FTUE as disabling tutorials will not prevent this from showing up.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

This is a popup that lets you know that you have unlocked Ascensions and briefly explains it. This is NOT a true FTUE as disabling tutorials will not prevent this from showing up.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtueAndEndTurn' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_confirmButton' field.

Cached name for the '_header' field.

Cached name for the '_description' field.

Cached name for the '_sneakyHitbox' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_confirmButton' field.

Cached name for the '_header' field.

Cached name for the '_description' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Ftue which appears when a player presses Proceed with items remaining in the Combat Reward screen. Auto-disables after you Proceed without forgetting.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_confirmButton' field.

Cached name for the '_header' field.

Cached name for the '_description' field.

Cached name for the '_rewardsContainer' field.

Cached name for the '_defaultZIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Start' method.

Cached name for the 'Create' method.

Cached name for the '_Input' method.

Cached name for the 'ToggleLeft' method.

Cached name for the 'ToggleRight' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_image1' field.

Cached name for the '_image2' field.

Cached name for the '_image3' field.

Cached name for the '_prevButton' field.

Cached name for the '_nextButton' field.

Cached name for the '_pageCount' field.

Cached name for the '_image' field.

Cached name for the '_bodyText' field.

Cached name for the '_header' field.

Cached name for the '_currentPage' field.

Cached name for the '_imagePosition' field.

Cached name for the '_textPosition' field.

Cached name for the '_pageTurnTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_outline' field.

Cached name for the '_outlineTween' field.

Cached name for the '_scaleTween' field.

Cached name for the '_hsv' field.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Ftue which appears when a player opens the map for the first time. Automatically appears after the start of act animation.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_confirmButton' field.

Cached name for the '_header' field.

Cached name for the '_description' field.

Cached name for the '_ftuePosition' field.

Cached name for the '_firstNode' field.

Cached name for the '_defaultZIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Ftue which appears when a player presses Proceed without interacting with the Merchant. Auto-disables if the player interacts with the Merchant.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtueAndOpenRug' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_confirmButton' field.

Cached name for the '_header' field.

Cached name for the '_description' field.

Cached name for the '_sneakyHitbox' field.

Cached name for the '_merchantRoom' field.

Cached name for the '_defaultZIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_confirmButton' field.

Cached name for the '_header' field.

Cached name for the '_description' field.

Cached name for the '_defaultZIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Ftue which appears when a player is presented with an option to receive a Power card in a Card Rewards screen, Choose Card Selection screen, or a Shop screen. NOTE: I lied, these last two cases aren't implemented yet.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_confirmButton' field.

Cached name for the '_header' field.

Cached name for the '_description' field.

Cached name for the '_card' field.

Cached name for the '_ftueHolder' field.

Cached name for the '_defaultZIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_confirmButton' field.

Cached name for the '_header' field.

Cached name for the '_description' field.

Cached name for the '_arrow' field.

Cached name for the '_defaultZIndex' field.

Cached name for the '_relicReward' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_confirmButton' field.

Cached name for the '_header' field.

Cached name for the '_description' field.

Cached name for the '_arrow' field.

Cached name for the '_defaultZIndex' field.

Cached name for the '_restSiteOptionContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'CloseFtue' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_confirmButton' field.

Cached name for the '_header' field.

Cached name for the '_description' field.

Cached name for the '_defaultZIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A Base Button class which doesn't rely on Godot's Button class.

Detects input actions

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'GetControllerIconNode' method.

Cached name for the '_EnterTree' method.

Cached name for the '_Input' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'UpdateControllerButton' method.

Cached name for the 'RegisterHotkeys' method.

Cached name for the 'UnregisterHotkeys' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ClickedSfx' property.

Cached name for the 'HoveredSfx' property.

Cached name for the 'Hotkeys' property.

Cached name for the 'ControllerIconHotkey' property.

Cached name for the 'HasControllerHotkey' property.

Cached name for the '_controllerHotkeyIcon' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The "clickable"

Called when we start pressing down on the mouse button

Called when the mouse button is released on this control (had to start the click in this Control too)

Middle-man function to prevent base.OnRelease() and to allow handling of various input types simultaneously. Required because we invoke OnButtonReleased

Called when a user hovers this button or navigates to/focuses on this button (controller).

Called when a user unhovers or navigates away from this button (controller).

Called when a user starts a click or button press.

Called when the player releases a click or button press. NOTE: Doesn't trigger unless the user triggered OnPressDown on this button.

WARNING: If overriding, be sure to call the base function to retain OnPressDown and OnRelease functionality.

Force emits the Released signal and calls OnRelease(), bypassing all hover/focus/pause checks. Used by AutoSlay for automated testing.

Helper function to enable/disable this button similar to how Unity handles it

Helper function to enable this button similar to how Unity handles it

Helper function to disable this button similar to how Unity handles it

Called whenever this button becomes enabled

Called whenever this button becomes disabled

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'ConnectSignals' method.

Cached name for the 'OnVisibilityChanged' method.

Cached name for the 'OnFocusHandler' method.

Cached name for the 'OnUnFocusHandler' method.

Cached name for the 'HandleMousePress' method.

Cached name for the 'HandleMouseRelease' method.

Cached name for the 'OnHoverHandler' method.

Cached name for the 'OnUnhoverHandler' method.

Cached name for the 'OnPressHandler' method.

Cached name for the 'OnReleaseHandler' method.

Cached name for the 'RefreshFocus' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Cached name for the '_GuiInput' method.

Cached name for the 'CheckMouseDragThreshold' method.

Cached name for the 'DebugPress' method.

Cached name for the 'DebugRelease' method.

Cached name for the 'ForceClick' method.

Cached name for the 'SetEnabled' method.

Cached name for the 'Enable' method.

Cached name for the 'Disable' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'AllowFocusWhileDisabled' property.

Cached name for the 'IsFocused' property.

Cached name for the 'IsEnabled' property.

Cached name for the '_ignoreDragThreshold' field.

Cached name for the '_isEnabled' field.

Cached name for the '_isHovered' field.

Cached name for the '_isControllerFocused' field.

Cached name for the '_isControllerNavigable' field.

Cached name for the '_beginDragPosition' field.

Cached name for the '_isPressed' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Released' signal.

Cached name for the 'Focused' signal.

Cached name for the 'Unfocused' signal.

Cached name for the 'MouseReleased' signal.

Cached name for the 'MousePressed' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

A custom Dropdown component class.

Removes any junk that's already there

Closes this dropdown. The name is verbose because it sounds generic without it. Called when we select an option or click outside the bounds of the dropdown.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'OnVisibilityChange' method.

Cached name for the 'ClearDropdownItems' method.

Cached name for the '_Input' method.

Cached name for the 'OnDismisserClicked' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OpenDropdown' method.

Cached name for the 'CloseDropdown' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_dropdownContainer' field.

Cached name for the '_dropdownItems' field.

Cached name for the '_dismisser' field.

Cached name for the '_currentOptionLabel' field.

Cached name for the '_currentOptionHighlight' field.

Cached name for the '_isHovered' field.

Cached name for the '_isOpen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A base LineEdit class that is used to access the virtual keyboard for various devices/apis (ie Steam Deck)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_GuiInput' method.

Cached name for the 'OpenKeyboard' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

A base TextEdit class that is used to access the virtual keyboard for various devices/apis (ie Steam Deck)

This mirrors LineEdit.IsEditing()

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'IsEditing' method.

Cached name for the '_Ready' method.

Cached name for the 'RefreshFont' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the '_GuiInput' method.

Cached name for the 'OpenKeyboard' method.

Cached name for the 'StopEditing' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_selectionReticle' field.

Cached name for the '_isEditing' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Awaits the next process frame and returns the delta time. Throws if the token is cancelled or the node has exited the tree, which silently swallows.

Awaits the next process frame. Unlike , this merely returns when the cancellation token is cancelled instead of throwing. Use this in scenarios where cancellation is frequent and expected, as throwing OperationCancelledException can be very slow when running in debug mode. This method itself cancels the cancellation token if the node is removed from the scene tree or becomes invalid.

Returns the node's , or null if the node is not inside a tree. Unlike , this does not trigger a native error print when the tree is null. Always prefer this over when the node may not be in the tree.

Returns true if candidate is located within parent's subtree.

Returns true if the node is not null, is valid, and is not deleting.

Checks to see if a controller is detected before we grab the focus of control.

Obtains the nearest ancestor of the given type.

Awaits an arbitrary signal on a , automatically cancelling when the owning node exits the tree.

ToSignal connects via CONNECT_ONE_SHOT, but one-shot cleanup only runs during signal emission. If the source object is freed without emitting the signal, the SignalAwaiterCallable and its GC handle linger until the source is destroyed by the garbage collector. This method avoids that by explicitly disconnecting on both the signal-fired and tree-exiting paths.

Awaits an arbitrary signal on a , automatically cancelling when the owning node exits the tree.

ToSignal connects via CONNECT_ONE_SHOT, but one-shot cleanup only runs during signal emission. If the source object is freed without emitting the signal, the SignalAwaiterCallable and its GC handle linger until the source is destroyed by the garbage collector. This method avoids that by explicitly disconnecting on both the signal-fired and tree-exiting paths.

Obtains all children of a certain type, searching recursively.

Manages scrolling of a container. This should be put on an object that doesn't scroll, and then the content to be scrolled should be a child named Content or Mask/Content.

If the content to be scrolled is dynamic (e.g. a tab in the settings menu, then you can change it using this method.

If this is called, then scrolling is disabled when the content fits entirely within the scroll container.

Detects mouse click up/down and updates our scroll target accordingly.

Detects mouse wheel up/down and updates our scroll target accordingly

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetContent' method.

Cached name for the 'UpdatePadding' method.

Cached name for the 'DisableScrollingIfContentFits' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdateScrollLimitBottom' method.

Cached name for the '_GuiInput' method.

Cached name for the '_Input' method.

Cached name for the 'ProcessControllerEvent' method.

Cached name for the 'ProcessMouseEvent' method.

Cached name for the 'ProcessScrollEvent' method.

Cached name for the '_Process' method.

Cached name for the 'InstantlyScrollToTop' method.

Cached name for the 'ProcessGuiFocus' method.

Cached name for the 'UpdateScrollPosition' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScrollViewportTop' property.

Cached name for the 'ScrollViewportSize' property.

Cached name for the 'ScrollLimitBottom' property.

Cached name for the 'Scrollbar' property.

Cached name for the '_controllerScrollAmount' field.

Cached name for the '_startDragPosY' field.

Cached name for the '_targetDragPosY' field.

Cached name for the '_isDragging' field.

Cached name for the '_paddingTop' field.

Cached name for the '_paddingBottom' field.

Cached name for the '_content' field.

Cached name for the '_scrollbarPressed' field.

Cached name for the '_disableScrollingIfContentFits' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

WARNING: If overriding, be sure to call the base function to retain OnPressDown and OnRelease functionality.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_GuiInput' method.

Cached name for the 'SetValueBasedOnMousePosition' method.

Cached name for the 'SetValueWithoutAnimation' method.

Cached name for the '_Process' method.

Cached name for the 'UpdateHandlePosition' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_handle' field.

Cached name for the '_currentHandlePosition' field.

Cached name for the '_currentVelocity' field.

Cached name for the '_isDragging' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'MouseReleased' signal.

Cached name for the 'MousePressed' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

A Slider class which doesn't rely on Godot's Slider class. Advantages are that the handle interpolates between positions and you can define the slider area/handle without restrictions imposed by the theming system.

WARNING: If overriding, be sure to call the base function to retain OnPressDown and OnRelease functionality.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_GuiInput' method.

Cached name for the 'SetValueBasedOnMousePosition' method.

Cached name for the 'SetValueWithoutAnimation' method.

Cached name for the '_Process' method.

Cached name for the 'UpdateHandlePosition' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_handle' field.

Cached name for the '_currentHandlePosition' field.

Cached name for the '_currentVelocity' field.

Cached name for the '_isDragging' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'MouseReleased' signal.

Cached name for the 'MousePressed' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Awaits the tween's signal, automatically cancelling when the owning node exits the tree. Unlike ToSignal(tween, Tween.SignalName.Finished), this will not hang when the tween is killed (e.g. because the node exited the tree and bound tweens stop processing).

Tween.Kill() does not emit the finished signal (see scene/animation/tween.cpp). ToSignal connects via CONNECT_ONE_SHOT, but one-shot cleanup only runs during signal emission (object.cpp). Since the signal is never emitted, the SignalAwaiterCallable remains in the tween's signal map, holding a strong GC handle that pins the SignalAwaiter and the async state machine. The state machine in turn holds the tween reference, forming a reference cycle across the managed/native boundary that persists for the lifetime of the process. This method sidesteps that by cancelling via the node's TreeExiting signal, which fires before the node is freed. true if the tween finished normally and the owner is still alive when control returns to the caller. false if the owner exited the tree before the tween completed, OR if the owner was freed between the tween's Finished signal firing and the caller's continuation resuming. Callers should bail out early when false is returned.

Awaits the tween's signal with cancellation support. Unlike ToSignal(tween, Tween.SignalName.Finished), this will not hang when the tween is killed, provided the caller cancels the token.

Tween.Kill() does not emit the finished signal (see scene/animation/tween.cpp). ToSignal connects via CONNECT_ONE_SHOT, but one-shot cleanup only runs during signal emission (object.cpp). Since the signal is never emitted, the SignalAwaiterCallable remains in the tween's signal map, holding a strong GC handle that pins the SignalAwaiter and the async state machine. The state machine in turn holds the tween reference, forming a reference cycle across the managed/native boundary that persists for the lifetime of the process. This method sidesteps that by using a that can be cancelled externally.

Lays out cards vertically, then horizontally, then sets the position and the size of the container according to the passed global start position and alignment.

Where to start positioning nodes. Which side of the global start location the cards should be placed on.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'LayoutResizeAndReposition' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Blocks hover tips from displaying. Useful for situations such as while you are using card/potion targeting WARNING: Be very careful when modifying this!!! Make sure that if you set it to true, that you set it back to false!

Allows the HoverTip to follow the node it's tied to.

Sets the position of the hover tip relative to the given node based on the alignment set.

The control node that we are aligning the hover tip to. Dictates the position of the hover tip relative to the given node. ie: top left side of the node, Top right side of the node

Align the hover tip for the given relic. We separate it because there are special positioning rules for relics.

The relic we are aligning too

Positions the hovertips given a Card. We separate it because there are special positioning rules for cards.

The holder that we are aligning to

Adds a static offset to a HoverTip when it's following a node. Used when the default offset doesn't have enough padding. See NLabPotionHolder for example.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'SetFollowOwner' method.

Cached name for the 'CreateAndShowMapPointHistory' method.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the 'SetAlignment' method.

Cached name for the 'SetAlignmentForRelic' method.

Cached name for the 'SetAlignmentForCardHolder' method.

Cached name for the 'CorrectVerticalOverflow' method.

Cached name for the 'CorrectHorizontalOverflow' method.

Cached name for the 'Clear' method.

Cached name for the 'Remove' method.

Cached name for the 'SetExtraFollowOffset' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'TextHoverTipDimensions' property.

Cached name for the 'CardHoverTipDimensions' property.

Cached name for the '_textHoverTipContainer' field.

Cached name for the '_cardHoverTipContainer' field.

Cached name for the '_owner' field.

Cached name for the '_followOwner' field.

Cached name for the '_followOffset' field.

Cached name for the '_extraOffset' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_floorNum' field.

Cached name for the '_playerId' field.

Cached name for the '_titleLabel' field.

Cached name for the '_playerStats' field.

Cached name for the '_roomStats' field.

Cached name for the '_rewardStatsContainer' field.

Cached name for the '_skippedStatsContainer' field.

Cached name for the '_actionStats' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Vertical popup used in several places to get confirmation for actions. Renders above the capstone screens (above top bar).

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'OnYesButtonPressed' method.

Cached name for the 'OnNoButtonPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_verticalPopup' field.

Cached name for the '_steamId' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdateVisibility' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_shaderMaterial' field.

Cached name for the '_container' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_cardNode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This indicator is displayed over players' indicators when we detect that our connection with them is bad.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Initialize' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsShown' property.

Cached name for the '_peerId' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Displays the player's relics and deck. Shown when a player clicks a remote player.

Opens the Inspect Relic screen and allows the player to paginate through the rest of the top bar relics.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'AfterCapstoneOpened' method.

Cached name for the 'AfterCapstoneClosed' method.

Cached name for the '_Ready' method.

Cached name for the '_Input' method.

Cached name for the 'ShowEntry' method.

Cached name for the 'BackButtonPressed' method.

Cached name for the 'OnRelicClicked' method.

Cached name for the 'UpdateNavigation' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'ScreenType' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_playerNameLabel' field.

Cached name for the '_cardsHeader' field.

Cached name for the '_cardContainer' field.

Cached name for the '_backButton' field.

Cached name for the '_potionsHeader' field.

Cached name for the '_potionContainer' field.

Cached name for the '_relicsHeader' field.

Cached name for the '_relicContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Handles the following: - Displaying "intents" for remote players when they hover over potions, cards, relics, and powers - Pulling cards that are executing player choice from the play pile and displaying them above the player's head with some thinky dots, then returning those cards to the play queue - Displaying relics, potions, and powers that are executing player choice and displaying them above the player's head with thinky dots Note that none of these are executed in singleplayer. For the local player in multiplayer, the first responsibility is excluded (we know what we're hovering). However, the last two points still apply.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnHitboxEntered' method.

Cached name for the 'OnHitboxExited' method.

Cached name for the 'OnHoverChanged' method.

Cached name for the 'RefreshHoverDisplay' method.

Cached name for the 'OnPeerInputStateChanged' method.

Cached name for the 'OnPeerInputStateRemoved' method.

Cached name for the '_Process' method.

Cached name for the 'HideThinkyDots' method.

Cached name for the 'RefreshHoverTips' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CardIntent' property.

Cached name for the '_cardIntent' field.

Cached name for the '_relicIntent' field.

Cached name for the '_potionIntent' field.

Cached name for the '_powerIntent' field.

Cached name for the '_hitbox' field.

Cached name for the '_targetingIndicator' field.

Cached name for the '_cardThinkyDots' field.

Cached name for the '_relicThinkyDots' field.

Cached name for the '_potionThinkyDots' field.

Cached name for the '_powerThinkyDots' field.

Cached name for the '_shouldShowHoverTip' field.

Cached name for the '_hoverTips' field.

Cached name for the '_isInPlayerChoice' field.

Cached name for the '_cardInPlayAwaitingPlayerChoice' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnCreatureValueChanged' method.

Cached name for the 'RefreshValues' method.

Cached name for the 'UpdateHealthBarWidth' method.

Cached name for the 'UpdateSelectionReticleWidth' method.

Cached name for the 'OnEnergyChanged' method.

Cached name for the 'OnStarsChanged' method.

Cached name for the 'RefreshCombatValues' method.

Cached name for the 'OnCreatureHovered' method.

Cached name for the 'OnCreatureUnhovered' method.

Cached name for the 'FlashPlayerReady' method.

Cached name for the 'UpdateHighlightedState' method.

Cached name for the 'BlockChanged' method.

Cached name for the 'RefreshConnectedState' method.

Cached name for the 'OnPlayerVotesCleared' method.

Cached name for the 'OnPlayerEndTurnPing' method.

Cached name for the 'FlashEndTurn' method.

Cached name for the 'SetNextTweenTime' method.

Cached name for the 'OnPlayerScreenChanged' method.

Cached name for the 'TweenLocationIconAway' method.

Cached name for the 'TweenLocationIconIn' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hitbox' property.

Cached name for the '_healthBar' field.

Cached name for the '_characterIcon' field.

Cached name for the '_nameplateLabel' field.

Cached name for the '_topContainer' field.

Cached name for the '_turnEndIndicator' field.

Cached name for the '_disconnectedIndicator' field.

Cached name for the '_networkProblemIndicator' field.

Cached name for the '_selectionReticle' field.

Cached name for the '_locationIcon' field.

Cached name for the '_locationContainer' field.

Cached name for the '_energyContainer' field.

Cached name for the '_energyImage' field.

Cached name for the '_energyCount' field.

Cached name for the '_starContainer' field.

Cached name for the '_starCount' field.

Cached name for the '_cardContainer' field.

Cached name for the '_cardImage' field.

Cached name for the '_cardCount' field.

Cached name for the '_locationIconTween' field.

Cached name for the '_isMouseOver' field.

Cached name for the '_isCreatureHovered' field.

Cached name for the '_isHighlighted' field.

Cached name for the '_focusedWhileTargeting' field.

Cached name for the '_nextTweenTime' field.

Cached name for the '_currentLocationIcon' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Displays a list of all the players in the session.

Lock navigation so you cannot navigate away from the player states Important for controller navigation while potion targeting an ally

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the '_Input' method.

Cached name for the 'UpdateNavigation' method.

Cached name for the 'LockNavigation' method.

Cached name for the 'UnlockNavigation' method.

Cached name for the 'UpdatePositionAfterOneFrame' method.

Cached name for the 'UpdatePosition' method.

Cached name for the 'GetTargetPosition' method.

Cached name for the 'AnimHide' method.

Cached name for the 'AnimShow' method.

Cached name for the 'ShowImmediately' method.

Cached name for the 'HideImmediately' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'FirstPlayerState' property.

Cached name for the '_tween' field.

Cached name for the '_hidden' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This overlay is displayed over everything on the client when we lose connection with the host for a long period of time. It is in both Run and Game. The Game one is only used when we are in the middle of a transition, or if the run isn't started yet. Usually, we want to use the Run one because it allows usage of menus (it's under the top bar), but sometimes we get locked while we're loading and we still want to display this over everything.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Relocalize' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsShown' property.

Cached name for the '_gameLevel' field.

Cached name for the '_icon' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A popup to suggest that the player go and play a singleplayer run first.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnBackButtonPressed' method.

Cached name for the 'OnIgnoreButtonPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_verticalPopup' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnPlayerConnected' method.

Cached name for the 'OnPlayerDisconnected' method.

Cached name for the 'OnPlayerChanged' method.

Cached name for the 'Cleanup' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_othersLabel' field.

Cached name for the '_container' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'RefreshVisuals' method.

Cached name for the 'CancelShake' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'PlayerId' property.

Cached name for the '_characterIcon' field.

Cached name for the '_readyIndicator' field.

Cached name for the '_disconnectedIndicator' field.

Cached name for the '_nameplateLabel' field.

Cached name for the '_characterLabel' field.

Cached name for the '_platform' field.

Cached name for the '_isSingleplayer' field.

Cached name for the '_playerId' field.

Cached name for the '_isReady' field.

Cached name for the '_isConnected' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'RefreshSoloLabelVisibility' method.

Cached name for the 'Cleanup' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_inviteButton' field.

Cached name for the '_soloLabel' field.

Cached name for the '_container' field.

Cached name for the '_displayLocalPlayer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Resizes remote cursors to match our cursor size.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'SetNextPosition' method.

Cached name for the '_Process' method.

Cached name for the 'UpdateImage' method.

Cached name for the 'GetHotspot' method.

Cached name for the 'GetTexture' method.

Cached name for the 'RefreshSize' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'PlayerId' property.

Cached name for the '_textureRect' field.

Cached name for the '_lastPositionUpdateMsec' field.

Cached name for the '_defaultHotspot' field.

Cached name for the '_drawingHotspot' field.

Cached name for the '_erasingHotspot' field.

Cached name for the '_defaultCursorImage' field.

Cached name for the '_tiltedCursorImage' field.

Cached name for the '_defaultDrawingImage' field.

Cached name for the '_tiltedDrawingImage' field.

Cached name for the '_defaultErasingImage' field.

Cached name for the '_tiltedErasingImage' field.

Cached name for the '_defaultCursorTexture' field.

Cached name for the '_tiltedCursorTexture' field.

Cached name for the '_defaultDrawingTexture' field.

Cached name for the '_tiltedDrawingTexture' field.

Cached name for the '_defaultErasingTexture' field.

Cached name for the '_tiltedErasingTexture' field.

Cached name for the '_drawingMode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Displays mouse cursors for remote players and syncs the local mouse cursor with remote players.

Forces all cursors to update their positions, even if they haven't moved. When cursor positioning is overridden using Synchronizer.StartOverridingCursorPositioning, call this method if the cursor's screen-space position has been affected, even though the cursor has not moved. For instance, in a scrollable screen like the map screen, this should be called when the map is scrolled by the local player.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Deinitialize' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ForceUpdateAllCursors' method.

Cached name for the 'GetCursorPosition' method.

Cached name for the 'OnInputStateAdded' method.

Cached name for the 'OnInputStateRemoved' method.

Cached name for the 'AddCursor' method.

Cached name for the 'OnInputStateChanged' method.

Cached name for the 'DrawingCursorStateChanged' method.

Cached name for the 'GetDrawingMode' method.

Cached name for the 'GetCursor' method.

Cached name for the 'RemoveCursor' method.

Cached name for the 'UpdateCursorVisibility' method.

Cached name for the '_Input' method.

Cached name for the 'OnGuiFocusChanged' method.

Cached name for the 'ApplyDebugUiVisibility' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_actNumber' field.

Cached name for the '_actName' field.

Cached name for the '_banner' field.

Cached name for the '_actIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This VFX dramatically shows the name and epithet of an Ancient when you enter their room.

Returns the index of the glyph in the center of the text. Returns a fractional value if the midline is in the middle of a glyph (which it usually is).

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'UpdateTransform' method.

Cached name for the 'UpdateGlyphSpace' method.

Cached name for the 'GetTextCenterGlyphIndex' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_titleLabel' field.

Cached name for the '_ancientBannerEffect' field.

Cached name for the '_epithetLabel' field.

Cached name for the '_moveTween' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Limits FPS to 30 when the game window loses focus to reduce GPU load and save battery.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Notification' method.

Cached name for the 'EnterBackgroundMode' method.

Cached name for the 'ExitBackgroundMode' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_savedMaxFps' field.

Cached name for the '_isBackgrounded' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Signal used to force other Scenes to refresh their UI when the application Window is updated via updated Settings or ctrl-F or something.

Wraps game startup and shows an error if there is a problem.

Initializes only the components of the game we need to display an error.

Does all the game-level initialization tasks asynchronously. Stuff that should happen as early as possible should go in _EnterTree. Beware of changing the order of operations in this method. There are dependencies that are non-obvious, and you should read and understand the methods you change.

Called when we set our Aspect Ratio to Auto mode OR when the size of the window is changed while Aspect Ratio is Auto.

If the game is a release build. i.e. Steam build

Called when the game starts to apply the player's graphics settings.

Used to update graphics settings when we change the resolution or display mode from the options screen.

Used to update VSync settings when changed from the options screen.

Reset the game instance. Only meant to be called from tests.

Listens for game close request

Called when the Main Menu is launched for the first time

Loads remaining atlases, runs ModelDb.Preload, and loads all common/menu assets in background. Called after main menu is displayed to not block the user.

Almost nothing changes text when the language is changed. This is called when the language is changed to reload all text.

Start a new singleplayer run on both the front and back ends.

The character that the player is playing as. Whether a save file should be created for the run. The canonical acts that should be in the run. The modifiers that are applied to the run. The seed that the run's RNG should use. The type of game mode that we're starting. The ascension level that the run should be played at. Time used to determine the daily run info. Null if not a daily run.

Start a new multiplayer run on both the front and back ends.

The lobby containing the multiplayer info. Whether a save file should be created for the run. The canonical acts that should be in the run. The modifiers that are applied to the run. The seed that the run's RNG should use. The ascension level that the run should be played at. Time used to determine the daily run info. Null if not a daily run.

Called when we detect that a mod is installed during runtime. Displays a warning telling the user that the mod won't be loaded until after a restart.

If either the settings or the progress save failed to load, then this displays an error popup notifying the player and asking them to send logs. Does nothing otherwise.

If localization validation errors were found in user override files, displays a popup notifying the user. Shows summary of errors (count and file paths) and directs user to check console logs for details.

Contains platform-specific initialization. This must complete before the game can be allowed to proceed.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_Ready' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'IsMainThread' method.

Cached name for the '_ExitTree' method.

Cached name for the 'IsReleaseGame' method.

Cached name for the 'InitializeGraphicsPreferences' method.

Cached name for the 'ApplyDisplaySettings' method.

Cached name for the 'GetInspectRelicScreen' method.

Cached name for the 'GetInspectCardScreen' method.

Cached name for the 'ApplySyncSetting' method.

Cached name for the 'Reset' method.

Cached name for the '_Notification' method.

Cached name for the 'Quit' method.

Cached name for the 'Relocalize' method.

Cached name for the 'ReloadMainMenu' method.

Cached name for the '_Input' method.

Cached name for the 'ToggleFullscreen' method.

Cached name for the 'DebugModifyTimescale' method.

Cached name for the 'ActivateWorldEnvironment' method.

Cached name for the 'DeactivateWorldEnvironment' method.

Cached name for the 'SetScreenShakeTarget' method.

Cached name for the 'ClearScreenShakeTarget' method.

Cached name for the 'ScreenShake' method.

Cached name for the 'ScreenRumble' method.

Cached name for the 'ScreenShakeTrauma' method.

Cached name for the 'DoHitStop' method.

Cached name for the 'ToggleTrailerMode' method.

Cached name for the 'SetScreenshakeMultiplier' method.

Cached name for the 'InitPools' method.

Cached name for the 'CheckShowLocalizationOverrideErrors' method.

Cached name for the 'OnSteamNoLongerRunning' method.

Cached name for the 'LogResourceStats' method.

Cached name for the 'FormatBytes' method.

Cached name for the 'IsGameFocusedWindow' method.

Cached name for the 'GetOrCreateFeedbackScreen' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'RootSceneContainer' property.

Cached name for the 'HoverTipsContainer' property.

Cached name for the 'MainMenu' property.

Cached name for the 'CurrentRunNode' property.

Cached name for the 'LogoAnimation' property.

Cached name for the 'Transition' property.

Cached name for the 'TimeoutOverlay' property.

Cached name for the 'AudioManager' property.

Cached name for the 'RemoteCursorContainer' property.

Cached name for the 'InputManager' property.

Cached name for the 'HotkeyManager' property.

Cached name for the 'FeedbackScreen' property.

Cached name for the 'ReactionWheel' property.

Cached name for the 'ReactionContainer' property.

Cached name for the 'CursorManager' property.

Cached name for the 'DebugAudio' property.

Cached name for the 'DebugSeedOverride' property.

Cached name for the 'StartOnMainMenu' property.

Cached name for the 'InspectRelicScreen' property.

Cached name for the 'InspectCardScreen' property.

Cached name for the 'ScreenshakeTarget' property.

Cached name for the 'WorldEnvironment' property.

Cached name for the 'HitStop' property.

Cached name for the '_inspectionContainer' field.

Cached name for the '_screenShake' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'WindowChange' signal.

Cached name for the 'PhobiaModeToggled' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Responsible for muting audio when the game enters the background, if the player has the setting set.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Notification' method.

Cached name for the 'Mute' method.

Cached name for the 'Unmute' method.

Cached name for the 'SetMasterVolume' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Cached name for the '_lastFocusOutMsec' field.

Cached name for the '_loggedEnvironment' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The root Node which contains reference to all other game system Nodes in a given run. For example: Run.Node.TopBar.Settings can get you access to the TopBarSettingsButton node.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the '_Notification' method.

Cached name for the 'SetCurrentRoom' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CombatRoom' property.

Cached name for the 'TreasureRoom' property.

Cached name for the 'EventRoom' property.

Cached name for the 'RestSiteRoom' property.

Cached name for the 'MapRoom' property.

Cached name for the 'MerchantRoom' property.

Cached name for the 'GlobalUi' property.

Cached name for the 'RunMusicController' property.

Cached name for the '_cardScene' field.

Cached name for the '_roomContainer' field.

Cached name for the '_testButton' field.

Cached name for the '_seedLabel' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'SetCurrentScene' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CurrentScene' property.

Cached name for the '_currentScene' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages the fancy screen to screen transitions that use the SDF shader. FadeOut = Fades out the current screen. This means the screen becomes black. FadeIn = Fades the screen in. This means the screen becomes revealed.

The gradient sweep transition when players move from room to room. This replaced the spiral room transition animation. Note that this utilizes TWO images to accomplish this transition, a simple backdrop fade + gradient sweep.

Uses the SimpleTransition ColorRect to fade from black -> seeing the next room.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InTransition' property.

Cached name for the '_initialGradientYPosition' field.

Cached name for the '_targetGradientYPosition' field.

Cached name for the '_gradientTransition' field.

Cached name for the '_simpleTransition' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdateVisuals' method.

Cached name for the 'Flash' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_outline' field.

Cached name for the '_visualContainer' field.

Cached name for the '_labelContainer' field.

Cached name for the '_passiveLabel' field.

Cached name for the '_evokeLabel' field.

Cached name for the '_bounds' field.

Cached name for the '_flashParticle' field.

Cached name for the '_selectionReticle' field.

Cached name for the '_isLocal' field.

Cached name for the '_sprite' field.

Cached name for the '_curTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the 'RemoveSlotAnim' method.

Cached name for the 'AddSlotAnim' method.

Cached name for the 'AddOrbAnim' method.

Cached name for the 'UpdateControllerNavigation' method.

Cached name for the 'TweenLayout' method.

Cached name for the 'UpdateVisuals' method.

Cached name for the 'ClearOrbs' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsLocal' property.

Cached name for the 'DefaultFocusOwner' property.

Cached name for the '_orbContainer' field.

Cached name for the '_creatureNode' field.

Cached name for the '_curTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Called the first time an object is instantiated for use in a pool.

Called when a pooled object is retrieved from a pool.

Called when a pooled object is freed and put back into a pool for reuse later.

WARNING: ONLY USE THIS PROPERTY FOR DEBUGGING! All of this pool's free objects.

Create an instance of the node. Null if we're in test mode.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Reload' method.

Cached name for the 'DoFlash' method.

Cached name for the 'DoBounce' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Image' property.

Cached name for the 'Outline' property.

Cached name for the '_container' field.

Cached name for the '_bounceTween' field.

Cached name for the '_obtainedTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ConnectPlayerEvents' method.

Cached name for the 'DisconnectPlayerEvents' method.

Cached name for the 'GrowPotionHolders' method.

Cached name for the 'UpdateNavigation' method.

Cached name for the 'PotionFtueCheck' method.

Cached name for the 'PlayAddFailedAnim' method.

Cached name for the 'OnPotionHolderFocused' method.

Cached name for the 'OnPotionHolderUnfocused' method.

Cached name for the 'OnPotionShortcutPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'FirstPotionControl' property.

Cached name for the 'LastPotionControl' property.

Cached name for the '_potionHolders' field.

Cached name for the '_potionErrorBg' field.

Cached name for the '_potionShortcutButton' field.

Cached name for the '_potionsFullTween' field.

Cached name for the '_potionHolderInitPos' field.

Cached name for the '_focusedHolder' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Uses the potion. This may initiate targeting for single-targeted potions. If targeting is cancelled, the potion will not be used.

Makes all of your potions popup and make a slosh sound to remind players that they have potions.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_EnterTree' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OpenPotionPopup' method.

Cached name for the 'AddPotion' method.

Cached name for the 'DisableUntilPotionRemoved' method.

Cached name for the 'CancelPotionUseOrDiscard' method.

Cached name for the 'RemoveUsedPotion' method.

Cached name for the 'DiscardPotion' method.

Cached name for the 'ShouldCancelTargeting' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Potion' property.

Cached name for the 'HasPotion' property.

Cached name for the 'IsPotionUsable' property.

Cached name for the '_potionScale' field.

Cached name for the '_emptyIcon' field.

Cached name for the '_popup' field.

Cached name for the '_potionTargeting' field.

Cached name for the '_isUsable' field.

Cached name for the '_emptyPotionTween' field.

Cached name for the '_hoverTween' field.

Cached name for the '_disabledUntilPotionRemoved' field.

Cached name for the '_isFocused' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnUseButtonPressed' method.

Cached name for the 'OnDiscardButtonPressed' method.

Cached name for the '_Input' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Remove' method.

Cached name for the 'DisconnectSignals' method.

Cached name for the 'RefreshButtons' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsUsable' property.

Cached name for the 'InACardSelectScreen' property.

Cached name for the '_holder' field.

Cached name for the '_popupContainer' field.

Cached name for the '_useButton' field.

Cached name for the '_discardButton' field.

Cached name for the '_hoverTipBounds' field.

Cached name for the '_tween' field.

Cached name for the 'IsMarkedForRemoval' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetLocKey' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnEnable' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_background' field.

Cached name for the '_label' field.

Cached name for the '_currentTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'BeginAnim' method.

Cached name for the 'TypeToTexture' method.

Cached name for the 'TextureToType' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Type' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'DeinitializeNetworking' method.

Cached name for the '_ExitTree' method.

Cached name for the 'DoLocalReaction' method.

Cached name for the 'DoRemoteReaction' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InMultiplayer' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the '_Notification' method.

Cached name for the '_Input' method.

Cached name for the 'HideWheel' method.

Cached name for the 'WarpMouseBackToOriginalPosition' method.

Cached name for the 'React' method.

Cached name for the 'MoveMarker' method.

Cached name for the 'GetSelectedWedge' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_rightWedge' field.

Cached name for the '_downRightWedge' field.

Cached name for the '_downWedge' field.

Cached name for the '_downLeftWedge' field.

Cached name for the '_leftWedge' field.

Cached name for the '_upLeftWedge' field.

Cached name for the '_upWedge' field.

Cached name for the '_upRightWedge' field.

Cached name for the '_marker' field.

Cached name for the '_ignoreNextMouseInput' field.

Cached name for the '_centerPosition' field.

Cached name for the '_selectedWedge' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnSelected' method.

Cached name for the 'OnDeselected' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Reaction' property.

Cached name for the '_textureRect' field.

Cached name for the '_normal' field.

Cached name for the '_tween' field.

Cached name for the '_defaultPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Only contains the visuals (the image) of a relic. Does NOT handle input, that is to be done by a RelicHolder.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Reload' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Icon' property.

Cached name for the 'Outline' property.

Cached name for the '_iconSize' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A basic relic display. In comparison with the top-bar relic holder, this cannot flash and never displays amounts. It automatically supports hovering tweens and showing hovertips, but clicks must be handled externally. Used in run history, multiplayer expanded state, the relic collection, and the relic unlock screen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Relic' property.

Cached name for the '_relic' field.

Cached name for the '_hoverTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

UI for holding relics. Is located under the top bar. Positioning is handled by the HFlowContainer.

Opens the Inspect Relic screen and allows the player to paginate through the rest of the top bar relics.

Returns the position the relic inventory is at normally. this.Position can change if the relic inventory is hidden, so this is used when we want to position elements relative to the relic inventory.

Used for trailers

Used for trailers

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ConnectPlayerEvents' method.

Cached name for the 'DisconnectPlayerEvents' method.

Cached name for the 'OnRelicUnfocused' method.

Cached name for the 'AnimShow' method.

Cached name for the 'AnimHide' method.

Cached name for the 'ShowImmediately' method.

Cached name for the 'HideImmediately' method.

Cached name for the 'GetDefaultPosition' method.

Cached name for the '_Input' method.

Cached name for the 'DebugHideTopBar' method.

Cached name for the 'UpdateNavigation' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_originalPos' field.

Cached name for the '_curTween' field.

Cached name for the '_debugHideTween' field.

Cached name for the '_isDebugHidden' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'RelicsChanged' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Shows the relic in a relic container. The full relic experience; shows the amount, can flash, and can animate in from an arbitrary position. This is used in the relic display under the top bar during a run.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'RefreshAmount' method.

Cached name for the 'RefreshStatus' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'DoFlash' method.

Cached name for the 'OnDisplayAmountChanged' method.

Cached name for the 'OnStatusChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Relic' property.

Cached name for the 'Inventory' property.

Cached name for the '_relic' field.

Cached name for the '_amountLabel' field.

Cached name for the '_hoverTween' field.

Cached name for the '_obtainedTween' field.

Cached name for the '_originalIconPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A utility for particle systems whose textures can get downscaled Scales up the particle system so that it matches the original texture's size. Used mainly for the ground lighting in rest sites.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_originalResolution' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Corresponding button node for the RestSiteOption entity.

Special bool for this button as disabling this button means we can still hover/focus unlike other buttons which are enabled/disabled which behave differently.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Reload' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'RefreshTextState' method.

Cached name for the 'UpdateShaderParam' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_hsv' field.

Cached name for the '_visuals' field.

Cached name for the '_icon' field.

Cached name for the '_outline' field.

Cached name for the '_label' field.

Cached name for the '_labelPosition' field.

Cached name for the '_isUnclickable' field.

Cached name for the '_executingOption' field.

Cached name for the '_currentTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the '_Ready' method.

Cached name for the 'RandomizeFire' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'Deselect' method.

Cached name for the 'FlipX' method.

Cached name for the 'HideFlameGlow' method.

Cached name for the 'RefreshThoughtBubbleVfx' method.

Cached name for the 'Shake' method.

Cached name for the 'GetRestSiteOptionAnchor' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hitbox' property.

Cached name for the '_controlRoot' field.

Cached name for the '_selectionReticle' field.

Cached name for the '_leftThoughtAnchor' field.

Cached name for the '_rightThoughtAnchor' field.

Cached name for the '_characterIndex' field.

Cached name for the '_thoughtBubbleVfx' field.

Cached name for the '_selectedOptionConfirmation' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Reload' method.

Cached name for the 'GetReward' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_rewardsScreen' field.

Cached name for the '_rewardContainer' field.

Cached name for the '_chainsContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'RewardClaimed' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Reload' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderParam' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_background' field.

Cached name for the '_iconContainer' field.

Cached name for the '_label' field.

Cached name for the '_reticle' field.

Cached name for the '_hsv' field.

Cached name for the '_currentTween' field.

Cached name for the '_hsvDefault' field.

Cached name for the '_hsvHover' field.

Cached name for the '_hsvDown' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'RewardClaimed' signal.

Cached name for the 'RewardSkipped' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'SetForegroundLayer' method.

Cached name for the 'AddLayer' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdatePhobiaMode' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_visual' field.

Cached name for the '_phobiaModeVisual' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This is used by NControllerCardPlay to try to initially hover over the last creature that was targeted

TEMPORARY! Used when showing a combat room, to allow proceeding to the next room. We'll probably remove this once we have more event-like buttons set up for this.

The mode that this combat room is currently in. See docs for more info.

Create a new combat room node.

Data used to determine what visuals should appear in the combat room. The mode that the combat room should start in.

For typical combat, this is called as part of combat setup. If there is no combat setup (e.g. in pre-finished rooms), then this must be called directly, otherwise the background of the combat will not be shown.

Places player creatures and pets in the combat room. It places players in an offset grid. Row/column count is determined by the nearest square root of the player count. Grid rows above the first one are offset successively, and we attempt to fit all the players in the available space, leaving enough padding in the center for card plays (usually, see ). Pets are placed around players' feet. Technically we only support four players, but I figured I'd make it easy for modders to expand the number of players!

All player and pet nodes. Scaling added by the camera. Should the players be fully centered in the scene? Usually false (to leave enough padding in the center for card plays), but true in certain situations like "surrounded" combats.

Enables controller navigation for all control nodes on the whitelist (atm we assume these are creature hitboxes). Disables controller navigation for un-whitelisted creature hitboxes and cards in hand. Use case: restrict navigation to just monsters when we are targeting them with a card.

Controls that we still want to allow input navigation for

Enables controller navigation for creatures and cards in hand.

Plays the splash VFX and adds the liquid overlay on the targeted creature.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'SubscribeToCombatEvents' method.

Cached name for the 'AdjustCreatureScaleForAspectRatio' method.

Cached name for the 'CreateAllyNodes' method.

Cached name for the 'CreateEnemyNodes' method.

Cached name for the 'RemoveCreatureNode' method.

Cached name for the 'UpdateCreatureNavigation' method.

Cached name for the 'OnActiveScreenUpdated' method.

Cached name for the 'EnableControllerNavigation' method.

Cached name for the 'RandomizeEnemyScalesAndHues' method.

Cached name for the 'RadialBlur' method.

Cached name for the 'SetWaitingForOtherPlayersOverlayVisible' method.

Cached name for the 'OnProceedButtonPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Ui' property.

Cached name for the 'SceneContainer' property.

Cached name for the 'BgContainer' property.

Cached name for the 'Background' property.

Cached name for the 'ProceedButton' property.

Cached name for the 'BackCombatVfxContainer' property.

Cached name for the 'CombatVfxContainer' property.

Cached name for the 'CreatedMsec' property.

Cached name for the 'Mode' property.

Cached name for the 'EncounterSlots' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the 'FocusedControlFromTopBar' property.

Cached name for the '_allyContainer' field.

Cached name for the '_enemyContainer' field.

Cached name for the '_radialBlur' field.

Cached name for the '_proceedButton' field.

Cached name for the '_waitingForOtherPlayersOverlay' field.

Cached name for the '_window' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The event layout node. Null in custom-layout events like .

The Custom Event node.

Container node for event VFX. Null in custom-layout events like .

Creates an event room node for the given event.

The event to create the room node for. The state of the run that the event is in. Whether or not the event is pre-finished (i.e. loaded from a save after being finished).

Occurs when the local player clicks an event option.

Occurs after an option is executed. This may not occur at the same time as the local player clicking the button if we are in a shared multiplayer event.

Called whenever an event's state changes - i.e. when an option is chosen. Note that, in multiplayer, this does not necessarily occur at the same time the local player chooses an option. For shared events, this is called after all players vote on an option.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'SetPortrait' method.

Cached name for the 'DisableOptionButtons' method.

Cached name for the 'OnEnteringEventCombat' method.

Cached name for the 'OnActiveScreenUpdated' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Layout' property.

Cached name for the 'EmbeddedCombatRoom' property.

Cached name for the 'VfxContainer' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_isPreFinished' field.

Cached name for the '_eventContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The map room is what we enter at the start of each Act.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ReopenMap' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_actIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Used to determine if the merchant was focused while in targeting mode, for things like .

Is the local player dead? Used to determine whether to open the merchant rug or play a dialogue line when clicked.

See .

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnRelease' method.

Cached name for the 'RefreshFocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the 'IsLocalPlayerDead' property.

Cached name for the '_merchantSelectionReticle' field.

Cached name for the '_focusedWhileTargeting' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'MerchantOpened' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Manages the starting UI flow for a merchant room. i.e. opening the inventory and proceeding to the map. This does not include the merchant items themselves. Those are handled by .

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ToggleMerchantTrack' method.

Cached name for the 'AfterRoomIsLoaded' method.

Cached name for the 'HideScreen' method.

Cached name for the 'MerchantFtueCheck' method.

Cached name for the 'OnMerchantOpened' method.

Cached name for the 'OpenInventory' method.

Cached name for the 'OnActiveScreenUpdated' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ProceedButton' property.

Cached name for the 'Inventory' property.

Cached name for the 'MerchantButton' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_proceedButton' field.

Cached name for the '_characterContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages the UI flow for a rest site.

Grays out options so that they can't be selected while an option is being executed.

Re-enables options so that they can be selected after an option is executed. This is if a relic allows you to choose multiple options.

Animates the description text down below the characters. If a player is doing the mend target selection, the arrow gets in the way of the text.

Animates the description text back up to its original position. If a player is doing the mend target selection, the arrow gets in the way of the text.

Disables the fire vfx in the rest site if there are no more options remaining.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'DisableOptions' method.

Cached name for the 'EnableOptions' method.

Cached name for the 'AnimateDescriptionDown' method.

Cached name for the 'AnimateDescriptionUp' method.

Cached name for the 'UpdateRestSiteOptions' method.

Cached name for the 'RestSiteButtonHovered' method.

Cached name for the 'RestSiteButtonUnhovered' method.

Cached name for the 'OnPlayerChangedHoveredRestSiteOption' method.

Cached name for the 'ShowProceedButton' method.

Cached name for the 'OnProceedButtonReleased' method.

Cached name for the 'SetText' method.

Cached name for the 'FadeOutOptionDescription' method.

Cached name for the '_Input' method.

Cached name for the 'ExtinguishFireIfAble' method.

Cached name for the 'OnActiveScreenUpdated' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ProceedButton' property.

Cached name for the 'Header' property.

Cached name for the 'Description' property.

Cached name for the 'BgContainer' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_choicesContainer' field.

Cached name for the '_choicesScreen' field.

Cached name for the '_proceedButton' field.

Cached name for the '_restSiteLighting' field.

Cached name for the '_descriptionTween' field.

Cached name for the '_descriptionPositionTween' field.

Cached name for the '_choicesTween' field.

Cached name for the '_originalDescriptionYPos' field.

Cached name for the '_lastFocused' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages the UI flow for a treasure room.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnProceedButtonPressed' method.

Cached name for the 'RefreshVotes' method.

Cached name for the 'OnProceedButtonReleased' method.

Cached name for the 'OnChestButtonReleased' method.

Cached name for the 'OnMouseEntered' method.

Cached name for the 'OnMouseExited' method.

Cached name for the 'UpdateChestSkin' method.

Cached name for the 'OnActiveScreenChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ProceedButton' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_banner' field.

Cached name for the '_chestButton' field.

Cached name for the '_chestNode' field.

Cached name for the '_proceedButton' field.

Cached name for the '_goldParticles' field.

Cached name for the '_relicCollection' field.

Cached name for the '_skipVoteContainer' field.

Cached name for the '_isRelicCollectionOpen' field.

Cached name for the '_hasChestBeenOpened' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Screen that has a list of monsters that you can click on to view their name, description, hp, some stats, and a list of their moves which you can click on to play the associated animation and sfx.

On screen open. When the player opens the Bestiary.

Called when the Bestiary is closed (Back button)

Initializes the list of monsters based on your save file.

A player clicked on a monster in the list on the right.

Loads a specific monster's bestiary entry.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'CreateEntries' method.

Cached name for the 'OnMonsterClicked' method.

Cached name for the 'SelectMonster' method.

Cached name for the 'OnMoveButtonClicked' method.

Cached name for the 'GetSideCenter' method.

Cached name for the 'GetSideFloor' method.

Cached name for the 'CanBeShown' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the 'BackVfxContainer' property.

Cached name for the 'VfxContainer' property.

Cached name for the 'Layout' property.

Cached name for the '_monsterNameLabel' field.

Cached name for the '_epithet' field.

Cached name for the '_sidebar' field.

Cached name for the '_bestiaryList' field.

Cached name for the '_selectionArrow' field.

Cached name for the '_arrowTween' field.

Cached name for the '_initSelectionArrow' field.

Cached name for the '_layoutContainer' field.

Cached name for the '_currentLayout' field.

Cached name for the '_descriptionLabel' field.

Cached name for the '_moveList' field.

Cached name for the '_moveContainer' field.

Cached name for the '_selectedEntry' field.

Cached name for the '_previousScreenshakeTarget' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_nameLabel' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The buttons in the monster list in the Bestiary entry. A text button.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'HoveredSfx' property.

Cached name for the 'IsDiscovered' property.

Cached name for the 'IsUnderConstruction' property.

Cached name for the '_label' field.

Cached name for the '_highlight' field.

Cached name for the '_underConstructionIcon' field.

Cached name for the '_defaultColor' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Cleanup' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Cleanup' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_encounterVisuals' field.

Cached name for the '_creatureContainer' field.

Cached name for the '_encounterSlots' field.

Cached name for the '_bestiary' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Cleanup' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_creature' field.

Cached name for the '_creatureContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Cleanup' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_creature' field.

Cached name for the '_background' field.

Cached name for the '_backgroundPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The buttons which are in the Action list for the monsters in the Bestiary. Click on these buttons to play the associated animation: Attack, Hurt, Die, etc.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_UnhandledInput' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ClickedSfx' property.

Cached name for the 'HoveredSfx' property.

Cached name for the '_buttonAnimator' field.

Cached name for the '_label' field.

Cached name for the '_tween' field.

Cached name for the '_clickTween' field.

Cached name for the '_hotkey' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

An interface used for certain screens that need to supersede all other screens These screens sit on top overlay screens. Sometimes, these screens need to persist for the whole of the run. Notes about capstone screen: - capstone screens sit on top of everything. including overlay screens - there's only allowed to be one capstone screen at a time (i.e: deck view screen, map screen, settings screen). Ex "Deck View Screen": - the "Deck View Screen" needs to supersede most gameplay screens (combat reward screen/choose a card screen) - When a screen of the same level is opened (Map Screen, Settings Screen), this screen is destroyed

The screen type which will be synced with peers. This is used to display an icon next to the multiplayer player's icon, and to determine whether the remote player's mouse should be shown (i.e. whether they're on the same screen as you).

Node class that manages the current capstone screen. If a new Capstone screen is opened, any previously open capstone screens are destroyed. If a new Capstone screen is opened, any previously open overlay screens are hidden until there are no more capstone screens.

Called just before the run is disposed.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Close' method.

Cached name for the 'CloseInternal' method.

Cached name for the 'DisableBackstopInstantly' method.

Cached name for the 'EnableBackstopInstantly' method.

Cached name for the 'CleanUp' method.

Cached name for the 'OnActiveScreenChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InUse' property.

Cached name for the '_backstop' field.

Cached name for the '_backstopFade' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Changed' signal.

Cached name for the 'CapstoneClosed' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Pretty much a copy of NTickbox. Doesn't inherit it because it doesn't use the standard tickbox visuals.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnToggle' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsTicked' property.

Cached name for the '_isTicked' field.

Cached name for the '_baseS' field.

Cached name for the '_baseV' field.

Cached name for the '_outline' field.

Cached name for the '_image' field.

Cached name for the '_hsv' field.

Cached name for the '_tween' field.

Cached name for the '_baseScale' field.

Cached name for the '_hoverV' field.

Cached name for the '_hoverScale' field.

Cached name for the '_pressDownScale' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Called when the player changes the text in the search box. If this was already called recently, then the previous one is cancelled and a new delay starts.

The only filter in this screen that acts like radio buttons rather than tickboxes.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnCardTypeSort' method.

Cached name for the 'OnRaritySort' method.

Cached name for the 'OnCostSort' method.

Cached name for the 'OnAlphabetSort' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'ToggleShowStats' method.

Cached name for the 'ToggleShowUpgrades' method.

Cached name for the 'ToggleFilterMultiplayerCards' method.

Cached name for the 'UpdateCardPoolFilter' method.

Cached name for the 'UpdateTypeFilter' method.

Cached name for the 'UpdateRarityFilter' method.

Cached name for the 'UpdateCostFilter' method.

Cached name for the 'SearchBarQueryChanged' method.

Cached name for the 'SearchBarQuerySubmitted' method.

Cached name for the 'UpdateFilter' method.

Cached name for the 'ShowCardDetail' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_grid' field.

Cached name for the '_searchBar' field.

Cached name for the '_ironcladFilter' field.

Cached name for the '_silentFilter' field.

Cached name for the '_defectFilter' field.

Cached name for the '_regentFilter' field.

Cached name for the '_necrobinderFilter' field.

Cached name for the '_colorlessFilter' field.

Cached name for the '_ancientsFilter' field.

Cached name for the '_miscPoolFilter' field.

Cached name for the '_typeSorter' field.

Cached name for the '_attackFilter' field.

Cached name for the '_skillFilter' field.

Cached name for the '_powerFilter' field.

Cached name for the '_otherTypeFilter' field.

Cached name for the '_raritySorter' field.

Cached name for the '_commonFilter' field.

Cached name for the '_uncommonFilter' field.

Cached name for the '_rareFilter' field.

Cached name for the '_otherFilter' field.

Cached name for the '_costSorter' field.

Cached name for the '_zeroFilter' field.

Cached name for the '_oneFilter' field.

Cached name for the '_twoFilter' field.

Cached name for the '_threePlusFilter' field.

Cached name for the '_xFilter' field.

Cached name for the '_alphabetSorter' field.

Cached name for the '_viewMultiplayerCards' field.

Cached name for the '_viewStats' field.

Cached name for the '_viewUpgrades' field.

Cached name for the '_cardCountLabel' field.

Cached name for the '_noResultsLabel' field.

Cached name for the '_lastHoveredControl' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Inherits from NCardGrid, with functionality to help perf for the card library.

Refreshes the seen/unlocked card sets. Call when opening the card library to pick up any cards discovered since the last visit.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'RefreshVisibility' method.

Cached name for the 'InitGrid' method.

Cached name for the 'UpdateGridNavigation' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsCardLibrary' property.

Cached name for the 'CenterGrid' property.

Cached name for the 'ShowStats' property.

Cached name for the '_showStats' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The current pool the player is viewing in the Card Library. Unlike the other tickboxes, this one is a radio-buttion style. Clicking on a pool filter will deselect the others. If this filter is already active, then you can't click on it.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnToggle' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsSelected' property.

Cached name for the '_isSelected' field.

Cached name for the '_image' field.

Cached name for the '_hsv' field.

Cached name for the '_controllerSelectionReticle' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Toggled' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnEnable' method.

Cached name for the 'SetLabel' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_labelTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Pretty much a copy of NTickbox. Doesn't inherit it because it doesn't use the standard tickbox visuals.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnToggle' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsTicked' property.

Cached name for the '_isTicked' field.

Cached name for the '_baseS' field.

Cached name for the '_baseV' field.

Cached name for the '_outline' field.

Cached name for the '_image' field.

Cached name for the '_hsv' field.

Cached name for the '_tween' field.

Cached name for the '_baseScale' field.

Cached name for the '_hoverScale' field.

Cached name for the '_pressDownScale' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Toggled' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Cached name for the '_image' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'SetLabel' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_labelTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

An interface used to define any screen that allows for cards to be chosen (ie NCardSelectionScreen, NChooseACardScreen)

Base class for all grid-based card selection screens.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignalsAndInitGrid' method.

Cached name for the '_ExitTree' method.

Cached name for the 'SetPeekButtonTargets' method.

Cached name for the 'AfterOverlayOpened' method.

Cached name for the 'AfterOverlayClosed' method.

Cached name for the 'AfterOverlayShown' method.

Cached name for the 'AfterOverlayHidden' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenType' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the 'FocusedControlFromTopBar' property.

Cached name for the '_grid' field.

Cached name for the '_peekButton' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

a button that sits below the card reward screen that presents alternatives to picking cards. The most common is "Skip", but some relics dynamically add other options such as Pael's Wing

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the 'AnimateIn' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderParam' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_image' field.

Cached name for the '_label' field.

Cached name for the '_optionName' field.

Cached name for the '_animInTween' field.

Cached name for the '_showPosition' field.

Cached name for the '_currentTween' field.

Cached name for the '_hsv' field.

Cached name for the '_hsvDefault' field.

Cached name for the '_hsvHover' field.

Cached name for the '_hsvDown' field.

Cached name for the '_hotkeys' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Selection screen for card rewards after winning combat. NOTE: The card reward selection screen is only set up to look good with exactly 3 cards right now. Any more or less than that and things may start to look wonky. We'll need do some UI work to make it look nicer if that's required.

Called both in _Ready and if someone re-rolls the options of the associated CardReward.

The index of the selected option. If the index is greater than or equal to the number of cards, then it represents the index of an alternative option.

For a short time after opening the screen, set the cards to unselectable. Common mistake is for the player to click right after opening the screen, selecting a reward by mistake. Note that this only makes it so the player cannot select the cards. They can still navigate

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnAlternateRewardSelected' method.

Cached name for the 'SelectCard' method.

Cached name for the 'InspectCard' method.

Cached name for the 'AfterOverlayOpened' method.

Cached name for the 'PowerCardFtueCheck' method.

Cached name for the 'AfterOverlayClosed' method.

Cached name for the 'AfterOverlayShown' method.

Cached name for the 'AfterOverlayHidden' method.

Cached name for the 'UpdateControllerIcons' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenType' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_ui' field.

Cached name for the '_banner' field.

Cached name for the '_cardRow' field.

Cached name for the '_rewardAlternativesContainer' field.

Cached name for the '_inspectPrompt' field.

Cached name for the '_cardTween' field.

Cached name for the '_buttonTween' field.

Cached name for the '_lastFocusedControl' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A simple button to skip choosing a card on some select screens (like the choose 1 of 3 card reward screen).

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'AnimateIn' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderParam' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_image' field.

Cached name for the '_label' field.

Cached name for the '_optionName' field.

Cached name for the '_animInTween' field.

Cached name for the '_showPosition' field.

Cached name for the '_currentTween' field.

Cached name for the '_hsv' field.

Cached name for the '_hsvDefault' field.

Cached name for the '_hsvHover' field.

Cached name for the '_hsvDown' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnBundleClicked' method.

Cached name for the 'OpenPreviewScreen' method.

Cached name for the 'CancelSelection' method.

Cached name for the 'ConfirmSelection' method.

Cached name for the 'AfterOverlayOpened' method.

Cached name for the 'AfterOverlayClosed' method.

Cached name for the 'AfterOverlayShown' method.

Cached name for the 'AfterOverlayHidden' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenType' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_bundleRow' field.

Cached name for the '_bundlePreviewContainer' field.

Cached name for the '_bundlePreviewCards' field.

Cached name for the '_previewCancelButton' field.

Cached name for the '_previewConfirmButton' field.

Cached name for the '_selectedBundle' field.

Cached name for the '_banner' field.

Cached name for the '_peekButton' field.

Cached name for the '_fadeTween' field.

Cached name for the '_cardTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Selection screen for choosing a card from in-combat generators like Attack Potion. NOTE: The card reward selection screen is only set up to look good with exactly 3 cards right now. Any more or less than that and things may start to look wonky. We'll need do some UI work to make it look nicer if that's required.

TODO: this is very similar to NCardRewardScreen... if we have a 3rd screen set up like this, might be worth having them inherit from a common class.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'SelectHolder' method.

Cached name for the 'OpenPreviewScreen' method.

Cached name for the 'OnSkipButtonReleased' method.

Cached name for the 'AfterOverlayOpened' method.

Cached name for the 'AfterOverlayClosed' method.

Cached name for the 'AfterOverlayShown' method.

Cached name for the 'AfterOverlayHidden' method.

Cached name for the 'UpdateControllerIcons' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenType' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_banner' field.

Cached name for the '_cardRow' field.

Cached name for the '_skipButton' field.

Cached name for the '_combatPiles' field.

Cached name for the '_inspectPrompt' field.

Cached name for the '_peekButton' field.

Cached name for the '_openedTicks' field.

Cached name for the '_screenComplete' field.

Cached name for the '_cardSelected' field.

Cached name for the '_canSkip' field.

Cached name for the '_cardTween' field.

Cached name for the '_fadeTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ConnectSignalsAndInitGrid' method.

Cached name for the 'AfterOverlayOpened' method.

Cached name for the 'UpdateConfirmButton' method.

Cached name for the 'CheckIfSelectionComplete' method.

Cached name for the 'CompleteSelection' method.

Cached name for the 'UnsubscribeFromPile' method.

Cached name for the 'UpdatePileContents' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_bottomTextContainer' field.

Cached name for the '_infoLabel' field.

Cached name for the '_confirmButton' field.

Cached name for the '_combatPiles' field.

Cached name for the '_isSubscribedToPile' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A generic select from the cards in the player's deck. Managing logic for the extra confirmation screen. Typically we use this screen when we are modifying the composition of a deck rather than a specific card. This is included but not limited to: - transforming cards - removing cards - cloning cards (Dolly's Mirror) Does not include actions that modify specific cards such as, upgrading (see NDeckSelectScreen) or applying enchantments (see NDeckEnchantSelectScreen) to cards, as those have special UI

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'RefreshConfirmButtonVisibility' method.

Cached name for the 'PreviewSelection' method.

Cached name for the 'CloseSelection' method.

Cached name for the 'CancelSelection' method.

Cached name for the 'ConfirmSelection' method.

Cached name for the 'CheckIfSelectionComplete' method.

Cached name for the 'AfterOverlayShown' method.

Cached name for the 'AfterOverlayHidden' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the 'FocusedControlFromTopBar' property.

Cached name for the '_previewContainer' field.

Cached name for the '_previewCards' field.

Cached name for the '_previewCancelButton' field.

Cached name for the '_previewConfirmButton' field.

Cached name for the '_closeButton' field.

Cached name for the '_confirmButton' field.

Cached name for the '_infoLabel' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

NCardSelectionScreen specifically for enchanting cards in your deck. Managing logic for the extra confirmation screen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'RefreshConfirmButtonVisibility' method.

Cached name for the 'CloseSelection' method.

Cached name for the 'CancelSelection' method.

Cached name for the 'PreviewSelection' method.

Cached name for the 'ConfirmSelection' method.

Cached name for the 'CheckIfSelectionComplete' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'UseSingleSelection' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the 'FocusedControlFromTopBar' property.

Cached name for the '_enchantmentAmount' field.

Cached name for the '_enchantSinglePreviewContainer' field.

Cached name for the '_singlePreview' field.

Cached name for the '_singlePreviewCancelButton' field.

Cached name for the '_singlePreviewConfirmButton' field.

Cached name for the '_confirmButton' field.

Cached name for the '_enchantMultiPreviewContainer' field.

Cached name for the '_multiPreview' field.

Cached name for the '_multiPreviewCancelButton' field.

Cached name for the '_multiPreviewConfirmButton' field.

Cached name for the '_enchantmentDescriptionContainer' field.

Cached name for the '_enchantmentTitle' field.

Cached name for the '_enchantmentDescription' field.

Cached name for the '_enchantmentIcon' field.

Cached name for the '_bottomTextContainer' field.

Cached name for the '_infoLabel' field.

Cached name for the '_closeButton' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

CardSelectionScreen specifically for transforming cards to random other cards. For transforming cards into specific other cards, you probably don't need to use this.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'RefreshConfirmButtonVisibility' method.

Cached name for the 'CloseSelection' method.

Cached name for the 'CancelSelection' method.

Cached name for the 'ConfirmSelection' method.

Cached name for the 'OpenPreviewScreen' method.

Cached name for the 'CompleteSelection' method.

Cached name for the 'ToggleShowUpgrades' method.

Cached name for the 'OnControllerStateUpdated' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the 'FocusedControlFromTopBar' property.

Cached name for the '_previewContainer' field.

Cached name for the '_transformPreview' field.

Cached name for the '_confirmButton' field.

Cached name for the '_previewCancelButton' field.

Cached name for the '_previewConfirmButton' field.

Cached name for the '_bottomTextContainer' field.

Cached name for the '_infoLabel' field.

Cached name for the '_viewUpgrades' field.

Cached name for the '_closeButton' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

CardSelectionScreen specifically for upgrading cards in your deck. Managing logic for the extra confirmation screen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'CloseSelection' method.

Cached name for the 'CancelSelection' method.

Cached name for the 'ConfirmSelection' method.

Cached name for the 'CheckIfSelectionComplete' method.

Cached name for the 'ToggleShowUpgrades' method.

Cached name for the 'OnControllerStateUpdated' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'UseSingleSelection' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the 'FocusedControlFromTopBar' property.

Cached name for the '_upgradeSinglePreviewContainer' field.

Cached name for the '_singlePreview' field.

Cached name for the '_singlePreviewCancelButton' field.

Cached name for the '_singlePreviewConfirmButton' field.

Cached name for the '_viewUpgrades' field.

Cached name for the '_bottomTextContainer' field.

Cached name for the '_infoLabel' field.

Cached name for the '_upgradeMultiPreviewContainer' field.

Cached name for the '_multiPreview' field.

Cached name for the '_multiPreviewCancelButton' field.

Cached name for the '_multiPreviewConfirmButton' field.

Cached name for the '_closeButton' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ConnectSignalsAndInitGrid' method.

Cached name for the 'AfterOverlayOpened' method.

Cached name for the 'CheckIfSelectionComplete' method.

Cached name for the 'CompleteSelection' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_bottomTextContainer' field.

Cached name for the '_infoLabel' field.

Cached name for the '_confirmButton' field.

Cached name for the '_combatPiles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Dropdown for selecting an act. Only used in development. If this ends up being used in production, make it less messy.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'PopulateOptions' method.

Cached name for the 'OnDropdownItemSelected' method.

Cached name for the 'GetDropdownContainer' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CurrentOption' property.

Cached name for the '_currentOptionIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Initialize' method.

Cached name for the 'SetFireBlue' method.

Cached name for the 'SetFireRed' method.

Cached name for the 'Cleanup' method.

Cached name for the 'SetAscensionLevel' method.

Cached name for the 'IncrementAscension' method.

Cached name for the 'DecrementAscension' method.

Cached name for the 'RefreshArrowVisibility' method.

Cached name for the 'SetMaxAscension' method.

Cached name for the 'RefreshAscensionText' method.

Cached name for the 'AnimIn' method.

Cached name for the 'UpdateControllerButton' method.

Cached name for the 'Disable' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Ascension' property.

Cached name for the '_maxAscension' field.

Cached name for the '_leftArrow' field.

Cached name for the '_rightArrow' field.

Cached name for the '_ascensionLevel' field.

Cached name for the '_info' field.

Cached name for the '_leftTriggerIcon' field.

Cached name for the '_rightTriggerIcon' field.

Cached name for the '_iconHsv' field.

Cached name for the '_arrowsVisible' field.

Cached name for the '_mode' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'AscensionLevelChanged' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

The button you click to select a character before starting a run.

This button is not selected by anyone.

This button is selected by the local player (and maybe also remote players).

This button is not selected locally, but is selected by at least one remote player.

There's a small delay before the unlock animation starts, and in that time, we want the button to look locked even though it's not.

Plays the unlock animation.

When this button is clicked on (or navigated to via controller), this button is considered Selected!

When a player selects a button that's NOT this one, selected buttons become deselected, and this is called.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnUnfocus' method.

Cached name for the '_Process' method.

Cached name for the 'LockForAnimation' method.

Cached name for the 'Reset' method.

Cached name for the 'OnRemotePlayerSelected' method.

Cached name for the 'OnRemotePlayerDeselected' method.

Cached name for the 'Select' method.

Cached name for the 'Deselect' method.

Cached name for the 'RefreshState' method.

Cached name for the 'GetSaturationForCurrentState' method.

Cached name for the 'GetValueForCurrentState' method.

Cached name for the 'AnimateSaturationToCurrentState' method.

Cached name for the 'RefreshOutline' method.

Cached name for the 'RefreshPlayerIcons' method.

Cached name for the 'DebugUnlock' method.

Cached name for the 'UnlockIfPossible' method.

Cached name for the 'UpdateShaderH' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsRandom' property.

Cached name for the 'IsLocked' property.

Cached name for the 'IsSelected' property.

Cached name for the '_icon' field.

Cached name for the '_iconAdd' field.

Cached name for the '_lock' field.

Cached name for the '_outlineLocal' field.

Cached name for the '_outlineRemote' field.

Cached name for the '_outlineMixed' field.

Cached name for the '_shadow' field.

Cached name for the '_playerIconContainer' field.

Cached name for the '_hsv' field.

Cached name for the '_isLocked' field.

Cached name for the '_currentOutline' field.

Cached name for the '_isSelected' field.

Cached name for the '_state' field.

Cached name for the '_hoverTween' field.

Cached name for the '_hsvTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Checks if we need to show the Ascension Multiplayer FTUE-like popup and displays one if so.

Opens this screen

Called when the player selects a Character! Also called when you open the character select screen.

Called when the ascension is changed from the ascension panel. When the host hits the left and right arrow, we want to send the ascension change to clients. On the clients, this is called when the ascension sync message is received, but we don't want to do anything.

Called when the player presses the unready button in multiplayer. You can't unready in singleplayer.

Called when another player joins with a max ascension level lower than the current one. Also called when the lobby is first initialized. Also called in singleplayer if choosing a character changes the max ascension. Called on both host and client.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'CheckForMultiplayerAscensionPopup' method.

Cached name for the 'InitializeSingleplayer' method.

Cached name for the 'InitCharacterButtons' method.

Cached name for the 'UpdateRandomCharacterVisibility' method.

Cached name for the '_Input' method.

Cached name for the 'DebugUnlockAllCharacters' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'OnEmbarkPressed' method.

Cached name for the '_Process' method.

Cached name for the 'CleanUpLobby' method.

Cached name for the 'OnAscensionPanelLevelChanged' method.

Cached name for the 'OnUnreadyPressed' method.

Cached name for the 'UpdateRichPresence' method.

Cached name for the 'MaxAscensionChanged' method.

Cached name for the 'AscensionChanged' method.

Cached name for the 'SeedChanged' method.

Cached name for the 'ModifiersChanged' method.

Cached name for the 'AfterInitialized' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the 'ShouldShowActDropdown' property.

Cached name for the '_name' field.

Cached name for the '_infoPanel' field.

Cached name for the '_description' field.

Cached name for the '_hp' field.

Cached name for the '_gold' field.

Cached name for the '_relicTitle' field.

Cached name for the '_relicDescription' field.

Cached name for the '_relicIcon' field.

Cached name for the '_relicIconOutline' field.

Cached name for the '_selectedButton' field.

Cached name for the '_charButtonContainer' field.

Cached name for the '_bgContainer' field.

Cached name for the '_readyAndWaitingContainer' field.

Cached name for the '_backButton' field.

Cached name for the '_unreadyButton' field.

Cached name for the '_embarkButton' field.

Cached name for the '_ascensionPanel' field.

Cached name for the '_actDropdown' field.

Cached name for the '_actDropdownLabel' field.

Cached name for the '_remotePlayerContainer' field.

Cached name for the '_characterUnlockAnimationBackstop' field.

Cached name for the '_randomCharacterButton' field.

Cached name for the '_infoPanelTween' field.

Cached name for the '_infoPanelPosFinalVal' field.

Cached name for the '_delayEmbarkForCharacterSelect' field.

Cached name for the '_charSelectButtonScene' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnWindowChange' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_window' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'OnEmbarkPressed' method.

Cached name for the 'OnUnreadyPressed' method.

Cached name for the 'UpdateRichPresence' method.

Cached name for the '_Process' method.

Cached name for the 'CleanUpLobby' method.

Cached name for the 'PlayerConnected' method.

Cached name for the 'PlayerReadyChanged' method.

Cached name for the 'RemotePlayerDisconnected' method.

Cached name for the 'BeginRun' method.

Cached name for the 'AfterMultiplayerStarted' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_name' field.

Cached name for the '_infoPanel' field.

Cached name for the '_hp' field.

Cached name for the '_gold' field.

Cached name for the '_selectedButton' field.

Cached name for the '_bgContainer' field.

Cached name for the '_confirmButton' field.

Cached name for the '_backButton' field.

Cached name for the '_unreadyButton' field.

Cached name for the '_ascensionPanel' field.

Cached name for the '_floorLabel' field.

Cached name for the '_actLabel' field.

Cached name for the '_remotePlayerContainer' field.

Cached name for the '_infoPanelTween' field.

Cached name for the '_infoPanelPosFinalVal' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetSkin' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_sphereGuardianHover' field.

Cached name for the '_decaHover' field.

Cached name for the '_sentryHover' field.

Cached name for the '_sneckoHover' field.

Cached name for the '_cultistHover' field.

Cached name for the '_shapesHover' field.

Cached name for the '_amogusHover' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The screen must be up for 2 seconds before you can exit. Otherwise, you can open it and close it before seeing it (confusion).

Processes mouse wheel to zoom in and out of the Timeline screen.

When you want to randomize the order for a section with just names. Used for Modding Support section.

Takes all the playtester credits, shuffles it

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'InitMegaCrit' method.

Cached name for the 'InitComposer' method.

Cached name for the 'InitAdditionalProgramming' method.

Cached name for the 'InitAdditionalVfx' method.

Cached name for the 'InitMarketingSupport' method.

Cached name for the 'InitConsultants' method.

Cached name for the 'InitVoices' method.

Cached name for the 'InitLocalization' method.

Cached name for the 'InitTwitchExtension' method.

Cached name for the 'InitModdingSupport' method.

Cached name for the 'InitPlaytesters' method.

Cached name for the 'InitTrailer' method.

Cached name for the 'InitFmod' method.

Cached name for the 'InitSpine' method.

Cached name for the 'InitGodot' method.

Cached name for the 'InitExitMessage' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'CloseScreenDebug' method.

Cached name for the '_GuiInput' method.

Cached name for the '_Process' method.

Cached name for the 'ProcessScrollEvent' method.

Cached name for the 'ShuffleOneColumn' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_canClose' field.

Cached name for the '_exitingScreen' field.

Cached name for the '_tween' field.

Cached name for the '_screenContents' field.

Cached name for the '_backButton' field.

Cached name for the '_targetPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Intermediate screen when loading a custom run in multiplayer. Allows players to join back into the session before it is resumed.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'OnEmbarkPressed' method.

Cached name for the 'OnUnreadyPressed' method.

Cached name for the 'UpdateRichPresence' method.

Cached name for the '_Process' method.

Cached name for the 'CleanUpLobby' method.

Cached name for the 'PlayerConnected' method.

Cached name for the 'PlayerReadyChanged' method.

Cached name for the 'RemotePlayerDisconnected' method.

Cached name for the 'BeginRun' method.

Cached name for the 'AfterInitialized' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_confirmButton' field.

Cached name for the '_backButton' field.

Cached name for the '_unreadyButton' field.

Cached name for the '_ascensionPanel' field.

Cached name for the '_readyAndWaitingContainer' field.

Cached name for the '_seedInput' field.

Cached name for the '_remotePlayerContainer' field.

Cached name for the '_modifiersList' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Allows the player to start a run with any set of ascension, character, and modifiers.

Called when the ascension is changed from the ascension panel. When the host hits the left and right arrow, we want to send the ascension change to clients. On the clients, this is called when the ascension sync message is received, but we don't want to do anything.

Called when the custom modifiers are changed from the modifiers list. When the host ticks a modifier on or off, we want to send that change to clients. On the clients, this is called after the modifiers list syncs with the modifier sync message, but we don't need to do anything here.

Called when another player joins with a max ascension level lower than the current one. Also called when the lobby is first initialized. Also called in singleplayer if the max ascension changes due to the character changing. Called on both host and client.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'InitializeSingleplayer' method.

Cached name for the 'OnSeedInputSubmitted' method.

Cached name for the 'InitCharacterButtons' method.

Cached name for the '_Input' method.

Cached name for the 'DebugUnlockAllCharacters' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'OnEmbarkPressed' method.

Cached name for the 'OnUnreadyPressed' method.

Cached name for the 'UpdateRichPresence' method.

Cached name for the '_Process' method.

Cached name for the 'CleanUpLobby' method.

Cached name for the 'GetModifiersString' method.

Cached name for the 'OnAscensionPanelLevelChanged' method.

Cached name for the 'OnModifiersListChanged' method.

Cached name for the 'MaxAscensionChanged' method.

Cached name for the 'AscensionChanged' method.

Cached name for the 'SeedChanged' method.

Cached name for the 'ModifiersChanged' method.

Cached name for the 'AfterInitialized' method.

Cached name for the 'UpdateControllerButton' method.

Cached name for the 'TryFocusOnModifiersList' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ModifiersHotkey' property.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_disclaimer' field.

Cached name for the '_selectedButton' field.

Cached name for the '_charButtonContainer' field.

Cached name for the '_confirmButton' field.

Cached name for the '_backButton' field.

Cached name for the '_unreadyButton' field.

Cached name for the '_ascensionPanel' field.

Cached name for the '_readyAndWaitingContainer' field.

Cached name for the '_seedInput' field.

Cached name for the '_remotePlayerContainer' field.

Cached name for the '_modifiersList' field.

Cached name for the '_modifiersHotkeyIcon' field.

Cached name for the '_uiMode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_highlight' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetIsReady' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_characterIconContainer' field.

Cached name for the '_playerNameLabel' field.

Cached name for the '_characterNameLabel' field.

Cached name for the '_ascensionLabel' field.

Cached name for the '_ascensionNumberLabel' field.

Cached name for the '_readyIndicator' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Does first-time initialization with the given day. Should only be called when the page loads and when a new player joins the run.

Called by the paginator when the day in the paginator changes.

Called when we press left/right arrows when viewing Global Rank. Lets other players view the scores and names of other players ranked above/below them.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ToggleGlobalRank' method.

Cached name for the 'SetLocalizedText' method.

Cached name for the 'Cleanup' method.

Cached name for the 'ChangePage' method.

Cached name for the 'SetPage' method.

Cached name for the 'NavigateGlobalRank' method.

Cached name for the 'ClearEntries' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_paginator' field.

Cached name for the '_scoreContainer' field.

Cached name for the '_leftArrow' field.

Cached name for the '_rightArrow' field.

Cached name for the '_loadingIndicator' field.

Cached name for the '_noScoresIndicator' field.

Cached name for the '_noFriendsIndicator' field.

Cached name for the '_noScoreUploadIndicator' field.

Cached name for the '_separators' field.

Cached name for the '_globalTickbox' field.

Cached name for the '_currentPage' field.

Cached name for the '_currentIndex' field.

Cached name for the '_hasNegativeScore' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_rank' field.

Cached name for the '_name' field.

Cached name for the '_score' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'FormatHoursAndMinutes' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_rank' field.

Cached name for the '_name' field.

Cached name for the '_floor' field.

Cached name for the '_badges' field.

Cached name for the '_time' field.

Cached name for the '_isYou' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Screen that displays when loading a multiplayer daily run, allowing other players to join the game before it starts.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'InitializeDisplay' method.

Cached name for the 'OnEmbarkPressed' method.

Cached name for the 'OnUnreadyPressed' method.

Cached name for the 'UpdateRichPresence' method.

Cached name for the '_Process' method.

Cached name for the 'CleanUpLobby' method.

Cached name for the 'PlayerConnected' method.

Cached name for the 'PlayerReadyChanged' method.

Cached name for the 'RemotePlayerDisconnected' method.

Cached name for the 'BeginRun' method.

Cached name for the 'AfterMultiplayerStarted' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_dateLabel' field.

Cached name for the '_embarkButton' field.

Cached name for the '_backButton' field.

Cached name for the '_unreadyButton' field.

Cached name for the '_characterContainer' field.

Cached name for the '_leaderboard' field.

Cached name for the '_modifiersTitleLabel' field.

Cached name for the '_modifiersContainer' field.

Cached name for the '_remotePlayerContainer' field.

Cached name for the '_readyAndWaitingContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Displays when the player's already uploaded a score for today's daily. When hovered, displays info about why the score won't be uploaded.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

This is called: - Once when the screen is shown - Anytime when the player count changes

Fetches the time from the time server and initializes the lobby for multiplayer or singleplayer. After this completes, _lobby will be initialized. Its time will be set with the time fetched from the time server, or with the local time, if we couldn't fetch the time from the server.

Attempt to get the time from the time server. If any time server request succeeded in the past, this uses the cached time server time. Otherwise, it requests a new time. Falls back to local time if the server is unreachable.

Returns the time on the Mega Crit time server.

This is called on both host and client after the lobby is setup to sync the state of the lobby. It is also called when any player leaves or rejoins the game to reroll modifiers so that CharacterCards can properly avoid hitting any characters that have been rolled.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'InitializeSingleplayer' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'InitializeLeaderboard' method.

Cached name for the 'InitializeDisplay' method.

Cached name for the 'SetIsLoading' method.

Cached name for the '_Process' method.

Cached name for the 'MaxAscensionChanged' method.

Cached name for the 'AscensionChanged' method.

Cached name for the 'SeedChanged' method.

Cached name for the 'ModifiersChanged' method.

Cached name for the 'OnEmbarkPressed' method.

Cached name for the 'OnUnreadyPressed' method.

Cached name for the 'UpdateRichPresence' method.

Cached name for the 'CleanUpLobby' method.

Cached name for the 'AfterLobbyInitialized' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_titleLabel' field.

Cached name for the '_disclaimer' field.

Cached name for the '_dateLabel' field.

Cached name for the '_timeLeftLabel' field.

Cached name for the '_characterContainer' field.

Cached name for the '_embarkButton' field.

Cached name for the '_backButton' field.

Cached name for the '_unreadyButton' field.

Cached name for the '_leaderboard' field.

Cached name for the '_modifiersTitleLabel' field.

Cached name for the '_modifiersContainer' field.

Cached name for the '_remotePlayerContainer' field.

Cached name for the '_readyAndWaitingContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_icon' field.

Cached name for the '_description' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'SetLabel' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_label' field.

Cached name for the '_labelTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This is pretty close to NPaginator, but NPaginator only supports a static list of options whereas this needs to - Set its text based on a DateTimeOffset that is (effectively) infinite - Dynamically enable/disable arrows based on whether the query says there is a leaderboard It uses the same scene as NPaginator but with the script replaced.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_GuiInput' method.

Cached name for the 'PageLeft' method.

Cached name for the 'PageRight' method.

Cached name for the 'DayChangeHelper' method.

Cached name for the 'OnDayChanged' method.

Cached name for the 'Disable' method.

Cached name for the 'Enable' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_vfxLabel' field.

Cached name for the '_leftArrow' field.

Cached name for the '_rightArrow' field.

Cached name for the '_selectionReticle' field.

Cached name for the '_tween' field.

Cached name for the '_leaderboard' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'GetControllerIconNode' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_isLeftArrow' field.

Cached name for the '_image' field.

Cached name for the '_hsv' field.

Cached name for the '_tween' field.

Cached name for the '_baseScale' field.

Cached name for the '_hotkeys' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The language dropdown in the OptionsScreen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'PopulateOptions' method.

Cached name for the 'OnDropdownItemSelected' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CurrentCategory' property.

Cached name for the '_dropdownItemScene' field.

Cached name for the '_selectionReticle' field.

Cached name for the '_categories' field.

Cached name for the '_currentCategoryIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Init' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CategoryIndex' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Opens the feedback screen from anywhere when a hotkey is pressed.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the '_Input' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_selectionReticle' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'SetRotation1' method.

Cached name for the 'SetRotation2' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Cached name for the 'opposite' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'SetSelected' method.

Cached name for the 'FlashError' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Cached name for the '_isSelected' field.

Cached name for the '_selectionReticle' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetState' method.

Cached name for the 'SetRandomPosition' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Cartoon' property.

Cached name for the 'MyState' property.

Cached name for the '_tween' field.

Cached name for the '_originalPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Used to limit the number of characters that can be typed into the description box.

Set the screenshot that will be uploaded with the feedback. The screenshot will be automatically scaled to a smaller size so that the upload isn't massive.

Send feedback, allowing the player to exit the menu if they want to get back to playing.

Send feedback and log after close. This is purposefully static so that we ensure that nothing from the screen is used, as it can be deallocated before the method completes.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Relocalize' method.

Cached name for the 'OnDescriptionChanged' method.

Cached name for the 'SetScreenshot' method.

Cached name for the 'EmojiButtonSelected' method.

Cached name for the 'SendButtonFocused' method.

Cached name for the 'SendButtonUnfocused' method.

Cached name for the 'Open' method.

Cached name for the 'Close' method.

Cached name for the 'ClearInput' method.

Cached name for the 'SetSelectedEmoji' method.

Cached name for the 'SendButtonSelected' method.

Cached name for the 'ReturnToGameSelected' method.

Cached name for the 'ReturnToGameFocused' method.

Cached name for the 'ReturnToGameUnfocused' method.

Cached name for the 'WiggleCartoons1' method.

Cached name for the 'WiggleCartoons2' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_backButton' field.

Cached name for the '_mainPanel' field.

Cached name for the '_descriptionInput' field.

Cached name for the '_emojiLabel' field.

Cached name for the '_sendButton' field.

Cached name for the '_sendLabel' field.

Cached name for the '_categoryLabel' field.

Cached name for the '_returnToGameButton' field.

Cached name for the '_returnToGameLabel' field.

Cached name for the '_returnToGameHoverLabel' field.

Cached name for the '_categoryDropdown' field.

Cached name for the '_sendBackstop' field.

Cached name for the '_sendPanel' field.

Cached name for the '_successLabel' field.

Cached name for the '_failedLabel' field.

Cached name for the '_sendingLabel' field.

Cached name for the '_flower' field.

Cached name for the '_selectedEmoteButton' field.

Cached name for the '_screenshotBytes' field.

Cached name for the '_originalSuccessPosition' field.

Cached name for the '_lastClosedMsec' field.

Cached name for the '_descriptionText' field.

Cached name for the '_descriptionCaretLine' field.

Cached name for the '_descriptionCaretColumn' field.

Cached name for the '_wiggleTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Badge visual which appears on the game over screen. Can be hovered to view its name and description.

This creates an NBadge for the game over screen.

This creates an NBadge for the run history screen :). TODO: And the statistics screen later!

Maps badge rarity enums to prefix used for LocStrings

0.4 second animation of a Badge animating in. Deferred due to how GridContainer lays out its elements after AddChildSafely().

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'GetRarityPrefix' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'GetBadgeBaseTexture' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Cached name for the '_hoverNode' field.

Cached name for the '_selectionReticle' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetText' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_selectionReticle' field.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Call when we want this button to animate in.

Call when we want this button to hide this button (Disables clickability/hotkeys)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_tween' field.

Cached name for the '_hoverTween' field.

Cached name for the '_showPosition' field.

Cached name for the '_hsv' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Create an instance of this screen. Null if we're in test mode.

Called when the player continues to the score/badge breakdown.

Animates the second page of our Game Over screen

Based on the badges you get, save them to the progress file.

Helper function to create score lines, add child, and place it in a list to bulk animate later.

Lookup table of score thresholds based on the total number of unlocks the player has completed. Must match: .

We move the Creature nodes so they render above the game over screen backstop! Drama!

Called when the Game Over screen appears (immediately upon Death/Victory)

Little helper function that creates the x1.1 sort of string for the Score Line.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'DiscoveredAnyEpochs' method.

Cached name for the 'InitializeBannerAndQuote' method.

Cached name for the 'OpenSummaryScreen' method.

Cached name for the 'AddScoreLine' method.

Cached name for the 'PlayUnlockSfx' method.

Cached name for the 'TweenScore' method.

Cached name for the 'GetScoreThreshold' method.

Cached name for the 'ShowLeaderboard' method.

Cached name for the 'HideSummary' method.

Cached name for the 'OpenRunHistoryScreen' method.

Cached name for the 'OnMainMenuButtonPressed' method.

Cached name for the 'OpenTimeline' method.

Cached name for the 'ReturnToMainMenu' method.

Cached name for the 'AfterOverlayOpened' method.

Cached name for the 'MoveCreaturesToDifferentLayerAndDisableUi' method.

Cached name for the 'UpdateBackstopMaterial' method.

Cached name for the 'AfterOverlayClosed' method.

Cached name for the 'AfterOverlayShown' method.

Cached name for the 'AfterOverlayHidden' method.

Cached name for the 'GetAscensionMulti' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenType' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'FocusedControlFromTopBar' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_continueButton' field.

Cached name for the '_viewRunButton' field.

Cached name for the '_mainMenuButton' field.

Cached name for the '_leaderboardButton' field.

Cached name for the '_badgeContainer' field.

Cached name for the '_scoreLineContainer' field.

Cached name for the '_scoreBar' field.

Cached name for the '_scoreFg' field.

Cached name for the '_scoreProgress' field.

Cached name for the '_unlocksRemaining' field.

Cached name for the '_score' field.

Cached name for the '_scoreThreshold' field.

Cached name for the '_scoreUnlockedEpochId' field.

Cached name for the '_leaderboard' field.

Cached name for the '_creatureContainer' field.

Cached name for the '_summaryContainer' field.

Cached name for the '_fullBlackBackstop' field.

Cached name for the '_summaryBackstop' field.

Cached name for the '_backstop' field.

Cached name for the '_banner' field.

Cached name for the '_deathQuote' field.

Cached name for the '_victoryDamageLabel' field.

Cached name for the '_uiNode' field.

Cached name for the '_screenshakeContainer' field.

Cached name for the '_discoveryLabel' field.

Cached name for the '_encounterQuote' field.

Cached name for the '_isAnimatingSummary' field.

Cached name for the '_backstopMaterial' field.

Cached name for the '_quoteTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This is specifically the main menu button in the Game Over screen.

Call when we want this button to animate in. Called when we transition from Death intermission -> summary and when returning from Run History/Settings.

Called to hide this button (Open Settings/Run History or something during Death summary)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetLabelForUnlock' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'HideButton' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_label' field.

Cached name for the '_tween' field.

Cached name for the '_hoverTween' field.

Cached name for the '_showPosition' field.

Cached name for the '_hsv' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Animates the Run Summary portion of the Death Screen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetControllerNav' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_discoveryContainer' field.

Cached name for the '_discoveryHeader' field.

Cached name for the '_discoveredContents' field.

Cached name for the '_discoveredCards' field.

Cached name for the '_discoveredRelics' field.

Cached name for the '_discoveredPotions' field.

Cached name for the '_discoveredEnemies' field.

Cached name for the '_discoveredEpochs' field.

Cached name for the '_tween' field.

Cached name for the '_waitTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

0.4 second animation of a score line animating in. Deferred due to how GridContainer lays out its elements after AddChildSafely().

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Call when we want this button to animate in. Called when we transition from Death intermission -> summary and when returning from Run History/Settings.

Called to hide this button (Open Settings/Run History or something during Death summary)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_tween' field.

Cached name for the '_hoverTween' field.

Cached name for the '_showPosition' field.

Cached name for the '_hsv' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Allows the player to view a single relic. This allows players to see the higher resolution asset and flavor text.

Opens the Relic Inspection Screen.

The collection of relics this relic is a part of (used for left/right arrows) The relic the user clicked on to open this screen (index is automatically identified)

Call to update the screen to match the relic we're viewing. Called on screen open and when paging left/right.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_Input' method.

Cached name for the 'OnRightButtonPressed' method.

Cached name for the 'OnLeftButtonPressed' method.

Cached name for the 'SetRelic' method.

Cached name for the 'UpdateRelicDisplay' method.

Cached name for the 'SetRarityVisuals' method.

Cached name for the 'Close' method.

Cached name for the 'OnBackstopPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_popup' field.

Cached name for the '_backstop' field.

Cached name for the '_nameLabel' field.

Cached name for the '_rarityLabel' field.

Cached name for the '_description' field.

Cached name for the '_flavor' field.

Cached name for the '_relicImage' field.

Cached name for the '_frameHsv' field.

Cached name for the '_leftButton' field.

Cached name for the '_rightButton' field.

Cached name for the '_hoverTipRect' field.

Cached name for the '_screenTween' field.

Cached name for the '_popupTween' field.

Cached name for the '_popupPosition' field.

Cached name for the '_leftButtonX' field.

Cached name for the '_rightButtonX' field.

Cached name for the '_index' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The submenu buttons in the bottom section in the Compendium screen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'SetLocalization' method.

Cached name for the '_Notification' method.

Cached name for the 'RefreshLabels' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'UpdateShaderParam' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_bgPanel' field.

Cached name for the '_label' field.

Cached name for the '_icon' field.

Cached name for the '_locKeyPrefix' field.

Cached name for the '_hsv' field.

Cached name for the '_defaultV' field.

Cached name for the '_focusV' field.

Cached name for the '_pressV' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OpenCardLibrary' method.

Cached name for the 'OpenRelicCollection' method.

Cached name for the 'OpenPotionLab' method.

Cached name for the 'OpenBestiary' method.

Cached name for the 'OpenLeaderboards' method.

Cached name for the 'OpenStatistics' method.

Cached name for the 'OpenRunHistory' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_confirmButton' field.

Cached name for the '_cardLibraryButton' field.

Cached name for the '_relicCollectionButton' field.

Cached name for the '_potionLabButton' field.

Cached name for the '_bestiaryButton' field.

Cached name for the '_leaderboardsButton' field.

Cached name for the '_statisticsButton' field.

Cached name for the '_runHistoryButton' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Shows run info in the main menu! Handy!

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'AnimShow' method.

Cached name for the 'AnimHide' method.

Cached name for the 'ShowError' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'HasResult' property.

Cached name for the '_visTween' field.

Cached name for the '_initPosition' field.

Cached name for the '_runInfoContainer' field.

Cached name for the '_errorContainer' field.

Cached name for the '_dateLabel' field.

Cached name for the '_goldLabel' field.

Cached name for the '_healthLabel' field.

Cached name for the '_progressLabel' field.

Cached name for the '_ascensionLabel' field.

Cached name for the '_charIcon' field.

Cached name for the '_isShown' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Call this once when the menu opens with the appropriate mode for the screen we're displayed on.

See the documentation for the enumeration for the correct value to pass.

Call this when: - We are in client mode and the host changes the modifiers that are selected - Once when the game is loaded from a multiplayer save

The modifiers to display as checked.

Returns the list of modifiers that are ticked on.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Initialize' method.

Cached name for the 'UntickMutuallyExclusiveModifiersForTickbox' method.

Cached name for the 'AfterModifiersChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_container' field.

Cached name for the '_mode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'ModifiersChanged' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Button used specifically for the Early Access Disclaimer.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Created as needed (not preloaded) because it only shows up once.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'UpdateEaDisclaimerDescription' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_tween' field.

Cached name for the '_image' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderParam' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'PlayerId' property.

Cached name for the '_tween' field.

Cached name for the '_hsv' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderParam' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the 'PlayerId' property.

Cached name for the '_tween' field.

Cached name for the '_hsv' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'RefreshButtonClicked' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the 'DebugFriendsButtons' property.

Cached name for the '_buttonContainer' field.

Cached name for the '_loadingOverlay' field.

Cached name for the '_loadingFriendsIndicator' field.

Cached name for the '_noFriendsLabel' field.

Cached name for the '_refreshButton' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Lays out buttons centered in a vertical column. When that column is full, starts a new column and centers both. This assumes that all children are the same size.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Notification' method.

Cached name for the 'LayoutChildren' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_bg' field.

Cached name for the '_logoContainer' field.

Cached name for the '_logoSpineNode' field.

Cached name for the '_logoBgColor' field.

Cached name for the '_tween' field.

Cached name for the '_cancelled' field.

Cached name for the '_skeletonReady' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Helper to connect Focused/Unfocused signals to main menu text buttons.

This handles the little carets animation for the main menu text buttons.

Re-checks the visibility of text buttons after we abandon a run from the main menu or close the Timeline screen. Useful because we may have unlocked new features.

For getting into multiplayer testing quickly. Checks some command line args and skips through menu clicking based on the args.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'ConnectMainMenuTextButtonFocusLogic' method.

Cached name for the 'MainMenuButtonFocused' method.

Cached name for the 'MainMenuButtonUnfocused' method.

Cached name for the 'EnableBackstop' method.

Cached name for the 'DisableBackstop' method.

Cached name for the 'DisableBackstopInstantly' method.

Cached name for the 'EnableBackstopInstantly' method.

Cached name for the 'UpdateShaderMix' method.

Cached name for the 'UpdateShaderLod' method.

Cached name for the 'RefreshButtons' method.

Cached name for the 'UpdateTimelineButtonBehavior' method.

Cached name for the 'OnSubmenuStackChanged' method.

Cached name for the 'OnContinueButtonPressed' method.

Cached name for the 'DisplayLoadSaveError' method.

Cached name for the 'OnAbandonRunButtonPressed' method.

Cached name for the 'AbandonRun' method.

Cached name for the 'SingleplayerButtonPressed' method.

Cached name for the 'OpenSingleplayerSubmenu' method.

Cached name for the 'OpenMultiplayerSubmenu' method.

Cached name for the 'OpenCompendiumSubmenu' method.

Cached name for the 'OpenTimelineScreen' method.

Cached name for the 'OpenSettingsMenu' method.

Cached name for the 'OpenProfileScreen' method.

Cached name for the 'OpenPatchNotes' method.

Cached name for the 'Quit' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'CheckCommandLineArgs' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'PatchNotesScreen' property.

Cached name for the 'BlurBackstop' property.

Cached name for the 'MainMenuButtons' property.

Cached name for the 'SubmenuStack' property.

Cached name for the 'ContinueRunInfo' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_window' field.

Cached name for the '_continueButton' field.

Cached name for the '_abandonRunButton' field.

Cached name for the '_singleplayerButton' field.

Cached name for the '_compendiumButton' field.

Cached name for the '_timelineButton' field.

Cached name for the '_settingsButton' field.

Cached name for the '_quitButton' field.

Cached name for the '_multiplayerButton' field.

Cached name for the '_buttonReticleLeft' field.

Cached name for the '_buttonReticleRight' field.

Cached name for the '_reticleTween' field.

Cached name for the '_patchNotesButtonNode' field.

Cached name for the '_openProfileScreenButton' field.

Cached name for the '_lastHitButton' field.

Cached name for the '_runInfo' field.

Cached name for the '_timelineNotificationDot' field.

Cached name for the '_backstopTween' field.

Cached name for the '_bg' field.

Cached name for the '_blur' field.

Cached name for the '_openTimeline' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'ScaleBgIfNarrow' method.

Cached name for the 'HideLogo' method.

Cached name for the 'ShowLogo' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_window' field.

Cached name for the '_bg' field.

Cached name for the '_logo' field.

Cached name for the '_logoTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Overridden so the node appear when this button is hovered. That's it. Same exact behavior for the AbandonRun button btw. They should be identical.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_mainMenu' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages spawned submenus in the main menu. We lazily spawn submenus only when they are requested to reduce loading times.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreenScene' field.

Cached name for the '_characterSelectScreenScene' field.

Cached name for the '_singleplayerSubmenu' field.

Cached name for the '_multiplayerSubmenu' field.

Cached name for the '_multiplayerHostSubmenu' field.

Cached name for the '_joinFriendSubmenu' field.

Cached name for the '_characterSelectSubmenu' field.

Cached name for the '_loadMultiplayerSubmenu' field.

Cached name for the '_compendiumSubmenu' field.

Cached name for the '_bestiarySubmenu' field.

Cached name for the '_relicCollectionSubmenu' field.

Cached name for the '_potionLabSubmenu' field.

Cached name for the '_cardLibrarySubmenu' field.

Cached name for the '_runHistorySubmenu' field.

Cached name for the '_statsScreen' field.

Cached name for the '_timelineScreen' field.

Cached name for the '_settingsScreen' field.

Cached name for the '_dailyScreen' field.

Cached name for the '_dailyLoadScreen' field.

Cached name for the '_customRunScreen' field.

Cached name for the '_customRunLoadScreen' field.

Cached name for the '_moddingScreen' field.

Cached name for the '_profileScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The text buttons seen as a vertical list in the main menu. Buttons like Singleplayer, Multiplayer, Statistics, Options, Quit, etc Note that we tween the scale/modulate of the label instead of the entire button because stuff is parented to the continue button

This is null at certain points when the scene is being loaded.

Wait one frame before the text change affects the Control node's size so we can set the pivot accurately.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'SetLocalization' method.

Cached name for the '_Notification' method.

Cached name for the 'RefreshLabel' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'AnimUnhover' method.

Cached name for the 'AnimPressDown' method.

Cached name for the 'AnimRelease' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnEnable' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'label' field.

Cached name for the '_defaultColor' field.

Cached name for the '_hoveredColor' field.

Cached name for the '_downColor' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Checks the unlock state of Custom and Daily to determine whether they should be locked or not. Is not checked only at _Ready() because the MainMenu isn't recreated upon returning from the Timeline.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'RefreshButtons' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnStandardPressed' method.

Cached name for the 'OnDailyPressed' method.

Cached name for the 'OnCustomPressed' method.

Cached name for the 'StartHost' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_standardButton' field.

Cached name for the '_dailyButton' field.

Cached name for the '_customButton' field.

Cached name for the '_loadingOverlay' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'UpdateButtons' method.

Cached name for the 'AbandonRun' method.

Cached name for the 'StartLoad' method.

Cached name for the 'OnHostPressed' method.

Cached name for the 'FastHost' method.

Cached name for the 'OpenJoinFriendsScreen' method.

Cached name for the 'OnJoinFriendsPressed' method.

Cached name for the 'OnSubmenuShown' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_hostButton' field.

Cached name for the '_loadButton' field.

Cached name for the '_abandonButton' field.

Cached name for the '_joinButton' field.

Cached name for the '_loadingOverlay' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Button on the main menu which opens the profile screen, allowing the player to switch profiles.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the '_Notification' method.

Cached name for the 'RefreshLabels' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateDescription' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_profileIcon' field.

Cached name for the '_title' field.

Cached name for the '_description' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_hsv' field.

Cached name for the '_icon' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'CreateNewPatchEntry' method.

Cached name for the 'NextPatchNote' method.

Cached name for the 'PreviousPatchNote' method.

Cached name for the 'Open' method.

Cached name for the 'Close' method.

Cached name for the 'LoadPatchNoteText' method.

Cached name for the 'ReadPatchNoteFile' method.

Cached name for the 'UpdateDateLabel' method.

Cached name for the 'GetFileNameFromPath' method.

Cached name for the 'RemoveFileExtension' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsOpen' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_screenContents' field.

Cached name for the '_marginContainer' field.

Cached name for the '_prevButton' field.

Cached name for the '_nextButton' field.

Cached name for the '_patchNotesToggle' field.

Cached name for the '_backButton' field.

Cached name for the '_dateLabel' field.

Cached name for the '_patchText' field.

Cached name for the '_tween' field.

Cached name for the '_cachedScene' field.

Cached name for the '_index' field.

Cached name for the '_currentScrollLine' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The huge submenu buttons you see in the MainMenu.

Used when this button is LOCKED from the player for whatever reason.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'GetImagePath' method.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'SetIconAndLocalization' method.

Cached name for the '_Notification' method.

Cached name for the 'RefreshLabels' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Cached name for the 'UpdateShaderParam' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_bgPanel' field.

Cached name for the '_icon' field.

Cached name for the '_title' field.

Cached name for the '_description' field.

Cached name for the '_locKeyPrefix' field.

Cached name for the '_hsv' field.

Cached name for the '_defaultV' field.

Cached name for the '_focusV' field.

Cached name for the '_pressV' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Checks the unlock state of Custom and Daily to determine whether they should be locked or not. Is not checked only at _Ready() because the MainMenu isn't recreated upon returning from the Timeline.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'RefreshButtons' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OpenCharacterSelect' method.

Cached name for the 'OpenDailyScreen' method.

Cached name for the 'OpenCustomScreen' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_standardButton' field.

Cached name for the '_dailyButton' field.

Cached name for the '_customButton' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The last control node we were focusing on when this submenu was hidden (usually when another submenu is opened above it)

Used to override submenu back button behaviors (see: Timeline)

The initial control the submenu is focused on when it is first opened

Called when this submenu is newly pushed onto the stack OR when it is re-shown because the submenu above it has been popped from the stack.

Called when this submenu has just been popped from the stack OR when it is hidden because a new submenu has just been pushed onto the stack.

Called only when this submenu is newly pushed on to a stack.

Called only when this submenu is popped from the stack it was on.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'HideBackButtonImmediately' method.

Cached name for the 'SetStack' method.

Cached name for the 'OnScreenVisibilityChange' method.

Cached name for the 'OnSubmenuShown' method.

Cached name for the 'OnSubmenuHidden' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_backButton' field.

Cached name for the '_stack' field.

Cached name for the '_lastFocusedControl' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The huge submenu buttons you see in the MainMenu.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'SetIconAndLocalization' method.

Cached name for the '_Notification' method.

Cached name for the 'RefreshLabels' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderParam' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_hsv' field.

Cached name for the '_bgPanel' field.

Cached name for the '_icon' field.

Cached name for the '_title' field.

Cached name for the '_description' field.

Cached name for the '_locKeyPrefix' field.

Cached name for the '_defaultV' field.

Cached name for the '_scaleTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages submenus in the main menu. Also manages specific submenus while in-game (the compendium stack).

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'InitializeForMainMenu' method.

Cached name for the 'Push' method.

Cached name for the 'Pop' method.

Cached name for the 'ShowBackstop' method.

Cached name for the 'HideBackstop' method.

Cached name for the 'Peek' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'SubmenusOpen' property.

Cached name for the '_mainMenu' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'StackModified' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Represents the animation which plays when players don't all vote for the same map point. The amount of state to keep track of was getting a little unwieldy to put directly into the map screen.

Plays the animation if necessary. The animation is not played if all players voted for the same coordinate.

The special roughly 200x200 (in 1080p) map icon for the Ancient room. TODO: Bump up asset to ~266x266 px (as we're targeting 1440p) NOTE: Outline is created as a 2px stroke for the 1080p asset and named the same as the icon with _outline appended.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnSelected' method.

Cached name for the 'RefreshColorInstantly' method.

Cached name for the 'AnimHover' method.

Cached name for the 'AnimUnhover' method.

Cached name for the 'AnimPressDown' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'TraveledColor' property.

Cached name for the 'UntravelableColor' property.

Cached name for the 'HoveredColor' property.

Cached name for the 'HoverScale' property.

Cached name for the 'DownScale' property.

Cached name for the 'TargetMaterial' property.

Cached name for the '_icon' field.

Cached name for the '_outline' field.

Cached name for the '_tween' field.

Cached name for the '_elapsedTime' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnSelected' method.

Cached name for the 'RefreshColorInstantly' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'TraveledColor' property.

Cached name for the 'UntravelableColor' property.

Cached name for the 'HoveredColor' property.

Cached name for the 'HoverScale' property.

Cached name for the 'DownScale' property.

Cached name for the '_hoverTween' field.

Cached name for the '_usesSpine' field.

Cached name for the '_spriteContainer' field.

Cached name for the '_spineSprite' field.

Cached name for the '_material' field.

Cached name for the '_placeholderImage' field.

Cached name for the '_placeholderOutline' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the '_Input' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_eraserIconPos' field.

Cached name for the '_drawingIconPos' field.

Cached name for the '_isPressed' field.

Cached name for the '_cursorTex' field.

Cached name for the '_cursorTiltedTex' field.

Cached name for the '_cursor' field.

Cached name for the '_direction' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Exists solely to move the y position of the map asset when the aspect ratio becomes narrower than 16:9

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnVisibilityChanged' method.

Cached name for the 'OnWindowChange' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_mapTop' field.

Cached name for the '_mapMid' field.

Cached name for the '_mapBot' field.

Cached name for the '_drawings' field.

Cached name for the '_window' field.

Cached name for the '_offsetX' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_drawingToolHolder' field.

Cached name for the '_icon' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetIsDrawing' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnControllerUpdated' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_drawingToolHolder' field.

Cached name for the '_icon' field.

Cached name for the '_tween' field.

Cached name for the '_isDrawing' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

An abstract base class to manage the drawing on the map Inherited classes manage map drawing for different types of inputs. Is created and destroyed on demand.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'StopDrawing' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DrawingMode' property.

Cached name for the '_drawings' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Finished' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Takes care of drawing both local and remote players' map drawings. Notes on the tech art side: Lines are placed into a subviewport which renders to a half-resolution texture. Drawn lines are simple colored Line2D nodes. Eraser lines are Line2D nodes with a shader with a subtractive blend mode. More details are in the shader itself. The subviewport texture is drawn on top of the map. Importantly, it is drawn using the premultiplied-alpha blend mode. Without this, black artifacts are seen on the edges of the lines because of the intermediate subviewport texture blending.

Called when the local player begins drawing a line.

The position at which the player started drawing. The mode to override the current mode with. If null, the current mode in the set using SetDrawingMode is used. If it is null and the current mode is None, an exception is thrown. In most cases, you want this to be true. If false, this returns DrawingMode.None if the player is drawing using a shortcut (right click or middle click). The kind of drawing that the player is currently doing.

Called when a remote player changes which screen they're looking at. If the player was looking at the map and drawing a line, then this will revert their cursor back to the default one. It's necessary because drawing packets are unreliable, so the end packet may not be received.

The player whose screen changed. The screen the player was looking at.

Sends a sync message if enough time has passed since the last one, or buffers it to be sent otherwise.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdateCurrentLinePositionLocal' method.

Cached name for the 'StopLineLocal' method.

Cached name for the 'SetDrawingModeLocal' method.

Cached name for the 'ClearDrawnLinesLocal' method.

Cached name for the 'IsDrawing' method.

Cached name for the 'IsLocalDrawing' method.

Cached name for the 'GetDrawingMode' method.

Cached name for the 'GetLocalDrawingMode' method.

Cached name for the 'ToNetPosition' method.

Cached name for the 'FromNetPosition' method.

Cached name for the 'UpdateVisibilityFromSettings' method.

Cached name for the 'ClearAllLines' method.

Cached name for the 'OnPlayerScreenChanged' method.

Cached name for the 'TrySendSyncMessage' method.

Cached name for the 'SendSyncMessage' method.

Cached name for the 'UpdateLocalCursor' method.

Cached name for the 'RepositionBasedOnBackground' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_lineDrawScene' field.

Cached name for the '_lineEraseScene' field.

Cached name for the '_cursorManager' field.

Cached name for the '_eraserMaterial' field.

Cached name for the '_defaultSize' field.

Cached name for the '_lastMessageMsec' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetIsErasing' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnControllerUpdated' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_drawingToolHolder' field.

Cached name for the '_icon' field.

Cached name for the '_tween' field.

Cached name for the '_isErasing' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A single line on the map legend. Has some hover logic, will eventually require controller support so players can navigate to this and read what each map icon represents.

Helper method which grabs the Node's name and finds the appropriate map point type.

Name of this Godot node.

Helper method which grabs the Node's name and then finds the appropriate LocString for this LegendItem's label and HoverTip text fields.

Name of this Godot node.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetMapPointType' method.

Cached name for the 'SetLocalizedFields' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_icon' field.

Cached name for the '_scaleDownTween' field.

Cached name for the '_pointType' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The little arrow which indicates where you are on the map.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ResetMapPoint' method.

Cached name for the 'HideMapPoint' method.

Cached name for the 'SetMapPoint' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Cached name for the '_posOffset' field.

Cached name for the '_isEnabled' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Indicates whether a node is an adjacent node above the current node (you're able to travel to it IF you have completed the room). If you want logic to trigger based on the button being clickable, use _isEnabled instead.

This map point's current state. Affects how it looks and its hoverability/clickability.

Returns true when a player's icon should be displayed to indicate that they've voted for this map point.

Override this to add extra behavior when a map node selection. Usually for visuals.

The base class handles the logic for selecting a map point, so we don't allow overriding it. Instead, override OnSelected to run logic before selecting the map point.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'IsInputAllowed' method.

Cached name for the 'RefreshVisualsInstantly' method.

Cached name for the 'OnSelected' method.

Cached name for the 'OnRelease' method.

Cached name for the 'RefreshColorInstantly' method.

Cached name for the 'RefreshState' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'TraveledColor' property.

Cached name for the 'UntravelableColor' property.

Cached name for the 'HoveredColor' property.

Cached name for the 'HoverScale' property.

Cached name for the 'DownScale' property.

Cached name for the 'AllowFocusWhileDisabled' property.

Cached name for the 'VoteContainer' property.

Cached name for the 'IsTravelable' property.

Cached name for the 'State' property.

Cached name for the 'TargetColor' property.

Cached name for the '_state' field.

Cached name for the '_outlineColor' field.

Cached name for the '_controllerSelectionReticle' field.

Cached name for the '_screen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This is to be called by the backend so we can setup our map screen.

The new map to set. The seed to use for the visual jitter on the map node positions. True if map drawings should be cleared.

Sets the marker to be at the specified coordinate. Since the player starts in the Neow room in a new run, TravelToMapCoord isn't called so we need to init the marker externally.

Animation and logic which occurs when a coord is finalized for travel. In multiplayer, this only occurs when all votes have been received and a map point has been selected.

The coordinate to travel to

Just a helper class to make Init() easier to parse, don't mind me.

Creates a bunch of dots to form a path from start to end

Detects mouse click up/down and updates our scroll target accordingly

Detects mouse click up/down and does drawing

Detects mouse wheel up/down and updates our scroll target accordingly

Initializes and begins to animate the "Select a Starting Room" message. This only appears in the very first map screen you enter per Act.

Makes the map anim interruptable via click or scroll

During the first half of the map scroll animation, moving the map is disabled.

Allows the player to abort (aka cancel) the start of act animation early.

This is used to disable scrolling and clicking on the map screen for 1/5 of a second for when the player interrupts the map animation. Otherwise it's possible to double click and stop the map at a strange position.

Opens the map screen.

If this is true, then we'll skip the full map animation. Should be true if the player has opened the map manually instead of proceeding at the end of a room. The map screen that was just opened.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'GetLineEndpoint' method.

Cached name for the 'RecalculateTravelability' method.

Cached name for the 'InitMapVotes' method.

Cached name for the 'OnMapPointSelectedLocally' method.

Cached name for the 'RefreshAllMapPointVotes' method.

Cached name for the 'RemoveAllMapPointsAndPaths' method.

Cached name for the '_Process' method.

Cached name for the 'UpdateScrollPosition' method.

Cached name for the '_GuiInput' method.

Cached name for the 'ProcessMouseEvent' method.

Cached name for the 'ProcessMouseDrawingEvent' method.

Cached name for the 'ProcessScrollEvent' method.

Cached name for the 'ProcessControllerEvent' method.

Cached name for the 'SetTravelEnabled' method.

Cached name for the 'SetDebugTravelEnabled' method.

Cached name for the 'RefreshAllPointVisuals' method.

Cached name for the 'PlayStartOfActAnimation' method.

Cached name for the 'InitMapPrompt' method.

Cached name for the 'SetInterruptable' method.

Cached name for the 'CanScroll' method.

Cached name for the 'TryCancelStartOfActAnim' method.

Cached name for the 'OnVisibilityChanged' method.

Cached name for the 'OnCapstoneChanged' method.

Cached name for the 'Close' method.

Cached name for the 'Open' method.

Cached name for the 'OnBackButtonPressed' method.

Cached name for the '_Input' method.

Cached name for the 'OnMapDrawingButtonPressed' method.

Cached name for the 'OnMapErasingButtonPressed' method.

Cached name for the 'UpdateDrawingButtonStates' method.

Cached name for the 'OnClearMapDrawingButtonPressed' method.

Cached name for the 'HighlightPointType' method.

Cached name for the 'OnLegendHotkeyPressed' method.

Cached name for the 'OnDrawingToolsHotkeyPressed' method.

Cached name for the 'GetNetPositionFromScreenPosition' method.

Cached name for the 'GetMapPositionFromNetPosition' method.

Cached name for the 'GetScreenPositionFromNetPosition' method.

Cached name for the 'IsNodeOnScreen' method.

Cached name for the 'CleanUp' method.

Cached name for the 'UpdateHotkeyDisplay' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsOpen' property.

Cached name for the 'IsTravelEnabled' property.

Cached name for the 'IsDebugTravelEnabled' property.

Cached name for the 'MapLegendX' property.

Cached name for the 'IsTraveling' property.

Cached name for the 'Drawings' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_mapContainer' field.

Cached name for the '_pathsContainer' field.

Cached name for the '_points' field.

Cached name for the '_bossPointNode' field.

Cached name for the '_secondBossPointNode' field.

Cached name for the '_startingPointNode' field.

Cached name for the '_mapBgContainer' field.

Cached name for the '_marker' field.

Cached name for the '_backButton' field.

Cached name for the '_drawingToolsHotkeyIcon' field.

Cached name for the '_drawingTools' field.

Cached name for the '_mapDrawingButton' field.

Cached name for the '_mapErasingButton' field.

Cached name for the '_mapClearButton' field.

Cached name for the '_mapLegend' field.

Cached name for the '_legendItems' field.

Cached name for the '_legendHotkeyIcon' field.

Cached name for the '_backstop' field.

Cached name for the '_tween' field.

Cached name for the '_startDragPos' field.

Cached name for the '_targetDragPos' field.

Cached name for the '_isDragging' field.

Cached name for the '_hasPlayedAnimation' field.

Cached name for the '_controllerScrollAmount' field.

Cached name for the '_distX' field.

Cached name for the '_distY' field.

Cached name for the '_actAnimTween' field.

Cached name for the '_mapScrollAnimTimer' field.

Cached name for the '_mapAnimStartDelay' field.

Cached name for the '_mapAnimDuration' field.

Cached name for the '_canInterruptAnim' field.

Cached name for the '_isInputDisabled' field.

Cached name for the '_promptTween' field.

Cached name for the '_drawingInput' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Opened' signal.

Cached name for the 'Closed' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Input' method.

Cached name for the 'ProcessMouseDrawingEvent' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ListeningButton' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Detects mouse click up/down and does drawing

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Input' method.

Cached name for the 'ProcessMouseDrawingEvent' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'IconName' method.

Cached name for the 'IconPath' method.

Cached name for the 'OutlinePath' method.

Cached name for the 'UnknownIconPath' method.

Cached name for the 'UnknownOutlinePath' method.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the 'RefreshMarkedIconVisibility' method.

Cached name for the '_ExitTree' method.

Cached name for the '_Process' method.

Cached name for the 'OnSelected' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'SetAngle' method.

Cached name for the 'RefreshColorInstantly' method.

Cached name for the 'RefreshState' method.

Cached name for the 'UpdateIcon' method.

Cached name for the 'ShowCircleVfx' method.

Cached name for the 'AnimHover' method.

Cached name for the 'AnimUnhover' method.

Cached name for the 'AnimPressDown' method.

Cached name for the 'OnHighlightPointType' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'TraveledColor' property.

Cached name for the 'UntravelableColor' property.

Cached name for the 'HoveredColor' property.

Cached name for the 'HoverScale' property.

Cached name for the 'DownScale' property.

Cached name for the '_iconContainer' field.

Cached name for the '_icon' field.

Cached name for the '_questIcon' field.

Cached name for the '_outline' field.

Cached name for the '_circleVfx' field.

Cached name for the '_tween' field.

Cached name for the '_pulseTween' field.

Cached name for the '_elapsedTime' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Vertical popup used to get player confirmation before loading mods. Renders above the capstone screens (above top bar).

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnYesButtonPressed' method.

Cached name for the 'OnNoButtonPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_verticalPopup' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Called both during initialization and when a new mod is installed during runtime.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnGetModsPressed' method.

Cached name for the 'OnMakeModsPressed' method.

Cached name for the 'OnRowSelected' method.

Cached name for the 'OnModEnabledOrDisabled' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_modInfoContainer' field.

Cached name for the '_modRowContainer' field.

Cached name for the '_pendingChangesWarning' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_title' field.

Cached name for the '_image' field.

Cached name for the '_description' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Ping button. Flies in from off-screen after a short delay when the local player is ready but remote players are not.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_visuals' field.

Cached name for the '_image' field.

Cached name for the '_label' field.

Cached name for the '_viewport' field.

Cached name for the '_hsv' field.

Cached name for the '_hoverTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnRelease' method.

Cached name for the 'SetSelected' method.

Cached name for the 'OnTickboxToggled' method.

Cached name for the 'GetPlatformIcon' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_selectionHighlight' field.

Cached name for the '_tickbox' field.

Cached name for the '_screen' field.

Cached name for the '_isSelected' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A great way to resize bg assets. Interpolates from 16:9 to other aspect ratios. TODO: Adopt for normal events??

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnWindowChange' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_window' field.

Cached name for the '_pos43' field.

Cached name for the '_scale43' field.

Cached name for the '_pos169' field.

Cached name for the '_scale169' field.

Cached name for the '_pos219' field.

Cached name for the '_scale219' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Controls submenu stacks that show up as a capstone (compendium, settings). Allows submenus to stack on top of each other and act as one big capstone. They are all dismissed if another capstone shows up.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'ShowScreen' method.

Cached name for the 'GetCapstoneSubmenuType' method.

Cached name for the '_Ready' method.

Cached name for the 'OnSubmenuStackChanged' method.

Cached name for the 'AfterCapstoneOpened' method.

Cached name for the 'AfterCapstoneClosed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Type' property.

Cached name for the 'Stack' property.

Cached name for the 'ScreenType' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'DefaultFocusedControl' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Used by Draw pile, Discard pile, and Exhaust pile screens during combat. Do not use it for anything else. You have been warned.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnPileContentsChanged' method.

Cached name for the 'OnReturnButtonPressed' method.

Cached name for the 'AfterCapstoneOpened' method.

Cached name for the 'AfterCapstoneClosed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenType' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_background' field.

Cached name for the '_grid' field.

Cached name for the '_backButton' field.

Cached name for the '_bottomLabel' field.

Cached name for the '_currentTween' field.

Cached name for the '_closeHotkeys' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This is the screen used to view an arbitrary set of cards EX: pandoras box

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'OnInspectCardHidden' method.

Cached name for the 'ToggleShowUpgrades' method.

Cached name for the 'OnReturnButtonPressed' method.

Cached name for the 'AfterCapstoneOpened' method.

Cached name for the 'AfterCapstoneClosed' method.

Cached name for the 'OnControllerStateUpdated' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenType' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the 'FocusedControlFromTopBar' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the '_background' field.

Cached name for the '_grid' field.

Cached name for the '_backButton' field.

Cached name for the '_showUpgrades' field.

Cached name for the '_bottomLabel' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Selection screen for choosing a relic from out of combat generators like JewelryBox

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'SelectHolder' method.

Cached name for the 'OnSkipButtonReleased' method.

Cached name for the 'AfterOverlayOpened' method.

Cached name for the 'AfterOverlayClosed' method.

Cached name for the 'AfterOverlayShown' method.

Cached name for the 'AfterOverlayHidden' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenType' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_banner' field.

Cached name for the '_relicRow' field.

Cached name for the '_skipButton' field.

Cached name for the '_screenComplete' field.

Cached name for the '_relicSelected' field.

Cached name for the '_cardTween' field.

Cached name for the '_fadeTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This is the screen used to view the player's deck (that's you!)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'AfterCapstoneClosed' method.

Cached name for the 'OnPileContentsChanged' method.

Cached name for the 'OnObtainedSort' method.

Cached name for the 'OnCardTypeSort' method.

Cached name for the 'OnCostSort' method.

Cached name for the 'OnAlphabetSort' method.

Cached name for the 'DisplayCards' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenType' property.

Cached name for the '_obtainedSorter' field.

Cached name for the '_typeSorter' field.

Cached name for the '_costSorter' field.

Cached name for the '_alphabetSorter' field.

Cached name for the '_bg' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Shows a very large version of a single card so players can view the portrait and its upgrade. Accessed from various card pile screens, shop, run history screen, and card library. We have to do this, rather than making it its own Overlay Screen, because we end up using it both for other overlay screens and capstone screens (deck view screen).

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Close' method.

Cached name for the 'OnRightButtonReleased' method.

Cached name for the 'OnLeftButtonReleased' method.

Cached name for the 'ToggleShowUpgrade' method.

Cached name for the 'UpdateCardDisplay' method.

Cached name for the 'SetCard' method.

Cached name for the 'OnBackstopPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsShowingUpgradedCard' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_card' field.

Cached name for the '_backstop' field.

Cached name for the '_upgradeTickbox' field.

Cached name for the '_leftButton' field.

Cached name for the '_rightButton' field.

Cached name for the '_hoverTipRect' field.

Cached name for the '_index' field.

Cached name for the '_openTween' field.

Cached name for the '_cardTween' field.

Cached name for the '_cardPosition' field.

Cached name for the '_leftButtonX' field.

Cached name for the '_rightButtonX' field.

Cached name for the '_viewAllUpgraded' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Whether this screen is the last thing you'll see in the current room. See for more info.

If this rewards screen requires the player to take all rewards, then the skip button cannot be shown.

If the rewards screen is terminal, this is true once the player has taken all rewards or skipped them. False if the rewards screen is not terminal or the player has not taken all rewards yet.

Detects mouse wheel up/down and updates our scroll target accordingly

If the player attempts to skip rewards AND they have encountered less than 3 rewards, we show the Rewards FTUE to let them know that they shouldn't skip rewards. You have to click em to get em!

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'RewardCollectedFrom' method.

Cached name for the 'RewardSkippedFrom' method.

Cached name for the 'UpdateScreenState' method.

Cached name for the 'RemoveButton' method.

Cached name for the 'OnProceedButtonPressed' method.

Cached name for the 'AfterOverlayOpened' method.

Cached name for the 'AfterOverlayClosed' method.

Cached name for the 'TryEnableProceedButton' method.

Cached name for the 'AfterOverlayShown' method.

Cached name for the 'AfterOverlayHidden' method.

Cached name for the '_GuiInput' method.

Cached name for the 'ProcessScrollEvent' method.

Cached name for the 'ProcessGuiFocus' method.

Cached name for the '_Process' method.

Cached name for the 'UpdateScrollPosition' method.

Cached name for the 'HideWaitingForPlayersScreen' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CanScroll' property.

Cached name for the 'ScrollLimitBottom' property.

Cached name for the 'IsComplete' property.

Cached name for the 'ScreenType' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the 'FocusedControlFromTopBar' property.

Cached name for the '_proceedButton' field.

Cached name for the '_rewardsContainer' field.

Cached name for the '_scrollbar' field.

Cached name for the '_headerLabel' field.

Cached name for the '_rewardContainerMask' field.

Cached name for the '_waitingForOtherPlayersOverlay' field.

Cached name for the '_rewardsWindow' field.

Cached name for the '_targetDragPos' field.

Cached name for the '_scrollbarPressed' field.

Cached name for the '_fadeTween' field.

Cached name for the '_lastRewardFocused' field.

Cached name for the '_isTerminal' field.

Cached name for the '_skipDisallowed' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Completed' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Manages spawned submenus during a run. We lazily spawn submenus only when they are requested to reduce loading times.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreenScene' field.

Cached name for the '_pauseMenuScene' field.

Cached name for the '_statsScreenScene' field.

Cached name for the '_runHistoryScreenScene' field.

Cached name for the '_compendiumSubmenu' field.

Cached name for the '_bestiarySubmenu' field.

Cached name for the '_relicCollectionSubmenu' field.

Cached name for the '_potionLabSubmenu' field.

Cached name for the '_cardLibrarySubmenu' field.

Cached name for the '_runHistoryScreen' field.

Cached name for the '_settingsScreen' field.

Cached name for the '_statsScreen' field.

Cached name for the '_pauseMenu' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

This is the screen used to view an arbitrary set of cards EX: pandoras box

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'OnInspectCardHidden' method.

Cached name for the 'AfterCapstoneOpened' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenType' property.

Cached name for the '_confirmButton' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

An interface used by the NOverlayStack to manage screens that need to visibly stack on top of each other The requirements to what should be considered to be made an overlay screen are as follows: - need specific interaction when opened on top of with other screens - These screens are created and destroyed on demand Ex : "Combat reward screen" and "Choose a Card Screen" - both are used for a limited amount of time, so we can create/destroy them as needed - when I open the "Choose a Card Screen", the "Combat reward screen" sits underneath it while being disabled - when I close the "Choose a Card Screen", the "Combat reward screen" needs to become visible again

The screen type which will be synced with peers. This is used to display an icon next to the multiplayer player's icon, and to determine whether the remote player's mouse should be shown (i.e. whether they're on the same screen as you).

Node class that manages the ordering of all overlay screens. Any overlays added to the stack will sit on top of previously opened overlays, Only the top overlay is considered active overlays below it will not be active again until the overlays on top of it are closed

Adds a new screen to the top of the stack. Hides the previously open screen if there was one.

overlay screen that is being added to the stack.

Removes the specified screen from the stack. Sets up the previously open screen if there is one and the top screen was removed. Note: We have this instead of Pop because a screen is responsible for removing itself, and we can't guarantee that it'll be at the top of the stack when it needs to do this.

Overlay screen to be removed.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Clear' method.

Cached name for the 'HideOverlays' method.

Cached name for the 'ShowOverlays' method.

Cached name for the 'ShowBackstop' method.

Cached name for the 'HideBackstop' method.

Cached name for the 'OnActiveScreenChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScreenCount' property.

Cached name for the '_backstop' field.

Cached name for the '_backstopFade' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Changed' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

For multiplayer!

Helper method to quit to main menu as we require an async Task.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'RefreshLabels' method.

Cached name for the 'OnBackOrResumeButtonPressed' method.

Cached name for the 'OnSettingsButtonPressed' method.

Cached name for the 'OnCompendiumButtonPressed' method.

Cached name for the 'OnGiveUpButtonPressed' method.

Cached name for the 'OnDisconnectButtonPressed' method.

Cached name for the 'OnSaveAndQuitButtonPressed' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the 'Buttons' property.

Cached name for the 'UseSharedBackstop' property.

Cached name for the 'ScreenType' property.

Cached name for the '_backButton' field.

Cached name for the '_buttonContainer' field.

Cached name for the '_resumeButton' field.

Cached name for the '_settingsButton' field.

Cached name for the '_compendiumButton' field.

Cached name for the '_giveUpButton' field.

Cached name for the '_disconnectButton' field.

Cached name for the '_saveAndQuitButton' field.

Cached name for the '_pausedLabel' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Hover. Brighten a lil.

Unhover

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnPress' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'UseSharedBackstop' property.

Cached name for the '_backButton' field.

Cached name for the '_label' field.

Cached name for the '_image' field.

Cached name for the '_hsv' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

How the potion should be shown (locked, hidden, or visible).

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_potionNode' field.

Cached name for the '_potionHolder' field.

Cached name for the '_visibility' field.

Cached name for the '_hoverTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'OnSubmenuShown' method.

Cached name for the 'ClearPotions' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_screenContents' field.

Cached name for the '_common' field.

Cached name for the '_uncommon' field.

Cached name for the '_rare' field.

Cached name for the '_special' field.

Cached name for the '_screenTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Set the potions to be displayed.

The potion rarities to be displayed. The header that will be displayed at the top of the category. The potions that have been seen by the local player. The unlock state of the local player. All the potions that the local player has unlocked. An optional second rarity to display additionally. Only used in one specific category

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ClearPotions' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_headerLabel' field.

Cached name for the '_potionContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Initialize' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_icon' field.

Cached name for the '_label' field.

Cached name for the '_hsv' field.

Cached name for the '_tween' field.

Cached name for the '_profileScreen' field.

Cached name for the '_profileId' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Button in the profile screen which allows the player to select a profile.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Initialize' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_title' field.

Cached name for the '_description' field.

Cached name for the '_currentProfileIndicator' field.

Cached name for the '_profileIcon' field.

Cached name for the '_deleteButton' field.

Cached name for the '_background' field.

Cached name for the '_hsv' field.

Cached name for the '_profileScreen' field.

Cached name for the '_tween' field.

Cached name for the '_profileId' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetProfileId' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_icon' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Screen where the player can change profiles.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'ShowLoading' method.

Cached name for the 'Refresh' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_loadingOverlay' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'OnSubmenuShown' method.

Cached name for the 'ClearRelics' method.

Cached name for the 'SetLastFocusedRelic' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_screenContents' field.

Cached name for the '_starter' field.

Cached name for the '_common' field.

Cached name for the '_uncommon' field.

Cached name for the '_rare' field.

Cached name for the '_shop' field.

Cached name for the '_ancient' field.

Cached name for the '_event' field.

Cached name for the '_screenTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Instantiates a relic category by sorting and categorizing relics by ancient, character specific, and unlock/seen status.

Helper method to hook up relic nodes.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'CreateForSubcategory' method.

Cached name for the '_Ready' method.

Cached name for the 'LoadIcon' method.

Cached name for the 'ClearRelics' method.

Cached name for the 'OnRelicEntryPressed' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_collection' field.

Cached name for the '_headerLabel' field.

Cached name for the '_relicsContainer' field.

Cached name for the '_spacer' field.

Cached name for the '_icon' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Handles logic/visuals for a single relic button in the Relic Collection screen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ModelVisibility' property.

Cached name for the '_relicHolder' field.

Cached name for the '_relicNode' field.

Cached name for the '_hoverTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Sum of floors at the start of this act

Create an instance of this node. Null if we're in test mode.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_actLabel' field.

Cached name for the '_baseFloorNum' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ShowEntry' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_headerLabel' field.

Cached name for the '_cardContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Hovered' signal.

Cached name for the 'Unhovered' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Reload' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_titleLabel' field.

Cached name for the '_cardImage' field.

Cached name for the '_enchantmentImage' field.

Cached name for the '_labelContainer' field.

Cached name for the '_scaleTween' field.

Cached name for the '_amount' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Clicked' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetDeckHistory' method.

Cached name for the 'SetRelicHistory' method.

Cached name for the 'HighlightRelevantEntries' method.

Cached name for the 'UnHighlightEntries' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_actContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'Highlight' method.

Cached name for the 'Unhighlight' method.

Cached name for the 'GetSfxVolume' method.

Cached name for the 'HurryUp' method.

Cached name for the 'SetupForAnimation' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'FloorNum' property.

Cached name for the '_baseScale' field.

Cached name for the '_texture' field.

Cached name for the '_outline' field.

Cached name for the '_questIcon' field.

Cached name for the '_animateInTween' field.

Cached name for the '_hoverTween' field.

Cached name for the '_baseAngle' field.

Cached name for the '_hurryUp' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Opens the Inspect Relic screen and allows the player to paginate through the rest of the top bar relics.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelicClicked' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_headerLabel' field.

Cached name for the '_relicsContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Hovered' signal.

Cached name for the 'Unhovered' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Rename to NRunHistoryScreen someday.

Padding at the bottom of the screen so that the scrollbar shows up if the contents don't quite touch the bottom

Called whenever we want to load a run history file!

Counts the total number of MapPointHistoryEntry objects. This is how many floors the player has traversed I think.

Sets the text in the top right that is like Singleplayer: Standard or Multiplayer: Custom, etc.

Given a entry, returns how the run ended (aka the ).

Helper method to generate a death quote given a run history entry, characterId, and how they died.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnLeftButtonButtonReleased' method.

Cached name for the 'OnRightButtonButtonReleased' method.

Cached name for the 'CanBeShown' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuShown' method.

Cached name for the 'OnSubmenuHidden' method.

Cached name for the '_Input' method.

Cached name for the 'SelectPlayer' method.

Cached name for the 'LoadGoldHpAndPotionInfo' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_screenContents' field.

Cached name for the '_playerIconContainer' field.

Cached name for the '_hpLabel' field.

Cached name for the '_goldLabel' field.

Cached name for the '_potionHolder' field.

Cached name for the '_floorLabel' field.

Cached name for the '_timeLabel' field.

Cached name for the '_dateLabel' field.

Cached name for the '_seedLabel' field.

Cached name for the '_gameModeLabel' field.

Cached name for the '_buildLabel' field.

Cached name for the '_badgeContainer' field.

Cached name for the '_deathQuoteLabel' field.

Cached name for the '_mapPointHistory' field.

Cached name for the '_relicHistory' field.

Cached name for the '_deckHistory' field.

Cached name for the '_outOfDateVisual' field.

Cached name for the '_index' field.

Cached name for the '_prevButton' field.

Cached name for the '_nextButton' field.

Cached name for the '_selectedPlayerIcon' field.

Cached name for the '_screenTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Whether this arrow is facing left or right

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsLeft' property.

Cached name for the 'Hotkeys' property.

Cached name for the '_isLeft' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Select' method.

Cached name for the 'Deselect' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_achievementLock' field.

Cached name for the '_ascensionIcon' field.

Cached name for the '_ascensionLabel' field.

Cached name for the '_selectionReticle' field.

Cached name for the '_hsv' field.

Cached name for the '_icon' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages the screen contexts that is currently active (the top-most screen that the player is interacting with). This is used to span between all of our different screen systems (overlays, capstones, submenus, even rooms).

Event used to let listeners know that the Current Active Screen may have changed Useful for screens that needs to hide/show certain UX depending on if it is the Current Screen or not.

Looks through all of our screen systems in order of priority to determine what the active screen context currently is.

The screen context that is currently active.

An interface that is shared by all screens in sts2. Used to bridge the gap between all of our various screen systems (Overlays, Capstones, Rooms, Submenus)

The default control to focus on when it becomes the ActiveScreen while the player is using controller

The default control to focus on when navigating from the top bar (typically from your relics) Most of the time just equal to the DefaultFocusedControl

Ensures that the state of the node reflects SettingsSave/PrefsSave. For example, if we change SettingsSave.FastMode, then this should be called on NFastModeTickbox to ensure it is ticked/unticked appropriately.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnValueChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

The display mode dropdown in the SettingsScreen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'AddDropdownItem' method.

Cached name for the 'OnDropdownItemSelected' method.

Cached name for the 'GetAspectRatioSettingString' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_currentAspectRatioSetting' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Init' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'aspectRatioSetting' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnValueChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_image' field.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The Display selection dropdown in the Graphics settings.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Notification' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'OnDropdownItemSelected' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_dropdownItemScene' field.

Cached name for the '_currentDisplayIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Init' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'displayIndex' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Helper script to allow a Node to become anchored to this Node. Used specifically for positioning the DropdownContainers (they're tricky due to how they're layered)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnVisibilityChange' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_dropdownNode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnIndexChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'SetFullscreen' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Cached name for the 'TryRefreshHandIndices' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdateInput' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InputName' property.

Cached name for the '_bg' field.

Cached name for the '_inputLabel' field.

Cached name for the '_keyBindingLabel' field.

Cached name for the '_controllerBindingIcon' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnViewportSizeChange' method.

Cached name for the 'OnVisibilityChange' method.

Cached name for the 'SetAsListeningEntry' method.

Cached name for the '_UnhandledKeyInput' method.

Cached name for the '_Input' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_minPadding' field.

Cached name for the '_listeningEntry' field.

Cached name for the '_resetToDefaultButton' field.

Cached name for the '_commandHeader' field.

Cached name for the '_keyboardHeader' field.

Cached name for the '_controllerHeader' field.

Cached name for the '_steamInputPrompt' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Given a 3 character ISO 639-2 "like" code, initialize the language button's asset and label.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Init' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'SetAsSelected' method.

Cached name for the 'SetAsDeselected' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsSelected' property.

Cached name for the '_image' field.

Cached name for the '_outline' field.

Cached name for the '_flag' field.

Cached name for the '_label' field.

Cached name for the '_tween' field.

Cached name for the 'isoCode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The language dropdown in the OptionsScreen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'PopulateOptions' method.

Cached name for the 'OnDropdownItemSelected' method.

Cached name for the 'GetLanguageNameForCode' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CurrentLanguage' property.

Cached name for the '_dropdownItemScene' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Init' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'LanguageCode' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnValueChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Sets your 2D MSAA setting. Affects how "jagged" sprites and other 2D things look. Notably when rotated.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnIndexChanged' method.

Cached name for the 'GetMsaaLabel' method.

Cached name for the 'GetMsaa' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_image' field.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_image' field.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'UpdateShaderV' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_pageLeft' field.

Cached name for the '_image' field.

Cached name for the '_hsv' field.

Cached name for the '_paginator' field.

Cached name for the '_tween' field.

Cached name for the '_baseScale' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Base class for Paginator controls for Max FPS and Combat Speed in the settings screen. Use a dropdown if there are a lot of settings. TODO: Does this need to override NButton for controller support?

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the '_GuiInput' method.

Cached name for the 'OnIndexChanged' method.

Cached name for the 'SetIndex' method.

Cached name for the 'PageLeft' method.

Cached name for the 'PageRight' method.

Cached name for the 'IndexChangeHelper' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_vfxLabel' field.

Cached name for the '_selectionReticle' field.

Cached name for the '_currentIndex' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_image' field.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OpenPopup' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_image' field.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The resolution dropdown in the OptionsScreen.

A separate function as we repopulate the list of resolutions whenever the player changes the Display they wish to play the game on.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_Ready' method.

Cached name for the 'RefreshCurrentlySelectedResolution' method.

Cached name for the 'PopulateDropdownItems' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'RefreshEnabled' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnDropdownItemSelected' method.

Cached name for the 'DoesResolutionFit' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_dropdownItemScene' field.

Cached name for the '_arrow' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Init' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'resolution' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Cached name for the 'TryRefreshRunTimer' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnIndexChanged' method.

Cached name for the 'GetShakeMultiplier' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'ConnectSignals' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_image' field.

Cached name for the '_label' field.

Cached name for the '_selectionReticle' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The display mode dropdown in the SettingsScreen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'ConnectSignals' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_selectionReticle' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnResized' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tabContainer' field.

Cached name for the '_texture' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A script specifically used to make the Settings panels (General Settings, Graphics Settings, Audio Settings) fade in nicely

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'RefreshSize' method.

Cached name for the 'OnVisibilityChange' method.

Cached name for the 'IsSettingsOption' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Content' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_minPadding' field.

Cached name for the '_firstControl' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Should be called before adding as child!

Helper class so the localize labels function doesn't look too busy.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'SetIsInRun' method.

Cached name for the '_Ready' method.

Cached name for the 'OnSettingsTabChanged' method.

Cached name for the 'LocalizeLabels' method.

Cached name for the 'OpenModdingScreen' method.

Cached name for the 'OpenFeedbackScreen' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'OnSubmenuHidden' method.

Cached name for the 'OnSubmenuShown' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_settingsTabManager' field.

Cached name for the '_feedbackScreenButton' field.

Cached name for the '_moddingScreenButton' field.

Cached name for the '_toast' field.

Cached name for the '_isInRun' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'SettingsClosed' signal.

Cached name for the 'SettingsOpened' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the '_GuiInput' method.

Cached name for the 'OnValueChanged' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_slider' field.

Cached name for the '_valueLabel' field.

Cached name for the '_selectionReticle' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Handles the visuals for the Settings tabs in the settings screen. Click and input events are handled by the SettingsTabManager class.

A special flag as there can be a "currently selected" tab. Kind of like radio buttons I guess.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ForceTabPressed' method.

Cached name for the 'Select' method.

Cached name for the 'Deselect' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'UpdateShaderParam' method.

Cached name for the 'SetLabel' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_isSelected' field.

Cached name for the '_outline' field.

Cached name for the '_image' field.

Cached name for the '_label' field.

Cached name for the '_hsv' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Hooks up the Tab button callbacks.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ResetTabs' method.

Cached name for the 'Enable' method.

Cached name for the 'Disable' method.

Cached name for the 'TabLeft' method.

Cached name for the 'TabRight' method.

Cached name for the 'SwitchTabTo' method.

Cached name for the 'UpdateControllerButton' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CurrentlyDisplayedPanel' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_currentTab' field.

Cached name for the '_scrollContainer' field.

Cached name for the '_leftTriggerIcon' field.

Cached name for the '_rightTriggerIcon' field.

Cached name for the '_scrollbarTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'TabChanged' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'ConnectSignals' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Cached name for the '_selectionReticle' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_tween' field.

Cached name for the '_originalY' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnValueChanged' method.

Cached name for the 'OnDragEnded' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Cached name for the 'TryRefreshMapDrawings' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'GetVSyncString' method.

Cached name for the 'OnIndexChanged' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnHovered' method.

Cached name for the 'OnUnhovered' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnTick' method.

Cached name for the 'OnUntick' method.

Cached name for the 'SetFromSettings' method.

Cached name for the 'OnWindowChange' method.

Cached name for the 'RefreshEnabled' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_settingsScreen' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages the shop items for the fake merchant shop. We need this because we need to override the default controller navigation

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'UpdateNavigation' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'UpdateVisual' method.

Cached name for the 'OnInventoryOpened' method.

Cached name for the 'OnPreview' method.

Cached name for the 'CreateHoverTip' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsShowingUpgradedCard' property.

Cached name for the 'Visual' property.

Cached name for the '_saleVisual' field.

Cached name for the '_cardHolder' field.

Cached name for the '_cardNode' field.

Cached name for the '_hoverTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'UpdateVisual' method.

Cached name for the 'OnCardRemovalUsed' method.

Cached name for the 'CreateHoverTip' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Visual' property.

Cached name for the '_removalVisual' field.

Cached name for the '_animator' field.

Cached name for the '_costContainer' field.

Cached name for the '_isUnavailable' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'PlayAnimation' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ShowOnInventoryOpen' method.

Cached name for the 'ShowForPurchaseAttempt' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_dialogueBox' field.

Cached name for the '_tween' field.

Cached name for the '_bubble' field.

Cached name for the '_hsv' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the '_Process' method.

Cached name for the 'PointAtTarget' method.

Cached name for the 'StopPointing' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_startPos' field.

Cached name for the '_targetPos' field.

Cached name for the '_targetNode' field.

Cached name for the '_targetOffset' field.

Cached name for the '_noise' field.

Cached name for the '_time' field.

Cached name for the '_rug' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages the shop items for a shop.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Open' method.

Cached name for the 'SubscribeToEntries' method.

Cached name for the 'Close' method.

Cached name for the 'OnCardRemovalUsed' method.

Cached name for the 'UpdateNavigation' method.

Cached name for the 'UpdateHorizontalNavigation' method.

Cached name for the 'UpdateVerticalNavigation' method.

Cached name for the 'BlockInput' method.

Cached name for the 'UnblockInput' method.

Cached name for the 'OnActiveScreenUpdated' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsOpen' property.

Cached name for the 'MerchantHand' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_characterCardContainer' field.

Cached name for the '_colorlessCardContainer' field.

Cached name for the '_relicContainer' field.

Cached name for the '_potionContainer' field.

Cached name for the '_cardRemovalNode' field.

Cached name for the '_backButton' field.

Cached name for the '_merchantDialogue' field.

Cached name for the '_inventoryTween' field.

Cached name for the '_slotsContainer' field.

Cached name for the '_backstop' field.

Cached name for the '_inputBlocker' field.

Cached name for the '_isInputBlocked' field.

Cached name for the '_lastSlot' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'InventoryClosed' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'UpdateVisual' method.

Cached name for the 'CreateHoverTip' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Visual' property.

Cached name for the '_potionHolder' field.

Cached name for the '_potionNode' field.

Cached name for the '_potionNodePosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'UpdateVisual' method.

Cached name for the 'CreateHoverTip' method.

Cached name for the 'OnPreview' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Visual' property.

Cached name for the '_iconSize' field.

Cached name for the '_relicHolder' field.

Cached name for the '_relicNode' field.

Cached name for the '_relicNodePosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

UI wrapper class for MerchantEntry.

Used when the entry slot is purchased to ensure that the hand tries to point at it. Particularly useful for the Merchant Robes relic since purchasing the slots happens automatically.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Initialize' method.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the '_ExitTree' method.

Cached name for the '_GuiInput' method.

Cached name for the 'OnMousePressed' method.

Cached name for the 'OnMouseReleased' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'TriggerMerchantHandToPointHere' method.

Cached name for the 'OnPreview' method.

Cached name for the 'CreateHoverTip' method.

Cached name for the 'ClearHoverTip' method.

Cached name for the 'OnMerchantHandHovered' method.

Cached name for the 'OnMerchantHandUnhovered' method.

Cached name for the 'OnPurchaseFailed' method.

Cached name for the 'UpdateVisual' method.

Cached name for the 'WiggleAnimation' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hitbox' property.

Cached name for the 'Visual' property.

Cached name for the '_isHovered' field.

Cached name for the '_hitbox' field.

Cached name for the '_costLabel' field.

Cached name for the '_hoverTween' field.

Cached name for the '_purchaseFailedTween' field.

Cached name for the '_merchantRug' field.

Cached name for the '_ignoreMouseRelease' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'Hovered' signal.

Cached name for the 'Unhovered' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'RefreshUnlocked' method.

Cached name for the 'SetLockVisuals' method.

Cached name for the 'SetDateLabel' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsUnlocked' property.

Cached name for the '_border' field.

Cached name for the '_icon' field.

Cached name for the '_lock' field.

Cached name for the '_iconHsv' field.

Cached name for the '_borderHsv' field.

Cached name for the '_infoLabel' field.

Cached name for the '_date' field.

Cached name for the '_achievement' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAchievementsChanged' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ScrollLimitBottom' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_achievementsContainer' field.

Cached name for the '_scrollbarPressed' field.

Cached name for the '_startDragPos' field.

Cached name for the '_targetDragPos' field.

Cached name for the '_isDragging' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Helper function to create a Section in the StatsScreen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'LoadStats' method.

Cached name for the 'CreateSection' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_characterIcon' field.

Cached name for the '_statsContainer' field.

Cached name for the '_nameLabel' field.

Cached name for the '_unlocksLabel' field.

Cached name for the '_playtimeEntry' field.

Cached name for the '_winLossEntry' field.

Cached name for the '_streakEntry' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Helper function to create a Section in the StatsScreen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'CreateSection' method.

Cached name for the 'LoadStats' method.

Cached name for the 'SetupHoverTips' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_gridContainer' field.

Cached name for the '_achievementsEntry' field.

Cached name for the '_playtimeEntry' field.

Cached name for the '_cardsEntry' field.

Cached name for the '_winLossEntry' field.

Cached name for the '_monsterEntry' field.

Cached name for the '_relicEntry' field.

Cached name for the '_potionEntry' field.

Cached name for the '_eventsEntry' field.

Cached name for the '_streakEntry' field.

Cached name for the '_characterStatContainer' field.

Cached name for the '_screenTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_image' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'SetTopText' method.

Cached name for the 'SetBottomText' method.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Cached name for the '_imgUrl' field.

Cached name for the '_icon' field.

Cached name for the '_topLabel' field.

Cached name for the '_bottomLabel' field.

Cached name for the '_controllerFocusReticle' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OpenStatsMenu' method.

Cached name for the 'OpenAchievementsMenu' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_statsTabManager' field.

Cached name for the '_statsTab' field.

Cached name for the '_achievementsTab' field.

Cached name for the '_statsGrid' field.

Cached name for the '_screenTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ResetTabs' method.

Cached name for the '_Input' method.

Cached name for the 'SwitchToTab' method.

Cached name for the 'UpdateControllerButton' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_leftTriggerIcon' field.

Cached name for the '_rightTriggerIcon' field.

Cached name for the '_tabContainer' field.

Cached name for the '_currentTab' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Used for sorting Epochs chronologically on the Timeline. Sorted whenever we reveal an Epoch. Useful for navigating between Epochs in the Inspect screen.

The Epoch is revealed and the player has inspected it before.

The Epoch is obtained so the player is able to click on the slot in the Timeline to reveal/complete it!

This Epoch has never been obtained. Used to show empty slots, can be useful to communicate how to obtain the Epoch.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ClickedSfx' property.

Cached name for the 'Hotkeys' property.

Cached name for the '_tween' field.

Cached name for the '_label' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetDirection' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ClickedSfx' property.

Cached name for the '_tween' field.

Cached name for the '_icon' field.

Cached name for the '_isFacingRight' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ClickedSfx' property.

Cached name for the 'Hotkeys' property.

Cached name for the 'ControllerIconHotkey' property.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Visually represents an Epoch. Used when animating images of Epochs or when we have them float about in space when we unlock Epochs.

Used by the Unlock Epoch Screen

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the 'SetToWigglyUnlockPreviewMode' method.

Cached name for the 'GlowFlash' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_glow' field.

Cached name for the '_mask' field.

Cached name for the '_portrait' field.

Cached name for the '_isHovered' field.

Cached name for the '_isHoverable' field.

Cached name for the '_isHeld' field.

Cached name for the '_isWigglyUnlockPreviewMode' field.

Cached name for the '_glowTween' field.

Cached name for the '_targetScale' field.

Cached name for the '_time' field.

Cached name for the '_noiseSpeed' field.

Cached name for the '_noise' field.

Cached name for the '_denyTween' field.

Cached name for the '_transparencyTween' field.

Cached name for the '_scaleTween' field.

Cached name for the '_blueGlowColor' field.

Cached name for the '_goldGlowColor' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The screen which opens when you click on an Epoch to view the bigger image + flavor text. Note that there are two UX for this screen. One for first time open (plays the animation of the text crawling in) and the second time open, which skips this animation.

If the Epoch was revealed, we go through a slightly different UX flow (more dramatic opening of screen, queue up unlocks, etc)

The Epoch Inspect Screen was navigated to via the Chapter Navigator button.

Is called when the player opens the Epoch inspect screen by clicking on a locked node in the Timeline.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'HidePaginators' method.

Cached name for the 'Close' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Cached name for the '_Input' method.

Cached name for the 'OnMouseReleased' method.

Cached name for the 'SpeedUpTextAnimation' method.

Cached name for the 'NextChapter' method.

Cached name for the 'PrevChapter' method.

Cached name for the 'RefreshChapterPaginators' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_closeButton' field.

Cached name for the '_portrait' field.

Cached name for the '_portraitFlash' field.

Cached name for the '_mask' field.

Cached name for the '_chains' field.

Cached name for the '_portraitHsv' field.

Cached name for the '_fancyText' field.

Cached name for the '_storyLabel' field.

Cached name for the '_chapterLabel' field.

Cached name for the '_closeLabel' field.

Cached name for the '_placeholderLabel' field.

Cached name for the '_nextChapterButton' field.

Cached name for the '_prevChapterButton' field.

Cached name for the '_unlockInfo' field.

Cached name for the '_hasStory' field.

Cached name for the '_wasRevealed' field.

Cached name for the '_prevChapterButtonOffsetX' field.

Cached name for the '_nextChapterButtonOffsetX' field.

Cached name for the '_maskOffsetX' field.

Cached name for the '_maskOffsetY' field.

Cached name for the '_closeButtonY' field.

Cached name for the '_unlockTween' field.

Cached name for the '_buttonTween' field.

Cached name for the '_tween' field.

Cached name for the '_textTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ClickedSfx' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'AnimateIn' method.

Cached name for the 'AnimateOut' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_tween' field.

Cached name for the '_vfxHolder' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Called when the player clicks on a glowing + locked slot!

Called when this slot is spawned in via Timeline Expansion OR your very first time opening the Timeline. Has a fun animation.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnRelease' method.

Cached name for the 'RevealEpoch' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the '_Process' method.

Cached name for the 'DisableHighlight' method.

Cached name for the 'EnableHighlight' method.

Cached name for the 'SetState' method.

Cached name for the 'UpdateShaderS' method.

Cached name for the 'UpdateShaderV' method.

Cached name for the 'UpdateBlurLod' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ClickedSfx' property.

Cached name for the 'HoveredSfx' property.

Cached name for the 'State' property.

Cached name for the 'HasSpawned' property.

Cached name for the '_slotImage' field.

Cached name for the '_portrait' field.

Cached name for the '_chains' field.

Cached name for the '_hsv' field.

Cached name for the '_blurPortrait' field.

Cached name for the '_outline' field.

Cached name for the '_blur' field.

Cached name for the '_blurShader' field.

Cached name for the '_selectionReticle' field.

Cached name for the '_offscreenVfx' field.

Cached name for the '_highlightVfx' field.

Cached name for the '_subViewportContainer' field.

Cached name for the '_subViewport' field.

Cached name for the '_isGlowPulsing' field.

Cached name for the '_isComplete' field.

Cached name for the '_isHovered' field.

Cached name for the '_era' field.

Cached name for the 'eraPosition' field.

Cached name for the '_glowTween' field.

Cached name for the '_spawnTween' field.

Cached name for the '_hoverTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Represents a single column in the Timeline. Node which has a list of NEpochSlots, an Era icon, its name, and year.

Creates this Era Column and also the first slot for it

Epoch slot pop-up effect!

Cache the position of where we predict the Position this column will be. There's no way to forcefully refresh the layout in Godot so PredictHBoxLayout() was created and that passes in the expected position.

Behold the hack. Every time this Node's size is updated we force the position to be where it should. Note that this is called several times per frame as many children are added to the list of columns so the _isAnimated bool is actually disabled next frame.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SpawnIcon' method.

Cached name for the 'SetPredictedPosition' method.

Cached name for the 'RectChange' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_icon' field.

Cached name for the '_name' field.

Cached name for the '_year' field.

Cached name for the '_iconTween' field.

Cached name for the '_labelTween' field.

Cached name for the '_labelSpawned' field.

Cached name for the 'era' field.

Cached name for the '_prevLocalPos' field.

Cached name for the '_prevGlobalPos' field.

Cached name for the '_predictedPosition' field.

Cached name for the '_targetPosition' field.

Cached name for the '_isAnimated' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnMouseExited' method.

Cached name for the 'OnMouseEntered' method.

Cached name for the 'OnGuiInput' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_disclaimer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The slots container intercepts inputs and transforms its child node "WhatsMoved" we do this because if this Node is moved too much we can't intercept GUI inputs and such. We could probably bypass this by using _Input oops. Whatever.

Processes clicking and dragging the screen horizontally.

Processes mouse wheel to zoom in and out of the Timeline screen.

When the Timeline is opened, if there are Epochs the game will automatically center to the closest one.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the '_GuiInput' method.

Cached name for the 'ProcessPanEvent' method.

Cached name for the 'ProcessGuiFocus' method.

Cached name for the 'ProcessScrollEvent' method.

Cached name for the '_Process' method.

Cached name for the 'OnToggleVisibility' method.

Cached name for the 'Reset' method.

Cached name for the 'SetEnabled' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'GetInitX' property.

Cached name for the '_whatsMoved' field.

Cached name for the '_dragStartPosition' field.

Cached name for the '_targetPosition' field.

Cached name for the '_isDragging' field.

Cached name for the '_tween' field.

Cached name for the '_epochSlots' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

The Timeline screen allows players to reveal Epochs they've obtained to see lore and unlock content. When accessed: 1. Load progress data 2. Set up the Epoch slots 3. Control screen state logic for the SingleEpochViewScreen and UnlockScreen 4. Play any bespoke animations for Timeline expansion, etc

This is a convenience reference for static access and avoiding re-initialization and NOT a Singleton.

Only called the first time you enter the Timeline (hence the name).

Called from NTimelineTutorial once the player completes it.

Called every time this screen is opened. The Timeline is recreated from the save file each time. NOTE: If you're opening the screen for the first time, FirstTimeLogic() is called instead.

When the Timeline is opened, if there is an epoch to unlock, we lerp to it.

Creates Epoch slots and the Era columns required to hold them. This is called both when opening the screen and for Timeline expansion events (isAnimated).

Exists solely to calculate the expected position for a column during timeline expansion. This position is cached to prevent a 1 frame flicker of moving columns when the Timeline expands.

Called whenever we add new epoch slots to this screen. Expands the Timeline "line" and pops in the new Era icons if applicable.

This is the non-animated version of GrowTimelineAndAddEraIcons()

Lookup table to get the icon and name associated with a given EpochEra. Utilizes Tuples. Fancy.

Misc unlock screens just show "text"

Character unlock screen shows text and the idle animation of the character

Used by EpochModels to queue up a "Card Unlock Screen". See: IroncladUnlock1Epoch.cs

Used by EpochModels to queue up a "Relic Unlock Screen". See: Silent3Epoch.cs

Used by EpochModels to queue up a "Potion Unlock Screen".

Allows the user to pan the screen left/right if there are 4+ Epochs

Called when we open an Epoch Inspect screen. Because the backstop is transparent we do some fancy trickery.

Called when we close the Epoch Inspect screen.

Animates in the Header and Actions Available UI. Called during the first timeline expansion or on screen open (if any Epochs are slotted)

Resets all vars and nodes on this screen. Used when players back out to main menu and reopen this screen. While less safe than destroying and recreating the scene, it's more efficient.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'OnSubmenuOpened' method.

Cached name for the 'OnSubmenuClosed' method.

Cached name for the 'OnSubmenuShown' method.

Cached name for the 'OnSubmenuHidden' method.

Cached name for the '_Ready' method.

Cached name for the 'OnBackButtonPressed' method.

Cached name for the 'GetEraTexturePath' method.

Cached name for the 'GetSlot' method.

Cached name for the 'OpenInspectScreen' method.

Cached name for the 'QueueMiscUnlock' method.

Cached name for the 'SetScreenDraggability' method.

Cached name for the 'ShowBackstopAndHideUi' method.

Cached name for the 'OpenQueuedScreen' method.

Cached name for the 'IsScreenQueued' method.

Cached name for the 'IsInspectScreenQueued' method.

Cached name for the 'ShowHeaderAndActionsUi' method.

Cached name for the 'DisableInput' method.

Cached name for the 'EnableInput' method.

Cached name for the 'RefreshBackButton' method.

Cached name for the 'ResetScreen' method.

Cached name for the 'GetReminderVfxHolder' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CurrentUnlockScreen' property.

Cached name for the 'InitialFocusedControl' property.

Cached name for the '_inspectScreen' field.

Cached name for the '_reminderText' field.

Cached name for the '_reminderVfxHolder' field.

Cached name for the '_backstop' field.

Cached name for the '_inputBlocker' field.

Cached name for the '_lineContainer' field.

Cached name for the '_line' field.

Cached name for the '_epochSlotContainer' field.

Cached name for the '_slotsContainer' field.

Cached name for the '_backButton' field.

Cached name for the '_unlockScreenHolder' field.

Cached name for the '_tutorial' field.

Cached name for the '_isUiVisible' field.

Cached name for the '_queuedInspectScreen' field.

Cached name for the '_lineGrowTween' field.

Cached name for the '_backstopTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Init' method.

Cached name for the '_Ready' method.

Cached name for the 'CloseTutorial' method.

Cached name for the 'AnimateTutorial' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_text' field.

Cached name for the '_acknowledgeButton' field.

Cached name for the '_timeline' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnFocus' method.

Cached name for the '_Process' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_tween' field.

Cached name for the '_hoverTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The screen which opens when you click on an Epoch to view the bigger image + flavor text. Note that there are two UX for this screen. One for first time open (plays the animation of the text crawling in) and the second time open, which skips this animation.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'HideImmediately' method.

Cached name for the 'AnimIn' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_icon' field.

Cached name for the '_label' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Unlock screen which reveals which cards you unlocked after slotting an Epoch. We want to let players know that these cards show up on future runs and allow them to inspect each card.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Open' method.

Cached name for the 'OnScreenPreClose' method.

Cached name for the 'OnScreenClose' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_cardRow' field.

Cached name for the '_banner' field.

Cached name for the '_cardTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Unlock screen which appears after unlocking any new character

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Open' method.

Cached name for the 'OnScreenPreClose' method.

Cached name for the 'OnScreenClose' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_topLabel' field.

Cached name for the '_bottomLabel' field.

Cached name for the '_spineAnchor' field.

Cached name for the '_creatureVisuals' field.

Cached name for the '_rareGlow' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Unlock screen which appears after you place the first Epoch and you unlock the three Epochs: Neow, Silent, and Regent Epochs. Used during Timeline Expansion One (slotting Ironclad Enters) and after you slot your fourth Epoch.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Open' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_cardFlyTween' field.

Cached name for the '_infoLabel' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Unlock screen which appears after you place the first Epoch and you unlock the three Epochs: Neow, Silent, and Regent Epochs. Only used in one place lol.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Open' method.

Cached name for the 'SetUnlocks' method.

Cached name for the 'OnScreenPreClose' method.

Cached name for the 'OnScreenClose' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_textToSet' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Unlock screen which reveals which potions you unlocked after slotting an Epoch. We want to let players know that these potions show up on future runs and allow them to inspect each potions.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Open' method.

Cached name for the 'OnScreenClose' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_potionRow' field.

Cached name for the '_banner' field.

Cached name for the '_potionTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Unlock screen which reveals which relics you unlocked after slotting an Epoch. We want to let players know that these relics show up on future runs and allow them to inspect each relic.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Open' method.

Cached name for the 'OnScreenClose' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_relicRow' field.

Cached name for the '_banner' field.

Cached name for the '_relicTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Abstract class of the Unlock Screens. Used for general animation and some logistics required for the Timeline Screen. All Unlock Screens in the Timeline must use this!

Useful for UI stuff because this Node is in the Scene so the positions are accurate. See: NUnlockEpochScreen where we animate the Epochs on screen open!

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ConnectSignals' method.

Cached name for the 'Open' method.

Cached name for the 'OnScreenPreClose' method.

Cached name for the 'OnScreenClose' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_unlockConfirmButton' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Unlock screen which isn't really a screen but just an animation. Extends NUnlockScreen so it supports queueing it up like the other unlocks on the TimelineScreen.

Empty _Ready() function so we don't initialize the Confirm button like other unlock screens. Better ways to handle but w/e.

Set which era slots are unlocked when this "screen" is triggered.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Open' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Image of a literal hand. This name is kind of wonky because it's definitely not the same as NPlayerHand.

If true: Z-indexes hand to 1 so that they appear above the fight backdrop, modulates them to white regardless of whether they belong to the local player, and adjusts their pivot in preparation for throwing RPS moves. If false: undoes all the above.

If true is passed, stops the hand from following the mouse cursor (local or remote), and tweens the hand towards the edge of the screen.

Emulates a person throwing a rock-paper-scissors move; that is, the hand shakes three times, then shows an image that looks like a fist, a peace sign, or a hand with all fingers spread.

The RPS move to show. How long, in total, the three shakes should take to animate.

Sets the position at which the hand will point. If SetFrozenForRelicAwards has been called with true, then this does nothing.

Called after relic picking is done and the hand should go away.

Called when the hand is shown and we should animate it in from off-screen.

Does a small tween: scale down if true, scale up if false. Should be called when the left mouse button (local or remote) is pressed down.

Shakes the hand very dramatically and fades it out.

The amount of time to shake and fade.

Does a tween that looks like the hand is grabbing the holder. After the tween is complete, the holder will be parented to the hand.

The relic holder to grab.

Sets hand to fist.

Sets the progress of the slide-in animation, from 0 to 1. This should be used when the treasure room is opened for the first time, so that the hands do not immediately spawn on-screen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'SetIsInFight' method.

Cached name for the 'SetFrozenForRelicAwards' method.

Cached name for the 'DoFightMove' method.

Cached name for the 'SetTextureToFightMove' method.

Cached name for the 'SetPointingPosition' method.

Cached name for the 'AnimateAway' method.

Cached name for the 'AnimateIn' method.

Cached name for the 'SetIsDown' method.

Cached name for the 'SetSkipped' method.

Cached name for the 'SetAnimateInProgress' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Index' property.

Cached name for the 'IsDown' property.

Cached name for the 'IsShown' property.

Cached name for the '_grabMarker' field.

Cached name for the '_textureRect' field.

Cached name for the '_currentVelocity' field.

Cached name for the '_desiredPosition' field.

Cached name for the '_downTween' field.

Cached name for the '_state' field.

Cached name for the '_isInFight' field.

Cached name for the '_originalPosition' field.

Cached name for the '_handAnimateInProgress' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Spawns hand images at the treasure room relic picking screen.

Animates hands to a neutral space near the edges of the screen.

Z-indexes hands to 1 so that they appear above the fight backdrop, modulates them to white regardless of whether they belong to the local player, and adjusts their pivot in preparation for throwing RPS moves. Note that should happen before DoFight is called, because the hands should already be z-index up as the fight backdrop starts fading in.

Animates the hands in just before the relic picking finishes.

Animates the results of a relic picking fight. result.type must be FoughtOver, and result.fight must be non-null.

The relic fight to animate. The relic holder that is displaying result.relic.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnInputStateAdded' method.

Cached name for the 'OnInputStateRemoved' method.

Cached name for the 'AddHand' method.

Cached name for the 'OnInputStateChanged' method.

Cached name for the '_Input' method.

Cached name for the 'ProcessGuiFocus' method.

Cached name for the 'GetHand' method.

Cached name for the 'RemoveHand' method.

Cached name for the 'UpdateHandVisibility' method.

Cached name for the 'BeforeRelicsAwarded' method.

Cached name for the 'AnimateHandsIn' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_handAnimateInProgress' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Selection screen for relics at the treasure room screen. In singleplayer, this just shows one relic. In multiplayer, this shows multiple relics and handles animation that occurs after all players select a relic.

Initialize the relic display. This can't get called in _Ready because RelicPickingSynchronizer.BeginRelicPicking has not been called by then.

Await this to know when relic picking begins.

Await this to know when to hide the screen.

Animates in the relic collection.

Chest visual to fade out.

Animates out the relic collection, after relic picking is done.

Chest visual to fade back in.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'InitializeRelics' method.

Cached name for the 'SpawnEmptyChestVfx' method.

Cached name for the 'SetSelectionEnabled' method.

Cached name for the 'AnimIn' method.

Cached name for the 'AnimOut' method.

Cached name for the 'PickRelic' method.

Cached name for the 'RefreshVotes' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'SingleplayerRelicHolder' property.

Cached name for the 'DefaultFocusedControl' property.

Cached name for the '_fightBackstop' field.

Cached name for the '_fightLabel' field.

Cached name for the '_emptyVfxTween' field.

Cached name for the '_hands' field.

Cached name for the '_openedTicks' field.

Cached name for the '_isEmptyChest' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'AnimateAwayVotes' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnRelease' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Index' property.

Cached name for the 'VoteContainer' property.

Cached name for the 'Relic' property.

Cached name for the '_uncommonGlow' field.

Cached name for the '_rareGlow' field.

Cached name for the '_animatedIn' field.

Cached name for the '_tween' field.

Cached name for the '_initTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'DeferredInit' method.

Cached name for the '_ExitTree' method.

Cached name for the 'RefreshVisibility' method.

Cached name for the 'ToggleTimer' method.

Cached name for the 'OnTimerTimeout' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_timerLabel' field.

Cached name for the '_timer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'InitTopBarButton' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnRelease' method.

Cached name for the 'OnPress' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnEnable' method.

Cached name for the 'OnDisable' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateScreenOpen' method.

Cached name for the 'OnScreenClosed' method.

Cached name for the 'CancelAnimations' method.

Cached name for the 'IsOpen' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'IsScreenOpen' property.

Cached name for the '_icon' field.

Cached name for the '_hsv' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Animates rocking back and forth

Toggles the anim state of this button. Utilized when an external UI (ie BackButton) closes this screen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnPileContentsChanged' method.

Cached name for the 'OnRelease' method.

Cached name for the 'IsOpen' method.

Cached name for the '_Process' method.

Cached name for the 'ToggleAnimState' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_elapsedTime' field.

Cached name for the '_rockBaseRotation' field.

Cached name for the '_countLabel' field.

Cached name for the '_count' field.

Cached name for the '_bumpTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'OnRelease' method.

Cached name for the 'IsOpen' method.

Cached name for the 'StartOscillation' method.

Cached name for the 'StopOscillation' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Cached name for the '_oscillateTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Toggles the anim state of this button. Utilized when an external UI (ie BackButton) closes this screen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'OnRelease' method.

Cached name for the 'IsOpen' method.

Cached name for the '_Process' method.

Cached name for the 'ToggleAnimState' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Hotkeys' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'PlayGlow' method.

Cached name for the 'PlaySkulls' method.

Cached name for the 'PlayFlowers' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_isGlowOn' field.

Cached name for the '_areSkullsOn' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages the 's animations, since its 2 creatures (each of its claws) that share one big Spine file.

Resets the reaction track animationafter its current animation is finished returning control of the rig to other animation tracks

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the '_Ready' method.

Cached name for the 'PlayHurtAnim' method.

Cached name for the 'PlayArmDeathAnim' method.

Cached name for the 'PlayBodyDeathAnim' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_leftArm' field.

Cached name for the '_rightArm' field.

Cached name for the '_rightArmState' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'FollowCurve' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_bola2' field.

Cached name for the '_bola3' field.

Cached name for the '_startPosition' field.

Cached name for the '_controlPosition' field.

Cached name for the '_endPosition' field.

Cached name for the '_rotationSpeed' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Kill' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'GetEffectiveDuration' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_overlay' field.

Cached name for the '_borderGlow' field.

Cached name for the '_revealParticles' field.

Cached name for the '_shineParticles' field.

Cached name for the '_endParticles' field.

Cached name for the '_anticipationScaleCurve' field.

Cached name for the '_revealScaleCurve' field.

Cached name for the '_overlayShowDuration' field.

Cached name for the '_overlayShowShortDuration' field.

Cached name for the '_overlayIdleDuration' field.

Cached name for the '_overlayIdleShortDuration' field.

Cached name for the '_overlayHideDuration' field.

Cached name for the '_glowFadeDuration' field.

Cached name for the '_glowTopScale' field.

Cached name for the '_shineDelay' field.

Cached name for the '_endParticlesDelay' field.

Cached name for the '_cardNode' field.

Cached name for the '_tween' field.

Cached name for the '_whiteOpaque' field.

Cached name for the '_whiteClear' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Kill' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_card' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_shiv1' field.

Cached name for the '_shiv2' field.

Cached name for the '_shiv3' field.

Cached name for the '_shiv4' field.

Cached name for the '_shiv5' field.

Cached name for the '_shiv6' field.

Cached name for the '_shiv7' field.

Cached name for the '_shiv8' field.

Cached name for the '_shiv9' field.

Cached name for the '_spawnPosition' field.

Cached name for the '_spawnTween' field.

Cached name for the '_fanTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Many of this VFX are spawned via NHellraiserVfx. This represents a single sword particle and maybe useful for re-use if we want these to spawn when the Hellraiser power procs.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnTweenFinished' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Many of this VFX are spawned via NHellraiserVfx. This represents a single sword particle and maybe useful for re-use if we want these to spawn when the Hellraiser power procs.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'OnTweenFinished' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_sword' field.

Cached name for the 'posY' field.

Cached name for the 'targetColor' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Vfx for Hellraiser card. Spawns many swords and tints the screen red.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_duration' field.

Cached name for the '_swordAmount' field.

Cached name for the '_spawnPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_duration' field.

Cached name for the '_spikeAmount' field.

Cached name for the '_spawnPosition' field.

Cached name for the '_vfxColor' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Processes the jittering and rotation logic for this vfx

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'AnimateIn' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_elapsedPauseTime' field.

Cached name for the '_pauseCounter' field.

Cached name for the '_isPaused' field.

Cached name for the '_timer' field.

Cached name for the '_totalPauses' field.

Cached name for the '_canPauseTimer' field.

Cached name for the '_intensity' field.

Cached name for the '_speed' field.

Cached name for the '_duration' field.

Cached name for the '_originalRotation' field.

Cached name for the '_targetScale' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Input' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_env' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_offsetDelta' field.

Cached name for the '_noise' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Input' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_env' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Implement this on a node under NCreature to stop the NCreature from being freed until the task returned from GetDelayTask is complete

A simple vfx which renders a colorRect to tint the entire screen using an additive blend.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'SetVfxColor' method.

Cached name for the 'OnTweenFinished' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_vfxColor' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'PoofToDeath' method.

Cached name for the 'RestartTorches' method.

Cached name for the 'KillTorches' method.

Cached name for the 'PlayHit1' method.

Cached name for the 'PlayHit2' method.

Cached name for the 'PlayHit3' method.

Cached name for the 'PlayLaserBase' method.

Cached name for the 'PlayLaserHit' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_hitFxParticles' field.

Cached name for the '_hitBoneNode' field.

Cached name for the '_deathBodyParticles' field.

Cached name for the '_laserBaseParticles' field.

Cached name for the '_hitParticles1' field.

Cached name for the '_hitParticles2' field.

Cached name for the '_hitParticles3' field.

Cached name for the '_constantSparks1' field.

Cached name for the '_constantSparks2' field.

Cached name for the '_constantSparks3' field.

Cached name for the '_torch1Node' field.

Cached name for the '_torch2Node' field.

Cached name for the '_torch3Node' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartTrail' method.

Cached name for the 'EndTrail' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_parent' field.

Cached name for the '_innerTrail' field.

Cached name for the '_outerTrail' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'TurnOnDeath1' method.

Cached name for the 'TurnOnDeath2' method.

Cached name for the 'TurnOnHurt' method.

Cached name for the 'TurnOnLandingSmoke' method.

Cached name for the 'TurnOffLandingSmoke' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_hurtParticles1' field.

Cached name for the '_hurtParticles2' field.

Cached name for the '_smokeParticlesLeft' field.

Cached name for the '_smokeParticlesRight' field.

Cached name for the '_parent' field.

Cached name for the '_currentWeapon' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_target' field.

Cached name for the '_maxSegments' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnDamageChips' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_damageParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the 'OnToggleVisibility' method.

Cached name for the 'CreatePoint' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_target' field.

Cached name for the '_pointDuration' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'SetColor' method.

Cached name for the 'AdjustStartPosition' method.

Cached name for the '_ExitTree' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_startPosition' field.

Cached name for the '_movingRight' field.

Cached name for the '_vfxColor' field.

Cached name for the '_velocity' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'RotateCore' method.

Cached name for the 'ModulateParticles' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_anticipationParticles' field.

Cached name for the '_impactParticles' field.

Cached name for the '_modulateParticles' field.

Cached name for the '_corePivot' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ModulateParticles' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_slashParticles' field.

Cached name for the '_modulateParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationFinished' method.

Cached name for the 'Create' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Cached name for the '_specks' field.

Cached name for the '_creatureNode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particle' field.

Cached name for the '_velocity' field.

Cached name for the '_startPosition' field.

Cached name for the '_floorY' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'EmbossCurve' property.

Cached name for the '_tween' field.

Cached name for the '_cardNode' field.

Cached name for the '_enchantmentSparkles' field.

Cached name for the '_enchantmentIcon' field.

Cached name for the '_enchantmentLabel' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'GetDuration' method.

Cached name for the 'GetDurationInternal' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CardNode' property.

Cached name for the '_cardOwnerNode' field.

Cached name for the '_vfx' field.

Cached name for the '_swooshPath' field.

Cached name for the '_scaleTween' field.

Cached name for the '_scalingOut' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Another card soul vfx when we have no card. Used when the discard pile is shuffled into the draw pile.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_vfx' field.

Cached name for the '_fadeOutTween' field.

Cached name for the '_vfxFading' field.

Cached name for the '_startPos' field.

Cached name for the '_endPos' field.

Cached name for the '_controlPointOffset' field.

Cached name for the '_duration' field.

Cached name for the '_speed' field.

Cached name for the '_accel' field.

Cached name for the '_arcDir' field.

Cached name for the '_trailPath' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

This vfx is called when cards fly from one spot to another, leaving a pretty trail.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnCardExitedTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_card' field.

Cached name for the '_trailPath' field.

Cached name for the '_vfx' field.

Cached name for the '_fadeOutTween' field.

Cached name for the '_vfxFading' field.

Cached name for the '_isAddingToPile' field.

Cached name for the '_startPos' field.

Cached name for the '_endPos' field.

Cached name for the '_controlPointOffset' field.

Cached name for the '_duration' field.

Cached name for the '_speed' field.

Cached name for the '_accel' field.

Cached name for the '_arcDir' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'PlaySubParticles' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'SfxVolume' property.

Cached name for the '_tween' field.

Cached name for the '_willPlaySfx' field.

Cached name for the '_cardNode' field.

Cached name for the '_cardContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the 'OnToggleVisibility' method.

Cached name for the 'CreatePoint' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_parent' field.

Cached name for the '_pointDuration' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Holds both the Sprites (the card image + particle effects) and the Trails for the "card trail vfx". We need these detached so that the Trail nodes' parents don't affect the trail's positions.

Prevents the trail from emitting a ton of sparks upon reaching destination.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the 'StopParticles' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_nodeToFollow' field.

Cached name for the '_sprites' field.

Cached name for the '_updateSprites' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages full card transformations that take place in the center of the screen (ie transformations for cards in the deck/draw/discard) Centers the card and plays the transform animation. The actual transform animation logic lives in NCardTransformShineVfx

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'TurnOnDeathParticles' method.

Cached name for the 'TurnOnEnergyParticles' method.

Cached name for the 'TurnOffEnergyParticles' method.

Cached name for the 'OnPlowStart' method.

Cached name for the 'OnPlowEnd' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_deathParticles' field.

Cached name for the '_energyParticlesFront' field.

Cached name for the '_energyParticlesBack' field.

Cached name for the '_plowStartTarget' field.

Cached name for the '_plowEndTarget' field.

Cached name for the '_parent' field.

Cached name for the '_globalPlowTarget' field.

Cached name for the '_globalPlowEndTarget' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartLaser' method.

Cached name for the 'EndLaser' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_laser' field.

Cached name for the '_rings' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ApplyTint' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Cached name for the '_modulateParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ApplyTint' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Cached name for the '_modulateParticles' field.

Cached name for the '_impactDelay' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Makes the word Blocked appear over the enemy if attack damage is fully Blocked.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Vfx used to pop out numbers when we deal damage to things.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_globalSpawnPosition' field.

Cached name for the '_text' field.

Cached name for the '_tween' field.

Cached name for the '_velocity' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_rocks' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Regenerate' method.

Cached name for the 'EndRegenerate' method.

Cached name for the 'Wither' method.

Cached name for the 'OnAnimationEvent' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_damageParticleNodes' field.

Cached name for the '_particleGravity' field.

Cached name for the '_particleSpeedScale' field.

Cached name for the '_particleVelocityMinMax' field.

Cached name for the '_sprayNodes' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Animate' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartVoice' method.

Cached name for the 'StartAttack' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_voiceParticles' field.

Cached name for the '_attackParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A simple vfx which renders a colorRect to tint the entire screen using an additive blend.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'GetOrCreate' method.

Cached name for the '_Ready' method.

Cached name for the 'PlayVfx' method.

Cached name for the 'OnTweenFinished' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Sub Vfx for doom that manage the front and back particle effects (the glow, the light spears, the ground)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'FireSpear' method.

Cached name for the 'FireAllSpears' method.

Cached name for the 'ShowOrHide' method.

Cached name for the 'UpdateWidth' method.

Cached name for the 'SetVisibility' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'CurScaleX' property.

Cached name for the '_scalableLayers' field.

Cached name for the '_spears' field.

Cached name for the '_verticalShrinkingLayer' field.

Cached name for the '_particlesToKeepDense' field.

Cached name for the '_baseScales' field.

Cached name for the '_indeces' field.

Cached name for the '_baseSpearRegionWidth' field.

Cached name for the '_dumbHackBecauseOfHowTexturerectsWork' field.

Cached name for the '_rotationHackForSameDumbReason' field.

Cached name for the '_baseParticleDensity' field.

Cached name for the '_spearFixedHScale' field.

Cached name for the '_spearAngleIntensity' field.

Cached name for the '_minSpearSize' field.

Cached name for the '_maxSpearSize' field.

Cached name for the '_minSpearTime' field.

Cached name for the '_maxSpearTime' field.

Cached name for the '_outerMargin' field.

Cached name for the '_innerMargin' field.

Cached name for the '_time' field.

Cached name for the '_isOn' field.

Cached name for the '_curScaleX' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Manages the VFX for Doom (and its sub-emitters). Moves the creatures visuals into itself to handle sucking it into Hell.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_ExitTree' method.

Cached name for the '_Ready' method.

Cached name for the 'ShowOrHideParticles' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Cached name for the '_back' field.

Cached name for the '_front' field.

Cached name for the '_creatureVisuals' field.

Cached name for the '_position' field.

Cached name for the '_size' field.

Cached name for the '_shouldDie' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'LaunchSwarm' method.

Cached name for the 'CompleteSwarmAttack' method.

Cached name for the 'CancelSwarmAttack' method.

Cached name for the 'TurnOffSwarm' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_swarmParticles' field.

Cached name for the '_attackingBugParticles' field.

Cached name for the '_swarmTargetNode' field.

Cached name for the '_basePosition' field.

Cached name for the '_swarmTween' field.

Cached name for the '_swarming' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Glowing Pulse vfx for Epochs that need to be revealed by the player.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Special Vfx to help players find offscreen revealable Epochs.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_slot' field.

Cached name for the '_tween' field.

Cached name for the '_showVfx' field.

Cached name for the '_viewportSizeX' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_timer' field.

Cached name for the '_target' field.

Cached name for the '_speed' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnParticlesStart' method.

Cached name for the 'OnParticlesEnd' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'AdjustStartPosition' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_startParticles' field.

Cached name for the '_endParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'ApplyTint' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Cached name for the '_modulateParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Fire Explosion used by cards and potions

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_clouds' field.

Cached name for the '_ember' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'SetSporeTypeIsVulnerable' method.

Cached name for the 'OnAnimationStart' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_frailSpores' field.

Cached name for the '_vulnerableSpores' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartThrust' method.

Cached name for the 'EndThrust' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_thrustParicles' field.

Cached name for the '_dustLeftParticles' field.

Cached name for the '_dustRightParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'StartDebuff' method.

Cached name for the 'StopDebuff' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_debuffParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'TurnOnTrail' method.

Cached name for the 'TurnOffTrail' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_isKeyDown' field.

Cached name for the '_trailParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Creates a "toast" style popup. Used when you obtain an Epoch during gameplay.

Used to detect if this Vfx is already running. If so, delay it so we can see all of them one by one.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_epoch' field.

Cached name for the '_portrait' field.

Cached name for the '_label' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnBurst' method.

Cached name for the 'OnIdleParticles' method.

Cached name for the 'OnDissipate' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_explodePuffParticles' field.

Cached name for the '_puffParticles' field.

Cached name for the '_dotParticles' field.

Cached name for the '_bitParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_impactParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'ModulateParticles' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_impactParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'InitializePositions' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_centerParticles' field.

Cached name for the '_groundParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'Initialize' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_spotlight' field.

Cached name for the '_spotlightParticles' field.

Cached name for the '_anticipationParticles' field.

Cached name for the '_slashParticles' field.

Cached name for the '_endParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ApplyColor' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Cached name for the '_mainFire' field.

Cached name for the '_ember' field.

Cached name for the '_flameSprites' field.

Cached name for the '_vfxColor' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnEyeBubblesStart' method.

Cached name for the 'OnEyeBubblesEnd' method.

Cached name for the 'OnHeadBubblesStart' method.

Cached name for the 'OnHeadBubblesEnd' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_eyeParticles1' field.

Cached name for the '_eyeParticles2' field.

Cached name for the '_eyeParticles3' field.

Cached name for the '_headParticles1' field.

Cached name for the '_headParticles2' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Vfx used to pop out numbers when things heal.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_creatureNode' field.

Cached name for the '_text' field.

Cached name for the '_tween' field.

Cached name for the '_velocity' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_anticipationParticles' field.

Cached name for the '_impactParticles' field.

Cached name for the '_debugPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Cached name for the '_specks' field.

Cached name for the '_creatureNode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Cached name for the '_duration' field.

Cached name for the '_mat' field.

Cached name for the '_isMovingRight' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'OnParticlesStart' method.

Cached name for the 'OnParticlesEnd' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the 'ApplyRotation' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_impactStartParticles' field.

Cached name for the '_impactEndParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the 'ApplyRotation' method.

Cached name for the '_Ready' method.

Cached name for the 'ShowLaser' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_anticipationParticles' field.

Cached name for the '_laserParticles' field.

Cached name for the '_laserEndParticles' field.

Cached name for the '_laserLine' field.

Cached name for the '_laserContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnHeavySlash' method.

Cached name for the 'OnAttackSlash' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_slashStepBase' field.

Cached name for the '_slashShaderMat' field.

Cached name for the '_tween' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The base size in pixels that we want our item icon to be at.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_itemSprite' field.

Cached name for the '_flightTime' field.

Cached name for the '_heightMultiplier' field.

Cached name for the '_horizontalCurve' field.

Cached name for the '_verticalCurve' field.

Cached name for the '_rotationMultiplier' field.

Cached name for the '_rotationInfluenceCurve' field.

Cached name for the '_sourcePosition' field.

Cached name for the '_targetPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnLeftEmbersStart' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_parent' field.

Cached name for the '_explosionParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'OnChargeSteamStart' method.

Cached name for the 'OnChargeSteamEnd' method.

Cached name for the 'OnDeathSpitStart' method.

Cached name for the 'OnDeathSpitEnd' method.

Cached name for the 'OnLeftEmbersStart' method.

Cached name for the 'OnPlowChunksStart' method.

Cached name for the 'OnPlowChunksEnd' method.

Cached name for the 'OnRegenSplatsStart' method.

Cached name for the 'OnRegenSplatsEnd' method.

Cached name for the 'OnRocketThrustStart' method.

Cached name for the 'OnRocketThrustEnd' method.

Cached name for the 'OnClawLExplode' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_regenSplatParticles' field.

Cached name for the '_plowChunkParticles' field.

Cached name for the '_steamParticles1' field.

Cached name for the '_steamParticles2' field.

Cached name for the '_steamParticles3' field.

Cached name for the '_smokeParticles' field.

Cached name for the '_sparkParticles' field.

Cached name for the '_spittleParticles' field.

Cached name for the '_leftArmExplosionPosition' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartTrail1' method.

Cached name for the 'StartTrail2' method.

Cached name for the 'EndTrail1' method.

Cached name for the 'EndTrail2' method.

Cached name for the 'StartHay' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_trail1' field.

Cached name for the '_trail2' field.

Cached name for the '_hay' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Cached name for the 'Fire' method.

Cached name for the 'OnTweenComplete' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_beam' field.

Cached name for the '_beamHolder' field.

Cached name for the '_staticParticles' field.

Cached name for the '_baseBeamScale' field.

Cached name for the '_lengthTween' field.

Cached name for the '_rotationTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_cryptoParticles' field.

Cached name for the '_noiseParticles' field.

Cached name for the '_explosionBase' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartSparks' method.

Cached name for the 'EndSparks' method.

Cached name for the 'FireLaser' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_sparkParticles' field.

Cached name for the '_beamVfx' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'OnExplode' method.

Cached name for the 'OnTakeDamage' method.

Cached name for the 'OnBurningStart' method.

Cached name for the 'OnEmbersStart' method.

Cached name for the 'OnThinEmbersStart' method.

Cached name for the 'OnBurningEnd' method.

Cached name for the 'OnEmbersEnd' method.

Cached name for the 'OnThinEmbersEnd' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_fireNode1' field.

Cached name for the '_fireNode2' field.

Cached name for the '_fireNode3' field.

Cached name for the '_fireNode4' field.

Cached name for the '_explosionParticles' field.

Cached name for the '_damageParticles' field.

Cached name for the '_emberParticles' field.

Cached name for the '_thinEmberParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'GetProjectileDirection' method.

Cached name for the 'GetTopPosition' method.

Cached name for the 'Initialize' method.

Cached name for the 'ModulateParticles' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'WaitTime' property.

Cached name for the '_anticipationParticles' field.

Cached name for the '_projectileStartParticles' field.

Cached name for the '_projectileParticles' field.

Cached name for the '_impactParticles' field.

Cached name for the '_modulateParticles' field.

Cached name for the '_anticipationContainer' field.

Cached name for the '_anticipationDuration' field.

Cached name for the '_projectileContainer' field.

Cached name for the '_projectileStartPoint' field.

Cached name for the '_projectileEndPoint' field.

Cached name for the '_projectileOffset' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ExtendLaser' method.

Cached name for the 'RetractLaser' method.

Cached name for the 'ResetLaser' method.

Cached name for the 'SetLaserColor' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_animNode' field.

Cached name for the '_targetingBone' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tint' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAttackStart' method.

Cached name for the 'OnAttackEnd' method.

Cached name for the 'OnHurtStart' method.

Cached name for the 'OnHurtEnd' method.

Cached name for the 'OnDebuffStart' method.

Cached name for the 'OnDebuffEnd' method.

Cached name for the 'OnDissipate' method.

Cached name for the 'DissipateFunction' method.

Cached name for the 'OnDeathBreathStart' method.

Cached name for the 'OnDeathBreathEnd' method.

Cached name for the 'OnReconstitute' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_attackPuffParticles' field.

Cached name for the '_attackSparkParticles' field.

Cached name for the '_debuffPuffParticles' field.

Cached name for the '_gasPuffParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnDustStart' method.

Cached name for the 'OnDustStop' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_dustParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_image' field.

Cached name for the '_playAnim' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_lifeTimer' field.

Cached name for the '_particles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

VFX that plays when a remote player double-clicks a map node.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'TurnOnFlameThrower' method.

Cached name for the 'TurnOffFlameThrower' method.

Cached name for the 'TurnOnEngine' method.

Cached name for the 'TurnOffEngine' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_flameThrowerParticlesDark' field.

Cached name for the '_flameThrowerParticlesLight' field.

Cached name for the '_cinderParticles' field.

Cached name for the '_glowParticles' field.

Cached name for the '_engineParticles' field.

Cached name for the '_engineParticlesDark' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the 'Initialize' method.

Cached name for the '_Ready' method.

Cached name for the 'SetMinionVisible' method.

Cached name for the 'UpdateMinionSprite' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'SourceFinalPosition' property.

Cached name for the 'DestinationFinalPosition' property.

Cached name for the '_minionSprite' field.

Cached name for the '_minionTextures' field.

Cached name for the '_minionAnimator' field.

Cached name for the '_minionAnimations' field.

Cached name for the '_minionVfx' field.

Cached name for the '_fallingTrail' field.

Cached name for the '_fallingVfx' field.

Cached name for the '_impactVfx' field.

Cached name for the '_flightTime' field.

Cached name for the '_fallingVfxEntryTime' field.

Cached name for the '_horizontalCurve' field.

Cached name for the '_verticalCurve' field.

Cached name for the '_textureCurve' field.

Cached name for the '_maxHeight' field.

Cached name for the '_sourceOffset' field.

Cached name for the '_destinationOffset' field.

Cached name for the '_previousIndex' field.

Cached name for the '_sourcePosition' field.

Cached name for the '_destinationPosition' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_mask1' field.

Cached name for the '_reflection1' field.

Cached name for the '_mask2' field.

Cached name for the '_reflection2' field.

Cached name for the '_mask3' field.

Cached name for the '_reflection3' field.

Cached name for the '_noise' field.

Cached name for the '_totalTime' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Creates an instance of NMonsterDeathVfx for the specified creature.

The creature node. The cancellation token. The created NMonsterDeathVfx instance, or null if cancellation is requested or NCombatRoom.Instance is null.

Creates an instance of NMonsterDeathVfx for the specified creature. This should be used on creatures like the Decimillipede that are made of several different creatures that fade out together.

The creature nodes. The created NMonsterDeathVfx instance, or null if cancellation is requested or NCombatRoom.Instance is null.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartCast' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_parent' field.

Cached name for the '_targetBone' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'UpdateFlameVisibility' method.

Cached name for the 'OnScytheFlame1' method.

Cached name for the 'OnScytheFlame2' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_parent' field.

Cached name for the '_headRef' field.

Cached name for the '_scytheFireParticles1' field.

Cached name for the '_scytheFireParticles2' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'TurnOnSprayAttack' method.

Cached name for the 'TurnOffSprayAttack' method.

Cached name for the 'TurnOnSlamSpray' method.

Cached name for the 'TurnOffSlamSpray' method.

Cached name for the 'TurnOnDeathSpray' method.

Cached name for the 'TurnOffDeathSpray' method.

Cached name for the 'TurnOnDrool' method.

Cached name for the 'TurnOffDrool' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_droolParticles' field.

Cached name for the '_sprayParticles' field.

Cached name for the '_rainDropParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnParticlesStart' method.

Cached name for the 'OnParticlesEnd' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnSpewStart' method.

Cached name for the 'OnSpewEnd' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_spewParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'TurnOnInfect' method.

Cached name for the 'TurnOffInfect' method.

Cached name for the 'StartExplode' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_bubbleParticlesA' field.

Cached name for the '_bubbleParticlesB' field.

Cached name for the '_bubbleParticlesC' field.

Cached name for the '_gooParticlesDeath' field.

Cached name for the '_wormParticlesDeath' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_impactParticles' field.

Cached name for the '_horizontalSmokeContainer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_flash' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_icon' field.

Cached name for the '_iconEcho' field.

Cached name for the '_powerField' field.

Cached name for the '_amount' field.

Cached name for the '_isBuff' field.

Cached name for the '_textTween' field.

Cached name for the '_spriteTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_sprite' field.

Cached name for the '_spriteTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_sprite' field.

Cached name for the '_powerField' field.

Cached name for the '_vfxContainer' field.

Cached name for the '_textTween' field.

Cached name for the '_positionTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_timer' field.

Cached name for the '_creatureVisuals' field.

Cached name for the '_backVfx' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'StartAttack' method.

Cached name for the 'EndAttack' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_spineNode' field.

Cached name for the '_sprayParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Activate' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_blurShader' field.

Cached name for the '_vfxPosition' field.

Cached name for the '_rect' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Oscillates the rain direction from -20 to 20 degrees rapidly (exaggerated so effect can be seen clearly)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Check if we want to make sure we turn off any vfx between animations. We have to do this if the animation that is supposed to turn off the vfx is interrupted early.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'TurnOnDying' method.

Cached name for the 'TurnOnDying2' method.

Cached name for the 'TurnOffDying' method.

Cached name for the 'Explode' method.

Cached name for the 'DisableExplode' method.

Cached name for the 'Attack' method.

Cached name for the 'OnAnimationStart' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_deathParticlesArm' field.

Cached name for the '_deathParticlesChest' field.

Cached name for the '_deathParticlesBack' field.

Cached name for the '_deathParticlesLeg' field.

Cached name for the '_deathParticlesLegL' field.

Cached name for the '_explosionParticles' field.

Cached name for the '_attackParticlesSmall' field.

Cached name for the '_attackParticlesSmall2' field.

Cached name for the '_attackParticlesLarge' field.

Cached name for the '_curWeapon' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Renders 3 additive blended images of a relic above a creature

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_sprite' field.

Cached name for the '_sprite2' field.

Cached name for the '_sprite3' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Extinguish the fire. NOTE: This is public because it'll be used by front-end rest site classes in the future. Remove this note once we actually use it and Rider stops warning us.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Flicker' method.

Cached name for the 'Sway' method.

Cached name for the 'Extinguish' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_minFlickerScale' field.

Cached name for the '_maxFlickerScale' field.

Cached name for the '_minFlickerTime' field.

Cached name for the '_maxFlickerTime' field.

Cached name for the '_minSkew' field.

Cached name for the '_maxSkew' field.

Cached name for the '_minSkewTime' field.

Cached name for the '_maxSkewTime' field.

Cached name for the '_extinguishTime' field.

Cached name for the '_enabled' field.

Cached name for the '_cpuGlowParticles' field.

Cached name for the '_gpuSparkParticles' field.

Cached name for the '_baseScale' field.

Cached name for the '_baseSkew' field.

Cached name for the '_scaleTweenRef' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_clouds' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Creates VFX for rolling boulder.

The creatures that will be hit by the boulder. The amount of damage the boulder will do. Affects the size and speed of the boulder. This class does _not_ deal this damage to the creatures. If running in a test scene without NCombatRoom, this is where the creature to hit is located. VFX, or null if in tests.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'CleanUpBeforeEarlyExit' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_boulder' field.

Cached name for the '_shadow' field.

Cached name for the '_slamBehind' field.

Cached name for the '_slamFront' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'HitCreature' signal.

Cached name for the 'Finished' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_anticipationParticles' field.

Cached name for the '_impactParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_continuousParticles' field.

Cached name for the '_oneShotParticles' field.

Cached name for the '_duration' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartBubbles' method.

Cached name for the 'StartWeeds' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_bubbleParticles' field.

Cached name for the '_weedParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'ScaleCoralTo' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnDeathStart' method.

Cached name for the 'OnDeathEnd' method.

Cached name for the 'OnDarknessStart' method.

Cached name for the 'OnDarknessEnd' method.

Cached name for the 'OnChomp' method.

Cached name for the 'OnGrow' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_deathParticles' field.

Cached name for the '_buffParticles' field.

Cached name for the '_chompParticles' field.

Cached name for the '_scaleNode' field.

Cached name for the '_keyDown' field.

Cached name for the '_onState' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'ApplyTint' method.

Cached name for the 'ApplyRotation' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_throwParticles' field.

Cached name for the '_impactParticles' field.

Cached name for the '_modulateParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'DamageHandler' method.

Cached name for the 'DeathHandler' method.

Cached name for the 'PoofHandler' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles1' field.

Cached name for the '_wideParticles' field.

Cached name for the '_poofParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'Play' method.

Cached name for the 'SetFloatingDirection' method.

Cached name for the 'Stop' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_burstParticles' field.

Cached name for the '_continuousParticles' field.

Cached name for the '_zParticles' field.

Cached name for the '_localizedZTexture' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartGooParticles' method.

Cached name for the 'StopGooParticles' method.

Cached name for the 'StopVomitParticles' method.

Cached name for the 'StartVomitParticles' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_gooParticlesR' field.

Cached name for the '_gooParticlesL' field.

Cached name for the '_gooParticlesVomit' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'GetProjectileDirection' method.

Cached name for the 'GetTopPosition' method.

Cached name for the 'Initialize' method.

Cached name for the 'ModulateParticles' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'WaitTime' property.

Cached name for the '_anticipationParticles' field.

Cached name for the '_projectileStartParticles' field.

Cached name for the '_projectileParticles' field.

Cached name for the '_impactParticles' field.

Cached name for the '_modulateParticles' field.

Cached name for the '_anticipationContainer' field.

Cached name for the '_anticipationDuration' field.

Cached name for the '_projectileContainer' field.

Cached name for the '_projectileStartPoint' field.

Cached name for the '_projectileEndPoint' field.

Cached name for the '_projectileOffset' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

A nice puff of smoke used by cards and potions.

Special vfx-only enum as passing in any color can be problematic. Color treatments require bespoke tuning (i.e. the color of the associated embers)

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_clouds' field.

Cached name for the '_ember' field.

Cached name for the '_color' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'Reset' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_highlights' field.

Cached name for the '_targetColor' field.

Cached name for the '_highlightColor' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'StartCast' method.

Cached name for the 'ResetCast' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_projectileBone' field.

Cached name for the '_targetBone' field.

Cached name for the '_glowParticles' field.

Cached name for the '_blobParticles' field.

Cached name for the '_trail' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartSoundwave' method.

Cached name for the 'EndSoundwave' method.

Cached name for the 'StartBeckon' method.

Cached name for the 'EndBeckon' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_soundShaderMat' field.

Cached name for the '_beckonShaderMat' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the '_Process' method.

Cached name for the 'Forge' method.

Cached name for the 'Attack' method.

Cached name for the 'OnTargetingBegan' method.

Cached name for the 'OnTargetingEnded' method.

Cached name for the 'OnFocused' method.

Cached name for the 'OnUnfocused' method.

Cached name for the 'UpdateHoverTip' method.

Cached name for the 'FireSparks' method.

Cached name for the 'FireFlames' method.

Cached name for the 'EndSlash' method.

Cached name for the 'CleanupForge' method.

Cached name for the 'CleanupAttack' method.

Cached name for the 'RemoveSovereignBlade' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'OrbitProgress' property.

Cached name for the '_spineNode' field.

Cached name for the '_bladeGlow' field.

Cached name for the '_forgeSparks' field.

Cached name for the '_spawnFlames' field.

Cached name for the '_spawnFlamesBack' field.

Cached name for the '_slashParticles' field.

Cached name for the '_chargeParticles' field.

Cached name for the '_spikeParticles' field.

Cached name for the '_spikeParticles2' field.

Cached name for the '_spikeCircle' field.

Cached name for the '_spikeCircle2' field.

Cached name for the '_hilt' field.

Cached name for the '_hilt2' field.

Cached name for the '_detail' field.

Cached name for the '_trail' field.

Cached name for the '_orbitPath' field.

Cached name for the '_hitbox' field.

Cached name for the '_selectionReticle' field.

Cached name for the '_attackTween' field.

Cached name for the '_scaleTween' field.

Cached name for the '_sparkDelay' field.

Cached name for the '_glowTween' field.

Cached name for the '_trailFadeTween' field.

Cached name for the '_trailStart' field.

Cached name for the '_bladeSize' field.

Cached name for the '_targetOrbitPosition' field.

Cached name for the '_isBehindCharacter' field.

Cached name for the '_isFocused' field.

Cached name for the '_hoverTip' field.

Cached name for the '_isForging' field.

Cached name for the '_isAttacking' field.

Cached name for the '_isKeyPressed' field.

Cached name for the '_testCharge' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'TurnOnFire' method.

Cached name for the 'TurnOffFire' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_flameParticlesFlat' field.

Cached name for the '_flameParticlesAdd' field.

Cached name for the '_cinderParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Speech bubble vfx used when creatures talk during combat or an NPC talks in a "room" style environment (i.e. Merchant)

Creates a speech bubble given a creature. Use this when you want creatures to talk during combat!

When we want to specify the absolute position of the speech bubble vfx.

Given a creature, dynamically calculates and returns the position of where the "mouth" should be. Used during combat, where we don't know which side a creature could be on.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'SetSpeechBubbleColor' method.

Cached name for the '_ExitTree' method.

Cached name for the 'CreateInternal' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'SecondsToDisplay' property.

Cached name for the '_container' field.

Cached name for the '_label' field.

Cached name for the '_contents' field.

Cached name for the '_bubble' field.

Cached name for the '_shadow' field.

Cached name for the '_hsv' field.

Cached name for the '_tween' field.

Cached name for the '_startPos' field.

Cached name for the '_vfxColor' field.

Cached name for the '_style' field.

Cached name for the '_side' field.

Cached name for the '_text' field.

Cached name for the '_elapsedTime' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartExplosion' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_spineParticles' field.

Cached name for the '_spineSubParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Cached name for the '_tint' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_continuousParticles' field.

Cached name for the '_oneShotParticles' field.

Cached name for the '_duration' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the 'Initialize' method.

Cached name for the 'ModulateParticles' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_impactParticles' field.

Cached name for the '_poofPivot' field.

Cached name for the '_scaleRange' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Stab vfx is a silly line that goes into the creature center. Pass in the creature vfx center position!

The creature to target Whether the VFX is facing enemies The color of the VFX The created VFX instance or null if in test mode

Spawns our stab vfx in a random position to the left or right of the target.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetColor' method.

Cached name for the 'GenerateSpawnPosition' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_primaryVfx' field.

Cached name for the '_secondaryVfx' field.

Cached name for the '_creatureCenter' field.

Cached name for the '_vfxColor' field.

Cached name for the '_facingEnemies' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_label' field.

Cached name for the '_textTween' field.

Cached name for the '_positionTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_impactParticles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_emittingParticles' field.

Cached name for the '_startParticles' field.

Cached name for the '_endParticles' field.

Cached name for the '_sweepingParticles' field.

Cached name for the '_sweepingIndexCurve' field.

Cached name for the '_sweepDuration' field.

Cached name for the '_targetCenterPositions' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'PlayAnim1' method.

Cached name for the 'SquirtNeck' method.

Cached name for the 'StartDizzies' method.

Cached name for the 'EndDizzies' method.

Cached name for the 'StartEmbers' method.

Cached name for the 'StartFlames' method.

Cached name for the 'EndFlames' method.

Cached name for the 'StartBurnVfx' method.

Cached name for the 'EndBurnVfx' method.

Cached name for the 'StartCeilingSparks' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_neckParticles' field.

Cached name for the '_dizzyParticles' field.

Cached name for the '_emberParticles' field.

Cached name for the '_flameParticles' field.

Cached name for the '_burnParticles' field.

Cached name for the '_targetedBurnParticle' field.

Cached name for the '_burnParticleFountain' field.

Cached name for the '_ceilingParticles' field.

Cached name for the '_parent' field.

Cached name for the '_keyDown' field.

Cached name for the '_doingThing' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'TurnOnSaliva' method.

Cached name for the 'TurnOffSaliva' method.

Cached name for the 'TurnOnDrool' method.

Cached name for the 'TurnOffDrool' method.

Cached name for the 'TurnOnBaseBlast' method.

Cached name for the 'TurnOffBaseBlast' method.

Cached name for the 'TurnOffContinuousParticles' method.

Cached name for the 'OnAnimationStart' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_continuousParticles' field.

Cached name for the '_salivaFountainParticles' field.

Cached name for the '_salivaDroolParticles' field.

Cached name for the '_salivaCloudParticles' field.

Cached name for the '_baseBlastParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnParticlesStart' method.

Cached name for the 'OnParticlesEnd' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Thin Slice vfx will intersect the given position. Pass in the creature vfx center position!

Spawns our slash particle in a random position around the given centerPoint

Returns the angle from one vector to another in radians. Written because Vector2.AngleTo() was confusing

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'SetColor' method.

Cached name for the 'GenerateSpawnPosition' method.

Cached name for the 'GetAngle' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_slash' field.

Cached name for the '_sparkle' field.

Cached name for the '_creatureCenter' field.

Cached name for the '_vfxColor' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Thought bubble vfx used when creatures think during combat. Generally, this is the player character breaking the 4th wall. Out of energy! No more cards in the draw pile. Etc

Creates a thought bubble given a creature. Use this when you want creatures to think out loud during combat!

When we want to specify the absolute position of the thought bubble vfx.

When we want to specify the absolute position of the thought bubble vfx with an image.

Given a creature, dynamically calculates and returns the position of where the "mouth" should be. Used during combat, where we don't know which side a creature could be on.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'SetTexture' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_container' field.

Cached name for the '_label' field.

Cached name for the '_textureRect' field.

Cached name for the '_contents' field.

Cached name for the '_tail' field.

Cached name for the '_style' field.

Cached name for the '_side' field.

Cached name for the '_text' field.

Cached name for the '_texture' field.

Cached name for the '_tween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'Create' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_textureRect' field.

Cached name for the '_texture' field.

Cached name for the '_modulate' field.

Cached name for the '_spriteTween' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'OnAnimationStart' method.

Cached name for the 'DissolveTail' method.

Cached name for the 'StartSpray' method.

Cached name for the 'EndSpray' method.

Cached name for the 'StartDeathSpray' method.

Cached name for the 'EndDeathSpray' method.

Cached name for the 'DeathExplode' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_tailShaderMat' field.

Cached name for the '_sprayParticles' field.

Cached name for the '_deathSprayParticles' field.

Cached name for the '_deathSprayParticlesBack' field.

Cached name for the '_deathExplosionParticles' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFrontEvent' method.

Cached name for the 'AnimationEnded' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_frontVinesNode' field.

Cached name for the '_backVinesNode' field.

Cached name for the '_dirtBlast1' field.

Cached name for the '_dirtBlast2' field.

Cached name for the '_dirtBlast3' field.

Cached name for the '_dirtBlast4' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'StartSteam1' method.

Cached name for the 'EndSteam1' method.

Cached name for the 'StartSteam2' method.

Cached name for the 'EndSteam2' method.

Cached name for the 'StartSteam3' method.

Cached name for the 'EndSteam3' method.

Cached name for the 'StartSteam5' method.

Cached name for the 'EndSteam5' method.

Cached name for the 'StartWaterfall' method.

Cached name for the 'EndWaterfall' method.

Cached name for the 'Explode' method.

Cached name for the 'Buildup1' method.

Cached name for the 'Buildup2' method.

Cached name for the 'Buildup3' method.

Cached name for the 'ClearDeathSteam' method.

Cached name for the 'EmitGracefully' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_steam1Particles' field.

Cached name for the '_steam2Particles' field.

Cached name for the '_steam3Particles' field.

Cached name for the '_steam4Particles' field.

Cached name for the '_steam5Particles' field.

Cached name for the '_steam6Particles' field.

Cached name for the '_steamLeakParticles1' field.

Cached name for the '_steamLeakParticles2' field.

Cached name for the '_steamLeakParticles3' field.

Cached name for the '_mistParticles' field.

Cached name for the '_mouthParticles' field.

Cached name for the '_dropletParticles' field.

Cached name for the '_leakProcMat1' field.

Cached name for the '_leakProcMat2' field.

Cached name for the '_leakProcMat3' field.

Cached name for the '_isDead' field.

Cached name for the '_parent' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the 'Initialize' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Cached name for the '_centerPivot' field.

Cached name for the '_groundPivot' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Creates fullscreen VFX that occurs when healing at an event.

Creates VFX warning that the player is low. Uses NLowHpBorderVfx, but avoids creating more than one at a time.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'UpdateParticles' method.

Cached name for the 'SetProperties' method.

Cached name for the 'Unlock' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_duration' field.

Cached name for the '_particles' field.

Cached name for the '_endParticles' field.

Cached name for the '_particlesCurve' field.

Cached name for the '_brightEnabledCurve' field.

Cached name for the '_erosionEnabledCurve' field.

Cached name for the '_erosionBaseCurve' field.

Cached name for the '_previousParticleIndex' field.

Cached name for the '_asShaderMaterial' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached name for the 'OnAnimationFinished' signal.

Get the signal information for all the signals declared in this class. This method is used by Godot to register the available signals in the editor. Do not call this method.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'SetProperties' method.

Cached name for the 'Play' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_gfx' field.

Cached name for the '_duration' field.

Cached name for the '_alphaMultiplierCurve' field.

Cached name for the '_minBaseAlphaCurve' field.

Cached name for the '_erosionCurve' field.

Cached name for the '_noiseAOffsetCurve' field.

Cached name for the '_noiseBOffsetCurve' field.

Cached name for the '_originalMaterial' field.

Cached name for the '_materialCopy' field.

Cached name for the '_noiseAOffsetY' field.

Cached name for the '_noiseBOffsetY' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Cached name for the 'SetProperties' method.

Cached name for the 'RandomizeInitialOffset' method.

Cached name for the 'Play' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_duration' field.

Cached name for the '_alphaMultiplierCurve' field.

Cached name for the '_noiseOffsetCurve' field.

Cached name for the '_gradient' field.

Cached name for the '_originalMaterial' field.

Cached name for the '_materialCopy' field.

Cached name for the '_isPlaying' field.

Cached name for the '_currentTimer' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ExitTree' method.

Cached name for the 'Create' method.

Cached name for the '_Ready' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_textures' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'DoHitStop' method.

Cached name for the 'SetTimeScale' method.

Cached name for the 'EaseForStrength' method.

Cached name for the 'SecondsForDuration' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'SetEmitting' method.

Cached name for the 'Restart' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_particles' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

ScreenShake VFX script. Lives as a Node which shakes a specified Control node (_shakeTarget). Multiple effects can be stacked Can be called from anywhere using NGame.Instance.ScreenShake(), Screenpunch(), Rumble(), etc. See CombatRoom for example to attach this effect to other screens.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'SetTarget' method.

Cached name for the '_Process' method.

Cached name for the 'Shake' method.

Cached name for the 'Rumble' method.

Cached name for the 'AddTrauma' method.

Cached name for the 'ClearTarget' method.

Cached name for the 'StopRumble' method.

Cached name for the 'SetMultiplier' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ShakeTarget' property.

Cached name for the '_originalTargetPosition' field.

Cached name for the '_multiplier' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_frames' field.

Cached name for the '_fps' field.

Cached name for the '_loop' field.

Cached name for the '_randomizeRotation' field.

Cached name for the '_rotationRange' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnToggleVisibility' method.

Cached name for the '_Process' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_maxSegments' field.

Cached name for the '_parent' field.

Cached name for the '_isActive' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Plays all one shot particles in a vfx scene. Destroys the Vfx after "_lifetime" seconds.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'AfterExpired' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_lifetime' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'AnimationEnded' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_animation' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Enum to simplify params for VFX colors. See NAdditiveOverlayVfx for example.

Various VFX may allow a shorter or longer version, this enum allows specifying the duration based on feel and not exact numbers (as they may be scaled based on the game speed)

Enum to simplify params for VFX positions. See NRadialBlurVfx for example.

Sets CurrentValue. Should be used only in instances where we're loading the player from another source, such as multiplayer host.

The new value.

For creating at the start of a run.

RNG to use for rolls.

For restoring from save.

Restored value at the saved spot in the run. RNG to use for rolls.

Roll for what rarity of card should be generated. Using this will NOT modify the odds of future generated card rarities. Use for things like encounter rewards.

Odds type to roll for. What rarity a generated card should be.

Roll for what rarity of card should be generated. Using this will NOT modify the odds of future generated card rarities. Use for things like shops.

Odds type to roll for. offset for rare odds What rarity a generated card should be.

Roll for what rarity of card should be generated. Using this will use only the base odds for the given card source. Used for some events.

Odds type to roll for. What rarity a generated card should be.

Manages the odds of rolling various rarities when generating cards (encounter rewards, shops, etc.) for each player.

Manages the odds of whether or not a potion drops after beating an encounter for each player.

The percentage of normal combats that we expect to roll potions over the course of a run. While our rolling logic is more complex than this (to avoid streakiness and other game-feel reasons), we should converge on this percentage.

For creating at the start of a run.

RNG to use for rolls.

For restoring from save.

Restored value at the saved spot in the run. RNG to use for rolls.

Roll for whether or not a potion should be included in a set of rewards. Using this will modify the odds of future potion rewards.

The player who will receive the potential potion reward. Manager containing ascension level information that affects potion rewards. Room type for roll, affects bonus chance for potions. Whether or not to give a potion reward. This method implements a pity system where: - If a potion is rolled, future potion chances decrease by 10% - If a potion is not rolled, future potion chances increase by 10% - Elite rooms provide a 25% bonus chance for potions - The HookBus allows for external modification of potion reward odds

Manages the odds of what types of rooms are rolled when entering an unknown point.

Keeps track of the odds for different room types to be rolled when the player visits an unknown map point type. Note: If a room type has negative odds, that means it should NEVER be rolled, and its odds shouldn't increase as other types are rolled. This is relevant for effects like the Deadly Enemies modifier.

Contains the odds of all non-Event rooms being rolled. If we roll higher than the sum of all these odds, the result will be considered an Event room.

For creating at the start of a run.

RNG to use for rolls.

Sets the base odds for a room type. Note that this does not set the _current_ odds. It only sets what the odds get reset to when that room is rolled.

Roll for the next room type and update future odds based on what's rolled.

Room types that we shouldn't be able to roll. The state of the run that this room is being entered in. A RoomType.

Reset the odds for all room types to their base level. Called between acts.

Controls achievement unlocking.

Unlocks an achievement on the current platform and profile. Remember that the player can have multiple profiles per platform account. This unlocks the achievement on the profile's progress.save, as well as on the platform account if the account does not yet have it.

Achievement to unlock. Optional local player from when the achievement was unlocked. Will be null when unlocked outside a run (like on the main menu or after game over).

Revokes an achievement from the current player profile. Should only be used for debugging.

Returns whether an achievement is unlocked on the current player profile. Note that this does _not_ tell you whether the achievement is unlocked on the player's platform account. There is likely no scenario in which we need that, but if we do, add a new API.

Represents one of the several branches that a player could be playing on. The members are ordered from oldest build to newest build. Builds promote along the path dev-test -> private-beta -> public-beta -> public, reaching dev-test first and the public default branch last, so dev-test carries the newest build and public the oldest. The enum lists branches in the reverse of that promotion path. This order is relied on for Steam Workshop version-range comparisons, so it must match the branch order configured on the Steamworks SteamPipe > Builds page. None sorts below every real branch.

Branch was unable to be determined. This can be returned in valid cases; for instance, when not running on any platform.

Production branch. What most players are going to be playing.

Public beta branch. Accessible by the public, but they have to opt into it.

Private beta branch, i.e. what Byrdlett has access to.

Dev test branch. Only accessible to devs.

Prefer over ToString as this gives the actual branch name as displayed in Steam or other platform

Obtains the player name for the given player ID, with bracket escaping for safe use in BBCode contexts. Use when displaying in plain text controls.

Player names are untrusted external input (e.g. Steam display names) and may contain square brackets that would crash or corrupt the BBCode parser. This method escapes by default so that callers don't need to remember to escape individually. The majority of call sites render through MegaRichTextLabel or HoverTip (both BBCode), so safe-by-default prevents the class of bugs where a new call site forgets to escape. The platform type to use. Must be passed for cases where multiple platforms are supported; for instance, on PC we can play on LAN (for debug) or on Steam. The ID of the player whose name is retrieved.

Obtains the raw player name for the given player ID, without any escaping. Only use this for plain text contexts (e.g. , ). For BBCode contexts (e.g. , HoverTip), use instead.

The platform type to use. Must be passed for cases where multiple platforms are supported; for instance, on PC we can play on LAN (for debug) or on Steam. The ID of the player whose name is retrieved.

Returns the ID of the player playing on this machine.

The platform type to use. Must be passed for cases where multiple platforms are supported; for instance, on PC we can play on LAN (for debug) or on Steam.

Returns IDs of friends who are currently in lobbies that can be joined.

The platform type to use. Must be passed for cases where multiple platforms are supported; for instance, on PC we can play on LAN (for debug) or on Steam.

Returns true if OpenInviteDialog may be called on the given platform; false otherwise.

The platform type to use. Must be passed for cases where multiple platforms are supported; for instance, on PC we can play on LAN (for debug) or on Steam.

Opens the platform invite dialog for the given net service.

Opens a URL in a platform-specific browser. For example, on Steam, the URL is opened in the game overlay if available. On non-Steam PC, the URL is opened in the OS' default browser.

Opens the virtual keyboard. Does nothing on PC.

Closes the virtual keyboard.

Returns which platform branch the player is playing on.

Returns the three-letter language code for the language that the player currently has set for the primary platform.

Returns the raw string identifier of the language code that the player currently has set for primary platform.

Sets the primary rich presence display data for the player. This API is currently rather Steam-centric, so feel free to refactor later if necessary.

The key in the rich presence localization to display as the primary string. Additional key/value pairs used for substitutions can be provided through . The group to associate with. This is an arbitrary string that is used to associate players in the same multiplayer group together. Pass null if there is no multiplayer group. The size of the multiplayer group.

Sets a key-value pair used in rich presence loc string substitution. This API is currently rather Steam-centric, so feel free to refactor later if necessary.

Clears all rich presence data set for the player, including the primary display data and associated key-value pairs.

Returns the kind of fullscreening this platform allows for. See for the values.

Returns whether or not the platform overlay (ie steam overlay) is currently open

Initialization result. Failure code if Initialization was called and Initialized is false.

Cancellation token that is cancelled when Steam disconnects. Pass this to SteamCallResult to prevent async Steam API calls from hanging indefinitely when the callback pump stops.

Responsible for handling Steam-related requests to join multiplayer sessions coming from outside the game.

If the game is not yet launched and the player accepts an invite, Steam launches the game with a specific command line argument. This method handles joining the multiplayer session. It should be called relatively early after the game is launched.

Implementation of ISaveStore which saves files to Steam remote storage for syncing across devices. Note that the usage of Steam API in here can be confusing. Here's what I've actually observed happens when we write files: - Steam ALWAYS writes the file to a directory on the local computer (C:/Program Files (x86)/Steam/userdata/[appid]) - If the user has enabled steam cloud saves, then Steam additionally uploads them to the cloud In addition, if the user re-enables steam cloud saves after having them disabled, then Steam immediately looks into the local userdata directory and tries to upload those files if they're there. So, while we always write to this save store while Steam is initialized. Whether those saves get uploaded to the cloud is up to the user's settings. EXCEPTION BEHAVIOR: Methods in this class can fail in two ways: 1. Managed exceptions: Our wrapper code throws InvalidOperationException (write/read failures), FileNotFoundException (missing files), or SteamRemoteSaveStoreException (async read with non-OK EResult). The Steam API can return arbitrary EResult codes (see https://partner.steamgames.com/doc/api/steam_api#EResult), including unexpected ones after Cloud conflict resolution (e.g. k_EResultRemoteFileConflict, k_EResultBusy). 2. Native exceptions: Every method delegates through Steamworks.NET's NativeMethods P/Invoke layer into Valve's native steam_api DLL. If the native code faults, the CLR raises SEHException, which cannot be predicted or prevented from managed code. Callers must not assume a fixed set of exception types. All callers on startup-critical or gameplay paths should catch broadly to avoid fatal errors.

This controls whether files are synced from cloud to local. When the user disables steam cloud: - We still want to write files to the user's local steam cloud cache, to handle cloud conflicts later - But we never want to sync files from the user's steam cloud cache to our file storage. In essence: If the user has enabled cloud sync, then Steam cloud is the authority. If the user has disabled cloud sync, then our local storage becomes the authority. But in both instances, we wish to keep the two storages in sync. This allows players to turn off steam cloud sync in order to modify their save files.

Manages Steam user stats and global stat aggregates. Used to track per-user architect damage and fetch the global aggregate across all players.

The type of fullscreen that this platform supports.

Invalid value.

This platform supports both fullscreen and non-fullscreen.

This platform forces being in fullscreen. If the settings.save says that the game should be windowed, it is forced into fullscreen anyway (with the settings.save unchanged). The settings menu toggle will show as disabled. Used on platforms for which fullscreen may be supported depending on the current configuration; for example, Big Picture mode on a PC.

This platform only allows being in fullscreen. If the settings.save says that the game should be windowed, it is forced into fullscreen anyway. The settings menu toggle will be hidden. Used on platforms like consoles and mobile where fullscreen is never supported.

Xoshiro256** (xor, shift, rotate) pseudo-random number generator (PRNG). The original algorithm's license is as follows. ==================================================================== Written in 2018 by David Blackman and Sebastiano Vigna (vigna@acm.org) To the extent possible under law, the author has dedicated all copyright and related and neighboring rights to this software to the public domain worldwide. This software is distributed without any warranty. See . */ ===================================================================== This particular implementation is copied from the Redzen library with heavy modifications: https://github.com/colgreen/Redzen/blob/main/Redzen/Random/Xoshiro256StarStarRandom.cs The original license of the Redzen library is as follows. ===================================================================== Redzen code library. Copyright 2015-2023 Colin D. Green (colin.green1@gmail.com) This software is issued under the MIT License. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Initializes a new instance with a seed from the default seed source.

Initializes a new instance with the provided seed.

Seed value.

Splitmix64 PRNG.

PRNG state. This can take any value, including zero. A new random UInt64.

Re-initialises the random number generator state using the provided seed value.

Seed value.

Fills the provided span with random byte values, sampled from the uniform distribution with interval [0, 255].

The byte span to fill with random samples.

Get the next 64 random bits from the underlying PRNG. This method forms the foundation for most of the methods of each Next* implementation, which take these 64 bits and manipulate them to provide random values of various data types, such as integers, byte arrays, floating point values, etc.

A containing random bits from the underlying PRNG algorithm.

Returns a random integer sampled from the uniform distribution with interval [0, maxValue), i.e., exclusive of .

The maximum value to be sampled (exclusive). A new random sample.

Returns a random integer sampled from the uniform distribution with interval [minValue, maxValue), i.e., inclusive of and exclusive of .

The minimum value to be sampled (inclusive). The maximum value to be sampled (exclusive). A new random sample. maxValue must be greater than minValue. minValue may be negative.

Returns a random sampled from the uniform distribution with interval [0, 1), i.e., inclusive of 0.0 and exclusive of 1.0.

A new random sample, of type .

Returns a random integer sampled from the uniform distribution with interval [0, int.MaxValue], i.e., inclusive of .

A new random sample. This method differs from , in the following way; the uniform distribution that is sampled from includes the value .

Returns a random sampled from the uniform distribution with interval [0, uint.MaxValue], i.e., over the full range of possible uint values.

A new random sample.

Returns a random sampled from the uniform distribution with interval [0, ulong.MaxValue], i.e., over the full range of possible ulong values.

A new random sample.

Returns a random boolean sampled from the uniform discrete distribution {false, true}, i.e., a fair coin flip.

A new random sample. Returns a sample the Bernoulli distribution with p = 0.5; also known as a a fair coin flip.

Returns a random sampled from the uniform distribution with interval [0, 1), i.e., inclusive of 0.0 and exclusive of 1.0.

A new random sample, of type .

Determines per-player reward generation. This means: * What cards are generated for rewards. * What potions are generated for rewards. * Whether or not the player gets a potion reward at all.

Determines what the different shops are selling.

Determines what a transformed card will roll into,

A custom random class which allows predictable results when utilizing seeds.

A non-deterministic RNG instance. This will not produce the same results after saving and loading. Good for when we need to randomize things that don't impact gameplay. We use this instead of the GD.Rand functions because they're extremely slow when called from C#.

An ergonomic constructor for creating an RNG for a specific piece of content during a run. This RNG will be unique among: - The run (using player.RunState.Rng) - The player SLOT - The ID of the content passed This uses the player _slot index_, rather than the NetId, to ensure consistent results when playing a daily run. Because it only uses the three things above, if the player sees the same piece of content again this run, the RNG will return the same results. If that is a possibility, pass in a .

Fast-forwards the counter of this Rng. The counter is the number of times this Rng has generated a number.

Count to fast-forward to.

Returns true or false. 50/50

Get a random integer between 0 (inclusive) and maxExclusive.

1 higher than the highest allowed int. Random integer.

Get a random integer between minInclusive and maxExclusive.

Lowest allowed number. 1 higher than the maximum allowed number. Random integer.

Get a random integer between 0 (inclusive) and maxExclusive.

1 higher than the highest allowed int. Random integer.

Get a random integer between minInclusive and maxInclusive.

Lowest allowed number. 1 higher than the maximum allowed number. Random integer.

Get a random floating-point between 0 and max.

Highest allowed number. Random float.

Get a random floating-point number between min and max.

Lowest allowed number. Highest allowed number. Random float.

Get a random double-precision (double) between 0.0 (inclusive) and 1.0 (exclusive).

Random double.

Get a random double-precision floating-point number between 0 and 1.

Random double.

Generate a random floating-point number with a Gaussian distribution between min and max with the specified mean and standard deviation. See https://en.wikipedia.org/wiki/Normal_distribution for more on Gaussian distributions.

Mean for the Gaussian distribution. Standard deviation for the Gaussian distribution. Lowest allowed number. Highest allowed number. Random double with a Gaussian distribution.

Returns a random number within a normal distribution. This is used as part of the algorithm for location assignment. Mean for the Gaussian distribution. Standard deviation for the Gaussian distribution. Lowest allowed number. Highest allowed number.

Get a random item from the specified set of items.

Set of items to pull from. Type of items contained in the set. Random item.

Get a random item from the specified set of items, respecting a specified weighting function.

Set of items to pull from. Function to determine which items should be returned more/less often. Type of items contained in the set. Random item.

Get a random item from the specified set of items, respecting a specified weighting function.

Floating-point number between 0 and 1 to use for randomness. Set of items to pull from. Function to determine which items should be returned more/less often. Element to return if the weighting function fails to grab an item. Type of items contained in the set. Random item.

Shuffles a list in place using the Fisher-Yates algorithm.

The list to shuffle. Type of items in the list.

This is true if cards were manually set through the constructor, and Options has an empty card pool. The intent when this is set to true is that _cards is a static list that should not be re-populated nor changed.

Create a card reward from a specified source, using the current character's card pool and the source's rarity-rolling logic. This is the typical way one would generate a card reward for something like the end of combat.

Options used to generate the card rewards. How many choices to offer (usually 3). The player that this reward is for. PlayerChoiceSynchronizer, for injection in tests.

Create a card reward with specific cards in it. This is for exceptionally rare cases where we want to offer a very specific set of cards that ignores modification, like during the tutorial run. Note that will do nothing if called after this method.

List of cards to offer as rewards. The source of the reward. The player that this reward is for. If the options are rerolled with , then these options will be used to generate a new set of cards. PlayerChoiceSynchronizer, for injection in tests.

Called when the CardReward rolls options for the first time, and may be called again afterward to generate a new set of the same type of rewards.

The relic that this reward gives, if it's predetermined. For randomly-rolled relic rewards (like from Elite combats), this is null. For predetermined relic rewards (like from ), this is set to the predetermined relic.

The relic that this reward gives. For randomly-rolled relic rewards (like from Elite combats), this starts out null, and is populated by . For predetermined relic rewards (like from ), this is set to the predetermined relic.

The player that this reward is for.

The index to use for this reward when ordering the rewards displayed in a . Lower indexes are displayed first.

Whether this reward has been populated.

Whether the reward has successfully been taken.

If this is set, uses this rng rather than the default one used by the particular reward (Typically a player RNG) Used in the Crystal Sphere Items so that we can pass the event rng to be used and not hit state divergences in multiplayer since we don't sync the player rng sets in that case

Logic to run to populate this reward with options. For example, calling this on a CardReward would generate 3 cards for the player to choose from.

Logic to run when this reward is selected.

Whether the reward was received. Usually true, but false in certain cases (like if the player tries to take a potion when they have no more room for potions).

Create an icon node representing this reward. Null if we're in test mode.

YOU SHOULD MOST LIKELY NOT BE CALLING THIS! See . This only selects the reward on the local machine.

Represents a set of rewards that can be presented to the player. One of these is always generated at the end of combat, but events and relics can also present rewards. This class will always apply reward modifications from relics and other hooks. There are currently no cases in which you need to use this class directly. In the future, if there are complicated reward cases that are hard to build into RewardsCmd, change this class to support them.

Set by RewardsSetSynchronizer.

Associates this rewards set with a room without generating rewards for it, and allows the rewards screen to be shown even with no rewards. This determines whether the rewards screen is terminal (has a proceed button). Use to both associate a room and generate its rewards.

Generate a list of rewards to offer for the specified room. Should only be used with combat or treasure rooms.

Room to generate rewards for.

Used when custom rewards are offered, like in an event or by a relic.

Call this to disallow skipping the rewards. The player must take all the rewards before the screen is dismissed.

Populates the reward instances in Rewards, calls modify hooks on them, and returns the result. Usually you want to use Offer instead. This is mostly for tests where we inspect the rewards that are generated.

Populates the reward instances in Rewards, calls modify hooks on them, and offers the rewards to the player. If the player is not the local player, then rewards are only generated on the backend and not shown to the player.

Generates a list of default rewards to offer at the end of the specified room. This does _not_ include hook modifications, like from Prayer Wheel. Calling this may increment RNG counters and make other run state changes.

Player to generate rewards for. Room to generate rewards for. List of rewards.

A reward that adds a specific card to the player's deck. Good for events like that give specific quest cards, and for other miscellaneous spots that offer specific cards as rewards (like giving you your stolen card back as a reward).

Set an encounter to use for this reward's description. If this is not set, the default description will be used.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'ShouldTransformText' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'bbcode' property.

Cached name for the 'Bbcode' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Rotation' property.

Cached name for the 'Spacing' property.

Cached name for the 'CenterCharacter' property.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Cached name for the '_fastNoise' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_ProcessCustomFX' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'Bbcode' property.

Cached name for the 'bbcode' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

The model ID associated with this room. Non-null for combat rooms and event rooms.

Whether or not this room should load in as already finished. Used by the save/load system when the player saves after finishing a room, but before choosing a new map location to visit.

The ID of the room within the current map coordinate. This id is only unique within each map coordinate. You usually shouldn't have to use this directly; look at instead. This is not stable across save/load.

Called when this room is being entered.

The state of the run that this room is being entered in. If true, skip hooks and room visit tracking. Used when reconstructing the base of the room stack on load (e.g., pushing a parent EventRoom underneath a pre-finished CombatRoom).

Override this in implementors.

The state of the run that this room is being entered in. If true, skip hooks and room visit tracking. Used when reconstructing the base of the room stack on load (e.g., pushing a parent EventRoom underneath a pre-finished CombatRoom).

Called when this room is being exited.

The state of the run that this room is being exited in.

Called when another room is popped off the room stack, causing this to become the current room again.

The room that was exited before this was called. The state of the run that this room is being resumed in.

Is this the "Victory" room where the player meets the Architect and the run ends?

Creates the combat background for a particular encounter. If this encounter doesn't have a unique background, automatically pull the one for the act. Otherwise scrub through the the corresponding filepath and set up the background dynamically. file structure: ->scenes/backgrounds/{title} --> layers ---> {title}_bg_00_a.tscn ---> {title}_bg_01_a.tscn ---> {title}_bg_01_b.tscn ---> {title}_bg_02_a.tscn ---> {title}_bg_02_b.tscn ---> {title}_fg_a.tscn --> {title}_background.tscn notes: - the {title}_background.tscn file helps visually define how the layers are set up - the layer scenes (in the layer folder) are an asset optimization. - {title} must be exactly the same as the class name - layer files that share the same prefix (_bg_##, _fg_) are grouped together, and will be randomly chosen for the combat's background - you can have as many _bg_ layers as you want. - _bg_ layers are stacked from least to most - there is only 1 fg layer currently

Represents the visuals that should be used for a combat-style event.

The mutable encounter that the player is facing in this room.

The state of the combat that is currently in progress in this room.

Whether to create a combat room node for this combat room. Usually true, but false for "delayed-start" combats, like events with combat-style layouts that can transition to combats if certain options are selected.

If this combat room is nested within an event room, should we resume the parent event after combat ends? Usually true, but false for some combat-style events. In many of these cases, you transition from a visual-only combat room into a real combat, and then you just proceed to the next map point after combat ends.

If this combat room is nested within an event room that should resume after combat, this stores the parent event's ID so the event room can be recreated on load.

Creates a combat room for the given encounter.

Encounter that is taking place in this combat room. State of the run that this combat room is a part of.

The mode that the combat room is in. This allows for combat rooms to be used in many different scenarios. See the specific options for details.

Full combat - shows all creatures, combat UI, enables interactivity, runs hooks.

Finished combat - shows players only, no combat UI, no interactivity, no hooks. Used when loading a save after combat ended but before leaving the room.

Visual only - shows all creatures (allies and enemies) but no combat UI, no interactivity, no hooks. Used for combat-style events where enemies are visible but not yet fightable.

The canonical version of the event that the player is doing in this room. Unlike CombatRoom.Encounter, we want this to be canonical, because we create a separate mutable copy for each player.

The mutable version of the event that the local player is doing in this room. When using this, keep in mind that the

The encounter (for background, scene/slots).

Creatures to display on the ally side.

Creatures to display on the enemy side.

The act this combat room is being shown in. Used to get a fallback background scene if the encounter doesn't have one.

This is false in exactly one scenario: when Neow is not spawned as part of the player's first run

Whether this act has a second boss (Double Boss ascension mode).

This forces a specific model type to be at a specific index in a list. First, it searches for a model of type TSpecificModel in the list. If one already exists in the list, it is swapped with the model at the passed index. Otherwise, the model at the passed index is replaced a new instance of TSpecificModel. Used when setting order of specific encounters or events in the tutorial.

The list to search in. The index where the model type will be at, in the end. The type of models contained in the list. The specific kind of model we'll force to be at desiredIndex.

Represents a type of room that a player can be in. This is different from in subtle but important ways. A MapPointType represents a type of point on the map. When a player clicks on one of these points, a RoomType is "resolved". Most of the time, this resolution is straightforward: MapPointType.Monster always resolves to RoomType.Monster. MapPointType.Treasure always resolves to RoomType.Treasure. etc. However, MapPointType.Unknown ("?" on the map) can resolve to RoomType.Event, RoomType.Monster, and others. Furthermore, the current RoomType can change without the MapPointType changing. For example, imagine this sequence: The player clicks on a ? map point (MapPointType.Unknown). The room type resolves to RoomType.Event. In the event, the player selects the "Start a Fight!" option. The room type changes to RoomType.Monster. With this in mind, it's important to treat these two concepts as distinct.

Offer the normal treasure room rewards (gold, relics, etc.)

The amount of gold given to the player.

Offer extra rewards. Normally this does nothing but if extra rewards were added by a relic then this will show the rewards screen. Note that this only awaits the local player's reward task, and not everyone's.

Various flags which can be passed to the CardCreationOptions to control card generation behavior. This controls both built-in behavior (rolling for upgrades in rewards) as well as hook behavior (Molten Egg, Ruby Earrings).

Indicates that rarity should not be modified. This should be used when an event option specifies the rarity. For example, specifies that its rewards are uncommon, so no relics should modify the rarities.

Indicates that the built-in reward upgrade should not be applied. When offering combat rewards, there is a chance that cards are offered upgraded. This should not apply to most event rewards, but it does for some other rewards like those offered from .

Indicates that all modify hooks that upgrade cards should not apply their effect. Applies to things like .

Indicates that no modify hooks should be run. This is used when a modify hook itself generates a card, to prevent infinite looping. For example, uses this when generating new rewards so that it itself doesn't apply to the reward it generates.

Indicates that the card pool passed to the reward generation should not be modified. Relics like can modify the reward pool passed into the reward generation. However, relics like generate a card from a pool of only powers, which should not be modified by hooks.

Indicates that the cards passed to the reward generation should not be modified. FTUE can manually set the cards that are offered to the player. should be allowed to upgraded these cards (the player can get it if they're playing their first run in multiplayer), but Prismatic Shard should not be allowed to change the cards.

Indicates that the odds of rolling rare cards should be modified and that we should use the modified odds, even if this is not an encounter roll.

Indicates that the cards created other specifically for a card reward. It is explicitly added in . Important for relics like or that only affect card rewards.

Indicates that no upgrades should be applied to the generated card at all.

Specifies that the pool and cards generated may not be modified.

Options passed when creating cards for rewards. Various combinations of these options will do different things, so read carefully when you are using this for a new circumstance.

The card pool from which rewards will be pulled. Either must be non-empty or must be non-null.

The filter to apply to the card pool when generating rewards. We use this instead of because it allows effects that modify the available card pools (like ) to properly apply the same filter. WARNING: This cannot be serialized, so don't use this when adding extra rewards to combat rewards.

The card pool from which rewards will be pulled. Either must be non-empty or must be non-null. WARNING: This cannot be serialized, so don't use this when adding extra rewards to combat rewards.

The source from which this reward is being generated from. Used to indicate to modification hooks whether they should apply to this reward or not. For example, some relics specify that they only apply to encounter rewards, and not to rewards from events or shops.

The odds to use when generating the rarity of the cards in the reward. Hooks should look at the source to determine where the cards come from, not this.

Restrictions applied when determining what can modify the generated rewards.

If set, we use this override over the default one in the factory Used in the Crystal Sphere Items so that we can pass the event rng to be used and not hit state divergences in multiplayer since we don't sync the player rng sets in that case

Constructor which takes a card pool model.

The card pools from which rewards will be generated. The purpose for which the rewards are being generated. The odds to apply when rolling card rarities. A filter to apply to the card pool when generating rewards.

Constructor which takes a custom card pool.

The list of cards from which rewards will be generated. The purpose for which the rewards are being generated. The odds to apply when rolling card rarities.

Creates a default instance of CardCreationOptions for use in generating end-of-combat rewards or shop rewards for the given room type. Do not use this in events or relics.

Generates an instance of CardCreationOptions which can be used when generating rewards for events or relics. This uses CardRarityOddsType.RegularEncounter to generate card rarities, meaning that common cards will be far more likely to show up than rare ones.

Generates an instance of CardCreationOptions which should be used when generating rewards for events or relics. This uses CardRarityOddsType.RegularEncounter to generate card rarities, meaning that common cards will be much more likely to show up than rare ones. DO NOT use this if your custom pool only contains cards of specific rarities! CardRarityOddsType.RegularEncounter rolls for rarity, and if it lands on a rarity that your pool does not contain, then it will break. In that situation, use ForEventWithUniformOdds instead.

Generates an instance of CardCreationOptions which can be used when generating rewards for events or relics. This uses CardRarityOddsType.Uniform to generate card rarities, meaning that all cards in the pool will have an even chance of being rolled.

Get all the cards that could be created for the specified player based on this set of options.

Sets the custom pool on this instance of CardCreationOptions.

The custom pool to use when rolling rewards. The new rarity odds to use when rolling rewards. If there is only one rarity in the new custom pool, you should pass Uniform to this.

Sets the card pool on this instance of CardCreationOptions.

Sets flags on this instance of CardCreationOptions.

This card was created for a post-encounter card reward.

This card was created to be shown in a shop.

This card was created for a reward generated from an event or relic.

Sentinel value, should not be used.

Rolls for rarity as if we were generating cards for a regular encounter. Note that this does not mean that the reward was generated from an encounter. Use this in conjunction with CardCreationSource to determine that. This roll method should be used in cases where you are generating a reward that should weight more towards commons than rares (which is usually the case). Be careful not to use this or the other encounter types if you are limiting the rarity in the pool passed to the generation.

Rolls for rarity as if we were generating cards for an elite encounter. Be careful not to use this or the other encounter types if you are limiting the rarity in the pool passed to the generation.

Rolls for rarity as if we were generating cards for an boss encounter (i.e. only rare cards). Be careful not to use this or the other encounter types if you are limiting the rarity in the pool passed to the generation.

Rolls for rarity as if we were generating cards for showing in the shop.

Forces rolling all cards in the pool unweighted - rarity is not taken into account. Use this if you are limiting the rarity in the pool passed to the generation.

Extra fields that are used for specific pieces of content within a run.

Whether or not the player started the run at the Ancient. This is used to determine whether or not to show the first node in Act 1 as Neow when loading from a save. If the player starts a singleplayer run, then unlocks the Neow epoch in multiplayer and places it, we don't want to generate the map upon load with Neow in it.

Number of times the Test Subject was killed in this run. We need to save this so that it gets saved to the SerializableProgress at the end of the run.

Whether or not the player went to the event and freed Repy in this run. This is then used to determine wither to show Repy in the background of the encounter.

The kind of game mode a run is played in.

Helper method to check if epochs and achievements are allowed this run. Update once more game modes are created.

Ancient choice logs are used exclusively to to make Ancient Metrics to send to our metrics site. This makes them a bit more flexible to use than the MapPointHistoryEntry.EventChoices which are required to be LocStrings.

For serialization only

All the rooms entered in this map point. Usually contains just 1, but can contain more when one type of room transitions into another (like when the Dense Vegetation event transitions into the Wrigglers combat). Accessing index 0 will usually give you what you want, but keep an eye out for cases where you may care about other rooms entered in the same map point.

Represents a room in a map point. Since each map point can contain multiple rooms (e.g. 's ), we need multiple of these per map point.

The type of room this is. Tells us what type of model ModelId refers to.

The model id of the encounter or event at each room in this map point. ie CEREMONIAL_BEAST

The model IDs of the monsters in the encounter, if this was an encounter. This contains the actual monsters that the encounter resolved to, if the encounter has random monsters.

A scope in which cards exist.

Create a card within this scope.

Owner of the new card. Type of the new card. Newly-created card.

Create a card within this scope, based on a canonical card.

Canonical version of the new card. Owner of the new card. Newly-created card.

WARNING: If you're specifically intending to create a clone in combat for an effect like , you should use instead. Create a clone of a mutable card within this scope. The card must already have an owner.

Add a mutable card to this scope. The card must not have an owner yet.

Mutable card to add. The player who should own this card.

Remove a card from this scope. Be careful with this! Outside of tests, cards should really not be moving around between scopes.

THIS IS TEMPORARY AND SHOULD ONLY BE USED IN TESTS AND DEV CONSOLE COMMANDS.

Interface for a collection of players. Primarily used to allow mocking the player collection for testing, so we don't need to create an entire run instance to test parts of the code.

Players that are present.

The slot index of the player, or -1 if the player is not in Players. The player who has player ID playerId, or null if there is no player in Players.

The Acts in this run. Acts[0] is Act 1, Acts[1] is Act 2, etc.

The index of the current Act we're on. Act 1 has index 0, Act 2 has index 1, etc.

The current Act we're on.

The map for this run's current act. Starts out with an empty map, but should be updated during the start of the run by .

The MapCoord that we're currently at in this run. Will be null before we've entered our first map point.

The game mode that we are playing.

The MapPoint that we're currently at in this run. Will be null before we've entered our first map point.

The that we're currently at in this run.

The that we're currently at in this run.

The floor we are on in the current act. For example, on floor 1 in act 3, this will be 1.

The floor we are on with respect to the entire run. For example, on floor 1 in act 3, this will be around 34 (17 from act 1, 16 from act 2, 1 from act 3).

The number of rooms the player is currently in. This will usually be exactly 1, but here are the reasons it may be a different number: * There may be 2+ rooms when a player makes a choice that spawns a new room without traveling to a new map point. For example, in the Dense Vegetation event, when the player chooses the Rest option, a new is pushed to this stack. Then, when that combat is over, we pop that room off the stack, allowing us to return to the event. * There may be 0 rooms during brief windows, like in the middle of traveling to a new map point. Whenever we travel to a new map point, the stack of rooms is cleared and the first room for that map point is pushed onto it, so this becomes 1.

The room that we're currently in in this run. Usually the same as BaseRoom because there's usually only one room in the rooms stack. However, when there are multiple rooms in the stack (like at an event where one of the options starts a combat), this will be the last room that was entered in the current map point. Usually safe to treat as non-null, but may be null during brief windows, like while we're in the middle of traveling to a new map point.

The room at the base of the rooms stack. Usually the same as CurrentRoom because there's usually only one room in the rooms stack. However, when there are multiple rooms in the stack (like at an event where one of the options starts a combat), this will be the first room that was entered in the current map point. Usually safe to treat as non-null, but may be null during brief windows, like while we're in the middle of traveling to a new map point.

Is the run in the "game over" state? i.e. are all players dead?

The Ascension difficulty of this run.

This run's set of run-level RNGs.

This run's set of run-level odds.

The grab bag used in multiplayer for shared relic picking. When pulling relics for the shared screen where everyone chooses one relic of many, we want to attempt to pick relics that no one has. When a player pulls a relic from their individual grab bag, they also remove the relic from this grab bag. Refresh is allowed on this grab bag so that if we run out of relics of a certain rarity, duplicates are allowed to show up.

The unlock state for the run. In multiplayer, this encompasses the unlocks for _all_ players in the run. Only use this for things that are shared among players, like the shared treasure relics, or ancients. For checking player-specific unlocks, e.g. for player-specific rewards, use the unlock state on the individual players. In singleplayer, this is equivalent to the player's unlock state.

List of custom modifiers applied to this run, for daily or custom runs.

Models which unlock badges for the run.

The model used to scale various things (block, power application) in multiplayer.

The map point history for the current run. MapPointHistory[0] contains all the MapPointHistoryEntries for act 1, MapPointHistory[1] for act 2, etc.

The history entry for the current map point. Can be null for a brief period at the very start of an act, before the Ancient room has been entered.

Extra fields that are used for specific pieces of content within the run.

Convenience property so that we can easily check if we should filter out cards for singleplayer or multiplayer.

Does this state contain the specified card?

Deserialize the specified card and add it to this state.

Serialized card to deserialize. The player who should own this card.

Add the specified map point type and room type to the map point history.

The type of map point that the player selected. The type of room that the player first entered in this map point. This is usually the _only_ room that they entered in this map point (for example, if MapPointType = Monster, RoomType will always be Monster). The most common exception is for events that contain encounters. In these cases, the player will select a MapPointType = Unknown, the initial room type will be Event, but the player will later enter another RoomType (Monster) in the same map point. This isn't tracked by the map point history though, so don't worry about it here. The model ID of the encounter or event associated with the room, if any.

Get the MapPointHistoryEntry for the specified location. Can be null if the player debug-travelled to a location.

Get all the models that should have run hooks called on them.

The combat state that the players are currently in. If this is null, the players are not in combat, and we should manually return all models. If this is not null, the players are in combat, and we should manually return only non-combat models (like deck cards) while delegating the rest to the combat state.

The next room index. This is an incrementing integer that IDs the next room that the player will enter.

Find an IRunState from a list of creatures. Tries to return a concrete , but falls back to if none is found.

Identifies a coordinate on the map that the player is at. Contains an act index + map coordinate. Make sure you look at as well, which also includes a room identifier. This class is more suitable for situations where the room doesn't matter, e.g. map voting.

The act that this location is in.

The coordinate that this location is at. Will be null when we're in the map room (at the start of an act, before picking the ancient map point).

The map point history entry. The record of the player actions taken by the local player in the map point.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

The default associated with a default instance.

The source-generated options associated with this context.

Uploads run history to the metrics server. DO NOT UPLOAD WHEN: - Abandon - Not a release build - The run ended before floor 5 (these are invalid runs) For multiplayer runs, each individual player uploads their individual metrics.

Uploads a player's Settings preferences and Graphics info. This is only uploaded a single time, at the end of their 5th run. This allows players to have a chance to play and figure out which settings they want to use. This info is used to figure out which options and display settings are frequently used.

Tracks the current stats and changes experienced for a specific player at a single room.

True if a thief took gold or cards from this player this combat and did not give them back.

Records that loot was stolen from this player (gold by amount, or 1 per card).

Records that previously stolen loot was returned to this player.

"Deque" is short for Double-Ended Queue. https://en.wikipedia.org/wiki/Double-ended_queue

This is used in multiplayer for relics that are seen at a shared relic picking treasure chest. Relics that are chosen by a player are removed from their player's grab bag, and the other relics seen at the chest are moved to this dequeue. It is not used at all for the shared relic grab bag.

Check if any relics are available to pull. Used by events to determine if they should appear.

Get the front relic from the bucket of the specified rarity and remove it from the bucket. Used by most relic reward sources (elite combat rewards etc).

Rarity of the relic we want. The current run state, used to check if relics are allowed. Filter for what type of relics we are allowed to return. RelicModel

Get the back relic from the bucket of the specified rarity and remove it from the bucket. Used in shops.

Rarity of the relic we want. Filter for what type of relics we are allowed to return. The current run state, used to check if relics are allowed. RelicModel

Removes the specified relic from the bucket of the appropriate rarity so that it is never rolled. If it's already not there, then nothing happens.

Uniquely identifies a location within a run for RunLocationTargetedMessageBuffer. This location takes into account which room the player is in, which is important for multi-room locations, like those that happen in combat events. Make sure you look at as well, which identifies locations on the map without considering the room.

The act and map coordinate that the location is at.

The room index that this location is in. Zero is the root room. Any room other than zero is a sub-room, entered using RunManager.EnterRoomWithoutExitingCurrentRoom.

The ascension manager for this run.

Whether or not this run should be saved. This will always be true for normal players. For developers, it will be true when starting/continuing a run from the main menu, but false when starting from SceneBootstrapper or from tests.

If set to true, the final run score will be uploaded to the daily run leaderboard for today.

Is there currently a run in progress? True when in a run, false when on the main menu or submenus. You shouldn't usually have to check this, because most run-dependent things are only executed within the context of a run, but this is a good escape valve if you need it.

Is the run currently being cleaned up? Only true in the brief period of time after the player hits Save and Quit or abandon and IsInProgress is still true. IsInProgress maybe should also check this, but I'm scared because we're about to launch.

Discovery order modifications (e.g. boss order or enemy order) is usually disabled in multiplayer and tests. Set this to true to force them to be applied.

The run time when you beat the Act 3 boss.

The total play time of the current run. If the run has been won, will use the WinTime instead.

This flag returns true if we are in a singleplayer session or we are faking a multiplayer session. Sometimes, for testing, we add dummy players through the bootstrapper. In those cases, we still want end turn and other functions not to wait for multiple players, because there's only one acting player.

Saved maps from a loaded run, indexed by act index. Used to restore exact map topology instead of regenerating from RNG. Cleared after use to allow relics to regenerate maps normally.

Set up a brand-new singleplayer run. This includes running initialization code for things that should happen at the start of a run (obtaining the characters' starting deck and relic, setting an empty potion belt, etc.).

RunState that should be used for the run. Whether or not the run should be saved to disk. True during normal gameplay, false during tests and bootstrap. If non-null, then the final run score will be uploaded to the daily run leaderboard for the passed time.

Set up a brand-new multiplayer run. This includes running initialization code for things that should happen at the start of a run (obtaining the characters' starting deck and relic, setting an empty potion belt, etc.).

RunState that should be used for the run. The multiplayer lobby containing the players that will go on the run together. Whether or not the run should be saved to disk. True during normal gameplay, false during tests and bootstrap. If non-null, then the final run score will be uploaded to the daily run leaderboard for the passed time.

Set up a singleplayer run that's been loaded from a save file. No start-of-run initialization code will be run here, since we're loading an existing state.

RunState that should be used for the run. The serialized version of the run. This may contain extra data that's not part of the deserialized RunState.

Set up a multiplayer run that's been loaded from a save file. No start-of-run initialization code will be run here, since we're loading an existing state.

RunState that should be used for the run. The multiplayer lobby containing the players that will go on the run together. The lobby also contains the serialized version of the run. This may contain extra data that's not part of the deserialized RunState.

Set up a run that's been loaded from a CombatReplay file. No start-of-run initialization code will be run here, since we're loading an existing state.

RunState that should be used for the run. CombatReplay that is being replayed in this run. The replay also contains the serialized version of the run. This may contain extra data that's not part of the deserialized RunState.

Set up a brand-new run to be used in an automated test. Should only be used in the test project. This includes running initialization code for things that should happen at the start of a run (obtaining the characters' starting deck and relic, setting an empty potion belt, etc.).

RunState that should be used for the run. The mock INetGameService to use. Whether or not combat state synchronization should be disabled. This is only relevant if you are testing multiplayer scenarios. If true, saving will be performed. Remember to call .

Call this when starting a brand new run, not when loading a saved run.

Call this when loading a saved run, not when starting a brand new run.

Call this when we start a new run to set the StartedWithNeow extra field.

Call this to validate a save can be loaded without actually creating a run. This performs deep validation by instantiating save components to ensure all data is valid. This validation occurs AFTER JSON parsing and migration, so the save file has already been successfully deserialized. However, the content may still be invalid due to: - Removed modifiers that exist in the save - Invalid card/relic/potion IDs - Corrupted game state data If the save has any deprecated content in it, the save will be mutated so that the content is replaced with its deprecated version. This is done so that it can be sent over the network correctly in multiplayer scenarios. Unlike MigrationManager.LoadSave(), this method does not automatically handle corruption. Callers must handle exceptions and rename corrupt files as needed.

The save to attempt to load. The player ID of the local (hosting) player. If it is not in the save file, an exception is thrown.

Builds a blacklist of room types that should not be rolled for an Unknown map point, based on the connected map points.

The history entry for the previous map point. Null before we've visited the second map point. The next map points from the current one. Empty before we've visited the first map point, and after visiting the boss map point. A set of room types that should be excluded when rolling.

Finalize the relics at the start of a run. This is called when creating a new run, but not before loading a saved run, since is not idempotent.

Initialize the rooms for the run. Don't call this in Start so we can skip it in tests.

Returns true if tutorial modifications should be applied to the current run. False otherwise. Takes into account things like game mode, test mode, and singleplayer/multiplayer.

Generate a new map. This is called at the start of the run, between each act, and when relics create an entirely new map. Don't call this in Start so we can skip it in tests.

WARNING: This should only be called by and in tests.

Roll for a room type based on the specified map point type. Most map point type have an idempotent room type mapping, but unknown points need to do an RNG roll to determine room type, which is why we call this a "roll".

MapPointType to roll a RoomType for. Room types that we shouldn't be able to roll for map point types with multiple options. RoomType.

Overrides question mark rooms for the player's very first run.

Helper to call the universal "enter the room" fade in vfx.

Resets various UI elements before transitioning to the next room.

Should only be used in tests or dev commands, never in real flows.

Should only be used in tests or dev commands, never in real flows.

Room to enter. If true, skip hooks and room visit tracking. Used when reconstructing the base of the room stack on load (e.g., pushing a parent EventRoom underneath a pre-finished CombatRoom).

Exit all the rooms that the player is currently in and enter the specified room. NOTE: If you want to enter a room WITHOUT exiting the current rooms first, call instead.

Room to enter

Enter the specified room without exiting any current rooms you may be in. IMPORTANT NOTE: If you are already in a room and want to exit it first, you should call instead. If you are already in a room, this will push the new room on top of the "room stack". This is to support effects where the player should enter a new sub-room, then return to the old one when they're done. For example, if the player enters an event and selects options that start a fight, they should enter a combat room. Then, when they're done with the combat, it should be "popped off" the room stack, and they should transition back to the event.

Room that should be entered. Whether we should fade to black before entering the room. Usually true, but false when the room-change is backend only (like when transitioning from a combat-style event to a real combat).

Should only be used in and tests/debugging.

The act to set.

Update rich presence on platform for the current character/act/ascension.

This is called from NRewardsScreen when the screen is terminal. Runs the correct logic for proceeding depending on the state of the run. A rewards screen is terminal for combat rewards and treasure rooms, where proceeding from it opens up the map so you can select the next room to travel to. A rewards screen is non-terminal for things like the Calling Bell relic, which shows a rewards screen wherever you pick it up from and then lets you continue with whatever was happening in that room.

Exits the current room and resumes the previous room in the stack. This is usually called if you're in an event combat and you're returning back to the event.

Abandons the run. If in multiplayer, you should only call this on the host, and the run abandonment will be synchronized across all peers. If called on a multiplayer client, an exception will be thrown.

When you Abandon a Run you are sentenced to death.

Cleans up the run and disconnects us from any multiplayer peers.

If true, messages are allowed to be sent before closing the multiplayer connection. Pass false if the game window is being closed.

Called when the run ends.

Whether or not the run ended in a victory. The serialized version of the run that just ended.

Updates the player's DiscoveredEnemies stat when the player loses to a monster. This does _not_ update the progress save in any way! It only checks if the player has newly discovered a monster and adds it to DiscoveredEnemies if so.

Get the energy icon prefix for the local player's character. Null if there's no run in progress. An unfortunate necessity to make energy icons render properly.

THIS IS TEMPORARY AND SHOULD ONLY BE USED IN TESTS

We generate a string for the seed that gets hashed to a uint for the actual thing passed to the RNGs. This is the original string that was input, for display purposes.

The seed that was hashed from the InputSeed.

Determines everything that's generated upfront when a run first starts. This includes: * Which monsters you'll fight. * Which events you'll run into. * Which relics you'll be offered.

Determines how your draw pile gets shuffled, both at the start of combat and when you run out of cards in it.

Determines what types of room is rolled when visiting an unknown map point.

Determines what cards are generated during combat by things like Attack Potion. Distinct from CardRewards because we don't want Attack Potion usage to impact card rewards.

Determines what potions are generated during combat by things like Alchemize. Distinct from PotionRewards because these can't generate healing potions.

Determines what cards are randomly chosen during combat by things like True Grit.

Determines random in-combat energy costs for things like Confusion and Snecko Eye.

Determines the results of random targeting during combat (Bouncing Flask, Sword Boomerang, etc.).

Determines what moves each monster makes whenever there's randomness involved.

Determines some niche one-off RNG stuff that we don't care about interacting, like the modifier.

Determines what orbs are randomly chosen during combat by things like Chaos.

Determines who gets treasure when multiple players pick the same relic at the treasure room.

ONLY USE THIS FOR TESTING! Mock out the specified RNG type to use the specified seed.

See

See

See

The index of the next ID which would be returned from . Reset when we enter a new map location.

See

See

The MapCoords that have been visited within the current act.

See

See

See

See

See

See

NOTE: If in game we end up with an ability to skip rows (ie sts1 winged boots) we will have to rethink this approach.

See

See

A stack of all the rooms the player is currently in. There will usually be exactly one room in here, but here are the reasons it may be a different number: * There may be 2+ rooms in here when a player makes a choice that spawns a new room without traveling to a new map point. For example, in the Dense Vegetation event, when the player chooses the Rest option, a new is pushed to this stack. Then, when that combat is over, we pop that room off the stack, allowing us to return to the event. * There may be 0 rooms in here during brief windows, like in the middle of traveling to a new map point. Whenever we travel to a new map point, this stack is cleared and the first room for that map point is pushed onto it.

See

The room at the base of the rooms stack. Usually the same as CurrentRoom because there's usually only one room in the rooms stack. However, when there are multiple rooms in the stack (like at an event where one of the options starts a combat), this will be the first room that was entered in the current map point. Usually safe to treat as non-null, but may be null during brief windows, like while we're in the middle of traveling to a new map point.

See

See

See

See

See

See

The unlock state for the run. In multiplayer, this encompasses the unlocks for _all_ players in the run. Only use this for things that are shared among players, like the shared treasure relics, or ancients. For checking player-specific unlocks, e.g. for player-specific rewards, use the unlock state on the individual players. In singleplayer, this is equivalent to the player's unlock state.

The IDs of all the events that have been visited during this run. This allows us to avoid visiting the same shared event twice across multiple acts.

List of custom modifiers applied to this combat, for daily or custom runs.

List of badge models.

See .

All cards that have been created within this state. This allows us to keep track of "floating" cards that have not been added to a deck (like card rewards or fake cards in upgrade previews).

The model used to scale various things (block, power application) in multiplayer.

Create a RunState for a brand new run. This will connect each player up with the RunState so their starting inventory works properly.

The players that should be in the run. The mutable acts that should be in the run. The modifiers that are applied to the run. The game mode that we're playing in. The ascension level that the run should be played at. The seed that the run's RNG should use.

Load a serialized RunState.

See .

See .

See .

See .

See .

See .

See .

See

Add the specified coord to the list of visited map coords.

Pop the current room off the stack of rooms that we're in.

The removed room. If we aren't in any rooms.

Push the specified room onto the stack of rooms that we're in.

If we're already in the specified room.

Add the specified event to the list of visited events.

See .

See .

See .

Adds a player to the players in the run. This should only ever be used in debug scenarios - typically players are passed to the run in the constructor.

The player to add to the run. The index at which to add them to the list. -1 to append.

Removes any visited map coords that don't exist in the given map. Defends against old multiplayer saves (pre-v0.99.1) that had their SavedMap stripped by a canonicalization bug, causing map regeneration with different topology. The root cause is fixed but damaged saves persist.

Clears the list of visited map coords for the current act. This should only be used in debug scenarios, like when using the dev console to re-enter an act.

Adds a modifier to the list of modifiers applied to this run. This should never be used in a real game run.

Returns true if the RunState still contains a given model. Used in hook iteration to determine whether a model was removed by a different model's hook execution.

Helper functions for calculating score, badges, and the score for daily leaderboards (Also called score, very confusing!)

A sentinel value for clients in a multiplayer run to submit when uploading a daily run score. For more information on why this is needed, see .

Calculates the score for a given . Only called in the Architect room.

The run that was just completed. True if the run ended in a victory. The final score for the run.

Calculates the score for a given .

A serializable version of the run that was just completed. True if the run ended in a victory. The final score for the run.

Helper function to calculate score based on total floors climbed. Useful as we display the score on the score line as well.

Counts the total number of elites the player killed during a run.

Helper function to calculate score based on Elites killed. Useful as we display the score on the score line as well.

Counts the total number of bosses the player killed during a run.

Helper function to calculate score based on total bosses slain. Useful as we display the score on the score line as well.

Returns a list of badges that this run has obtained.

Encodes the current run into a "daily upload score". This is greatly differentiated from the score used to unlock epochs. Cursed naming.

Decodes our fancy encoded int into a struct.

TEMPORARY: This class handles the one-time migration of user data from the legacy unscoped directory structure to the new user-scoped directory structure introduced for playtesters. This migrator is designed to help existing playtesters transition their save data, replays, and console history to the new platform-specific, user-scoped directory structure without losing their progress. This class should be removed a few months after the user-scoped directory feature has been released to playtesters, once we're confident that all active users have migrated their data. The migration moves data from: - user://saves/ -> user://{platform}/{userId}/profile1/saves/ - user://replays/ -> user://{platform}/{userId}/profile1/replays/ - user://console_history.log -> user://{platform}/{userId}/profile1/console_history.log Note: Logs are intentionally NOT migrated as they remain in the legacy location (user://logs/) since Godot controls the log file creation.

Holds progress data of a specific character's statistics with an ancient.

The character this stats entry is for.

How many times this character has won a run after encountering this ancient.

How many times this character has lost a run after encountering this ancient.

How many times this character has visited this ancient.

Holds progress data on a per ancient basis.

The Id of this ancient!

Total number of visits to this ancient across all characters.

How many times the player has won a run after encountering this ancient in it.

How many times the player has lost a run after encountering this ancient in it.

Increments a run victory with this ancient.

Increments a run loss with this ancient.

Get the number of times the player has visited this ancient as the specified character.

Get the stats for this ancient and the specified character.

Holds progress data on a single Badge. Represents which badges a character has acquired. Used by CharacterStats

The badge this BadgeStat entry is for.

How many times this character has acquired this badge.

The rarity of this badge.

Holds progress data on a per card basis. Used by SerializableProgress

Holds progress data on a per character basis. Used by SerializableProgress

An implementation of ISaveStore which saves files to both local and cloud storage. This is the main entry point for cloud saves. You should not use any cloud-enabled save stores directly - instead, write and read through this abstraction layer. When files are read, they are always read from local storage. SyncCloudToLocal should be called once at the beginning of the game's lifecycle before any files are read so that you are reading the up-to-date data. CLOUD ERROR POLICY: All cloud operations are best-effort. A cloud failure must never prevent local saves from working or the game from starting. Exception handlers catch broadly (Exception, not specific types) because SteamRemoteSaveStore methods are P/Invoke calls into Valve's native steam_api DLL, which can throw SEHException at any time in addition to the managed exceptions (InvalidOperationException, SteamRemoteSaveStoreException) that our wrapper code throws.

Constructor.

The class which will be used to save to local storage. The class which will be used to save to cloud storage.

Reads a file from local storage.

Reads a file asynchronously from local storage.

Checks if a file exists in local storage.

Checks if a directory exists in local storage.

Writes a file synchronously to both local and remote storage.

Writes a file synchronously to both local and remote storage.

Writes a file asynchronously to both local and remote storage.

Writes a file asynchronously to both local and remote storage.

Deletes a file from both local and remote storage.

Renames a file in both local and remote storage. Try to avoid using this, Steam's remote storage doesn't allow atomic renaming.

Returns the files in the directory from local storage.

Returns the directories in the directory read from local storage.

Creates a directory in both local and remote storage.

Deletes a directory and any remaining contents in both local and remote storage.

Deletes temporary files from both local and remote storage.

Gets the last modified time of a file in local storage.

Gets the size of a file without reading the entire file.

Sets the last modified time of a file in local storage.

Returns the full path of a file in local storage.

Checks if the cloud storage has any files stored.

Removes a file from remote storage, but keeps it in the local storage.

Returns true if the file at the path is in remote storage. The file can also be in local storage, but this is disregarded.

Synchronizes a file from the remote to local storage. If the file exists on remote storage and the last-modified timestamp differs at all from the local one, then the local file will be overwritten with the one from remote storage. If the file doesn't exist on remote storage but does locally, then the local file will be deleted.

Synchronizes an entire directory from cloud to local storage. The rules for are followed for every file found in the given directory, first for those found on the cloud, then for those found on the local side (if any files existed locally but not in the cloud).

Overwrites the state of a file in the cloud with the state of a file on the local side. This is used when the player launches the game for the first time with cloud sync enabled. If the file exists locally, then the file on the cloud is replaced unconditionally. If the file doesn't exist locally but exists on the cloud, the file is deleted from the cloud.

The relative path to the file. If this is true, then after the file is written to the cloud, then it is forgotten immediately. See comments in for when you might use this.

Overwrites the state of a directory in the cloud with the state of a directory on the local side. This is used when the player launches the game for the first time with cloud sync enabled. The rules for are followed for every file found in the given directory, first for those found on the cloud, then for those found on the local side (if any files existed locally but not in the cloud). Files are written in order of last-modified time. Once we exceed either byteLimit or fileLimit, then files are written to the cloud storage, but they are forgotten from the remote cloud storage (not deleted, just forgotten). So why write-and-forget? Why not just... not write? Later, when we go to sync cloud files to the local storage, we need the files to exist in the remote storage. Otherwise, we'll delete the files in the local storage.

The directory to sync. The maximum number of bytes that can be written to storage. The maximum number of files that can be written to storage.

Forgets the oldest files that would cause us to go over the byte/file limit quotas. This is used when the player is writing a new run history file, which might exceed a limit that we set on the count/size of run histories.

The directory to sync. The number bytes that will be written to the new run history file. The maximum number of bytes that can be written to storage. The maximum number of files that can be written to storage.

Returns true if the file should be included in cloud sync operations. Filters out .backup files, which are local crash-recovery artifacts created by CopyBackup. These should never be uploaded to or synced from cloud storage.

Removes a .backup file that should never have been uploaded to cloud storage. These are local-only artifacts that were uploaded before OverwriteCloudWithLocalDirectory filtered them. Cleaning them up frees cloud quota.

Syncs the local file's last modified time to the cloud file's last modified time. This is best-effort: on Windows, the file can become temporarily unavailable (antivirus, cloud sync tools, file system contention) between the write and the timestamp update. A failed sync just means the next cloud sync might redundantly re-copy the file, which is harmless. Called in both the success path (to sync timestamps after a cloud write) and the failure path (to prevent SyncCloudToLocal from overwriting local with stale cloud data on next startup). Catches Exception broadly (not just IOException) because CloudStore.GetLastModifiedTime is a P/Invoke call that can throw several exception types (SEHException, InvalidOperationException, etc.). The consequence of not catching broadly here is a game crash, which is not acceptable for a timestamp sync failure.

Holds progress data on a per encounter basis. Used by SerializableProgress. Useful for the Bestiary, Statistics, Achievements, and Epochs.

How many times the player has won against this encounter.

How many times the player has died to this encounter.

Increments a victory against this encounter.

Increments a loss against this encounter.

Holds progress data on a per enemy creature basis. Used by SerializableProgress. Useful for the Bestiary, Statistics, Achievements, and Epochs.

The Id of this enemy!

How many times the player has won against this enemy.

How many times the player has died to this enemy.

Increments a victory against this enemy.

Increments a loss against this enemy.

The status of which an SerializableEpoch can be in. The states are: Revealed: Complete! Obtained: The player has met the requirements to get this AND the slot is available in the Timeline. ObtainedNoSlot: The player has met the requirements to get this but the slot isn't visible. Unobtained: The player has unlocked the slot but has not yet obtained this Epoch.

Holds progress data of a specific Character's matchup against a specific Encounter or Enemy.

The character this FightStat entry is for.

How many times this character has won against this encounter or enemy.

How many times this character has lost to this encounter or enemy.

Implements the ISaveStore interface for managing game save files within Godot. Handles file operations including reading, writing, and managing save directories. All file I/O operations related to game saves should use this class to ensure proper path handling, atomic writes, and consistent error handling across the application.

WARNING: ONLY CHANGE THIS IN TESTS. The directory that your save files live at. On Windows, these will be at: C:\Users\{USER}\AppData\Roaming\SlayTheSpire2\{platform}\{userId}\profile{profileId}\saves

Copies the current save to a .backup file using temp+rename for crash safety. The .backup serves as a fallback for the non-atomic rename on Windows and for recovery when the primary save is corrupted. Writing to a .tmp file first ensures the old .backup is preserved if a crash occurs mid-write.

Forces the OS to flush all buffered data for the specified file to the storage device. Without this, data may sit in the OS page cache and be lost on power loss or OS crash. Why .NET FileStream instead of Godot's FileAccess.Flush()? Godot's Flush() calls fflush() (see file_access_unix.cpp:322 and file_access_windows.cpp:374) which only pushes data from the C stdio buffer to the OS kernel page cache. Godot does not expose fsync/fdatasync/FlushFileBuffers anywhere in its FileAccess API. .NET's Flush(flushToDisk: true) calls fsync (Linux) / FlushFileBuffers (Windows) which forces the kernel to write to the physical device. This is a platform-dependent call and may not work on all OSes (e.g. consoles with sandboxed filesystems). On unsupported platforms, the catch block logs a warning and the save proceeds without durability guarantees (same as before this change). Console ports will need a platform-specific ISaveStore implementation in C# anyway, which can use that platform's native flush/commit API directly.

An interface used by cloud save stores, providing additional functionality on top of ISaveStore.

Returns true if any files are stored in the cloud.

Removes a file from remote storage, but keeps it in the local cache.

For implementors: Functionally, what this should do is remove the file from the cloud, freeing up cloud storage, but the file should still exist when we call ReadFile on it. WriteFile will re-upload the file to the cloud. This implementation is modeled after SteamRemoteStorage. If this proves to be problematic, feel free to re-evaluate the strategy.

Returns true if the file at the path is in remote storage. The file can also be in local storage, but this is disregarded.

Signals the cloud store that a batch of file writes is about to begin. On Steam, this calls BeginFileWriteBatch so that cloud sync is deferred until the batch ends, preventing partial sync on Steam Deck suspend.

Signals the cloud store that a batch of file writes has ended. On Steam, this calls EndFileWriteBatch so that deferred cloud sync can proceed.

Returns true if the user has enabled cloud sync. DO NOT use this to check if you should be writing files to the cloud. DO use this to check if you should be syncing files from the cloud to this machine. See for why.

Interface for all save schemas that can be serialized and migrated.

The version of the schema, used for migration purposes.

An abstraction layer around how we store save data.

Creates a directory if it doesn't already exist. Implementors must ensure that this does not throw if the directory already exists.

Deletes a directory and any remaining contents. No error is emitted if the directory doesn't already exist.

Utility for serializing and deserializing save data.

Adds a type info resolver to the resolving chain. Only used in tests to include test objects in the JSON serialization.

Serializes a save schema to JSON asynchronously.

The type of save schema The data to serialize The JSON string

Serializes a save schema to JSON.

The type of save schema The object to serialize The JSON string

Deserializes JSON to a save schema object.

The type of save schema The JSON string The deserialization result

Generate an unlock state from the current progress save.

Called after a loss. Marks the player as having lost to an encounter (not a monster).

Called after a loss. Marks the player as having lost to a specific monster in an encounter.

Called whenever a run is completed. This could be Death, Victory, or Abandon.

Check for Epoch-related unlocks at the end of each run. Singleplayer only.

If you complete a run with a character for the first time, there's generally an unlock for another character.

When the player completes Ascension 1 they unlock Character Epoch 7. This unlock grants the player the means to Kill the Architect and 3 cards.

Checks for Character5Epoch for all characters. Requires defeating 15 Elites in the game with the character.

Checks for Character6Epoch for all characters. Requires defeating 15 Bosses in the game with the character.

Helper function to obtain character unlocks 1, 2, and 3. Requires the player to defeat a boss in an act for the first time (for each character!)

Called mid-run (like when you kill a boss that unlocks an Epoch). If this Epoch's slot is available, we obtain it and return true. We return a bool so callers can log or show VFX accordingly.

Epoch to try to obtain. The local player's Player instance. True if you Obtained a new Epoch, false if not (you already have it OR the slot is unavailable).

Called post-run (like after abandoning your first run, which unlocks the Silent). If this Epoch's slot is available, we obtain it and return true. We return a bool so callers can log or show VFX accordingly.

Epoch to try to obtain. The serializable version of the local player's Player instance. The serializable version of the run. True if you Obtained a new Epoch, false if not (you already have it OR the slot is unavailable).

WARNING: This should only be called by and . If this Epoch's slot is available, we obtain it and return true. We return a bool so callers can log or show VFX accordingly.

Epoch to try to obtain. True if you Obtained a new Epoch, false if not (you already have it OR the slot is unavailable).

Returns the set of epochs that the player has both obtained and may reveal. In certain (buggy) scenarios, the player may end up obtaining epochs that are still hidden. An example scenario (though this may be fixed in the future) is: - The player joins a multiplayer daily, which allows them to play a character they have not unlocked - The player obtains an epoch for that character which they can't see on the timeline This method skips those sorts of epochs. However, it still returns epochs that are in ObtainedNoSlot state but are about to be revealed by another epoch the player has obtained.

Lots of checks and update of the progress save file after the end of each combat.

If the player wins a singleplayer run, this logic checks if they're playing on Max Ascension. If so, increment it by 1.

If the player wins a multiplayer run, this logic checks if they're playing on Max Ascension. If so, increment it by 1.

Returns true if all ftues are disabled OR if the given ftue key exists (seen by the player before). Is also disabled if there's no game (test mode)

Checks if a one-time popup has been seen before or not. This is only used by the "Ascension Unlocked" popups for now.

This should be called right after the profile ID is initialized so that there is a directory we can save run histories to.

Loads a single run history file with migration support.

The history file name (e.g., "1234567890.run") The result of the load operation

Returns a list of all the run histories that we have available to load. To actually load the history, use .

Save a run while one is currently in progress.

Save a run when you just have a SerializableRun field, independent of whether run manager has been set up yet. WARNING: Only use this if you know what you are doing This exists so we can resave a serializable run without already having a run in progress Important for resaving SerializableRun.NumReloads right after we've started a run. in most cases you should call the other SaveRun overload.

Loads the multiplayer run and canonicalizes it. In this case, "canonicalize" means that we load the save, detect any deprecated content, and replace it with the deprecated version of that model (e.g. .)

The local player ID who is loading the save.

Applies platform-specific default settings when a settings file is recreated.

The settings object to apply defaults to

A serializable form of a single line that a player has drawn on the map.

A serializable form of the drawings that all players have drawn on the map.

Converts a SerializableMapDrawings instance into a base64-encoded string that can be saved into the JSON save file. When we serialize the map drawings to a multiplayer client, we serialize it directly as a binary blob. JSON can't do this and so this class exists as an adapter. The gains from gzipping the output haven't really been measured, so if we find that it's causing performance problems we can remove it.

A serializable form of the drawings that a single player has drawn on the map. There are multiple of these in the save in multiplayer.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

The default associated with a default instance.

The source-generated options associated with this context.

Base interface for all migrations.

The version to migrate from.

The version to migrate to.

The type of save that this migration operates on.

Migrates the JsonObject from the old version to the new version.

The JsonObject to migrate The migrated JsonObject

Strongly typed interface for migrations that operate on a specific save type.

The save type to migrate

A mutable JSON representation of the data being migrated. It serves as a loosely typed mutable blob we can deserialize into and modify with our migration classes until finally parsing into the latest structured save schema. This implementation uses System.Text.Json's JsonNode instead of a custom implementation.

Creates a JSON object from a JsonDocument.

The JsonDocument to convert

Creates a JSON object from a JSON string.

The JSON string

Creates a JSON object from a JsonObject.

The JsonObject

Parses this JsonObject to a strongly typed object.

The type to convert to An instance of the specified type

Gets a property in the JSON object.

The property name The property value

Removes a property from the JSON object.

The property name to remove

Renames a property in the JSON object.

The current property name The new property name

Checks if the JSON object has a property.

The property name True if the property exists

Helper method to convert JsonNode to .NET objects

Gets a property as a specific type.

The type to convert to The property name The property value as the specified type

Gets a string value from the JSON object.

The property name The string value

Gets a boolean value from the JSON object.

The property name The boolean value

Gets an integer value from the JSON object.

The property name The integer value

Gets a nested JSON object from the JSON object.

The property name The nested JSON object

Sets a value in the JSON object.

The key to set. The value to set.

Sets a nested object property in the JSON object.

The property name The MigratingData object to set

Gets a list of objects from the JSON array.

The property name The list of objects

Gets the raw JsonNode for a property, useful for direct manipulation in migrations.

The property name The JsonNode or null if not found

Sets an array property in the JSON object.

The type of items in the array The property name The collection of items to set

Attribute used to mark a class as a migration.

The type of save that this migration operates on.

The version to migrate from.

The version to migrate to.

Creates a new migration attribute.

The type of save that this migration operates on The version to migrate from The version to migrate to

Base class for migrations that automatically derives migration properties from the Migration attribute and uses JsonObject for migration operations.

The save type to migrate

The version to migrate from. Derived from the Migration attribute.

The version to migrate to. Derived from the Migration attribute.

The type of save that this migration operates on. Derived from the Migration attribute.

Migrates the JSON object from the old version to the new version.

The JSON object to migrate The migrated JSON object

Implement this in derived classes to modify the JSON object.

The JSON object to modify

Exception thrown when a migration fails.

Exception thrown when a schema version is missing from a save file.

Base exception for migration path validation failures.

Exception thrown when there are gaps in the migration path.

Exception thrown when there are duplicate migrations from the same version.

Manages save schema migrations and version tracking. This class combines functionality previously spread across MigrationRegistry, SaveSystemBootstrap, and migration logic from SaveManager.

Initializes a new instance of the class.

The save store to use for file operations

Initializes the migration system, registering migrations and setting current versions.

Thrown when migration paths are invalid

Derives the latest version numbers dynamically from registered migrations.

Ensures that a version is set for the specified save type.

The save type

Validates migration paths for gaps and duplicates.

Thrown when migration paths have gaps Thrown when migration paths have duplicates

Gets a list of version numbers that represent gaps in the migration path. A gap is defined as a version that is a target in one migration but not a source in any migration, except for the highest version which is expected to be only a target.

The save type to check A list of version numbers that represent gaps

Gets a list of version numbers that are sources for multiple migrations. This indicates a conflict in the migration path.

The save type to check A list of version numbers that are sources for multiple migrations

Checks if the migration path for a specific save type is valid. Throws the same exceptions as ValidateMigrationPaths for consistency.

The save type to check True if the migration path is valid Thrown when migration paths have gaps Thrown when migration paths have duplicates

Registers a migration.

The migration to register

Sets the minimum supported schema version for a specific save type.

The save type The minimum supported version

Gets the current schema version for a specific save type.

The save type that implements the ISaveSchema interface The current version number for the specified save type Thrown when no migrations are found for the specified save type

Gets the minimum supported schema version for a specific save type.

The save type The minimum supported version Thrown when no minimum supported version has been set

Gets a migration for a specific save type and version.

The save type The version to migrate from The version to migrate to (used only for validation) The migration, or null if no migration exists

Gets the next available version in the migration chain.

The save type that implements the ISaveSchema interface The current version number to find the next version for The next version number if a migration exists, or null if no migration is available

Gets all registered save types that have migrations.

The save types

Gets all registered migrations for a specific save type.

The save type The migrations

Extracts the schema version from a JsonObject.

The JsonObject to extract the version from The schema version Thrown when the schema version is not found

Creates a new save instance with the latest schema version for the type.

The save type New save instance with current schema version

Preserves a corrupted save file using standardized naming convention.

The path to the corrupt save file The reason for corruption

Determines if a corrupt file should be preserved based on the status.

The read save status True if the file should be preserved as corrupt

Loads save data with aggressive recovery attempts, falling back to a .backup if the primary file is missing or corrupt. This covers the case where a non-atomic rename on Windows (delete-then-move) lost the primary file during a power failure. Does NOT create new saves or modify files - that's the caller's responsibility. All recovery operations happen in memory only, preserving original files for debugging.

The type of save data The path to the save file ReadSaveResult with save data or error status

Loads save data from a single file path with aggressive recovery attempts.

Attempts to load save data with aggressive recovery attempts, including migration and repair. Uses multiple fallback strategies: schema version inference, sequential migrations, JSON repair, and data scavenging.

The type of save data The path to the save file (for logging) The file content to parse ReadSaveResult with save data or error status

Attempts to infer schema version from save structure

The save type The save data to examine Inferred version or null if can't infer

Attempts to scavenge usable data from corrupted/old saves by stamping the current schema version and deserializing directly. Unknown fields are silently skipped; missing fields get C# defaults. SerializableRun is excluded because defaulted combat state (0 HP, empty deck) causes gameplay bugs.

The save type The save data to scavenge from Scavenged save object or null if nothing can be salvaged

Attempts basic JSON repair (fix common issues like trailing commas, missing brackets). Limited to safe, conservative repairs only.

The JSON content to repair Repaired JSON string or null if repair failed

Migrates save data using JsonObject.

The type of save data to migrate The JsonObject to migrate The migrated JsonObject Thrown when a migration cannot be found or fails

Registry for save migrations. This class will eventually be auto-generated by a source generator.

IMPORTANT: This is a temporary reflection-based implementation. Eventually, this class will be generated at compile time by a source generator that scans for all classes with the [Migration] attribute.

Registers all migrations with the migration manager.

The migration manager to register migrations with

No-op migration for release save wipe. All pre-release saves are invalidated via minimum supported version bump.

No-op migration for release save wipe. All pre-release saves are invalidated via minimum supported version bump.

No-op migration for release save wipe. All pre-release saves are invalidated via minimum supported version bump.

No-op migration for release save wipe. All pre-release saves are invalidated via minimum supported version bump.

Migrates renamed/deleted ModelIds in completed run history saves. Same renames as SerializableRunV15ToV16, applied to the RunHistory schema.

No-op migration for release save wipe. All pre-release saves are invalidated via minimum supported version bump.

SerializableReward.CardPoolId (singular) changed to CardPoolIds (plural).

Added GameMode. It defaults to None for error-checking purposes, but for existing real runs, it should default to something reasonable.

Migrates renamed/deleted ModelIds: - CARD.PREPARE -> CARD.PREPARED (class Prepare renamed back to Prepared) - ENCOUNTER.TOADPOLES_NORMAL -> ENCOUNTER.SEAPUNK_NORMAL (class ToadpolesNormal renamed to SeapunkNormal) - MONSTER.DOOR -> MONSTER.DEPRECATED_MONSTER (Door monster deleted in Doormaker rework)

No-op migration for release save wipe. All pre-release saves are invalidated via minimum supported version bump.

Renames used by SerializableRun V15->V16 and RunHistory V8->V9.

Recursively walks a JSON tree and replaces string values found in the renames dictionary.

Used in Run History V2->V3 and SerializableRun V3->V4. migratingData is assumed to be the list of list of MapPointHistoryEntry.

Recursively removes schema_version from everything except for the first JSON object.

Contains utilities for moving files around during a migration of the save directory location.

This class serves as a schema for the Preferences save file. It's used for serializing and deserializing data in the options screen. This file is synced across devices/platforms. It is also scoped per-profile.

The schema version of this save.

This class serves as a schema for the Profile save file. It's used for storing the preferred profile that the player plays as. This file is stored at the account level, not at the profile level, and is synced across devices/platforms.

The schema version of this save.

TEMPORARY: This class handles the one-time migration of user data from before profiles existed. This migrator is designed to help existing playtesters transition their save data, replays, and console history to the new platform-specific, user-scoped directory structure without losing their progress. This class should be removed a few months after the user profile feature has been released to playtesters, once we're confident that all active users have migrated their data. The migration moves all data from user://{platform}/{userId}/saves/ -> user://{platform}/{userId}/profile1/saves/

Domain type for player progress. Separates runtime representation from the JSON wire format (). Uses dictionaries for stat lookups and hashsets for deduplication of discovered content.

Creates an empty ProgressState. Used for new save files and test setup.

Sets an epoch to Obtained if its slot exists, or creates a new ObtainedNoSlot entry.

Sets or creates an epoch at any desired state. Used by timeline expansions. Bypasses 's one-way guard so the state can be moved in any direction (e.g. NotObtained to Revealed).

Opens a timeline slot for an epoch. If no entry exists, creates a NotObtained entry. If the epoch was earned before its slot existed (ObtainedNoSlot), promotes it to Obtained. Does NOT modify ObtainDate (the date was set when the epoch was earned, not when the slot opened).

Sets an obtained epoch to Revealed state. Pure data mutation only. The metric upload stays on .

Clears all epochs. Used by the debug Reset Progress button.

For each Revealed epoch, ensures all epochs it would expand via have slot entries. Promotes ObtainedNoSlot to Obtained and creates missing entries as NotObtained.

Result of a save file read operation.

The type of save data

The save data, if the operation succeeded or was recreated.

The status of the operation.

Whether the operation succeeded and resulted in usable save data. This includes successful loads, migrations, repairs, and partial recoveries.

Error message, if the operation failed.

Creates a new successful result with save data.

The save data

Creates a new result with a status.

The status Optional error message

Creates a new result with a status and save data.

The save data The status Optional error message

Status codes for save file reading operations.

The operation succeeded.

The JSON could not be parsed.

The file was not found.

The file was empty.

The migration failed.

The schema version is missing from the save file.

The save file version is newer than the current version.

The save file version is too old to migrate.

The save required migration and was migrated in memory.

The JSON had errors that were automatically repaired.

Data was recovered but some information may be lost.

File access error (I/O error, permissions, etc).

The save is completely unrecoverable.

The save file loaded successfully but failed content validation.

Extension methods for ReadSaveStatus.

Determines if a save read status is recoverable.

The read status to check True if the status indicates a recoverable error or success

JSON converter for List<string> of epoch IDs that provides backward compatibility with the old List<ModelId> format ("epoch.xxx") while writing the new format ("xxx").

For JSON deserialization.

For manual instantiation at the start of a run or in tests.

Abstract model to grab saved properties from.

This should only be called internally or from tests.

The object to serialize properties from. Id of the AbstractModel passed, or null if it is not an abstract model.

Only for use internally or in tests!

Object to dump properties into. For serializing over the network, to save space, we map the string names statically to integers

Serializable representation of an act map for save files. Captures the full map topology so it can be restored without regeneration.

Represents a way to serialize the entire state of a card to save file or for sending to a multiplayer peer. This should only be used in multiplayer if you need to recreate a card from scratch. If you are referencing an already-existing card owned by a player, you should use NetCombatCard or NetDeckCard.

Serializable representation of a single map point for save files.

The model ID that this reward is predetermined to be. This is used for rewards that are predetermined to be a specific model, such as granting the specific relics that were originally being sold by . Note: If you want to set a pre-determined CardModel reward, you should probably use and the property instead. TODO: This only supports RelicModel right now. Add support for PotionModel later if necessary.

The card for a . This has to be a full serialized card instead of just an ID, because steals a card from you and then returns it via this reward. This card may have modifications (upgrade, enchantment, etc.), so we need to be able to fully reconstruct it. Only non-null when RewardType is SpecialCard.

These properties are only used for gold rewards.

Whether or not the gold was "stolen back". Usually false, but true in situations where an enemy/event "stole" some of your gold (such as ), and this reward represents you taking it back.

These properties are only used for randomized card rewards.

The IDs of the card pools that this card reward can be rolled from.

The number of cards that should be available to choose from in this card reward.

See for details.

Property is always serialized and deserialized no matter what.

Property is only serialized and deserialized if Object.Equals returns false when comparing the current value of the property and the default value of the property when the declaring type's default constructor is called.

Property is only serialized and deserialized if Object.Equals returns false when comparing the current value of the property and default(T), where T is the property of the type.

Property is only serialized and deserialized if it is a collection that is not empty, or if it is not null.

Manages saving and loading game data, including settings, progress, current runs, and run history. Implements the Singleton pattern for global access to save functionality.

The SaveManager coordinates multiple specialized save managers: - : Handles user settings (not cloud synced) - : Manages global game progress and statistics - : Handles saving/loading of active runs - : Manages historical run data This specialized manager architecture improves testability by allowing each save manager to be tested independently with appropriate mocks and stubs. Save files are stored in a user-scoped, platform-specific location: - In editor: C:\Users\{USER}\AppData\Roaming\SlayTheSpire2\{platform}\{userId}\saves - In builds: C:\Users\{USER}\AppData\Roaming\Godot\app_userdata\sts2\{platform}\{userId}\saves

The agnostic epoch IDs in unlock order. Used by and to enforce prerequisite ordering.

If the SaveManager is in the middle of saving the run, then this is non-null and not completed.

Constructor with dependency injection support.

The file I/O backend to use. Force all operations to be performed synchronously. Only use in tests.

Constructor with a separate local-only store for settings. Settings are machine-specific (display, controller, window) and must not be cloud-synced.

Constructs the default SaveManager for this platform and configuration. - If we are currently in test mode, then this returns a SaveManager that doesn't actually save to disk. - If cloud saves are enabled, then this returns a SaveManager that saves both to cloud and to disk for the appropriate save backend.

Sets CurrentProfileId. This is called during the initialization of the game. It must be called after cloud sync has completed to allow the profile save to sync.

The profile ID to use. If null, it will be read from file.

Switches the current profile ID and saves it to the profile save file. Methods on the SaveManager will start reporting new data right after, but you will must call InitPrefsData and InitProgressData so that PrefsData and ProgressData will report old data.

The profile ID to switch to.

Increments and saves the NumReloads field of a save file.

Called whenever the player wins, loses, or abandons run. Updates the progress.save file using the current_run.save file or similar.

The serialized run data. Whether or not the run ended in a victory.

Called when the player wins a combat.

Recursively deletes all files and subdirectories within the given directory.

PRG-5240: When using cloud storage, we must also delete cloud-only files. Cloud-only files can exist when: - Old run history files were "forgotten" from cloud quota tracking but still exist on Steam servers - Files were uploaded from another device but not yet synced locally If we only deleted local files, cloud-only files would be restored on next game launch by SyncCloudToLocal, causing deleted profile data (like old run history) to reappear.

Initializes a default settings file for testing purposes. This is separate from InitSettingsData because that is used directly in tests.

Initializes a default prefs file for testing purposes. This is separate from InitPrefsData because that is used directly in tests.

Loads the settings file for the first time. This should only be called once early on in the lifetime of the game. If the settings save could not be read because it was corrupt or did not exist, a new one is created.

The result of reading the settings save file.

Loads the prefs file for the first time. This should be called once early on in the lifetime of the game, and then only when the player switches profiles after that. If the progress save could not be read because it was corrupt or did not exist, a new one is created.

The result of reading the prefs save file.

Loads the progress file for the first time. This should be called once early on in the lifetime of the game, and then only when the player switches profiles after that. If the progress save could not be read because it was corrupt or did not exist, a new one is created.

The result of reading the progress save file.

Synchronizes files that are cloud-saved in the background. When this is called, we copy all newer files from the cloud save backend to the user:// directory, overwriting the saves that are there. If there is no active cloud save backend, then this method does nothing.

Deletes settings.save from cloud storage if it exists. Settings are machine-specific (display, controller, window) and were never intended to be cloud-synced. A stale cloud copy was uploaded by earlier versions and can cause sync conflicts when the local settings legitimately differ (e.g., different platform, different display configuration).

Removes current_run.save files that have already been saved to run history. This prevents stale saves from being restored after cloud sync issues (e.g., Steam Deck suspend).

Checks if a current_run.save file for a specific profile is stale (already exists in history) and deletes it.

Removes orphaned .tmp files from all save directories. These can be left behind if the game crashes or is force-killed during an async write.

Extracts the start_time field from a serialized run save JSON without full deserialization. Returns null if the field cannot be extracted.

This returns true under the following circumstances: - If there is a cloud save backend with no files uploaded and we have save files locally - If the cloud save backend is present and has a local cache, but cloud sync is not enabled If true is returned, then OverwriteCloudWithLocal should be called. If false is returned, then SyncCloudToLocal should be called.

If any cloud backend is enabled, but there are no files uploaded to that backend and we have save files on our end, then this uploads all of our files to the cloud. If there is no active cloud save backend, then this method does nothing. This is used to upload all save files to the cloud for the first time when we enable a cloud save backend.

Load the current run save.

The current run save, wrapped in a result object that contains some status info.

Load and validate the current multiplayer run save. Performs deep validation to ensure all save content is valid and handles corruption automatically. If the save contains deprecated content, the model IDs are automatically replaced with the deprecated versions.

The local player ID to validate against The current multiplayer run save with validation status

Returns true if all ftues are disabled OR if the given ftue key exists (seen by the player before). Is also disabled if there's no game (test mode)

Generates an unlock state from the current progress save. This object can be used to query what the player has unlocked. This should only be called from the main menu. When in a run, you should use the unlock state on or on Player. See the documentation in UnlockState for why.

Sets an Epoch Slot to be available but not revealed/obtained.

Sets or creates an Epoch to any EpochState we wish. Used by TimelineExpansions for overriding behaviors.

Sets or creates an Epoch to any EpochState we wish. Used by TimelineExpansions for overriding behaviors.

Reveals an Epoch. Sets an Epoch to IsComplete. Occurs when the player clicks on an Obtained Epoch in the Timeline screen.

Called by the debug Reset Progress button in the Timeline screen.

Checks if an epoch has been revealed on the timeline. You should only be querying this from the main menu. When you are inside of a run, you should be using or .

Checks if an epoch has been revealed on the timeline. You should only be querying this from the main menu. When you are inside of a run, you should be using or .

Helper method which returns every Epoch that unlocks cards in the game. Modify this list to affect our total card unlock statistics.

Helper method which returns every Epoch that unlocks relics in the game. Modify this list to affect our total relic unlock statistics.

Helper method which returns every Epoch that unlocks relics in the game. Modify this list to affect our total relic unlock statistics.

Returns the sum of the Ascension progress of every character the player has.

Returns the number of Epochs we have that the player has discovered but not yet revealed in the Timeline.

Called whenever the score bar is filled. Increments TotalUnlocks and grants an Epoch.

Look-up function to get an Epoch ID based on the player's TotalUnlocks (the score bar system at the end of run). Must match .

The player needs to complete any run to access the compendium or be a dev.

Disposable scope returned by . Calls on dispose, allowing batch usage with using.

Disposable scope returned by . Calls on dispose, allowing batch usage with using.

Obtains an enchantment by ID, or falls back to the deprecated event if it's not found. This should only be used in save loading where it's okay to fall back to deprecated content.

Obtains an ancient event by ID, or falls back to the deprecated ancient event if it's not found. This should only be used in save loading where it's okay to fall back to deprecated content.

Obtains an encounter by ID, or falls back to the deprecated encounter if it's not found. This should only be used in save loading where it's okay to fall back to deprecated content.

Obtains a card by ID, or falls back to the deprecated card if it's not found. This should only be used in save loading where it's okay to fall back to deprecated content.

Obtains a relic by ID, or falls back to the deprecated relic if it's not found. This should only be used in save loading where it's okay to fall back to deprecated content.

Obtains a potion by ID, or falls back to the deprecated potion if it's not found. This should only be used in save loading where it's okay to fall back to deprecated content.

Obtains a modifier by ID, or falls back to the deprecated modifier if it's not found. This should only be used in save loading where it's okay to fall back to deprecated content.

Obtains an enchantment by ID, or falls back to the deprecated enchantment if it's not found. This should only be used in save loading where it's okay to fall back to deprecated content.

Obtains a monster by ID, or falls back to the deprecated monster if it's not found. This should only be used in save loading where it's okay to fall back to deprecated content.

Obtains a character by ID, or falls back to the deprecated character if it's not found. This should only be used in save loading where it's okay to fall back to deprecated content.

Obtains a act by ID, or falls back to the deprecated act if it's not found. This should only be used in save loading where it's okay to fall back to deprecated content.

Holds progress data on a per Epoch basis. If a SerializableEpoch is NOT in the list of epochs in SerializableProgress, it means the player has not revealed that Epoch's Slot via Timeline Expansion.

The player's gameplay progress for Slay the Spire 2. This would be considered the most important save file and is synced across devices/platforms. There would be a progress.save in each respective profile's folder and contains data such as: - Total wins, losses, playtime, and progress per character - Which cards/relics/potions/etc have been seen or unlocked - Which enemies/elites/bosses have been encountered and defeated - Character data - Timeline and Unlock progress (meta progression) - Unlocked achievements - Which FTUEs this player has seen

The schema version of this save.

Tracks how often each character has encountered, won, and lost against each Encounter.

Tracks how often each character has encountered, won, and lost against each Enemy Creature.

Tracks how often each character has encountered, won, and lost after encountering each ancient.

The amount of agnostic unlocks via score system this player has unlocked.

How much score this player has (is not cumulative).

Which multiplayer ascension we had selected the last time we started a multiplayer run.

The maximum unlocked ascension in multiplayer. In singleplayer runs, we use character stats. In multiplayer runs, all characters share an ascension.

Characters that have been unlocked between the last run and the next time the player opens the character select screen. Used to show an animation on the character select screen.

Get the stats for the specified character.

Get the stats for the specified ancient.

The schema version of this save.

This is null if the run is not a daily. Otherwise, it contains the date from the time server of the daily.

The map coordinates you've visited in the current Act.

When this save was created or last updated.

The amount of seconds that has elapsed for this run.

The exact moment when a Win was clocked on the RunTime. (Currently when you beat the Act 3 boss)

The furthest floor count reached during this run. Used when uploading the "floor" value when uploading to the daily leaderboards.

Records an achievement unlock in the SerializableProgress file. Stores the achievement identifier as a raw string at the wire format boundary. Enum resolution happens in .

This class serves as a schema for the Settings save file. It's used for serializing and deserializing data in the options screen. This file is stored at the account level, not the profile level, and is NOT to be synced across devices/platforms. See for the profile-level options displayed in the options screen.

The schema version of this save.

A minimalist mock implementation of ICloudSaveStore for testing.

A minimalist mock implementation of ISaveStore for testing. Instead of relying on actual file system operations like the original implementation, this mock keeps everything in memory and tracks method calls for verification. This approach: 1. Avoids duplicating the real implementation's logic 2. Makes tests more predictable by not hitting the actual file system 3. Allows verifying interactions through the Calls collection 4. Provides customization points only where needed for specific tests

Constants for method names to use when tracking or comparing method calls

In-memory storage of file contents, with path as the key and content as the value

In-memory representation of directory structure

Tracks all method calls for verification in tests

Custom callback for RenameFile operation to allow tests to intercept and verify behavior

Base directory for GetFullPath operations

Creates a new instance of the mock save store with the specified base directory

The base directory for file operations

Gets the full path for a filename relative to the base directory

Directly sets the content of a file in the virtual file system without going through WriteFile. Used to simulate corrupt files (e.g. empty content from zeroed-out saves).

Reads a file from the virtual file system

Writes a file to the virtual file system

Writes a file to the virtual file system

Asynchronously writes a file to the virtual file system

Asynchronously writes a file to the virtual file system

Checks if a file exists in the virtual file system

Checks if a directory exists in the virtual file system

Deletes a file from the virtual file system

Renames a file in the virtual file system. If RenameFileAction is set, it will be called instead of performing the default behavior.

Gets all files in a directory from the virtual file system

Gets all directories in a directory from the virtual file system

Creates a directory in the virtual file system

Deletes a directory and any remaining contents from the virtual file system.

Deletes temporary files (ending with .tmp) from a directory in the virtual file system

Collects validation errors during save deserialization. Threaded through FromSerializable methods to accumulate structured errors with path tracking.

Pushes a path segment onto the stack (e.g. "Players[0]", "Deck[3]", "Id").

Pops the most recent path segment from the stack.

Records a warning at the current path. Warnings indicate degraded data but the save is still loadable.

Records a fatal error at the current path. Fatal errors mean the save cannot be loaded.

All validation errors collected so far, in insertion order.

Whether any fatal errors have been recorded.

Number of warning-severity errors.

Number of fatal-severity errors.

Severity levels for save validation errors.

The save loaded but data was degraded (e.g. deprecated content replaced with fallback).

The save cannot be loaded due to invalid or missing data.

A single validation error found during save deserialization.

Whether this error is fatal or a warning Dot-separated field path where the error occurred (e.g. "Players[0].Deck[3].Id") Human-readable description of the error

A single validation error found during save deserialization.

Whether this error is fatal or a warning Dot-separated field path where the error occurred (e.g. "Players[0].Deck[3].Id") Human-readable description of the error

Whether this error is fatal or a warning

Dot-separated field path where the error occurred (e.g. "Players[0].Deck[3].Id")

Human-readable description of the error

Whether this error is fatal (the save cannot be loaded).

Enum for various available aspect ratio settings

Enum used for changing how fast the game runs. This is NOT a multiplier-based speed setting.

Enum used for changing VSync settings

Interface for automated card selection, used by both test mode and AutoSlay.

Selects cards from the available options.

Cards available for selection. Minimum number of cards to select. Maximum number of cards to select.

Selects a card reward from the available options.

Whether the game is running in test mode. True when we're running unit tests, true when we're running the normal game.

Whether the game iS NOT running in test mode. True when we're running the normal game, false when we're running unit tests.

NEVER CALL THIS. Only calls should be in NetCoreRunner and CiCoreRunner.

Force specific cards to show up for CardFactory.GetDistinctForCombat.

Consume the combat cards generation override and clear it out.

Force a specific order for the initial shuffle.

Consume the initial shuffle override and clear it out.

An abstract class which contains data for a single Epoch.

List of all valid epochs currently in the game

Not used as of this time except for the header of the hovertip when peeking at the unlock requirement.

The fancy lore text.

The text shown in the hovertip when you hover this Epoch while it's not yet obtained.

The text which shows up at the bottom of the Epoch Inspect Screen, describing what had been unlocked.

The "row" which this Era supposedly resides in. 0 is the bottom, 4 is the top!

Grabs the index of a given Epoch. If invalid, returns -1

Returns the list of epochs whose slots are revealed when this epoch is revealed on the timeline. Used by at runtime and by save validation to detect missing slots.

WARN: Currently, every Epoch MUST unlock something. Whether it be information, cards, relics, etc. Without an unlock, if the player slots 2 Epochs at once, the game will function incorrectly.

Static method to get the Id for a given type

Little helper method for coloring the text.

Little helper method for coloring the text.

Little helper method for coloring the text.

Elsewhere: Placeholder

Preon: A void of nothingness. But then, the world comes into existence!

The Architect: Too many Beasts of Imagination begin to populate Preon and things aren’t simple and fun anymore.

Traitors: One of the many Ancients, Neow, grows jealous of the awe-inspiring will of the Architect.

Slumber

Buy Something!

Seeds: Enamored by the growth and stability of flora and fauna.

The Daily

Darv

Booting Up

Tricked

Hello! Hello!

Resolving Bugs

Confrontation

Laser Beams

Ooh Shiny!

Cultists

The Finest

The Spire

The Ironclad

Devastation

The Pact

Ablaze

Snuffed

My Face

Life and Death

Expeditionists

Futility

Spireborn

The Giant

Annihilation

To Kill

Neow

Orobas

Open

The Calm

Anomalous Planet

I Arrive

We Need a Hero!

Grand Strategy

Friends

Discontent

Little King

Scribbles: On this quiet planet, Beasts of Imagination begin to dot the world.

Ancients: The Ancient Trees are not all the same. Each individual tree is shaped by its surroundings.

Civilization

Consequences

Insects

Dance of Death

Bigger Prey

Ill

Trophies

Poisoner

Bigger Prey: The other sisters judge the fourth one in silence...

Soup

Underdocks

Given an Epoch, identifies the story and grabs the previous chapter if possible. Returns null if out of bounds or if there's no previous chapter. Will skip over chapters you haven't revealed.

Grabs the next chapter in the provided Epoch's story. Returns null if out of bounds or if there's not a next chapter. Will skip over unrevealed chapters in a story.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the 'Dump' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Represents the state of unlocked content for a given player. The local player can encapsulate this state in their progress save. The real place this class is useful is in multiplayer scenarios, where different players have different unlock states. This is used in three places: - In the class, to query a specific player's unlock state (e.g. for rewards or Attack potion generation) - In the class, to query the superset of all players' unlock states (e.g. for ancient generation) - In the class, to query the local player's unlock state outside of a run (e.g. in the compendium) For multiplayer, keep in mind which one is appropriate to use at a given time. Using the third when one of the first two should be used will result in a state divergence. In singleplayer, the first two are equivalent, but you should still consider when using the third is appropriate. If you use the third during a run, epochs unlocked between a save and a load may be inappropriately included in the run.

The total set of epochs revealed. If this is the shared unlock set, this is the superset of all epochs from all players.

The encounter IDs this player has seen (lost or won). If this is the shared unlock set, this is the superset of all encounters seen by all players.

Ths number of runs the player has done. If this is the shared unlock set, this is the **maximum** number of runs among all players.

Returns the all the characters that the player has unlocked.

Get all the ancients in the game that don't belong to a specific act and that the player has unlocked.

Get all the relics in the game that the player has unlocked.

Get all the relics in the game that the player has unlocked.

Returns true if the player has seen this encounter (won or lost). If this is the multiplayer unlock state, returns true if any player has seen the encounter.

Get all the card pools in the game that belong to specific characters and that the player has unlocked.

Get all the cards in the game that the player has unlocked. Be careful using this, it includes cards that you shouldn't be able to randomly roll for rewards.

Get all the card pools in the game that the player has unlocked.

Injection constructor.

Produces an unlock state from a progress state. Only use this to derive an unlock state for the local player.

The progress state to derive the unlock state from.

Produces an unlock state that is the union of all passed unlock states. In essence: In a multiplayer game, if one person has something unlocked, it will be unlocked for everyone in the multiplayer session.

Set of states to merge together.

Checks if this player has revealed an epoch on the timeline.

The type of epoch. The amount of epochs the player has unlocked.

Normal block granted by a card.

Unpowered block granted by a card. Example: ("Double your Block") should not pick up extra block from .

Normal block granted by a monster move.

Unpowered block granted by a non-card source. Example: The power ("At the end of your turn, gain X Block") should not pick up extra block from .

Normal damage done by a card.

Unpowered damage done by a card. Generally used by Curse/Status cards that do damage to the player.

HP loss from a card. Used by cards that have a "Lose X HP" drawback like Offering.

Normal damage done by a monster move

Unpowered damage done by a source other than a card or monster move. Most commonly used by damaging powers whose damage should still be blockable, like Thorns.

HP loss from a source other than a card or monster move. Most commonly used by damaging powers whose damage should be unblockable, like Poison.

Aka damage type: - Unblockable = HP loss like Poison - Unpowered = Damage from relics, potions, and powers - Move = Attack damage from Attack cards and Enemy creatures attacking

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

Defines the source generated JSON serialization contract metadata for a given type.

The default associated with a default instance.

The source-generated options associated with this context.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

This is for feedback bot (the discord bot), the text here is what it will display when called. The id for the ancient choice This is for the metrics system, the text here is what will be displayed in the metrics website screen. Represents the ancient's id This is for feedback bot (the discord bot), the text here is what it will display when called. This is for the metrics system, the text here is what will be displayed in the metrics website screen.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'OnRoomEntered' method.

Cached name for the 'OnActEntered' method.

Cached name for the 'RefreshBossIcon' method.

Cached name for the 'RefreshSecondBossIconColor' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ShouldOnlyShowSecondBossIcon' property.

Cached name for the '_bossIcon' field.

Cached name for the '_bossIconOutline' field.

Cached name for the '_secondBossIcon' field.

Cached name for the '_secondBossIconOutline' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdateIcon' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_floorNumLabel' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdateGold' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_goldLabel' field.

Cached name for the '_goldPopupLabel' field.

Cached name for the '_currentGold' field.

Cached name for the '_additionalGold' field.

Cached name for the '_alreadyRunning' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_ExitTree' method.

Cached name for the 'UpdateHealth' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateHpTween' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_hpLabel' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_icon' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Allows this UI element to be hovered and display character/ascension/achievement info.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnFocus' method.

Cached name for the 'OnUnfocus' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the 'ShowTip' property.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Override the map point type for debugging purposes.

MapPointType to use instead of the real one.

Clear the map point type override.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the '_EnterTree' method.

Cached name for the '_ExitTree' method.

Cached name for the 'DebugSetMapPointTypeOverride' method.

Cached name for the 'DebugClearMapPointTypeOverride' method.

Cached name for the 'OnFocus' method.

Cached name for the 'GetHoverTipPrefixForRoomType' method.

Cached name for the 'GetHoverTipPrefixForUnknownRoomType' method.

Cached name for the 'OnUnfocus' method.

Cached name for the 'UpdateIcon' method.

Cached name for the 'GetCurrentMapPointType' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_roomIcon' field.

Cached name for the '_roomIconOutline' field.

Cached name for the '_debugMapPointTypeOverride' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached StringNames for the signals contained in this class, for fast lookup.

Cached StringNames for the methods contained in this class, for fast lookup.

Cached name for the '_Ready' method.

Cached name for the 'OnAnimationEvent' method.

Cached name for the 'ShowFire' method.

Cached name for the 'StartPath1' method.

Cached name for the 'EndPath1' method.

Cached name for the 'StartPath2' method.

Cached name for the 'EndPath2' method.

Cached name for the 'StartPath3' method.

Cached name for the 'EndPath3' method.

Get the method information for all the methods declared in this class. This method is used by Godot to register the available methods in the editor. Do not call this method.

Cached StringNames for the properties and fields contained in this class, for fast lookup.

Cached name for the '_trail1' field.

Cached name for the '_trail2' field.

Cached name for the '_trail3' field.

Cached name for the '_fireTexture' field.

Get the property information for all the properties declared in this class. This method is used by Godot to register the available properties in the editor. Do not call this method.

Cached StringNames for the signals contained in this class, for fast lookup.

Custom -derived type for the CamelCaseRegex method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Custom -derived type for the SnakeCaseRegex method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Custom -derived type for the WhitespaceRegex method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Custom -derived type for the SpecialCharRegex method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Custom -derived type for the SteamIdRegex method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Custom -derived type for the NonSpaceWhitespaceCharacters method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Custom -derived type for the ConsecutiveSpaces method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Custom -derived type for the HtmlTags method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Helper methods used by generated -derived implementations.

Default timeout value set in , or if none was set.

Whether is non-infinite.

Determines whether the specified index is a boundary.

Determines whether the character is part of the [\w] set.

Supports searching for characters in or not in "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".

Supports searching for characters in or not in "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_".

Supports searching for the string "76561".

Supports searching for characters in or not in "\t\n\v\f\r \u0085             \u2028\u2029  　".