Remble Staffing
📎 1 file 4,323 chars
📄
pasted-code-1795316229574.txt
txt 149 lines
▶
# ORBITAL COLLECTION — FUNCTIONAL ENTITIES ONLY

The orbital collection must focus on actual Minecraft entities, projectiles, and useful effects.

Do NOT include pointless orbitals such as obsidian blocks, diamond blocks, random ingots, or ordinary decorative items.

Every orbital should have a purpose, unique visual appearance, and functional behaviour.

## 1. Explosive Orbitals

These are a priority.

- **Primed TNT** — Already-lit TNT entities orbiting the player.
- **TNT Minecarts** — Primed TNT minecarts orbiting in circular formations.
- **Creeper Orbital** — Creepers orbiting the player.
- **Charged Creeper Orbital** — Charged creepers with lightning effects.
- **End Crystal Orbital** — End crystals rotating around the player.
- **Fireball Orbital** — Ghast fireballs orbiting the player.
- **Small Fireball Orbital** — Blaze fireballs.
- **Wither Skull Orbital** — Wither skull projectiles.
- **Dragon Fireball Orbital** — Dragon fireballs.
- **Firework Orbital** — Firework rockets orbiting before launching.
- **Explosive Meteor Orbital** — Falling explosive projectiles.

## 2. Mob Orbitals

Use actual Minecraft entities with their real models and textures.

Prioritise useful mobs:

- Warden
- Iron Golem
- Snow Golem
- Creeper
- Charged Creeper
- Ravager
- Wither Skeleton
- Blaze
- Ghast
- Enderman
- Evoker
- Vindicator
- Pillager
- Guardian
- Elder Guardian
- Shulker
- Phantom
- Breeze
- Bogged
- Witch
- Wither
- Ender Dragon
- Wolf
- Allay

Also automatically support other mobs with registered spawn eggs, including mobs added by compatible mods.

Mob orbitals should have configurable AI, targeting, and attack behaviour. Default to harmless orbiting.

## 3. Projectile Orbitals

Use actual Minecraft projectile entities.

- Arrows
- Spectral Arrows
- Tridents
- Snowballs
- Eggs
- Ender Pearls
- Splash Potions
- Lingering Potions
- Experience Bottles
- Fire Charges
- Wind Charges
- Breeze Wind Charges
- Dragon Fireballs
- Wither Skulls
- Ghast Fireballs
- Blaze Fireballs

Projectiles should rotate around the player and optionally launch towards a selected target.

## 4. Environmental Orbitals

- Lightning Orbital
- Rain Orbital
- Thunderstorm Orbital
- Snowstorm Orbital
- Firestorm Orbital
- Meteor Shower
- Falling Anvil Orbital
- Falling Dripstone Orbital
- Water Stream Orbital
- Lava Orbital

## 5. Special Orbital Abilities

Create unique abilities rather than simply making everything rotate.

Examples:

**TNT Barrage**
Multiple rings of primed TNT rotate overhead before launching outward.

**Minecart Apocalypse**
TNT minecarts rotate in several rings with increasing rotation speeds.

**Warden Protection**
Wardens surround the player and protect their owner from hostile mobs.

**Meteor Shower**
Multiple falling meteors appear overhead and descend towards the ground.

**Lightning Cage**
Lightning effects rotate around the player in a spherical formation.

**Projectile Storm**
A configurable selection of arrows, fireballs, tridents and other projectiles orbit before launching.

**Creeper Army**
Creepers rotate around the player, with optional charged variants.

**End Crystal Shield**
End crystals rotate in a protective spherical formation.

**Wither Storm**
Wither skulls rotate around the player before launching.

**Ghast Barrage**
Multiple ghast fireballs rotate in several rings.

## 6. IMPORTANT FUNCTIONAL REQUIREMENTS

