Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456]

▼NJumpvalley
▼NAnimation
CAnimatedNode	This class provides some components to bind to a Godot node, mainly to assist with writing animation code for the node
CAnimatedNodeGroup	Class that groups multiple AnimatedNodes together so that they can communicate with each other. This class can also help make it so only one AnimatedNode within the group can be shown at a time
▼NAudio
CAudioStreamReader	Loads a file that's either imported as a resource (at one point or another) or somewhere on the filesystem
▼NGui
CBackgroundPanel	Handler for the BackgroundPanel, a panel (or some other Godot Control) that acts as a background for a currently visible menu
▼NIO
CInfoFile	Reads an Info file, a blob of text that's primarily for defining metadata for a specific object, such as an audio file or a level. The blob of text typically comes from a plain-text file named "info.txt". The contents of such types of files should be formatted like this: property name: property value where each property is specified on its own line. For the property name, spaces should be replaced with underscores. The property name and property value should be split with a ": ", including the space and not including the quotes. This text formatting is inspired by the way that the content of .osu files are formatted in Osu (the rhythm game)
CJsonInfoFile	Class intended to help with using the data from info files written in JavaScript Object Notation (JSON). Info files are files that contain metadata about an object (e.g. one that's on a filesystem). The conventional file name for JSON info files is info.json
CPathUtil	Provides some values and methods for performing operations related to file paths
▼NLevels
▼NInteractives
▼NMechanics
▼NTeleporters
CStartEndTeleporter	Type of teleporter that teleports a node to Teleporter.Destination when the node touches specified parts called start nodes. Start nodes should be Area3Ds.
CTeleporter	Interactive that sends a Node3D to a defined destination
CCheckpointSet	Interactive that handles checkpoints for a level
COverallBoundingBoxObject	Interactive that calculates its root node's overall bounding box. Calculation is done via the GetOverallBoundingBox method
CSpinner	A basic spinner. A spinner is a rotating platform. The root node of this interactive should be a StaticBody3D. Make sure to specify its constant angular velocity in the constant_angular_velocity or constant_angular_velocity_degrees metadata entries instead of the StaticBody3D's built in ConstantAngularVelocity property. This is so the spinner doesn't move objects when it isn't running. The spinner won't turn if you don't specify the angular velocity in one of the metadata entries
CInteractive	The base class for all Interactive types in Jumpvalley
CInteractiveNode	A subclass of Interactive that operates over a Godot node. It makes using a Godot node's properties and metadata easier. See the relevant wiki sectionfor details
CInteractiveToolkit	Provides some variables and methods that may assist with the development of interactives
CNodeMetadataChangedArgs	Event arguments for InteractiveNode.NodeMetadataChanged
CDifficulty	Represents a difficulty, a set of values that judge how difficult a level is
CDifficultyPresets	This class contains some difficulty sets that can be used to label the difficulty of a level. Currently, the difficulty sets here have one of these characteristics: It's directly from a game or community It's from a game or community, but it's been modified.
CDifficultySet	Class that groups multiple difficulties together. Useful when you want to have all the difficulties within a game in one place and be able to perform some calculations based off of them
CDirectoryLevelRunner	Subclass of LevelRunner that handles running levels located within a directory
CLevel	This class represents a level that's playable in Jumpvalley. Each level contains four primary components: interactives, music, static objects, and start point. More details can be found on Jumpvalley's wiki article on Level Layout
CLevelInfo	Class containing some info about a level
CLevelInfoFile	Reads an info file for a Jumpvalley level
CLevelPackage	This class represents a level package, a filesystem folder that contains the components of a level. Each level package includes: The level's info file The Godot package (PCK file) that contains the level's contents
CLevelRunner	Class responsible for running and stopping levels. This is intended to be a base class where subclasses handle running levels in their own way
▼NMusic
CMusicGroup	Handles a Playlist that's in the form of nodes in a scene tree. Each MusicGroup node must have a node as a direct child named "Music" that lists the directory (folder) paths of songs in its metadata. There are two ways to specify songs that should be played: songs array in metadata The metadata (as mentioned above) has an array named songs that specifies the songs to play. The array's C# type should be Godot.Collections.Array. Incremental songN metadata entries This method is used when no songs array is present in the metadata. Multiple metadata entries should be specified in this format: Entry name: songN where N represents the numerical index of the song package directory starting from 1. Songs are played in numerical order. Entry value: The absolute path to the song's directory. (The value's type must be string.)
CMusicPlayer	Plays music that is split into playlists (see Playlist) This class applies a fade transition when the user wants to switch between playlists. Each instance of a MusicPlayer can only play one song at a time at most
CMusicZone	Represents a single music zone. Music zones each have their own playlist. Such playlists typically only contain one song, but it's possible for the playlists to have multiple songs. To specify the geometry that makes up the music zone, the music zone has to have a node named "ZoneParts" as a direct child. This "ZoneParts" node should contain MeshInstance3Ds using box meshes (preferred for performance reasons) or CSGBox3Ds. These boxes make up the music zone's geometry
CMusicZonePlayer	MusicPlayer that handles the playback of Playlists with music zones in mind. Music zone logic is handled like how it is in Juke's Towers of Hell. This means that whenever a player enters a music zone, the zone's playlist gets played. In order for music to play when the player is outside a music zone, a primary playlist must be set. This playlist will get played when outside of the music zones. It's important to note that MusicZonePlayer will only update CurrentPlaylist once per process frame for stability reasons (as long as the calling of MusicZonePlayer's _Process() function hasn't been disabled)
CPlaylist	Represents a musical playlist that can hold multiple Songs
CSong	Represents a single song associated with a file, along with some metadata
CSongChangedArgs	Event arguments for Playlist.SongChanged and MusicPlayer.SongChanged
CSongInfo	Class that holds some metadata about a song file
CSongInfoFile	Reads the associated "info.txt" file for a song. The contents of such types of files should be formatted like this: property name: property value where each property is specified on its own line. Currently, the properties read for an song's info.txt file are: name: The name of the song artists: The artists that made the song album: The album the song belongs to audio_path: The file path to the audio file, including its file name and extension This text formatting is inspired by the way that the content of .osu files are formatted in Osu (the rhythm game)
CSongPackage	Represents a folder (such as one on the filesystem) that contains a song and its info metadata
▼NPlayers
▼NCamera
CBaseCamera	The base class that handles a 3d camera focusing on a 3d object. It includes support for camera panning and zoom controls
▼NMovement
CBaseMover	This is the base class that provides a player's character the ability to move in different directions, jump, and climb. It serves mainly as a controller interface for developers to build on. The design of this takes lots of inspiration from Roblox's PlayerModule
CBodyRotator	This class is responsible for turning a 3D body's yaw angle in the direction that it's moving. Such direction is approached gradually, unless it's specified that the direction should be set instantly. Thanks to Godot 4.0 .NET thirdperson controllerby vaporvee for helping me figure out how to smoothly turn a 3D body in terms of a third-person controller
CBodyStateChangedArgs	Event arguments for BaseMover.BodyStateChanged. In this class's documentation, "character" refers to the CharacterBody3D whose movement is being handled by its BaseMover
CClimber	Allows a character to climb objects. Specifically, these objects are PhysicsBody3Ds A PhysicsBody3D can be climbed if it has a boolean metadata entry named "is_climbable" that's set to true
CPlayer	This class represents a player who is playing Jumpvalley or some other app that derives from it. This class inherits from the Interactive class since it contains some functionality that assists with initializing, starting, stopping, and disposing the app components functioning on behalf of the player. This class contains some of the basic components that allow the app to function for the player, such as: Their music player The Controller instance that allows them to control their character The Camera instance that allows them to control their camera Their primary GUI node
▼NRaycasting
CRaycastSweep	Sweeps over a region of 3D space using a series of equally-spaced-out raycasts. The center raycast, being located in the middle (or close to it), is assigned to the greatest integer that's less than or equal to the median index. "index" here refers to the numerical index that a raycast is located in within a raycast sweep from left to right
CRaycastSweepResult	Class that contains data about the result of a raycast sweep operation (where collisions with a RaycastSweep's raycasts are checked)
▼NTiming
COffsetStopwatch	This class extends the Stopwatch (in the standard C# library) so that an initial value for elapsed time can be specified. This initial value acts as an offset for the Stopwatch's real elapsed time
▼NTweening
CIntervalTween	Class that runs a tween by incrementing steps at a specified time interval. Note that while the time interval should mostly be fixed, there will be slight differences in the actual time between each step. To account for this, the Stopwatch class is used to run the tween based on a timestamp. Therefore, the aforementioned differences shouldn't add up and cause the tween to finish noticeably later than expected for longer tweens
CMethodTween	Provides a way of tweening via Godot using method overrides. The advantage of using this over a normal Godot Tween is that the Tween doesn't have to be in the scene tree in order to operate. Another difference is that unlike a normal Godot Tween, this tween doesn't start automatically after being instantiated. Developers must call Resume() manually in order to get the tween running. Syntax is inspired by JavaFX's animation package
CSceneTreeTween	MethodTween that can bind to the Process step of a Godot scene tree. Every process step, the tween will also get stepped until the playback of the tween is finished or stopped
CTweenGroup	A class capable of overseeing multiple tweens as a "group". It offers support for storing tweens in a key-value map (also called a Dictionary<TKey, TValue>) and doing various operations with all of the tweens in the map at once. In addition, it can be used to make Godot tweens work with objects that aren't in the scene tree, particularly, through the use of Tween.TweenMethod Please note: In order for this to work, an instance of TweenGroup<TKey> must be parented to a Godot node of some sort (preferably one that will be in the scene tree until the application exits). This is due to the Godot limitation that Tweens must be in the scene tree in order to be processed