/** * Spawns a creeper or primed TNT when a player breaks an ore block, by chance. * * @param event The event */ @EventHandler(ignoreCancelled = true) public void onBlockBreak(BlockBreakEvent event) { Block block = event.getBlock(); if (ORES.contains(block.getType())) { double chance = Math.random(); Location location = block.getLocation().add(0.5, 0.5, 0.5); if (0.05 > chance) { TNTPrimed tnt = location.getWorld().spawn(location, TNTPrimed.class); tnt.setFuseTicks(80); } else if (0.1 > chance) { Creeper creeper = location.getWorld().spawn(location, Creeper.class); creeper.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 2, 2)); } } }
@Test public void testBukkitClasses() throws InputException { Class[] inputTypes = {Class[].class}; String[] input = {"Zombie,Creeper,Pig"}; Object[] output = InputFormatter.getTypesFromInput(inputTypes, Arrays.asList(input), null); // First let's make sure we didn't lose anything, or get anything assertEquals(inputTypes.length, output.length); // Next let's make sure everything is the right type for (Object object : output) { assertTrue(object instanceof Class[]); } // Finally, let's make sure the values are correct Class[] classes = (Class[]) output[0]; assertEquals(classes[0], Zombie.class); assertEquals(classes[1], Creeper.class); assertEquals(classes[2], Pig.class); }
@EventHandler public void onExplode(EntityExplodeEvent event) { if(event.getEntity() instanceof Creeper) { Entity e = event.getEntity(); if(e.hasMetadata("challenge")) { event.blockList().clear(); String[] meta = e.getMetadata("challenge").get(0).asString().split(", "); final String player = meta[1]; plugin.getChallenges().addKill(Bukkit.getPlayer(player)); Bukkit.getPlayer(player).setLevel(plugin.getChallenges().getKillsLeft(Bukkit.getPlayer(player))); if(plugin.getChallenges().getKillsLeft(Bukkit.getPlayer(player)) == 0) { plugin.getChallenges().finishChallenge(Bukkit.getPlayer(player), false); } } } }
@EventHandler public void onEntityBendingDeath(EntityBendingDeathEvent event) { Entity v = event.getVictim(); Element e = CoreAbility.getAbility(event.getAbility()).getElement(); int xp; if(v == null || e == null) return; if(v instanceof Player) { xp = 25 + (int)(Math.random() * ((35 - 25) + 1)); } else if(v instanceof Zombie || v instanceof Creeper || v instanceof Witch || v instanceof Skeleton || v instanceof Guardian || v instanceof Spider) { xp = 13 + (int)(Math.random() * ((22 - 13) + 1)); } else { xp = 3 + (int)(Math.random() * ((8 - 3) + 1)); } BendingExp.addExp(event.getAttacker(), e, xp); }
@EventHandler public void on(EntityDeathEvent event) { if (!(event.getEntity() instanceof Creeper)) return; Creeper creeper = (Creeper) event.getEntity(); // explode after 2 seconds ticks ExplosionTask task = new ExplosionTask(creeper.getLocation(), creeper.isPowered() ? 6 : 3, false); task.runTaskLater(plugin, 40); // set up some layered smoke effects for (int i = 0; i < 5; i++) { // increase the count over time ImpendingExplosionParticleTask smoke = new ImpendingExplosionParticleTask(creeper.getLocation(), 20 * (i+1)); smoke.runTaskLater(plugin, 10 + (i * 10)); } }
/** * {@inheritDoc} */ public CreeperMenu(Plot plot, Creeper creeper) { super(plot, creeper); //powered ItemStack powered = new ItemStack(Material.REDSTONE); ItemMeta poweredMeta = powered.getItemMeta(); poweredMeta.setDisplayName(ChatColor.GREEN + "Change whether this creeper is charged"); powered.setItemMeta(poweredMeta); insertItem(powered, event -> { creeper.setPowered(!creeper.isPowered()); event.setCancelled(true); }, 0); }
@Override public void trigger(AlmightyNotchPlugin plugin, World world) { PluginManager pluginManager = Bukkit.getPluginManager(); for (LivingEntity entity : world.getLivingEntities()) { if (entity.getType() == EntityType.CREEPER) { Creeper creeper = (Creeper) entity; float power = creeper.isPowered() ? 6.0F : 3.0F; ExplosionPrimeEvent event = new ExplosionPrimeEvent(creeper, power, false); pluginManager.callEvent(event); if (!event.isCancelled()) { creeper.damage(creeper.getHealth()); world.createExplosion(creeper.getLocation(), power); } } } plugin.getMessenger().sendMessage(Bukkit.getServer(), getOccurMessage()); }
@EventHandler(ignoreCancelled = true) public void onEntityExplodeEvent(EntityExplodeEvent event) { AttackType attackType = AttackType.UNKNOWN; Entity attacker = event.getEntity(); if (attacker instanceof TNTPrimed) { attackType = AttackType.TNT; } else if (attacker instanceof Creeper) { attackType = AttackType.CREEPER; } else if (attacker instanceof Fireball) { if (((Fireball) attacker).getShooter() instanceof Ghast) { attackType = AttackType.GHAST; } } if (plugin.getChestSettings().allowDestroyBy(attackType)) { return; } for (Iterator<Block> it = event.blockList().iterator(); it.hasNext();) { Block block = it.next(); if (isProtected(block)) { it.remove(); } } }
@Override public void display() { Creeper creeper = this.baseLocation.getWorld().spawn(this.baseLocation.clone().add(0.0D, 5.0D, 0.0D), Creeper.class); creeper.setPowered(true); creeper.setMetadata("owner-id", new FixedMetadataValue(this.hub, this.player.getUniqueId().toString())); this.lovingTask = this.hub.getServer().getScheduler().runTaskTimer(this.hub, () -> { if (!creeper.isDead()) ParticleEffect.HEART.display(0.25F, 0.5F, 0.25F, 1.0F, 6, creeper.getLocation(), 20.0D); }, 5L, 5L); }
private void explode(Creeper creeper) { this.lovingTask.cancel(); Location flowerSpawnLocation = creeper.getLocation().clone().add(0.0D, 1.5D, 0.0D); for (int i = 0; i < 64; i++) { ItemStack redDye = new ItemStack(Material.INK_SACK, 1, (short) 1); Item item = this.player.getWorld().dropItemNaturally(flowerSpawnLocation, redDye); item.setVelocity(new Vector(GadgetManager.RANDOM.nextInt(2) - 1, 1.5, GadgetManager.RANDOM.nextInt(2) - 1)); try { GadgetManager.AGE_FIELD.set((((CraftItem) item).getHandle()), 5500); } catch (IllegalAccessException e) { e.printStackTrace(); } } creeper.getWorld().strikeLightningEffect(creeper.getLocation()); creeper.getWorld().createExplosion(creeper.getLocation().getX(), (creeper.getLocation().getY() + 2.0D), creeper.getLocation().getZ(), 2.5F, false, false); creeper.remove(); HeartEffect heartEffect = new HeartEffect(this.hub.getCosmeticManager().getParticleManager().getEffectManager()); heartEffect.particle = de.slikey.effectlib.util.ParticleEffect.HEART; heartEffect.setLocation(flowerSpawnLocation.clone().add(0.0D, 1.5D, 0.0D)); heartEffect.start(); this.end(); }
@Override @Nullable public ItemType convert(final Object o) { final SkullType type; if (o instanceof Skeleton || o instanceof SkeletonData) { if (o instanceof SkeletonData ? ((SkeletonData) o).isWither() : ((Skeleton) o).getSkeletonType() == SkeletonType.WITHER) { type = SkullType.WITHER; } else { type = SkullType.SKELETON; } } else if (o instanceof Zombie || o instanceof EntityData && Zombie.class.isAssignableFrom(((EntityData<?>) o).getType())) { type = SkullType.ZOMBIE; } else if (o instanceof OfflinePlayer || o instanceof PlayerData) { type = SkullType.PLAYER; } else if (o instanceof Creeper || o instanceof CreeperData) { type = SkullType.CREEPER; } else { return null; } @SuppressWarnings("deprecation") final ItemType i = new ItemType(Material.SKULL_ITEM.getId(), (short) type.ordinal()); if (o instanceof OfflinePlayer) { final SkullMeta s = (SkullMeta) Bukkit.getItemFactory().getItemMeta(Material.SKULL_ITEM); s.setOwner(((OfflinePlayer) o).getName()); i.setItemMeta(s); } return i; }
@EventHandler(ignoreCancelled = false) public void onCreeperPower(cn.nukkit.event.entity.CreeperPowerEvent event) { if (canIgnore(CreeperPowerEvent.getHandlerList())) { return; } PowerCause cause = PowerCause.valueOf(event.getCause().name()); // Dirty and fast conversion CreeperPowerEvent bukkitEvent = new CreeperPowerEvent((Creeper) PokkitEntity.toBukkit(event.getEntity()), cause); callCancellable(event, bukkitEvent); }
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) public void onStart(BloodMoonStartEvent event) { World world = event.getWorld(); PluginConfig worldConfig = plugin.getConfig(world); if (plugin.isFeatureEnabled(world, Feature.SUPER_CREEPERS) && worldConfig.getBoolean(Config.FEATURE_SUPER_CREEPERS_LIGHTNING)) { for (LivingEntity entity : world.getLivingEntities()) { if (entity.getType() == EntityType.CREEPER) { ((Creeper) entity).setPowered(true); } } } }
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) public void onStop(BloodMoonEndEvent event) { World world = event.getWorld(); PluginConfig worldConfig = plugin.getConfig(world); if (plugin.isFeatureEnabled(world, Feature.SUPER_CREEPERS) && worldConfig.getBoolean(Config.FEATURE_SUPER_CREEPERS_LIGHTNING)) { for (LivingEntity entity : world.getLivingEntities()) { if (entity.getType() == EntityType.CREEPER) { ((Creeper) entity).setPowered(false); } } } }
@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) public void onCreatureSpawn(CreatureSpawnEvent event) { LivingEntity entity = event.getEntity(); World world = entity.getWorld(); PluginConfig worldConfig = plugin.getConfig(world); if (entity.getType() == EntityType.CREEPER && plugin.isActive(world) && plugin.isFeatureEnabled(world, Feature.SUPER_CREEPERS) && worldConfig.getBoolean(Config.FEATURE_SUPER_CREEPERS_LIGHTNING)) { ((Creeper) entity).setPowered(true); } }
private void mockDamagableEntity() { //create a mocked, minimal creeper entity = mock(Creeper.class); assumeTrue(entity instanceof Damageable); managedEntity = mock(RpgPlusEntity.class); when(managedEntity.getEntity()).thenReturn(entity); }
@EventHandler public void onCreeperExplode(ExplosionPrimeEvent event) { if (!creeperEnabled || !plugin.isSkyWorld(event.getEntity().getWorld())) { return; } if (event.getEntity() instanceof Creeper && !isValidTarget(((Creeper)event.getEntity()).getTarget())) { event.setCancelled(true); } else if (event.getEntity() instanceof TNTPrimed && !isValidTarget(((TNTPrimed) event.getEntity()).getSource())) { event.setCancelled(true); } }
/** * On creeper death, drop fireworks and heads with a configurable chance. */ @EventHandler(ignoreCancelled = true) public void onCreeperDeath(EntityDeathEvent event) { if (!CONFIG.isAffectedWorld(event)) { return; } Entity entity = event.getEntity(); if (entity.getType() == EntityType.CREEPER && entity.hasMetadata(SPECIAL_KEY)) { Creeper creeper = (Creeper) entity; // Require recent player damage on the creeper for special drops. Long damageTime = getPlayerDamageTime(entity); if (damageTime != null) { Location loc = creeper.getLocation(); if (loc.getWorld().getFullTime() - damageTime < PLAYER_DAMAGE_TICKS) { if (Math.random() < CONFIG.FIREWORK_DROP_CHANCE) { // Replace the default drops. event.getDrops().clear(); final int amount = random(CONFIG.MIN_FIREWORK_DROPS, CONFIG.MAX_FIREWORK_DROPS); for (int i = 0; i < amount; ++i) { ItemStack firework = new ItemStack(Material.FIREWORK); FireworkMeta meta = (FireworkMeta) firework.getItemMeta(); meta.setPower(random(0, 3)); meta.addEffect(randomFireworkFffect(false)); firework.setItemMeta(meta); event.getDrops().add(firework); } } // Powered creepers may drop a creeper skull in addition to // fireworks. if (creeper.isPowered() && Math.random() < CONFIG.CHARGED_CREEPER_SKULL_CHANCE) { event.getDrops().add(new ItemStack(Material.SKULL_ITEM, 1, (short) 4)); } } } } }
/** * When a creeper explodes, reinforcements are launched from him with random * velocities by this method. * * Reinforcements are always launched at a 45 degree angle, a configurable * range from the exploding creeper. * * @param creeper the exploding creeper. */ protected void launchReinforcements(Entity creeper) { final int numReinforcements = random(CONFIG.MIN_REINFORCEMENTS, CONFIG.MAX_REINFORCEMENTS); for (int i = 0; i < numReinforcements; ++i) { // Compute unit velocity vector components, given 45 degree pitch. double yaw = 2.0 * Math.PI * Math.random(); double y = INV_ROOT_2; double x = INV_ROOT_2 * Math.cos(yaw); double z = INV_ROOT_2 * Math.sin(yaw); // Spawn one reinforcement. Location origin = creeper.getLocation(); World world = origin.getWorld(); Location loc = origin.clone().add(CONFIG.REINFORCEMENT_RANGE * x, 0.5, CONFIG.REINFORCEMENT_RANGE * z); Creeper reinforcement = (Creeper) world.spawnEntity(loc, EntityType.CREEPER); if (reinforcement != null) { reinforcement.setMetadata(SPECIAL_KEY, SPECIAL_META); double speed = random(CONFIG.MIN_REINFORCEMENT_SPEED, CONFIG.MAX_REINFORCEMENT_SPEED); Vector velocity = new Vector(speed * x, speed * y, speed * z); reinforcement.setVelocity(velocity); // Randomly charge a fraction of creepers. if (Math.random() < CONFIG.CHARGED_CHANCE) { reinforcement.setPowered(true); } } } }
/** * Returns the amount of damage done to the material by an entity * * @param entity the entity that is involved in damaging * @param material the name of the material to lookup * @param data * @return amount of damage done */ public int getDamageTypeAmount(Entity entity, String material, int data) { material = getMaterialName(material, data); if (durabilityMaterials.containsKey(material)) { EntityType eventTypeRep = entity.getType(); switch (eventTypeRep) { case PRIMED_TNT: return durabilityMaterials.get(material).getTntDamage(); case SNOWBALL: return 0; case CREEPER: Creeper creeper = (Creeper) entity; return creeper.isPowered() ? durabilityMaterials.get(material).getChargedCreeperDamage() : durabilityMaterials.get(material).getCreepersDamage(); case WITHER: case WITHER_SKULL: return durabilityMaterials.get(material).getWithersDamage(); case MINECART_TNT: return durabilityMaterials.get(material).getTntMinecartsDamage(); case FIREBALL: case SMALL_FIREBALL: case GHAST: return durabilityMaterials.get(material).getGhastsDamage(); case BAT: return durabilityMaterials.get(material).getNullDamage(); default: break; } } return 1; }
@EventHandler public void onExplode(EntityExplodeEvent event) { if (event.getEntity() instanceof Creeper) { event.setCancelled(true); return; } else if (event.getEntityType() == EntityType.PRIMED_TNT) { event.setCancelled(true); } }
@Override public void effect(Event e, ItemStack item, int level) { EntityDamageByEntityEvent event = (EntityDamageByEntityEvent) e; final Player player = (Player) event.getDamager(); final LivingEntity ent = (LivingEntity) event.getEntity(); new BukkitRunnable() { @Override public void run() { if (ent.getHealth() <= 0) { byte type = 3; if (ent instanceof Skeleton) { type = 0; if (((Skeleton) ent).getSkeletonType().equals(SkeletonType.WITHER)) type = 1; } else if (ent instanceof Zombie) type = 2; else if (ent instanceof Creeper) type = 4; ItemStack skull = new ItemStack(Material.SKULL_ITEM, 1, type); if (type == 3) { SkullMeta sm = (SkullMeta) skull.getItemMeta(); sm.setOwner(ent.getName()); skull.setItemMeta(sm); } ent.getWorld().dropItem(ent.getLocation(), skull); EffectManager.playSound(player.getLocation(), "BLOCK_ANVIL_LAND", 0.1f, 1.5f); } } }.runTaskLater(getPlugin(), 5l); }
public static CreeperPowerEvent callCreeperPowerEvent(net.minecraft.entity.Entity creeper, net.minecraft.entity.Entity lightning, CreeperPowerEvent.PowerCause cause) { CreeperPowerEvent event = new CreeperPowerEvent((Creeper) creeper.getBukkitEntity(), (LightningStrike) lightning.getBukkitEntity(), cause); creeper.getBukkitEntity().getServer().getPluginManager().callEvent(event); return event; }
/** * Prevents the breakage of hanging items * * @param e */ @EventHandler(priority = EventPriority.LOW) public void onBreakHanging(final HangingBreakByEntityEvent e) { if (DEBUG) { plugin.getLogger().info(e.getEventName()); plugin.getLogger().info(e.getRemover().toString()); } if (Util.inWorld(e.getEntity())) { if ((e.getRemover() instanceof Creeper) && !Settings.allowCreeperDamage) { e.setCancelled(true); return; } // Check if creeper griefing is allowed if ((e.getRemover() instanceof Creeper) && !Settings.allowCreeperGriefing) { // Find out who the creeper was targeting Creeper creeper = (Creeper)e.getRemover(); if (creeper.getTarget() instanceof Player) { Player target = (Player)creeper.getTarget(); // Check if the target is on their own island or not if (!plugin.getIslands().locationIsOnIsland(target, e.getEntity().getLocation())) { // They are a visitor tsk tsk e.setCancelled(true); return; } } // Check if this creeper was lit by a visitor if (litCreeper.contains(creeper.getUniqueId())) { if (DEBUG) { plugin.getLogger().info("DBEUG: preventing creeper from damaging"); } e.setCancelled(true); return; } } if (e.getRemover() instanceof Player) { Player p = (Player) e.getRemover(); // This permission bypasses protection if (p.isOp() || VaultHelper.hasPerm(p, Settings.PERMPREFIX + "mod.bypassprotect")) { return; } if (actionAllowed(p,e.getEntity().getLocation(),SettingsFlag.BREAK_BLOCKS)) { return; } // Not allowed Util.sendMessage(p, plugin.getLocale(p.getUniqueId()).get("island.protected")); e.setCancelled(true); } } }
@Override public void handleInteraction(Entity who, Entity with) { if (with instanceof Creeper) this.explode((Creeper) with); }
@Override protected boolean init(final @Nullable Class<? extends Creeper> c, final @Nullable Creeper e) { powered = e == null ? 0 : e.isPowered() ? 1 : -1; return true; }
@Override public void set(final Creeper c) { if (powered != 0) c.setPowered(powered == 1); }
@Override public boolean match(final Creeper entity) { return powered == 0 || entity.isPowered() == (powered == 1); }
@Override public Class<Creeper> getType() { return Creeper.class; }
public CreeperPowerEvent(final Creeper creeper, final LightningStrike bolt, final PowerCause cause) { this(creeper, cause); this.bolt = bolt; }
public CreeperPowerEvent(final Creeper creeper, final PowerCause cause) { super(creeper); this.cause = cause; }
@Override public Creeper getEntity() { return (Creeper) entity; }
@Override public Creeper getBukkitEntity() { return (Creeper) super.getBukkitEntity(); }