net.minecraft.entity.mob.MobEntity Java Examples

private void renderBoxes(double partialTicks)
{
	double extraSize = boxSize.getSelected().extraSize;
	
	for(MobEntity e : mobs)
	{
		GL11.glPushMatrix();
		
		GL11.glTranslated(e.prevX + (e.getX() - e.prevX) * partialTicks,
			e.prevY + (e.getY() - e.prevY) * partialTicks,
			e.prevZ + (e.getZ() - e.prevZ) * partialTicks);
		
		GL11.glScaled(e.getWidth() + extraSize, e.getHeight() + extraSize,
			e.getWidth() + extraSize);
		
		float f = MC.player.distanceTo(e) / 20F;
		GL11.glColor4f(2 - f, f, 0, 0.5F);
		
		GL11.glCallList(mobBox);
		
		GL11.glPopMatrix();
	}
}
 

private void renderTracers(double partialTicks)
{
	Vec3d start =
		RotationUtils.getClientLookVec().add(RenderUtils.getCameraPos());
	
	GL11.glBegin(GL11.GL_LINES);
	for(MobEntity e : mobs)
	{
		Vec3d end = e.getBoundingBox().getCenter()
			.subtract(new Vec3d(e.getX(), e.getY(), e.getZ())
				.subtract(e.prevX, e.prevY, e.prevZ)
				.multiply(1 - partialTicks));
		
		float f = MC.player.distanceTo(e) / 20F;
		GL11.glColor4f(2 - f, f, 0, 0.5F);
		
		GL11.glVertex3d(start.x, start.y, start.z);
		GL11.glVertex3d(end.x, end.y, end.z);
	}
	GL11.glEnd();
}
 

public static void registerSpawn(DimensionType dim, MobEntity mob, EntityCategory cat, BlockPos pos)
{
    if (lower_spawning_limit != null)
    {
        if (!( (lower_spawning_limit.getX() <= pos.getX() && pos.getX() <= upper_spawning_limit.getX()) &&
             (lower_spawning_limit.getY() <= pos.getY() && pos.getY() <= upper_spawning_limit.getY()) && 
             (lower_spawning_limit.getZ() <= pos.getZ() && pos.getZ() <= upper_spawning_limit.getZ())
           ))
        {
            return;
        }
    }
    Pair<DimensionType, EntityCategory> key = Pair.of(mob.dimension, cat);
    long count = spawn_stats.get(key).getOrDefault(mob.getType(), 0L);
    spawn_stats.get(key).put(mob.getType(), count + 1);
    spawned_mobs.get(key).put(Pair.of(mob.getType(), pos));
    local_spawns.put(cat, local_spawns.get(cat)+1);
}
 

@Redirect(method = "spawnEntitiesInChunk", at = @At(
        value = "INVOKE",
        target = "Lnet/minecraft/server/world/ServerWorld;spawnEntity(Lnet/minecraft/entity/Entity;)Z"
))
private static boolean spawnEntity(ServerWorld world, Entity entity_1)
{
    if (CarpetSettings.lagFreeSpawning)
        // we used the mob - next time we will create a new one when needed
        ((WorldInterface) world).getPrecookedMobs().remove(entity_1.getType());

    if (SpawnReporter.track_spawns > 0L && SpawnReporter.local_spawns != null)
    {
        SpawnReporter.registerSpawn(
                world.dimension.getType(),
                (MobEntity) entity_1,
                entity_1.getType().getCategory(),
                entity_1.getBlockPos());
    }
    if (!SpawnReporter.mock_spawns)
        return world.spawnEntity(entity_1);
    return false;
}
 

public static List<BaseText> printEntitiesByType(EntityCategory cat, World worldIn, boolean all) //Class<?> entityType)
{
    List<BaseText> lst = new ArrayList<>();
    lst.add( Messenger.s(String.format("Loaded entities for %s class:", get_type_string(cat))));
    for (Entity entity : ((ServerWorld)worldIn).getEntities(null, (e) -> e.getType().getCategory()==cat))
    {
        boolean persistent = entity instanceof MobEntity && ( ((MobEntity) entity).isPersistent() || ((MobEntity) entity).cannotDespawn());
        if (!all && persistent)
            continue;

        EntityType type = entity.getType();
        BlockPos pos = entity.getBlockPos();
        lst.add( Messenger.c(
                "w  - ",
                Messenger.tp(persistent?"gb":"wb",pos),
                String.format(persistent?"g : %s":"w : %s", type.getName().getString())
        ));

    }
    if (lst.size()==1)
    {
        lst.add(Messenger.s(" - Empty."));
    }
    return lst;
}
 