- Primed TNT must actually be primed, not just a TNT block model.
- TNT minecarts must use actual TNT minecart entities.
- Fireballs must use actual projectile entities.
- Wither skulls must use actual wither skull projectiles.
- Mob orbitals must use real Minecraft entities.
- Every orbital must have its own configuration.
- Support multiple rings and configurable entity counts.
- Allow orbitals to launch, remain stationary, or continuously rotate.
- Add configurable fuse times, cooldowns, rotation speeds and launch behaviour where applicable.
- Ensure owner protection works correctly.
- Ensure entities and scheduled tasks are cleaned up when orbitals stop.
- Include server performance limits and configurable damage settings.

Do not replace functional entities with decorative block displays or fake particle models.

The goal is to make RembleOrbital a massive collection of genuinely functional Minecraft orbital abilities.
Kodari AI
KodariToday at 3:00 am 3
OrbitalCollection
A Fabric mod for Minecraft 1.21.1 that adds a massive collection of functional orbital abilities. Players can summon rings of primed TNT, TNT minecarts, mobs like Wardens and Creepers, projectiles including fireballs and wither skulls, and environmental effects like lightning and meteor showers. Each orbital uses real Minecraft entities with configurable rotation speeds, ring counts, launch behaviour, fuse times, cooldowns, and damage settings. Includes owner protection, automatic entity cleanup, server performance limits, and special abilities like TNT Barrage, Warden Protection, and End Crystal Shield.
  • Create a server-side orbital controller with bounded entity counts and cleanup.

  • Add commands to start and stop harmless mob rings.

  • Keep unsupported explosive, projectile, and environmental abilities explicit rather than substituting decorative entities.

Created a partial foundation: /orbital start <mob> creates four harmless mob orbitals, and /orbital stop removes them. Orbitals also stop on disconnect, death, dimension change, or server shutdown.

This does not yet include the requested explosives, projectiles, environmental effects, special abilities, configuration, targeting, or full mob support.

Remble Staffing

new project idea:

📎 1 file 10,203 chars
📄
pasted-code-1795317323519.txt
txt 444 lines
▶
# 14. ALL-IN-ONE MOD EXPANSION — REMBLECORE

Expand RembleOrbital into a complete all-in-one Minecraft abilities, weapons, effects, animations and admin utility mod.

Keep the existing orbital system, but introduce additional systems that integrate with it.

The mod should feel like a professionally developed custom Minecraft plugin recreated as a Fabric mod.

# 15. ADVANCED VISUAL EFFECTS AND CUTSCENES

This is extremely important.

I want visually impressive abilities, not basic particle effects.

Implement a custom effects engine supporting:

- Cinematic camera animations.
- Screen shake.
- Flash effects.
- Custom particle formations.
- Lightning animations.
- Shockwave animations.
- Explosion effects.
- Energy beams.
- Circular particle rings.
- Expanding particle spheres.
- Screen overlays.
- Dramatic activation animations.
- Custom sound sequences.
- Boss-style ability introductions.
- Smooth transitions.
- Animated ability cooldown indicators.

### Orbital Cutscenes

Create unique cutscenes for major abilities.

Examples:

**TNT Apocalypse**
1. Camera focuses on the player.
2. The sky darkens.
3. TNT begins appearing overhead.
4. Multiple rings rotate around the player.
5. Dramatic sound effect plays.
6. TNT launches or activates.

**Warden Summoning**
1. Dark particles surround the player.
2. Ground shockwave effect.
3. Warden summoning animation.
4. Multiple Wardens appear in orbital formations.
5. Deep ambient sound plays.

**Meteor Shower**
1. Camera looks towards the sky.
2. Sky becomes darker.
3. Meteors appear overhead.
4. Fire trails follow the meteors.
5. Impact effects occur.

Cutscenes must be synchronised in multiplayer.

Allow cutscenes to be skipped using a configurable key or command.

Do not forcibly take control of a player's camera indefinitely.

# 16. JUMPSCARE SYSTEM

Add:

`/jumpscare `

This command triggers a scary cinematic jumpscare for the selected player.

Create a genuinely surprising horror-style effect.

Possible effects:
- Sudden scary image overlay.
- Creepy entity appearing close to the player's viewpoint.
- Sudden sound effect.
- Screen flash.
- Short camera shake.
- Sudden disappearance.
- Creepy message.

The jumpscare must be client-rendered for the target player.

Do not use copyrighted horror images, sounds or characters.

Requirements:
- Only the targeted player sees the jumpscare.
- Other players should not see the private overlay.
- Configurable duration.
- Configurable sound.
- Configurable intensity.
- Configurable cooldown.
- `/jumpscare ` permission restricted.
- Add `/jumpscare toggle` to disable receiving jumpscares.

Make it scary but do not permanently blind, disorient or trap players.

# 17. PASSWORD AUTHENTICATION SYSTEM

Before using any RembleCore commands, players must authenticate.

Command:

`/password `

The password is:

`emont`

Password comparison must be case-insensitive.

These should all work:

- `/password emont`
- `/password Emont`
- `/password EMONT`
- `/password eMoNt`

Once authenticated, players can use permitted RembleCore commands.

### Authentication requirements

- Unauthenticated players cannot access protected commands.
- Authentication should persist for the player's current session.
- Disconnecting logs the player out.
- Incorrect passwords should display an error.
- Add configurable failed-attempt limits.
- Add a configurable authentication timeout.
- Never expose the password in chat, logs or command suggestions.
- Use constant-time comparison where practical.

IMPORTANT: This is an in-game feature gate, not secure account authentication. Do not store the plaintext password in unnecessary places.

Allow administrators to configure whether authentication is required for particular commands.

# 18. ALL-IN-ONE GUI

Create:

`/gui `

The password argument must be checked against the configured password, case-insensitively.

Also create:

`/gui`

This opens the GUI for an already authenticated player.

Create an extremely polished GUI.

Theme:
- Dark purple.
- Black.
- Violet gradients where supported.
- Custom item icons.
- Attractive titles.
- Detailed item lore.
- Pagination.
- Search system.
- Category navigation.

### Main GUI categories

1. Orbital System
2. Weapons
3. Abilities
4. Effects
5. Cutscenes
6. Jumpscares
7. Player Management
8. Configuration
9. Admin Tools

### Orbital System GUI

- View every orbital.
- Preview orbitals.
- Give orbital rods.
- Configure ring amounts.
- Configure rotation speeds.
- Configure entity counts.
- Configure cooldowns.
- Stop active orbitals.

### Weapons GUI

- View all custom weapons.
- Give weapons.
- Preview abilities.
- Configure weapon settings.
- Configure cooldowns.

### Effects GUI

- Preview particle effects.
- Trigger visual effects.
- Manage sound effects.
- Configure screen effects.

### Player Management GUI

- View online players.
- Give selected players items.
- Trigger authorised effects.
- Manage player abilities.
- Stop player orbitals.

### Configuration GUI

- Change global settings.
- Change orbital settings.
- Change weapon settings.
- Configure authentication.
- Configure cooldowns.
- Reload configurations.

All GUI buttons must actually work.

# 19. CUSTOM WEAPONS SYSTEM

Create a collection of unique custom weapons.

Every weapon must have its own ability, animations, cooldowns and effects.

## DASH SWORD

Create a custom sword called:

&b&lDash Sword

Ability:

Right-click to dash forward.

Requirements:
- Dash up to 30 blocks.
- 10-second cooldown.
- Smooth movement.
- Blue energy trail.
- Dash sound effect.
- Custom activation animation.
- Prevent dashing through solid blocks.
- Prevent suffocation.
- Respect world borders.
- Configurable distance.
- Configurable cooldown.

Support horizontal and vertical directional movement where safe.

## ORBITAL MACE

