Java Examples for org.bukkit.entity.Firework

public static void spawnFirework(Location location, World world, Color color) {
    Firework firework = world.spawn(location, Firework.class);
    FireworkMeta fireworkMeta = firework.getFireworkMeta();
    FireworkEffect effect = FireworkEffect.builder().withColor(color).with(FireworkEffect.Type.BALL).trail(true).build();
    fireworkMeta.addEffect(effect);
    fireworkMeta.setPower(1);
    firework.setFireworkMeta(fireworkMeta);
}

private void doEndGame(Arena arena) {
    if (arena.getAfterCount() <= 0) {
        arena.setEndGame(false);
        arena.resetArena(false);
        plugin.signHandler.updateSigns();
    } else {
        arena.setAfterCount(arena.getAfterCount() - 1);
        for (UUID id : arena.getPlayers()) {
            Player p = Bukkit.getPlayer(id);
            try {
                if (!arena.getSpectators().contains(p.getUniqueId())) {
                    if (arena.getTeam(p) == winningTeam) {
                        Firework f = p.getLocation().getWorld().spawn(p.getLocation().add(0, 2, 0), Firework.class);
                        FireworkMeta fm = f.getFireworkMeta();
                        fm.setPower(1);
                        FireworkEffect fe = FireworkEffect.builder().flicker(true).withColor(arena.getTeam(p).getColour()).with(Type.STAR).build();
                        fm.clearEffects();
                        fm.addEffect(fe);
                        f.setFireworkMeta(fm);
                    }
                }
            } catch (Exception ignored) {
            }
        }
    }
}

@EventHandler
public void drop(PlayerDropItemEvent e) {
    System.out.print("DROP");
    /*for ( int faktor = 1; faktor <= 80; faktor ++ ) {
		
		Firework f = (Firework)
		e.getPlayer().getWorld().spawn(e.getPlayer().getLocation(), Firework.class);
        
        FireworkMeta fm = f.getFireworkMeta();
        fm.addEffect(FireworkEffect.builder()
                      .trail(true)
                      .flicker(false)
                      .withColor(Color.GRAY)
                      .withColor(Color.GRAY)
                      .withColor(Color.GRAY)
                      .withColor(Color.GRAY)
                      .withColor(Color.GRAY)
                      .withColor(Color.WHITE)
                      .withColor(Color.WHITE)
                      .withColor(Color.WHITE)
                      .withColor(Color.WHITE)
                      .withColor(Color.BLACK)
                      .withColor(Color.BLACK)
                      .withColor(Color.BLACK)
                      .withColor(Color.BLACK)
                      .withFade(Color.BLACK)
                      .build());
        fm.setPower(0);
        f.setFireworkMeta(fm);
		}*/
    e.setCancelled(true);
}

public void playFlareEffect() {
    if (isCurrent(Spawned.class)) {
        Location location = ((Spawned) this.state).getLocation();
        if (location == null)
            return;
        FireworkEffect effect = FireworkEffect.builder().with(FireworkEffect.Type.BURST).withColor(this.getDyeColor().getColor()).build();
        Firework firework = FireworkUtil.spawnFirework(location, effect, 0);
        NMSHacks.skipFireworksLaunch(firework);
    }
}

public void spawnRandomFirework(Location location) {
    if (!UltraCosmeticsData.get().getPlugin().isEnabled())
        return;
    final ArrayList<Firework> fireworks = new ArrayList<>();
    for (int i = 0; i < 4; i++) {
        final Firework f = player.getWorld().spawn(location.clone().add(0.5, 0, 0.5), Firework.class);
        FireworkMeta fm = f.getFireworkMeta();
        fm.addEffect(getRandomFireworkEffect());
        f.setFireworkMeta(fm);
        fireworks.add(f);
    }
    Bukkit.getScheduler().runTaskLater(UltraCosmeticsData.get().getPlugin(), new Runnable() {

        @Override
        public void run() {
            for (Firework f : fireworks) f.detonate();
        }
    }, 2);
}

protected void detonate(Location location, Vector v) {
    final Firework fw = (Firework) location.getWorld().spawnEntity(location.add(v), EntityType.FIREWORK);
    location.subtract(v);
    FireworkMeta meta = fw.getFireworkMeta();
    meta.setPower(0);
    for (int i = 0; i < intensity; i++) {
        meta.addEffect(firework);
    }
    fw.setFireworkMeta(meta);
    fw.detonate();
}

/**
     * Make a packet object
     *
     * @param location       Location to play firework effect at
     * @param fireworkEffect FireworkEffect to play
     * @return Packet constructed by the parameters
     */
private static Object makePacket(Location location, FireworkEffect fireworkEffect) {
    try {
        Firework firework = location.getWorld().spawn(location, Firework.class);
        FireworkMeta data = firework.getFireworkMeta();
        data.clearEffects();
        data.setPower(1);
        data.addEffect(fireworkEffect);
        firework.setFireworkMeta(data);
        Object nmsFirework = ReflectionUtil.getHandle(firework);
        firework.remove();
        return PACKET_PLAY_OUT_ENTITY_STATUS.newInstance(nmsFirework, (byte) 17);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

@Override
public void run() {
    if (bat.isValid() && creepFunMap.containsKey(event.getPlayer().getName())) {
        FireworkEffect.Type type = FireworkEffect.Type.values()[random.nextInt(FireworkEffect.Type.values().length)];
        FireworkEffect effect = FireworkEffect.builder().with(type).withColor(colors[color]).withFade(colors[(color + 1 >= colors.length) ? 0 : color + 1]).flicker(random.nextBoolean()).trail(random.nextBoolean()).build();
        Firework firework = bat.getWorld().spawn(bat.getLocation(), Firework.class);
        FireworkMeta meta = firework.getFireworkMeta();
        meta.addEffect(effect);
        meta.setPower(2);
        firework.setFireworkMeta(meta);
        color++;
        if (color >= colors.length)
            color = 0;
    } else {
        this.cancel();
    }
}

public static Firework spawnFirework(Location loc, FireworkEffect effect, int power) {
    Firework firework = loc.getWorld().spawn(loc, Firework.class);
    FireworkMeta fireworkMeta = firework.getFireworkMeta();
    fireworkMeta.addEffect(effect);
    fireworkMeta.setPower(power);
    firework.setFireworkMeta(fireworkMeta);
    firework.setMetadata(FIREWORK_METADATA, new FixedMetadataValue(Cardinal.getInstance(), true));
    return firework;
}

@SuppressWarnings("unchecked")
@Override
public void execute(final ScriptEntry scriptEntry) throws CommandExecutionException {
    // Get objects
    final dLocation location = scriptEntry.hasObject("location") ? (dLocation) scriptEntry.getObject("location") : ((BukkitScriptEntryData) scriptEntry.entryData).getNPC().getLocation();
    Element type = (Element) scriptEntry.getObject("type");
    Element power = (Element) scriptEntry.getObject("power");
    boolean flicker = scriptEntry.hasObject("flicker");
    boolean trail = scriptEntry.hasObject("trail");
    List<dColor> primary = (List<dColor>) scriptEntry.getObject("primary");
    List<dColor> fade = (List<dColor>) scriptEntry.getObject("fade");
    // Report to dB
    dB.report(scriptEntry, getName(), location.debug() + type.debug() + power.debug() + (flicker ? aH.debugObj("flicker", flicker) : "") + (trail ? aH.debugObj("trail", trail) : "") + aH.debugObj("primary colors", primary.toString()) + (fade != null ? aH.debugObj("fade colors", fade.toString()) : ""));
    Firework firework = location.getWorld().spawn(location, Firework.class);
    FireworkMeta fireworkMeta = firework.getFireworkMeta();
    fireworkMeta.setPower(power.asInt());
    Builder fireworkBuilder = FireworkEffect.builder();
    fireworkBuilder.with(FireworkEffect.Type.valueOf(type.asString().toUpperCase()));
    fireworkBuilder.withColor(Conversion.convertColors(primary));
    if (fade != null) {
        fireworkBuilder.withFade(Conversion.convertColors(fade));
    }
    if (flicker) {
        fireworkBuilder.withFlicker();
    }
    if (trail) {
        fireworkBuilder.withTrail();
    }
    fireworkMeta.addEffects(fireworkBuilder.build());
    firework.setFireworkMeta(fireworkMeta);
}

protected final Firework fire(Location location, IConsumableDetails details, Object userObject) {
    final Firework firework = (Firework) location.getWorld().spawnEntity(location, EntityType.FIREWORK);
    FireworkMeta meta = firework.getFireworkMeta();
    final FireworkPlayerDetails fDetails = FireworkPlayerDetails.fromConsumableDetails(details, firework, userObject);
    if (!onFire(fDetails, meta)) {
        firework.remove();
        return null;
    }
    firework.setFireworkMeta(meta);
    final BukkitTask[] task = new BukkitTask[1];
    task[0] = Bukkit.getScheduler().runTaskTimer(getPlugin(), new Runnable() {

        @Override
        public void run() {
            if (firework.isDead()) {
                onExplode(fDetails);
                task[0].cancel();
            }
            firework.setTicksLived(Integer.MAX_VALUE);
        }
    }, 10 * (1 + meta.getPower()), 2);
    return firework;
}

@EventHandler
public void onEntityShootBowEvent(EntityShootBowEvent event) {
    if (event.isCancelled()) {
        return;
    }
    if (runOnWorld == null) {
        return;
    }
    if (event.getEntity().getType() != EntityType.SKELETON) {
        return;
    }
    if ((event.getProjectile().getType() == EntityType.ARROW) && (event.getEntity().getEquipment().getHelmet().getType() == Material.GLASS)) {
        Firework f = (Firework) runOnWorld.spawnEntity(event.getEntity().getEyeLocation(), EntityType.FIREWORK);
        FireworkMeta fwm = f.getFireworkMeta();
        FireworkEffect effect = FireworkEffect.builder().withTrail().with(FireworkEffect.Type.STAR).withColor(new Color[] { Color.GREEN, Color.GREEN }).with(FireworkEffect.Type.BURST).build();
        fwm.addEffect(effect);
        f.setFireworkMeta(fwm);
        event.getProjectile().setPassenger(f);
    }
}

public void shootFirework() {
    for (Player p : Bukkit.getOnlinePlayers()) {
        Firework f = p.getWorld().spawn(p.getLocation(), Firework.class);
        FireworkMeta fm = f.getFireworkMeta();
        Random r = new Random();
        int fType = r.nextInt(5) + 1;
        Type type;
        switch(fType) {
            default:
            case 1:
                type = Type.BALL;
                break;
            case 2:
                type = Type.BALL_LARGE;
                break;
            case 3:
                type = Type.BURST;
                break;
            case 4:
                type = Type.CREEPER;
                break;
            case 5:
                type = Type.STAR;
                break;
        }
        int c1i = r.nextInt(18) + 1;
        int c2i = r.nextInt(18) + 1;
        Color c1 = getColour(c1i);
        Color c2 = getColour(c2i);
        FireworkEffect effect = FireworkEffect.builder().flicker(r.nextBoolean()).withColor(c1).withFade(c2).with(type).trail(r.nextBoolean()).build();
        fm.addEffect(effect);
        int power = r.nextInt(2) + 1;
        fm.setPower(power);
        f.setFireworkMeta(fm);
    }
}

/**
     * Play a pretty firework at the location with the FireworkEffect when called
     * @param world
     * @param loc
     * @param fe
     * @throws Exception
     */
public void playFirework(World world, Location loc, FireworkEffect fe) throws Exception {
    // Bukkity load (CraftFirework)
    Firework fw = (Firework) world.spawn(loc, Firework.class);
    // the net.minecraft.server.World
    Object nms_world = null;
    Object nms_firework = null;
    /*
         * The reflection part, this gives us access to funky ways of messing around with things
         */
    if (world_getHandle == null) {
        // get the methods of the craftbukkit objects
        world_getHandle = getMethod(world.getClass(), "getHandle");
        firework_getHandle = getMethod(fw.getClass(), "getHandle");
    }
    // invoke with no arguments
    nms_world = world_getHandle.invoke(world, (Object[]) null);
    nms_firework = firework_getHandle.invoke(fw, (Object[]) null);
    // null checks are fast, so having this seperate is ok
    if (nms_world_broadcastEntityEffect == null) {
        // get the method of the nms_world
        nms_world_broadcastEntityEffect = getMethod(nms_world.getClass(), "broadcastEntityEffect");
    }
    /*
         * Now we mess with the metadata, allowing nice clean spawning of a pretty firework (look, pretty lights!)
         */
    // metadata load
    FireworkMeta data = (FireworkMeta) fw.getFireworkMeta();
    // clear existing
    data.clearEffects();
    // power of one
    data.setPower(1);
    // add the effect
    data.addEffect(fe);
    // set the meta
    fw.setFireworkMeta(data);
    /*
         * Finally, we broadcast the entity effect then kill our fireworks object
         */
    // invoke with arguments
    nms_world_broadcastEntityEffect.invoke(nms_world, new Object[] { nms_firework, (byte) 17 });
    // remove from the game
    fw.remove();
}

public static Firework shootFirework(Location loc, Random rand) {
    int type = rand.nextInt(5) + 1;
    Firework firework = loc.getWorld().spawn(loc, Firework.class);
    FireworkMeta meta = firework.getFireworkMeta();
    Type ft = null;
    switch(type) {
        case 1:
            ft = Type.BALL;
            break;
        case 2:
            ft = Type.BALL_LARGE;
            break;
        case 3:
            ft = Type.BURST;
            break;
        case 4:
            ft = Type.CREEPER;
            break;
        case 5:
            ft = Type.STAR;
            break;
    }
    FireworkEffect effect = FireworkEffect.builder().flicker(rand.nextBoolean()).withColor(fireworkColor(rand.nextInt(16) + 1)).withFade(fireworkColor(rand.nextInt(16) + 1)).trail(rand.nextBoolean()).with(ft).trail(rand.nextBoolean()).build();
    meta.addEffect(effect);
    firework.setFireworkMeta(meta);
    return firework;
}

public void spawnFireworks(Player player) {
    int power = Misc.getRandom().nextInt(3) + 1;
    Type fireworkType = Type.values()[Misc.getRandom().nextInt(Type.values().length)];
    double varX = Misc.getRandom().nextGaussian() * 3;
    double varZ = Misc.getRandom().nextGaussian() * 3;
    Firework fireworks = (Firework) player.getWorld().spawnEntity(player.getLocation().add(varX, 0, varZ), EntityType.FIREWORK);
    FireworkMeta fireworkmeta = fireworks.getFireworkMeta();
    FireworkEffect effect = FireworkEffect.builder().flicker(Misc.getRandom().nextBoolean()).withColor(colorChoose()).withFade(colorChoose()).with(fireworkType).trail(Misc.getRandom().nextBoolean()).build();
    fireworkmeta.addEffect(effect);
    fireworkmeta.setPower(power);
    fireworks.setFireworkMeta(fireworkmeta);
}

public void spawnFireworks(Player player) {
    int power = Misc.getRandom().nextInt(3) + 1;
    Type fireworkType = Type.values()[Misc.getRandom().nextInt(Type.values().length)];
    double varX = Misc.getRandom().nextGaussian() * 3;
    double varZ = Misc.getRandom().nextGaussian() * 3;
    Firework fireworks = (Firework) player.getWorld().spawnEntity(player.getLocation().add(varX, 0, varZ), EntityType.FIREWORK);
    FireworkMeta fireworkmeta = fireworks.getFireworkMeta();
    FireworkEffect effect = FireworkEffect.builder().flicker(Misc.getRandom().nextBoolean()).withColor(colorChoose()).withFade(colorChoose()).with(fireworkType).trail(Misc.getRandom().nextBoolean()).build();
    fireworkmeta.addEffect(effect);
    fireworkmeta.setPower(power);
    fireworks.setFireworkMeta(fireworkmeta);
}

@Override
public void run() {
    for (int i = -2; i < 3; i++) {
        org.bukkit.entity.Firework firework = world.spawn(new org.bukkit.Location(loc.getWorld(), loc.getX() + (i * 5), loc.getY(), loc.getZ()), org.bukkit.entity.Firework.class);
        org.bukkit.inventory.meta.FireworkMeta data = firework.getFireworkMeta();
        data.addEffects(org.bukkit.FireworkEffect.builder().withColor(color1).withColor(color2).withColor(color3).with(type).trail(new java.util.Random().nextBoolean()).flicker(new java.util.Random().nextBoolean()).build());
        data.setPower(new java.util.Random().nextInt(2) + 2);
        firework.setFireworkMeta(data);
    }
}

@Override
protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
    final ItemStack stack = user.getBase().getItemInHand();
    if (stack.getType() == Material.FIREWORK) {
        if (args.length > 0) {
            if (args[0].equalsIgnoreCase("clear")) {
                FireworkMeta fmeta = (FireworkMeta) stack.getItemMeta();
                fmeta.clearEffects();
                stack.setItemMeta(fmeta);
                user.sendMessage(tl("fireworkEffectsCleared"));
            } else if (args.length > 1 && (args[0].equalsIgnoreCase("power") || (args[0].equalsIgnoreCase("p")))) {
                FireworkMeta fmeta = (FireworkMeta) stack.getItemMeta();
                try {
                    int power = Integer.parseInt(args[1]);
                    fmeta.setPower(power > 3 ? 4 : power);
                } catch (NumberFormatException e) {
                    throw new Exception(tl("invalidFireworkFormat", args[1], args[0]));
                }
                stack.setItemMeta(fmeta);
            } else if ((args[0].equalsIgnoreCase("fire") || (args[0].equalsIgnoreCase("f"))) && user.isAuthorized("essentials.firework.fire")) {
                int amount = 1;
                boolean direction = false;
                if (args.length > 1) {
                    if (NumberUtil.isInt(args[1])) {
                        final int serverLimit = ess.getSettings().getSpawnMobLimit();
                        amount = Integer.parseInt(args[1]);
                        if (amount > serverLimit) {
                            amount = serverLimit;
                            user.sendMessage(tl("mobSpawnLimit"));
                        }
                    } else {
                        direction = true;
                    }
                }
                for (int i = 0; i < amount; i++) {
                    Firework firework = (Firework) user.getWorld().spawnEntity(user.getLocation(), EntityType.FIREWORK);
                    FireworkMeta fmeta = (FireworkMeta) stack.getItemMeta();
                    if (direction) {
                        final Vector vector = user.getBase().getEyeLocation().getDirection().multiply(0.070);
                        if (fmeta.getPower() > 1) {
                            fmeta.setPower(1);
                        }
                        firework.setVelocity(vector);
                    }
                    firework.setFireworkMeta(fmeta);
                }
            } else {
                final MetaItemStack mStack = new MetaItemStack(stack);
                for (String arg : args) {
                    try {
                        mStack.addFireworkMeta(user.getSource(), true, arg, ess);
                    } catch (Exception e) {
                        user.sendMessage(tl("fireworkSyntax"));
                        throw e;
                    }
                }
                if (mStack.isValidFirework()) {
                    FireworkMeta fmeta = (FireworkMeta) mStack.getItemStack().getItemMeta();
                    FireworkEffect effect = mStack.getFireworkBuilder().build();
                    if (fmeta.getEffects().size() > 0 && !user.isAuthorized("essentials.firework.multiple")) {
                        throw new Exception(tl("multipleCharges"));
                    }
                    fmeta.addEffect(effect);
                    stack.setItemMeta(fmeta);
                } else {
                    user.sendMessage(tl("fireworkSyntax"));
                    throw new Exception(tl("fireworkColor"));
                }
            }
        } else {
            throw new NotEnoughArgumentsException();
        }
    } else {
        throw new Exception(tl("holdFirework"));
    }
}

public static void playFirework(World world, Location loc, FireworkEffect fe) throws Exception {
    Firework fw = (Firework) world.spawn(loc, Firework.class);
    Object nms_world = null;
    Object nms_firework = null;
    if (world_getHandle == null) {
        world_getHandle = getMethod(world.getClass(), "getHandle");
        firework_getHandle = getMethod(fw.getClass(), "getHandle");
    }
    nms_world = world_getHandle.invoke(world, null);
    nms_firework = firework_getHandle.invoke(fw, null);
    if (nms_world_broadcastEntityEffect == null) {
        nms_world_broadcastEntityEffect = getMethod(nms_world.getClass(), "broadcastEntityEffect");
    }
    FireworkMeta data = fw.getFireworkMeta();
    data.clearEffects();
    data.setPower(1);
    data.addEffect(fe);
    fw.setFireworkMeta(data);
    nms_world_broadcastEntityEffect.invoke(nms_world, new Object[] { nms_firework, Byte.valueOf((byte) 17) });
    fw.remove();
}

@Override
public void spawn(Plugin plugin, List<ParticleDescription> descriptions, Location location) {
    Firework firework = (Firework) location.getWorld().spawnEntity(location, EntityType.FIREWORK);
    try {
        checkMethodCache(firework.getWorld(), firework);
        Object nmsWorld = world_getHandle.invoke(firework.getWorld());
        Object nmsFirework = firework_getHandle.invoke(firework);
        nmsFirwork_setInvisible.invoke(nmsFirework, true);
        FireworkMeta meta = firework.getFireworkMeta();
        meta.clearEffects();
        for (ParticleDescription description : descriptions) {
            Builder builder = FireworkEffect.builder();
            builder.with(description.getShape().getFireworkType());
            builder.withColor(description.getColors().toArray(new Color[description.getColors().size()]));
            builder.withFade(description.getFadeColors().toArray(new Color[description.getFadeColors().size()]));
            meta.addEffect(builder.build());
        }
        meta.setPower(1);
        firework.setFireworkMeta(meta);
        nmsWorld_broadcastEntityEffect.invoke(nmsWorld, nmsFirework, (byte) 17);
    } catch (Exception e) {
        ExceptionHandler.exception(new InternalException(plugin, e, "Reflection read error"));
    }
    firework.remove();
}

/**
	 * This method handles a Regicide Death.<br>
	 * Please note that in a Regicide Game, players cannot truly 'die'.
	 */
public void die() {
    Firework firework = this.player.getWorld().spawn(this.player.getLocation(), Firework.class);
    FireworkMeta fm = firework.getFireworkMeta();
    fm.addEffect(FireworkEffect.builder().flicker(false).trail(true).with(Type.BALL).with(Type.BALL_LARGE).with(Type.STAR).withColor(Color.YELLOW).withColor(Color.ORANGE).withFade(Color.RED).withFade(Color.PURPLE).build());
    fm.setPower(1);
    firework.setFireworkMeta(fm);
    if (this.isKing) {
        player.sendMessage(ChatColor.RED + "You have lost the King!");
        //remove steak from inventory
        player.getInventory().remove(Material.COOKED_BEEF);
    }
    this.isKing = false;
}

@EventHandler
public void fireworksign(SignChangeEvent e) {
    if (e.getLine(0).equalsIgnoreCase("[firework]")) {
        if (e.getPlayer().hasPermission(PermissionKey.SIGN_FIREWORK.getPermission())) {
            if (colours.isEmpty()) {
                for (DyeColor color : DyeColor.values()) {
                    colours.put(color.name(), color.name());
                }
            }
            if (colours.containsKey(e.getLine(1).toString().toUpperCase().replace(" ", "_")) || e.getLine(1).contains("random")) {
                e.setLine(0, ChatColor.DARK_BLUE + "[Firework]");
                e.setLine(1, e.getLine(1).toLowerCase());
                sendMessage(e.getPlayer(), ChatColor.GREEN + "you successfully placed a firework sign!");
                e.getBlock().getState().update();
                colours.clear();
            } else {
                e.getBlock().breakNaturally();
                sendMessage(e.getPlayer(), ChatColor.RED + "a colour is needed to create this sign");
                colours.clear();
            }
        } else {
            if (e.getLine(0).equalsIgnoreCase("[firework]")) {
                e.getBlock().breakNaturally();
                sendMessage(e.getPlayer(), ChatColor.RED + "you are not allowed to place these signs\n" + ChatColor.WHITE + "permission: xEssentials.signs.firework");
            }
        }
    }
}

@Override
public void createFireworksExplosion(Location location, boolean flicker, boolean trail, int type, int[] colors, int[] fadeColors, int flightDuration) {
    FireworkEffect.Type t = Type.BALL;
    if (type == 1) {
        t = Type.BALL_LARGE;
    } else if (type == 2) {
        t = Type.STAR;
    } else if (type == 3) {
        t = Type.CREEPER;
    } else if (type == 4) {
        t = Type.BURST;
    }
    Color[] c1 = new Color[colors.length];
    for (int i = 0; i < colors.length; i++) {
        c1[i] = Color.fromRGB(colors[i]);
    }
    Color[] c2 = new Color[fadeColors.length];
    for (int i = 0; i < fadeColors.length; i++) {
        c2[i] = Color.fromRGB(fadeColors[i]);
    }
    FireworkEffect effect = FireworkEffect.builder().flicker(flicker).trail(trail).with(t).withColor(c1).withFade(c2).build();
    Firework firework = location.getWorld().spawn(location, Firework.class);
    FireworkMeta meta = firework.getFireworkMeta();
    meta.addEffect(effect);
    meta.setPower(flightDuration < 1 ? 1 : flightDuration);
    firework.setFireworkMeta(meta);
}

public static boolean listenerBlockBreak(String world, Integer x, Integer z, Player player, Material mat, String evillage, String playeruuid, Block block) {
    if (((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).containsKey("str")) {
        String nmat;
        if (mat == null) {
            nmat = null;
        } else
            switch(mat) {
                case WOOL:
                    nmat = mat.toString() + "_" + ((Wool) block.getState().getData()).getColor().toString();
                    break;
                case SANDSTONE:
                    nmat = mat.toString() + "_" + ((Sandstone) block.getState().getData()).getType().toString();
                    break;
                case WOOD:
                case LOG:
                    nmat = mat.toString() + "_" + ((Tree) block.getState().getData()).getSpecies().toString();
                    break;
                case STEP:
                    nmat = mat.toString() + "_" + ((Step) block.getState().getData()).getMaterial().toString();
                    break;
                case WOOD_STEP:
                    nmat = mat.toString() + "_" + ((WoodenStep) block.getState().getData()).getSpecies().toString();
                    break;
                default:
                    nmat = mat.toString();
                    break;
            }
        if (Config.isConfigurationSection("Village Structures." + ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("str"))) {
            if (Config.isInt("Village Structures." + ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("str") + ".Block Hp." + nmat)) {
                if (QuickChecks.isMultiType(((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("str").toString())) {
                    x = ((Integer) ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("mx"));
                    z = ((Integer) ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("mz"));
                }
                ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).replace("hp", ((Integer) ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("hp")) - Config.getInt("Village Structures." + ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("str") + ".Block Hp." + nmat));
                if (((Integer) ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("hp")) < 1) {
                    if (QuickChecks.isMultiType(((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("str").toString())) {
                        tempfile = new File(structureFolder, ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("str") + ".yml");
                        FileConfiguration tempyaml = new YamlConfiguration();
                        try {
                            tempyaml.load(tempfile);
                        } catch (IOExceptionInvalidConfigurationException |  ex) {
                            Logger.getLogger(ListenerBlockBreak.class.getName()).log(Level.SEVERE, null, ex);
                        }
                        for (String cx : tempyaml.getConfigurationSection("Scematic").getKeys(false)) {
                            for (String cz : tempyaml.getConfigurationSection("Scematic." + cx).getKeys(false)) {
                                if (((HashMap) ((HashMap) serverdata.get("worldmap").get(player.getWorld().getUID().toString()).get(x)).get(z)).get("dir").toString().equalsIgnoreCase("n")) {
                                    ((HashMap) ((HashMap) serverdata.get("worldmap").get(player.getWorld().getUID().toString()).get(x + Integer.parseInt(cx) * -1)).get(z + Integer.parseInt(cz) * -1)).remove("str");
                                } else if (((HashMap) ((HashMap) serverdata.get("worldmap").get(player.getWorld().getUID().toString()).get(x)).get(z)).get("dir").toString().equalsIgnoreCase("e")) {
                                    ((HashMap) ((HashMap) serverdata.get("worldmap").get(player.getWorld().getUID().toString()).get(x + Integer.parseInt(cz) * -1)).get(z + Integer.parseInt(cx) * -1)).remove("str");
                                } else if (((HashMap) ((HashMap) serverdata.get("worldmap").get(player.getWorld().getUID().toString()).get(x)).get(z)).get("dir").toString().equalsIgnoreCase("s")) {
                                    ((HashMap) ((HashMap) serverdata.get("worldmap").get(player.getWorld().getUID().toString()).get(x + Integer.parseInt(cx))).get(z + Integer.parseInt(cz))).remove("str");
                                } else {
                                    ((HashMap) ((HashMap) serverdata.get("worldmap").get(player.getWorld().getUID().toString()).get(x + Integer.parseInt(cz))).get(z + Integer.parseInt(cx))).remove("str");
                                }
                            }
                        }
                    }
                    ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).remove("str");
                    ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).remove("hp");
                    ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).remove("dir");
                    ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).remove("base");
                    if (((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).containsKey("con")) {
                        ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).remove("con");
                    }
                    if (((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).containsKey("cle")) {
                        ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).remove("cle");
                    }
                    Firework fw = (Firework) player.getWorld().spawnEntity(player.getLocation(), EntityType.FIREWORK);
                    FireworkMeta fwm = fw.getFireworkMeta();
                    FireworkEffect.Type type = FireworkEffect.Type.CREEPER;
                    FireworkEffect effect = FireworkEffect.builder().flicker(true).withColor(Color.RED).withFade(Color.BLACK).with(type).trail(true).build();
                    fwm.addEffect(effect);
                    fwm.setPower(1);
                    fw.setFireworkMeta(fwm);
                    fw = (Firework) player.getWorld().spawnEntity(player.getLocation(), EntityType.FIREWORK);
                    fwm.setPower(2);
                    fw.setFireworkMeta(fwm);
                    fwm.setPower(3);
                    fw.setFireworkMeta(fwm);
                    fw = (Firework) player.getWorld().spawnEntity(player.getLocation(), EntityType.FIREWORK);
                    fwm.setPower(4);
                    fw.setFireworkMeta(fwm);
                } else if (((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).containsKey("fir")) {
                    ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).put("fir", true);
                    Firework fw = (Firework) player.getWorld().spawnEntity(player.getLocation(), EntityType.FIREWORK);
                    FireworkMeta fwm = fw.getFireworkMeta();
                    FireworkEffect.Type type = FireworkEffect.Type.BURST;
                    FireworkEffect effect = FireworkEffect.builder().flicker(false).withColor(Color.SILVER).withFade(Color.BLACK).with(type).trail(false).build();
                    fwm.addEffect(effect);
                    fwm.setPower(3);
                    fw.setFireworkMeta(fwm);
                    return true;
                }
            }
        } else {
            if (Config.isInt("Village Ranks." + ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("str") + ".Block Hp." + nmat)) {
                ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).replace("hp", ((Integer) ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("hp")) - Config.getInt("Village Ranks." + ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("str") + ".Block Hp." + nmat));
                if (((Integer) ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).get("hp")) < 1) {
                    Firework fw = (Firework) player.getWorld().spawnEntity(player.getLocation(), EntityType.FIREWORK);
                    FireworkMeta fwm = fw.getFireworkMeta();
                    FireworkEffect.Type type = FireworkEffect.Type.CREEPER;
                    FireworkEffect effect = FireworkEffect.builder().flicker(true).withColor(Color.RED).withFade(Color.BLACK).with(type).trail(true).build();
                    fwm.addEffect(effect);
                    fwm.setPower(1);
                    fw.setFireworkMeta(fwm);
                    fw = (Firework) player.getWorld().spawnEntity(player.getLocation(), EntityType.FIREWORK);
                    fwm.setPower(2);
                    fw.setFireworkMeta(fwm);
                    fwm.setPower(3);
                    fw.setFireworkMeta(fwm);
                    fw = (Firework) player.getWorld().spawnEntity(player.getLocation(), EntityType.FIREWORK);
                    fwm.setPower(4);
                    fw.setFireworkMeta(fwm);
                    Defeated.Defeated(evillage, playeruuid);
                } else if (((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).containsKey("fir")) {
                    ((HashMap) ((HashMap) serverdata.get("worldmap").get(world).get(x)).get(z)).put("fir", true);
                    Firework fw = (Firework) player.getWorld().spawnEntity(player.getLocation(), EntityType.FIREWORK);
                    FireworkMeta fwm = fw.getFireworkMeta();
                    FireworkEffect.Type type = FireworkEffect.Type.BURST;
                    FireworkEffect effect = FireworkEffect.builder().flicker(false).withColor(Color.SILVER).withFade(Color.BLACK).with(type).trail(false).build();
                    fwm.addEffect(effect);
                    fwm.setPower(3);
                    fw.setFireworkMeta(fwm);
                    return true;
                }
            }
        }
        if (!Config.getStringList("Village Settings.Placeable/Destroyble Blocks In Structures").contains(nmat)) {
            return true;
        }
    }
    return false;
}

