This code appears to be part of a larger implementation...

August 31, 2025 at 10:48 PM

    private int getPotentialBonusSpawns(Raid.RaiderType p_219829_, RandomSource p_219830_, int p_219831_, DifficultyInstance p_219832_, boolean p_219833_) {
        Difficulty difficulty = p_219832_.getDifficulty();
        boolean flag = difficulty == Difficulty.EASY;
        boolean flag1 = difficulty == Difficulty.NORMAL;
        boolean flag2 = difficulty == Difficulty.EXTREME;
        int i;
        switch (p_219829_) {
            case VINDICATOR:
            case PILLAGER:
                if (flag) {
                    i = p_219830_.nextInt(2);
                } else if (flag1) {
                    i = 1;
                } else {
                    i = 2;
                }
                break;
            case EVOKER:
            case ILLUSIONER:
            default:
                return 0;
            case WITCH:
                if (flag || p_219831_ <= 5 || p_219831_ == 8 || p_219831_ >= 11) {
                    return 0;
                }

                i = 1;
                if ((flag2 && p_219831_ >= 5) && (flag2 && p_219831_ != 8))
                	return 1;
                break;
            case RAVAGER:
                if (flag || p_219831_ <= 3 || p_219831_ >= 6) {
                    return 0;
                }
                
                i = 1;
                if ((flag2 && p_219831_ == 4) || (flag2 && p_219831_ == 5))
                	return 1;
        }

        return i > 0 ? p_219830_.nextInt(i + 1) : 0;
    }

    public boolean isActive() {
        return this.active;
    }

    public CompoundTag save(CompoundTag p_37748_) {
        p_37748_.putInt("Id", this.id);
        p_37748_.putBoolean("Started", this.started);
        p_37748_.putBoolean("Active", this.active);
        p_37748_.putLong("TicksActive", this.ticksActive);
        p_37748_.putInt("BadOmenLevel", this.raidOmenLevel);
        p_37748_.putInt("GroupsSpawned", this.groupsSpawned);
        p_37748_.putInt("PreRaidTicks", this.raidCooldownTicks);
        p_37748_.putInt("PostRaidTicks", this.postRaidTicks);
        p_37748_.putFloat("TotalHealth", this.totalHealth);
        p_37748_.putInt("NumGroups", this.numGroups);
        p_37748_.putString("Status", this.status.getName());
        p_37748_.putInt("CX", this.center.getX());
        p_37748_.putInt("CY", this.center.getY());
        p_37748_.putInt("CZ", this.center.getZ());
        ListTag listtag = new ListTag();

        for (UUID uuid : this.heroesOfTheVillage) {
            listtag.add(NbtUtils.createUUID(uuid));
        }

        p_37748_.put("HeroesOfTheVillage", listtag);
        return p_37748_;
    }

    public int getNumGroups(Difficulty p_37725_) {
        switch (p_37725_) {
            case EASY:
                return 9;
            case NORMAL:
                return 10;
            case HARD:
                return 11;
            case EXTREME:
                return 12;
            default:
                return 0;
        }
    }

    public float getEnchantOdds() {
        int i = this.getRaidOmenLevel();
        if (i == 2) {
            return 0.1F;
        } else if (i == 3) {
            return 0.25F;
        } else if (i == 4) {
            return 0.5F;
        } else {
            return i == 5 ? 0.75F : 0.0F;
        }
    }

    public void addHeroOfTheVillage(Entity p_37727_) {
        this.heroesOfTheVillage.add(p_37727_.getUUID());
    }

    static enum RaidStatus {
        ONGOING,
        VICTORY,
        LOSS,
        STOPPED;

        private static final Raid.RaidStatus[] VALUES = values();

        static Raid.RaidStatus getByName(String p_37804_) {
            for (Raid.RaidStatus raid$raidstatus : VALUES) {
                if (p_37804_.equalsIgnoreCase(raid$raidstatus.name())) {
                    return raid$raidstatus;
                }
            }

            return ONGOING;
        }

        public String getName() {
            return this.name().toLowerCase(Locale.ROOT);
        }
    }

    static enum RaiderType {
        VINDICATOR(EntityType.VINDICATOR, new int[]{0, -2, 1, 1, 3, 3, 4, 3, 3, 4, 5, 6, 9}),
        EVOKER(EntityType.EVOKER, new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2}),
        ILLUSIONER(EntityType.ILLUSIONER, new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2}),
        PILLAGER(EntityType.PILLAGER, new int[]{0, 4, 4, 3, 4, 4, 4, 4, 4, 5, 5, 7, 4}),
        WITCH(EntityType.WITCH, new int[]{0, 0, 0, 0, 0, 1, 0, 0, 3, 1, 1, 1, 1}),
        RAVAGER(EntityType.RAVAGER, new int[]{0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 2, 4});

        static final Raid.RaiderType[] VALUES = values();
        final EntityType<? extends Raider> entityType;
        final int[] spawnsPerWaveBeforeBonus;

        private RaiderType(final EntityType<? extends Raider> p_37821_, final int[] p_37822_) {
            this.entityType = p_37821_;
            this.spawnsPerWaveBeforeBonus = p_37822_;
        }
    }
}

This code appears to be part of a larger implementation dealing with a raid mechanic, likely from a game (possibly inspired by Minecraft given the context). Here's a breakdown of the various components and what their functions do:

getPotentialBonusSpawns Method:
- This method determines the "potential bonus spawns" for raider entities during a raid, depending on:
  - The type of raider (Raid.RaiderType).
  - The current difficulty level (DifficultyInstance).
  - The wave of the raid (p_219831_).
  - If a specific difficulty condition or rule is met.
- The method uses multiple difficulty levels (Difficulty.EASY, Difficulty.NORMAL, Difficulty.EXTREME).
- Depending on the raider type (e.g., PILLAGER, VINDICATOR, etc.), it calculates potential bonuses using random values (RandomSource).
- The returned value is the number of bonus spawns for that raider type, with specific logic for different raider waves (e.g., handling WITCH or RAVAGER logic uniquely).
isActive Method:
- A simple method that returns whether the raid is currently active (this.active).
save Method:
- This method serializes the state of the raid into a CompoundTag object for persistence/storage.
- It stores various attributes of the raid:
  - Its ID, start status, activity status, tick count, bad omen level, number of waves/groups spawned, countdown ticks, post-raid ticks, total health, and the raid's status.
- It also calculates the center (CX, CY, CZ) and stores a list of "Heroes of the Village" (players/entities who contributed to the raid victory) using UUID.
getNumGroups Method:
- This method determines the number of groups (waves of raiders) in a raid based on the difficulty.
- E.g., EASY has 9 groups, NORMAL has 10, HARD has 11, and EXTREME has 12.
getEnchantOdds Method:
- This calculates the odds of enchanted loot or effects occurring during the raid.
- The enchant odds depend on the "bad omen level" (returned from getRaidOmenLevel()):
  - e.g., 2 provides 10%, 3 provides 25%, 4 provides 50%, and 5 provides 75%.
addHeroOfTheVillage Method:
- This adds an entity (Entity p_37727_) to the list of "heroes of the village" (likely those who helped defeat the raid) by storing their UUID.
RaidStatus Enum:
- Enumerates the possible statuses of a raid:
  - ONGOING: The raid is currently happening.
  - VICTORY: The raid was defeated, and the players won.
  - LOSS: The attackers won (village was lost).
  - STOPPED: The raid was halted or interrupted.
- Provides a method (getByName) to fetch a RaidStatus case-insensitively by name and a method to return the status name as a lower-case string (getName).
RaiderType Enum:
- Enumerates the types of raiders (units in the raid), such as VINDICATOR, EVOKER, PILLAGER, WITCH, RAVAGER.
- Each raider type is associated with:
  - An EntityType (likely defining the type of in-game entity).
  - A spawn-per-wave configuration (spawnsPerWaveBeforeBonus), which is an array that specifies how many of that entity spawn per wave based on raid progression.
- The enum can be used to manage raider-specific data across waves of the raid.

Summary:

This code defines the mechanics of a raid system in a game:

Determines raid progression, group spawns, and special mechanics (e.g., bonus spawns, enchant odds).
Keeps track of raid state, difficulty settings, and raid-related entities (like heroes).
Models different raider types and raid statuses, enabling flexible behavior as the raid progresses.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr