Examples with PotionType net.minecraft.potion.PotionType used on opensource projects

Example 1 with PotionType

use of net.minecraft.potion.PotionType in project MinecraftForge by MinecraftForge.

the class PotionCurativeItemDebug method preInit.

@Mod.EventHandler
public void preInit(FMLPreInitializationEvent evt) {
    Item medicine = new Medicine().setRegistryName(MOD_ID, "medicine");
    GameRegistry.register(medicine);
    Potion incurablePotion = new IncurablePotion().setRegistryName(MOD_ID, "incurable_potion");
    GameRegistry.register(incurablePotion);
    // Register PotionType that can be cured with medicine
    PotionEffect curable = new PotionEffect(incurablePotion, 1200);
    curable.setCurativeItems(Collections.singletonList(new ItemStack(medicine)));
    GameRegistry.register(new PotionType(curable).setRegistryName(MOD_ID, "curable_potion_type"));
    // Register PotionType that can't be cured
    GameRegistry.register(new PotionType(new PotionEffect(incurablePotion, 1200)).setRegistryName(MOD_ID, "incurable_potion_type"));
}

Example 2 with PotionType

use of net.minecraft.potion.PotionType in project Railcraft by Railcraft.

the class PotionsPlugin method init.

private static void init() {
    POTIONS.clear();
    POTIONS_SPLASH.clear();
    POTIONS_LINGERING.clear();
    for (PotionType potiontype : PotionType.REGISTRY) {
        POTIONS.add(PotionUtils.addPotionToItemStack(new ItemStack(Items.POTIONITEM), potiontype));
        POTIONS_SPLASH.add(PotionUtils.addPotionToItemStack(new ItemStack(Items.SPLASH_POTION), potiontype));
        POTIONS_LINGERING.add(PotionUtils.addPotionToItemStack(new ItemStack(Items.LINGERING_POTION), potiontype));
    }
    hasInit = true;
}

Example 3 with PotionType

use of net.minecraft.potion.PotionType in project SpongeCommon by SpongePowered.

the class SpongeParticleHelper method toCachedPacket.

