This code implements the behavior for a zombie entity in...

August 28, 2025 at 09:13 PM

            if (livingentity != null
                && p_363771_.getDifficulty() == Difficulty.HARD
                && (double)this.random.nextFloat() < this.getAttributeValue(Attributes.SPAWN_REINFORCEMENTS_CHANCE)
                && p_363771_.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING)) {
                int i = Mth.floor(this.getX());
                int j = Mth.floor(this.getY());
                int k = Mth.floor(this.getZ());
                EntityType<? extends Zombie> entitytype = this.getType();
                Zombie zombie = entitytype.create(p_363771_, EntitySpawnReason.REINFORCEMENT);
                if (zombie == null) {
                    return true;
                }

                for (int l = 0; l < 50; l++) {
                    int i1 = i + Mth.nextInt(this.random, 7, 40) * Mth.nextInt(this.random, -1, 1);
                    int j1 = j + Mth.nextInt(this.random, 7, 40) * Mth.nextInt(this.random, -1, 1);
                    int k1 = k + Mth.nextInt(this.random, 7, 40) * Mth.nextInt(this.random, -1, 1);
                    BlockPos blockpos = new BlockPos(i1, j1, k1);
                    if (SpawnPlacements.isSpawnPositionOk(entitytype, p_363771_, blockpos)
                        && SpawnPlacements.checkSpawnRules(entitytype, p_363771_, EntitySpawnReason.REINFORCEMENT, blockpos, p_363771_.random)) {
                        zombie.setPos((double)i1, (double)j1, (double)k1);
                        if (!p_363771_.hasNearbyAlivePlayer((double)i1, (double)j1, (double)k1, 7.0)
                            && p_363771_.isUnobstructed(zombie)
                            && p_363771_.noCollision(zombie)
                            && (zombie.canSpawnInLiquids() || !p_363771_.containsAnyLiquid(zombie.getBoundingBox()))) {
                            zombie.setTarget(livingentity);
                            zombie.finalizeSpawn(p_363771_, p_363771_.getCurrentDifficultyAt(zombie.blockPosition()), EntitySpawnReason.REINFORCEMENT, null);
                            p_363771_.addFreshEntityWithPassengers(zombie);
                            AttributeInstance attributeinstance = this.getAttribute(Attributes.SPAWN_REINFORCEMENTS_CHANCE);
                            AttributeModifier attributemodifier = attributeinstance.getModifier(REINFORCEMENT_CALLER_CHARGE_ID);
                            double d0 = attributemodifier != null ? attributemodifier.amount() : 0.0;
                            attributeinstance.removeModifier(REINFORCEMENT_CALLER_CHARGE_ID);
                            attributeinstance.addPermanentModifier(new AttributeModifier(REINFORCEMENT_CALLER_CHARGE_ID, d0 - 0.05, AttributeModifier.Operation.ADD_VALUE));
                            zombie.getAttribute(Attributes.SPAWN_REINFORCEMENTS_CHANCE).addPermanentModifier(ZOMBIE_REINFORCEMENT_CALLEE_CHARGE);
                            break;
                        }
                    }
                }
            }

            return true;
        }
    }

This code implements the behavior for a zombie entity in Minecraft to potentially summon reinforcement zombies under specific conditions. Here's a breakdown of what it does:

Check Conditions for Summoning Reinforcements:
- The code checks if livingentity (intended to be the zombie's attacker or target) is not null.
- It verifies that the difficulty of the game (p_363771_.getDifficulty()) is set to HARD.
- It uses a random chance (based on the zombie's SPAWN_REINFORCEMENTS_CHANCE attribute) to determine whether this zombie should attempt to spawn reinforcements.
- It checks if the game rule doMobSpawning (GameRules.RULE_DOMOBSPAWNING) is enabled, allowing new mobs to spawn.
Determine Spawn Location for a New Zombie:
- The zombie's current position is used as a reference (its X, Y, Z coordinates).
- A new zombie entity of the same type (EntityType<? extends Zombie>) is created by calling entitytype.create with the appropriate parameters (p_363771_ represents the world and EntitySpawnReason.REINFORCEMENT as the reason).
- If the new zombie entity (zombie) creation fails (returns null), the function ends early.
Attempt to Spawn the Reinforcement Zombie in a Valid Location:
- The code tries up to 50 random locations within a certain range (7-40 blocks in each direction from the calling zombie) to find a valid spawning position.
- For each attempt:
  - A candidate position (blockpos) is generated.
  - The code checks if the position is suitable for spawning the zombie using SpawnPlacements.isSpawnPositionOk and other validation functions like checking spawn rules, unobstructed space, no collision, no nearby players, etc.
  - If a valid position is found, the zombie's position is set, and additional properties are finalized (e.g., spawn difficulty and targeting capability).
  - The new zombie is added to the world using addFreshEntityWithPassengers.
Adjust Spawn Reinforcement Chance:
- After successfully spawning a reinforcement zombie, the SPAWN_REINFORCEMENTS_CHANCE attribute of the parent zombie is adjusted downward by removing and re-adding an attribute modifier.
- The new zombie is given a reinforcement charge to potentially summon reinforcements itself in the future.
Stop After Success:
- Once a reinforcement zombie is successfully spawned, the loop breaks and no further attempts are made.
Return Statement:
- The function returns true, presumably to indicate the operation completed successfully.

Summary:

This code governs the behavior of zombies in the game to spawn "reinforcement" zombies in proximity under specific conditions when playing on the hard difficulty and according to certain probabilities and rules. It ensures that reinforcements spawn in valid locations and modifies the spawning probabilities dynamically for better game balance.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr