Chrono API

Chrono API is a Minecraft Forge mod for controlling the flow of time.

Originally extracted from Deus Chrono-Machina, it separates the reusable time-control engine from the original mod’s gameplay content. Other mods and Palladium power packs can use its time-manipulation features without requiring Deus Chrono-Machina itself.

THIS MOD IS NOT COMPATIBLE WITH Deus Chrono-Machina v6.x (just remind)

AND IT'S A REQUIRED DEPENDENCY FOR Deus Chrono-Machina v7.x (not released yet)

Features

• Slow down or accelerate supported simulation from 0.0001 to 100 TPS. Normal speed is 20 TPS.
• Pause and resume time globally or within an owner-following field.
• Create named time fields targeting entities, blocks, geometric areas, chunks, or loaded dimensions.
• Exempt entities from time pause and tick-rate changes through UUID whitelists.
• Rewind available recorded history, including entities, blocks, items, projectiles, inventories, and supported player state.
• Integrate time control through a Java API or optional Palladium abilities and conditions.
• Extend the engine through custom immunity, rewind-protection, player-state, and client-presentation hooks.
• Use /chrono commands for gameplay integrations, testing, and server administration.

Rewind restores recorded state rather than reversing every operation performed by the server. Coverage depends on loaded history, supported state, and the integration paths used by other mods.

Palladium Compatibility

With Palladium installed, power packs can access Chrono API through JSON abilities and conditions in the chrono_api namespace.

Palladium is optional. The core mod, commands, and Java API work without it.

Palladium compatibility was contributed by Ender2460.

Abilities

Ability ID	Description
chrono_api:stop_time	Pause time around the player, with a configurable radius and UUID exemptions.
chrono_api:tick_rate	Set a player-following field’s tick rate using rate, radius, and whitelist.
chrono_api:dynamic_tick_rate	Calculate the tick rate from a supported dynamic value source.
chrono_api:rewind	Request a local rewind using the configured seconds value.
chrono_api:dynamic_rewind	Calculate the rewind duration from a supported dynamic value source.
chrono_api:chrono_immunity	Whitelist the ability holder while enabled and remove that whitelist entry when the ability ends.
chrono_api:whitelist	Expose UUID-list whitelist operations through property_type and optional end-of-ability cleanup. See the implementation note below.

The pause, tick-rate, and rewind abilities currently operate through server-side player holders. The immunity and whitelist abilities accept living-entity holders.

Configuration

• rate: Tick rate used by fixed-rate abilities or as the calculation operand for dynamic rate control.
• radius: Explicit owner-following radius for pause and rate control. Use 1–128 blocks. The default -1 omits the radius override; it does not select global time control.
• seconds: Rewind duration from 0.1 to 100 seconds.
• whitelist: An array of valid entity UUID strings.
• property_type: add or remove for the dedicated whitelist ability.
• remove_last_tick: When enabled for an add configuration, remove the configured UUID entries when the ability ends.

Current implementation note: The dedicated chrono_api:whitelist ability’s add branch currently falls through to remove. Until corrected, use /chrono whitelist add, chrono_immunity, or the whitelist property of the pause/rate abilities when adding exemptions.

Dynamic Value Sources

Both dynamic abilities support:

dynamic_property	Value source
scoreboard	The player’s score in the objective named by property.
energy_bar	The current value of the holder’s energy bar named by property.
palladium_property	A numeric property on the current ability instance, selected by property.
xp_level	The player’s experience level.
xp	The player’s progress toward the next experience level, not total XP points.

The multiplier field selects the calculation:

• add: source value + configured rate or seconds
• multiply: source value × configured rate or seconds
• divide: source value ÷ configured rate or seconds

Avoid a zero divisor. Dynamic rewind starts only when the calculated duration is within 0.1–100 seconds.

Ability Examples

These are ability-definition fragments for a Palladium power’s abilities section. Configure activation conditions and cooldowns through Palladium as appropriate.

Pause a 32-block-radius field:

{
  "type": "chrono_api:stop_time",
  "radius": 32.0,
  "whitelist": []
}

Give the holder a whitelist-based time exemption while enabled:

{
  "type": "chrono_api:chrono_immunity"
}

Calculate the tick rate as the player’s XP level multiplied by 2:

{
  "type": "chrono_api:dynamic_tick_rate",
  "dynamic_property": "xp_level",
  "multiplier": "multiply",
  "rate": 2.0,
  "radius": 32.0,
  "whitelist": []
}

Request a five-second local rewind:

