Jazz2 namespace
Root namespace of Jazz² Resurrection.
Namespaces
- namespace Actors
- Implementation of all objects.
- namespace AssetPacker
- Offline data conversion tool, see Asset packing.
- namespace Collisions
- Collision checking.
- namespace Compatibility
- Translation layer for original data files.
- namespace Editor
- namespace Events
- Events and object spawning.
- namespace Formats
- The game's own level and tile set formats.
- namespace Input
- Input handling.
- namespace LevelPacks
- namespace Multiplayer
- Multiplayer-related classes, compiled only if
WITH_MULTIPLAYER. - namespace Rendering
- Scene rendering and viewport management.
- namespace Resources
- Structures for game resources.
- namespace Scripting
- Scripting-related classes, compiled only if
WITH_ANGELSCRIPT. - namespace Tests
- Measurement harnesses, compiled only if
WITH_PHYSICS_PROBE. - namespace Tiles
- Tile sets and maps.
- namespace UI
- User interface and menus.
- namespace Utils
- Files written safely, JSON files and ZIP archives, compiled only if
WITH_EDITORorWITH_LEVEL_PACKS.
Classes
- struct CharacterProfile
- Abilities of a character.
- struct ContentFileType
- Type tag written into the header of each file the game produces.
- class ContentResolver
- Manages loading of assets.
- struct CustomWeaponOptions
- How a custom weapon fires and what, and how it looks, only a custom weapon has it.
- struct EpisodeContinuationState
- Continuation state between two episodes.
- struct EpisodeContinuationStateWithLevel
- Continuation state between two levels in episode.
- class ILevelHandler
- Base interface of a level handler.
- class IResumable
- Base interface of a resumable object.
- class IRootController
- Base interface of a root controller.
- class IStateHandler
- Base interface of a state handler, only one handler runs at a time.
- struct LevelDescriptor
- Contains all components to fully initialize a level instance.
- class LevelHandler
- Level handler of a local game session.
- struct LevelInitialization
- Level initialization parameters.
- struct LevelLoadOptions
- Options of loading a level.
- struct LightEmitter
- Allows objects to emit light.
- struct LocalizedLevelTexts
- Texts of a level translated to one language.
- struct PlayerCarryOver
- Player carry over between levels.
- class PreferencesCache
- Provides access to a user preferences.
- struct TouchButtonLayout
- Per-button layout stored in user preferences.
- struct VideoFormat
- Layout of the game's own cinematic format.
- struct WeaponDefinition
- What a level makes of one of the weapons.
- struct WeaponEditorData
- What a level keeps of a weapon only for the editor.
- struct WeaponFireOptions
- How a custom weapon fires.
- struct WeaponImage
- Image of a custom weapon, a sheet of frames in rows and columns.
- struct WeaponOptions
- Options of a weapon a level can change, as JJ2+ scripts know them.
- struct WeaponsDescription
- Weapons of a level.
- struct WeaponShotOptions
- Shot of a custom weapon.
- struct WeaponSound
- Sound of a custom weapon, a file kept in the level.
- struct WeaponSprite
- Sprite of a custom weapon.
Enums
- enum class AnimationLoopMode { Once, Loop, FixedSingle }
- Animation loop mode.
- enum class AnimState { Idle = 0x00000000, Walk = 0x00000001, Run = 0x00000002, Dash = 0x00000003, VIdle = 0x00000000, Jump = 0x00000004, Fall = 0x00000008, Hook = 0x0000000c, Shoot = 0x00000010, Crouch = 0x00000020, Lookup = 0x00000040, Dizzy = 0x00000080, Buttstomp = 0x00000100, Uppercut = 0x00000200, Airboard = 0x00000400, Hurt = 0x00000800, Swim = 0x00001000, Copter = 0x00002000, Push = 0x00004000, Swing = 0x00008000, Freefall = 0x00010000, Lift = 0x00020000, Spring = 0x0040000, RevUp = 0x00080000, TransitionRunToIdle = 0x40000000, TransitionRunToDash = 0x40000001, TransitionFallToIdle = 0x40000002, TransitionIdleToJump = 0x40000003, TransitionShootToIdle = 0x40000004, TransitionHookShootToHook = 0x40000005, TransitionCopterShootToCopter = 0x40000006, TransitionUppercutA = 0x40000007, TransitionUppercutB = 0x40000008, TransitionUppercutEnd = 0x40000009, TransitionButtstompStart = 0x4000000A, TransitionPoleH = 0x4000000B, TransitionPoleV = 0x4000000C, TransitionPoleHSlow = 0x4000000D, TransitionPoleVSlow = 0x4000000E, TransitionDeath = 0x4000000F, TransitionTurn = 0x40000010, TransitionWarpIn = 0x40000013, TransitionWarpOut = 0x40000014, TransitionEndOfLevel = 0x40000016, TransitionWarpInFreefall = 0x40000017, TransitionWarpOutFreefall = 0x40000018, TransitionIdleBored = 0x40000019, TransitionDashToIdle = 0x40000020, TransitionIdleToShoot = 0x40000021, TransitionButtstompEnd = 0x40000022, TransitionLiftStart = 0x40000023, TransitionLiftEnd = 0x40000024, TransitionLedge = 0x40000025, TransitionLedgeClimb = 0x40000026, TransitionRevUpStart = 0x40000027, TransitionRevUpEnd = 0x40000028, TransitionWalkToIdle = 0x40000029, TransitionHookIdleFlavor = 0x4000002A, TransitionSidekick = 0x4000002B, TransitionFallShootToFall = 0x40000030, TransitionFromFrog = 0x40000040, Activated = 0x00000020, TransitionActivate = 0x4F000000, TransitionAttack = 0x4F000001, TransitionAttackEnd = 0x4F000002, Uninitialized = -1, Default = 0 }
- Well-known animation state.
- enum class Direction { None = 0, Up = 0x01, Down = 0x02, Left = 0x04, Right = 0x08, Any = Up | Down | Left | Right }
- Direction.
-
enum class EventType : std::
uint16_t { Empty = 0, LevelStart, LevelStartMultiplayer, Checkpoint, SceneryDestruct, SceneryDestructButtstomp, SceneryDestructSpeed, SceneryCollapse, ModifierVine, ModifierOneWay, ModifierHook, ModifierHPole, ModifierVPole, ModifierHurt, ModifierTube, ModifierRicochet, ModifierSlide, ModifierDeath, ModifierSetWater, ModifierLimitCameraView, ModifierNoClimb, AreaStopEnemy, AreaFloatUp, AreaHForce, AreaText, AreaEndOfLevel, AreaCallback, AreaActivateBoss, AreaFlyOff, AreaRevertMorph, AreaMorphToFrog, AreaNoFire, AreaWaterBlock, AreaWeather, AreaAmbientSound, AreaAmbientBubbles, TriggerCrate, TriggerArea, TriggerZone, WarpCoinBonus, WarpOrigin, WarpTarget, LightAmbient, LightSteady, LightPulse, LightFlicker, LightIlluminate, Spring, Bridge, MovingPlatform, PushableBox, Eva, Pole, SignEOL, Moth, SteamNote, Bomb, PinballBumper, PinballPaddle, CtfBase, BirdCage, Stopwatch, SpikeBall, AirboardGenerator, Copter, RollingRock, RollingRockTrigger, SwingingVine, EnemyTurtle, EnemyLizard, EnemySucker, EnemySuckerFloat, EnemyLabRat, EnemyHelmut, EnemyDragon, EnemyBat, EnemyFatChick, EnemyFencer, EnemyRapier, EnemySparks, EnemyMonkey, EnemyDemon, EnemyBee, EnemyBeeSwarm, EnemyCaterpillar, EnemyCrab, EnemyDoggy, EnemyDragonfly, EnemyFish, EnemyMadderHatter, EnemyRaven, EnemySkeleton, EnemyTurtleTough, EnemyTurtleTube, EnemyWitch, EnemyLizardFloat, BossTweedle, BossBilsy, BossDevan, BossQueen, BossRobot, BossUterus, BossTurtleTough, BossBubba, BossDevanRemote, BossBolly, TurtleShell, Coin, Gem, GemGiant, GemRing, GemStomp, Carrot, CarrotFly, CarrotInvincible, OneUp, FastFire, Food, Ammo, PowerUpWeapon, Crate, Barrel, CrateAmmo, BarrelAmmo, CrateGem, BarrelGem, PowerUpMorph, PowerUpShield, RaceCheckpoint, PassthroughEvent, Count, Generator = 0x1000, WeaponBlaster = 0x2001, WeaponBouncer = 0x2002, WeaponElectro = 0x2003, WeaponFreezer = 0x2004, WeaponPepper = 0x2005, WeaponRF = 0x2006, WeaponSeeker = 0x2007, WeaponThunderbolt = 0x2008, WeaponTNT = 0x2009, WeaponToaster = 0x200A } - Event type.
-
enum class ExitType : std::
uint8_t { None, Normal, Warp, Bonus, Special, Boss, TypeMask = 0x0f, Frozen = 0x40, FastTransition = 0x80 } - Exit type.
-
enum class GameDifficulty : std::
uint8_t { Default, Easy, Normal, Hard } - Game difficulty.
-
enum class CameraOverride : std::
uint8_t { Keep, Follow, Fix } - How ILevelHandler::
OverrideCameraView() changes the camera of a player on an axis. -
enum class WaterInteraction : std::
uint8_t { Swim, LowGravity } - How players move under water, see ILevelHandler::
GetWaterInteraction(). -
enum class LevelFlags : std::
uint16_t { None = 0, HasPit = 0x01, HasPitInstantDeath = 0x02, UseLevelPalette = 0x04, IsHidden = 0x08, IsMultiplayerLevel = 0x10, HasLaps = 0x20, HasCaptureTheFlag = 0x40, HasVerticalSplitscreen = 0x80, HasMultiplayerSpawnPoints = 0x100, NotEditable = 0x200, HasPreview = 0x400 } - Level flags.
- enum class PitType { FallForever, InstantDeathPit, StandOnPlatform }
- Level pit type.
- enum class PlayerAction { Left, Right, Up, Down, Buttstomp, Fire, Jump, Run, ChangeWeapon, Menu, Console, SwitchToBlaster, SwitchToBouncer, SwitchToFreezer, SwitchToSeeker, SwitchToRF, SwitchToToaster, SwitchToTNT, SwitchToPepper, SwitchToElectro, SwitchToThunderbolt, Count, CountInMenu = SwitchToBlaster, None = -1 }
- Player action.
-
enum class PlayerType : std::
uint8_t { None, Jazz, Spaz, Lori, Frog, Bird, Bird2, Spectate = UINT8_MAX } - Player type.
-
enum class CharacterAirJump : std::
int32_t { None, Copter, DoubleJump } - What a character does when jump is pressed in the air, see CharacterProfile.
-
enum class CharacterGroundJump : std::
int32_t { Crouch, Jump, Jazz, Spaz, Lori } - What a character does when jump is pressed while crouching, see CharacterProfile.
- enum class RescaleMode { None, HQ2x, _3xBrz, CrtScanlines, CrtShadowMask, CrtApertureGrille, Monochrome, Sabr, CleanEdge, Count, TypeMask = 0x0f, UseAntialiasing = 0x80 }
- Rescale mode.
-
enum class WeaponWheelStyle : std::
uint8_t { Disabled, Enabled, EnabledWithAmmoCount } - Weapon wheel style.
-
enum class PerformanceMetricsLevel : std::
uint8_t { Off, Basic, Detailed } - How much the performance metrics overlay shows.
-
enum class PlayerColorMode : std::
uint8_t { OnlineOnly, FirstLocalPlayer, AllLocalPlayers } - When the custom player character color is applied.
-
enum class ParticleQuality : std::
uint8_t { Off, Low, High, Ultra } - Particle quality.
-
enum class DitheringScope : std::
uint8_t { None, Layers, BehindSprites, Screen } - What is drawn in the colors of the 16-bit renderer of JJ2+, see PreferencesCache::
Dithering. -
enum class GamepadType : std::
uint8_t { Xbox, PlayStation, PlayStationLegacy, Steam, Switch, Nintendo64 } - Gamepad button labels.
-
enum class EpisodeEndOverwriteMode : std::
uint8_t { Always, NoCheatsOnly, HigherScoreOnly } - Episode completion overwrite mode.
-
enum class UnlockableEpisodes : std::
uint32_t { None = 0x00, FormerlyAPrince = 0x01, JazzInTime = 0x02, Flashback = 0x04, FunkyMonkeys = 0x08, ChristmasChronicles = 0x10, TheSecretFiles = 0x20 } - Unlockable episodes, supports a bitwise combination of its member values.
-
enum class EpisodeContinuationFlags : std::
uint8_t { None = 0x00, IsCompleted = 0x01, CheatsUsed = 0x02 } - Episode continuation flags, supports a bitwise combination of its member values.
-
enum class TouchButtonAnchor : std::
uint8_t { BottomLeft = 0, BottomRight = 1, TopLeft = 2, TopRight = 3, TopCenter = 4 } - Anchor edge for a configurable touch button.
-
enum class TouchButtonSlot : std::
uint8_t { Dpad = 0, Fire = 1, Jump = 2, Run = 3, ChangeWeapon = 4, Menu = 5, Console = 6, Count = 7 } - Slot index for each independently configurable touch button.
-
enum class SafeAreaEdge : std::
uint8_t { Left = 0, Top = 1, Right = 2, Bottom = 3, Count = 4 } - Screen edge a safe area inset is measured from.
- enum class SfxFlags { None = 0, Exclusive = 0x01, Looping = 0x02 }
- Sound effect flags.
-
enum class ShieldType : std::
uint8_t { None, Fire, Water, Lightning, Laser, Count } - Shield type.
-
enum class SuspendType : std::
uint8_t { None, Vine, Hook, SwingingVine } - Suspend type.
- enum class WarpFlags { Default = 0, Fast = 0x01, Freeze = 0x02, SkipWarpIn = 0x04, IncrementLaps = 0x10 }
- Warp flags.
-
enum class WeaponStyle : std::
int8_t { Normal, Missile, Popcorn, Capped } - How often a weapon fires while the button is held, as JJ2+ scripts know it.
-
enum class WeaponSpread : std::
int32_t { Normal = 0, Double = 1, Triple = 2, DoubleOrTriple = 3, DirectionAndAim = 4, NormalOrDirectionAndAim = 5, Pepper = 6, NormalOrPepper = 7, Toaster = 8 } - How many shots a weapon fires at once and how, as JJ2+ scripts know it.
-
enum class WeaponKind : std::
uint8_t { Stock, Custom, Script } - What a level makes of one of the weapons.
-
enum class ShotTrigger : std::
uint8_t { Contact, Proximity, Timer } - When a custom shot goes off.
-
enum class ShotLook : std::
uint8_t { Sprite, Glow, Electro, Beam } - How a custom shot is drawn.
-
enum class ShotFlip : std::
uint8_t { Normal, Flipped, Random } - Whether the sprite of a custom shot is flipped, beyond turning to where it's fired.
-
enum class WeaponType : std::
uint8_t { Unknown = UINT8_MAX, Blaster = 0, Bouncer, Freezer, Seeker, RF, Toaster, TNT, Pepper, Electro, Thunderbolt, Count } - Player weapon type.
-
enum class WeatherType : std::
uint8_t { None, Snow, Flowers, Rain, Leaf, Inactive = 0x40, OutdoorsOnly = 0x80 } - Weather type.
Typedefs
-
using LevelStateSnapshot = SmallVector<std::
uint8_t, 0> - Serialized live state of a level.
-
using Uuid = StaticArray<16, std::
uint8_t> - Universally unique identifier (16 bytes).
Functions
-
void ApplyPlatformWebRequestOptions(Death::
IO:: WebRequest& request) - Applies whatever the platform needs on a freshly created web request before it is executed.
- auto GetWeatherKind(WeatherType type) -> WeatherType constexpr
- Returns the type of weather without its flags.
- auto IsWeatherActive(WeatherType type) -> bool constexpr
- Returns whether the weather falls.
Enum documentation
enum class Jazz2:: AnimationLoopMode
#include <Jazz2/AnimationLoopMode.h>
Animation loop mode.
Determines how an animation advances once it reaches its last frame. Stored per Resources::
| Enumerators | |
|---|---|
| Once |
The animation is played once and then remains in its last frame. |
| Loop |
The animation is looped — when reaching the last frame, it begins again at the first one. |
| FixedSingle |
A fixed, single frame is displayed. |
enum class Jazz2:: AnimState
#include <Jazz2/AnimState.h>
Well-known animation state.
Identifies the animation an actor should currently play. Lower bits pack the continuous movement state (horizontal/vertical speed, shooting) so several conditions can be combined, while higher values starting at 0x40000000 are discrete one-shot transition animations (e.g., turning, warping, uppercut stages) and a few aliases reused for object states. A Resources::
| Enumerators | |
|---|---|
| Idle |
Standing still |
| Walk |
Walking |
| Run |
Running |
| Dash |
Dashing |
| VIdle |
No vertical movement |
| Jump |
Jumping (moving upwards) |
| Fall |
Falling (moving downwards) |
| Hook |
Suspended (e.g., on a hook) |
| Shoot |
Shooting |
| Crouch |
Crouching |
| Lookup |
Looking up |
| Dizzy |
Dizzy |
| Buttstomp |
Buttstomping |
| Uppercut |
Uppercut |
| Airboard |
Riding the airboard |
| Hurt |
Hurt |
| Swim |
Swimming |
| Copter |
Using the copter |
| Push |
Pushing an object |
| Swing |
Swinging on a vine |
| Freefall |
Free-falling |
| Lift |
Being lifted |
| Spring |
Launched by a spring |
| RevUp |
Revving up on the spot before launching into a run |
| TransitionRunToIdle |
Transition from running to idle |
| TransitionRunToDash |
Transition from running to dashing |
| TransitionFallToIdle |
Transition from falling to idle |
| TransitionIdleToJump |
Transition from idle to jumping |
| TransitionShootToIdle |
Transition from shooting to idle |
| TransitionHookShootToHook |
Transition from shooting on a hook back to hanging |
| TransitionCopterShootToCopter |
Transition from shooting with the copter back to the copter |
| TransitionUppercutA |
First part of the uppercut |
| TransitionUppercutB |
Second part of the uppercut |
| TransitionUppercutEnd |
End of the uppercut |
| TransitionButtstompStart |
Start of the buttstomp |
| TransitionPoleH |
Spinning around a horizontal pole |
| TransitionPoleV |
Spinning around a vertical pole |
| TransitionPoleHSlow |
Slow spinning around a horizontal pole |
| TransitionPoleVSlow |
Slow spinning around a vertical pole |
| TransitionDeath |
Death animation |
| TransitionTurn |
Turning around |
| TransitionWarpIn |
Warping in |
| TransitionWarpOut |
Warping out |
| TransitionEndOfLevel |
End-of-level animation |
| TransitionWarpInFreefall |
Warping in while free-falling |
| TransitionWarpOutFreefall |
Warping out while free-falling |
| TransitionIdleBored |
Bored idle animation |
| TransitionDashToIdle |
Transition from dashing to idle |
| TransitionIdleToShoot |
Transition from idle to shooting |
| TransitionButtstompEnd |
End of the buttstomp |
| TransitionLiftStart |
Start of being lifted |
| TransitionLiftEnd |
End of being lifted |
| TransitionLedge |
Hanging on a ledge |
| TransitionLedgeClimb |
Climbing up a ledge |
| TransitionRevUpStart |
Start of revving up on the spot |
| TransitionRevUpEnd |
End of revving up, as the player launches away |
| TransitionWalkToIdle |
Last stage of sliding to a halt, below walking pace |
| TransitionHookIdleFlavor |
Idle flourish played while hanging still on a vine |
| TransitionSidekick |
A sidekick played as one animation, ending included |
| TransitionFallShootToFall |
Transition from shooting while falling back to falling |
| TransitionFromFrog |
Transition reverting from the frog morph |
| Activated |
Object is activated |
| TransitionActivate |
Object activation animation |
| TransitionAttack |
Object attack animation |
| TransitionAttackEnd |
End of the object attack animation |
| Uninitialized |
Uninitialized/unspecified state |
| Default |
Default state |
enum class Jazz2:: Direction
#include <Jazz2/Direction.h>
Direction.
Identifies one or more of the four cardinal directions as single-bit flags, with Direction::
| Enumerators | |
|---|---|
| None |
None |
| Up |
Up |
| Down |
Down |
| Left |
Left |
| Right |
Right |
| Any |
Any |
enum class Jazz2:: EventType : std:: uint16_t
#include <Jazz2/EventType.h>
Event type.
Identifies every kind of event or object that can be placed in a level or spawned at runtime — player and checkpoint markers, destructible/modifier scenery tiles, trigger and warp markers, lights, environment objects, enemies and bosses, collectibles and containers. Values below EventType::0x2000-range values are projectiles/objects remotable in multiplayer. The event spawner maps each value to the actor it instantiates.
| Enumerators | |
|---|---|
| Empty |
No event |
| LevelStart |
Player spawn point |
| LevelStartMultiplayer |
Multiplayer player spawn point |
| Checkpoint |
Checkpoint |
| SceneryDestruct |
Tile destructible by weapon fire |
| SceneryDestructButtstomp |
Tile destructible by buttstomp |
| SceneryDestructSpeed |
Tile destructible by running at high speed |
| SceneryCollapse |
Tile that collapses after being stepped on |
| ModifierVine |
Vine the player can climb |
| ModifierOneWay |
One-way platform tile |
| ModifierHook |
Hook the player can hang on |
| ModifierHPole |
Horizontal pole |
| ModifierVPole |
Vertical pole |
| ModifierHurt |
Tile that hurts the player |
| ModifierTube |
Tube that transports the player |
| ModifierRicochet |
Tile that ricochets projectiles |
| ModifierSlide |
Tile the player slides on |
| ModifierDeath |
Tile that instantly kills the player |
| ModifierSetWater |
Sets the water level |
| ModifierLimitCameraView |
Limits the camera view |
| ModifierNoClimb |
Tile the player cannot climb |
| AreaStopEnemy |
Area that stops enemies |
| AreaFloatUp |
Area that makes the player float up |
| AreaHForce |
Area that applies a horizontal force |
| AreaText |
Area that shows a text |
| AreaEndOfLevel |
Area that ends the level |
| AreaCallback |
Area that invokes a script callback |
| AreaActivateBoss |
Area that activates a boss |
| AreaFlyOff |
Area that disables the airboard and the flying carrot, and turns a bird back |
| AreaRevertMorph |
Area that reverts player morph |
| AreaMorphToFrog |
Area that morphs the player into a frog |
| AreaNoFire |
Area that disables firing |
| AreaWaterBlock |
Area that blocks water |
| AreaWeather |
Area that sets the weather |
| AreaAmbientSound |
Area that plays an ambient sound |
| AreaAmbientBubbles |
Area that emits ambient bubbles |
| TriggerCrate |
Crate that toggles a trigger |
| TriggerArea |
Area that sets a trigger |
| TriggerZone |
Zone that toggles a trigger |
| WarpCoinBonus |
Warp to a coin bonus |
| WarpOrigin |
Warp origin |
| WarpTarget |
Warp target |
| LightAmbient |
Ambient light |
| LightSteady |
Steady light |
| LightPulse |
Pulsing light |
| LightFlicker |
Flickering light |
| LightIlluminate |
Illuminating light |
| Spring |
Spring |
| Bridge |
Bridge |
| MovingPlatform |
Moving platform |
| PushableBox |
Pushable box |
| Eva |
Eva (kissable character) |
| Pole |
Pole |
| SignEOL |
End-of-level sign |
| Moth |
Moth |
| SteamNote |
Steam note |
| Bomb |
Bomb |
| PinballBumper |
Pinball bumper |
| PinballPaddle |
Pinball paddle |
| CtfBase |
Capture the flag base |
| BirdCage |
Bird cage |
| Stopwatch |
Stopwatch |
| SpikeBall |
Spike ball |
| AirboardGenerator |
Airboard generator |
| Copter |
Copter |
| RollingRock |
Rolling rock |
| RollingRockTrigger |
Rolling rock trigger |
| SwingingVine |
Swinging vine |
| EnemyTurtle |
Turtle enemy |
| EnemyLizard |
Lizard enemy |
| EnemySucker |
Sucker enemy |
| EnemySuckerFloat |
Floating sucker enemy |
| EnemyLabRat |
Lab rat enemy |
| EnemyHelmut |
Helmut enemy |
| EnemyDragon |
Dragon enemy |
| EnemyBat |
Bat enemy |
| EnemyFatChick |
Fat chick enemy |
| EnemyFencer |
Fencer enemy |
| EnemyRapier |
Rapier enemy |
| EnemySparks |
Sparks enemy |
| EnemyMonkey |
Monkey enemy |
| EnemyDemon |
Demon enemy |
| EnemyBee |
Bee enemy |
| EnemyBeeSwarm |
Bee swarm enemy |
| EnemyCaterpillar |
Caterpillar enemy |
| EnemyCrab |
Crab enemy |
| EnemyDoggy |
Doggy enemy |
| EnemyDragonfly |
Dragonfly enemy |
| EnemyFish |
Fish enemy |
| EnemyMadderHatter |
Madder Hatter enemy |
| EnemyRaven |
Raven enemy |
| EnemySkeleton |
Skeleton enemy |
| EnemyTurtleTough |
Tough turtle enemy |
| EnemyTurtleTube |
Tube turtle enemy |
| EnemyWitch |
Witch enemy |
| EnemyLizardFloat |
Floating lizard enemy |
| BossTweedle |
Tweedle boss |
| BossBilsy |
Bilsy boss |
| BossDevan |
Devan boss |
| BossQueen |
Queen boss |
| BossRobot |
Robot boss |
| BossUterus |
Uterus boss |
| BossTurtleTough |
Tough turtle boss |
| BossBubba |
Bubba boss |
| BossDevanRemote |
Devan remote boss |
| BossBolly |
Bolly boss |
| TurtleShell |
Turtle shell |
| Coin |
Coin |
| Gem |
Gem |
| GemGiant |
Giant gem |
| GemRing |
Gem ring |
| GemStomp |
Gem released by buttstomp |
| Carrot |
Carrot (restores health) |
| CarrotFly |
Flying carrot (grants copter) |
| CarrotInvincible |
Invincibility carrot |
| OneUp |
Extra life |
| FastFire |
Fast fire power-up |
| Food |
Food (contributes to sugar rush) |
| Ammo |
Weapon ammo |
| PowerUpWeapon |
Weapon power-up |
| Crate |
Crate |
| Barrel |
Barrel |
| CrateAmmo |
Crate containing ammo |
| BarrelAmmo |
Barrel containing ammo |
| CrateGem |
Crate containing gems |
| BarrelGem |
Barrel containing gems |
| PowerUpMorph |
Morph power-up monitor |
| PowerUpShield |
Shield power-up monitor |
| RaceCheckpoint |
Ordered track waypoint (passive minimap/race positioning marker, JJ2+ Text event with TextID >= 100) |
| PassthroughEvent |
Event of the original game that the game doesn't use. Kept as it is for the scripts of the level, which read the events of the level as the original game has them. The number of the event is in the first byte of the parameters, its 20 bits of parameters in the next three bytes, see Compatibility:: |
| Count |
Number of well-known events |
| Generator |
Generator (spawns another event repeatedly) |
| WeaponBlaster |
Remotable Blaster projectile |
| WeaponBouncer |
Remotable Bouncer projectile |
| WeaponElectro |
Remotable Electro projectile |
| WeaponFreezer |
Remotable Freezer projectile |
| WeaponPepper |
Remotable Pepper projectile |
| WeaponRF |
Remotable RF projectile |
| WeaponSeeker |
Remotable Seeker projectile |
| WeaponThunderbolt |
Remotable Thunderbolt projectile |
| WeaponTNT |
Remotable TNT |
| WeaponToaster |
Remotable Toaster projectile |
enum class Jazz2:: ExitType : std:: uint8_t
#include <Jazz2/ExitType.h>
Exit type.
Describes how the player left a level when a level change begins. The low bits (extracted with ExitType::
| Enumerators | |
|---|---|
| None |
Unspecified |
| Normal |
Standard exit |
| Warp |
Warp exit |
| Bonus |
Bonus exit |
| Special |
Special exit |
| Boss |
Exit after killing a boxx |
| TypeMask |
Mask for exit type |
| Frozen |
Player should spawn frozen in the next level |
| FastTransition |
Animated fade transitions should be skipped |
enum class Jazz2:: GameDifficulty : std:: uint8_t
#include <Jazz2/GameDifficulty.h>
Game difficulty.
Selected difficulty of a play session — easy, normal or hard — with GameDifficulty::
| Enumerators | |
|---|---|
| Default |
Default/unspecified |
| Easy |
Easy |
| Normal |
Normal |
| Hard |
Hard |
enum class Jazz2:: CameraOverride : std:: uint8_t
#include <Jazz2/ILevelHandler.h>
How ILevelHandler::
| Enumerators | |
|---|---|
| Keep |
Stays as it is |
| Follow |
Follows the player again |
| Fix |
Fixed at the given position |
enum class Jazz2:: WaterInteraction : std:: uint8_t
#include <Jazz2/ILevelHandler.h>
How players move under water, see ILevelHandler::
| Enumerators | |
|---|---|
| Swim |
Players swim |
| LowGravity |
Players walk and jump as on land, but fall more slowly |
enum class Jazz2:: LevelFlags : std:: uint16_t
#include <Jazz2/LevelFlags.h>
Level flags.
Per-level boolean properties stored as single-bit flags — whether the level has a pit (and whether that pit kills instantly), uses a custom palette, is hidden, is a multiplayer level, has laps or capture-the-flag, should use a vertical splitscreen, or defines multiplayer spawn points. Read from the level file and used by the level handler to configure the session. Supports a bitwise combination of its member values.
| Enumerators | |
|---|---|
| None |
None |
| HasPit |
Level has a pit |
| HasPitInstantDeath |
Level has a pit with instant death |
| UseLevelPalette |
Level has custom palette |
| IsHidden |
Level is hidden |
| IsMultiplayerLevel |
Level is for multiplayer |
| HasLaps |
Level has laps |
| HasCaptureTheFlag |
Level has capture the flag |
| HasVerticalSplitscreen |
Vertical splitscreen should be used |
| HasMultiplayerSpawnPoints |
Level has multiplayer spawn points |
| NotEditable |
Level was exported only to be played, the level editor doesn't open it. Only a courtesy to the author, not a protection — it's a single bit of the header anyone can clear. |
| HasPreview |
Level has a preview image (Formats:: Lets the list of custom levels skip the levels without one, the chunk is at the very end of the body. Readers before 4.0.0 ignore it, as they do every bit of the header they don't know. |
enum class Jazz2:: PitType
#include <Jazz2/PitType.h>
Level pit type.
Determines what happens to a player who reaches the bottom of the level. The player can fall forever out of the level boundaries, die instantly, or be kept inside the level by standing on an invisible platform at the bottom edge. Derived from the level's pit-related flags and used to clamp or kill players below the level.
| Enumerators | |
|---|---|
| FallForever |
Player should fall forever out of the level boundaries |
| InstantDeathPit |
Player should die instantly out of the level boundaries |
| StandOnPlatform |
Player should stand on platform, not leaving the level boundaries |
enum class Jazz2:: PlayerAction
#include <Jazz2/PlayerAction.h>
Player action.
Logical input action a player can perform, decoupled from the physical key, button or touch control bound to it. Covers movement, jumping, running, firing, weapon switching and UI actions (menu, console), plus the direct switch-to-weapon shortcuts. PlayerAction::
| Enumerators | |
|---|---|
| Left |
Left |
| Right |
Right |
| Up |
Up |
| Down |
Down |
| Buttstomp |
Buttstomp (Down in the air) |
| Fire |
Fire a weapon |
| Jump |
Jump |
| Run |
Run |
| ChangeWeapon |
Change a weapon |
| Menu |
Menu / Back |
| Console |
Toggle in-game console |
| SwitchToBlaster |
Switch to weapon 1 |
| SwitchToBouncer |
Switch to weapon 2 |
| SwitchToFreezer |
Switch to weapon 3 |
| SwitchToSeeker |
Switch to weapon 4 |
| SwitchToRF |
Switch to weapon 5 |
| SwitchToToaster |
Switch to weapon 6 |
| SwitchToTNT |
Switch to weapon 7 |
| SwitchToPepper |
Switch to weapon 8 |
| SwitchToElectro |
Switch to weapon 9 |
| SwitchToThunderbolt |
Switch to weapon 10 |
| Count |
Number of all actions |
| CountInMenu |
Number of actions usable in a menu |
| None |
No action |
enum class Jazz2:: PlayerType : std:: uint8_t
#include <Jazz2/PlayerType.h>
Player type.
Identifies the playable character — Jazz, Spaz or Lori — plus the temporary Frog and two Bird morphs and a PlayerType::
| Enumerators | |
|---|---|
| None |
None/unspecified |
| Jazz |
Jazz |
| Spaz |
Spaz |
| Lori |
Lori |
| Frog |
Frog |
| Bird |
Yellow bird that attacks with its beak |
| Bird2 |
Red bird that shoots instead |
| Spectate |
Spectate mode |
enum class Jazz2:: CharacterAirJump : std:: int32_t
#include <Jazz2/PlayerType.h>
What a character does when jump is pressed in the air, see CharacterProfile.
| Enumerators | |
|---|---|
| None |
Nothing |
| Copter |
Helicopter ears |
| DoubleJump |
Another jump in the air |
enum class Jazz2:: CharacterGroundJump : std:: int32_t
#include <Jazz2/PlayerType.h>
What a character does when jump is pressed while crouching, see CharacterProfile.
| Enumerators | |
|---|---|
| Crouch |
Keeps crouching |
| Jump |
Ordinary jump |
| Jazz |
Uppercut |
| Spaz |
Sidekick |
| Lori |
Lori's kick |
enum class Jazz2:: RescaleMode
#include <Jazz2/PreferencesCache.h>
Rescale mode.
Selects the post-processing filter applied when the internal viewport is scaled to the output resolution, ranging from pixel-perfect to upscalers (HQ2×, 3×BRZ, SABR, CleanEdge) and CRT emulation. TypeMask isolates the filter while UseAntialiasing is an independent flag.
| Enumerators | |
|---|---|
| None |
None/Pixel-perfect |
| HQ2x |
HQ2× |
| _3xBrz |
3×BRZ |
| CrtScanlines |
CRT Scanlines |
| CrtShadowMask |
CRT Shadow Mask |
| CrtApertureGrille |
CRT Aperture Grille |
| Monochrome |
Monochrome |
| Sabr |
SABR |
| CleanEdge |
CleanEdge |
| Count |
Count of rescale modes |
| TypeMask |
Mask for the rescale mode |
| UseAntialiasing |
Antialiasing should be applied |
enum class Jazz2:: WeaponWheelStyle : std:: uint8_t
#include <Jazz2/PreferencesCache.h>
Weapon wheel style.
Controls whether the radial weapon selection wheel is available and, when enabled, whether it also displays the remaining ammo count for each weapon.
| Enumerators | |
|---|---|
| Disabled |
Disabled |
| Enabled |
Enabled |
| EnabledWithAmmoCount |
Enabled with Ammo count |
enum class Jazz2:: PerformanceMetricsLevel : std:: uint8_t
#include <Jazz2/PreferencesCache.h>
How much the performance metrics overlay shows.
Basic is the frame rate alone (with the round trip time in online multiplayer), which is all the option ever used to show. Detailed adds where the time of a frame goes - the phases of the frame on the CPU, the GPU time or whatever the graphics hardware can tell instead, the draw calls and the memory - averaged over half a second, see nCine::
| Enumerators | |
|---|---|
| Off |
Hidden |
| Basic |
Frame rate only |
| Detailed |
Frame rate and a breakdown of the frame |
enum class Jazz2:: PlayerColorMode : std:: uint8_t
#include <Jazz2/PreferencesCache.h>
When the custom player character color is applied.
Determines the scope in which the user's custom fur recolor takes effect: only for remote players in online multiplayer, additionally for the first local player, or for every local player.
| Enumerators | |
|---|---|
| OnlineOnly |
Only in online multiplayer |
| FirstLocalPlayer |
Online, and the first player in local games |
| AllLocalPlayers |
Online, and all players in local games |
enum class Jazz2:: ParticleQuality : std:: uint8_t
#include <Jazz2/PreferencesCache.h>
Particle quality.
Scales the debris and weather particle effects (see Tiles::
| Enumerators | |
|---|---|
| Off |
No particles |
| Low |
About half of the particles |
| High |
All particles (default) |
| Ultra |
Reserved, behaves as High for now |
enum class Jazz2:: DitheringScope : std:: uint8_t
#include <Jazz2/PreferencesCache.h>
What is drawn in the colors of the 16-bit renderer of JJ2+, see PreferencesCache::
| Enumerators | |
|---|---|
| None |
Nothing, everything is drawn in full colors |
| Layers |
The textured backgrounds and the translucent layers behind the sprites themselves |
| BehindSprites |
Everything behind the sprite layer as one image, the sprites and what is in front of them stay as they are |
| Screen |
The whole scene, as the 16-bit renderer of JJ2+ draws it, the HUD stays as it is |
enum class Jazz2:: GamepadType : std:: uint8_t
#include <Jazz2/PreferencesCache.h>
Gamepad button labels.
Selects which controller family's glyphs and button names are shown in the user interface, so that on-screen prompts match the physical gamepad being used.
| Enumerators | |
|---|---|
| Xbox |
Xbox |
| PlayStation |
PlayStation |
| PlayStationLegacy |
PlayStation (Legacy) |
| Steam |
Steam |
| Switch |
Switch |
| Nintendo64 |
Nintendo 64 |
enum class Jazz2:: EpisodeEndOverwriteMode : std:: uint8_t
#include <Jazz2/PreferencesCache.h>
Episode completion overwrite mode.
Decides under which conditions a newly recorded episode-completion result replaces the previously stored one: always, only when no cheats were used, or only when the new score is higher.
| Enumerators | |
|---|---|
| Always |
Always |
| NoCheatsOnly |
No cheats only |
| HigherScoreOnly |
Higher score only |
enum class Jazz2:: UnlockableEpisodes : std:: uint32_t
#include <Jazz2/PreferencesCache.h>
Unlockable episodes, supports a bitwise combination of its member values.
Bit flags identifying which episodes have been unlocked, mainly used when the application is compiled with SHAREWARE_DEMO_ONLY to gate access to the full episode list. Stored in PreferencesCache::
| Enumerators | |
|---|---|
| None |
None |
| FormerlyAPrince |
Formerly a Prince |
| JazzInTime |
Jazz in Time |
| Flashback |
Flashback |
| FunkyMonkeys |
Funky Monkeys |
| ChristmasChronicles |
Christmas Chronicles |
| TheSecretFiles |
The Secret Files |
enum class Jazz2:: EpisodeContinuationFlags : std:: uint8_t
#include <Jazz2/PreferencesCache.h>
Episode continuation flags, supports a bitwise combination of its member values.
Bit flags recorded alongside a stored EpisodeContinuationState, marking whether the episode has been completed and whether cheats were used during the saved playthrough.
| Enumerators | |
|---|---|
| None |
None |
| IsCompleted |
Episode is complete |
| CheatsUsed |
Cheats have been used |
enum class Jazz2:: TouchButtonAnchor : std:: uint8_t
#include <Jazz2/PreferencesCache.h>
Anchor edge for a configurable touch button.
Identifies which screen corner (or top-center, used for round screens) a touch button's position is measured from, so that its TouchButtonLayout::
| Enumerators | |
|---|---|
| BottomLeft |
Bottom-left corner |
| BottomRight |
Bottom-right corner |
| TopLeft |
Top-left corner |
| TopRight |
Top-right corner |
| TopCenter |
Top-center (used for round screens) |
enum class Jazz2:: TouchButtonSlot : std:: uint8_t
#include <Jazz2/PreferencesCache.h>
Slot index for each independently configurable touch button.
Enumerates the on-screen touch controls (D-pad, fire, jump, run, change weapon, menu and console) that can each be repositioned and resized independently. Used to index the PreferencesCache::
| Enumerators | |
|---|---|
| Dpad |
D-pad / Joystick (moves and resizes as a unit with its sub-zones) |
| Fire |
Fire button |
| Jump |
Jump button |
| Run |
Run button |
| ChangeWeapon |
Change weapon button |
| Menu |
Pause / Menu button |
| Console |
Console button |
| Count |
Number of configurable slots |
enum class Jazz2:: SafeAreaEdge : std:: uint8_t
#include <Jazz2/PreferencesCache.h>
Screen edge a safe area inset is measured from.
Indexes PreferencesCache::
| Enumerators | |
|---|---|
| Left |
Left edge, as a fraction of the view width |
| Top |
Top edge, as a fraction of the view height |
| Right |
Right edge, as a fraction of the view width |
| Bottom |
Bottom edge, as a fraction of the view height |
| Count |
Number of edges |
enum class Jazz2:: SfxFlags
#include <Jazz2/SfxFlags.h>
Sound effect flags.
Options controlling how a sound effect attached to an actor behaves, mainly on the remote peers of an online session, which only ever receive a request to play it. SfxFlags::
| Enumerators | |
|---|---|
| None |
Plain one-shot sound |
| Exclusive |
Replaces the previous instance of the same sound from the same actor, follows the actor while it plays |
| Looping |
Loops until stopped, use together with SfxFlags:: |
enum class Jazz2:: ShieldType : std:: uint8_t
#include <Jazz2/ShieldType.h>
Shield type.
Kind of temporary protective shield a player can carry — fire, water, lightning or laser — or ShieldType::
| Enumerators | |
|---|---|
| None |
No shield |
| Fire |
Fire shield |
| Water |
Water shield |
| Lightning |
Lightning shield |
| Laser |
Laser shield |
| Count |
Count of supported shield types |
enum class Jazz2:: SuspendType : std:: uint8_t
#include <Jazz2/SuspendType.h>
Suspend type.
Describes what is currently holding a player off the ground, suspending normal gravity and movement — a climbable vine, a hook, or a swinging vine — with SuspendType::
| Enumerators | |
|---|---|
| None |
None |
| Vine |
Vine |
| Hook |
Hook |
| SwingingVine |
Swinging vine |
enum class Jazz2:: WarpFlags
#include <Jazz2/WarpFlags.h>
Warp flags.
Options controlling how a player warp is performed, as single-bit flags over the WarpFlags::
| Enumerators | |
|---|---|
| Default |
Standard warp |
| Fast |
Fast warp, without transitions |
| Freeze |
Freezes the player at the end of transition |
| SkipWarpIn |
Skips warp-in transition, the player disappears instantly |
| IncrementLaps |
Number of laps will be incremented (in race levels) |
enum class Jazz2:: WeaponStyle : std:: int8_t
#include <Jazz2/WeaponDefinition.h>
How often a weapon fires while the button is held, as JJ2+ scripts know it.
The weapons of the game keep how they fire, except that tapping fire of a WeaponStyle::
| Enumerators | |
|---|---|
| Normal |
Fires as long as the button is held, tapping fires faster |
| Missile |
Fires once per press |
| Popcorn |
Fires as long as the button is held, at least as often as without fast fire |
| Capped |
Fires as long as the button is held, tapping doesn't fire faster |
enum class Jazz2:: WeaponSpread : std:: int32_t
#include <Jazz2/WeaponDefinition.h>
How many shots a weapon fires at once and how, as JJ2+ scripts know it.
The values are those of SPREAD::Spread of JJ2+.
| Enumerators | |
|---|---|
| Normal |
One shot |
| Double |
Two shots, angled up and down |
| Triple |
Three shots |
| DoubleOrTriple |
Two shots, three when powered up |
| DirectionAndAim |
Two shots, one where the player faces and one where it aims |
| NormalOrDirectionAndAim |
One shot, two when powered up |
| Pepper |
A spray of shots |
| NormalOrPepper |
One shot, a spray when powered up |
| Toaster |
One shot, faster with fast fire |
enum class Jazz2:: WeaponKind : std:: uint8_t
#include <Jazz2/WeaponDefinition.h>
What a level makes of one of the weapons.
| Enumerators | |
|---|---|
| Stock |
The weapon of the game, maybe with other options |
| Custom |
A weapon of the level, which fires shots it describes |
| Script |
A weapon the script of the level sets up |
enum class Jazz2:: ShotTrigger : std:: uint8_t
#include <Jazz2/WeaponDefinition.h>
When a custom shot goes off.
| Enumerators | |
|---|---|
| Contact |
When it hits something |
| Proximity |
When something comes close, it doesn't move once placed |
| Timer |
When its time runs out |
enum class Jazz2:: ShotLook : std:: uint8_t
#include <Jazz2/WeaponDefinition.h>
How a custom shot is drawn.
| Enumerators | |
|---|---|
| Sprite |
Its sprite |
| Glow |
Its sprite added to what's behind, as the pepper spray |
| Electro |
A swirl of sparks of its sprite left behind it, as the electro blaster |
| Beam |
A beam from the muzzle, as the thunderbolt, as long as it would fly in its time |
enum class Jazz2:: ShotFlip : std:: uint8_t
#include <Jazz2/WeaponDefinition.h>
Whether the sprite of a custom shot is flipped, beyond turning to where it's fired.
| Enumerators | |
|---|---|
| Normal |
Not flipped |
| Flipped |
Flipped |
| Random |
Each shot at random |
enum class Jazz2:: WeaponType : std:: uint8_t
#include <Jazz2/WeaponType.h>
Player weapon type.
Identifies one of the player's weapons — Blaster, Bouncer, Freezer, Seeker, RF, Toaster, TNT, Pepper, Electro and Thunderbolt — with WeaponType::
| Enumerators | |
|---|---|
| Unknown |
Unspecified |
| Blaster |
Blaster |
| Bouncer |
Bouncer |
| Freezer |
Freezer |
| Seeker |
Seeker |
| RF |
RF |
| Toaster |
Toaster |
| TNT |
TNT |
| Pepper |
Pepper |
| Electro |
Electro |
| Thunderbolt |
Thunderbolt |
| Count |
Number of weapons |
enum class Jazz2:: WeatherType : std:: uint8_t
#include <Jazz2/WeatherType.h>
Weather type.
Selects the falling-particle weather effect rendered over a level — snow, flowers, rain or leaves — or WeatherType::
| Enumerators | |
|---|---|
| None |
None |
| Snow |
Snow |
| Flowers |
Flowers |
| Rain |
Rain |
| Leaf |
Leaf |
| Inactive |
Nothing falls, the type and WeatherType:: |
| OutdoorsOnly |
Outdoors only, should be used in combination with other options |
Typedef documentation
using Jazz2:: LevelStateSnapshot = SmallVector<std:: uint8_t, 0>
#include <Jazz2/LevelInitialization.h>
Serialized live state of a level.
Complete state of a level — tile map, event map, players and all actors — taken when the player leaves the level to a special level (see LevelInitialization::
using Jazz2:: Uuid = StaticArray<16, std:: uint8_t>
#include <Jazz2/PreferencesCache.h>
Universally unique identifier (16 bytes).
Fixed 16-byte array used as a stable identity, such as the unique player and server IDs persisted in PreferencesCache.
Function documentation
void Jazz2:: ApplyPlatformWebRequestOptions(Death:: IO:: WebRequest& request)
#include <Jazz2/PlatformWebRequest.h>
Applies whatever the platform needs on a freshly created web request before it is executed.
Nothing anywhere else, and nothing at all on a platform whose TLS stack can find its own trust store. The PS Vita cannot: VitaSDK's libcurl verifies against the firmware's own store under vs0:, a mount point an application's sandbox does not contain - opening it fails with ENOENT, not a permission error - and the TLS stack linked into the executable is not the system one that iTLS-Enso and friends patch, so nothing installed on the console supplies it either. Without this every HTTPS request fails to verify, which takes the server list, the update check and script web requests with it. The PSP is in the same position for a simpler reason: its libcurl is built on mbedTLS with a Unix default path (/etc/ssl/certs/ca-certificates.crt) that exists nowhere on a memory stick. The Nintendo 3DS is the PSP's case again: devkitPro's libcurl is built on mbedTLS with the same default path, and the console's own trust store is not something a homebrew title can read.
The bundle therefore travels with the content (the CMake packaging fetches it at configure time) and is named here rather than inside WebRequest: where a game keeps its files is not something that layer can know, and the handle it already exposes is enough to say so from outside.
WeatherType Jazz2:: GetWeatherKind(WeatherType type) constexpr
#include <Jazz2/WeatherType.h>
Returns the type of weather without its flags.
bool Jazz2:: IsWeatherActive(WeatherType type) constexpr
#include <Jazz2/WeatherType.h>
Returns whether the weather falls.