members = this.arena.getPlayersInTeam(this.team);
84 |
85 | for (Player member : members)
86 | this.particle.play(this.teamSpawn, member);
87 |
88 | } else {
89 | this.particle.play(this.teamSpawn);
90 | }
91 | }
92 | }
93 | }
94 |
--------------------------------------------------------------------------------
/API/src/main/java/me/metallicgoat/tweaksaddon/api/gentiers/GenTierLevel.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.api.gentiers;
2 |
3 | import de.marcely.bedwars.api.GameAPI;
4 | import de.marcely.bedwars.api.arena.Arena;
5 | import de.marcely.bedwars.api.game.spawner.DropType;
6 | import de.marcely.bedwars.api.message.Message;
7 | import java.time.Duration;
8 | import lombok.AllArgsConstructor;
9 | import lombok.Data;
10 | import me.metallicgoat.tweaksaddon.api.unsafe.MBedwarsTweaksAPILayer;
11 | import org.bukkit.Sound;
12 | import org.bukkit.entity.Player;
13 | import org.jetbrains.annotations.Nullable;
14 |
15 | @Data
16 | @AllArgsConstructor
17 | public class GenTierLevel {
18 |
19 | private final int tier;
20 | private final String tierName; // Display Name
21 | @Nullable
22 | private final String holoName; // Example '&eTier &cII'
23 | @Nullable
24 | private final String typeId; // Spawners with this drop-type should update
25 | private final GenTierHandler handler; // Action (eg bed break or upgrade)
26 | private final Duration time; // Time until the update happens (After Last Event)
27 | @Nullable
28 | private final Double speed; // New drop speed
29 | @Nullable
30 | private final Integer limit; // New drop speed
31 | @Nullable
32 | private final String earnMessage; // The chat message displayed on update
33 | @Nullable
34 | private final Sound earnSound; // Sound played when a tier is earned
35 |
36 | public GenTierLevel(
37 | int tier,
38 | String tierName,
39 | GenTierHandler handler,
40 | Duration time,
41 | @Nullable String earnMessage,
42 | @Nullable Sound earnSound) {
43 |
44 | this(tier,
45 | tierName,
46 | null,
47 | null,
48 | handler,
49 | time,
50 | null,
51 | null,
52 | earnMessage,
53 | earnSound);
54 | }
55 |
56 | /**
57 | * Plays the sound, and broadcasts the message of this gen tier.
58 | * Used when this level becomes active
59 | *
60 | * @param arena where this level is active on
61 | */
62 | public void broadcastEarn(Arena arena) {
63 | if (this.earnSound != null) {
64 | for (Player p : arena.getPlayers())
65 | p.playSound(p.getLocation(), this.earnSound, 1F, 1F);
66 | }
67 |
68 | if (this.earnMessage != null)
69 | arena.broadcast(Message.build(this.earnMessage));
70 |
71 | }
72 |
73 | /**
74 | * Returns the DropType of the spawners this level will affect
75 | * Will return null is level does not affect as spawner (i.e. Bread break tier)
76 | *
77 | * @return the DropType this level aims to affect if applicable
78 | */
79 | @Nullable
80 | public DropType getType() {
81 | return GameAPI.get().getDropTypeById(this.typeId);
82 | }
83 |
84 | /**
85 | * Gets the next level after this one has been reached.
86 | *
87 | * @return the next GenTierLevel, or null if this is the highest level
88 | */
89 | @Nullable
90 | public GenTierLevel getNextLevel() {
91 | return MBedwarsTweaksAPILayer.INSTANCE.getGenTierLevel(this.tier + 1);
92 | }
93 |
94 | /**
95 | * Gets the previous level before this one has been reached.
96 | *
97 | * @return the previous GenTierLevel, or null if this is the first level
98 | */
99 | @Nullable
100 | public GenTierLevel getPreviousLevel() {
101 | return MBedwarsTweaksAPILayer.INSTANCE.getGenTierLevel(this.tier - 1);
102 | }
103 | }
--------------------------------------------------------------------------------
/API/src/main/java/me/metallicgoat/tweaksaddon/api/gentiers/GenTierState.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.api.gentiers;
2 |
3 | import de.marcely.bedwars.api.arena.Arena;
4 | import de.marcely.bedwars.api.arena.Team;
5 | import java.time.Duration;
6 | import org.jetbrains.annotations.Nullable;
7 |
8 | /**
9 | * Represents the current state of the gen tier system in an arena.
10 | */
11 | public interface GenTierState {
12 |
13 | /**
14 | * Get the arena this GenTierState belongs to.
15 | *
16 | * @return The arena this GenTierState belongs to.
17 | */
18 | Arena getArena();
19 |
20 | /**
21 | * Check if the gen tier system is currently active in this arena.
22 | *
23 | * @return true if the gen tier system is active, false otherwise.
24 | */
25 | boolean isValid();
26 |
27 | /**
28 | * Check whether a team has bought a team has bought the sudden-death upgrade.
29 | *
30 | * As a result, a dragon will be spawned for the team on sudden death.
31 | *
32 | *
33 | * @param team The team to check.
34 | * @return true if the team has bought the sudden-death upgrade, false otherwise.
35 | */
36 | boolean hasBoughtDragon(Team team);
37 |
38 | /**
39 | * Set whether a team has bought the sudden-death upgrade.
40 | *
41 | * As a result, a dragon will be spawned for the team on sudden death.
42 | *
43 | *
44 | * @param team The team to set.
45 | * @param state The state to set.
46 | */
47 | void setDragonBought(Team team, boolean state);
48 |
49 | /**
50 | * Get the remaining time until the next gen tier level is reached.
51 | *
52 | * Doesn't go below {@link Duration#ZERO}. Might stay at zero for a very short
53 | * time (max a few seconds) if the server is lagging and the scheduler didn't catch up yet.
54 | *
55 | *
56 | * @return The remaining time until the next gen tier level is reached, or null if there is no next gen tier level.
57 | */
58 | @Nullable
59 | Duration getRemainingNextTier();
60 |
61 | /**
62 | * Set the remaining time until the next gen tier level is reached.
63 | *
64 | * @param duration The duration to set
65 | * @throws IllegalStateException if there is no next gen tier level
66 | */
67 | void setRemainingNextTier(Duration duration);
68 |
69 | /**
70 | * Get the tier level that already has been reached.
71 | *
72 | * @return the current gen tier level, or null if no gen tier level has been reached yet
73 | */
74 | @Nullable
75 | GenTierLevel getCurrentTier();
76 |
77 | /**
78 | * Get the next gen tier level that will be reached.
79 | *
80 | * @return the next gen tier level, or null if there is no next gen tier level
81 | */
82 | @Nullable
83 | GenTierLevel getNextTier();
84 |
85 | /**
86 | * Schedule the next gen tier level to be reached.
87 | *
88 | * @param level the next gen tier level to be reached
89 | */
90 | void scheduleNextTier(GenTierLevel level);
91 |
92 | /**
93 | * Schedule the next gen tier level to be reached.
94 | *
95 | * @param level the next gen tier level to be reached
96 | * @param time the duration until the next gen tier level is reached
97 | */
98 | void scheduleNextTier(GenTierLevel level, Duration time);
99 |
100 | /**
101 | * Cancel the current gen tier progression and stops any further.
102 | */
103 | void cancelTiers();
104 | }
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/tweaks/misc/WorldBorderResize.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.tweaks.misc;
2 |
3 | import de.marcely.bedwars.api.arena.Arena;
4 | import de.marcely.bedwars.api.arena.ArenaPersistentStorage;
5 | import de.marcely.bedwars.api.arena.ArenaStatus;
6 | import de.marcely.bedwars.api.arena.RegenerationType;
7 | import de.marcely.bedwars.api.event.arena.ArenaStatusChangeEvent;
8 | import de.marcely.bedwars.api.event.arena.ArenaUnloadEvent;
9 | import de.marcely.bedwars.api.event.arena.RoundStartEvent;
10 | import java.util.HashMap;
11 | import java.util.Map;
12 | import java.util.Optional;
13 | import me.metallicgoat.tweaksaddon.MBedwarsTweaksPlugin;
14 | import me.metallicgoat.tweaksaddon.config.MainConfig;
15 | import org.bukkit.Bukkit;
16 | import org.bukkit.WorldBorder;
17 | import org.bukkit.event.EventHandler;
18 | import org.bukkit.event.EventPriority;
19 | import org.bukkit.event.Listener;
20 | import org.bukkit.scheduler.BukkitTask;
21 |
22 | public class WorldBorderResize implements Listener {
23 |
24 | private static final String KEY_ORIGINAL_SIZE = "tweaks:world_border_original_size";
25 |
26 | private final Map activeTasks = new HashMap<>();
27 |
28 | @EventHandler
29 | public void onRoundStart(RoundStartEvent event) {
30 | start(event.getArena());
31 | }
32 |
33 | @EventHandler(priority = EventPriority.MONITOR)
34 | public void onRoundStop(ArenaStatusChangeEvent event) {
35 | if (event.getNewStatus() != ArenaStatus.RUNNING)
36 | cancel(event.getArena());
37 | }
38 |
39 | @EventHandler
40 | public void onArenaUnload(ArenaUnloadEvent event) {
41 | cancel(event.getArena());
42 | }
43 |
44 | private void start(Arena arena) {
45 | if (!MainConfig.world_border_resize_enabled || arena.getRegenerationType() != RegenerationType.WORLD)
46 | return;
47 | if (arena.getGameWorld().getWorldBorder().getSize() >= 100_000) // probably vanilla border (disabled)
48 | return;
49 |
50 | cancel(arena);
51 |
52 | final BukkitTask scheduler = Bukkit.getScheduler().runTaskLater(
53 | MBedwarsTweaksPlugin.getInstance(),
54 | () -> resize(arena),
55 | 20L * MainConfig.world_border_resize_start_time);
56 |
57 | this.activeTasks.put(arena, scheduler);
58 | }
59 |
60 | private void resize(Arena arena) {
61 | final WorldBorder border = arena.getGameWorld().getWorldBorder();
62 |
63 | // store original size
64 | {
65 | final ArenaPersistentStorage storage = arena.getPersistentStorage();
66 |
67 | storage.setSynchronizedFlag(KEY_ORIGINAL_SIZE, false);
68 | storage.set(KEY_ORIGINAL_SIZE, border.getSize());
69 | storage.saveAsync();
70 | }
71 |
72 | // tell bukkit to resize
73 | border.setSize(
74 | border.getSize()*(MainConfig.world_border_resize_scale/100D),
75 | MainConfig.world_border_resize_duration);
76 |
77 | // clean up
78 | this.activeTasks.remove(arena);
79 | }
80 |
81 | private void cancel(Arena arena) {
82 | if (!MainConfig.world_border_resize_enabled)
83 | return;
84 |
85 | // cancel scheduler
86 | {
87 | final BukkitTask scheduler = this.activeTasks.remove(arena);
88 |
89 | if (scheduler != null)
90 | scheduler.cancel();
91 | }
92 |
93 | // restore border size
94 | {
95 | final ArenaPersistentStorage storage = arena.getPersistentStorage();
96 | final Optional originalSize = storage.getDouble(KEY_ORIGINAL_SIZE);
97 |
98 | if (originalSize.isPresent()) {
99 | final WorldBorder border = arena.getGameWorld().getWorldBorder();
100 |
101 | border.setSize(originalSize.get(), 1);
102 | storage.remove(KEY_ORIGINAL_SIZE);
103 | }
104 | }
105 | }
106 | }
107 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/gentiers/handlers/SuddenDeathHandler.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.gentiers.handlers;
2 |
3 | import de.marcely.bedwars.api.arena.Arena;
4 | import de.marcely.bedwars.api.arena.Team;
5 | import de.marcely.bedwars.api.game.spawner.Spawner;
6 | import de.marcely.bedwars.tools.location.XYZ;
7 | import java.util.List;
8 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierActionType;
9 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierLevel;
10 | import me.metallicgoat.tweaksaddon.config.MainConfig;
11 | import me.metallicgoat.tweaksaddon.gentiers.GenTiers;
12 | import me.metallicgoat.tweaksaddon.gentiers.dragons.SuddenDeathDragonImpl;
13 | import me.metallicgoat.tweaksaddon.utils.Util;
14 | import org.bukkit.Location;
15 | import org.bukkit.Material;
16 | import org.bukkit.World;
17 |
18 | public class SuddenDeathHandler extends BaseGenTierHandler {
19 |
20 | @Override
21 | public void run(GenTierLevel level, Arena arena) {
22 | final Location middle = getArenaMid(arena);
23 |
24 | if (!arena.isInside(middle))
25 | throw new RuntimeException("Failed to find the center of an Arena!");
26 |
27 | // Spawn Team Dragons
28 | for (Team team : arena.getEnabledTeams()) {
29 | if (arena.getPlayersInTeam(team).isEmpty())
30 | continue;
31 |
32 | // Spawn Default Dragon
33 | if (MainConfig.default_sudden_death_dragon_enabled)
34 | SuddenDeathDragonImpl.createNewDragon(arena, team, middle);
35 |
36 | // Spawn extra dragon
37 | if (GenTiers.getState(arena).hasBoughtDragon(team))
38 | SuddenDeathDragonImpl.createNewDragon(arena, team, middle);
39 | }
40 |
41 | // Destroy all Generators
42 | for (Spawner spawner : arena.getSpawners()) {
43 | final Location location = spawner.getLocation().toLocation(arena.getGameWorld()).add(0, 3, 0);
44 |
45 | int i = 5;
46 |
47 | while (location.subtract(0, 1, 0).getBlock().getType() != Material.AIR || i > 0){
48 | location.getBlock().setType(Material.AIR);
49 | i--;
50 | }
51 | }
52 | }
53 |
54 | private Location getArenaMid(Arena arena) {
55 | final World world = arena.getGameWorld();
56 |
57 | if (world == null)
58 | throw new RuntimeException("Cannot spawn a dragon in an arena with no world!?!?!?!");
59 |
60 | final XYZ max = arena.getMaxRegionCorner();
61 | final XYZ min = arena.getMinRegionCorner();
62 |
63 | Location location = null;
64 |
65 | if (min != null && max != null) {
66 | location = new Location(
67 | world,
68 | (max.getX() + min.getX()) / 2,
69 | (max.getY() + min.getY()) / 2,
70 | (max.getZ() + min.getZ()) / 2
71 | );
72 | }
73 |
74 | if (location == null)
75 | location = findAverageLocation(Util.getAllTeamSpawns(arena, world, null), world);
76 |
77 | return location;
78 | }
79 |
80 | // Find the middle using a bunch of points in the arena
81 | public Location findAverageLocation(List locations, World world) {
82 | if (locations == null || locations.isEmpty()) {
83 | return null;
84 | }
85 |
86 | double totalX = 0;
87 | double totalY = 0;
88 | double totalZ = 0;
89 |
90 | for (Location loc : locations) {
91 | totalX += loc.getX();
92 | totalY += loc.getY();
93 | totalZ += loc.getZ();
94 | }
95 |
96 | int numberOfLocations = locations.size();
97 |
98 | return new Location(
99 | world,
100 | totalX / numberOfLocations,
101 | totalY / numberOfLocations,
102 | totalZ / numberOfLocations
103 | );
104 | }
105 |
106 | @Override
107 | public String getId() {
108 | return GenTierActionType.SUDDEN_DEATH.getDefaultHandlerId();
109 | }
110 |
111 | @Override
112 | public GenTierActionType getActionType() {
113 | return GenTierActionType.SUDDEN_DEATH;
114 | }
115 | }
116 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/tweaks/cosmetic/InvisFootstepsParticles.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.tweaks.cosmetic;
2 |
3 | import de.marcely.bedwars.api.GameAPI;
4 | import de.marcely.bedwars.api.arena.Arena;
5 | import de.marcely.bedwars.api.event.player.PlayerQuitArenaEvent;
6 | import de.marcely.bedwars.tools.NMSHelper;
7 | import me.metallicgoat.tweaksaddon.MBedwarsTweaksPlugin;
8 | import me.metallicgoat.tweaksaddon.config.MainConfig;
9 | import org.bukkit.Bukkit;
10 | import org.bukkit.Effect;
11 | import org.bukkit.Location;
12 | import org.bukkit.Material;
13 | import org.bukkit.entity.Player;
14 | import org.bukkit.event.EventHandler;
15 | import org.bukkit.event.Listener;
16 | import org.bukkit.event.player.PlayerMoveEvent;
17 | import org.bukkit.potion.PotionEffectType;
18 | import org.bukkit.scheduler.BukkitTask;
19 | import org.jetbrains.annotations.Nullable;
20 |
21 | import java.util.IdentityHashMap;
22 | import java.util.Map;
23 |
24 | // ONLY FOR 1.8.8 -> 1.12.2
25 | public class InvisFootstepsParticles implements Listener {
26 |
27 | private final Map playerMoveTimes = new IdentityHashMap<>();
28 | private BukkitTask task = null;
29 |
30 | @EventHandler
31 | public void onPlayerMove(PlayerMoveEvent event) {
32 | if (!MainConfig.play_footsteps_with_invis || NMSHelper.get().getVersion() > 12)
33 | return;
34 |
35 | final Player player = event.getPlayer();
36 | final Arena arena = GameAPI.get().getArenaByPlayer(player);
37 |
38 | if (arena == null || arena.getSpectators().contains(player) || !player.hasPotionEffect(PotionEffectType.INVISIBILITY))
39 | return;
40 |
41 | this.playerMoveTimes.put(player, System.currentTimeMillis());
42 |
43 | startTaskIfNeeded();
44 | }
45 |
46 | @EventHandler
47 | public void onPlayerQuit(PlayerQuitArenaEvent event) {
48 | if (!MainConfig.play_footsteps_with_invis || NMSHelper.get().getVersion() > 12)
49 | return;
50 |
51 | this.playerMoveTimes.remove(event.getPlayer());
52 |
53 | stopTaskIfEmpty();
54 | }
55 |
56 | @SuppressWarnings("deprecation") // Player#playEffect()
57 | private void startTaskIfNeeded() {
58 | if (this.task != null)
59 | return;
60 |
61 | this.task = Bukkit.getScheduler().runTaskTimer(MBedwarsTweaksPlugin.getInstance(), () -> {
62 | // Play particle if player moved within 2 seconds
63 | this.playerMoveTimes.entrySet().removeIf(entry -> {
64 | final Player player = entry.getKey();
65 | final Arena arena = GameAPI.get().getArenaByPlayer(player);
66 |
67 | if (!player.hasPotionEffect(PotionEffectType.INVISIBILITY) || arena == null || arena.getSpectators().contains(player))
68 | return true;
69 |
70 | if (System.currentTimeMillis() - entry.getValue() < 200) {
71 | final Location loc = getSuitableParticleLocation(player);
72 |
73 | if (loc != null)
74 | player.playEffect(loc, Effect.FOOTSTEP, 1);
75 |
76 | }
77 |
78 | return false;
79 | });
80 |
81 | stopTaskIfEmpty();
82 |
83 | }, 0, 7);
84 | }
85 |
86 | private void stopTaskIfEmpty() {
87 | if (!this.playerMoveTimes.isEmpty())
88 | return;
89 |
90 | if (this.task != null) {
91 | this.task.cancel();
92 | this.task = null;
93 | }
94 | }
95 |
96 | @Nullable
97 | private Location getSuitableParticleLocation(Player player) {
98 | final Location location = player.getLocation().clone();
99 |
100 | int i = 0;
101 | Material blockType = location.getBlock().getRelative(0, -1, 0).getType();
102 |
103 | while (blockType == Material.AIR && i < 2) {
104 | location.add(0, -1, 0);
105 | blockType = location.getBlock().getRelative(0, -1, 0).getType();
106 | i++;
107 | }
108 |
109 | if (blockType == Material.AIR)
110 | return null;
111 |
112 | location.setY(Math.floor(location.getY()) + 0.05);
113 |
114 | return location;
115 | }
116 | }
117 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/tweaks/advancedswords/AntiChest.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.tweaks.advancedswords;
2 |
3 | import de.marcely.bedwars.api.BedwarsAPI;
4 | import me.metallicgoat.tweaksaddon.config.SwordsToolsConfig;
5 | import me.metallicgoat.tweaksaddon.utils.Util;
6 | import org.bukkit.entity.HumanEntity;
7 | import org.bukkit.entity.Player;
8 | import org.bukkit.event.EventHandler;
9 | import org.bukkit.event.Listener;
10 | import org.bukkit.event.inventory.InventoryAction;
11 | import org.bukkit.event.inventory.InventoryClickEvent;
12 | import org.bukkit.event.inventory.InventoryDragEvent;
13 | import org.bukkit.inventory.Inventory;
14 | import org.bukkit.inventory.ItemStack;
15 |
16 | public class AntiChest implements Listener {
17 |
18 | @EventHandler
19 | public void onShiftClick(InventoryClickEvent e) {
20 | if (!SwordsToolsConfig.anti_chest_enabled)
21 | return;
22 |
23 | if (e.getInventory().getSize() > 26) {
24 | if (e.getClick().isShiftClick() && inArena((Player) e.getWhoClicked())) {
25 | final Inventory clicked = e.getClickedInventory();
26 |
27 | if (clicked == e.getWhoClicked().getInventory()) {
28 | final ItemStack clickedOn = e.getCurrentItem();
29 |
30 | if (clickedOn != null
31 | && SwordsToolsConfig.anti_chest_materials.contains(clickedOn.getType())
32 | && ToolSwordHelper.isNotToIgnore(clickedOn)) {
33 | e.setCancelled(true);
34 | }
35 | }
36 | }
37 | }
38 | }
39 |
40 | @EventHandler
41 | public void onInventoryClick(InventoryClickEvent e) {
42 | if (!SwordsToolsConfig.anti_chest_enabled)
43 | return;
44 |
45 | final Inventory clicked = e.getClickedInventory();
46 | if (!(e.getInventory().getSize() > 26))
47 | return;
48 |
49 | if (e.getAction() == InventoryAction.HOTBAR_SWAP || e.getAction() == InventoryAction.HOTBAR_MOVE_AND_READD) {
50 | final HumanEntity player = e.getWhoClicked();
51 | final Inventory inventory = player != null ? player.getInventory() : null;
52 |
53 | if (inventory != null && clicked != inventory) {
54 | final int swapSlot = e.getHotbarButton();
55 | ItemStack movingItem = null;
56 |
57 | if (e.getClick().name().equals("SWAP_OFFHAND"))
58 | movingItem = Util.getItemInOffHand(player);
59 |
60 | else if (swapSlot >= 0)
61 | movingItem = inventory.getItem(swapSlot);
62 |
63 | if (movingItem != null
64 | && SwordsToolsConfig.anti_chest_materials.contains(movingItem.getType())
65 | && ToolSwordHelper.isNotToIgnore(movingItem)) {
66 | e.setCancelled(true);
67 | return;
68 | }
69 | }
70 | }
71 |
72 | if (clicked != e.getWhoClicked().getInventory() && inArena((Player) e.getWhoClicked())) {
73 | // The cursor item is going into the top inventory
74 | final ItemStack onCursor = e.getCursor();
75 | if (onCursor != null
76 | && SwordsToolsConfig.anti_chest_materials.contains(onCursor.getType())
77 | && ToolSwordHelper.isNotToIgnore(onCursor)) {
78 | e.setCancelled(true);
79 | }
80 | }
81 | }
82 |
83 | @EventHandler
84 | public void onInventoryDrag(InventoryDragEvent e) {
85 | if (!SwordsToolsConfig.anti_chest_enabled)
86 | return;
87 |
88 | final ItemStack dragged = e.getOldCursor();
89 | if (SwordsToolsConfig.anti_chest_materials.contains(dragged.getType())
90 | && inArena((Player) e.getWhoClicked())
91 | && ToolSwordHelper.isNotToIgnore(dragged)) {
92 |
93 | final int inventorySize = e.getInventory().getSize();
94 | for (int i : e.getRawSlots()) {
95 | if (i < inventorySize) {
96 | e.setCancelled(true);
97 | break;
98 | }
99 | }
100 | }
101 | }
102 |
103 | private boolean inArena(Player p) {
104 | return BedwarsAPI.getGameAPI().getArenaByPlayer(p) != null;
105 | }
106 | }
107 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/tweaks/cosmetic/PlaceholderUpdating.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.tweaks.cosmetic;
2 |
3 | import de.marcely.bedwars.api.BedwarsAPI;
4 | import de.marcely.bedwars.api.arena.Arena;
5 | import de.marcely.bedwars.api.arena.ArenaStatus;
6 | import de.marcely.bedwars.api.event.arena.ArenaDeleteEvent;
7 | import de.marcely.bedwars.api.event.arena.ArenaStatusChangeEvent;
8 | import de.marcely.bedwars.api.event.player.PlayerJoinArenaEvent;
9 | import de.marcely.bedwars.api.event.player.PlayerQuitArenaEvent;
10 | import de.marcely.bedwars.api.message.Message;
11 | import de.marcely.bedwars.tools.Helper;
12 | import java.util.Map;
13 | import java.util.concurrent.ConcurrentHashMap;
14 | import me.metallicgoat.tweaksaddon.MBedwarsTweaksPlugin;
15 | import me.metallicgoat.tweaksaddon.config.MainConfig;
16 | import org.bukkit.Bukkit;
17 | import org.bukkit.entity.Player;
18 | import org.bukkit.event.EventHandler;
19 | import org.bukkit.event.EventPriority;
20 | import org.bukkit.event.Listener;
21 | import org.bukkit.scheduler.BukkitTask;
22 |
23 | public class PlaceholderUpdating implements Listener {
24 |
25 | private final Map tickingArenas = new ConcurrentHashMap<>();
26 |
27 | private BukkitTask createScheduler(Arena arena) {
28 | long delay = 0;
29 |
30 | switch (arena.getStatus()) {
31 | case LOBBY:
32 | case END_LOBBY:
33 | delay = (int) Math.max(0, (arena.getLobbyTimeRemaining()%1)*20D);
34 | break;
35 | case RUNNING:
36 | delay = arena.getRunningTime().toMillis()/50;
37 | break;
38 | }
39 |
40 | return Bukkit.getServer().getScheduler().runTaskTimerAsynchronously(MBedwarsTweaksPlugin.getInstance(), () -> {
41 | if (arena.getStatus() == ArenaStatus.RUNNING && MainConfig.scoreboard_updating_enabled_in_game)
42 | arena.updateScoreboard();
43 | else if (arena.getStatus() == ArenaStatus.LOBBY && MainConfig.scoreboard_updating_enabled_in_lobby)
44 | arena.updateScoreboard();
45 |
46 | if ((arena.getStatus() == ArenaStatus.RUNNING && MainConfig.custom_action_bar_in_game) ||
47 | (arena.getStatus() == ArenaStatus.LOBBY && MainConfig.custom_action_bar_in_lobby)) {
48 |
49 | for (Player player : arena.getPlayers())
50 | BedwarsAPI.getNMSHelper().showActionbar(player, Message.build(Helper.get().replacePAPIPlaceholders(MainConfig.custom_action_bar_message, player)).done());
51 | }
52 | }, delay, 20L);
53 | }
54 |
55 | private void startScheduler(Arena arena) {
56 | if (!arena.exists())
57 | return;
58 |
59 | this.tickingArenas.computeIfAbsent(arena, this::createScheduler);
60 | }
61 |
62 | private void stopScheduler(Arena arena) {
63 | final BukkitTask task = this.tickingArenas.remove(arena);
64 |
65 | if (task != null)
66 | task.cancel();
67 | }
68 |
69 | @EventHandler
70 | public void onPlayerJoin(PlayerJoinArenaEvent event) {
71 | final Arena arena = event.getArena();
72 |
73 | if (arena.getPlayers().size() >= 2) // already added
74 | return;
75 |
76 | startScheduler(arena);
77 | }
78 |
79 | @EventHandler
80 | public void onPlayerLeave(PlayerQuitArenaEvent event) {
81 | final Arena arena = event.getArena();
82 |
83 | if (!arena.getPlayers().isEmpty()) // not empty yet
84 | return;
85 |
86 | stopScheduler(arena);
87 | }
88 |
89 | @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
90 | public void onArenaStatusChange(ArenaStatusChangeEvent event) {
91 | // resync scheduler
92 | final Arena arena = event.getArena();
93 | final ArenaStatus newStatus = event.getNewStatus();
94 |
95 | if (newStatus != ArenaStatus.RUNNING && newStatus != ArenaStatus.END_LOBBY)
96 | return;
97 |
98 | Bukkit.getScheduler().runTaskLaterAsynchronously(MBedwarsTweaksPlugin.getInstance(), () -> {
99 | stopScheduler(arena);
100 | startScheduler(arena);
101 | }, 1);
102 | }
103 |
104 | @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
105 | public void onArenaDeleteEvent(ArenaDeleteEvent event) {
106 | stopScheduler(event.getArena());
107 | }
108 | }
109 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/MBedwarsTweaksPlugin.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon;
2 |
3 | import de.marcely.bedwars.api.BedwarsAPI;
4 | import lombok.Getter;
5 | import me.metallicgoat.tweaksaddon.api.events.PostConfigLoadEvent;
6 | import me.metallicgoat.tweaksaddon.api.events.PreConfigsLoadEvent;
7 | import me.metallicgoat.tweaksaddon.config.ConfigLoader;
8 | import me.metallicgoat.tweaksaddon.config.MainConfig;
9 | import me.metallicgoat.tweaksaddon.gentiers.dragons.DragonUtil;
10 | import me.metallicgoat.tweaksaddon.integration.DependencyLoader;
11 | import me.metallicgoat.tweaksaddon.tweaks.advancedswords.ToolSwordHelper;
12 | import me.metallicgoat.tweaksaddon.utils.Console;
13 | import me.metallicgoat.tweaksaddon.utils.Metrics;
14 | import me.metallicgoat.tweaksaddon.utils.NMSClass;
15 | import me.metallicgoat.tweaksaddon.utils.UpdateChecker;
16 | import me.metallicgoat.tweaksaddon.utils.Util;
17 | import org.bukkit.Bukkit;
18 | import org.bukkit.plugin.PluginDescriptionFile;
19 | import org.bukkit.plugin.java.JavaPlugin;
20 |
21 | public class MBedwarsTweaksPlugin extends JavaPlugin {
22 |
23 | public static final int MIN_MBEDWARS_API_VER = 205;
24 | public static final String MIN_MBEDWARS_VER_NAME = "5.5.5";
25 |
26 | @Getter
27 | private static MBedwarsTweaksPlugin instance;
28 | @Getter
29 | private static MBedwarsTweaksAddon addon;
30 |
31 | @Override
32 | public void onEnable() {
33 | instance = this;
34 |
35 | if (!checkMBedwars())
36 | return;
37 | if (!registerAddon())
38 | return;
39 |
40 | new Metrics(this, 11928);
41 |
42 | Util.init();
43 |
44 | addon.registerMessageMappings();
45 | addon.registerEvents();
46 | addon.registerUpgrades();
47 | addon.registerCommands();
48 |
49 | final PluginDescriptionFile pdf = this.getDescription();
50 |
51 | Console.printInfo(
52 | "------------------------------",
53 | pdf.getName() + " For MBedwars",
54 | "By: " + pdf.getAuthors(),
55 | "Version: " + pdf.getVersion(),
56 | "------------------------------"
57 | );
58 |
59 | loadTweaks(true);
60 | }
61 |
62 | public void loadTweaks(boolean firstLoad) {
63 | BedwarsAPI.onReady(() -> {
64 | DependencyLoader.loadAll();
65 |
66 | {
67 | final PreConfigsLoadEvent preConfigsLoadEvent = new PreConfigsLoadEvent(firstLoad);
68 | Bukkit.getPluginManager().callEvent(preConfigsLoadEvent);
69 |
70 | ConfigLoader.loadTweaksConfigs(this);
71 |
72 | final PostConfigLoadEvent postConfigLoadEvent = new PostConfigLoadEvent(firstLoad);
73 | Bukkit.getPluginManager().callEvent(postConfigLoadEvent);
74 | }
75 |
76 | ToolSwordHelper.load();
77 |
78 | if (MainConfig.disable_dragon_death_sound) {
79 | try {
80 | NMSClass.disableDragonSound();
81 | } catch (Exception e) {
82 | Console.printWarn(
83 | "============================================",
84 | "Failed to disable dragon death sounds! You may want to disable them in your spigot.yml",
85 | "============================================"
86 | );
87 | }
88 | }
89 |
90 | // Check Update Async
91 | if (MainConfig.check_update_on_load)
92 | Bukkit.getScheduler().runTaskAsynchronously(this, () -> UpdateChecker.checkForUpdate(this.getDescription().getVersion()));
93 |
94 | });
95 | }
96 |
97 | @Override
98 | public void onDisable() {
99 | DragonUtil.killAllDragons();
100 | }
101 |
102 | private boolean checkMBedwars() {
103 | try {
104 | final Class apiClass = Class.forName("de.marcely.bedwars.api.BedwarsAPI");
105 | final int apiVersion = (int) apiClass.getMethod("getAPIVersion").invoke(null);
106 |
107 | if (apiVersion < MIN_MBEDWARS_API_VER)
108 | throw new IllegalStateException();
109 | } catch (Exception e) {
110 | getLogger().warning("Sorry, your installed version of MBedwars is not supported. Please install at least v" + MIN_MBEDWARS_VER_NAME);
111 | Bukkit.getPluginManager().disablePlugin(this);
112 |
113 | return false;
114 | }
115 |
116 | return true;
117 | }
118 |
119 | private boolean registerAddon() {
120 | addon = new MBedwarsTweaksAddon(this);
121 |
122 | if (!addon.register()) {
123 | getLogger().warning("It seems like this addon has already been loaded. Please delete duplicates and try again.");
124 | Bukkit.getPluginManager().disablePlugin(this);
125 |
126 | return false;
127 | }
128 |
129 | return true;
130 | }
131 | }
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/tweaks/advancedswords/AlwaysSword.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.tweaks.advancedswords;
2 |
3 | import de.marcely.bedwars.api.BedwarsAPI;
4 | import de.marcely.bedwars.api.GameAPI;
5 | import de.marcely.bedwars.api.arena.Arena;
6 | import de.marcely.bedwars.api.arena.ArenaStatus;
7 | import me.metallicgoat.tweaksaddon.MBedwarsTweaksPlugin;
8 | import me.metallicgoat.tweaksaddon.config.SwordsToolsConfig;
9 | import org.bukkit.Bukkit;
10 | import org.bukkit.GameMode;
11 | import org.bukkit.entity.Player;
12 | import org.bukkit.event.EventHandler;
13 | import org.bukkit.event.Listener;
14 | import org.bukkit.event.inventory.InventoryClickEvent;
15 | import org.bukkit.event.player.PlayerDropItemEvent;
16 | import org.bukkit.event.player.PlayerPickupItemEvent;
17 | import org.bukkit.inventory.Inventory;
18 | import org.bukkit.inventory.ItemStack;
19 | import org.bukkit.inventory.PlayerInventory;
20 | import org.bukkit.scheduler.BukkitTask;
21 |
22 | import java.util.IdentityHashMap;
23 | import java.util.Map;
24 |
25 | public class AlwaysSword implements Listener {
26 |
27 | final Map runningTasks = new IdentityHashMap<>();
28 |
29 | @EventHandler
30 | public void onClick(InventoryClickEvent e) {
31 | if (!SwordsToolsConfig.always_sword_drop_enabled)
32 | return;
33 |
34 | final Player player = (Player) e.getWhoClicked();
35 | final Arena arena = BedwarsAPI.getGameAPI().getArenaByPlayer(player);
36 |
37 | if (arena != null
38 | && arena.getStatus() == ArenaStatus.RUNNING
39 | && player.getGameMode() != GameMode.SPECTATOR) {
40 |
41 | if (runningTasks.containsKey(player))
42 | runningTasks.get(player).cancel();
43 |
44 | runningTasks.put(player, Bukkit.getServer().getScheduler().runTaskLater((MBedwarsTweaksPlugin.getInstance()), () -> {
45 | final Arena currArena = GameAPI.get().getArenaByPlayer(player);
46 |
47 | if (currArena != arena || !arena.getPlayers().contains(player) || arena.getSpectators().contains(player)) {
48 | runningTasks.remove(player);
49 | return;
50 | }
51 |
52 | final Inventory pi = player.getInventory();
53 | final int i = ToolSwordHelper.getSwordsAmount(player);
54 |
55 | if (i >= 2) {
56 | for (ItemStack itemStack : pi.getContents()) {
57 | if (itemStack != null
58 | && itemStack.getType() == ToolSwordHelper.WOOD_SWORD
59 | && ToolSwordHelper.isNotToIgnore(itemStack)) {
60 |
61 | pi.remove(itemStack);
62 |
63 | if (!ToolSwordHelper.hasBetterSword(player))
64 | break;
65 | }
66 | }
67 | // Give player a wood sword if they don't have one
68 | } else if (i == 0 &&
69 | (e.getCurrentItem() == null || e.getCurrentItem() != null && !e.getCurrentItem().getType().name().endsWith("SWORD") && ToolSwordHelper.isNotToIgnore(e.getCurrentItem())) &&
70 | (e.getCursor() == null || e.getCursor() != null && !e.getCursor().getType().name().endsWith("SWORD") && ToolSwordHelper.isNotToIgnore(e.getCursor()))) {
71 |
72 | pi.addItem(ToolSwordHelper.getDefaultWoodSword(player, arena));
73 | }
74 |
75 | runningTasks.remove(player);
76 | }, 25L));
77 | }
78 | }
79 |
80 | @EventHandler
81 | public void giveSwordOnDrop(PlayerDropItemEvent event) {
82 | if (!SwordsToolsConfig.always_sword_drop_enabled)
83 | return;
84 |
85 | final Player player = event.getPlayer();
86 | final Arena arena = BedwarsAPI.getGameAPI().getArenaByPlayer(player);
87 | final PlayerInventory pi = player.getInventory();
88 |
89 | if (arena == null || arena.getStatus() != ArenaStatus.RUNNING)
90 | return;
91 |
92 | if (event.getItemDrop().getItemStack().getType() == ToolSwordHelper.WOOD_SWORD) {
93 | event.setCancelled(true);
94 | return;
95 | }
96 |
97 | if (ToolSwordHelper.getSwordsAmount(event.getPlayer()) == 0) {
98 | final ItemStack is = ToolSwordHelper.getDefaultWoodSword(player, arena);
99 |
100 | // tries to put sword in slot player dropped sword from
101 | if (pi.getItem(pi.getHeldItemSlot()) == null)
102 | pi.setItem(pi.getHeldItemSlot(), is);
103 | else
104 | pi.addItem(is);
105 | }
106 | }
107 |
108 | @EventHandler
109 | public void replaceSwordOnCollect(PlayerPickupItemEvent event) {
110 | if (!SwordsToolsConfig.always_sword_drop_enabled)
111 | return;
112 |
113 | final Player player = event.getPlayer();
114 | final Arena arena = BedwarsAPI.getGameAPI().getArenaByPlayer(player);
115 | final ItemStack sword = event.getItem().getItemStack();
116 |
117 | if (arena != null &&
118 | ToolSwordHelper.isSword(sword.getType()) &&
119 | ToolSwordHelper.isNotToIgnore(sword)) {
120 |
121 | final PlayerInventory pi = player.getInventory();
122 |
123 | if (pi.contains(ToolSwordHelper.WOOD_SWORD))
124 | pi.remove(ToolSwordHelper.WOOD_SWORD);
125 |
126 | pi.addItem(sword);
127 | event.getItem().remove();
128 | event.setCancelled(true);
129 | }
130 | }
131 | }
132 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/pom.xml:
--------------------------------------------------------------------------------
1 |
4 |
5 | 4.0.0
6 | MBedwarsTweaks
7 | jar
8 |
9 |
10 | me.metallicgoat.tweaksaddon
11 | MBedwarsTweaksParent
12 | 5.0.0-Beta2
13 |
14 |
15 |
16 |
17 | spigot-repo
18 | https://hub.spigotmc.org/nexus/content/repositories/snapshots/
19 |
20 |
21 | papermc
22 | https://repo.papermc.io/repository/maven-public/
23 |
24 |
25 | mbedwars-repo
26 | https://repo.marcely.de/repository/maven-public/
27 |
28 |
29 | placeholderapi
30 | https://repo.extendedclip.com/content/repositories/placeholderapi/
31 |
32 |
33 |
34 |
35 |
36 | me.metallicgoat.tweaksaddon
37 | API
38 | 5.0.0-Beta2
39 | compile
40 |
41 |
42 | org.jetbrains
43 | annotations
44 | 26.0.2
45 | provided
46 |
47 |
48 | org.spigotmc
49 | spigot-api
50 | 1.8.8-R0.1-SNAPSHOT
51 | provided
52 |
53 |
54 | io.papermc.paper
55 | paper-api
56 | 1.21.10-R0.1-SNAPSHOT
57 | provided
58 |
59 |
60 | me.clip
61 | placeholderapi
62 | 2.11.7
63 | provided
64 |
65 |
66 | de.marcely.bedwars
67 | API
68 | 5.5.6-Beta4
69 | provided
70 |
71 |
72 | me.metallicgoat.hotbarmanageraddon
73 | API
74 | 1.0
75 | system
76 | ${basedir}/libs/public/HotbarManager-1.0-SNAPSHOT.jar
77 |
78 |
79 | me.tvhee
80 | PrestigesAddon
81 | 1.2.0
82 | system
83 | ${basedir}/libs/public/PrestigeAddonAPI-1.2.0.jar
84 |
85 |
86 | org.projectlombok
87 | lombok
88 | 1.18.38
89 | compile
90 |
91 |
92 |
93 |
94 | 8
95 | 8
96 |
97 |
98 |
99 |
100 |
101 | org.apache.maven.plugins
102 | maven-shade-plugin
103 | 3.6.1
104 |
105 | false
106 |
107 |
108 | me.metallicgoat.tweaksaddon:API
109 |
110 | **/*
111 |
112 |
113 |
114 |
115 |
116 | me.metallicgoat.tweaksaddon:API
117 |
118 |
119 |
120 |
121 |
122 | package
123 |
124 | shade
125 |
126 |
127 |
128 |
129 |
130 |
131 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/tweaks/messages/TopKillerMessage.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.tweaks.messages;
2 |
3 | import de.marcely.bedwars.api.arena.Arena;
4 | import de.marcely.bedwars.api.arena.QuitPlayerMemory;
5 | import de.marcely.bedwars.api.event.arena.ArenaDeleteEvent;
6 | import de.marcely.bedwars.api.event.arena.RoundEndEvent;
7 | import de.marcely.bedwars.api.event.arena.RoundStartEvent;
8 | import de.marcely.bedwars.api.message.Message;
9 | import de.marcely.bedwars.api.player.DefaultPlayerStatSet;
10 | import de.marcely.bedwars.api.player.PlayerDataAPI;
11 | import de.marcely.bedwars.api.player.PlayerStats;
12 | import java.util.ArrayList;
13 | import java.util.Collection;
14 | import java.util.Comparator;
15 | import java.util.HashMap;
16 | import java.util.IdentityHashMap;
17 | import java.util.LinkedHashMap;
18 | import java.util.List;
19 | import java.util.Map;
20 | import java.util.Optional;
21 | import java.util.UUID;
22 | import java.util.stream.Collectors;
23 | import me.metallicgoat.tweaksaddon.config.MainConfig;
24 | import org.bukkit.Bukkit;
25 | import org.bukkit.OfflinePlayer;
26 | import org.bukkit.entity.Player;
27 | import org.bukkit.event.EventHandler;
28 | import org.bukkit.event.EventPriority;
29 | import org.bukkit.event.Listener;
30 |
31 | public class TopKillerMessage implements Listener {
32 |
33 | public Map> arenaPlayers = new IdentityHashMap<>();
34 |
35 | @EventHandler
36 | public void onRoundStart(RoundStartEvent event) {
37 | if (!MainConfig.top_killer_message_enabled)
38 | return;
39 |
40 | final Arena arena = event.getArena();
41 | final List players = new ArrayList<>();
42 |
43 | for (Player player : arena.getPlayers())
44 | players.add(player.getUniqueId());
45 |
46 | arenaPlayers.put(arena, players);
47 | }
48 |
49 | @EventHandler
50 | public void onGameOver(RoundEndEvent event) {
51 | if (!MainConfig.top_killer_message_enabled)
52 | return;
53 |
54 | final Arena arena = event.getArena();
55 | final Map nameIntMap = new HashMap<>();
56 |
57 | // Online Players
58 | for (UUID player : arenaPlayers.get(arena))
59 | addStatsToMap(nameIntMap, player);
60 |
61 | // Offline Players
62 | for (QuitPlayerMemory memory : arena.getQuitPlayerMemories())
63 | addStatsToMap(nameIntMap, memory.getUniqueId());
64 |
65 | printMessage(arena, sortHashMapByValue(nameIntMap));
66 | arenaPlayers.remove(arena);
67 | }
68 |
69 | @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
70 | public void onArenaDeleteEvent(ArenaDeleteEvent event) {
71 | arenaPlayers.remove(event.getArena());
72 | }
73 |
74 | // TODO this bad
75 | private void printMessage(Arena arena, Map playerIntegerMap) {
76 | final List formattedList = new ArrayList<>();
77 |
78 | // There is Killers
79 | if (!playerIntegerMap.isEmpty()) {
80 | for (String line : MainConfig.top_killer_pre_lines)
81 | formattedList.add(Message.build(line));
82 |
83 | int place = 1;
84 | for (UUID uuid : playerIntegerMap.keySet()) {
85 | final String text = MainConfig.top_killer_lines.get(place);
86 |
87 | if (text == null)
88 | continue;
89 |
90 | final OfflinePlayer player = Bukkit.getOfflinePlayer(uuid);
91 |
92 | formattedList.add(Message.build(text)
93 | .placeholder("killer-name", player.getName())
94 | .placeholder("killer-display-name", player.getName())
95 | .placeholder("kill-amount", playerIntegerMap.get(uuid))
96 | );
97 |
98 | place++;
99 | }
100 |
101 | for (String line : MainConfig.top_killer_sub_lines)
102 | formattedList.add(Message.build(line));
103 |
104 | // There are no killers
105 | } else {
106 | if (MainConfig.no_top_killer_message_enabled)
107 | return;
108 |
109 | for (String line : MainConfig.no_top_killer_message)
110 | formattedList.add(Message.build(line));
111 | }
112 |
113 | broadcast(arena, formattedList);
114 | }
115 |
116 | public LinkedHashMap sortHashMapByValue(Map hm) {
117 | return hm.entrySet()
118 | .stream()
119 | .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
120 | .collect(Collectors.toMap(
121 | Map.Entry::getKey,
122 | Map.Entry::getValue,
123 | (e1, e2) -> e1,
124 | LinkedHashMap::new
125 | ));
126 | }
127 |
128 | private void addStatsToMap(Map nameIntMap, UUID player) {
129 | if (player == null)
130 | return;
131 |
132 | final Optional stats = PlayerDataAPI.get().getStatsCached(player);
133 |
134 | if (!stats.isPresent())
135 | return;
136 |
137 | final int kills = DefaultPlayerStatSet.KILLS.getValue(stats.get().getGameStats()).intValue();
138 |
139 | if (kills > 0)
140 | nameIntMap.put(player, kills);
141 | }
142 |
143 | private void broadcast(Arena arena, List message) {
144 | if (message == null || (message.size() == 1 && message.get(0).done(false).isEmpty()))
145 | return;
146 |
147 | for (Message line : message)
148 | arena.broadcast(line);
149 | }
150 | }
151 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/tweaks/spawners/SpawnerUpgrade.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.tweaks.spawners;
2 |
3 | import de.marcely.bedwars.api.GameAPI;
4 | import de.marcely.bedwars.api.arena.Arena;
5 | import de.marcely.bedwars.api.arena.ArenaStatus;
6 | import de.marcely.bedwars.api.arena.Team;
7 | import de.marcely.bedwars.api.event.arena.ArenaDeleteEvent;
8 | import de.marcely.bedwars.api.event.arena.ArenaStatusChangeEvent;
9 | import de.marcely.bedwars.api.event.player.PlayerBuyUpgradeEvent;
10 | import de.marcely.bedwars.api.game.spawner.DropType;
11 | import de.marcely.bedwars.api.game.spawner.Spawner;
12 | import de.marcely.bedwars.api.game.upgrade.UpgradeLevel;
13 | import de.marcely.bedwars.api.game.upgrade.UpgradeTriggerHandler;
14 | import de.marcely.bedwars.api.game.upgrade.UpgradeTriggerHandlerType;
15 | import me.metallicgoat.tweaksaddon.MBedwarsTweaksPlugin;
16 | import me.metallicgoat.tweaksaddon.config.MainConfig;
17 | import org.bukkit.Location;
18 | import org.bukkit.event.EventHandler;
19 | import org.bukkit.event.EventPriority;
20 | import org.bukkit.event.Listener;
21 | import org.bukkit.scheduler.BukkitRunnable;
22 | import org.bukkit.scheduler.BukkitTask;
23 |
24 | import java.util.ArrayList;
25 | import java.util.List;
26 | import java.util.Map;
27 | import java.util.concurrent.ConcurrentHashMap;
28 | import java.util.concurrent.CopyOnWriteArrayList;
29 |
30 | public class SpawnerUpgrade implements Listener {
31 |
32 | public static Map> runningTasks = new ConcurrentHashMap<>();
33 |
34 | @EventHandler(priority = EventPriority.MONITOR)
35 | public void onPlayerBuyUpgrade(PlayerBuyUpgradeEvent event) {
36 | final Arena arena = event.getArena();
37 | final Team team = event.getTeam();
38 | final UpgradeLevel level = event.getUpgradeLevel();
39 | final UpgradeTriggerHandler handler = level.getTriggerHandler();
40 |
41 | // Check enable
42 | if (!MainConfig.advanced_forge_enabled || arena == null || team == null || handler == null || !event.getProblems().isEmpty())
43 | return;
44 |
45 | // Check upgrade type
46 | if (handler.getType() != UpgradeTriggerHandlerType.SPAWNER_MULTIPLIER)
47 | return;
48 |
49 | // Check whether he reached the required level
50 | final UpgradeLevel oldLevel = event.getUpgradeState().getCurrentUpgradeLevel(level.getUpgrade());
51 |
52 | if (oldLevel != null && oldLevel.getLevel() >= MainConfig.advanced_forge_level)
53 | return;
54 |
55 | if (level.getLevel() < MainConfig.advanced_forge_level)
56 | return;
57 |
58 | // Start upgrade
59 | final BukkitTask task = (new SpawnerUpgradeTask(arena, team)).runTaskTimer(
60 | MBedwarsTweaksPlugin.getInstance(),
61 | 80,
62 | 20L * MainConfig.advanced_forge_drop_rate);
63 | final List arenaTasks = runningTasks.get(arena);
64 |
65 | if (arenaTasks != null)
66 | arenaTasks.add(task);
67 | else {
68 | final List list = new CopyOnWriteArrayList<>();
69 | list.add(task);
70 | runningTasks.put(arena, list);
71 | }
72 | }
73 |
74 | @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
75 | public void onArenaStatusChangeEvent(ArenaStatusChangeEvent event) {
76 | if (event.getOldStatus() == ArenaStatus.RUNNING)
77 | removeArena(event.getArena());
78 | }
79 |
80 | @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
81 | public void onArenaDeleteEvent(ArenaDeleteEvent event) {
82 | removeArena(event.getArena());
83 | }
84 |
85 | private void removeArena(Arena arena) {
86 | final List tasks = runningTasks.remove(arena);
87 |
88 | if (tasks == null)
89 | return;
90 |
91 | for (BukkitTask task : tasks)
92 | task.cancel();
93 | }
94 |
95 |
96 |
97 | private static class SpawnerUpgradeTask extends BukkitRunnable {
98 | private final Arena arena;
99 | private final Location baseLocation;
100 | private final DropType dropType = GameAPI.get().getDropTypeById(MainConfig.advanced_forge_new_drop);
101 | private final DropType affectingType = GameAPI.get().getDropTypeById(MainConfig.advanced_forge_effected_spawner);
102 |
103 | public SpawnerUpgradeTask(Arena arena, Team team) {
104 | this.arena = arena;
105 | this.baseLocation = arena.getTeamSpawn(team).toLocation(arena.getGameWorld());
106 | }
107 |
108 | @Override
109 | public void run() {
110 | if (arena.getStatus() != ArenaStatus.RUNNING) {
111 | cancel();
112 | return;
113 | }
114 |
115 | if (affectingType == null || dropType == null)
116 | return;
117 |
118 | for (Spawner spawner : getAffectingSpawners())
119 | spawner.drop(false, dropType.getDroppingMaterials());
120 | }
121 |
122 | private List getAffectingSpawners() {
123 | final List spawnerList = new ArrayList<>();
124 |
125 | for (Spawner spawner : this.arena.getSpawners()) {
126 | if (spawner.getDropType() != affectingType)
127 | continue;
128 |
129 | if (baseLocation.distance(spawner.getLocation().toLocation(this.arena.getGameWorld())) <= MainConfig.advanced_forge_range)
130 | spawnerList.add(spawner);
131 | }
132 |
133 | return spawnerList;
134 | }
135 | }
136 | }
137 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/tweaks/spectialitems/TrackerDistance.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.tweaks.spectialitems;
2 |
3 | import de.marcely.bedwars.api.GameAPI;
4 | import de.marcely.bedwars.api.arena.Arena;
5 | import de.marcely.bedwars.api.arena.ArenaStatus;
6 | import de.marcely.bedwars.api.arena.Team;
7 | import de.marcely.bedwars.api.event.arena.ArenaStatusChangeEvent;
8 | import de.marcely.bedwars.api.event.arena.RoundStartEvent;
9 | import de.marcely.bedwars.api.game.specialitem.SpecialItem;
10 | import de.marcely.bedwars.api.game.specialitem.SpecialItemType;
11 | import de.marcely.bedwars.api.message.Message;
12 | import de.marcely.bedwars.tools.NMSHelper;
13 | import de.marcely.bedwars.tools.Pair;
14 | import java.text.DecimalFormat;
15 | import java.util.List;
16 | import java.util.concurrent.CopyOnWriteArrayList;
17 | import me.metallicgoat.tweaksaddon.MBedwarsTweaksPlugin;
18 | import me.metallicgoat.tweaksaddon.config.MainConfig;
19 | import me.metallicgoat.tweaksaddon.utils.Util;
20 | import org.bukkit.GameMode;
21 | import org.bukkit.entity.Player;
22 | import org.bukkit.event.EventHandler;
23 | import org.bukkit.event.EventPriority;
24 | import org.bukkit.event.Listener;
25 | import org.bukkit.inventory.ItemStack;
26 | import org.bukkit.scheduler.BukkitRunnable;
27 | import org.bukkit.scheduler.BukkitTask;
28 | import org.jetbrains.annotations.Nullable;
29 |
30 | public class TrackerDistance implements Listener {
31 |
32 | private static final DecimalFormat DECIMAL_FORMAT = new DecimalFormat("#.#");
33 |
34 | private final List tickingArenas = new CopyOnWriteArrayList<>();
35 | private BukkitTask task = null;
36 |
37 | @EventHandler
38 | public void onRoundStart(RoundStartEvent event) {
39 | if (!MainConfig.tracker_hotbar_message_enabled)
40 | return;
41 |
42 | tickingArenas.add(event.getArena());
43 |
44 | if (task == null)
45 | startTask();
46 |
47 | }
48 |
49 | // Stop checkin' when no ticking arenas
50 | @EventHandler(priority = EventPriority.MONITOR)
51 | public void onArenaStatusChange(ArenaStatusChangeEvent event) {
52 | if (event.getArena().getStatus() == ArenaStatus.RUNNING)
53 | return;
54 |
55 | tickingArenas.remove(event.getArena());
56 |
57 | if (tickingArenas.isEmpty() && task != null) {
58 | task.cancel();
59 | task = null;
60 | }
61 | }
62 |
63 | private void startTask() {
64 | if (task != null)
65 | task.cancel();
66 |
67 | task = new BukkitRunnable() {
68 | @Override
69 | public void run() {
70 | for (Arena arena : tickingArenas) {
71 |
72 | if (arena.getStatus() != ArenaStatus.RUNNING)
73 | continue;
74 |
75 | for (Player player : arena.getPlayers()) {
76 | final boolean holdingTracker = isTracker(player.getItemInHand()) || isTracker(Util.getItemInOffHand(player));
77 |
78 | if (!holdingTracker)
79 | continue;
80 |
81 | final Team playerTeam = arena.getPlayerTeam(player);
82 | final Pair nearestEnemy = getNearestEnemy(arena, player, playerTeam);
83 |
84 | if (nearestEnemy.getKey() == null) {
85 | // No enemies found message
86 | sendHotbarMessage(player, Message.build(MainConfig.tracker_hotbar_message_no_enemies));
87 | return;
88 | }
89 |
90 | final Team enemyTeam = arena.getPlayerTeam(nearestEnemy.getKey());
91 |
92 | if (enemyTeam == null) {
93 | throw new RuntimeException("Player Tracker Error: Enemy team is null");
94 | }
95 |
96 | // Send distance message
97 | sendHotbarMessage(player, Message.build(MainConfig.tracker_hotbar_message)
98 | .placeholder("distance", DECIMAL_FORMAT.format(nearestEnemy.getValue()))
99 | .placeholder("team-color", enemyTeam.getBungeeChatColor())
100 | .placeholder("team", enemyTeam.getDisplayName(player)));
101 | }
102 | }
103 | }
104 | }.runTaskTimer(MBedwarsTweaksPlugin.getInstance(), 20L, 20L);
105 | }
106 |
107 | private void sendHotbarMessage(Player player, Message message) {
108 | final String string = message.done(player);
109 |
110 | if (string.isEmpty())
111 | return;
112 |
113 | NMSHelper.get().showActionbar(player, string);
114 | }
115 |
116 | private Pair getNearestEnemy(Arena arena, Player player, Team playerTeam) {
117 | Player nearest = null;
118 | double nearestDistance = Double.MAX_VALUE;
119 |
120 | for (Player possibleEnemy : arena.getPlayers()) {
121 | if (playerTeam == arena.getPlayerTeam(possibleEnemy) || possibleEnemy.getGameMode() == GameMode.SPECTATOR)
122 | continue;
123 |
124 | final double distance = possibleEnemy.getLocation().distance(player.getLocation());
125 |
126 | if (distance < nearestDistance) {
127 | nearest = possibleEnemy;
128 | nearestDistance = distance;
129 | }
130 | }
131 |
132 | return new Pair<>(nearest, nearestDistance);
133 | }
134 |
135 | private boolean isTracker(@Nullable ItemStack itemStack) {
136 | if (itemStack == null)
137 | return false;
138 |
139 | final SpecialItem item = GameAPI.get().getSpecialItem(itemStack);
140 |
141 | return item != null && item.getType() == SpecialItemType.TRACKER;
142 | }
143 | }
144 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/utils/Util.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.utils;
2 |
3 | import de.marcely.bedwars.api.GameAPI;
4 | import de.marcely.bedwars.api.arena.Arena;
5 | import de.marcely.bedwars.api.arena.Team;
6 | import de.marcely.bedwars.api.arena.picker.ArenaPickerAPI;
7 | import de.marcely.bedwars.api.game.spawner.DropType;
8 | import de.marcely.bedwars.tools.Helper;
9 | import de.marcely.bedwars.tools.NMSHelper;
10 | import de.marcely.bedwars.tools.location.XYZYP;
11 | import java.lang.reflect.Method;
12 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierActionType;
13 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierHandler;
14 | import me.metallicgoat.tweaksaddon.api.unsafe.MBedwarsTweaksAPILayer;
15 | import me.metallicgoat.tweaksaddon.gentiers.handlers.BedDestroyHandler;
16 | import me.metallicgoat.tweaksaddon.gentiers.handlers.GameOverHandler;
17 | import me.metallicgoat.tweaksaddon.gentiers.handlers.SpawnerUpgradeHandler;
18 | import me.metallicgoat.tweaksaddon.gentiers.handlers.SuddenDeathHandler;
19 | import me.metallicgoat.tweaksaddon.impl.api.ImplMBedwarsTweaksAPILayer;
20 | import org.bukkit.Location;
21 | import org.bukkit.Material;
22 | import org.bukkit.World;
23 | import org.bukkit.entity.HumanEntity;
24 | import org.bukkit.inventory.ItemStack;
25 | import org.bukkit.inventory.PlayerInventory;
26 | import org.jetbrains.annotations.Nullable;
27 |
28 | import java.util.ArrayList;
29 | import java.util.Arrays;
30 | import java.util.Collection;
31 | import java.util.Collections;
32 | import java.util.HashMap;
33 | import java.util.List;
34 |
35 | public class Util {
36 |
37 | private static final HashMap handlersById = new HashMap<>();
38 |
39 | private static Method GET_ITEM_IN_OFF_HAND_METHOD = null;
40 |
41 | public static void init() {
42 | MBedwarsTweaksAPILayer.INSTANCE = new ImplMBedwarsTweaksAPILayer();
43 |
44 | registerDefaultGenTierHandlers();
45 |
46 | if (NMSHelper.get().getVersion() == 8)
47 | return;
48 |
49 | try {
50 | GET_ITEM_IN_OFF_HAND_METHOD = PlayerInventory.class.getDeclaredMethod("getItemInOffHand", null);
51 | } catch (Exception e) {
52 | e.printStackTrace();
53 | }
54 | }
55 |
56 | private static void registerDefaultGenTierHandlers() {
57 | registerGenTierHandler(new BedDestroyHandler());
58 | registerGenTierHandler(new GameOverHandler());
59 | registerGenTierHandler(new SpawnerUpgradeHandler());
60 | registerGenTierHandler(new SuddenDeathHandler());
61 | }
62 |
63 | public static void registerGenTierHandler(GenTierHandler handler) {
64 | if (handlersById.containsKey(handler.getId())) {
65 | throw new IllegalStateException("GenTierHandler already registered");
66 | }
67 |
68 | handlersById.put(handler.getId().toLowerCase(), handler);
69 | }
70 |
71 | public static void unregisterGenTierHandler(String id) {
72 | handlersById.remove(id);
73 | }
74 |
75 | public static GenTierHandler getGenTierHandlerById(String id) {
76 | return handlersById.get(id);
77 | }
78 |
79 | public static Collection getGenTierHandlers() {
80 | return handlersById.values();
81 | }
82 |
83 | public static @Nullable ItemStack getItemInOffHand(HumanEntity player) {
84 | if (GET_ITEM_IN_OFF_HAND_METHOD == null)
85 | return null;
86 |
87 | try {
88 | return (ItemStack) GET_ITEM_IN_OFF_HAND_METHOD.invoke(player.getInventory());
89 | } catch (Exception e) {
90 | e.printStackTrace();
91 | }
92 |
93 | return null;
94 | }
95 |
96 | public static Collection parseArenas(String arenaKey) {
97 | if (arenaKey.equalsIgnoreCase("ALL-ARENAS")) {
98 | return GameAPI.get().getArenas();
99 | }
100 |
101 | final Arena arenaByName = GameAPI.get().getArenaByName(arenaKey);
102 |
103 | if (arenaByName != null)
104 | return Collections.singleton(arenaByName);
105 |
106 | try {
107 | return ArenaPickerAPI.get().getArenasByCondition(arenaKey);
108 | } catch (Exception ignored) {
109 | return Collections.emptyList();
110 | }
111 | }
112 |
113 | public static @Nullable DropType getDropType(String id) {
114 | return GameAPI.get().getDropTypeById(id);
115 | }
116 |
117 | public static boolean isInteger(String s) {
118 | try {
119 | Integer.valueOf(s);
120 | return true;
121 | } catch (NumberFormatException e) {
122 | return false;
123 | }
124 | }
125 |
126 | public static List getAllTeamSpawns(Arena arena, World world, Team ignoreTeam) {
127 | final List targets = new ArrayList<>();
128 |
129 | for (Team currTeam : arena.getEnabledTeams()) {
130 | if (currTeam == ignoreTeam)
131 | continue;
132 |
133 | final XYZYP spawn = arena.getTeamSpawn(currTeam);
134 |
135 | if (spawn != null)
136 | targets.add(spawn.toLocation(world));
137 | }
138 |
139 | return targets;
140 | }
141 |
142 | public static List buildMaterialList(String... materials) {
143 | final List materialList = new ArrayList<>();
144 |
145 | for (String material : materials) {
146 | final Material mat = Helper.get().getMaterialByName(material);
147 |
148 | if (mat != null)
149 | materialList.add(mat);
150 | }
151 |
152 | return materialList;
153 | }
154 |
155 | public static List getLines(String string) {
156 | final String[] parts = string.split("\\\\n");
157 | return Arrays.asList(parts);
158 | }
159 | }
160 |
--------------------------------------------------------------------------------
/API/src/main/java/me/metallicgoat/tweaksaddon/api/GenTiersAPI.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.api;
2 |
3 | import de.marcely.bedwars.api.arena.Arena;
4 | import de.marcely.bedwars.api.arena.Team;
5 | import de.marcely.bedwars.api.game.upgrade.UpgradeTriggerHandler;
6 | import de.marcely.bedwars.tools.Validate;
7 | import java.util.Collections;
8 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierHandler;
9 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierLevel;
10 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierState;
11 | import me.metallicgoat.tweaksaddon.api.gentiers.SuddenDeathDragon;
12 | import me.metallicgoat.tweaksaddon.api.unsafe.MBedwarsTweaksAPILayer;
13 | import org.jetbrains.annotations.Nullable;
14 |
15 | import java.util.Collection;
16 | import java.util.List;
17 |
18 | /**
19 | * Represents the API to interact with the Gen Tiers system of MBedwars Tweaks
20 | */
21 | public class GenTiersAPI {
22 |
23 | /**
24 | * Get the dragons for a specific team in an arena.
25 | *
26 | * @param arena The arena which we are truing to get the dragons
27 | * @param team The team which the dragon belongs to
28 | * @return A list of actively running SuddenDeathDragons
29 | */
30 | public static List getDragons(Arena arena, Team team) {
31 | Validate.notNull(arena, "arena");
32 | Validate.notNull(team, "team");
33 |
34 | return MBedwarsTweaksAPILayer.INSTANCE.getDragons(arena, team);
35 | }
36 |
37 | /**
38 | * Get the dragons for arena.
39 | *
40 | * @param arena The arena which we are truing to get the dragons
41 | * @return A list of actively running SuddenDeathDragons
42 | */
43 | public static List getDragons(Arena arena) {
44 | Validate.notNull(arena, "arena");
45 |
46 | return MBedwarsTweaksAPILayer.INSTANCE.getDragons(arena, null);
47 | }
48 |
49 | /**
50 | * Get all existing dragons.
51 | *
52 | * @return A list of actively running SuddenDeathDragons
53 | */
54 | public static List getDragons() {
55 | return MBedwarsTweaksAPILayer.INSTANCE.getDragons(null, null);
56 | }
57 |
58 | /**
59 | * Get the GenTierState of an arena
60 | * Will return null if the gen tier system is not running in the specified arena
61 | *
62 | * @param arena the arena where we are grabbing the GenTierState from
63 | * @return The GenTierState of the corresponding arena
64 | */
65 | @Nullable
66 | public static GenTierState getState(Arena arena) {
67 | Validate.notNull(arena, "arena");
68 |
69 | return MBedwarsTweaksAPILayer.INSTANCE.getGenTierState(arena);
70 | }
71 |
72 | /**
73 | * Get all configured Gen Tiers
74 | *
75 | * @return An unmodifiable collection of all configured Gen Tiers
76 | */
77 | public static Collection getTiers() {
78 | return Collections.unmodifiableCollection(MBedwarsTweaksAPILayer.INSTANCE.getGenTierLevels());
79 | }
80 |
81 | /**
82 | * Get a specific Gen Tier by its level
83 | *
84 | * @param level The level of the Gen Tier you are trying to get
85 | * @return The Gen Tier of the corresponding level
86 | */
87 | @Nullable
88 | public static GenTierLevel getTier(int level) {
89 | return MBedwarsTweaksAPILayer.INSTANCE.getGenTierLevel(level);
90 | }
91 |
92 | /**
93 | * Get the first Gen Tier (level 1)
94 | *
95 | * @return The Gen Tier of level 1
96 | */
97 | @Nullable
98 | public static GenTierLevel getFirstTier() {
99 | return MBedwarsTweaksAPILayer.INSTANCE.getGenTierLevel(1);
100 | }
101 |
102 | /**
103 | * Register a custom GenTierHandler! You will need to implement the GenTierHandler
104 | *
105 | * @param handler The GenTier you are registering
106 | */
107 | public static void registerHandler(GenTierHandler handler) {
108 | Validate.notNull(handler, "handler");
109 |
110 | MBedwarsTweaksAPILayer.INSTANCE.registerGenTierHandler(handler);
111 | }
112 |
113 | /**
114 | * Unregisters a Gen Tier Handler. Using this you could replace internal handlers
115 | *
116 | * @param id The id of the handler
117 | */
118 | public static void unregisterHandler(String id) {
119 | Validate.notNull(id, "id");
120 |
121 | MBedwarsTweaksAPILayer.INSTANCE.unregisterGenTierHandler(id);
122 | }
123 |
124 | /**
125 | * Gets a GenTierHandler by its id
126 | *
127 | * @param id The id of the handler
128 | */
129 | @Nullable
130 | public static GenTierHandler getHandlerById(String id) {
131 | Validate.notNull(id, "id");
132 |
133 | return MBedwarsTweaksAPILayer.INSTANCE.getGenTierHandlerById(id);
134 | }
135 |
136 | /**
137 | * Get all registered GenTierHandlers
138 | *
139 | * @return all registered GenTierHandlers
140 | */
141 | public static Collection getHandlers() {
142 | return MBedwarsTweaksAPILayer.INSTANCE.getGenTierHandlers();
143 | }
144 |
145 | /**
146 | * Get the trigger handler used for the sudden death team upgrade.
147 | *
148 | * @return The singletone UpgradeTriggerHandler instance for the sudden death upgrade
149 | */
150 | public static UpgradeTriggerHandler getSuddenDeathUpgrade() {
151 | return MBedwarsTweaksAPILayer.INSTANCE.getSuddenDeathUpgrade();
152 | }
153 |
154 | /**
155 | * Reloads the gen-tiers config and applies any changes made to it
156 | *
157 | * Note: This will NOT update any arenas that are currently running the gen tier system,
158 | * and as a result might cause weird states for active arenas.
159 | * Runs IO on the same thread that it was called on.
160 | *
161 | */
162 | public static void reloadConfig() {
163 | MBedwarsTweaksAPILayer.INSTANCE.reloadGenTierConfig();
164 | }
165 | }
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/config/ConfigLoader.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.config;
2 |
3 | import de.marcely.bedwars.api.configuration.ConfigurationAPI;
4 | import de.marcely.bedwars.api.event.ConfigsLoadEvent;
5 | import de.marcely.bedwars.tools.Helper;
6 | import java.time.Duration;
7 | import me.metallicgoat.tweaksaddon.MBedwarsTweaksPlugin;
8 | import me.metallicgoat.tweaksaddon.api.GenTiersAPI;
9 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierHandler;
10 | import me.metallicgoat.tweaksaddon.config.ConfigManager.FileType;
11 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierLevel;
12 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierActionType;
13 | import me.metallicgoat.tweaksaddon.utils.Console;
14 | import me.metallicgoat.tweaksaddon.utils.Util;
15 | import org.bukkit.Material;
16 | import org.bukkit.event.EventHandler;
17 | import org.bukkit.event.Listener;
18 |
19 | import java.util.ArrayList;
20 | import java.util.Arrays;
21 | import java.util.HashMap;
22 |
23 | public class ConfigLoader implements Listener {
24 |
25 | @EventHandler
26 | public void onConfigLoad(ConfigsLoadEvent event) {
27 | if (!event.isStartup()) {
28 | MBedwarsTweaksPlugin.getInstance().loadTweaks(false); // Reload tweaks
29 | }
30 | }
31 |
32 | public static void loadTweaksConfigs(MBedwarsTweaksPlugin plugin) {
33 | final long start = System.currentTimeMillis();
34 |
35 | final boolean defaultDropTypesExist = (
36 | Util.getDropType("iron") != null
37 | && Util.getDropType("gold") != null
38 | && Util.getDropType("diamond") != null
39 | && Util.getDropType("emerald") != null
40 | );
41 |
42 | // Replace with these values if we know defaults are still setup
43 | if (defaultDropTypesExist) {
44 | MainConfig.gen_tiers_start_spawners = new ArrayList<>(Arrays.asList(
45 | Util.getDropType("emerald"),
46 | Util.getDropType("diamond")
47 | ));
48 |
49 | MainConfig.disable_empty_generators_spawners = new ArrayList<>(Arrays.asList(
50 | Util.getDropType("iron"),
51 | Util.getDropType("gold")
52 | ));
53 | }
54 |
55 | GenTiersConfig.gen_tier_levels = getDefaultGenTiers();
56 |
57 | ConfigManager.load(plugin, MainConfig.class, FileType.MAIN);
58 | ConfigManager.load(plugin, SwordsToolsConfig.class, FileType.SWORDS_TOOLS);
59 | GenTiersConfig.load(); // We load gen tiers a special way
60 |
61 | overrideMBedwarsConfigs();
62 |
63 | final long end = System.currentTimeMillis();
64 |
65 | Console.printInfo("Configs loaded in " + (end - start) + "ms.");
66 | }
67 |
68 | public static HashMap getDefaultGenTiers() {
69 | final GenTierHandler genUpgradeHandler = GenTiersAPI.getHandlerById(GenTierActionType.GEN_UPGRADE.getDefaultHandlerId());
70 |
71 | return new HashMap() {{
72 | put(1, new GenTierLevel(
73 | 1,
74 | "Diamond II", "&eTier &cII",
75 | "diamond",
76 | genUpgradeHandler, Duration.ofMinutes(6), 30D, null,
77 | "&bDiamond Generators &ehave been upgraded to Tier &4II",
78 | null
79 | ));
80 | put(2, new GenTierLevel(
81 | 2,
82 | "Emerald II", "&eTier &cII",
83 | "emerald",
84 | genUpgradeHandler, Duration.ofMinutes(6), 40D, null,
85 | "&aEmerald Generators &ehave been upgraded to Tier &4II",
86 | null
87 | ));
88 | put(3, new GenTierLevel(
89 | 3,
90 | "Diamond III", "&eTier &cIII",
91 | "diamond",
92 | genUpgradeHandler, Duration.ofMinutes(6), 20D, null,
93 | "&bDiamond Generators &ehave been upgraded to Tier &4III",
94 | null
95 | ));
96 | put(4, new GenTierLevel(
97 | 4,
98 | "Emerald III", "&eTier &cIII",
99 | "emerald",
100 | genUpgradeHandler, Duration.ofMinutes(6), 30D, null,
101 | "&aEmerald Generators &ehave been upgraded to Tier &4III",
102 | null
103 | ));
104 | put(5, new GenTierLevel(5, "Bed Destroy", GenTiersAPI.getHandlerById(GenTierActionType.BED_DESTROY.getDefaultHandlerId()), Duration.ofMinutes(5), null, null));
105 | put(6, new GenTierLevel(6, "Sudden Death", GenTiersAPI.getHandlerById(GenTierActionType.SUDDEN_DEATH.getDefaultHandlerId()), Duration.ofMinutes(10), null, null));
106 | put(7, new GenTierLevel(7, "Game Over", GenTiersAPI.getHandlerById(GenTierActionType.GAME_OVER.getDefaultHandlerId()), Duration.ofMinutes(10), null, null));
107 | }};
108 | }
109 |
110 | private static void overrideMBedwarsConfigs() {
111 | // Configure MBedwars to work like our old feature did
112 | if (MainConfig.personal_ender_chests_enabled) {
113 | try {
114 | final boolean teamchestEnabled = (boolean) ConfigurationAPI.get().getValue("teamchest-enabled");
115 | final Material teamchestBlock = (Material) ConfigurationAPI.get().getValue("teamchest-block");
116 |
117 | if (teamchestEnabled && teamchestBlock == Helper.get().getMaterialByName("ENDER_CHEST")) {
118 | ConfigurationAPI.get().setValue("teamchest-enabled", false);
119 | Console.printWarn(
120 | "WARNING: You have \"personal-ender-chests-enabled\" enabled. This setting will be removed in the future, as it is already possible in MBedwars.",
121 | "Open your MBedwars config.yml, and either set \"teamchest-enabled\" to false, or set \"teamchest-block\" to CHEST.",
122 | "Currently, we are using the MBedwars configuration api to override these values for you, but we may not do this in the future."
123 | );
124 | }
125 |
126 | } catch (IllegalArgumentException e) {
127 | Console.printWarn("Failed to apply personal ender chests. Try updating MBedwars, or disabling \"personal-ender-chests-enabled\"");
128 | }
129 | }
130 |
131 | if (MainConfig.tracker_hotbar_message_enabled) {
132 | try {
133 | final boolean mbedwarsActionbarEnabled = (boolean) ConfigurationAPI.get().getValue("actionbar-enabled");
134 |
135 | if (mbedwarsActionbarEnabled) {
136 | ConfigurationAPI.get().setValue("actionbar-enabled", false);
137 | Console.printWarn(
138 | "NOTE: You have \"tracker-hotbar-message-enabled\" enabled. This setting will interfere with the MBedwars's \"actionbar-enabled\" config.",
139 | "We have automatically disabled the MBedwars actionbar, however you may want to disable it yourself in the MBedwars config.yml."
140 | );
141 | }
142 |
143 | } catch (IllegalArgumentException e) {
144 | Console.printWarn("Failed to apply tracker hotbar message. Try updating MBedwars, or disabling \"tracker-hotbar-message-enabled\"");
145 | }
146 | }
147 | }
148 | }
149 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/MBedwarsTweaksAddon.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon;
2 |
3 | import de.marcely.bedwars.api.BedwarsAPI;
4 | import de.marcely.bedwars.api.BedwarsAddon;
5 | import de.marcely.bedwars.api.GameAPI;
6 | import de.marcely.bedwars.api.command.CommandHandler;
7 | import de.marcely.bedwars.api.command.CommandsCollection;
8 | import de.marcely.bedwars.api.command.SubCommand;
9 | import de.marcely.bedwars.api.message.DefaultMessageMappings;
10 | import de.marcely.bedwars.api.message.MessageAPI;
11 | import me.metallicgoat.tweaksaddon.commands.SpecialItemCommand;
12 | import me.metallicgoat.tweaksaddon.config.ConfigLoader;
13 | import me.metallicgoat.tweaksaddon.gentiers.GenTiers;
14 | import me.metallicgoat.tweaksaddon.gentiers.dragons.SuddenDeathUpgrade;
15 | import me.metallicgoat.tweaksaddon.integration.DependencyLoader;
16 | import me.metallicgoat.tweaksaddon.tweaks.advancedswords.*;
17 | import me.metallicgoat.tweaksaddon.tweaks.cosmetic.*;
18 | import me.metallicgoat.tweaksaddon.tweaks.explosives.*;
19 | import me.metallicgoat.tweaksaddon.tweaks.messages.*;
20 | import me.metallicgoat.tweaksaddon.tweaks.misc.*;
21 | import me.metallicgoat.tweaksaddon.tweaks.playerlimitbypass.PlayerLimitBypass;
22 | import me.metallicgoat.tweaksaddon.tweaks.playerlimitbypass.PlayerLimitBypassPaper;
23 | import me.metallicgoat.tweaksaddon.tweaks.spawners.*;
24 | import me.metallicgoat.tweaksaddon.tweaks.spectialitems.*;
25 | import me.metallicgoat.tweaksaddon.utils.Console;
26 | import org.bukkit.plugin.PluginManager;
27 |
28 | public class MBedwarsTweaksAddon extends BedwarsAddon {
29 |
30 | private final MBedwarsTweaksPlugin plugin;
31 |
32 | public MBedwarsTweaksAddon(MBedwarsTweaksPlugin plugin) {
33 | super(plugin);
34 |
35 | this.plugin = plugin;
36 | }
37 |
38 | public void registerMessageMappings() {
39 | try {
40 | MessageAPI.get().registerDefaultMappings(
41 | DefaultMessageMappings.loadInternalYAML(this.plugin, this.plugin.getResource("messages.yml"))
42 | );
43 | } catch (Exception e) {
44 | e.printStackTrace();
45 | }
46 | }
47 |
48 | public void registerEvents() {
49 | final MBedwarsTweaksPlugin plugin = MBedwarsTweaksPlugin.getInstance();
50 | final PluginManager manager = plugin.getServer().getPluginManager();
51 |
52 | // CONTRIBUTORS: PLEASE READ
53 | // NOTE: Please keep the following categories and classes in alphabetical order
54 | // NOTE: If you are adding support for your own plugin, please add your class to the hooks folder
55 |
56 | // Advanced Swords
57 | manager.registerEvents(new AlwaysSword(), plugin);
58 | manager.registerEvents(new AntiChest(), plugin);
59 | manager.registerEvents(new AntiDrop(), plugin);
60 | manager.registerEvents(new DegradingBuyGroups(), plugin);
61 | manager.registerEvents(new ReplaceSwordOnBuy(), plugin);
62 | manager.registerEvents(new ReplaceToolOnBuy(), plugin);
63 | manager.registerEvents(new ToolSwordHelper(), plugin);
64 |
65 | // Cosmetic
66 | manager.registerEvents(new FriendlyVillagers(), plugin);
67 | manager.registerEvents(new HealPoolParticles(), plugin);
68 | manager.registerEvents(new InvisFootstepsParticles(), plugin);
69 | manager.registerEvents(new PlaceholderUpdating(), plugin);
70 | manager.registerEvents(new SpongeParticles(), plugin);
71 |
72 | // Explosives
73 | manager.registerEvents(new DisableFireballOutsideArena(), plugin);
74 | manager.registerEvents(new ExplosiveFallDamageMultiplier(), plugin);
75 | manager.registerEvents(new FireballBlockBreakWhitelist(), plugin);
76 | manager.registerEvents(new FireballThrowEffects(), plugin);
77 | manager.registerEvents(new FireballUseCoolDown(), plugin);
78 | manager.registerEvents(new TNTIgniteCountdown(), plugin);
79 |
80 | // Messages
81 | manager.registerEvents(new BuyMessage(), plugin);
82 | manager.registerEvents(new CustomBedBreakMessage(), plugin);
83 | manager.registerEvents(new FinalKillSuffix(), plugin);
84 | manager.registerEvents(new TeamEliminate(), plugin);
85 | manager.registerEvents(new TopKillerMessage(), plugin);
86 |
87 | // Misc
88 | manager.registerEvents(new BlockArenaStats(), plugin);
89 | manager.registerEvents(new EmptyContainers(), plugin);
90 | manager.registerEvents(new HeightCap(), plugin);
91 | manager.registerEvents(new LockTeamChest(), plugin);
92 | manager.registerEvents(new PearlSoundBroadcast(), plugin);
93 | manager.registerEvents(new PermanentEffects(), plugin);
94 | manager.registerEvents(new PlaceBlocksOnBed(), plugin);
95 | manager.registerEvents(new RemoveInvisOnDamage(), plugin);
96 | manager.registerEvents(new WorldBorderResize(), plugin);
97 | manager.registerEvents(new LootDropAtEliminatedTeamBase(), plugin);
98 | //manager.registerEvents(new TieBreaker(), plugin);
99 |
100 | // Spawners
101 | manager.registerEvents(new AFKSpawners(), plugin);
102 | manager.registerEvents(new DisableEmptyGenerators(), plugin);
103 | manager.registerEvents(new SpawnerUpgrade(), plugin);
104 |
105 | // Special Items
106 | manager.registerEvents(new SpecialItemCooldown(), plugin);
107 | manager.registerEvents(new TrackerDistance(), plugin);
108 |
109 | // Gen Tiers
110 | manager.registerEvents(new GenTiers(), plugin);
111 |
112 | // Server Events
113 | manager.registerEvents(new ConfigLoader(), plugin);
114 | manager.registerEvents(new DependencyLoader(), plugin);
115 |
116 | // Version Specific Events
117 | try {
118 | Class.forName("io.papermc.paper.event.player.PlayerServerFullCheckEvent");
119 | manager.registerEvents(new PlayerLimitBypass(), plugin);
120 | } catch (ClassNotFoundException ignored) {
121 | manager.registerEvents(new PlayerLimitBypassPaper(), plugin);
122 | }
123 | }
124 |
125 | public void registerCommands() {
126 | final CommandsCollection commands = BedwarsAPI.getRootCommandsCollection();
127 |
128 | // Commands in tools commands collection
129 | {
130 | final SubCommand tools = commands.getCommand("tools");
131 |
132 | if (tools instanceof CommandsCollection) {
133 | final CommandsCollection toolsCollection = (CommandsCollection) tools;
134 |
135 | registerCommand("showspecialitems", toolsCollection, new SpecialItemCommand());
136 |
137 | } else {
138 | Console.printWarn("Failed to register command showspecialitems in \"/bw tools\" commands collection. ");
139 | }
140 | }
141 | }
142 |
143 | public void registerCommand(String name, CommandsCollection collection, CommandHandler handler) {
144 | final SubCommand command = collection.addCommand(name);
145 |
146 | if (command == null) {
147 | Console.printWarn("Failed to register command " + name + ". Possible interference with another plugin?");
148 | return;
149 | }
150 |
151 | command.setHandler(handler);
152 | }
153 |
154 |
155 | public void registerUpgrades() {
156 | GameAPI.get().registerUpgradeTriggerHandler(SuddenDeathUpgrade.INSTANCE);
157 | }
158 |
159 | @Override
160 | public String getName() {
161 | return plugin.getName();
162 | }
163 | }
164 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/config/GenTiersConfig.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.config;
2 |
3 | import de.marcely.bedwars.tools.Helper;
4 | import de.marcely.bedwars.tools.YamlConfigurationDescriptor;
5 | import java.io.File;
6 | import java.time.Duration;
7 | import java.time.temporal.ChronoUnit;
8 | import java.util.HashMap;
9 | import java.util.Map;
10 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierHandler;
11 | import me.metallicgoat.tweaksaddon.utils.Console;
12 | import me.metallicgoat.tweaksaddon.MBedwarsTweaksPlugin;
13 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierLevel;
14 | import me.metallicgoat.tweaksaddon.api.gentiers.GenTierActionType;
15 | import me.metallicgoat.tweaksaddon.utils.Util;
16 | import org.bukkit.Sound;
17 | import org.bukkit.configuration.ConfigurationSection;
18 | import org.bukkit.configuration.file.FileConfiguration;
19 | import org.bukkit.configuration.file.YamlConfiguration;
20 |
21 | public class GenTiersConfig {
22 |
23 | public static Map gen_tier_levels = new HashMap<>();
24 |
25 | public static void load() {
26 | synchronized (ConfigLoader.class) {
27 | try {
28 | loadUnchecked();
29 | } catch (Exception e) {
30 | e.printStackTrace();
31 | }
32 | }
33 | }
34 |
35 | private static void loadUnchecked() throws Exception {
36 | final String pluginVer = MBedwarsTweaksPlugin.getInstance().getDescription().getVersion();
37 | final File file = new File(MBedwarsTweaksPlugin.getAddon().getDataFolder(), "gen-tiers.yml");
38 |
39 | if (!file.exists()) {
40 | save(file, pluginVer);
41 | return;
42 | }
43 |
44 | // load it
45 | final FileConfiguration config = new YamlConfiguration();
46 |
47 | try {
48 | config.load(file);
49 | } catch (Exception e) {
50 | e.printStackTrace();
51 | }
52 |
53 | // read it
54 | final String configVer = config.getString("version");
55 | final ConfigurationSection tiersSection = config.getConfigurationSection("Gen-Tiers");
56 |
57 | if (tiersSection != null) {
58 | gen_tier_levels.clear();
59 |
60 | int i = 1;
61 | for (String levelNumString : tiersSection.getKeys(false)) {
62 | final int levelNum = i++;
63 |
64 | final ConfigurationSection section = tiersSection.getConfigurationSection(levelNumString);
65 |
66 | final String tierName = section.getString("Tier-Name");
67 | String genTierHandlerId = section.getString("Handler-Id");
68 | final String typeString = section.getString("Drop-Type");
69 | final double speed = section.getDouble("Drop-Speed");
70 | final int limit = section.getInt("Max-Nearby-Items", -1);
71 | final double time = section.getDouble("Time");
72 | String message = section.getString("Message");
73 | final String soundString = section.getString("Earn-Sound");
74 | String holoName = section.getString("Holo-Usage");
75 |
76 | message = message == null || message.isEmpty() ? null : message;
77 |
78 | {
79 | // OLD VALUES
80 | if (holoName == null)
81 | holoName = section.getString("Tier-Level");
82 |
83 | if (genTierHandlerId == null)
84 | genTierHandlerId = section.getString("Action");
85 | }
86 |
87 | // TODO Validate other values not null
88 | if (genTierHandlerId == null) {
89 | Console.printConfigWarn("Failed to load tier: [" + tierName + "]. Handler-Id is null", "gen-tiers");
90 | continue;
91 | }
92 |
93 | final GenTierHandler handler = Util.getGenTierHandlerById(genTierHandlerId.toLowerCase());
94 |
95 | if (handler == null) {
96 | Console.printConfigWarn("Failed to load tier: [" + tierName + "]. Handler-Id '" + genTierHandlerId + "' is invalid. Has it been registered?", "gen-tiers");
97 | continue;
98 | }
99 |
100 | Sound earnSound = null;
101 |
102 | if (soundString != null)
103 | earnSound = Helper.get().getSoundByName(soundString);
104 |
105 | if (handler.getActionType() == GenTierActionType.GEN_UPGRADE) {
106 |
107 | final GenTierLevel genTierLevel = new GenTierLevel(
108 | levelNum,
109 | tierName,
110 | holoName,
111 | typeString,
112 | handler,
113 | Duration.ofSeconds((long) (time * 60D)),
114 | speed,
115 | limit > 0 ? limit : null,
116 | message,
117 | earnSound
118 | );
119 |
120 | gen_tier_levels.put(levelNum, genTierLevel);
121 |
122 | } else {
123 | final GenTierLevel genTierLevel = new GenTierLevel(
124 | levelNum,
125 | tierName,
126 | handler,
127 | Duration.ofSeconds((long) (time * 60D)),
128 | message,
129 | earnSound
130 | );
131 |
132 | gen_tier_levels.put(levelNum, genTierLevel);
133 | }
134 | }
135 | }
136 |
137 | // auto update file if newer version
138 | if (!pluginVer.equals(configVer)) {
139 | updateOldConfigs(config);
140 | save(file, pluginVer);
141 | }
142 | }
143 |
144 | private static void save(File file, String pluginVer) throws Exception {
145 | final YamlConfigurationDescriptor config = new YamlConfigurationDescriptor();
146 |
147 | config.addComment("Used for Auto Updating. Do not Change! (Unless you know what you are doing)");
148 | config.set("version", pluginVer);
149 |
150 | config.addEmptyLine();
151 | config.addComment("MAKE SURE Gen-Tiers are enabled in the config.yml!");
152 | config.addEmptyLine();
153 |
154 | config.addComment("PAPI-Usage (The value used in our PAPI Placeholders during this tier)");
155 | config.addComment("Holo-Usage (The values used in holos during this tier)");
156 | config.addComment("Action (gen-upgrade, bed-destroy, sudden-death, game-over)");
157 | config.addComment("Time (time in minutes until action - NOTE time starts after the last action)");
158 | config.addComment("Message (chat message sent on trigger)");
159 | config.addComment("Earn-Sound (sound played on trigger) (You have to add this config if you want it)");
160 | config.addEmptyLine();
161 | config.addComment("--- Spawner Only --- ");
162 | config.addComment("Type (Type of spawner that will be updated)");
163 | config.addComment("Speed (How often an item drops (in seconds))");
164 | config.addComment("Max-Nearby-Items (how many items the spawner will produce before it goes on hold)");
165 |
166 | config.addEmptyLine();
167 |
168 | int i = 1;
169 | for (Map.Entry entry : gen_tier_levels.entrySet()) {
170 |
171 | if (entry.getKey() == null || entry.getValue() == null)
172 | continue;
173 |
174 | final GenTierLevel level = entry.getValue();
175 | final String configKey = "Gen-Tiers." + (i++) + ".";
176 |
177 | config.set(configKey + "Handler-Id", level.getHandler().getId());
178 | config.set(configKey + "Time", level.getTime().get(ChronoUnit.SECONDS)/60D);
179 | config.set(configKey + "Tier-Name", level.getTierName());
180 |
181 | if (level.getHandler().getActionType() == GenTierActionType.GEN_UPGRADE) {
182 | config.set(configKey + "Holo-Usage", level.getHoloName());
183 | config.set(configKey + "Drop-Type", level.getTypeId());
184 | config.set(configKey + "Drop-Speed", level.getSpeed());
185 |
186 | if (level.getLimit() != null)
187 | config.set(configKey + "Max-Nearby-Items", level.getLimit());
188 | }
189 |
190 | if (level.getEarnMessage() != null)
191 | config.set(configKey + "Message", level.getEarnMessage());
192 |
193 | if (level.getEarnSound() != null)
194 | config.set(configKey + "Earn-Sound", level.getEarnSound().name());
195 | }
196 |
197 | config.save(file);
198 | }
199 |
200 | private static void updateOldConfigs(FileConfiguration config) {
201 | // No updates yet :)
202 | }
203 | }
204 |
--------------------------------------------------------------------------------
/MBedwarsTweaks/src/main/java/me/metallicgoat/tweaksaddon/tweaks/advancedswords/ToolSwordHelper.java:
--------------------------------------------------------------------------------
1 | package me.metallicgoat.tweaksaddon.tweaks.advancedswords;
2 |
3 | import de.marcely.bedwars.api.GameAPI;
4 | import de.marcely.bedwars.api.arena.Arena;
5 | import de.marcely.bedwars.api.arena.ArenaStatus;
6 | import de.marcely.bedwars.api.arena.Team;
7 | import de.marcely.bedwars.api.event.arena.ArenaDeleteEvent;
8 | import de.marcely.bedwars.api.event.arena.ArenaStatusChangeEvent;
9 | import de.marcely.bedwars.api.event.arena.RoundStartEvent;
10 | import de.marcely.bedwars.api.event.player.PlayerBuyInShopEvent;
11 | import de.marcely.bedwars.api.game.shop.BuyGroup;
12 | import de.marcely.bedwars.api.game.shop.ShopItem;
13 | import de.marcely.bedwars.api.game.shop.product.ItemShopProduct;
14 | import de.marcely.bedwars.api.game.shop.product.ShopProduct;
15 | import de.marcely.bedwars.tools.Helper;
16 | import java.util.IdentityHashMap;
17 | import java.util.Map;
18 | import me.metallicgoat.hotbarmanageraddon.HotbarManagerTools;
19 | import me.metallicgoat.tweaksaddon.integration.DependType;
20 | import me.metallicgoat.tweaksaddon.MBedwarsTweaksPlugin;
21 | import me.metallicgoat.tweaksaddon.config.SwordsToolsConfig;
22 | import org.bukkit.Bukkit;
23 | import org.bukkit.ChatColor;
24 | import org.bukkit.Material;
25 | import org.bukkit.entity.Player;
26 | import org.bukkit.event.EventHandler;
27 | import org.bukkit.event.EventPriority;
28 | import org.bukkit.event.Listener;
29 | import org.bukkit.inventory.Inventory;
30 | import org.bukkit.inventory.ItemStack;
31 | import org.bukkit.inventory.meta.ItemMeta;
32 |
33 | public class ToolSwordHelper implements Listener {
34 |
35 | private static final Map buyGroupTrackerMap = new IdentityHashMap<>();
36 | public static Material WOOD_SWORD;
37 |
38 | public static void load() {
39 | // Get wooden sword given on spawn
40 | {
41 | Material sword = Helper.get().getMaterialByName("WOODEN_SWORD");
42 |
43 | if (sword == null)
44 | sword = Material.AIR;
45 |
46 | WOOD_SWORD = sword;
47 | }
48 | }
49 |
50 | @EventHandler
51 | public static void onRoundStart(RoundStartEvent event) {
52 | final Arena arena = event.getArena();
53 |
54 | buyGroupTrackerMap.put(arena, new BuyGroupTracker());
55 | }
56 |
57 | @EventHandler
58 | public void onShopBuy(PlayerBuyInShopEvent event) {
59 | final BuyGroup group = event.getItem().getBuyGroup();
60 |
61 | if (group == null || !event.getProblems().isEmpty())
62 | return;
63 |
64 | final BuyGroupTracker tracker = buyGroupTrackerMap.get(event.getArena());
65 |
66 | if(tracker != null)
67 | tracker.upgradeLevel(group, event.getItem().getBuyGroupLevel(), event.getPlayer());
68 | }
69 |
70 | @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
71 | public void onArenaStatusChangeEvent(ArenaStatusChangeEvent event) {
72 | if (event.getOldStatus() == ArenaStatus.RUNNING)
73 | removeArena(event.getArena());
74 | }
75 |
76 | @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
77 | public void onArenaDeleteEvent(ArenaDeleteEvent event) {
78 | removeArena(event.getArena());
79 | }
80 |
81 | private void removeArena(Arena arena) {
82 | buyGroupTrackerMap.remove(arena);
83 | }
84 |
85 | public static BuyGroupTracker getBuyGroupTracker(Arena arena) {
86 | if(arena == null || !buyGroupTrackerMap.containsKey(arena))
87 | return new BuyGroupTracker();
88 |
89 | return buyGroupTrackerMap.get(arena);
90 | }
91 |
92 | public static ItemStack getDefaultWoodSword(Player player, Arena arena) {
93 | if (player == null || arena == null)
94 | return new ItemStack(WOOD_SWORD);
95 |
96 | final Team team = arena.getPlayerTeam(player);
97 | if (team == null)
98 | return new ItemStack(WOOD_SWORD);
99 |
100 | for (ItemStack is : arena.getItemsGivenOnSpawn(player, team, true, true)) {
101 | if (is.getType() == WOOD_SWORD)
102 | return is.clone();
103 | }
104 |
105 | return new ItemStack(WOOD_SWORD);
106 | }
107 |
108 | public static boolean isSword(Material material) {
109 | return material.name().contains("SWORD");
110 | }
111 |
112 | public static boolean isTool(Material material) {
113 | return material.name().contains("AXE");
114 | }
115 |
116 | public static boolean isAxe(Material material) {
117 | return isTool(material) && !material.name().contains("_AXE");
118 | }
119 |
120 | public static boolean isPickaxe(Material material) {
121 | return material.name().contains("_PICKAXE");
122 | }
123 |
124 | public static int getSwordToolLevel(Material tool) {
125 |
126 | final String toolName = tool.name();
127 |
128 | if (toolName.contains("WOOD")) {
129 | return 1;
130 | } else if (toolName.contains("STONE")) {
131 | return 2;
132 | } else if (toolName.contains("IRON")) {
133 | return 3;
134 | } else if (toolName.contains("GOLD")) {
135 | return 4;
136 | } else if (toolName.contains("DIAMOND")) {
137 | return 5;
138 | } else if (toolName.contains("NETHERITE")) {
139 | return 6;
140 | } else {
141 | return 0;
142 | }
143 | }
144 |
145 | public static Material getToolInShopProduct(ShopItem shopItem) {
146 | for (ShopProduct rawProduct : shopItem.getProducts()) {
147 | if (!(rawProduct instanceof ItemShopProduct))
148 | continue;
149 |
150 | final ItemStack[] is = ((ItemShopProduct) rawProduct).getItemStacks();
151 | for (ItemStack item : is) {
152 | if (!isTool(item.getType()) || !isNotToIgnore(ChatColor.stripColor(shopItem.getDisplayName())))
153 | continue;
154 |
155 | return item.getType();
156 | }
157 | }
158 | return Material.AIR;
159 | }
160 |
161 | // Some items may look like a sword, but not be one. Example: Special Items
162 | public static boolean isNotToIgnore(ItemStack itemStack) {
163 | final ItemMeta meta = itemStack.getItemMeta();
164 | boolean isNotToIgnore = true;
165 | if (meta != null) {
166 | for (String s : SwordsToolsConfig.tools_swords_do_not_effect) {
167 | if (s.equals(ChatColor.stripColor(meta.getDisplayName())) && !s.equals("")) {
168 | isNotToIgnore = false;
169 | }
170 | }
171 | }
172 | return isNotToIgnore;
173 | }
174 |
175 | public static boolean isNotToIgnore(String name) {
176 | boolean isNotToIgnore = true;
177 | for (String s : SwordsToolsConfig.tools_swords_do_not_effect) {
178 | final String formatted = ChatColor.translateAlternateColorCodes('&', s);
179 | if (formatted.equals(name) && !s.equals("")) {
180 | isNotToIgnore = false;
181 | }
182 | }
183 | return isNotToIgnore;
184 | }
185 |
186 | // Checks how many swords a player has
187 | public static int getSwordsAmount(Player player) {
188 | int count = 0;
189 | for (ItemStack item : player.getInventory().getContents()) {
190 | if (item != null && isSword(item.getType())
191 | && ToolSwordHelper.isNotToIgnore(item)) {
192 | count++;
193 | }
194 | }
195 | return count;
196 | }
197 |
198 | // returns true if a player has a sword that is better than wood
199 | public static boolean hasBetterSword(Player player) {
200 | final Inventory pi = player.getInventory();
201 | for (ItemStack itemStack : pi.getContents()) {
202 | if (itemStack != null
203 | && isSword(itemStack.getType())
204 | && isNotToIgnore(itemStack)
205 | && itemStack.getType() == ToolSwordHelper.WOOD_SWORD) {
206 |
207 | return true;
208 | }
209 | }
210 | return false;
211 | }
212 |
213 | public static void givePlayerShopItem(Arena arena, Team team, Player player, ShopItem item) {
214 | Bukkit.getScheduler().runTaskLater(MBedwarsTweaksPlugin.getInstance(), () -> item.getProducts().forEach(shopProduct -> {
215 | if (DependType.HOTBAR_MANAGER.isEnabled()) {
216 | for (ShopProduct product : item.getProducts()) {
217 | for (ItemStack itemStack : product.getGivingItems(player, team, arena, 1))
218 | HotbarManagerTools.giveItemsProperly(itemStack, player, item.getPage(), null, true);
219 | }
220 | } else {
221 | shopProduct.give(player, arena.getPlayerTeam(player), arena, 1);
222 | }
223 | }), 1L);
224 | }
225 | }
226 |
--------------------------------------------------------------------------------