{
  "type": "chrono_api:rewind",
  "seconds": 5.0
}

Conditions

Condition ID	Description
chrono_api:is_paused	Check whether the current entity is affected by time pause.
chrono_api:is_rewound	Check whether the current entity is controlled by active rewind playback.
chrono_api:is_rewinding	Check whether any rewind is active; this is not a per-entity check.
chrono_api:is_whitelisted	Check a configured UUID against client, server, or both whitelist views using side_type.
chrono_api:tick_rate	Check whether the shared server tick-rate value is between min_ticks and max_ticks, inclusive.
chrono_api:is_chrono_immune	Check the current entity’s effective time-scheduler immunity, including whitelist and policy-based exemptions.

For is_whitelisted, supply one UUID explicitly: the current implementation evaluates only the first listed UUID, and an empty array does not select the current player.

Condition-definition examples:

{
  "type": "chrono_api:is_chrono_immune"
}

{
  "type": "chrono_api:tick_rate",
  "min_ticks": 0.0001,
  "max_ticks": 10.0
}

Whitelist-based immunity should not be treated as a guarantee of protection from every restoration operation. Precise rewind exclusions belong in field exclusions or rewind integration.

Commands

All commands require permission level 2. Command names are case-sensitive.

Basic Time Control

/chrono settickrate <TPS> [radius <blocks>]
/chrono pausetime <true|false> [radius <blocks>]
/chrono clearfield

Player-issued pause and rate commands control a following field with a default radius of 40 blocks. The optional radius accepts 1–128 blocks.

Console and command-block sources control the shared global field and cannot use the radius suffix.

Rewind

/chrono rewindTime <seconds>
/chrono rewindTime <seconds> at <x> <y> <z>
/chrono rewindTime <seconds> near <entity>
/chrono rewindTime <seconds> in <dimension> at <x> <y> <z>

Durations accept decimal values from 0.1 to 100 seconds. Ordinary rewind uses available history within a 32-block-radius area. The near form selects an area around the entity, not an entity-only rewind.

Whitelist and Diagnostics

/chrono whitelist add <targets>
/chrono whitelist remove <targets>
/chrono whitelist clear
/chrono whitelist list
/chrono diagnostics
/chrono diagnostics entity <target>

Named Time Fields

/chrono field create <id> <scope>
/chrono field rate <id> <TPS>
/chrono field pause <id> <true|false>
/chrono field step <id> <ticks>
/chrono field preview <id> rewind <seconds>
/chrono field rewind <id> <seconds>
/chrono field stop <id>
/chrono field clear <id>
/chrono field remove <id>

Supported scopes include entity selectors, exact UUIDs, blocks, block regions, spheres, boxes, cylinders, following entities, chunks, dimensions, and global selection.

Example:

/chrono field create arena sphere 0 64 0 32
/chrono field rate arena 5
/chrono field pause arena true
/chrono field step arena 1
/chrono field pause arena false
/chrono field remove arena

clear resets a named field’s controls while retaining its selection. remove deletes the field.

Java API

The main entry point is chrono_api.api.ChronoTime. Run time-control mutations on the logical server thread.

import chrono_api.api.ChronoTime;
import net.minecraft.server.level.ServerPlayer;

public void slowTime(ServerPlayer owner) {
    ChronoTime.setTickrate(8.0F, owner, 32.0D);
}

public void stopTime(ServerPlayer owner) {
    ChronoTime.pause(true, owner, 32.0D);
}

public void restoreTime(ServerPlayer owner) {
    ChronoTime.clear(owner);
}

public boolean rewindTime(ServerPlayer player) {
    return ChronoTime.rewind(
            player.serverLevel(),
            player.position(),
            5.0D,
            player
    );
}

Passing an entity creates or updates an owner-following field. Passing null controls the shared global field:

ChronoTime.setTickrate(8.0F, null);
ChronoTime.pause(true, null);

// Resume global time and restore 20 TPS.
ChronoTime.clear(null);

State-query interfaces include:

ChronoTime.isPaused(entity);
ChronoTime.tickrate(entity);
ChronoTime.isRewinding(entity);
ChronoTime.isRewinding();

For named selections and advanced operations, use ChronoTime.createField(...), TimeScope, and TimeControl.

Always check the result of a rewind request. It may fail when usable history is unavailable or another rewind is already active.

Requirements

• Minecraft 1.20.1
• Minecraft Forge 47.x
• Java 17
• Palladium only when using the optional power-pack integration

Install Chrono API on both the server and connecting clients.