This code appears to handle spawning and managing raiders during...

August 30, 2025 at 06:09 PM

                if (raid$raidertype.entityType == EntityType.RAVAGER) {
                    Raider raider1 = null;
                    Raider raider2 = null;
                    Raider raider3 = null;
                    Raider raider4 = null;
                    if (i == this.getNumGroups(Difficulty.EASY)) {
                        raider1 = EntityType.PILLAGER.create(this.level, EntitySpawnReason.EVENT);
                    }
                        else  if (i == this.getNumGroups(Difficulty.NORMAL)) {
                            raider1 = EntityType.VINDICATOR.create(this.level, EntitySpawnReason.EVENT);
                        }
                            else  if (i == this.getNumGroups(Difficulty.HARD)) {
                                raider2 = EntityType.PILLAGER.create(this.level, EntitySpawnReason.EVENT);
                                raider3 = EntityType.VINDICATOR.create(this.level, EntitySpawnReason.EVENT);
                    } else if (i >= this.getNumGroups(Difficulty.EXTREME)) {
                        if (k == 0) {
                            raider1 = EntityType.EVOKER.create(this.level, EntitySpawnReason.EVENT);
                        } {
                            raider2 = EntityType.ILLUSIONER.create(this.level, EntitySpawnReason.EVENT);
                        } {
                            raider3 = EntityType.VINDICATOR.create(this.level, EntitySpawnReason.EVENT);
                        } {
                            raider4 = EntityType.PILLAGER.create(this.level, EntitySpawnReason.EVENT);
                        }
                    }

                    k++;
                    if (raider1 != null) {
                        this.joinRaid(i, raider1, p_37756_, false);
                        raider1.moveTo(p_37756_, 0.0F, 0.0F);
                        raider1.startRiding(raider);
                        
                        k++;
                        if (raider2 != null) {
                            this.joinRaid(i, raider2, p_37756_, false);
                            raider2.moveTo(p_37756_, 0.0F, 0.0F);
                            raider2.startRiding(raider);
                            
                            k++;
                            if (raider3 != null) {
                                this.joinRaid(i, raider3, p_37756_, false);
                                raider3.moveTo(p_37756_, 0.0F, 0.0F);
                                raider3.startRiding(raider);
                                
                                k++;
                                if (raider4 != null) {
                                    this.joinRaid(i, raider4, p_37756_, false);
                                    raider4.moveTo(p_37756_, 0.0F, 0.0F);
                                    raider4.startRiding(raider);
                    }
                }
            }
        }

This code appears to handle spawning and managing raiders during a raid in the context of a Minecraft-like game. Here's a detailed breakdown of what this code does:

Check if the raider type is a Ravager:
```
if (raid$raidertype.entityType == EntityType.RAVAGER) {
```
This block executes only if the entity spawning the additional raiders is a RAVAGER. The RAVAGER is a specific type of raid entity.
Initialize Raider variables (raider1, raider2, etc.):
```
Raider raider1 = null;
Raider raider2 = null;
Raider raider3 = null;
Raider raider4 = null;
```
This prepares variables to possibly hold entities that will later be added to the raid.
Decide which raiders to spawn based on difficulty and raid group index:
- Depending on the value of i (possibly the current wave or group number) and the game's difficulty (EASY, NORMAL, HARD, EXTREME), raiders of different types are spawned:
  - For EASY: A PILLAGER is spawned (raider1).
  - For NORMAL: A VINDICATOR is spawned (raider1).
  - For HARD: Both a PILLAGER (raider2) and a VINDICATOR (raider3) are spawned.
  - For difficulty EXTREME (possibly a higher custom difficulty):
    - Depending on k (likely an index or counter):
      - An EVOKER is spawned (raider1).
      - An ILLUSIONER (raider2), a VINDICATOR (raider3), and a PILLAGER (raider4) are also created.
Increment the counter k:
```
k++;
```
This appears to help manage some sequencing in the raid waves or to track spawn progression.
Join spawned raiders to the raid: If a raider is spawned (i.e., if any of raider1, raider2, etc. are not null), the following happens:
- The raider is added to the raid via this.joinRaid(i, raiderX, p_37756_, false).
- The raider is moved to a specific location matching p_37756_.
- The raider is set to "ride" the RAVAGER (creating a stacking scenario during the raid).
Nested logic checks for spawning multiple raiders:
```
if (raider1 != null) { ... }
if (raider2 != null) { ... }
if (raider3 != null) { ... }
if (raider4 != null) { ... }
```
These nested checks ensure that each spawned raider is properly initialized, added, positioned, and riding if applicable.

Summary

This code is part of a raid system, allowing different types of raiders to be spawned, managed, and added to a raid wave based on difficulty and current wave index. Raiders can ride a RAVAGER, potentially creating a more dangerous raid hierarchy. The type and number of raiders vary with difficulty and group index. Overall, the logic adds complexity and variation to how raid waves behave in the game.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr