Examples with MooshroomEntity net.minecraft.entity.passive.MooshroomEntity used on opensource projects

Example 1 with MooshroomEntity

use of net.minecraft.entity.passive.MooshroomEntity in project carpet-extra by gnembon.

the class MilkMooshroomDispenserBehavior method getStewType.

private static ItemStack getStewType(List<MooshroomEntity> mooshrooms) {
    // check each mooshroom for stew effect, return suspicious stew of that type if exists
    for (MooshroomEntity mooshroom : mooshrooms) {
        MooshroomEntity_StatusEffectAccessorMixin mooshroomAccessor = (MooshroomEntity_StatusEffectAccessorMixin) mooshroom;
        StatusEffect stewEffect = mooshroomAccessor.getStewEffect();
        if (stewEffect != null) {
            // create suspicious stew and add mooshroom's stew effect to it
            ItemStack stewStack = new ItemStack(Items.SUSPICIOUS_STEW);
            SuspiciousStewItem.addEffectToStew(stewStack, stewEffect, mooshroomAccessor.getStewEffectDuration());
            // clear mooshroom's stew effect
            mooshroomAccessor.setStatusEffect(null);
            mooshroomAccessor.setStewEffectDuration(0);
            return stewStack;
        }
    }
    // return regular mushroom stew if no stew effects exist
    return new ItemStack(Items.MUSHROOM_STEW);
}

Example 2 with MooshroomEntity

use of net.minecraft.entity.passive.MooshroomEntity in project ExtendedMushrooms by cech12.

the class MushroomSporesItem method interactLivingEntity.

@Override
public ActionResultType interactLivingEntity(ItemStack stack, PlayerEntity playerIn, LivingEntity target, Hand hand) {
    boolean itemUsed = false;
    World world = target.level;
    if (!world.isClientSide && world instanceof ServerWorld) {
        if (target instanceof CowEntity && !(target instanceof MooshroomEntity)) {
            // Cow to Mooshroom
            target.setSpeed(0);
            // create mooshroom
            MooshroomEntity mooshroom = EntityType.MOOSHROOM.create(target.level);
            if (mooshroom != null) {
                mooshroom.copyPosition(target);
                mooshroom.finalizeSpawn((ServerWorld) world, world.getCurrentDifficultyAt(target.blockPosition()), SpawnReason.CONVERSION, null, null);
                mooshroom.setAge(((CowEntity) target).getAge());
                if (target.hasCustomName()) {
                    mooshroom.setCustomName(target.getCustomName());
                    mooshroom.setCustomNameVisible(target.isCustomNameVisible());
                }
                mooshroom.setHealth(target.getHealth());
                // replace cow with new mooshroom
                target.remove();
                world.addFreshEntity(mooshroom);
                mooshroom.playSound(SoundEvents.ZOMBIE_VILLAGER_CONVERTED, 2.0F, 1.0F);
                // remove one item
                stack.setCount(stack.getCount() - 1);
                itemUsed = true;
            }
        } else if (target instanceof SheepEntity && !(target instanceof MushroomSheepEntity)) {
            // Sheep to Mushroom Sheep
            MushroomSheepEntity.replaceSheep((SheepEntity) target, null);
            itemUsed = true;
        }
    }
    if (itemUsed) {
        // remove one item
        stack.setCount(stack.getCount() - 1);
        return ActionResultType.SUCCESS;
    }
    return ActionResultType.PASS;
}

Example 3 with MooshroomEntity

use of net.minecraft.entity.passive.MooshroomEntity in project carpet-extra by gnembon.

the class CarpetExtraDispenserBehaviors method getCustomDispenserBehavior.