private static ICachedParticleEffect toCachedPacket(SpongeParticleEffect effect) {
    SpongeParticleType type = effect.getType();
    EnumParticleTypes internal = type.getInternalType();
    // Special cases
    if (internal == null) {
        if (type == ParticleTypes.FIREWORKS) {
            final List<FireworkEffect> effects = type.getDefaultOption(ParticleOptions.FIREWORK_EFFECTS).get();
            if (effects.isEmpty()) {
                return EmptyCachedPacket.INSTANCE;
            }
            final net.minecraft.item.ItemStack itemStack = new net.minecraft.item.ItemStack(Items.FIREWORKS);
            FireworkUtils.setFireworkEffects(itemStack, effects);
            final SPacketEntityMetadata packetEntityMetadata = new SPacketEntityMetadata();
            packetEntityMetadata.entityId = CachedFireworkPacket.FIREWORK_ROCKET_ID;
            packetEntityMetadata.dataManagerEntries = new ArrayList<>();
            packetEntityMetadata.dataManagerEntries.add(new EntityDataManager.DataEntry<>(EntityFireworkRocket.FIREWORK_ITEM, itemStack));
            return new CachedFireworkPacket(packetEntityMetadata);
        }
        if (type == ParticleTypes.FERTILIZER) {
            int quantity = effect.getOptionOrDefault(ParticleOptions.QUANTITY).get();
            return new CachedEffectPacket(2005, quantity, false);
        } else if (type == ParticleTypes.SPLASH_POTION) {
            Potion potion = (Potion) effect.getOptionOrDefault(ParticleOptions.POTION_EFFECT_TYPE).get();
            for (PotionType potionType : PotionType.REGISTRY) {
                for (net.minecraft.potion.PotionEffect potionEffect : potionType.getEffects()) {
                    if (potionEffect.getPotion() == potion) {
                        return new CachedEffectPacket(2002, PotionType.REGISTRY.getIDForObject(potionType), false);
                    }
                }
            }
            return EmptyCachedPacket.INSTANCE;
        } else if (type == ParticleTypes.BREAK_BLOCK) {
            int state = getBlockState(effect, type.getDefaultOption(ParticleOptions.BLOCK_STATE));
            if (state == 0) {
                return EmptyCachedPacket.INSTANCE;
            }
            return new CachedEffectPacket(2001, state, false);
        } else if (type == ParticleTypes.MOBSPAWNER_FLAMES) {
            return new CachedEffectPacket(2004, 0, false);
        } else if (type == ParticleTypes.ENDER_TELEPORT) {
            return new CachedEffectPacket(2003, 0, false);
        } else if (type == ParticleTypes.DRAGON_BREATH_ATTACK) {
            return new CachedEffectPacket(2006, 0, false);
        } else if (type == ParticleTypes.FIRE_SMOKE) {
            final Direction direction = effect.getOptionOrDefault(ParticleOptions.DIRECTION).get();
            return new CachedEffectPacket(2000, getDirectionData(direction), false);
        }
        return EmptyCachedPacket.INSTANCE;
    }
    Vector3f offset = effect.getOption(ParticleOptions.OFFSET).map(Vector3d::toFloat).orElse(Vector3f.ZERO);
    int quantity = effect.getOption(ParticleOptions.QUANTITY).orElse(1);
    int[] extra = null;
    // The extra values, normal behavior offsetX, offsetY, offsetZ
    double f0 = 0f;
    double f1 = 0f;
    double f2 = 0f;
    // Depends on behavior
    // Note: If the count > 0 -> speed = 0f else if count = 0 -> speed = 1f
    Optional<BlockState> defaultBlockState;
    if (internal != EnumParticleTypes.ITEM_CRACK && (defaultBlockState = type.getDefaultOption(ParticleOptions.BLOCK_STATE)).isPresent()) {
        int state = getBlockState(effect, defaultBlockState);
        if (state == 0) {
            return EmptyCachedPacket.INSTANCE;
        }
        extra = new int[] { state };
    }
    Optional<ItemStackSnapshot> defaultSnapshot;
    if (extra == null && (defaultSnapshot = type.getDefaultOption(ParticleOptions.ITEM_STACK_SNAPSHOT)).isPresent()) {
        Optional<ItemStackSnapshot> optSnapshot = effect.getOption(ParticleOptions.ITEM_STACK_SNAPSHOT);
        if (optSnapshot.isPresent()) {
            ItemStackSnapshot snapshot = optSnapshot.get();
            extra = new int[] { Item.getIdFromItem((Item) snapshot.getType()), ((SpongeItemStackSnapshot) snapshot).getDamageValue() };
        } else {
            Optional<BlockState> optBlockState = effect.getOption(ParticleOptions.BLOCK_STATE);
            if (optBlockState.isPresent()) {
                BlockState blockState = optBlockState.get();
                Optional<ItemType> optItemType = blockState.getType().getItem();
                if (optItemType.isPresent()) {
                    extra = new int[] { Item.getIdFromItem((Item) optItemType.get()), ((Block) blockState.getType()).getMetaFromState((IBlockState) blockState) };
                } else {
                    return EmptyCachedPacket.INSTANCE;
                }
            } else {
                ItemStackSnapshot snapshot = defaultSnapshot.get();
                extra = new int[] { Item.getIdFromItem((Item) snapshot.getType()), ((SpongeItemStackSnapshot) snapshot).getDamageValue() };
            }
        }
    }
    if (extra == null) {
        extra = new int[0];
    }
    Optional<Double> defaultScale = type.getDefaultOption(ParticleOptions.SCALE);
    Optional<Color> defaultColor;
    Optional<NotePitch> defaultNote;
    Optional<Vector3d> defaultVelocity;
    if (defaultScale.isPresent()) {
        double scale = effect.getOption(ParticleOptions.SCALE).orElse(defaultScale.get());
        // Server formula: sizeServer = (-sizeClient * 2) + 2
        if (internal == EnumParticleTypes.EXPLOSION_LARGE || internal == EnumParticleTypes.SWEEP_ATTACK) {
            scale = (-scale * 2f) + 2f;
        }
        if (scale == 0f) {
            return new CachedParticlePacket(internal, offset, quantity, extra);
        }
        f0 = scale;
    } else if ((defaultColor = type.getDefaultOption(ParticleOptions.COLOR)).isPresent()) {
        Color color = effect.getOption(ParticleOptions.COLOR).orElse(null);
        boolean isSpell = internal == EnumParticleTypes.SPELL_MOB || internal == EnumParticleTypes.SPELL_MOB_AMBIENT;
        if (!isSpell && (color == null || color.equals(defaultColor.get()))) {
            return new CachedParticlePacket(internal, offset, quantity, extra);
        } else if (isSpell && color == null) {
            color = defaultColor.get();
        }
        f0 = color.getRed() / 255f;
        f1 = color.getGreen() / 255f;
        f2 = color.getBlue() / 255f;
        // but we already chose for the color, can't have both
        if (isSpell) {
            f0 = Math.max(f0, 0.001f);
            f2 = Math.max(f0, 0.001f);
        }
        // If the f0 value 0 is, the redstone will set it automatically to red 255
        if (f0 == 0f && internal == EnumParticleTypes.REDSTONE) {
            f0 = 0.00001f;
        }
    } else if ((defaultNote = type.getDefaultOption(ParticleOptions.NOTE)).isPresent()) {
        NotePitch notePitch = effect.getOption(ParticleOptions.NOTE).orElse(defaultNote.get());
        float note = ((SpongeNotePitch) notePitch).getByteId();
        if (note == 0f) {
            return new CachedParticlePacket(internal, offset, quantity, extra);
        }
        f0 = note / 24f;
    } else if ((defaultVelocity = type.getDefaultOption(ParticleOptions.VELOCITY)).isPresent()) {
        Vector3d velocity = effect.getOption(ParticleOptions.VELOCITY).orElse(defaultVelocity.get());
        f0 = velocity.getX();
        f1 = velocity.getY();
        f2 = velocity.getZ();
        Optional<Boolean> slowHorizontalVelocity = type.getDefaultOption(ParticleOptions.SLOW_HORIZONTAL_VELOCITY);
        if (slowHorizontalVelocity.isPresent() && effect.getOption(ParticleOptions.SLOW_HORIZONTAL_VELOCITY).orElse(slowHorizontalVelocity.get())) {
            f0 = 0f;
            f2 = 0f;
        }
        // The y value won't work for this effect, if the value isn't 0 the velocity won't work
        if (internal == EnumParticleTypes.WATER_SPLASH) {
            f1 = 0f;
        }
        if (f0 == 0f && f1 == 0f && f2 == 0f) {
            return new CachedParticlePacket(internal, offset, quantity, extra);
        }
    }
    // Is this check necessary?
    if (f0 == 0f && f1 == 0f && f2 == 0f) {
        return new CachedParticlePacket(internal, offset, quantity, extra);
    }
    return new CachedOffsetParticlePacket(internal, new Vector3f(f0, f1, f2), offset, quantity, extra);
}