@Redirect(
    method = "tickNewAi",
    at = @At(
        value = "FIELD",
        target = "Lnet/minecraft/entity/mob/MobEntity;despawnCounter:I",
        opcode = Opcodes.PUTFIELD
    )
)
private void realTimeImpl$adjustForRealTimeEntityDespawnAge(final MobEntity self, final int modifier) {
    final int ticks = (int) ((RealTimeTrackingBridge) self.getEntityWorld()).realTimeBridge$getRealTimeTicks();
    this.despawnCounter += ticks;
}
 

@Redirect(method = "spawnEntitiesInChunk", at = @At(value = "INVOKE", target = "net/minecraft/entity/mob/MobEntity.initialize(Lnet/minecraft/world/IWorld;Lnet/minecraft/world/LocalDifficulty;Lnet/minecraft/entity/SpawnType;Lnet/minecraft/entity/EntityData;Lnet/minecraft/nbt/CompoundTag;)Lnet/minecraft/entity/EntityData;"))
private static EntityData hookSpecialSpawn(MobEntity entity, IWorld world, LocalDifficulty localDifficulty, SpawnType spawnType, EntityData data, CompoundTag tag) {
	if (!EntityEvents.doSpecialSpawn(entity, world, entity.x, entity.y, entity.z, null, spawnType)) {
		return entity.initialize(world, localDifficulty, spawnType, data, tag);
	} else {
		return data;
	}
}
 

@Inject(method = SPAWN, at = @At(value = "INVOKE", target = "net/minecraft/world/World.spawnEntity(Lnet/minecraft/entity/Entity;)Z"), cancellable = true, locals = LocalCapture.CAPTURE_FAILHARD)
private void hookMobSpawns(World world, @Nullable CompoundTag itemTag, @Nullable Text name, @Nullable PlayerEntity player, BlockPos pos, SpawnType type, boolean alignPosition, boolean bl, CallbackInfoReturnable<Entity> callback, Entity entity) {
	if (!(entity instanceof MobEntity)) {
		return;
	}

	MobEntity mob = (MobEntity) entity;

	if (EntityEvents.doSpecialSpawn(mob, world, pos.getX(), pos.getY(), pos.getZ(), null, type)) {
		callback.setReturnValue(null);
	}
}
 

private PerimeterDiagnostics(ServerWorld server, EntityCategory ctype, MobEntity el)
{
    this.sle = null;
    this.worldServer = server;
    this.ctype = ctype;
    this.el = el;
}
 

public static boolean canEntitySpawnNaturally(MobEntity entity, IWorld world, double x, double y, double z, MobSpawnerLogic spawner, SpawnType spawnType, double sqDistanceFromPlayer) {
	Result result = canEntitySpawn(entity, world, x, y, z, spawner, spawnType);

	if (result == Result.DEFAULT) {
		// Vanilla logic, but inverted since we're checking if it CAN spawn instead of if it CAN'T
		return !(sqDistanceFromPlayer > 16384.0D && entity.canImmediatelyDespawn(sqDistanceFromPlayer)) && entity.canSpawn(world, SpawnType.NATURAL) && entity.canSpawn(world);
	} else {
		return result == Result.ALLOW;
	}
}
 

public static boolean canEntitySpawnFromSpawner(MobEntity entity, World world, double x, double y, double z, MobSpawnerLogic spawner) {
	Result result = canEntitySpawn(entity, world, x, y, z, spawner, SpawnType.SPAWNER);

	if (result == Result.DEFAULT) {
		// Vanilla logic, but inverted since we're checking if it CAN spawn instead of if it CAN'T
		return entity.canSpawn(world, SpawnType.SPAWNER) && entity.canSpawn(world);
	} else {
		return result == Result.ALLOW;
	}
}
 

public static Result canEntitySpawn(MobEntity entity, IWorld world, double x, double y, double z, MobSpawnerLogic spawner, SpawnType spawnType) {
	if (entity == null) {
		return Result.DEFAULT;
	}

	LivingSpawnEvent.CheckSpawn event = new LivingSpawnEvent.CheckSpawn(entity, world, x, y, z, spawner, spawnType);
	MinecraftForge.EVENT_BUS.post(event);
	return event.getResult();
}
 

public LivingSpawnEvent(MobEntity entity, IWorld world, double x, double y, double z) {
	super(entity);
	this.world = world;
	this.x = x;
	this.y = y;
	this.z = z;
}
 

@Override
public void onUpdate()
{
	mobs.clear();
	
	Stream<MobEntity> stream =
		StreamSupport.stream(MC.world.getEntities().spliterator(), false)
			.filter(e -> e instanceof MobEntity).map(e -> (MobEntity)e)
			.filter(e -> !e.removed && e.getHealth() > 0);
	
	if(filterInvisible.isChecked())
		stream = stream.filter(e -> !e.isInvisible());
	
	mobs.addAll(stream.collect(Collectors.toList()));
}
 

@Redirect(method = "spawnEntitiesInChunk", at = @At(
        value = "INVOKE",
        target = "Lnet/minecraft/entity/mob/MobEntity;initialize(Lnet/minecraft/world/IWorld;Lnet/minecraft/world/LocalDifficulty;Lnet/minecraft/entity/SpawnType;Lnet/minecraft/entity/EntityData;Lnet/minecraft/nbt/CompoundTag;)Lnet/minecraft/entity/EntityData;"
))
private static EntityData spawnEntity(MobEntity mobEntity, IWorld iWorld_1, LocalDifficulty localDifficulty_1, SpawnType spawnType_1, EntityData entityData_1, CompoundTag compoundTag_1)
{
    if (!SpawnReporter.mock_spawns)
        return mobEntity.initialize(iWorld_1, localDifficulty_1, spawnType_1, entityData_1, compoundTag_1);
    return null;
}
 

@Inject(method = "sendPackets", at = @At("RETURN"))
private void sendLeashPackets(Consumer<Packet<?>> consumer_1, CallbackInfo ci)
{
    if (CarpetSettings.leadFix)
    {
        if (entity instanceof MobEntity)
        {
            consumer_1.accept( new EntityAttachS2CPacket(entity, ((MobEntity) entity).getHoldingEntity()));
        }
    }
}
 

@Redirect(method = "spawnEntitiesInChunk", at = @At(value = "INVOKE", target = "net/minecraft/entity/mob/MobEntity.canSpawn(Lnet/minecraft/world/CollisionView;)Z"))
private static boolean disableVanillaLogic(MobEntity entity, CollisionView world) {
	return true;
}
 

@Redirect(method = "update", at = @At(value = "INVOKE", target = "net/minecraft/entity/mob/MobEntity.canSpawn(Lnet/minecraft/world/CollisionView;)Z"))
private boolean makeTheOtherMethodNotMessItUp(MobEntity on, CollisionView world) {
	return true;
}
 

@Redirect(method = "update", at = @At(value = "INVOKE", target = "net/minecraft/entity/mob/MobEntity.canSpawn(Lnet/minecraft/world/IWorld;Lnet/minecraft/entity/SpawnType;)Z"))
private boolean spawnTestRedirect(MobEntity on, IWorld world, SpawnType type) {
	MobSpawnerLogic spawner = (MobSpawnerLogic) (Object) this;

	return EntityEvents.canEntitySpawnFromSpawner(on, (World) world, on.x, on.y, on.z, spawner);
}
 

public static DefaultAttributeContainer.Builder createMoonVillagerAttributes() {
    return MobEntity.createMobAttributes().add(EntityAttributes.GENERIC_MOVEMENT_SPEED, 0.5D).add(EntityAttributes.GENERIC_FOLLOW_RANGE, 48.0D);
}
 

@Redirect(method = "spawnEntitiesInChunk", at = @At(value = "INVOKE", target = "net/minecraft/entity/mob/MobEntity.canSpawn(Lnet/minecraft/world/IWorld;Lnet/minecraft/entity/SpawnType;)Z"))
private static boolean hookCheckSpawn(MobEntity entity, IWorld world, SpawnType spawnType) {
	return EntityEvents.canEntitySpawnNaturally(entity, entity.world, entity.x, entity.y, entity.x, null, spawnType, playerDistanceStore);
}
 

@Redirect(method = "spawnEntitiesInChunk", at = @At(value = "INVOKE", target = "net/minecraft/entity/mob/MobEntity.canImmediatelyDespawn(D)Z"))
private static boolean disableVanillaLogicAndCaptureDistance(MobEntity entity, double distFromPlayer) {
	playerDistanceStore = distFromPlayer;
	return false;
}
 

public static boolean doSpecialSpawn(MobEntity entity, IWorld world, double x, double y, double z, MobSpawnerLogic spawner, SpawnType spawnType) {
	return MinecraftForge.EVENT_BUS.post(new LivingSpawnEvent.SpecialSpawn(entity, world, x, y, z, spawner, spawnType));
}
 