Create a custom mace called:

&5&lOrbital Mace

This weapon connects directly to the orbital system.

### Right-click

Activates the currently selected orbital.

For example:
- Warden Orbital.
- Primed TNT Orbital.
- TNT Minecart Orbital.
- Ghast Fireball Orbital.
- Wither Skull Orbital.
- Meteor Orbital.

### Shift + Right-click

Opens an orbital selection GUI.

The GUI should display:
- Orbital icon.
- Orbital name.
- Orbital description.
- Orbital preview.
- Cooldown information.
- Currently selected orbital.

Clicking an orbital selects it for the mace.

Display the selected orbital in the mace's lore.

Example:

&5&lOrbital Mace

&7Selected Orbital: &cPrimed TNT

&7Right-click to activate.

&7Shift + Right-click to select.

The mace must remember its selected orbital.

Each mace should have its own selection stored using persistent item data.

# 20. PRIVATE ITEM NAMES AND LORE

Implement an item privacy system.

For certain custom weapons, only the player who claimed the item should see its custom name and lore.

Example:

Player A owns an Orbital Mace.

Player A sees:

&5&lOrbital Mace
&7Selected Orbital: &cWarden

Player B sees the normal underlying item appearance and does not see the private custom name or lore.

Requirements:
- Each item has a unique persistent identifier.
- Each item records its original claimant UUID.
- Only the claimant sees the custom display name and lore.
- Other players see the normal base item name and appearance.
- The private information must not be exposed through ordinary inventory viewing.
- Item ownership must persist after server restarts.
- Dropping and picking up an item must not change its claimant.
- Prevent duplication exploits.
- Admins can configure whether items are transferable.

Use appropriate client-side rendering or packet handling to implement private item appearance correctly.

Do not simply hide the lore in a GUI while leaving it visible elsewhere.

# 21. ADDITIONAL WEAPONS

Create more custom weapons over time:

- Dash Sword.
- Orbital Mace.
- Thunder Sword.
- Void Blade.
- Gravity Hammer.
- Meteor Staff.
- Lightning Trident.
- Shadow Dagger.
- Firestorm Axe.
- Frost Blade.

Every weapon should have a genuinely unique ability.

Avoid making all weapons variations of the same attack.

# 22. UNIFIED COMMAND SYSTEM

Organise everything under the RembleCore command framework.

Commands should include:

`/orbital rod give  `

`/orbital rod config  `

`/orbital stop`

`/gui`

`/gui `

`/password `

`/jumpscare `

`/jumpscare toggle`

`/remblecore reload`

`/remblecore info`

Provide tab completion and permission checks.

# 23. FINAL QUALITY REQUIREMENTS

This must be a complete all-in-one mod.

Do not create separate unfinished systems.

All features must integrate properly.

Requirements:
- Dedicated-server support.
- Multiplayer synchronisation.
- Client-side rendering for custom overlays and cutscenes.
- Proper networking.
- Custom item models where supported.
- Custom sound assets or original sound effects.
- Configurable settings.
- Persistent item data.
- Proper player ownership tracking.
- Optimised tick handling.
- No memory leaks.
- No abandoned entities.
- No broken GUI interactions.
- No placeholder abilities.

Because cutscenes, screen overlays, camera effects and private item appearances require client-side functionality, implement the necessary client and server components. Provide a matching client installation if required.

# 24. DELIVERY

Deliver:
- Complete source project.
- Complete Gradle project.
- Server-side mod JAR.
- Required client-side mod JAR if separate.
- All assets.
- Configuration files.
- Installation instructions.
- Complete command documentation.
- Testing results.

Build and test the entire project.

Do not claim that a feature is complete unless it has actually been implemented.

**FINAL VISION:**

RembleCore should be an all-in-one Minecraft mod containing:

- Massive orbital collection.
- Primed TNT and TNT minecart systems.
- Functional mob orbitals.
- Custom weapons.
- Special abilities.
- Cinematic cutscenes.
- Horror jumpscares.
- Custom GUI.
- Password authentication.
- Private weapon names and lore.
- Advanced visual and sound effects.

Make this a polished, feature-rich mod that feels like a premium custom Minecraft experience.
Kodari AI
KodariToday at 3:17 am 3
  • Preserve the existing mob orbitals and add bounded, configurable ring behavior.

  • Keep unfinished systems explicit; password commands cannot safely guarantee secrecy through normal Minecraft command handling.

Added configurable mob-orbital rings, entity counts, radius, speed, and owner limits. Configuration and installation details are in README.md.

RembleCore is not complete. Weapons, authentication, permissions, GUI, cinematics, jumpscares, private item data, and explosive/projectile orbitals remain unimplemented. The existing orbital commands are unrestricted.

The project was not built or tested in this session.

Remble Staffing

make it please

Kodari AI
KodariToday at 3:24 am 2
  • Restrict the existing orbital commands to operators.

  • Add RembleCore info and configuration reload commands, while preserving orbital cleanup.

Added operator restrictions, /remblecore info, and /remblecore reload. Reloading stops active orbitals before applying settings.

RembleCore is still incomplete: the requested weapons, GUI, authentication, cinematics, jumpscares, private item data, and explosive and projectile orbitals are not implemented. The project was not built or tested in this session.

Remble Staffing

make it right now.

Kodari AI
KodariToday at 3:28 am 3

I’ll build on the existing orbital system first, keeping new entities bounded and cleaned up. I’ll distinguish implemented features from anything still missing.

Added real primed-TNT orbitals and /orbital launch, with a configurable launch fuse. Launched TNT can damage the owner and terrain; /orbital stop removes it before detonation.

RembleCore remains incomplete: the weapons, GUI, authentication, cinematics, jumpscares, private item data, and most requested orbital types are not implemented. The changes have not been built or tested.

Remble Staffing

MAKE IT BRO, stop pasuing. make a .jar

Kodari AI
KodariToday at 3:38 am 3

Added support for registered spawn-egg mobs, including compatible modded mobs, and cleanup of saved orbital entities after a restart.

RembleCore is still incomplete. The requested weapons, GUI, cinematics, authentication, jumpscares, and most orbital abilities have not been implemented or tested.

To get the current JAR:

  1. Click Compile in the top bar, or on phone tap ⋮ → Compile Project.

  2. Click Compile in the window.

  3. If it succeeds, click Download. If it fails, use Auto-fix.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
gradle.properties
README.md
settings.gradle
Code
6 387
src/main/java/com/remble/orbital/RembleOrbital.java
package com.remble.orbital;

import com.mojang.brigadier.arguments.StringArgumentType;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import net.fabricmc.api.ModInitializer;
import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
import net.fabricmc.fabric.api.event.lifecycle.v1.ServerEntityEvents;
import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents;
import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityType;
import net.minecraft.entity.SpawnReason;
import net.minecraft.entity.TntEntity;
import net.minecraft.entity.mob.MobEntity;
import net.minecraft.item.SpawnEggItem;
import net.minecraft.registry.Registries;
import net.minecraft.server.command.CommandManager;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.server.world.ServerWorld;
import net.minecraft.text.Text;

public final class RembleOrbital implements ModInitializer {
    private static final Map<UUID, List<Entity>> ORBITS = new HashMap<>();
    private static final Set<Entity> LAUNCHED = new HashSet<>();
    private static final Path CONFIG_PATH = Path.of("config", "rembleorbital.properties");
    private static int rings = 1;
    private static int entitiesPerRing = 4;
    private static int maxOwners = 16;
    private static double radius = 3.0;
    private static double speed = 0.04;
    private static int tntFuse = 40;
    private static final Map<String, EntityType<?>> TYPES = Map.ofEntries(
            Map.entry("warden", EntityType.WARDEN),
            Map.entry("primed_tnt", EntityType.TNT),
            Map.entry("iron_golem", EntityType.IRON_GOLEM),
            Map.entry("snow_golem", EntityType.SNOW_GOLEM),
            Map.entry("creeper", EntityType.CREEPER),
            Map.entry("ravager", EntityType.RAVAGER),
            Map.entry("wither_skeleton", EntityType.WITHER_SKELETON),
            Map.entry("blaze", EntityType.BLAZE),
            Map.entry("ghast", EntityType.GHAST),
            Map.entry("enderman", EntityType.ENDERMAN),
            Map.entry("evoker", EntityType.EVOKER),
            Map.entry("vindicator", EntityType.VINDICATOR),
            Map.entry("pillager", EntityType.PILLAGER),
            Map.entry("guardian", EntityType.GUARDIAN),
            Map.entry("elder_guardian", EntityType.ELDER_GUARDIAN),
            Map.entry("shulker", EntityType.SHULKER),
            Map.entry("phantom", EntityType.PHANTOM),
            Map.entry("breeze", EntityType.BREEZE),
            Map.entry("bogged", EntityType.BOGGED),
            Map.entry("witch", EntityType.WITCH),
            Map.entry("wolf", EntityType.WOLF),
            Map.entry("allay", EntityType.ALLAY)
    );
    private long ticks;

    @Override
    public void onInitialize() {
        loadConfig();
        ServerEntityEvents.ENTITY_LOAD.register((entity, world) -> {
            if (entity.getCommandTags().contains("rembleorbital.temporary")) entity.discard();
        });
        CommandRegistrationCallback.EVENT.register((dispatcher, registries, environment) -> dispatcher.register(
                CommandManager.literal("orbital")
                        .requires(CommandManager.requirePermissionLevel(CommandManager.GAMEMASTERS_CHECK))
                        .then(CommandManager.literal("stop").executes(context -> {
                            stop(context.getSource().getPlayerOrThrow().getUuid());
                            context.getSource().sendFeedback(() -> Text.literal("Orbital stopped."), false);
                            return 1;
                        }))
                        .then(CommandManager.literal("launch").executes(context -> {
                            ServerPlayerEntity player = context.getSource().getPlayerOrThrow();
                            List<Entity> entities = ORBITS.get(player.getUuid());
                            int count = 0;
                            if (entities != null) {
                                for (Entity entity : entities) {
                                    if (entity instanceof TntEntity tnt && LAUNCHED.add(entity)) {
                                        tnt.setFuse(tntFuse);
                                        tnt.setNoGravity(false);
                                        tnt.setVelocity(player.getRotationVec(1.0f).multiply(1.5));
                                        count++;
                                    }
                                }
                            }
                            int launched = count;
                            context.getSource().sendFeedback(() -> Text.literal("Launched " + launched + " primed TNT. Explosions can damage players and terrain."), false);
                            return count;
                        }))
                        .then(CommandManager.literal("start")
                                .then(CommandManager.argument("mob", StringArgumentType.greedyString())
                                        .suggests((context, builder) -> {
                                            TYPES.keySet().forEach(builder::suggest);
                                            Registries.ENTITY_TYPE.stream()
                                                    .filter(type -> SpawnEggItem.forEntity(type) != null)
                                                    .map(EntityType::getId)
                                                    .filter(id -> id != null)
                                                    .map(Object::toString)
                                                    .forEach(builder::suggest);
                                            return builder.buildFuture();
                                        })
                                        .executes(context -> {
                                            ServerPlayerEntity player = context.getSource().getPlayerOrThrow();
                                            String name = StringArgumentType.getString(context, "mob");
                                            EntityType<?> type = TYPES.get(name);
                                            if (type == null) {
                                                type = Registries.ENTITY_TYPE.stream()
                                                        .filter(candidate -> SpawnEggItem.forEntity(candidate) != null)
                                                        .filter(candidate -> {
                                                            var id = EntityType.getId(candidate);
                                                            return id != null && id.toString().equals(name);
                                                        })
                                                        .findFirst().orElse(null);
                                            }
                                            if (type == null) {
                                                context.getSource().sendError(Text.literal("Unknown orbital type."));
                                                return 0;
                                            }
                                            int count = start(player, type);
                                            context.getSource().sendFeedback(() -> Text.literal("Created " + count + " orbital entities."), false);
                                            return count;
                                        })))));
        CommandRegistrationCallback.EVENT.register((dispatcher, registries, environment) -> dispatcher.register(
                CommandManager.literal("remblecore")
                        .requires(CommandManager.requirePermissionLevel(CommandManager.GAMEMASTERS_CHECK))
                        .then(CommandManager.literal("info").executes(context -> {
                            context.getSource().sendFeedback(() -> Text.literal("RembleCore: mob and primed TNT orbitals available; other systems are not yet implemented."), false);
                            return 1;
                        }))
                        .then(CommandManager.literal("reload").executes(context -> {
                            ORBITS.values().forEach(entities -> entities.forEach(Entity::discard));
                            ORBITS.clear();
                            LAUNCHED.clear();
                            loadConfig();
                            context.getSource().sendFeedback(() -> Text.literal("RembleOrbital settings reloaded; active orbitals stopped."), false);
                            return 1;
                        }))));
        ServerTickEvents.END_SERVER_TICK.register(server -> {
            ticks++;
            ORBITS.entrySet().removeIf(entry -> {
                ServerPlayerEntity player = server.getPlayerManager().getPlayer(entry.getKey());
                if (player == null || !player.isAlive()) {
                    entry.getValue().forEach(Entity::discard);
                    LAUNCHED.removeAll(entry.getValue());
                    return true;
                }
                List<Entity> entities = entry.getValue();
                entities.removeIf(entity -> {
                    if (!entity.isRemoved()) return false;
                    LAUNCHED.remove(entity);
                    return true;
                });
                if (entities.isEmpty()) return true;
                for (int i = 0; i < entities.size(); i++) {
                    Entity entity = entities.get(i);
                    if (entity.getEntityWorld() != player.getEntityWorld()) {
                        entities.forEach(Entity::discard);
                        LAUNCHED.removeAll(entities);
                        return true;
                    }
                    if (LAUNCHED.contains(entity)) continue;
                    if (entity instanceof TntEntity tnt) tnt.setFuse(100);
                    int ring = i / entitiesPerRing;
                    int first = ring * entitiesPerRing;
                    int inRing = Math.min(entitiesPerRing, entities.size() - first);
                    double angle = ticks * speed * (ring + 1) + 2 * Math.PI * (i - first) / inRing;
                    double ringRadius = radius + ring;
                    entity.setPosition(player.getX() + Math.cos(angle) * ringRadius, player.getY() + 1.5 + ring, player.getZ() + Math.sin(angle) * ringRadius);
                    entity.setVelocity(0, 0, 0);
                }
                return false;
            });
        });
        ServerPlayConnectionEvents.DISCONNECT.register((handler, server) -> stop(handler.player.getUuid()));
        ServerLifecycleEvents.SERVER_STOPPING.register(server -> {
            ORBITS.values().forEach(entities -> entities.forEach(Entity::discard));
            ORBITS.clear();
            LAUNCHED.clear();
        });
    }

    private static int start(ServerPlayerEntity player, EntityType<?> type) {
        if (!(player.getEntityWorld() instanceof ServerWorld world)
                || (!ORBITS.containsKey(player.getUuid()) && ORBITS.size() >= maxOwners)) return 0;
        stop(player.getUuid());
        List<Entity> entities = new ArrayList<>();
        for (int i = 0; i < rings * entitiesPerRing; i++) {