// get custom dispenser behavior
// this checks conditions such as the item and certain block or entity being in front of the dispenser to decide which rule to return
// if the conditions for the rule match, it returns the instance of the dispenser behavior
// returns null to fallback to vanilla (or another mod's) behavior for the given item
public static DispenserBehavior getCustomDispenserBehavior(ServerWorld world, BlockPos pos, BlockPointer pointer, DispenserBlockEntity dispenserBlockEntity, ItemStack stack, Map<Item, DispenserBehavior> VANILLA_BEHAVIORS) {
    Item item = stack.getItem();
    Direction dispenserFacing = pointer.getBlockState().get(DispenserBlock.FACING);
    BlockPos frontBlockPos = pos.offset(dispenserFacing);
    BlockState frontBlockState = world.getBlockState(frontBlockPos);
    Block frontBlock = frontBlockState.getBlock();
    Box frontBlockBox = new Box(frontBlockPos);
    // blazeMeal
    if (CarpetExtraSettings.blazeMeal && item == Items.BLAZE_POWDER && frontBlock == Blocks.NETHER_WART) {
        return BLAZE_MEAL;
    }
    // chickenShearing
    if (CarpetExtraSettings.chickenShearing && item == Items.SHEARS) {
        boolean hasShearableChickens = !world.getEntitiesByType(EntityType.CHICKEN, frontBlockBox, EntityPredicates.VALID_LIVING_ENTITY.and((chickenEntity) -> {
            return !((AnimalEntity) chickenEntity).isBaby();
        })).isEmpty();
        if (hasShearableChickens) {
            return SHEAR_CHICKEN;
        }
    }
    // dispensersCarvePumpkins
    if (CarpetExtraSettings.dispensersCarvePumpkins && item instanceof ShearsItem && frontBlock == Blocks.PUMPKIN) {
        return CARVE_PUMPKIN;
    }
    // dispensersFeedAnimals
    if (CarpetExtraSettings.dispensersFeedAnimals) {
        // check for animals that can be bred with the current item being dispensed in front of dispenser
        boolean hasFeedableAnimals = !world.getEntitiesByClass(AnimalEntity.class, frontBlockBox, EntityPredicates.VALID_LIVING_ENTITY.and((animalEntity) -> {
            return ((AnimalEntity) animalEntity).isBreedingItem(stack);
        })).isEmpty();
        if (hasFeedableAnimals) {
            return FEED_ANIMAL;
        }
        // get brown mooshrooms in front of dispenser
        boolean hasFeedableMooshrooms = !world.getEntitiesByType(EntityType.MOOSHROOM, frontBlockBox, EntityPredicates.VALID_LIVING_ENTITY.and((mooshroomEntity) -> {
            return ((MooshroomEntity) mooshroomEntity).getMooshroomType() == MooshroomEntity.Type.BROWN;
        })).isEmpty();
        // check if item is a small flower
        if (hasFeedableMooshrooms && item.getRegistryEntry().isIn(ItemTags.SMALL_FLOWERS)) {
            return FEED_MOOSHROOM;
        }
    }
    // dispensersFillMinecarts
    if (CarpetExtraSettings.dispensersFillMinecarts) {
        // check for minecarts with no riders in front of dispenser
        boolean hasMinecarts = !world.getEntitiesByType(EntityType.MINECART, frontBlockBox, EntityPredicates.NOT_MOUNTED).isEmpty();
        // if a minecart exist, return dispenser behavior according to item type
        if (hasMinecarts) {
            if (item == Items.CHEST) {
                return FILL_MINECART_CHEST;
            } else if (item == Items.FURNACE) {
                return FILL_MINECART_FURNACE;
            } else if (item == Items.TNT) {
                return FILL_MINECART_TNT;
            } else if (item == Items.HOPPER) {
                return FILL_MINECART_HOPPER;
            }
        }
    }
    // dispensersMilkAnimals
    if (CarpetExtraSettings.dispensersMilkAnimals) {
        // bucket to milk
        if (item == Items.BUCKET) {
            // check for cows, mooshrooms, or goats in front of dispenser
            boolean hasMilkable = !world.getEntitiesByClass(AnimalEntity.class, frontBlockBox, EntityPredicates.VALID_LIVING_ENTITY.and((animalEntity) -> {
                return animalEntity instanceof CowEntity || animalEntity instanceof GoatEntity;
            })).isEmpty();
            if (hasMilkable) {
                return MILK_ANIMAL;
            }
        } else // bowl to stew
        if (item == Items.BOWL) {
            // check for mooshrooms in front of dispenser
            boolean hasMooshroom = !world.getEntitiesByType(EntityType.MOOSHROOM, frontBlockBox, EntityPredicates.VALID_LIVING_ENTITY).isEmpty();
            if (hasMooshroom) {
                return MILK_MOOSHROOM;
            }
        }
    }
    // dispensersPlayRecords
    if (CarpetExtraSettings.dispensersPlayRecords && item instanceof MusicDiscItem && frontBlock == Blocks.JUKEBOX) {
        return PLAY_DISC;
    }
    // dispensersPotPlants
    if (CarpetExtraSettings.dispensersPotPlants && frontBlock instanceof FlowerPotBlock && FlowerPotHelper.isPottable(item)) {
        return FILL_FLOWER_POT;
    }
    // dispensersStripBlocks
    if (CarpetExtraSettings.dispensersStripBlocks && item instanceof AxeItem && (StripBlocksDispenserBehavior.canStrip(frontBlock) || StripBlocksDispenserBehavior.isStripResult(frontBlock))) {
        return STRIP_BLOCK;
    }
    // dispensersTillSoil
    if (CarpetExtraSettings.dispensersTillSoil && item instanceof HoeItem) {
        // check block in front of dispenser and one block down
        for (int i = 0; i < 2; i++) {
            BlockPos hoeBlockPos = frontBlockPos.down(i);
            Block hoeBlock = world.getBlockState(hoeBlockPos).getBlock();
            // check if block is in tilled blocks, or is farmland (to prevent hoe being dispensed when you don't want it to)
            if (TillSoilDispenserBehavior.TILLED_BLOCKS.contains(hoeBlock) || hoeBlock == Blocks.FARMLAND) {
                return TILL_SOIL;
            }
        }
    }
    // dispensersToggleThings
    if (CarpetExtraSettings.dispensersToggleThings && item == Items.STICK && ToggleBlockDispenserBehavior.TOGGLEABLE_BLOCKS.contains(frontBlock)) {
        return TOGGLE_BLOCK;
    }
    // dispensersUseCauldrons
    if (CarpetExtraSettings.dispensersUseCauldrons && frontBlock instanceof AbstractCauldronBlock) {
        // empty cauldron
        if (item == Items.BUCKET) {
            return CAULDRON_EMPTYING_BUCKET;
        } else // fill cauldron
        if (item == Items.LAVA_BUCKET || item == Items.WATER_BUCKET || item == Items.POWDER_SNOW_BUCKET) {
            return CAULDRON_FILLING_BUCKET;
        } else // water cauldron behaviors (leather armor, shulker boxes, banners)
        if (CauldronWaterDispenserBehavior.isWaterCauldronItem(stack)) {
            return CAULDRON_WATER;
        }
    }
    // renewableEndstone
    if (CarpetExtraSettings.renewableEndstone && item == Items.DRAGON_BREATH && frontBlock == Blocks.COBBLESTONE) {
        return DRAGON_BREATH_ENDSTONE;
    }
    // renewableNetherrack
    if (CarpetExtraSettings.renewableNetherrack && item == Items.FIRE_CHARGE && frontBlock == Blocks.COBBLESTONE) {
        return FIRE_CHARGE_NETHERRACK;
    }
    // no custom behavior, return null
    return null;
}

Example 4 with MooshroomEntity

use of net.minecraft.entity.passive.MooshroomEntity in project carpet-extra by gnembon.

the class MilkMooshroomDispenserBehavior method dispenseSilently.

@Override
protected ItemStack dispenseSilently(BlockPointer pointer, ItemStack stack) {
    this.setSuccess(true);
    ServerWorld world = pointer.getWorld();
    BlockPos frontBlockPos = pointer.getPos().offset(pointer.getBlockState().get(DispenserBlock.FACING));
    Box frontBlockBox = new Box(frontBlockPos);
    // get non-baby mooshrooms in front of dispenser
    List<MooshroomEntity> mooshrooms = world.getEntitiesByType(EntityType.MOOSHROOM, frontBlockBox, EntityPredicates.VALID_LIVING_ENTITY.and((entity) -> {
        return !((MooshroomEntity) entity).isBaby();
    }));
    if (!mooshrooms.isEmpty()) {
        // get mushroom/suspicious stew
        ItemStack stewStack = getStewType(mooshrooms);
        // get milking sound effect depending if stew is sus
        SoundEvent stewMilkSound = stewStack.getItem() == Items.SUSPICIOUS_STEW ? SoundEvents.ENTITY_MOOSHROOM_SUSPICIOUS_MILK : SoundEvents.ENTITY_MOOSHROOM_MILK;
        // play sound
        world.playSound(null, frontBlockPos, stewMilkSound, SoundCategory.NEUTRAL, 1.0F, 1.0F);
        // add or dispense stew
        return this.addOrDispense(pointer, stack, stewStack);
    }
    // fail to dispense
    this.setSuccess(false);
    return stack;
}

Example 5 with MooshroomEntity

use of net.minecraft.entity.passive.MooshroomEntity in project carpet-extra by gnembon.

the class FeedMooshroomDispenserBehavior method dispenseSilently.

@Override
protected ItemStack dispenseSilently(BlockPointer pointer, ItemStack stack) {
    this.setSuccess(true);
    ServerWorld world = pointer.getWorld();
    BlockPos frontBlockPos = pointer.getPos().offset(pointer.getBlockState().get(DispenserBlock.FACING));
    // check if item is in SMALL_FLOWERS item tag
    if (stack.isIn(ItemTags.SMALL_FLOWERS)) {
        // get brown mooshrooms in front of dispenser
        List<MooshroomEntity> mooshrooms = world.getEntitiesByType(EntityType.MOOSHROOM, new Box(frontBlockPos), EntityPredicates.VALID_LIVING_ENTITY.and((mooshroomEntity) -> {
            return ((MooshroomEntity) mooshroomEntity).getMooshroomType() == MooshroomEntity.Type.BROWN;
        }));
        // check all mooshrooms
        for (MooshroomEntity mooshroom : mooshrooms) {
            MooshroomEntity_StatusEffectAccessorMixin mooshroomAccessor = (MooshroomEntity_StatusEffectAccessorMixin) mooshroom;
            // check if mooshroom has no stew effect
            if (mooshroomAccessor.getStewEffect() == null) {
                // get stew effect and length for flower
                Optional<Pair<StatusEffect, Integer>> effect = mooshroomAccessor.invokeGetStewEffectFrom(stack);
                // check if effect is present
                if (effect.isPresent()) {
                    Pair<StatusEffect, Integer> pair = effect.get();
                    // set stew effect for mooshroom
                    mooshroomAccessor.setStatusEffect(pair.getLeft());
                    mooshroomAccessor.setStewEffectDuration(pair.getRight());
                    // play sound effect and show particles
                    world.playSound(null, frontBlockPos, SoundEvents.ENTITY_MOOSHROOM_EAT, SoundCategory.NEUTRAL, 2.0F, 1.0F);
                    world.spawnParticles(ParticleTypes.EFFECT, mooshroom.getX() + mooshroom.getRandom().nextDouble() / 2.0D, mooshroom.getBodyY(0.5D), mooshroom.getZ() + mooshroom.getRandom().nextDouble() / 2.0D, 1, 0.0D, mooshroom.getRandom().nextDouble() / 5.0D, 0.0D, 0.01D);
                    // remove a flower and return stack
                    stack.decrement(1);
                    return stack;
                }
            }
        }
    }
    // fail to dispense
    this.setSuccess(false);
    return stack;
}