@Override
public void onRender(float partialTicks)
{
	// GL settings
	GL11.glEnable(GL11.GL_BLEND);
	GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
	GL11.glEnable(GL11.GL_LINE_SMOOTH);
	GL11.glLineWidth(2);
	GL11.glDisable(GL11.GL_TEXTURE_2D);
	GL11.glEnable(GL11.GL_CULL_FACE);
	GL11.glDisable(GL11.GL_DEPTH_TEST);
	GL11.glDisable(GL11.GL_LIGHTING);
	
	GL11.glPushMatrix();
	RenderUtils.applyRenderOffset();
	
	// set color
	float alpha = 0.5F + 0.25F * MathHelper
		.sin(System.currentTimeMillis() % 1000 / 500F * (float)Math.PI);
	GL11.glColor4f(1, 0, 0, alpha);
	
	// draw boxes
	for(Entity entity : MC.world.getEntities())
	{
		if(!(entity instanceof MobEntity))
			continue;
		
		if(!entity.isInvisible())
			continue;
		
		if(MC.player.squaredDistanceTo(entity) < 0.25)
			continue;
		
		GL11.glPushMatrix();
		GL11.glTranslated(entity.getX(), entity.getY(), entity.getZ());
		
		RenderUtils.drawOutlinedBox(FAKE_BLOCK_BOX);
		RenderUtils.drawSolidBox(FAKE_BLOCK_BOX);
		
		GL11.glPopMatrix();
	}
	
	GL11.glPopMatrix();
	
	// GL resets
	GL11.glColor4f(1, 1, 1, 1);
	GL11.glEnable(GL11.GL_DEPTH_TEST);
	GL11.glEnable(GL11.GL_TEXTURE_2D);
	GL11.glDisable(GL11.GL_BLEND);
	GL11.glDisable(GL11.GL_LINE_SMOOTH);
}
 

@Invoker
public static <T extends MobEntity> void invokeRegister(EntityType<T> type, SpawnRestriction.Location location, Heightmap.Type heightmapType, SpawnRestriction.SpawnPredicate<T> restriction) {
	throw new UnsupportedOperationException();
}
 

/**
 * @param entity the spawning entity
 * @param world the world to spawn in
 * @param x x coordinate
 * @param y y coordinate
 * @param z z coordinate
 * @param spawner the spawner that spawned this entity, or null if this spawn is
 *        coming from a world spawn or other non-spawner source
 */
public SpecialSpawn(MobEntity entity, IWorld world, double x, double y, double z,
		@Nullable MobSpawnerLogic spawner, SpawnType type) {
	super(entity, world, x, y, z);
	this.spawner = spawner;
	this.type = type;
}
 

/**
 * CheckSpawn is fired when an Entity is about to be spawned.
 *
 * @param entity the spawning entity
 * @param world the world to spawn in
 * @param x x coordinate
 * @param y y coordinate
 * @param z z coordinate
 * @param spawner the spawner that spawned this entity null if it this spawn is
 *               coming from a world spawn or other non-spawner source
 */
public CheckSpawn(MobEntity entity, IWorld world, double x, double y, double z,
		@Nullable MobSpawnerLogic spawner, SpawnType type) {
	super(entity, world, x, y, z);
	this.spawner = spawner;
	this.type = type;
}
 

/**
 * Determines if the specific ItemStack can be placed in the specified armor
 * slot, for the entity.
 *
 * @param stack     The ItemStack
 * @param armorType Equipment slot to be verified.
 * @param entity    The entity trying to equip the armor
 * @return True if the given ItemStack can be inserted in the slot
 */
default boolean canEquip(ItemStack stack, EquipmentSlot armorType, Entity entity) {
	return MobEntity.getPreferredEquipmentSlot(stack) == armorType;
}
 

/**
 * Called every tick from {@link net.minecraft.entity.passive.HorseEntity#tick()}
 * on the item in the armor slot.
 *
 * @param stack the armor itemstack
 * @param world the world the horse is in
 * @param horse the horse wearing this armor
 */
default void onHorseArmorTick(ItemStack stack, World world, MobEntity horse) {
}
 

/**
 * Get the {@link PathNodeType} for this block. Return {@code null} for vanilla behavior.
 *
 * @return the {@link PathNodeType}
 */
@Nullable
default PathNodeType getAiPathNodeType(BlockView world, BlockPos pos, @Nullable MobEntity entity) {
	return patchwork$getForgeBlock().getAiPathNodeType(getBlockState(), world, pos, entity);
}