Example 4 with PotionType

use of net.minecraft.potion.PotionType in project Cavern2 by kegare.

the class EntityCavenicWitch method attackEntityWithRangedAttack.

@Override
public void attackEntityWithRangedAttack(EntityLivingBase target, float distanceFactor) {
    int count = getAttackPotionCount();
    for (int i = 0; i < count; ++i) {
        if (!isDrinkingPotion()) {
            double d0 = target.posY + target.getEyeHeight() - 1.100000023841858D;
            double d1 = target.posX + target.motionX - posX;
            double d2 = d0 - posY;
            double d3 = target.posZ + target.motionZ - posZ;
            float f = MathHelper.sqrt(d1 * d1 + d3 * d3);
            PotionType potion = PotionTypes.HARMING;
            if (rand.nextFloat() < (target.getHealth() >= 8.0F ? 0.5F : 0.3F)) {
                if (target.isEntityUndead()) {
                    potion = PotionTypes.HEALING;
                } else {
                    potion = PotionTypes.POISON;
                }
            } else if (rand.nextFloat() < 0.25F) {
                potion = PotionTypes.WEAKNESS;
            } else if (rand.nextFloat() < 0.2F) {
                potion = PotionTypes.SLOWNESS;
            }
            EntityPotion entity = new EntityPotion(world, this, PotionUtils.addPotionToItemStack(new ItemStack(Items.SPLASH_POTION), potion));
            entity.rotationPitch -= -20.0F;
            entity.shoot(d1, d2 + f * 0.2F, d3, 0.75F, 8.0F);
            world.playSound(null, posX, posY, posZ, SoundEvents.ENTITY_WITCH_THROW, getSoundCategory(), 1.0F, 0.8F + rand.nextFloat() * 0.4F);
            world.spawnEntity(entity);
        }
    }
}

Example 5 with PotionType