public void launchFireworks(Player player) {
    FileConfiguration config = this.getConfig();
    for (String s : config.getStringList("fireworks")) {
        boolean flicker;
        boolean trail;
        Type type;
        List<Color> colours = new ArrayList<Color>();
        List<Color> fades = new ArrayList<Color>();
        if (s.equals("RANDOM")) {
            flicker = new Random().nextBoolean();
            trail = new Random().nextBoolean();
            type = Type.values()[new Random().nextInt(Type.values().length)];
            for (int i = 0; i < 3; i++) {
                colours.add(COLOURS[new Random().nextInt(COLOURS.length)]);
                fades.add(COLOURS[new Random().nextInt(COLOURS.length)]);
            }
        } else {
            if (config.getConfigurationSection(s) == null) {
                this.getLogger().warning("Firework '" + s + "' does not exist in the config!");
                continue;
            }
            flicker = config.getBoolean(s + ".flicker");
            trail = config.getBoolean(s + ".trail");
            String typeString = config.getString(s + ".type");
            try {
                type = Type.valueOf(typeString);
            } catch (IllegalArgumentException e) {
                this.getLogger().warning("Invalid type specified for firework '" + s + "'!");
                this.getLogger().warning("Using BALL instead");
                type = Type.BALL;
            } catch (NullPointerException e) {
                this.getLogger().warning("Invalid type specified for firework '" + s + "'!");
                this.getLogger().warning("Using BALL instead");
                type = Type.BALL;
            }
            for (String t : config.getStringList(s + ".colours")) {
                try {
                    colours.add((Color) Color.class.getField(t).get(null));
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (NoSuchFieldException e) {
                    this.getLogger().warning("Invalid colour '" + t + "' specified for firework '" + s + "'!");
                    this.getLogger().warning("Using WHITE instead");
                    colours.add(Color.WHITE);
                } catch (SecurityException e) {
                    e.printStackTrace();
                }
            }
            for (String t : config.getStringList(s + ".fades")) {
                try {
                    fades.add((Color) Color.class.getField(t).get(null));
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (NoSuchFieldException e) {
                    this.getLogger().warning("Invalid fade '" + t + "' specified for firework '" + s + "'!");
                    this.getLogger().warning("Using WHITE instead");
                    fades.add(Color.WHITE);
                } catch (SecurityException e) {
                    e.printStackTrace();
                }
            }
        }
        Firework firework = (Firework) player.getWorld().spawnEntity(player.getLocation(), EntityType.FIREWORK);
        FireworkMeta meta = firework.getFireworkMeta();
        FireworkEffect effect = FireworkEffect.builder().flicker(flicker).trail(trail).with(type).withColor(colours).withFade(fades).build();
        meta.addEffect(effect);
        firework.setFireworkMeta(meta);
    }
}

@EventHandler
public void playerLevelUpEvent(LevelUpEvent event) {
    int oldLevel = event.getFromLevel();
    int newLevel = event.getToLevel();
    if (newLevel < oldLevel)
        return;
    Player player = event.getPlayer();
    //just to be sure.
    if (player == null || !player.isOnline())
        return;
    RaCPlayer racPlayer = RaCPlayerManager.get().getPlayer(player);
    //Recheck max Health / Mana:
    racPlayer.getHealthManager().rescanPlayer();
    racPlayer.getHealthManager().checkMaxHealth();
    //Recheck Mana
    racPlayer.getManaManager().rescanPlayer();
    //Resync Spells
    racPlayer.getSpellManager().rescan();
    if (plugin.getConfigManager().getGeneralConfig().isConfig_use_levelup_message()) {
        LanguageAPI.sendTranslatedMessage(racPlayer, Keys.level_up_message, "player", player.getDisplayName(), "level", String.valueOf(newLevel));
        //check for new Skills and tell.
        for (Trait trait : racPlayer.getTraits()) {
            if (trait instanceof TraitWithRestrictions) {
                TraitWithRestrictions twrTrait = (TraitWithRestrictions) trait;
                if (!twrTrait.isInLevelRange(oldLevel) && twrTrait.isInLevelRange(newLevel)) {
                    LanguageAPI.sendTranslatedMessage(racPlayer, Keys.level_up_new_skill_message, "player", player.getDisplayName(), "level", String.valueOf(newLevel), "traitname", trait.getDisplayName());
                }
            }
        }
    }
    //Spawn firework if MC > 1.7 and wanted.
    if (plugin.getConfigManager().getGeneralConfig().isConfig_use_fireworks_on_level_up() && CertainVersionChecker.isAbove1_7()) {
        for (int i = 0; i < 4; i++) {
            Firework fw = (Firework) player.getWorld().spawnEntity(player.getLocation(), EntityType.FIREWORK);
            fw.setFireworkMeta(randomizeFireworkMeta(fw.getFireworkMeta()));
        }
    }
}

@Override
public void run() {
    if (this.timer < 20) {
        Firework fw = (Firework) player.getWorld().spawnEntity(player.getPlayer().getLocation(), EntityType.FIREWORK);
        FireworkMeta fwm = fw.getFireworkMeta();
        Random r = new Random();
        int rt = r.nextInt(4) + 1;
        FireworkEffect.Type type = FireworkEffect.Type.BALL;
        if (rt == 1) {
            type = FireworkEffect.Type.BALL;
        }
        if (rt == 2) {
            type = FireworkEffect.Type.BALL_LARGE;
        }
        if (rt == 3) {
            type = FireworkEffect.Type.BURST;
        }
        if (rt == 4) {
            type = FireworkEffect.Type.CREEPER;
        }
        if (rt == 5) {
            type = FireworkEffect.Type.STAR;
        }
        int r1i = r.nextInt(15) + 1;
        int r2i = r.nextInt(15) + 1;
        Color c1 = Colors.getColor(r1i);
        Color c2 = Colors.getColor(r2i);
        FireworkEffect effect = FireworkEffect.builder().flicker(r.nextBoolean()).withColor(c1).withFade(c2).with(type).trail(r.nextBoolean()).build();
        fwm.addEffect(effect);
        int rp = r.nextInt(2) + 1;
        fwm.setPower(rp);
        fw.setFireworkMeta(fwm);
        this.timer++;
    }
}

public static void shootRandomFirework(Location loc, int height) {
    Firework f = (Firework) loc.getWorld().spawnEntity(loc, EntityType.FIREWORK);
    FireworkMeta fm = f.getFireworkMeta();
    fm.setPower(height);
    int effectAmount = random.nextInt(3) + 1;
    for (int i = 0; i < effectAmount; i++) {
        Builder b = FireworkEffect.builder();
        int colorAmount = random.nextInt(3) + 1;
        for (int ii = 0; ii < colorAmount; ii++) {
            b.withColor(Color.fromBGR(random.nextInt(256), random.nextInt(256), random.nextInt(256)));
        }
        b.with(Type.values()[random.nextInt(Type.values().length)]);
        b.flicker(random.nextInt(2) == 0 ? false : true);
        b.trail(random.nextInt(2) == 0 ? false : true);
        fm.addEffect(b.build());
    }
    f.setFireworkMeta(fm);
}

public void selfDestruct(Player player) {
    //		Block block = player.getLocation().getBlock();
    //		block.setType(Material.CHEST);
    //		final Chest chest = (Chest) block.getState();
    //		for (ItemStack is : player.getInventory()) {
    //			if (is != null)
    //				chest.getInventory().addItem(is);
    //		}
    //		final Inventory inv = player.getInventory();
    //		final World world = player.getWorld();
    //		final Location loc = player.getLocation();
    Random r = new Random();
    double x, z;
    for (ItemStack is : player.getInventory()) {
        if (is != null) {
            Entity i = player.getWorld().dropItemNaturally(player.getLocation(), is);
            x = r.nextDouble() / 2 - .25;
            z = r.nextDouble() / 2 - .25;
            i.setVelocity(new Vector(x, 1, z));
        }
    }
    Firework fw = player.getWorld().spawn(player.getLocation(), Firework.class);
    FireworkMeta fwm = fw.getFireworkMeta();
    FireworkEffect effect = FireworkEffect.builder().withColor(Color.RED).with(Type.BALL).build();
    fwm.addEffects(effect);
    fwm.setPower(0);
    fw.setFireworkMeta(fwm);
    //		((CraftWorld)player.getWorld()).getHandle().broadcastEntityEffect(
    //                ((CraftFirework)fw).getHandle(),
    //                (byte)17);
    player.getInventory().clear();
    player.setHealth(0);
    selfDestructing.remove(player);
//		log(inv.toString());
//		plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
//			@Override 
//			public void run() {
//				log(inv.toString());
//				Random r = new Random();
//				double x, z;
//				for (ItemStack is : chest.getInventory()) {
//					if (is != null) {
//						Entity i = chest.getWorld().dropItemNaturally(chest.getLocation(), is);
//
//						x = r.nextDouble()/2 - .25;
//						z = r.nextDouble()/2 - .25;
//
//						log("x: " + x + " z: " + z);
//						i.setVelocity(new Vector(x, 5, z));
//					}
//				}
//			}
//		}, 20 * 3);
//		Bukkit.getWorld("Survival").createExplosion(player.getLocation().getX(), player.getLocation().getY(), player.getLocation().getZ(), (float)5, false, false);
}

private final void explosion(Location location) {
    if (shotFrom.getExplosionType().equals("TNT")) {
        double x = location.getX();
        double y = location.getY();
        double z = location.getZ();
        location.getWorld().createExplosion(x, y, z, (float) shotFrom.getExplodeRadius(), false, false);
    } else {
        World world = location.getWorld();
        Firework firework = world.spawn(location, Firework.class);
        FireworkMeta meta = firework.getFireworkMeta();
        meta.addEffect(getFireworkEffect());
        meta.setPower(1);
        firework.setFireworkMeta(meta);
        try {
            firework.detonate();
        } catch (Throwable ex) {
        }
    }
}

private void removePlayerFromArenaAndRestoreState(Player player, boolean winner) {
    // remove vote
    votes.remove(player.getName());
    // remove bar
    Bars.removeBar(player);
    // remove player on arena data
    arena.getPlayersManager().remove(player);
    // remove all potion effects
    for (PotionEffect effect : player.getActivePotionEffects()) {
        player.removePotionEffect(effect.getType());
    }
    // restore player status
    plugin.pdata.restorePlayerHunger(player);
    plugin.pdata.restorePlayerPotionEffects(player);
    plugin.pdata.restorePlayerArmor(player);
    plugin.pdata.restorePlayerInventory(player);
    plugin.pdata.restorePlayerLevel(player);
    // add player damage resistance
    player.addPotionEffect(new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, 80, 80, true), true);
    // restore location ot teleport to lobby
    if (arena.getStructureManager().getTeleportDestination() == TeleportDestination.LOBBY && plugin.globallobby.isLobbyLocationWorldAvailable()) {
        player.teleport(plugin.globallobby.getLobbyLocation());
        plugin.pdata.clearPlayerLocation(player);
    } else {
        plugin.pdata.restorePlayerLocation(player);
    }
    // reward player before restoring gamemode if player is winner
    if (winner) {
        arena.getStructureManager().getRewards().rewardPlayer(player);
        // spawn firework
        Firework f = player.getWorld().spawn(player.getLocation(), Firework.class);
        FireworkMeta fm = f.getFireworkMeta();
        fm.addEffect(FireworkEffect.builder().withColor(Color.GREEN).withColor(Color.RED).withColor(Color.PURPLE).with(Type.BALL_LARGE).withFlicker().build());
        fm.setPower(1);
        f.setFireworkMeta(fm);
    }
    plugin.pdata.restorePlayerGameMode(player);
    // update inventory
    player.updateInventory();
    // remove fly
    if (player.hasPermission("tntrun.fly.everywhere")) {
        player.setAllowFlight(true);
        player.setFlying(true);
    } else {
        player.setAllowFlight(false);
        player.setFlying(false);
    }
    plugin.pdata.restorePlayerFlight(player);
    if (player.getGameMode() == GameMode.CREATIVE) {
        player.setAllowFlight(true);
    }
    // check is in arena 0 players
    if (arena.getStatusManager().isArenaRunning() && arena.getPlayersManager().getPlayersCount() == 0) {
        arena.getGameHandler().stopArena();
    }
}

/**
     * Spawns a random firework at the given location.
     *
     * Please note: because the power of a firework is an integer, the min/max heights
     * are with a precision of ±5 blocks.
     *
     * @param location The location where the firework will be spawned.
     * @param heightMin The minimal height of the explosion.
     * @param heightMax The maximal height of the explosion.
     *
     * @return The random firework generated.
     */
public static Firework generateRandomFirework(Location location, int heightMin, int heightMax) {
    Random rand = new Random();
    Firework firework = (Firework) location.getWorld().spawnEntity(location, EntityType.FIREWORK);
    FireworkMeta meta = firework.getFireworkMeta();
    int effectsCount = rand.nextInt(3) + 1;
    for (int i = 0; i < effectsCount; i++) {
        meta.addEffect(generateRandomFireworkEffect());
    }
    // One level of power is half a second of flight time.
    // In half a second, a firework fly ~5 blocks.
    // So, one level of power = ~5 blocks.
    meta.setPower((int) Math.min(Math.floor((heightMin / 5) + rand.nextInt(heightMax / 5)), 128D));
    firework.setFireworkMeta(meta);
    return firework;
}

public void launchFireworkDisplay(final World w, final Location loc) {
    Firework fw = (Firework) w.spawn(loc.clone().add(new Vector(getRandomNum(5, -5), 1, getRandomNum(5, -5))), Firework.class);
    FireworkMeta meta = fw.getFireworkMeta();
    FireworkEffect effect = SkyWarsReloaded.getNMS().getFireworkEffect(getRandomColor(), getRandomColor(), getRandomColor(), getRandomColor(), getRandomColor(), getRandomType());
    meta.addEffect(effect);
    meta.setPower(getRandomNum(4, 1));
    fw.setFireworkMeta(meta);
    fireworksCount++;
    if (fireworksCount < ((SkyWarsReloaded.getCfg().getTimeAfterGame() - 5) * 4)) {
        SkyWarsReloaded.get().getServer().getScheduler().scheduleSyncDelayedTask(SkyWarsReloaded.get(), new Runnable() {

            public void run() {
                launchFireworkDisplay(w, loc);
            }
        }, 5);
    }
}

public static void spawnFirework(Location loc) {
    Random colour = new Random();
    Firework fw = loc.getWorld().spawn(loc, Firework.class);
    FireworkMeta fwMeta = fw.getFireworkMeta();
    Type fwType = Type.BALL_LARGE;
    int c1i = colour.nextInt(17) + 1;
    int c2i = colour.nextInt(17) + 1;
    Color c1 = getFWColor(c1i);
    Color c2 = getFWColor(c2i);
    FireworkEffect effect = FireworkEffect.builder().withFade(c2).withColor(c1).with(fwType).build();
    fwMeta.addEffect(effect);
    fwMeta.setPower(1);
    fw.setFireworkMeta(fwMeta);
}

public void spawnFirework(Player p) {
    Firework fw = (Firework) p.getWorld().spawnEntity(p.getLocation(), EntityType.FIREWORK);
    FireworkMeta fwm = fw.getFireworkMeta();
    FireworkEffect effect = FireworkEffect.builder().flicker(r.nextBoolean()).withColor(Color.AQUA).withFade(Color.ORANGE).with(Type.STAR).trail(r.nextBoolean()).build();
    fwm.addEffect(effect);
    int rp = r.nextInt(2) + 1;
    fwm.setPower(rp);
    fw.setFireworkMeta(fwm);
}

public void launchRandomFirework(Location loc) {
    Firework fw = loc.getWorld().spawn(loc, Firework.class);
    FireworkMeta fm = fw.getFireworkMeta();
    fm.setPower(1);
    fm.addEffects(FireworkEffect.builder().with(getRandomType()).withColor(getRandomColor()).build());
    fw.setFireworkMeta(fm);
}

public static FireworkExplodeEvent callFireworkExplodeEvent(EntityFireworks firework) {
    FireworkExplodeEvent event = new FireworkExplodeEvent((Firework) firework.getBukkitEntity());
    firework.world.getServer().getPluginManager().callEvent(event);
    return event;
}