use of net.minecraft.potion.PotionType in project takumicraft by TNTModders.

the class TakumiEvents method onExplosion.

@SubscribeEvent
public void onExplosion(Detonate event) {
    if (!event.getWorld().isRemote) {
        event.getAffectedEntities().removeIf(entity -> entity instanceof EntityLivingBase && ((EntityLivingBase) entity).getActiveItemStack().getItem() == TakumiItemCore.TAKUMI_SHIELD);
        if (event.getWorld().getBlockState(new BlockPos(event.getExplosion().getPosition())).getBlock() == TakumiBlockCore.ACID_BLOCK) {
            IBlockState state = event.getWorld().getBlockState(new BlockPos(event.getExplosion().getPosition()));
            int i = state.getValue(BlockTakumiAcid.META) + 1;
            event.getAffectedBlocks().forEach(pos -> {
                if (i < 16) {
                    for (EnumFacing facing : EnumFacing.values()) {
                        BlockPos blockPos = pos.offset(facing);
                        if (!event.getAffectedBlocks().contains(blockPos) && !event.getWorld().isAirBlock(blockPos) && event.getWorld().getBlockState(blockPos).getBlockHardness(event.getWorld(), blockPos) != -1 && event.getWorld().getBlockState(blockPos).getBlock() != TakumiBlockCore.ACID_BLOCK) {
                            event.getWorld().setBlockState(blockPos, TakumiBlockCore.ACID_BLOCK.getDefaultState().withProperty(BlockTakumiAcid.META, i));
                        }
                    }
                }
                event.getWorld().setBlockToAir(pos);
            });
            event.getAffectedBlocks().clear();
        }
    }
    if (event.getExplosion() instanceof TakumiExplosion) {
        if (((TakumiExplosion) event.getExplosion()).getExploder() instanceof AbstractEntityTakumiGrenade) {
            AbstractEntityTakumiGrenade grenade = (AbstractEntityTakumiGrenade) ((TakumiExplosion) event.getExplosion()).getExploder();
            if (grenade.getThrower() != null) {
                event.getAffectedEntities().remove(grenade.getThrower());
            }
        }
        if (((TakumiExplosion) event.getExplosion()).getExploder() instanceof EntityTakumiArrow) {
            EntityTakumiArrow takumiArrow = (EntityTakumiArrow) ((TakumiExplosion) event.getExplosion()).getExploder();
            if (takumiArrow.shootingEntity instanceof EntityStrayCreeper) {
                PotionType type = PotionUtils.getPotionFromItem(((EntityLivingBase) takumiArrow.shootingEntity).getHeldItem(EnumHand.OFF_HAND));
                for (Entity entity : event.getAffectedEntities()) {
                    if (entity instanceof EntityLivingBase && entity != takumiArrow.shootingEntity) {
                        PotionEffect effect = new PotionEffect(type.getEffects().get(0).getPotion(), 400);
                        ((EntityLivingBase) entity).addPotionEffect(effect);
                    }
                }
            }
        }
        if (((TakumiExplosion) event.getExplosion()).getExploder() instanceof EntityTakumiPotion) {
            for (Entity entity : event.getAffectedEntities()) {
                if (entity instanceof EntityLivingBase) {
                    List<PotionEffect> effects = PotionUtils.getEffectsFromStack(((EntityPotion) ((TakumiExplosion) event.getExplosion()).getExploder()).getPotion());
                    for (PotionEffect effect : effects) {
                        ((EntityLivingBase) entity).addPotionEffect(effect);
                    }
                }
            }
        }
        if (((TakumiExplosion) event.getExplosion()).getExploder() instanceof EntityTransHomingBomb) {
            event.getAffectedEntities().forEach(entity -> {
                if (entity instanceof EntityPlayer) {
                    ((EntityLivingBase) entity).addPotionEffect(new PotionEffect(MobEffects.LEVITATION, 150));
                    ((EntityLivingBase) entity).addPotionEffect(new PotionEffect(TakumiPotionCore.INVERSION, 150));
                }
            });
        }
    }
    if (event.getExplosion().getExplosivePlacedBy() instanceof ITakumiEntity) {
        boolean flg = ((ITakumiEntity) event.getExplosion().getExplosivePlacedBy()).takumiExplodeEvent(event);
        if (!flg) {
            event.setCanceled(true);
        }
    }
}