topchetoeu/bedwars-plugin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: topchetoeu:master-1.8
Branches Tags
topchetoeu:master-1.8
topchetoeu:master-1.18
...
pull from: topchetoeu:master-1.18
Branches Tags
topchetoeu:master-1.18
topchetoeu:master-1.8

No commits in common. "master-1.8" and "master-1.18" have entirely different histories.
master-1.8 ... master-1.1

77 changed files with 5729 additions and 4421 deletions
Show Stats Expand all files Collapse all files

11
.gitignore vendored
View File

@ -1,3 +1,8 @@
deps
target
.vscode
*
!.gitignore
!src
!src/*
!src/**
!deps
!deps/*.jar
!pom.xml

BIN
deps/server.jar vendored Normal file
View File

Binary file not shown.

48
pom.xml
View File

@ -12,23 +12,45 @@
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
</properties>
<repositories>
<repository>
<id>minecraft-libraries</id>
<name>Minecraft Libraries</name>
<url>https://libraries.minecraft.net</url>
</repository>
<repository>
<id>spigot-repo</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
<groupId>org.spigotmc</groupId>
<artifactId>spigot-api</artifactId>
<version>1.18.1-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.bukkit</groupId>
<artifactId>bukkit</artifactId>
<groupId>spigot</groupId>
<artifactId>server</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${basedir}/deps/bukkit.jar</systemPath>
<systemPath>${basedir}/deps/server.jar</systemPath>
</dependency>
<dependency>
<groupId>com.mojang</groupId>
<artifactId>brigadier</artifactId>
<version>1.0.18</version>
</dependency>
<dependency>
<groupId>com.mojang</groupId>
<artifactId>datafixerupper</artifactId>
<version>1.0.20</version>
</dependency>
</dependencies>
@ -73,5 +95,13 @@
</plugin>
</plugins>
</pluginManagement>
<resources>
<resource>
<directory>src</directory>
<includes>
<include>**/*.yml</include>
</includes>
</resource>
</resources>
</build>
</project>

72
src/default-favourites.yml Normal file
View File

@ -0,0 +1,72 @@
'26':
deal: 5
section: 4
'25':
deal: 11
section: 4
'24':
deal: 8
section: 2
'23':
deal: 7
section: 2
'22':
deal: 4
section: 2
'21':
deal: 2
section: 0
'19':
deal: 9
section: 4
'18':
deal: 4
section: 4
'17':
deal: 2
section: 2
'16':
deal: 2
section: 3
'15':
deal: 2
section: 1
'14':
deal: 1
section: 0
'12':
deal: 8
section: 4
'11':
deal: 3
section: 4
'10':
deal: 1
section: 2
'9':
deal: 1
section: 3
'8':
deal: 1
section: 1
'7':
deal: 4
section: 0
'5':
deal: 7
section: 4
'4':
deal: 0
section: 4
'3':
deal: 0
section: 2
'2':
deal: 0
section: 3
'1':
deal: 0
section: 1
'0':
deal: 0
section: 0

353
src/main/java/me/topchetoeu/bedwars/Commands.java
View File

@ -2,293 +2,254 @@ package me.topchetoeu.bedwars;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import org.bukkit.Bukkit;
import org.bukkit.Color;
import org.bukkit.Location;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import me.topchetoeu.bedwars.commandUtility.Command;
import me.topchetoeu.bedwars.commandUtility.CommandExecutor;
import me.topchetoeu.bedwars.commandUtility.CommandExecutors;
import me.topchetoeu.bedwars.commands.Command;
import me.topchetoeu.bedwars.engine.BedwarsPlayer;
import me.topchetoeu.bedwars.engine.Config;
import me.topchetoeu.bedwars.engine.Game;
import me.topchetoeu.bedwars.engine.Team;
import me.topchetoeu.bedwars.engine.TeamColor;
import me.topchetoeu.bedwars.messaging.MessageParser;
import me.topchetoeu.bedwars.messaging.MessageUtility;
import net.md_5.bungee.api.ChatColor;
public class Commands {
private static File confFile = new File(Main.getInstance().getDataFolder(), "config.yml");
@SuppressWarnings("deprecation")
public static CommandExecutor kill = (CommandSender sender, Command cmd, String alias, String[] args) -> {
@SuppressWarnings("unchecked")
public static Command kill(Command cmd) {
return cmd.player("players", false).setRecursive(true).setExecutor((sender, _cmd, args) -> {
if (Game.isStarted()) {
for (String arg : args) {
OfflinePlayer p = Bukkit.getOfflinePlayer(arg);
if (p != null) {
for (Player p : (List<Player>)args.get("players")) {
BedwarsPlayer bwp = Game.instance.getPlayer(p);
if (bwp != null) {
bwp.kill(bwp.getPlayer().getName() + " definitely died with no admin intervention.");
}
else sender.sendMessage("Player is not in game!");
else return MessageUtility.parser("commands.not-in-game").variable("player", p.getDisplayName()).parse();
}
else sender.sendMessage("Player doesn't exist!");
return null;
}
else return MessageUtility.parser("commands.game-not-started").parse();
});
}
else sender.sendMessage("The game isn't started yet");
};
@SuppressWarnings("deprecation")
public static CommandExecutor revive = (CommandSender sender, Command cmd, String alias, String[] args) -> {
@SuppressWarnings("unchecked")
public static Command revive(Command cmd) {
return cmd.player("players", false).setRecursive(true).setExecutor((sender, _cmd, args) -> {
if (Game.isStarted()) {
for (String arg : args) {
OfflinePlayer p = Bukkit.getOfflinePlayer(arg);
if (p != null) {
for (Player p : (List<Player>)args.get("players")) {
BedwarsPlayer bwp = Game.instance.getPlayer(p);
if (bwp != null) {
bwp.revive();
Bukkit.broadcastMessage("Player " + p.getName() + " revived!");
return null;
}
else sender.sendMessage("Player is not in game!");
else return MessageUtility.parser("commands.not-in-game").variable("player", p.getDisplayName()).parse();
}
else sender.sendMessage("Player doesn't exist!");
return null;
}
else return MessageUtility.parser("commands.game-not-started").parse();
});
}
else sender.sendMessage("The game isn't started yet");
};
public static CommandExecutor start = (CommandSender sender, Command cmd, String alias, String[] args) -> {
if (args.length == 0) {
public static Command start(Command cmd) {
return cmd.setExecutor((sender, _cmd, args) -> {
if (!Game.isStarted()) {
Game.start();
sender.sendMessage("Started the game!");
MessageUtility.parser("commands.start.success").send(sender);
return null;
}
else sender.sendMessage("The game is already started");
else return MessageUtility.parser("commands.start.game-started").parse();
});
}
else sender.sendMessage("Invalid command syntax. No parameters required!");
};
public static CommandExecutor stop = (CommandSender sender, Command cmd, String alias, String[] args) -> {
if (args.length == 0) {
public static Command stop(Command cmd) {
return cmd.setExecutor((sender, _cmd, args) -> {
if (Game.isStarted()) {
Game.stop();
MessageUtility.parser("commands.stop.success").send(sender);
return null;
}
else sender.sendMessage("The game is not started");
else return MessageUtility.parser("commands.start.game-not-started").parse();
});
}
else sender.sendMessage("Invalid command syntax. No parameters required!");
};
public static CommandExecutor baseAdd = (CommandSender sender, Command cmd, String alias, String[] args) -> {
if (args.length == 3 && args[2].length() == 1) {
private static Command basesArg() {
return Command.createCollection("team", () -> Config.instance.getColors()
.stream()
.collect(Collectors.toMap(
TeamColor::getName,
v -> v
)), false
);
}
public static Command baseAdd(Command cmd) {
return cmd.string("name", false)._int("red")._int("green")._int("blue")._enum("color", org.bukkit.ChatColor.class, true)._enum("wool", Material.class, true)
.setExecutor((sender, _cmd, args) -> {
if (!Game.isStarted()) {
if (Utility.isParsable(args[1])) {
String name = args[0];
int woolId = Integer.parseInt(args[1]);
char chatId = args[2].charAt(0);
String name = args.get("name").toString().toLowerCase();
Material wool = (Material)args.get("wool");
org.bukkit.ChatColor bukkitChatColor = (org.bukkit.ChatColor)args.get("color");
int r = (int)args.get("red"),
g = (int)args.get("green"),
b = (int)args.get("blue");
ChatColor chatColor = Utility.bukkitToBungeeColor(bukkitChatColor);
if (woolId >= 0 && woolId < 16) {
if (Config.instance.getColor(name.toLowerCase()) == null) {
Config.instance.getColors().add(new TeamColor(name.toLowerCase(), woolId, chatId));
Config.instance.getColors().add(new TeamColor(name, wool, Color.fromRGB(r, g, b), chatColor));
Config.instance.save(confFile);
sender.sendMessage("New base was created!");
MessageUtility.parser("commands.base-add.success").variable("base", name).send(sender);
return null;
}
else sender.sendMessage("Base with this name already exists!");
else return MessageUtility.parser("commands.base-add.already-exists").variable("base", name).parse();
}
else sender.sendMessage("woolId must be a valid number between 0 and 15!");
} else sender.sendMessage("woolId must be a valid number between 0 and 15!");
else return MessageUtility.parser("commands.base-add.game-started").parse();
});
}
else sender.sendMessage("Can't make modifications to the map while a game is ongoing!");
}
else sender.sendMessage("Invalid command syntax. Syntax: /bw conf base new <name> <woolId> <chatId>");
};
public static CommandExecutor baseRemove = (CommandSender sender, Command cmd, String alias, String[] args) -> {
if (args.length == 1) {
TeamColor color = Config.instance.getColor(args[0]);
if (color != null) {
public static Command baseRemove(Command cmd) {
return cmd
.addChild(basesArg())
.setExecutor((sender, _cmd, args) -> {
TeamColor color = (TeamColor)args.get("team");
Config.instance.getColors().remove(color);
Config.instance.save(confFile);
sender.sendMessage("Base removed!");
MessageUtility.parser("commands.base-remove").variable("base", color.getColorName()).send(sender);
return null;
});
}
else sender.sendMessage("Base doesn't exist!");
}
else sender.sendMessage("Invalid syntax! Syntax: /bw conf base del <name>");
};
public static CommandExecutor baseSetSpawn = (CommandSender sender, Command cmd, String alias, String[] args) -> {
boolean aligned = args.length == 2 && args[1].equals("aligned");
public static Command baseSetSpawn(Command cmd) {
return cmd
.addChild(basesArg())
.location("location")
.setExecutor((sender, _cmd, args) -> {
TeamColor color = (TeamColor)args.get("team");
Location loc = (Location)args.get("location");
if (args.length == 1 || aligned) {
if (sender instanceof Player) {
Player p = (Player)sender;
TeamColor color = Config.instance.getColor(args[0]);
if (color != null) {
Location loc = p.getLocation();
if (aligned) {
loc.setX(loc.getBlockX() + 0.5);
loc.setZ(loc.getBlockZ() + 0.5);
}
color.setSpawnLocation(loc);
Config.instance.save(confFile);
sender.sendMessage("Base spawn set to your current location");
}
else sender.sendMessage("Base doesn't exist!");
MessageUtility.parser("commands.base-spawn").variable("base", color.getColorName()).send(sender);
return null;
});
}
else sender.sendMessage("This commands is for players only!");
}
else sender.sendMessage("Invalid syntax! Syntax: /bw conf base spawn [aligned]");
};
public static CommandExecutor baseSetGenerator = (CommandSender sender, Command cmd, String alias, String[] args) -> {
boolean aligned = args.length == 2 && args[1].equals("aligned");
public static Command baseSetGenerator(Command cmd) {
return cmd
.addChild(basesArg())
.location("location")
.setExecutor((sender, _cmd, args) -> {
TeamColor color = (TeamColor)args.get("team");
Location loc = (Location)args.get("location");
if (args.length == 1 || aligned) {
if (sender instanceof Player) {
Player p = (Player)sender;
TeamColor color = Config.instance.getColor(args[0]);
if (color != null) {
Location loc = p.getLocation();
if (aligned) {
loc.setX(loc.getBlockX() + 0.5);
loc.setZ(loc.getBlockZ() + 0.5);
}
color.setGeneratorLocation(loc);
Config.instance.save(confFile);
sender.sendMessage("Base generator set to your current location");
}
else sender.sendMessage("Base doesn't exist!");
MessageUtility.parser("commands.base-generator").variable("base", color.getColorName()).send(sender);
return null;
});
}
else sender.sendMessage("This commands is for players only!");
}
else sender.sendMessage("Invalid syntax! Syntax: /bw conf base gen [aligned]");
};
public static CommandExecutor baseSetBed = (CommandSender sender, Command cmd, String alias, String[] args) -> {
boolean aligned = args.length == 2 && args[1].equals("aligned");
public static Command baseSetBed(Command cmd) {
return cmd
.addChild(basesArg())
.location("location")
.setExecutor((sender, _cmd, args) -> {
TeamColor color = (TeamColor)args.get("team");
Location loc = (Location)args.get("location");
if (args.length == 1 || aligned) {
if (sender instanceof Player) {
Player p = (Player)sender;
TeamColor color = Config.instance.getColor(args[0]);
if (color != null) {
Location loc = p.getLocation();
if (aligned) {
loc.setX(loc.getBlockX() + 0.5);
loc.setZ(loc.getBlockZ() + 0.5);
}
color.setBedLocation(loc);
Config.instance.save(confFile);
sender.sendMessage("Base bed set to your current location");
}
else sender.sendMessage("Base doesn't exist!");
MessageUtility.parser("commands.base-bed").variable("base", color.getColorName()).send(sender);
return null;
});
// );
}
else sender.sendMessage("This commands is for players only!");
}
else sender.sendMessage("Invalid syntax! Syntax: /bw conf base bed [aligned]");
};
public static CommandExecutor baseList = (CommandSender sender, Command cmd, String alias, String[] args) -> {
if (args.length == 0) {
ArrayList<TeamColor> colors = Config.instance.getColors();
public static Command baseList(Command cmd) {
return cmd
.setExecutor((sender, _cmd, args) -> {
List<TeamColor> colors = Config.instance.getColors();
if (colors.size() != 0) {
sender.sendMessage("Bases:");
MessageUtility.parser("commands.base-list.title").variable("count", colors.size()).send(sender);
for (TeamColor color : colors) {
sender.sendMessage("§" + color.getColorId() + color.getName() + "§r" + (
color.isFullySpecified() ? "" : " (not fully specified)"
));
}
}
else sender.sendMessage("No bases found.");
}
else sender.sendMessage("Invalid syntax! No parameters required");
};
MessageParser parser = MessageUtility.parser("commands.base-list.not-fully-specified");
public static CommandExecutor breakBed = (CommandSender sender, Command cmd, String alias, String[] args) -> {
if (!Game.isStarted()) {
sender.sendMessage("§4A game hasn't been started yet.");
return;
if (color.isFullySpecified()) parser = MessageUtility.parser("commands.base-list.fully-specified");
parser
.variable("name", color.getColorName())
.variable("woolId", color.getWoolMaterial().getKey())
.variable("colorRed", color.getColor().getRed())
.variable("colorGreen", color.getColor().getGreen())
.variable("colorBlue", color.getColor().getBlue())
.send(sender);
}
}
else MessageUtility.parser("commands.base-list.no-bases").send(sender);
return null;
});
}
@SuppressWarnings("unchecked")
public static Command breakBed(Command cmd) {
return cmd
.addChild(basesArg()).setRecursive(true)
.setExecutor((sender, _cmd, args) -> {
if (!Game.isStarted()) return MessageUtility.parser("commands.game-not-started").parse();
List<TeamColor> colors = (List<TeamColor>)args.get("team");
ArrayList<Team> teams = new ArrayList<>();
for (String arg : args) {
TeamColor color = Config.instance.getColor(arg);
if (color == null) {
sender.sendMessage(String.format("§4The team color §l§4%s§r§4 doesn't exist.", arg));
return;
}
for (TeamColor color : colors) {
Team team = Game.instance.getTeam(color);
if (team == null) {
sender.sendMessage(String.format("§6The team color §l§4%s§r§4 isn't in the game.", arg));
return MessageUtility.parser("commands.break-bed.not-in-game").variable("team", color.getColorName()).parse();
}
teams.add(team);
}
for (Team team : teams) {
if (!team.destroyBed(null))
sender.sendMessage(String.format("§4The %s's bed is already destroyed.", team.getTeamColor().getName()));
}
};
public static CommandExecutor createDiamondGen = (CommandSender sender, Command cmd, String alias, String[] args) -> {
if (args.length > 1) {
sender.sendMessage("§4Invalid syntax!§r Syntax: /bw config gen diamond [aligned]");
return;
team.destroyBed(null);
}
boolean aligned = args.length == 1 && args[0] == "aligned";
if (sender instanceof Player) {
Player p = (Player)sender;
Location loc = p.getLocation();
if (aligned) {
loc.setX(loc.getBlockX() + 0.5);
loc.setZ(loc.getBlockZ() + 0.5);
return null;
});
}
public static Command createDiamondGen(Command cmd) {
return cmd.location("location").setExecutor((sender, _cmd, args) -> {
Location loc = (Location)args.get("location");
Config.instance.getDiamondGenerators().add(loc);
Config.instance.save(confFile);
p.sendMessage("§aGenerator added!");
MessageUtility.parser("commands.generator-create.diamond").send(sender);
return null;
});
}
else sender.sendMessage("§4Only a player may execute this command.");
};
public static CommandExecutor createEmeraldGen = (CommandSender sender, Command cmd, String alias, String[] args) -> {
if (args.length > 1) {
sender.sendMessage("§4Invalid syntax!§r Syntax: /bw config gen emerald [aligned]");
return;
}
boolean aligned = args.length == 1 && args[0] == "aligned";
if (sender instanceof Player) {
Player p = (Player)sender;
Location loc = p.getLocation();
if (aligned) {
loc.setX(loc.getBlockX() + 0.5);
loc.setZ(loc.getBlockZ() + 0.5);
}
public static Command createEmeraldGen(Command cmd) {
return cmd.location("location").setExecutor((sender, _cmd, args) -> {
Location loc = (Location)args.get("location");
Config.instance.getEmeraldGenerators().add(loc);
Config.instance.save(confFile);
p.sendMessage("§aGenerator added!");
MessageUtility.parser("commands.generator-create.emerald").send(sender);
return null;
});
}
public static Command clearGens(Command cmd) {
return cmd.setExecutor((sender, _cmd, args) -> {
Config.instance.getEmeraldGenerators().clear();
Config.instance.save(confFile);
MessageUtility.parser("commands.generator-create.clear").send(sender);
return null;
});
}
else sender.sendMessage("§4Only a player may execute this command.");
};
public static CommandExecutor _default = CommandExecutors.message("For help do /bw help");
}

232
src/main/java/me/topchetoeu/bedwars/Main.java
View File

@ -1,18 +1,12 @@
package me.topchetoeu.bedwars;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.logging.Level;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftEntity;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.Player;
import org.bukkit.entity.Villager;
import org.bukkit.event.EventHandler;
@ -20,12 +14,12 @@ import org.bukkit.event.Listener;
import org.bukkit.event.entity.FoodLevelChangeEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitTask;
import me.topchetoeu.bedwars.commandUtility.Command;
import me.topchetoeu.bedwars.commandUtility.CommandExecutors;
import me.topchetoeu.bedwars.commands.Command;
import me.topchetoeu.bedwars.commands.CommandExecutors;
import me.topchetoeu.bedwars.engine.AttackCooldownEradicator;
import me.topchetoeu.bedwars.engine.Config;
import me.topchetoeu.bedwars.engine.Game;
import me.topchetoeu.bedwars.engine.trader.Favourites;
@ -42,8 +36,7 @@ import me.topchetoeu.bedwars.engine.trader.upgrades.FatigueTeamUpgrade;
import me.topchetoeu.bedwars.engine.trader.upgrades.HealTeamUpgrade;
import me.topchetoeu.bedwars.engine.trader.upgrades.ProtectionTeamUpgrade;
import me.topchetoeu.bedwars.engine.trader.upgrades.SharpnessTeamUpgrade;
// TODO add permissions
import me.topchetoeu.bedwars.messaging.MessageUtility;
public class Main extends JavaPlugin implements Listener {
@ -54,7 +47,7 @@ public class Main extends JavaPlugin implements Listener {
return instance;
}
private File confFile = new File(getDataFolder(), "config.yml");
// private File confFile = new File(getDataFolder(), "config.yml");
private int getGameSize() {
return Config.instance.getTeamSize() * Config.instance.getColors().size();
}
@ -64,7 +57,11 @@ public class Main extends JavaPlugin implements Listener {
private void stopTimer() {
if (timerTask == null) return;
Utility.broadcastTitle("Not enough players!", null, 10, 40, 5);
Utility.broadcastTitle(
MessageUtility.parser("pre-game.not-enough-players.title").parse(),
MessageUtility.parser("pre-game.not-enough-players.subtitle").parse(),
10, 40, 5
);
timerTask.cancel();
timerTask = null;
}
@ -76,10 +73,20 @@ public class Main extends JavaPlugin implements Listener {
stopTimer();
return;
}
if (timer % 30 == 0 || timer == 15 || timer == 10)
Utility.broadcastTitle("Starting in " + timer + " seconds!", null, 10, 40, 5);
else if (timer <= 5)
Utility.broadcastTitle("Starting in " + timer + " seconds!", null, 0, 20, 0);
if (timer % 30 == 0 || timer == 15 || timer == 10) {
Utility.broadcastTitle(
MessageUtility.parser("pre-game.starting.title").variable("time", timer).parse(),
MessageUtility.parser("pre-game.starting.subtitle").variable("time", timer).parse(),
10, 40, 5
);
}
else if (timer <= 5) {
Utility.broadcastTitle(
MessageUtility.parser("pre-game.starting.title").variable("time", timer).parse(),
MessageUtility.parser("pre-game.starting.subtitle").variable("time", timer).parse(),
0, 21, 0
);
}
timer--;
if (timer <= 0) {
Game.start();
@ -92,7 +99,6 @@ public class Main extends JavaPlugin implements Listener {
// TODO make timing configurable
if (!Game.isStarted()) {
if (playerCount <= 1 || playerCount <= getGameSize() / 4) {
Utility.broadcastTitle("Not enough players", "Waiting for more...", 0, 100, 0);
stopTimer();
}
else if (playerCount <= getGameSize() / 2) {
@ -127,7 +133,6 @@ public class Main extends JavaPlugin implements Listener {
e.setCancelled(true);
}
@SuppressWarnings("deprecation")
@Override
public void onEnable() {
playerCount = Bukkit.getServer().getOnlinePlayers().size();
@ -136,34 +141,14 @@ public class Main extends JavaPlugin implements Listener {
getDataFolder().mkdir();
File conf = new File(getDataFolder(), "config.yml");
if (!conf.exists())
try {
YamlConfiguration.loadConfiguration(
getClass()
.getClassLoader()
.getResourceAsStream("config.yml")
).save(confFile);
}
catch (IOException e) { /* Everything is fine */ }
// Deprecation warnings are for beginners
conf.createNewFile();
Config.load(conf);
File defaultFavs = new File(getDataFolder(), "default-favourites.yml");
File defaultFavourites = new File(getDataFolder(), "default-favourites.yml");
if (!defaultFavs.exists()) {
try {
OutputStream w = new FileOutputStream(defaultFavs);
InputStream r = getClass()
.getClassLoader()
.getResourceAsStream("default-favourites.yml");
MessageUtility.load(new File(getDataFolder(), "messages.yml"));
w.write(r.readAllBytes());
w.close();
r.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (!defaultFavourites.exists())
defaultFavourites.createNewFile();
File favsDir = new File(getDataFolder(), "favourites");
@ -173,6 +158,8 @@ public class Main extends JavaPlugin implements Listener {
e.printStackTrace();
}
AttackCooldownEradicator.init(this);
YamlConfiguration sectionsConf = YamlConfiguration.loadConfiguration(new File(getDataFolder(), "sections.yml"));
BlindnessTeamUpgrade.init(this);
@ -188,119 +175,68 @@ public class Main extends JavaPlugin implements Listener {
EnforcedRankedDealType.init();
RankedUpgradeDealType.init();
Sections.init(new File(getDataFolder(), "sections.yml"));
Favourites.instance = new Favourites(favsDir, defaultFavs);
Favourites.instance = new Favourites(favsDir, defaultFavourites);
updateTimer();
getServer().getWorlds().get(0).getEntitiesByClass(Villager.class).forEach(v -> {
net.minecraft.server.v1_8_R3.Entity nmsEntity = ((CraftEntity) v).getHandle();
nmsEntity.b(true); // Disables its AI
v.setAI(false);
});
Command cmd = new Command("bedwars", "bw").setExecutor(Commands._default);
cmd
.attachCommand(new Command("help")
.setExecutor(CommandExecutors.help(cmd))
.setHelpMessage("Shows help for the command")
)
.attachCommand(new Command("start")
.setExecutor(Commands.start)
.setHelpMessage("Starts the game")
)
.attachCommand(new Command("stop")
.setExecutor(Commands.stop)
.setHelpMessage("Stops the game, noone wins")
)
.attachCommand(new Command("respawn", "revive")
.setExecutor(Commands.revive)
.setHelpMessage("Respawns a spectator, if he has a bed, he is immediatly respawned"))
.attachCommand(new Command("breakbed", "eliminateteam")
.setExecutor(Commands.breakBed)
.setHelpMessage("Destoys the bed of a team")
)
.attachCommand(new Command("eliminate")
.setHelpMessage("Eliminates a player")
)
.attachCommand(new Command("kill")
.setExecutor(Commands.kill)
.setHelpMessage("Kills a player")
)
.attachCommand(new Command("killteam")
.setHelpMessage("Kills all players of a team")
)
.attachCommand(new Command("villagertools", "villager", "trader")
.setExecutor((sender, _cmd, alias, args) -> {
if (args.length == 0) {
Command cmd = Command.createLiteral("bedwars", "bw").permission("bedwars");
cmd.literal("help").permission("bedwars.help").setExecutor(CommandExecutors.help()).string("args", false).setRecursive(true).setExecutor(CommandExecutors.help());
Commands.start(cmd.literal("start")).permission("bedwars.control.start");
Commands.stop(cmd.literal("stop")).permission("bedwars.control.stop");
Commands.kill(cmd.literal("kill")).permission("bedwars.cheat.kill");
Commands.revive(cmd.literal("revive")).permission("bedwars.cheat.revive");
Command config = cmd.literal("configuration", "config", "conf").permission("bedwars.conf");
Command base = config.literal("base").permission("bedwars.conf.bases");
Command generator = config.literal("generator", "gen").permission("bedwars.conf.generators");
Commands.baseAdd(base.literal("add")).permission("bedwars.config.bases.add");
Commands.baseRemove(base.literal("remove")).permission("bedwars.config.bases.remove");
Commands.baseSetSpawn(base.literal("setspawn", "spawn")).permission("bedwars.config.bases.setspawn");
Commands.baseSetGenerator(base.literal("setgenerator", "generator", "gen")).permission("bedwars.config.bases.setgenerator");
Commands.baseSetBed(base.literal("setbed", "bed")).permission("bedwars.config.bases.setbed");
Commands.baseList(base.literal("list", "l")).permission("bedwars.config.bases.list");
Commands.createDiamondGen(generator.literal("diamond")).permission("bedwars.config.generators.diamond");
Commands.createEmeraldGen(generator.literal("emerald", "em")).permission("bedwars.config.generators.emerald");
Commands.clearGens(generator.literal("clear")).permission("bedwars.config.generators.clear");
Commands.breakBed(cmd.literal("breakbed", "cheat", "bedishonest", "abusepowers")).permission("bedwars.config.cheat.breakbed");
cmd.literal("villagertools", "villagers", "traders")
.setHelpMessage("Gives you tools to manage traders")
.permission("bedwars.villagertools")
.setExecutor((sender, _cmd, args) -> {
if (sender instanceof Player) {
Player p = (Player)sender;
Traders.instance.give(p);
return null;
}
else return MessageUtility.parser("commands.for-players").parse();
p.getInventory().addItem(Utility.namedItem(new ItemStack(Material.MONSTER_EGG), "§rTrader spawner"));
p.getInventory().addItem(Utility.namedItem(new ItemStack(Material.STICK), "§rTrader eradicator"));
}
}
})
.setHelpMessage("Gives you tools to manage traders")
)
.attachCommand(new Command("config", "conf", "settings")
.setExecutor(Commands._default)
.setHelpMessage("Command for configuring the map")
.attachCommand(new Command("spawn")
.setHelpMessage("Sets the spawn at which the platform is going to be spawned, and where spectators are going to be spawned")
)
.attachCommand(new Command("base", "b")
.setExecutor(Commands._default)
.setHelpMessage("Command for configuring separate bases")
.attachCommand(new Command("new", "add", "create", "c")
.setExecutor(Commands.baseAdd)
.setHelpMessage("Creates a base with a color, chat id and a wool id. NOTE: for chat id, do the following: if in chat the color you want is &2, specify just '2'")
)
.attachCommand(new Command("remove", "delete", "del", "d")
.setExecutor(Commands.baseRemove)
.setHelpMessage("Removes a base with the selected name")
)
.attachCommand(new Command("setbed", "bed", "b")
.setExecutor(Commands.baseSetBed)
.setHelpMessage("Sets the location of the bed. Any broken bed within 5 blocks of the specified location will trigger the breaking of the team's bed")
)
.attachCommand(new Command("setgenerator", "generator", "setgen", "gen", "g")
.setExecutor(Commands.baseSetGenerator)
.setHelpMessage("Sets the location of the generator. Anyone within 2 blocks of it will pick up the produced items")
)
.attachCommand(new Command("setspawn", "spawn", "s")
.setExecutor(Commands.baseSetSpawn)
.setHelpMessage("Sets the location where players of the team will respawn")
)
.attachCommand(new Command("list", "l")
.setExecutor(Commands.baseList)
.setHelpMessage("Lists all bases")
)
)
.attachCommand(new Command("generator", "gen", "g")
.setExecutor(Commands._default)
.setHelpMessage("Command for configuring the global generators")
.attachCommand(new Command("diamond", "d")
.setExecutor(Commands.createDiamondGen)
.setHelpMessage("Creates a diamond generator in (approximately) your position")
)
.attachCommand(new Command("emerald", "e")
.setExecutor(Commands.createEmeraldGen)
.setHelpMessage("Creates a emerald generator in (approximately) your position")
)
.attachCommand(new Command("remove", "delete", "del", "r")
.setHelpMessage("Deletes all generators within 5 block of your position")
)
)
)
.attachCommand(new Command("diemydarling")
.setExecutor((a, b, c, d) -> {
Bukkit.getWorld("world")
.getEntities()
.stream()
.filter(v -> v instanceof ArmorStand)
.forEach(v -> v.remove());
})
)
.register(this);
});
cmd.register(this);
// .attachCommand(new Command("respawn", "revive")
// .setExecutor(Commands.revive)
// .setHelpMessage("Respawns a spectator, if he has a bed, he is immediately respawned"))
// .attachCommand(new Command("breakbed", "eliminateteam")
// .setExecutor(Commands.breakBed)
// .setHelpMessage("Destroys the bed of a team")
// )
// .attachCommand(new Command("eliminate")
// .setHelpMessage("Eliminates a player")
// )
// .attachCommand(new Command("killteam")
// .setHelpMessage("Kills all players of a team")
// )
//
// .register(this);
getServer().getPluginManager().registerEvents(this, this);
}

163
src/main/java/me/topchetoeu/bedwars/Utility.java
View File

@ -4,58 +4,39 @@ import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.data.type.Bed;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftItemStack;
import org.bukkit.craftbukkit.v1_18_R1.inventory.CraftItemStack;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.EquipmentSlot;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.inventory.meta.PotionMeta;
import org.bukkit.potion.Potion;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
import org.bukkit.potion.PotionType;
import net.minecraft.server.v1_8_R3.ChatComponentText;
import net.minecraft.server.v1_8_R3.EntityPlayer;
import net.minecraft.server.v1_8_R3.IChatBaseComponent;
import net.minecraft.server.v1_8_R3.PacketPlayOutTitle;
import net.minecraft.server.v1_8_R3.PacketPlayOutTitle.EnumTitleAction;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.ComponentBuilder;
import net.md_5.bungee.api.chat.TranslatableComponent;
public class Utility {
private static IChatBaseComponent getText(String text) {
return new ChatComponentText(text);
public static void sendTitle(Player p, BaseComponent[] title, BaseComponent[] subtitle, int fadeIn, int duration, int fadeout) {
String _title = title == null ? null : BaseComponent.toLegacyText(title);
String _subtitle = subtitle == null ? null : BaseComponent.toLegacyText(subtitle);
p.sendTitle(_title, _subtitle, fadeIn, duration, fadeout);
}
public static void sendTitle(Player p, String title, String subtitle, int fadein, int duration, int fadeout) {
EntityPlayer handle = ((CraftPlayer)p).getHandle();
handle.playerConnection.sendPacket(new PacketPlayOutTitle(
EnumTitleAction.TIMES, null, fadein, duration, fadeout
));
if (subtitle == null) {
subtitle = "";
}
if (title == null) {
title = "";
}
handle.playerConnection.sendPacket(new PacketPlayOutTitle(
EnumTitleAction.SUBTITLE, getText(subtitle)
));
handle.playerConnection.sendPacket(new PacketPlayOutTitle(
EnumTitleAction.TITLE, getText(title)
));
}
public static void broadcastTitle(String title, String subtitle, int fadein, int duration, int fadeout) {
Bukkit.getOnlinePlayers().forEach(v -> sendTitle(v, title, subtitle, fadein, duration, fadeout));
public static void broadcastTitle(BaseComponent[] title, BaseComponent[] subtitle, int fadeIn, int duration, int fadeout) {
Bukkit.getOnlinePlayers().forEach(v -> sendTitle(v, title, subtitle, fadeIn, duration, fadeout));
}
public static boolean isParsable(String val) {
try {
@ -80,23 +61,32 @@ public class Utility {
i.setItemMeta(meta);
return i;
}
public static String getItemName(Material item) {
net.minecraft.server.v1_8_R3.ItemStack nmsStack = CraftItemStack.asNMSCopy(new ItemStack(item));
return nmsStack.getItem().a(nmsStack);
public static BaseComponent[] getItemName(Material item) {
return getItemName(new ItemStack(item));
}
public static BaseComponent[] getItemName(ItemStack item) {
if (item.getItemMeta().getDisplayName() != null && !item.getItemMeta().getDisplayName().isEmpty())
return new ComponentBuilder().appendLegacy(item.getItemMeta().getDisplayName()).create();
return new ComponentBuilder()
.append(new TranslatableComponent(CraftItemStack.asNMSCopy(item).n()))
.reset()
.create();
}
public static void takeOne(Player p, EquipmentSlot e) {
ItemStack i = p.getInventory().getItem(e);
if (i.getAmount() == 0) p.getInventory().setItem(e, i);
else {
i.setAmount(i.getAmount() - 1);
p.getInventory().setItem(e, i);
}
public static String getItemName(ItemStack item) {
if (item.getItemMeta().hasDisplayName()) return item.getItemMeta().getDisplayName();
net.minecraft.server.v1_8_R3.ItemStack nmsStack = CraftItemStack.asNMSCopy(item);
return nmsStack.getItem().a(nmsStack);
}
@SuppressWarnings("unchecked")
@SuppressWarnings({ "unchecked", "deprecation" })
public static ItemStack deserializeItemStack(Map<String, Object> map) {
String id = ((String)map.get("id")).toUpperCase();
int amount = map.containsKey("amount") ? (Integer)map.get("amount") : 1;
short damage = (short)(map.containsKey("damage") ? (Integer)map.get("damage") : 0);
ItemStack item = new ItemStack(Material.getMaterial(id), amount, damage);
ItemStack item = new ItemStack(Material.getMaterial(id), amount);
ItemMeta meta = item.getItemMeta();
if (map.containsKey("displayName")) meta.setDisplayName((String)map.get("displayName"));
@ -115,7 +105,6 @@ public class Utility {
String name = (String)potionMap.get("id");
int level = (Integer)potionMap.get("level");
int duration = (Integer)potionMap.get("duration");
boolean splash = potionMap.containsKey("splash") && (boolean)potionMap.get("splash");
PotionEffectType effectType = PotionEffectType.getByName(name.toUpperCase());
@ -124,10 +113,7 @@ public class Utility {
effectType,
duration, level, false
), false);
Potion pot = new Potion(PotionType.getByEffect(effectType), 1);
if (splash) pot = pot.splash();
pot.apply(item);
potionMeta.setColor(effectType.getColor());
meta = potionMeta;
}
@ -148,6 +134,35 @@ public class Utility {
return map;
}
public static boolean isBed(Block meta) {
return meta.getBlockData() instanceof Bed;
}
public static boolean isWool(Block meta) {
return meta.getType().getKey().getKey().endsWith("_wool");
}
public static boolean isWool(Material meta) {
return meta.getKey().getKey().endsWith("_wool");
}
public static boolean isTool(Material type) {
return type == Material.SHEARS ||
type.getKey().getKey().endsWith("_pickaxe") ||
type.getKey().getKey().endsWith("_shovel") ||
type.getKey().getKey().endsWith("_axe");
}
public static boolean isArmor(Material type) {
return
type.getKey().getKey().endsWith("_helmet") ||
type.getKey().getKey().endsWith("_chestplate") ||
type.getKey().getKey().endsWith("_leggings") ||
type.getKey().getKey().endsWith("_boots");
}
public static boolean isWeapon(Material type) {
return
type.getKey().getKey().endsWith("_sword") ||
type.getKey().getKey().endsWith("_axe");
}
public static Optional<PotionEffect> getPotionEffect(Collection<PotionEffect> p, PotionEffectType type) {
return p.stream().filter(v -> v.getType().equals(type)).findFirst();
}
@ -175,4 +190,54 @@ public class Utility {
if (obj == null) obj = "null";
p.sendMessage(obj.toString());
}
public static ChatColor bukkitToBungeeColor(org.bukkit.ChatColor bukkitChatColor) {
switch (bukkitChatColor) {
case RED:
return ChatColor.RED;
case AQUA:
return ChatColor.AQUA;
case BLACK:
return ChatColor.BLACK;
case BLUE:
return ChatColor.BLUE;
case BOLD:
return ChatColor.BOLD;
case DARK_AQUA:
return ChatColor.DARK_AQUA;
case DARK_BLUE:
return ChatColor.DARK_BLUE;
case DARK_GRAY:
return ChatColor.DARK_GRAY;
case DARK_GREEN:
return ChatColor.DARK_GREEN;
case DARK_PURPLE:
return ChatColor.DARK_PURPLE;
case DARK_RED:
return ChatColor.DARK_RED;
case GOLD:
return ChatColor.GOLD;
case GRAY:
return ChatColor.GRAY;
case GREEN:
return ChatColor.GREEN;
case ITALIC:
return ChatColor.ITALIC;
case LIGHT_PURPLE:
return ChatColor.LIGHT_PURPLE;
case MAGIC:
return ChatColor.MAGIC;
case RESET:
return ChatColor.RESET;
case STRIKETHROUGH:
return ChatColor.STRIKETHROUGH;
case UNDERLINE:
return ChatColor.UNDERLINE;
case WHITE:
return ChatColor.WHITE;
case YELLOW:
return ChatColor.YELLOW;
default:
return null;
}
}
}

147
src/main/java/me/topchetoeu/bedwars/commandUtility/Command.java
View File

@ -1,147 +0,0 @@
package me.topchetoeu.bedwars.commandUtility;
import java.util.Arrays;
import java.util.HashSet;
import org.apache.commons.lang.NullArgumentException;
import org.bukkit.command.CommandSender;
import org.bukkit.plugin.java.JavaPlugin;
public class Command {
private String[] aliases;
private String name;
private String helpMessage;
private CommandExecutor fallbackExecutor;
private HashSet<Command> attachedCommands = new HashSet<>();
private JavaPlugin parent = null;
public String[] getAliases() {
return aliases;
}
public String getName() {
return name;
}
public String getHelpMessage() {
return helpMessage;
}
public Command setHelpMessage(String val) {
helpMessage = val;
return this;
}
public CommandExecutor getFallbackExecutor() {
return fallbackExecutor;
}
public Command setExecutor(CommandExecutor val) {
fallbackExecutor = val;
return this;
}
public Command attachCommand(Command cmd) {
if (cmd == null) throw new NullArgumentException("cmd");
attachedCommands.add(cmd);
return this;
}
public Command detachCommand(Command cmd) {
if (cmd == null) throw new NullArgumentException("cmd");
attachedCommands.remove(cmd);
return this;
}
public boolean commandAttached(Command cmd) {
if (cmd == null) return false;
return attachedCommands.contains(cmd);
}
public Command[] getAttachedCommands() {
return attachedCommands.toArray(Command[]::new);
}
public void execute(CommandSender sender, String alias, String[] args) {
Command cmd;
if (args.length == 0) cmd = null;
else cmd = getAttachedCommand(args[0]);
String[] newArgs;
if (args.length <= 1) newArgs = new String[0];
else {
newArgs = new String[args.length - 1];
System.arraycopy(args, 1, newArgs, 0, args.length - 1);
}
if (cmd != null)
cmd.execute(sender, args[0], newArgs);
else if (fallbackExecutor != null) fallbackExecutor.execute(
sender, this,
alias, args
);
else sender.sendMessage("This command doesn't do anything :(");
}
public Command register(JavaPlugin pl) {
if (pl == parent) throw new IllegalArgumentException("The command is already attached to the given plugin");
if (pl == null) throw new NullArgumentException("pl");
parent = pl;
pl.getCommand(name).setAliases(Arrays.asList(aliases));
pl.getCommand(name).setExecutor(new org.bukkit.command.CommandExecutor() {
@Override
public boolean onCommand(CommandSender sender, org.bukkit.command.Command cmd, String alias, String[] args) {
execute(sender, alias, args);
return true;
}
});
return this;
}
public Command getAttachedCommand(String alias) {
String newAlias = alias.toLowerCase();
for (Command command : attachedCommands) {
if (command.name.equals(newAlias) || Arrays.stream(command.aliases).anyMatch(v -> v.equals(newAlias)))
return command;
}
return null;
}
public Command(String name, String alias) {
this.name = name;
this.aliases = new String[] { alias };
}
public Command(String name, String... aliases) {
this.name = name;
this.aliases = aliases;
}
public Command(String name, CommandExecutor executor, String... aliases) {
this.name = name;
this.aliases = aliases;
this.fallbackExecutor = executor;
}
public Command(String name, String alias, Command... commands) {
this.name = name;
this.aliases = new String[] { alias };
for (Command cmd : commands) {
attachCommand(cmd);
}
}
public Command(String name, String[] aliases, Command... commands) {
this.name = name;
this.aliases = aliases;
for (Command cmd : commands) {
attachCommand(cmd);
}
}
public Command(String name, String[] aliases, CommandExecutor executor, Command... commands) {
this.name = name;
this.aliases = aliases;
fallbackExecutor = executor;
for (Command cmd : commands) {
attachCommand(cmd);
}
}
}

7
src/main/java/me/topchetoeu/bedwars/commandUtility/CommandExecutor.java
View File

@ -1,7 +0,0 @@
package me.topchetoeu.bedwars.commandUtility;
import org.bukkit.command.CommandSender;
public interface CommandExecutor {
void execute(CommandSender sender, Command cmd, String alias, String[] args);
}

62
src/main/java/me/topchetoeu/bedwars/commandUtility/CommandExecutors.java
View File

@ -1,62 +0,0 @@
package me.topchetoeu.bedwars.commandUtility;
import org.bukkit.command.CommandSender;
public class CommandExecutors {
private static String join(String[] arr, String separator) {
if (arr.length == 0) return "";
if (arr.length == 1) return arr[0];
String res = arr[0];
for (int i = 1; i < arr.length; i++) {
res += separator + arr[i];
}
return res;
}
public static CommandExecutor help(Command mainCmd) {
return new CommandExecutor() {
@Override
public void execute(CommandSender sender, Command cmd, String alias, String[] args) {
Command currCmd = mainCmd;
String path = "/" + mainCmd.getName();
for (String arg : args) {
currCmd = currCmd.getAttachedCommand(arg);
if (currCmd == null) {
String msg = "Help can't be provided for the command.";
sender.sendMessage(msg);
return;
}
path += " " + currCmd.getName();
}
sender.sendMessage(path + ": " + (currCmd.getHelpMessage() == null ?
"no help provided" :
currCmd.getHelpMessage())
);
if (currCmd.getAliases().length != 0)
sender.sendMessage("Aliases: " + join(currCmd.getAliases(), ", "));
if (currCmd.getAttachedCommands().length > 0) {
sender.sendMessage("Commands: ");
for (Command subCmd : currCmd.getAttachedCommands()) {
sender.sendMessage(path + " " + subCmd.getName() + ": " + subCmd.getHelpMessage());
}
}
}
};
}
public static CommandExecutor message(String msg) {
return new CommandExecutor() {
@Override
public void execute(CommandSender sender, Command cmd, String alias, String[] args) {
sender.sendMessage(msg);
}
};
}
}

341
src/main/java/me/topchetoeu/bedwars/commands/Command.java Normal file
View File

@ -0,0 +1,341 @@
package me.topchetoeu.bedwars.commands;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.bukkit.command.CommandSender;
import org.bukkit.plugin.java.JavaPlugin;
import me.topchetoeu.bedwars.commands.args.ArgParser;
import me.topchetoeu.bedwars.commands.args.ArgParserRes;
import me.topchetoeu.bedwars.commands.args.CollectionArgParser;
import me.topchetoeu.bedwars.commands.args.CollectionProvider;
import me.topchetoeu.bedwars.commands.args.EnumArgParser;
import me.topchetoeu.bedwars.commands.args.IntArgParser;
import me.topchetoeu.bedwars.commands.args.LiteralArgParser;
import me.topchetoeu.bedwars.commands.args.LocationArgParser;
import me.topchetoeu.bedwars.commands.args.PlayerArgParser;
import me.topchetoeu.bedwars.commands.args.StringArgParser;
import me.topchetoeu.bedwars.commands.args.Suggestions;
import me.topchetoeu.bedwars.permissions.Permissions;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.ComponentBuilder;
public class Command {
private String name;
private String helpMessage;
private CommandExecutor executor;
private HashSet<Command> children = new HashSet<>();
private ArgParser parser;
private boolean recursive = false;
private String requiredPermission = null;
private Set<JavaPlugin> parents = new HashSet<>();
public String getName() {
return name;
}
public boolean attachedToAnyPlugin() {
return parents.size() > 0;
}
public Set<JavaPlugin> getParentPlugins() {
return Collections.unmodifiableSet(parents);
}
public ArgParser getParser() {
return parser;
}
public String getHelpMessage() {
return helpMessage;
}
public Command setHelpMessage(String val) {
helpMessage = val;
return this;
}
public String getRequiredPermission() {
return requiredPermission;
}
public Command permission(String wildcard) {
requiredPermission = wildcard;
return this;
}
public CommandExecutor getExecutor() {
return executor;
}
public Command setExecutor(CommandExecutor val) {
executor = val;
return this;
}
public Command addChild(Command cmd) {
if (cmd == null) throw new RuntimeException("cmd is null");
children.add(cmd);
return cmd;
}
public Command removeChild(Command cmd) {
if (cmd == null) throw new RuntimeException("cmd is null");
children.remove(cmd);
return this;
}
public boolean hasChild(Command cmd) {
if (cmd == null) return false;
return children.contains(cmd);
}
public Set<Command> getChildren() {
return Collections.unmodifiableSet(children);
}
public Command setRecursive(boolean val) {
recursive = val;
return this;
}
public boolean isRecursive() {
return recursive;
}
@SuppressWarnings("unchecked")
public void execute(CommandSender sender, String[] _args) {
Command toExecute = this;
Hashtable<String, Object> newArgs = new Hashtable<>();
List<String> args = new ArrayList<>();
Collections.addAll(args, _args);
String err = null;
while (args.size() > 0) {
Command newCmd = null;
Set<Command> children = toExecute.getChildren();
if (toExecute.isRecursive()) children = Collections.singleton(toExecute);
for (Command cmd : children) {
ArgParser parser = cmd.getParser();
ArgParserRes res = parser.parse(sender, args);
if (res.hasError()) err = res.getError();
else if (res.hasSucceeded()) {
for (int i = 0; i < res.getTakenCount(); i++) {
if (args.size() == 0) break;
args.remove(0);
}
if (res.hasResult()) {
if (cmd.recursive) {
if (!newArgs.containsKey(cmd.name)) newArgs.put(cmd.name, new ArrayList<>());
((List<Object>)newArgs.get(cmd.name)).add(res.getResult());
}
else newArgs.put(cmd.name, res.getResult());
}
newCmd = cmd;
if (cmd.requiredPermission != null) {
if (!Permissions.hasPermission(sender, cmd.requiredPermission))
err = "You don't have enough permissions to do that.";
}
break;
}
}
if (newCmd == null) {
toExecute = null;
break;
}
toExecute = newCmd;
if (err != null) break;
}
if (err == null) {
if (toExecute == null) err = "Invalid command syntax.";
else if (toExecute.getExecutor() == null) err = "Incomplete command.";
}
if (err != null) sender.spigot().sendMessage(new ComponentBuilder()
.append("Error: ")
.color(ChatColor.DARK_RED)
.append(err)
.color(ChatColor.RED)
.create()
);
else {
if (toExecute.isRecursive() && !newArgs.containsKey(toExecute.name)) newArgs.put(toExecute.name, new ArrayList<>());
BaseComponent[] _err = toExecute.getExecutor().execute(sender, this, newArgs);
if (_err != null && _err.length > 0) sender.spigot().sendMessage(new ComponentBuilder()
.append("Error: ")
.color(ChatColor.DARK_RED)
.append(err)
.reset()
.create()
);
}
}
public List<String> tabComplete(CommandSender sender, String[] _args) {
Command toComplete = this;
List<String> args = new ArrayList<>();
Collections.addAll(args, _args);
int index = 1;
while (args.size() > 0) {
boolean found = false;
index++;
for (Command cmd : toComplete.children) {
ArgParser parser = cmd.getParser();
ArgParserRes res = parser.parse(sender, args);
if (res.hasSucceeded()) {
for (int i = 0; i < res.getTakenCount(); i++) {
if (args.size() == 0) break;
args.remove(0);
}
toComplete = cmd;
found = true;
break;
}
}
if (!found) break;
}
if (args.size() == 0) return null;
Suggestions suggestions = new Suggestions();
for (Command cmd : toComplete.children) {
cmd.getParser().addCompleteSuggestions(sender, args, suggestions);
}
if (suggestions.hasError() && !suggestions.getSuggestions().contains(args.get(0))) {
sender.spigot().sendMessage(new ComponentBuilder()
.append("Error (argument %d): ".formatted(index + 1))
.color(ChatColor.DARK_RED)
.append(suggestions.getError())
.color(ChatColor.RED)
.create()
);
return null;
}
else {
List<String> _suggestions = new ArrayList<>(suggestions.getSuggestions());
return _suggestions;
}
}
public Command register(JavaPlugin pl) {
if (!(parser instanceof LiteralArgParser))
throw new IllegalArgumentException("Only a command with a literal parser may be registered.");
if (parents.contains(pl)) throw new IllegalArgumentException("The command is already attached to the given plugin");
if (pl == null) throw new RuntimeException("pl is null");
parents.add(pl);
LiteralArgParser parser = (LiteralArgParser)this.parser;
String name = parser.getLiteral();
pl.getCommand(name).setAliases(parser.getAliases());
pl.getCommand(name).setExecutor((sender, cmd, alias, args) -> {
execute(sender, args);
return true;
});
pl.getCommand(name).setTabCompleter((sender, cmd, alias, args) -> {
return tabComplete(sender, args);
});
return this;
}
public Command(String name, ArgParser parser) {
this.name = name;
this.parser = parser;
}
public Command literal(String name) {
Command cmd = createLiteral(name);
addChild(cmd);
return cmd;
}
public Command literal(String name, String ...aliases) {
Command cmd = createLiteral(name, aliases);
addChild(cmd);
return cmd;
}
public Command location(String name) {
Command cmd = createLocation(name);
addChild(cmd);
return cmd;
}
public Command _enum(String name, Class<? extends Enum<?>> enumType, boolean caseInsensitive) {
Command cmd = createEnum(name, enumType, caseInsensitive);
addChild(cmd);
return cmd;
}
public Command player(String name, boolean caseInsensitive) {
Command cmd = createPlayer(name, caseInsensitive);
addChild(cmd);
return cmd;
}
public Command string(String name, boolean greedy) {
Command cmd = createString(name, greedy);
addChild(cmd);
return cmd;
}
public Command _int(String name) {
Command cmd = createInt(name);
addChild(cmd);
return cmd;
}
public Command collection(String name, SimpleCollectionQuery query, boolean caseInsensitive) {
Command cmd = createCollection(name, query, caseInsensitive);
addChild(cmd);
return cmd;
}
public Command collection(String name, CollectionProvider provider, boolean caseInsensitive) {
Command cmd = createCollection(name, provider, caseInsensitive);
addChild(cmd);
return cmd;
}
public static Command createCollection(String name, SimpleCollectionQuery query, boolean caseInsensitive) {
return new Command(name, new CollectionArgParser(
() -> query.get().stream().collect(Collectors.toMap(v->v, v->v)),
caseInsensitive)
);
}
public static Command createCollection(String name, CollectionProvider provider, boolean caseInsensitive) {
return new Command(name, new CollectionArgParser(provider, caseInsensitive));
}
public static Command createPlayer(String name, boolean caseInsensitive) {
return new Command(name, new PlayerArgParser(caseInsensitive));
}
public static Command createEnum(String name, Class<? extends Enum<?>> enumType, boolean caseInsensitive) {
return new Command(name, new EnumArgParser(enumType, caseInsensitive));
}
public static Command createString(String name, boolean greedy) {
return new Command(name, new StringArgParser(greedy));
}
public static Command createInt(String name) {
return new Command(name, new IntArgParser());
}
public static Command createLocation(String name) {
return new Command(name, new LocationArgParser());
}
public static Command createLiteral(String lit) {
return new Command(lit, new LiteralArgParser(lit));
}
public static Command createLiteral(String lit, String ...aliases) {
return new Command(lit, new LiteralArgParser(lit, aliases));
}
public interface SimpleCollectionQuery {
Collection<String> get();
}
}

11
src/main/java/me/topchetoeu/bedwars/commands/CommandExecutor.java Normal file
View File

@ -0,0 +1,11 @@
package me.topchetoeu.bedwars.commands;
import java.util.Map;
import org.bukkit.command.CommandSender;
import net.md_5.bungee.api.chat.BaseComponent;
public interface CommandExecutor {
BaseComponent[] execute(CommandSender sender, Command cmd, Map<String, Object> args);
}

96
src/main/java/me/topchetoeu/bedwars/commands/CommandExecutors.java Normal file
View File

@ -0,0 +1,96 @@
package me.topchetoeu.bedwars.commands;
import java.util.ArrayList;
import java.util.List;
import me.topchetoeu.bedwars.commands.args.LiteralArgParser;
import net.md_5.bungee.api.chat.ComponentBuilder;
public class CommandExecutors {
// private static List<String> getSyntaxes(Command cmd) {
// ArrayList<String> syntaxes = new ArrayList<>();
// for (Command child : cmd.getChildren()) {
// ArgParser parser = child.getParser();
// if (parser instanceof LiteralArgParser) {
// }
// }
// return null;
// }
@SuppressWarnings("unchecked")
public static CommandExecutor help() {
return (sender, cmd, _args) -> {
List<String> args = (List<String>)_args.get("args");
if (args == null) args = new ArrayList<>();
String path = "/" + cmd.getName();
Command currCmd = cmd;
while (args.size() > 0) {
Command next = null;
for (Command child : currCmd.getChildren()) {
if (child.getParser() instanceof LiteralArgParser && child.getParser().parse(sender, args).hasSucceeded()) {
next = child;
break;
}
}
if (next == null) break;
currCmd = next;
path += " " + args.get(0);
args.remove(0);
}
cmd = currCmd;
LiteralArgParser cmdParser = (LiteralArgParser)cmd.getParser();
sender.spigot().sendMessage(new ComponentBuilder()
.append("Help for %s: ".formatted(path))
.bold(true)
.create()
);
if (cmd.getHelpMessage() != null) sender.spigot().sendMessage(new ComponentBuilder()
.append(" " + cmd.getHelpMessage())
.create()
);
sender.spigot().sendMessage(new ComponentBuilder()
.append(" Aliases: ")
.bold(true)
.append(String.join(", ", cmdParser.getAliases()))
.bold(false)
.create()
);
sender.spigot().sendMessage(new ComponentBuilder()
.append(" Subcommands: ")
.bold(true)
.create()
);
for (Command child : currCmd.getChildren()) {
if (child.getParser() instanceof LiteralArgParser) {
sender.spigot().sendMessage(new ComponentBuilder()
.append(" %s: ".formatted(((LiteralArgParser)child.getParser()).getLiteral()))
.bold(true)
.append(child.getHelpMessage() != null ? child.getHelpMessage() : "No help provided.")
.bold(false)
.create()
);
}
}
return null;
};
}
public static CommandExecutor message(String msg) {
return (sender, cmd, args) -> {
sender.sendMessage(msg);
return null;
};
}
}

10
src/main/java/me/topchetoeu/bedwars/commands/args/ArgParser.java Normal file
View File

@ -0,0 +1,10 @@
package me.topchetoeu.bedwars.commands.args;
import java.util.List;
import org.bukkit.command.CommandSender;
public interface ArgParser {
ArgParserRes parse(CommandSender sender, List<String> remainingArgs);
void addCompleteSuggestions(CommandSender sender, List<String> args, Suggestions suggestions);
}

71
src/main/java/me/topchetoeu/bedwars/commands/args/ArgParserRes.java Normal file
View File

@ -0,0 +1,71 @@
package me.topchetoeu.bedwars.commands.args;
public class ArgParserRes {
private int takenCount;
private Object res;
private boolean failed;
private String error;
public int getTakenCount() {
return takenCount;
}
public Object getResult() {
return res;
}
public String getError() {
return error;
}
public boolean takenAny() {
return takenCount > 0;
}
public boolean hasResult() {
return res != null;
}
public boolean hasFailed() {
return failed;
}
public boolean hasSucceeded() {
return !failed;
}
public boolean hasError() {
return error != null && !error.isEmpty();
}
private ArgParserRes(int takenCount, Object res, String error, boolean failed) {
this.takenCount = takenCount;
this.res = res;
this.failed = failed;
this.error = error;
}
public static ArgParserRes error(String error) {
if (error == null || error.isEmpty()) error = "An error ocurred while paring the arguments";
return new ArgParserRes(0, null, error, true);
}
public static ArgParserRes fail() {
return new ArgParserRes(0, null, null, true);
}
public static ArgParserRes takenNone() {
return takenNone(null);
}
public static ArgParserRes takenOne() {
return takenOne(null);
}
public static ArgParserRes takenMany(int count) {
return takenMany(count, null);
}
public static ArgParserRes takenNone(Object res) {
return new ArgParserRes(0, res, null, false);
}
public static ArgParserRes takenOne(Object res) {
return new ArgParserRes(1, res, null, false);
}
public static ArgParserRes takenMany(int count, Object res) {
if (count < 1) return takenNone(res);
return new ArgParserRes(count, res, null, false);
}
}

61
src/main/java/me/topchetoeu/bedwars/commands/args/CollectionArgParser.java Normal file
View File

@ -0,0 +1,61 @@
package me.topchetoeu.bedwars.commands.args;
import java.util.List;
import java.util.Map;
import org.bukkit.command.CommandSender;
public class CollectionArgParser implements ArgParser {
private final boolean caseInsensitive;
private final CollectionProvider provider;
public boolean isCaseInsensitive() {
return caseInsensitive;
}
public boolean isCaseSensitive() {
return !caseInsensitive;
}
public CollectionProvider getProvider() {
return provider;
}
@Override
public ArgParserRes parse(CommandSender sender, List<String> remainingArgs) {
String arg = remainingArgs.get(0);
Map<String, Object> map = provider.get();
if (caseInsensitive) arg = arg.toLowerCase();
if (map.containsKey(arg)) return ArgParserRes.takenOne(map.get(arg));
else return ArgParserRes.error("Unknown element '" + arg + "'.");
}
public CollectionArgParser addElement(String element, Object parsesTo) {
if (caseInsensitive) element = element.toLowerCase();
Map<String, Object> map = provider.get();
map.put(element, parsesTo);
return this;
}
public CollectionArgParser addElements(Map<String, Object> parseTable) {
for (Map.Entry<String, Object> a : parseTable.entrySet()) {
if (caseInsensitive) addElement(a.getKey().toLowerCase(), a.getValue());
else addElement(a.getKey(), a.getValue());
}
return this;
}
@Override
public void addCompleteSuggestions(CommandSender sender, List<String> args, Suggestions suggestions) {
String arg;
if (caseInsensitive) arg = args.get(0).toLowerCase();
else arg = args.get(0);
Map<String, Object> map = provider.get();
List<String> _suggestions = map.keySet().stream().filter(v -> v.startsWith(arg)).toList();
suggestions.addSuggestions(_suggestions);
if (_suggestions.size() == 0) suggestions.error("Unknown element '" + arg + "'.");
}
public CollectionArgParser(CollectionProvider provider, boolean caseInsensitive) {
this.provider = provider;
this.caseInsensitive = caseInsensitive;
}
}

7
src/main/java/me/topchetoeu/bedwars/commands/args/CollectionProvider.java Normal file
View File

@ -0,0 +1,7 @@
package me.topchetoeu.bedwars.commands.args;
import java.util.Map;
public interface CollectionProvider {
Map<String, Object> get();
}

24
src/main/java/me/topchetoeu/bedwars/commands/args/EnumArgParser.java Normal file
View File

@ -0,0 +1,24 @@
package me.topchetoeu.bedwars.commands.args;
import java.util.Hashtable;
import java.util.Map;
public class EnumArgParser extends StaticCollectionArgParser {
private static Map<String, Object> getCol(Class<? extends Enum<?>> enumType, boolean caseInsensitive) {
Map<String, Object> map = new Hashtable<>();
if (enumType.getEnumConstants() != null) {
for (Enum<?> c : enumType.getEnumConstants()) {
if (caseInsensitive) map.put(c.name().toLowerCase(), c);
else map.put(c.name(), c);
}
}
return map;
}
public EnumArgParser(Class<? extends Enum<?>> enumType, boolean caseInsensitive) {
super(getCol(enumType, caseInsensitive), caseInsensitive);
}
}

22
src/main/java/me/topchetoeu/bedwars/commands/args/IntArgParser.java Normal file
View File

@ -0,0 +1,22 @@
package me.topchetoeu.bedwars.commands.args;
import java.util.List;
import org.bukkit.command.CommandSender;
public class IntArgParser implements ArgParser {
@Override
public ArgParserRes parse(CommandSender sender, List<String> remainingArgs) {
try {
return ArgParserRes.takenOne(Integer.parseInt(remainingArgs.get(0)));
}
catch (NumberFormatException e) {
return ArgParserRes.error("Invalid number format.");
}
}
@Override
public void addCompleteSuggestions(CommandSender sender, List<String> args, Suggestions suggestions) {
suggestions.addSuggestion("0");
}
}

46
src/main/java/me/topchetoeu/bedwars/commands/args/LiteralArgParser.java Normal file
View File

@ -0,0 +1,46 @@
package me.topchetoeu.bedwars.commands.args;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.bukkit.command.CommandSender;
public class LiteralArgParser implements ArgParser {
private final String literal;
private final List<String> aliases = new ArrayList<>();
public String getLiteral() {
return literal;
}
public List<String> getAliases() {
return Collections.unmodifiableList(aliases);
}
@Override
public ArgParserRes parse(CommandSender sender, List<String> remainingArgs) {
if (!remainingArgs.get(0).equals(literal) && !aliases.contains(remainingArgs.get(0))) return ArgParserRes.fail();
else return ArgParserRes.takenOne();
}
@Override
public void addCompleteSuggestions(CommandSender sender, List<String> args, Suggestions elements) {
String arg = args.get(0);
elements.addSuggestions(aliases.stream().filter(v -> v.startsWith(arg)));
if (literal.startsWith(arg)) elements.addSuggestion(literal);
}
public LiteralArgParser(String lit) {
this.literal = lit;
}
public LiteralArgParser(String lit, String ...aliases) {
this.literal = lit;
Collections.addAll(this.aliases, aliases);
}
public LiteralArgParser(String lit, Collection<String> aliases) {
this.literal = lit;
this.aliases.addAll(aliases);
}
}

103
src/main/java/me/topchetoeu/bedwars/commands/args/LocationArgParser.java Normal file
View File

@ -0,0 +1,103 @@
package me.topchetoeu.bedwars.commands.args;
import java.util.List;
import org.bukkit.Location;
import org.bukkit.command.BlockCommandSender;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.LivingEntity;
public class LocationArgParser implements ArgParser {
@Override
public ArgParserRes parse(CommandSender sender, List<String> remainingArgs) {
if (remainingArgs.size() < 3) return ArgParserRes.fail();
else {
Location loc = null;
if (sender instanceof LivingEntity) loc = ((LivingEntity)sender).getLocation();
else if (sender instanceof BlockCommandSender) loc = ((BlockCommandSender)sender).getBlock().getLocation();
else return ArgParserRes.error("Coordinates may not be specified by a non-located command sender.");
String rawX = remainingArgs.get(0),
rawY = remainingArgs.get(1),
rawZ = remainingArgs.get(2);
boolean relX = false, relY = false, relZ = false;
if (rawX.startsWith("~")) {
relX = true;
rawX = rawX.substring(1);
if (rawX.isEmpty()) rawX = "0";
}
if (rawY.startsWith("~")) {
relY = true;
rawY = rawY.substring(1);
if (rawY.isEmpty()) rawY = "0";
}
if (rawZ.startsWith("~")) {
relZ = true;
rawZ = rawZ.substring(1);
if (rawZ.isEmpty()) rawZ = "0";
}
double x, y, z;
try {
x = Double.parseDouble(rawX);
y = Double.parseDouble(rawY);
z = Double.parseDouble(rawZ);
} catch(NumberFormatException e) {
return ArgParserRes.error("Invalid number format.");
}
if (relX) x += loc.getX();
if (relY) y += loc.getY();
if (relZ) z += loc.getZ();
return ArgParserRes.takenMany(3, new Location(loc.getWorld(), x, y, z));
}
}
private void addSuggestions(String arg, Double curr, Suggestions suggestions) {
if (arg.isEmpty()) {
suggestions.addSuggestions("~", curr.toString(), Double.toString(Math.floor(curr)), Double.toString(Math.floor(curr) + 0.5));
}
else if (arg.startsWith("~")) {
arg = arg.substring(1);
suggestions.addSuggestions("~" + arg, "~" + ".5");
}
else suggestions.addSuggestion(arg);
if (arg.length() > 0) {
try {
Double.parseDouble(arg);
}
catch (NumberFormatException e) {
suggestions.error("Number is in an invalid format.");
}
}
}
@Override
public void addCompleteSuggestions(CommandSender sender, List<String> args, Suggestions suggestions) {
Location loc = null;
if (sender instanceof LivingEntity) loc = ((LivingEntity)sender).getLocation();
else if (sender instanceof BlockCommandSender) loc = ((BlockCommandSender)sender).getBlock().getLocation();
else {
suggestions.error("Only located command senders may use locations.");
return;
}
double curr = loc.getZ();
if (args.size() < 3) curr = loc.getY();
if (args.size() < 2) curr = loc.getX();
String arg = args.get(args.size() - 1);
addSuggestions(arg, curr, suggestions);
}
public LocationArgParser() {
}
}

13
src/main/java/me/topchetoeu/bedwars/commands/args/PlayerArgParser.java Normal file
View File

@ -0,0 +1,13 @@
package me.topchetoeu.bedwars.commands.args;
import java.util.stream.Collectors;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
public class PlayerArgParser extends CollectionArgParser {
public PlayerArgParser(boolean caseInsensitive) {
super(() -> Bukkit.getOnlinePlayers().stream().collect(Collectors.toMap(Player::getName, v->v)), caseInsensitive);
}
}

17
src/main/java/me/topchetoeu/bedwars/commands/args/StaticCollectionArgParser.java Normal file
View File

@ -0,0 +1,17 @@
package me.topchetoeu.bedwars.commands.args;
import java.util.Collections;
import java.util.Map;
public class StaticCollectionArgParser extends CollectionArgParser {
private Map<String, Object> map;
public Map<String, Object> getMap() {
return Collections.unmodifiableMap(map);
}
public StaticCollectionArgParser(Map<String, Object> map, boolean caseInsensitive) {
super(() -> map, caseInsensitive);
this.map = map;
}
}

27
src/main/java/me/topchetoeu/bedwars/commands/args/StringArgParser.java Normal file
View File

@ -0,0 +1,27 @@
package me.topchetoeu.bedwars.commands.args;
import java.util.List;
import org.bukkit.command.CommandSender;
public class StringArgParser implements ArgParser {
private final boolean greeedy;
public boolean isGreedy() {
return greeedy;
}
@Override
public ArgParserRes parse(CommandSender sender, List<String> remainingArgs) {
if (greeedy) return ArgParserRes.takenMany(remainingArgs.size(), String.join(" ", remainingArgs));
else return ArgParserRes.takenOne(remainingArgs.get(0));
}
@Override
public void addCompleteSuggestions(CommandSender sender, List<String> args, Suggestions suggestions) {
}
public StringArgParser(boolean greedy) {
greeedy = greedy;
}
}

49
src/main/java/me/topchetoeu/bedwars/commands/args/Suggestions.java Normal file
View File

@ -0,0 +1,49 @@
package me.topchetoeu.bedwars.commands.args;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
public class Suggestions {
private final List<String> suggestions = new ArrayList<>();
private String error = null;
public boolean addSuggestion(String suggestion) {
return suggestions.add(suggestion);
}
public void addSuggestions(Collection<String> suggestions) {
for (String suggestion : suggestions) addSuggestion(suggestion);
}
public void addSuggestions(String ...suggestions) {
Collections.addAll(this.suggestions, suggestions);
}
public void addSuggestions(Stream<String> suggestions) {
this.suggestions.addAll(suggestions.toList());
}
public boolean hasSuggestion(String suggestion) {
return suggestions.contains(suggestion);
}
public List<String> getSuggestions() {
return Collections.unmodifiableList(suggestions);
}
public void error(String error) {
if (error == null || error.trim().isEmpty()) return;
this.error = error;
}
public boolean hasError() {
return error != null;
}
public String getError() {
return error;
}
public Suggestions(List<String> suggestions) {
this.suggestions.addAll(suggestions);
}
public Suggestions() {
}
}

31
src/main/java/me/topchetoeu/bedwars/engine/AttackCooldownEradicator.java Normal file
View File

@ -0,0 +1,31 @@
package me.topchetoeu.bedwars.engine;
import org.bukkit.Bukkit;
import org.bukkit.attribute.Attribute;
import org.bukkit.attribute.AttributeInstance;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.plugin.java.JavaPlugin;
public class AttackCooldownEradicator implements Listener{
@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerLogin(PlayerJoinEvent e){
setAttackSpeed(e.getPlayer(), 32);
}
private void setAttackSpeed(Player player, double attackSpeed){
AttributeInstance attribute = player.getAttribute(Attribute.GENERIC_ATTACK_SPEED);
attribute.setBaseValue(attackSpeed);
player.saveData();
}
public static AttackCooldownEradicator init(JavaPlugin pl) {
AttackCooldownEradicator instance = new AttackCooldownEradicator();
Bukkit.getPluginManager().registerEvents(instance, pl);
return instance;
}
}

95
src/main/java/me/topchetoeu/bedwars/engine/BedwarsPlayer.java
View File

@ -1,20 +1,27 @@
package me.topchetoeu.bedwars.engine;
package me.topchetoeu.bedwars.engine;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import com.mojang.datafixers.util.Pair;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.OfflinePlayer;
import org.bukkit.Sound;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftItemStack;
import org.bukkit.attribute.Attribute;
import org.bukkit.attribute.AttributeInstance;
import org.bukkit.craftbukkit.v1_18_R1.entity.CraftPlayer;
import org.bukkit.craftbukkit.v1_18_R1.inventory.CraftItemStack;
import me.topchetoeu.bedwars.Utility;
import me.topchetoeu.bedwars.engine.trader.dealTypes.RankedDealType;
import net.minecraft.server.v1_8_R3.EntityPlayer;
import net.minecraft.server.v1_8_R3.PacketPlayOutEntityEquipment;
import me.topchetoeu.bedwars.messaging.MessageUtility;
import net.minecraft.network.protocol.game.PacketPlayOutEntityEquipment;
import net.minecraft.world.entity.EnumItemSlot;
import org.bukkit.entity.Explosive;
import org.bukkit.entity.Fireball;
@ -32,7 +39,7 @@ import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerItemConsumeEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
import org.bukkit.event.entity.EntityPickupItemEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
@ -68,26 +75,28 @@ public class BedwarsPlayer implements Listener, AutoCloseable {
private OfflinePlayer offender = null;
private void updateInvisibility(Player p) {
net.minecraft.server.v1_8_R3.ItemStack helmetItem = CraftItemStack.asNMSCopy(getOnlinePlayer().getInventory().getHelmet());
net.minecraft.server.v1_8_R3.ItemStack chestplateItem = CraftItemStack.asNMSCopy(getOnlinePlayer().getInventory().getChestplate());
net.minecraft.server.v1_8_R3.ItemStack leggingsItem = CraftItemStack.asNMSCopy(getOnlinePlayer().getInventory().getLeggings());
net.minecraft.server.v1_8_R3.ItemStack bootsItem = CraftItemStack.asNMSCopy(getOnlinePlayer().getInventory().getBoots());
net.minecraft.world.item.ItemStack helmetItem = CraftItemStack.asNMSCopy(getOnlinePlayer().getInventory().getHelmet());
net.minecraft.world.item.ItemStack chestplateItem = CraftItemStack.asNMSCopy(getOnlinePlayer().getInventory().getChestplate());
net.minecraft.world.item.ItemStack leggingsItem = CraftItemStack.asNMSCopy(getOnlinePlayer().getInventory().getLeggings());
net.minecraft.world.item.ItemStack bootsItem = CraftItemStack.asNMSCopy(getOnlinePlayer().getInventory().getBoots());
if (invisible) {
helmetItem = chestplateItem = leggingsItem = bootsItem = null;
}
List<Pair<EnumItemSlot, net.minecraft.world.item.ItemStack>> items = new ArrayList<>();
items.add(new Pair<EnumItemSlot,net.minecraft.world.item.ItemStack>(EnumItemSlot.c, helmetItem));
items.add(new Pair<EnumItemSlot,net.minecraft.world.item.ItemStack>(EnumItemSlot.d, chestplateItem));
items.add(new Pair<EnumItemSlot,net.minecraft.world.item.ItemStack>(EnumItemSlot.e, leggingsItem));
items.add(new Pair<EnumItemSlot,net.minecraft.world.item.ItemStack>(EnumItemSlot.f, bootsItem));
int id = getOnlinePlayer().getEntityId();
PacketPlayOutEntityEquipment helmet = new PacketPlayOutEntityEquipment(id, 1, helmetItem);
PacketPlayOutEntityEquipment chestplate = new PacketPlayOutEntityEquipment(id, 2, chestplateItem);
PacketPlayOutEntityEquipment leggings = new PacketPlayOutEntityEquipment(id, 3, leggingsItem);
PacketPlayOutEntityEquipment boots = new PacketPlayOutEntityEquipment(id, 4, bootsItem);
EntityPlayer handle = ((CraftPlayer)p).getHandle();
PacketPlayOutEntityEquipment packet = new PacketPlayOutEntityEquipment(id, items);
handle.playerConnection.sendPacket(helmet);
handle.playerConnection.sendPacket(chestplate);
handle.playerConnection.sendPacket(leggings);
handle.playerConnection.sendPacket(boots);
((CraftPlayer)p).getHandle().b.a(packet);
}
private void updateInvisiblity() {
@ -207,8 +216,8 @@ public class BedwarsPlayer implements Listener, AutoCloseable {
reviveTask = null;
}
Utility.sendTitle(player.getPlayer(),
"You died!",
String.format("Respawning in %.2f", revivalTimer),
MessageUtility.parser("player.died.title").parse(),
MessageUtility.parser("player.died.subtitle").variable("time", "%.2f".formatted(revivalTimer)).parse(),
0, 4, 5
);
revivalTimer -= 0.1;
@ -253,7 +262,6 @@ public class BedwarsPlayer implements Listener, AutoCloseable {
}
else revivalPending = true;
}
@SuppressWarnings("deprecation")
public void eliminate() {
if (spectator) return;
if (!dead) {
@ -265,17 +273,30 @@ public class BedwarsPlayer implements Listener, AutoCloseable {
Bukkit.getServer().broadcastMessage(String.format("%s was eliminated.", player.getName()));
if (team.decreaseRemainingPlayers() > 0) {
// TODO fix these messages
// Also, this deprecation is just fine :)
player.getPlayer().sendTitle("You are dead", "You can only spectate your more intelligent friends");
Utility.sendTitle(
getOnlinePlayer(),
MessageUtility.parser("player.solo.eliminated.title").parse(),
MessageUtility.parser("player.solo.eliminated.subtitle").parse(),
5, 40, 10
);
}
else
Bukkit.getServer().broadcastMessage(String.format("Team %s was eliminated.", team.getTeamColor().getName()));
if (team.getPlayersCount() == 1) {
player.getPlayer().sendTitle("You were eliminated!", "Now you can spectate");
Utility.sendTitle(
getOnlinePlayer(),
MessageUtility.parser("player.solo.eliminated.title").parse(),
MessageUtility.parser("player.solo.eliminated.subtitle").parse(),
5, 40, 10
);
}
else
player.getPlayer().sendTitle("Your team was eliminated", "Your team fucked up bad time :(");
Utility.sendTitle(
getOnlinePlayer(),
MessageUtility.parser("player.team.eliminated.title").parse(),
MessageUtility.parser("player.team.eliminated.subtitle").parse(),
5, 40, 10
);
spectator = true;
}
@ -338,6 +359,9 @@ public class BedwarsPlayer implements Listener, AutoCloseable {
if (e.getEntity() instanceof Player) {
Player p = (Player)e.getEntity();
if (equals(p)) {
AttributeInstance attribute = p.getAttribute(Attribute.GENERIC_ATTACK_SPEED);
attribute.setBaseValue(16);
p.saveData();
if (e.getDamager() instanceof Player) {
offender = (OfflinePlayer)e.getDamager();
}
@ -396,7 +420,7 @@ public class BedwarsPlayer implements Listener, AutoCloseable {
if (e.getPlayer().getUniqueId().equals(player.getUniqueId())) {
if (e.getTo().getY() < 40) {
e.setTo(e.getTo().add(0, 100, 0));
e.getPlayer().playSound(e.getTo(), Sound.HURT_FLESH, 1, 1);
e.getPlayer().playSound(e.getTo(), Sound.ENTITY_PLAYER_HURT, 1, 1);
kill(DeathMessage.getMessage(DamageCause.VOID, player, offender, deathMessages));
}
}
@ -405,14 +429,17 @@ public class BedwarsPlayer implements Listener, AutoCloseable {
@EventHandler
private void onThrow(PlayerDropItemEvent e) {
if (equals(e.getPlayer())) {
if (e.getItemDrop().getItemStack().getType() == Material.WOOD_SWORD) e.setCancelled(true);
if (e.getItemDrop().getItemStack().getType() == Material.WOODEN_SWORD) e.setCancelled(true);
else WoodenSword.update(this, e.getPlayer().getInventory());
}
}
@EventHandler
private void onPickup(PlayerPickupItemEvent e) {
private void onPickup(EntityPickupItemEvent e) {
if (e.getEntity() instanceof Player) {
Player p = (Player)e.getEntity();
if (WoodenSword.isOtherSword(e.getItem().getItemStack().getType()))
e.getPlayer().getInventory().remove(Material.WOOD_SWORD);
p.getInventory().remove(Material.WOODEN_SWORD);
}
}
@EventHandler
private void onConsume(PlayerItemConsumeEvent e) {
@ -439,7 +466,7 @@ public class BedwarsPlayer implements Listener, AutoCloseable {
}
});
e.getPlayer().getInventory().setItemInHand(null);
e.getItem().setType(Material.AIR);
e.setCancelled(true);
}
}
@ -448,10 +475,10 @@ public class BedwarsPlayer implements Listener, AutoCloseable {
@EventHandler
private void onInventory(InventoryClickEvent e) {
if (e.getCursor() != null && e.getCursor().getType() == Material.WOOD_SWORD) {
if (e.getCursor() != null && e.getCursor().getType() == Material.WOODEN_SWORD) {
if (e.getClickedInventory() != e.getWhoClicked().getInventory()) e.setCancelled(true);
}
else if (e.getCurrentItem() != null && e.getCurrentItem().getType() == Material.WOOD_SWORD) {
else if (e.getCurrentItem() != null && e.getCurrentItem().getType() == Material.WOODEN_SWORD) {
if (e.getClick() == ClickType.SHIFT_LEFT || e.getClick() == ClickType.SHIFT_RIGHT) e.setCancelled(true);
}
}

39
src/main/java/me/topchetoeu/bedwars/engine/Config.java
View File

@ -6,7 +6,6 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.bukkit.Location;
import org.bukkit.configuration.Configuration;
@ -18,9 +17,9 @@ public class Config {
private int perTeam = 0;
private Location respawnLocation;
private ArrayList<TeamColor> colors;
private ArrayList<Location> diamondGenerators;
private ArrayList<Location> emeraldGenerators;
private List<TeamColor> colors;
private List<Location> diamondGenerators;
private List<Location> emeraldGenerators;
public Location getRespawnLocation() {
return respawnLocation;
@ -36,18 +35,18 @@ public class Config {
perTeam = size;
}
public ArrayList<TeamColor> getColors() {
public List<TeamColor> getColors() {
return colors;
}
public TeamColor getColor(String name) {
return Config.instance.getColors()
return getColors()
.stream()
.filter(v -> v.getName().equals(name.toLowerCase()))
.findFirst()
.orElse(null);
}
public ArrayList<Location> getDiamondGenerators() {
public List<Location> getDiamondGenerators() {
return diamondGenerators;
}
public Location getClosestDiamondGenerator(Location loc) {
@ -72,7 +71,7 @@ public class Config {
.collect(Collectors.toList());
}
public ArrayList<Location> getEmeraldGenerators() {
public List<Location> getEmeraldGenerators() {
return emeraldGenerators;
}
public Location getClosestEmeraldGenerator(Location loc) {
@ -97,10 +96,6 @@ public class Config {
.collect(Collectors.toList());
}
private static ArrayList<?> toList(Stream<?> s) {
return new ArrayList<>(s.collect(Collectors.toList()));
}
@SuppressWarnings("unchecked")
public static void load(File confFile) {
Configuration conf = YamlConfiguration.loadConfiguration(confFile);
@ -109,21 +104,22 @@ public class Config {
c.perTeam = conf.getInt("perTeam");
if (conf.get("respawnLocation") != null) c.respawnLocation = Location.deserialize(conf.getConfigurationSection("respawnLocation").getValues(false));
c.colors = (ArrayList<TeamColor>)toList(conf
c.colors = new ArrayList<>(conf
.getMapList("colors")
.stream()
.map(v -> TeamColor.deserialize((Map<String, Object>)v))
);
c.diamondGenerators = (ArrayList<Location>)toList(conf
.toList());
c.diamondGenerators = new ArrayList<>(conf
.getMapList("diamondGenerators")
.stream()
.map(v -> Location.deserialize((Map<String, Object>)v))
);
c.emeraldGenerators = (ArrayList<Location>)toList(conf
.toList())
;
c.emeraldGenerators = new ArrayList<>(conf
.getMapList("emeraldGenerators")
.stream()
.map(v -> Location.deserialize((Map<String, Object>)v))
);
.toList());
instance = c;
}
@ -132,14 +128,13 @@ public class Config {
FileConfiguration conf = YamlConfiguration.loadConfiguration(confFile);
conf.set("perTeam", perTeam);
conf.set("colors", toList(colors.stream().map(v -> v.serialize())));
conf.set("diamondGenerators", toList(diamondGenerators.stream().map(v -> v.serialize())));
conf.set("emeraldGenerators", toList(emeraldGenerators.stream().map(v -> v.serialize())));
conf.set("colors", colors.stream().map(v -> v.serialize()).toList());
conf.set("diamondGenerators", diamondGenerators.stream().map(v -> v.serialize()).toList());
conf.set("emeraldGenerators", emeraldGenerators.stream().map(v -> v.serialize()).toList());
try {
conf.save(confFile);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

69
src/main/java/me/topchetoeu/bedwars/engine/Game.java
View File

@ -44,6 +44,9 @@ import org.bukkit.util.Vector;
import me.topchetoeu.bedwars.Main;
import me.topchetoeu.bedwars.Utility;
import me.topchetoeu.bedwars.engine.trader.dealTypes.RankedDealType;
import me.topchetoeu.bedwars.messaging.MessageUtility;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
public class Game implements Listener, AutoCloseable {
public static Game instance = null;
@ -76,8 +79,8 @@ public class Game implements Listener, AutoCloseable {
ScoreboardManager.updateAll();
}
public static void stop(boolean immediatly) {
if (immediatly) stop();
public static void stop(boolean immediately) {
if (immediately) stop();
else Bukkit.getScheduler().runTaskLater(Main.getInstance(), () -> stop(), 20 * 5);
}
public static boolean isStarted() {
@ -101,13 +104,21 @@ public class Game implements Listener, AutoCloseable {
}
public void win(TeamColor color) {
getTeam(color).sendTitle("You won!", "", 0, 20 * 5, 0);
getTeam(color).sendTilteToOthers(color.getColorName() + " won!", "You lost :(", 0, 20 * 5, 0);
getTeam(color).sendTitle(
MessageUtility.parser("player.won.title").parse(),
MessageUtility.parser("player.won.subtitle").parse(),
0, 20 * 5, 0
);
getTeam(color).sendTitleToOthers(
MessageUtility.parser("player.lost.title").variable("team", color.getColorName()).parse(),
MessageUtility.parser("player.lost.subtitle").variable("team", color.getColorName()).parse(),
0, 20 * 5, 0
);
stop(false);
}
public void breakBlock(Block block) {
SavedBlock bl = new SavedBlock(block.getLocation(), block.getState().getData(), block.getState().getType());
SavedBlock bl = new SavedBlock(block.getLocation(), block.getState().getBlockData(), block.getState().getType());
brokenBlocks.add(bl);
block.setType(Material.AIR, false);
}
@ -126,7 +137,7 @@ public class Game implements Listener, AutoCloseable {
}
public boolean allowBreak(Location loc) {
if (!isStarted()) return true;
return placedBlocks.contains(loc) || loc.getWorld().getBlockAt(loc).getType() == Material.BED_BLOCK;
return placedBlocks.contains(loc) || Utility.isBed(loc.getWorld().getBlockAt(loc));
}
public ArrayList<Team> getTeams() {
@ -172,7 +183,6 @@ public class Game implements Listener, AutoCloseable {
return getPlayer(p) != null;
}
@SuppressWarnings("deprecation")
public void close() {
for (Team team : teams) {
team.close();
@ -204,7 +214,7 @@ public class Game implements Listener, AutoCloseable {
}
for (SavedBlock brokenBlock : brokenBlocks) {
brokenBlock.loc.getBlock().setType(brokenBlock.type, false);
brokenBlock.loc.getBlock().setData(brokenBlock.meta.getData(), false);
brokenBlock.loc.getBlock().setBlockData(brokenBlock.meta, false);
}
placedBlocks.clear();
@ -224,10 +234,15 @@ public class Game implements Listener, AutoCloseable {
if(!isPlaying(e.getPlayer())) {
e.getPlayer().setGameMode(GameMode.SPECTATOR);
e.getPlayer().teleport(Bukkit.getServer().getWorlds().get(0).getSpawnLocation());
Utility.sendTitle(e.getPlayer(), "You are now spectating", null, 5, 35, 10);
Utility.sendTitle(
e.getPlayer(),
MessageUtility.parser("player.midgame-spectator.title").parse(),
MessageUtility.parser("player.midgame-spectator.subtitle").parse(),
5, 35, 10
);
}
else
e.setJoinMessage(e.getPlayer().getName() + " reconnected.");
e.setJoinMessage(BaseComponent.toLegacyText(MessageUtility.parser("player.reconnected").variable("name", e.getPlayer().getDisplayName()).parse()));
}
@EventHandler
private void onInventoryClick(InventoryClickEvent e) {
@ -242,7 +257,7 @@ public class Game implements Listener, AutoCloseable {
private static boolean isExceptional(Material mat) {
return mat == Material.LONG_GRASS || mat == Material.YELLOW_FLOWER || mat == Material.RED_ROSE;
return !mat.isSolid();
}
@EventHandler
@ -251,7 +266,7 @@ public class Game implements Listener, AutoCloseable {
b.getDrops().forEach(v -> b.getWorld().dropItemNaturally(b.getLocation().add(0.5, 0.5, 0.5), v));
breakBlock(b);
}
else if (b.getType() == Material.BED_BLOCK) {
else if (Utility.isBed(b)) {
return false;
}
else if (allowBreak(b.getLocation())) {
@ -311,20 +326,13 @@ public class Game implements Listener, AutoCloseable {
private void onBlockPlace(BlockPlaceEvent e) {
if (e.getBlock().getType() == Material.TNT) {
e.setCancelled(true);
ItemStack i = e.getPlayer().getItemInHand();
if (i.getAmount() == 0) e.getPlayer().setItemInHand(null);
else {
i.setAmount(i.getAmount() - 1);
e.getPlayer().setItemInHand(i);
}
Utility.takeOne(e.getPlayer(), e.getHand());
e.getBlock().getWorld().spawnEntity(e.getBlock().getLocation().add(.5, 0, .5), EntityType.PRIMED_TNT).setVelocity(new Vector(0, 0, 0));
}
else {
switch (e.getBlockReplacedState().getType()) {
case WATER:
case STATIONARY_WATER:
case LAVA:
case STATIONARY_LAVA:
if (!allowBreak(e.getBlock().getLocation())) e.setCancelled(true);
return;
case AIR:
@ -334,7 +342,7 @@ public class Game implements Listener, AutoCloseable {
}
break;
case GRASS:
case LONG_GRASS:
case TALL_GRASS:
break;
}
@ -357,21 +365,16 @@ public class Game implements Listener, AutoCloseable {
}
for (Player p : Bukkit.getOnlinePlayers()) {
p.playSound(e.getLocation(), Sound.EXPLODE, 1, 1);
p.playSound(e.getLocation(), Sound.ENTITY_GENERIC_EXPLODE, 1, 1);
}
}
@EventHandler
private void onUse(PlayerInteractEvent e) {
if (e.getAction() == Action.RIGHT_CLICK_AIR || e.getAction() == Action.RIGHT_CLICK_BLOCK) {
if (e.getItem() == null) return;
if (e.getItem().getType() == Material.FIREBALL) {
if (e.getItem().getType() == Material.FIRE_CHARGE) {
ItemStack i = e.getPlayer().getItemInHand();
if (i.getAmount() == 0) e.getPlayer().setItemInHand(null);
else {
i.setAmount(i.getAmount() - 1);
e.getPlayer().setItemInHand(i);
}
Utility.takeOne(e.getPlayer(), e.getHand());
Location loc = e.getPlayer().getEyeLocation();
@ -399,9 +402,9 @@ public class Game implements Listener, AutoCloseable {
spectators.add(removed);
if (removed.isOnline()) {
removed.getPlayer().setGameMode(GameMode.SPECTATOR);
removed.getPlayer().teleport(Config.instance.getRespawnLocation());
removed.getPlayer().teleport(new Location(removed.getPlayer().getLocation().getWorld(), 0, 80, 0));
}
if (removed.isOnline()) removed.getPlayer().sendMessage("You will be a spectator");
if (removed.isOnline()) MessageUtility.parser("player.will-be-spectator").send(removed.getPlayer());
}
}
@ -432,14 +435,14 @@ public class Game implements Listener, AutoCloseable {
// TODO: Make times configurable
for (Location loc : Config.instance.getDiamondGenerators()) {
GeneratorLabel label = new GeneratorLabel("§cDiamond Generator", loc.clone().add(0, 1, 0));
GeneratorLabel label = new GeneratorLabel(TextComponent.fromLegacyText("§cDiamond Generator"), loc.clone().add(0, 1, 0));
Generator gen = new Generator(loc, 4, label);
gen.addItem(Material.DIAMOND, 600);
diamondGens.add(gen);
}
for (Location loc : Config.instance.getEmeraldGenerators()) {
GeneratorLabel label = new GeneratorLabel("§cEmerald Generator", loc.clone().add(0, 1, 0));
GeneratorLabel label = new GeneratorLabel(TextComponent.fromLegacyText("§cEmerald Generator"), loc.clone().add(0, 1, 0));
Generator gen = new Generator(loc, 2, label);
gen.addItem(Material.EMERALD, 1200);

8
src/main/java/me/topchetoeu/bedwars/engine/Generator.java
View File

@ -17,7 +17,7 @@ import org.bukkit.event.EventHandler;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.ItemMergeEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
import org.bukkit.event.entity.EntityPickupItemEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.scheduler.BukkitTask;
import org.bukkit.util.Vector;
@ -102,7 +102,8 @@ public class Generator implements AutoCloseable, Listener {
}
@EventHandler
private void onPickup(PlayerPickupItemEvent e) {
private void onPickup(EntityPickupItemEvent e) {
if (e.getEntity() instanceof Player) {
if (generatedItems.contains(e.getItem().getUniqueId())) {
e.setCancelled(true);
@ -111,7 +112,7 @@ public class Generator implements AutoCloseable, Listener {
Player p = bwp.getOnlinePlayer();
if (p.getLocation().distance(e.getItem().getLocation()) < 2) {
p.playSound(e.getItem().getLocation(), Sound.ITEM_PICKUP, .5f, 2);
p.playSound(e.getItem().getLocation(), Sound.ENTITY_ITEM_PICKUP, .5f, 2);
p.getInventory().addItem(e.getItem().getItemStack());
}
}
@ -120,6 +121,7 @@ public class Generator implements AutoCloseable, Listener {
e.getItem().remove();
}
}
}
public void close() {
for (Material m : new ArrayList<>(itemGenerators.keySet())) {

12
src/main/java/me/topchetoeu/bedwars/engine/GeneratorLabel.java
View File

@ -7,10 +7,12 @@ import org.bukkit.Location;
import org.bukkit.Material;
import me.topchetoeu.bedwars.Utility;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.ComponentBuilder;
public class GeneratorLabel {
private HoverLabel label;
private String firstLine;
private BaseComponent[] firstLine;
private Hashtable<Material, Float> remainingTimes = new Hashtable<>();
@ -27,20 +29,20 @@ public class GeneratorLabel {
}
public void update() {
ArrayList<String> lines = new ArrayList<>();
ArrayList<BaseComponent[]> lines = new ArrayList<>();
lines.add(firstLine);
lines.add(null);
for (Material item : remainingTimes.keySet()) {
lines.add(String.format("%s in %.2f seconds", Utility.getItemName(item), remainingTimes.get(item)));
lines.add(new ComponentBuilder().append(Utility.getItemName(item)).append(" in %.2f seconds".formatted(remainingTimes.get(item))).create());
}
label.setData(lines);
}
public GeneratorLabel(String firstLine, Location loc) {
public GeneratorLabel(BaseComponent[] firstLine, Location loc) {
this.firstLine = firstLine;
label = new HoverLabel(loc, new ArrayList<String>());
label = new HoverLabel(loc, new ArrayList<BaseComponent[]>());
}
}

26
src/main/java/me/topchetoeu/bedwars/engine/HoverLabel.java
View File

@ -9,18 +9,20 @@ import org.bukkit.entity.EntityType;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityDamageEvent;
import net.md_5.bungee.api.chat.BaseComponent;
public class HoverLabel {
private List<String> data;
private List<BaseComponent[]> data;
private List<ArmorStand> armorStands;
private Location loc;
private ArmorStand generateArmorStand(Location loc, String name) {
if (name == null || name.equals("")) return null;
private ArmorStand generateArmorStand(Location loc, BaseComponent[] name) {
if (name == null || name.length == 0) return null;
ArmorStand as = (ArmorStand)loc.getWorld().spawnEntity(loc, EntityType.ARMOR_STAND);
as.setGravity(false);
as.setVisible(false);
as.setCustomName(name);
as.setCustomName(BaseComponent.toLegacyText(name));
as.setCustomNameVisible(true);
return as;
@ -52,18 +54,18 @@ public class HoverLabel {
return loc;
}
private Location replaceData(List<String> data, int n) {
private Location replaceData(List<BaseComponent[]> data, int n) {
Location loc = this.loc.clone();
for (int i = 0; i < n; i++) {
String line = data.get(i);
BaseComponent[] line = data.get(i);
if (line == null || line.equals("")) {
if (line == null || line.length == 0) {
if (armorStands.get(i) != null) armorStands.get(i).remove();
armorStands.set(i, null);
}
else {
if (armorStands.get(i) == null) armorStands.set(i, generateArmorStand(loc, line));
else armorStands.get(i).setCustomName(line);
else armorStands.get(i).setCustomName(BaseComponent.toLegacyText(line));
}
loc.add(0, -0.25, 0);
}
@ -71,7 +73,7 @@ public class HoverLabel {
return loc;
}
public void setData(List<String> data) {
public void setData(List<BaseComponent[]> data) {
if (data.size() > this.data.size()) {
Location loc = replaceData(data, this.data.size());
@ -94,13 +96,13 @@ public class HoverLabel {
this.data = data;
}
public List<String> getData() {
public List<BaseComponent[]> getData() {
return data;
}
public HoverLabel(Location loc, List<String> data) {
public HoverLabel(Location loc, List<BaseComponent[]> data) {
this.loc = loc;
this.data = new ArrayList<String>();
this.data = new ArrayList<BaseComponent[]>();
this.armorStands = new ArrayList<ArmorStand>();
setData(data);
}

6
src/main/java/me/topchetoeu/bedwars/engine/SavedBlock.java
View File

@ -2,14 +2,14 @@ package me.topchetoeu.bedwars.engine;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.material.MaterialData;
import org.bukkit.block.data.BlockData;
public class SavedBlock {
public Location loc;
public MaterialData meta;
public BlockData meta;
public Material type;
public SavedBlock(Location l, MaterialData m, Material t) {
public SavedBlock(Location l, BlockData m, Material t) {
loc = l;
meta = m;
type = t;

7
src/main/java/me/topchetoeu/bedwars/engine/ScoreboardManager.java
View File

@ -12,6 +12,8 @@ import org.bukkit.scoreboard.DisplaySlot;
import org.bukkit.scoreboard.Objective;
import org.bukkit.scoreboard.Scoreboard;
import net.md_5.bungee.api.chat.BaseComponent;
public class ScoreboardManager {
private static Hashtable<UUID, Scoreboard> scoreboards = new Hashtable<>();
@ -25,7 +27,7 @@ public class ScoreboardManager {
if (v.getRemainingPlayers() == 0) teamCounter = "§4✖";
else if (!v.hasBed()) teamCounter = Integer.toString(v.getRemainingPlayers());
String newStr = String.format(" %s§r: %s", v.getTeamColor().getColorName(), teamCounter);
String newStr = String.format(" %s§r: %s", BaseComponent.toLegacyText(v.getTeamColor().getColorName()), teamCounter);
if (v.hasPlayer(p)) {
newStr = (newStr + "§r (you)").replaceAll("§([0-9a-z])", "§$1§l");
@ -45,8 +47,7 @@ public class ScoreboardManager {
p.setScoreboard(scoreboard);
Objective objective = scoreboard.registerNewObjective("bedwars", "dummy");
objective.setDisplayName(" §4§lBedwars ");
Objective objective = scoreboard.registerNewObjective("bedwars", "dummy", " §4§lBedwars ");
objective.setDisplaySlot(DisplaySlot.SIDEBAR);
}

40
src/main/java/me/topchetoeu/bedwars/engine/Team.java
View File

@ -9,7 +9,6 @@ import java.util.List;
import java.util.stream.Collectors;
import org.bukkit.Bukkit;
import org.bukkit.DyeColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.OfflinePlayer;
@ -28,6 +27,8 @@ import org.bukkit.inventory.meta.LeatherArmorMeta;
import me.topchetoeu.bedwars.Main;
import me.topchetoeu.bedwars.Utility;
import me.topchetoeu.bedwars.engine.trader.upgrades.TeamUpgrade;
import me.topchetoeu.bedwars.messaging.MessageUtility;
import net.md_5.bungee.api.chat.BaseComponent;
public class Team implements Listener, AutoCloseable {
private TeamColor color;
@ -55,7 +56,7 @@ public class Team implements Listener, AutoCloseable {
color.getBedLocation().getBlockY() + y,
color.getBedLocation().getBlockZ() + z
).getBlock();
if (block.getType() == Material.BED_BLOCK) {
if (Utility.isBed(block)) {
Game.instance.breakBlock(block);
}
}
@ -67,13 +68,17 @@ public class Team implements Listener, AutoCloseable {
if (bwp.isOnline()) {
Player p = bwp.getOnlinePlayer();
String msg = color.getColorName() + "§r's bed was destroyed";
if (player != null) msg += " by " + player.getName();
msg += ".";
Bukkit.broadcastMessage(msg);
MessageUtility.parser("team.bed-broken.notification")
.variable("team", getTeamColor().getColorName())
.variable("player", p == null ? "a very strong wind current" : p.getDisplayName())
.broadcast();
Utility.sendTitle(p, "Bed destroyed!", "You will no longer respawn!", 5, 35, 10);
p.playSound(p.getLocation(), Sound.EXPLODE, 1, 1);
Utility.sendTitle(p,
MessageUtility.parser("team.bed-broken.title").parse(),
MessageUtility.parser("team.bed-broken.subtitle").parse(),
5, 35, 10
);
p.playSound(p.getLocation(), Sound.ENTITY_GENERIC_EXPLODE, 1, 1);
}
}
@ -174,15 +179,15 @@ public class Team implements Listener, AutoCloseable {
@EventHandler
private void onBlockBreak(BlockBreakEvent e) {
if (e.getBlock().getType() == Material.BED_BLOCK) {
if (Utility.isBed(e.getBlock())) {
if (e.getBlock().getLocation().distance(color.getBedLocation()) < 5) {
if (hasPlayer(e.getPlayer())) {
e.setCancelled(true);
if (getPlayersCount() == 1) {
e.getPlayer().sendMessage("§4You may not destroy your bed.");
MessageUtility.parser("player.solo.break-own-bed").send(e.getPlayer());
}
else {
e.getPlayer().sendMessage("§4You may not destroy your team's bed.");
MessageUtility.parser("player.team.break-own-bed").send(e.getPlayer());
}
}
else {
@ -195,33 +200,32 @@ public class Team implements Listener, AutoCloseable {
}
}
public void sendMessage(String msg) {
public void sendMessage(BaseComponent[] msg) {
for (BedwarsPlayer bwp : players) {
if (bwp.isOnline()) bwp.getOnlinePlayer().sendMessage(msg);
if (bwp.isOnline()) bwp.getOnlinePlayer().spigot().sendMessage(msg);
}
}
public void sendTitle(String title, String subtitle, int fadein, int duration, int fadeout) {
public void sendTitle(BaseComponent[] title, BaseComponent[] subtitle, int fadein, int duration, int fadeout) {
for (BedwarsPlayer bwp : players) {
if (bwp.isOnline()) Utility.sendTitle(bwp.getOnlinePlayer(), title, subtitle, fadein, duration, fadeout);
}
}
public void sendTilteToOthers(String title, String subtitle, int fadein, int duration, int fadeout) {
public void sendTitleToOthers(BaseComponent[] title, BaseComponent[] subtitle, int fadein, int duration, int fadeout) {
for (Player p : Bukkit.getServer().getOnlinePlayers()) {
if (players.stream().noneMatch(v -> v.getPlayer().getUniqueId().equals(p.getUniqueId())))
Utility.sendTitle(p, title, subtitle, fadein, duration, fadeout);
}
}
@SuppressWarnings("deprecation")
public ItemStack teamifyItem(ItemStack stack, boolean colour, boolean upgrades) {
if (colour) {
if (stack.getType() == Material.WOOL) stack.setDurability((short)color.getWoolId());
if (Utility.isWool(stack.getType())) stack.setType(color.getWoolMaterial());
else {
ItemMeta meta = stack.getItemMeta();
if (meta instanceof LeatherArmorMeta) {
LeatherArmorMeta armour = (LeatherArmorMeta)meta;
armour.setColor(DyeColor.getByData((byte)color.getWoolId()).getColor());
armour.setColor(color.getColor());
stack.setItemMeta(armour);
}
}

49
src/main/java/me/topchetoeu/bedwars/engine/TeamColor.java
View File

@ -3,13 +3,21 @@ package me.topchetoeu.bedwars.engine;
import java.util.Hashtable;
import java.util.Map;
import org.bukkit.Color;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.configuration.serialization.ConfigurationSerializable;
import me.topchetoeu.bedwars.Utility;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.ComponentBuilder;
public class TeamColor implements ConfigurationSerializable {
private String name;
private int woolId;
private char colorId;
private Material wool;
private ChatColor chatColor;
private Color color;
private Location bed = null;
private Location spawnLocation = null;
private Location generatorLocation = null;
@ -17,14 +25,17 @@ public class TeamColor implements ConfigurationSerializable {
public String getName() {
return name;
}
public String getColorName() {
return String.format("§%c%s%s", colorId, name.substring(0, 1).toUpperCase(), name.substring(1));
public BaseComponent[] getColorName() {
return new ComponentBuilder().append(name).color(chatColor).create();
}
public int getWoolId() {
return woolId;
public Material getWoolMaterial() {
return wool;
}
public char getColorId() {
return colorId;
public Color getColor() {
return color;
}
public ChatColor getChatColor() {
return chatColor;
}
public Location getBedLocation() {
@ -52,30 +63,34 @@ public class TeamColor implements ConfigurationSerializable {
return bed != null && spawnLocation != null && generatorLocation != null;
}
public TeamColor(String name, int woolId, char colorId) {
public TeamColor(String name, Material wool, Color color, ChatColor colorId) {
this.name = name;
this.woolId = woolId;
this.colorId = colorId;
this.wool = wool;
this.color = color;
this.chatColor = colorId;
}
@Override
public Map<String, Object> serialize() {
Map<String, Object> map = new Hashtable<>();
map.put("name", name);
map.put("woolId", woolId);
map.put("colorId", colorId);
map.put("wool", wool.getKey().getKey().toLowerCase());
map.put("color", color.serialize());
map.put("chatColor", chatColor.getName());
if (bed != null) map.put("bed", bed.serialize());
if (generatorLocation != null) map.put("generator", generatorLocation.serialize());
if (spawnLocation != null) map.put("spawn", spawnLocation.serialize());
return map;
}
@SuppressWarnings("unchecked")
@SuppressWarnings({ "unchecked" })
public static TeamColor deserialize(Map<String, Object> map) {
TeamColor color = new TeamColor(
(String)map.get("name"),
(int)map.get("woolId"),
((String)map.get("colorId")).charAt(0)
map.get("name").toString(),
Material.getMaterial(map.get("wool").toString().toUpperCase()),
Color.deserialize((Map<String, Object>)map.get("color")),
Utility.bukkitToBungeeColor(org.bukkit.ChatColor.valueOf(map.get("chatColor").toString().toUpperCase()))
);
if (map.containsKey("bed")) color.setBedLocation(Location.deserialize((Map<String, Object>) map.get("bed")));

6
src/main/java/me/topchetoeu/bedwars/engine/WoodenSword.java
View File

@ -19,8 +19,8 @@ public class WoodenSword {
}
public static void update(BedwarsPlayer p, Inventory inv) {
if (hasOtherSword(inv))
inv.remove(Material.WOOD_SWORD);
else if (!inv.contains(Material.WOOD_SWORD))
inv.addItem(p.getTeam().teamifyItem(new ItemStack(Material.WOOD_SWORD, 1), true, true));
inv.remove(Material.WOODEN_SWORD);
else if (!inv.contains(Material.WOODEN_SWORD))
inv.addItem(p.getTeam().teamifyItem(new ItemStack(Material.WOODEN_SWORD, 1), true, true));
}
}

4
src/main/java/me/topchetoeu/bedwars/engine/trader/Deal.java
View File

@ -4,9 +4,11 @@ import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import net.md_5.bungee.api.chat.BaseComponent;
public interface Deal {
public ItemStack getDealItem(Player p);
public String getDealName(Player p);
public BaseComponent[] getDealName(Player p);
public Material getPriceType(Player p);
public int getPrice(Player p);
public boolean alreadyBought(Player p);

61
src/main/java/me/topchetoeu/bedwars/engine/trader/TraderGUI.java
View File

@ -23,6 +23,10 @@ import me.topchetoeu.bedwars.InventoryUtility;
import me.topchetoeu.bedwars.Main;
import me.topchetoeu.bedwars.Utility;
import me.topchetoeu.bedwars.engine.trader.dealTypes.ItemDeal;
import me.topchetoeu.bedwars.messaging.MessageUtility;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.ComponentBuilder;
// Very bad code.
public class TraderGUI implements Listener {
@ -43,14 +47,16 @@ public class TraderGUI implements Listener {
}
public ItemStack generateDealItem(Deal d, boolean addFavouriteLore) {
String name = "§r" + d.getDealName(player);
if (d.alreadyBought(player)) name += " §4(already unlocked)";
else name += String.format(" (%dx %s)",
d.getPrice(player),
Utility.getItemName(d.getPriceType(player))
);
ComponentBuilder cb = new ComponentBuilder().append(d.getDealName(player));
if (d.alreadyBought(player)) cb.append("(already unlocked)").color(ChatColor.DARK_RED);
else cb
.append(" (%dx ".formatted(d.getPrice(player)))
.reset()
.append(BaseComponent.toLegacyText(Utility.getItemName(d.getPriceType(player)))).color(ChatColor.DARK_RED)
.append(")")
.reset();
ItemStack item = Utility.copyNamedItem(d.getDealItem(player), name);
ItemStack item = Utility.copyNamedItem(d.getDealItem(player), BaseComponent.toLegacyText(cb.create()));
if (addFavouriteLore) {
List<String> lore = new ArrayList<>();
@ -70,7 +76,7 @@ public class TraderGUI implements Listener {
sectionsOffset = n;
ItemStack[] invC = inventory.getContents();
ItemStack blackGlassPanes = new ItemStack(Material.STAINED_GLASS_PANE, 1, (short)15);
ItemStack blackGlassPanes = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
ItemMeta meta = blackGlassPanes.getItemMeta();
meta.setDisplayName(" ");
blackGlassPanes.setItemMeta(meta);
@ -113,7 +119,7 @@ public class TraderGUI implements Listener {
inventory.setContents(contents);
}
player.playSound(player.getLocation(), Sound.CLICK, 1, 1);
player.playSound(player.getLocation(), Sound.UI_BUTTON_CLICK, 1, 1);
currSectionN = n;
}
@ -121,7 +127,7 @@ public class TraderGUI implements Listener {
ItemStack[] contents = inventory.getContents();
ItemStack empty = Utility.namedItem(new ItemStack(Material.STAINED_GLASS_PANE, 1, (short)8), "§rEmpty slot");
ItemStack empty = Utility.namedItem(new ItemStack(Material.LIGHT_GRAY_STAINED_GLASS_PANE, 1), "§rEmpty slot");
ItemMeta meta = empty.getItemMeta();
List<String> lore = new ArrayList<>();
@ -152,8 +158,8 @@ public class TraderGUI implements Listener {
public void trade(Deal deal) {
if (deal.alreadyBought(player)) {
player.sendMessage("You already own this.");
player.playSound(player.getLocation(), Sound.VILLAGER_NO, 1, 1);
MessageUtility.parser("trade.already-unlocked").variable("name", deal.getDealName(player)).send(player);
player.playSound(player.getLocation(), Sound.ENTITY_VILLAGER_NO, 1, 1);
}
else {
ItemStack[] inv = player.getInventory().getContents();
@ -170,27 +176,36 @@ public class TraderGUI implements Listener {
player.getInventory().setContents(inv);
MessageUtility.parser("trade.purchase")
.variable("name", deal.getDealName(player))
.variable("price", deal.getPrice(player))
.variable("priceType", Utility.getItemName(deal.getPriceType(player)))
.send(player);
deal.commence(player);
updateSection();
if (player.getInventory().contains(Material.STONE_SWORD) ||
player.getInventory().contains(Material.IRON_SWORD) ||
player.getInventory().contains(Material.DIAMOND_SWORD)) {
if (player.getInventory().contains(Material.WOOD_SWORD)) {
player.getInventory().remove(Material.WOOD_SWORD);
if (player.getInventory().contains(Material.WOODEN_SWORD)) {
player.getInventory().remove(Material.WOODEN_SWORD);
}
}
player.playSound(player.getLocation(), Sound.VILLAGER_YES, 1, 1);
player.playSound(player.getLocation(), Sound.ENTITY_VILLAGER_YES, 1, 1);
}
else {
player.sendMessage(String.format("You don't have enough %ss!", Utility.getItemName(deal.getPriceType(player)).toLowerCase()));
player.playSound(player.getLocation(), Sound.VILLAGER_NO, 1, 1);
MessageUtility.parser("trade.not-enough-resources")
.variable("name", deal.getDealName(player))
.variable("price", deal.getPrice(player))
.variable("priceType", Utility.getItemName(deal.getPriceType(player)))
.send(player);
player.playSound(player.getLocation(), Sound.ENTITY_VILLAGER_NO, 1, 1);
}
}
}
}
private void generateInventory(Inventory inv) {
ItemStack blackGlassPanes = new ItemStack(Material.STAINED_GLASS_PANE, 1, (short)15);
ItemStack blackGlassPanes = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
ItemMeta meta = blackGlassPanes.getItemMeta();
meta.setDisplayName(" ");
blackGlassPanes.setItemMeta(meta);
@ -242,12 +257,12 @@ public class TraderGUI implements Listener {
if (d == null && favourites.containsKey(currFavourite)) {
favourites.remove(currFavourite);
Favourites.instance.updateFavourites(player, favourites);
player.playSound(player.getLocation(), Sound.GHAST_FIREBALL, 1, 1);
player.playSound(player.getLocation(), Sound.ENTITY_GHAST_SHOOT, 1, 1);
}
else {
favourites.put(currFavourite, d);
Favourites.instance.updateFavourites(player, favourites);
player.playSound(player.getLocation(), Sound.ORB_PICKUP, 1, 1);
player.playSound(player.getLocation(), Sound.ENTITY_EXPERIENCE_ORB_PICKUP, 1, 1);
}
currFavourite = -1;
@ -278,7 +293,7 @@ public class TraderGUI implements Listener {
if (slot == 49) {
player.closeInventory();
player.playSound(player.getLocation(), Sound.CLICK, 1, 1);
player.playSound(player.getLocation(), Sound.UI_BUTTON_CLICK, 1, 1);
return;
}
else if (slot < 9) selectSection(slot - 2 + sectionsOffset); // Section
@ -303,7 +318,7 @@ public class TraderGUI implements Listener {
if (currSectionN < 0) {
if (e.getClick() == ClickType.SHIFT_LEFT) {
player.playSound(player.getLocation(), Sound.CLICK, 1, 1);
player.playSound(player.getLocation(), Sound.UI_BUTTON_CLICK, 1, 1);
currFavourite = n; return;
}
else if (e.getClick() == ClickType.SHIFT_RIGHT) {
@ -331,7 +346,7 @@ public class TraderGUI implements Listener {
}
}
public TraderGUI(File favsDir, Player p) {
public TraderGUI(File favouritesDir, Player p) {
this.sections = Sections.getSections();
this.player = p;
Bukkit.getPluginManager().registerEvents(this, Main.getInstance());

56
src/main/java/me/topchetoeu/bedwars/engine/trader/Traders.java
View File

@ -1,9 +1,11 @@
package me.topchetoeu.bedwars.engine.trader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.Charset;
import java.io.OutputStreamWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@ -14,7 +16,6 @@ import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.block.BlockFace;
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftEntity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.entity.Villager;
@ -27,10 +28,8 @@ import org.bukkit.event.player.PlayerInteractEntityEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
import com.google.common.io.Files;
import me.topchetoeu.bedwars.Main;
import net.minecraft.server.v1_8_R3.NBTTagCompound;
import me.topchetoeu.bedwars.Utility;
public class Traders implements Listener {
public static Traders instance = null;
@ -38,36 +37,29 @@ public class Traders implements Listener {
private List<UUID> villagers = new ArrayList<>();
private File file;
private final ItemStack eradicator, spawner;
private void write() {
BufferedWriter writer;
try {
writer = Files.newWriter(file, Charset.defaultCharset());
OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(file));
for (UUID uuid : villagers) {
writer.write(uuid.toString() + "\n");
}
writer.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void give(Player p) {
p.getInventory().addItem(eradicator, spawner);
}
public Villager summonVillager(Location loc) {
Villager vil = (Villager)loc.getWorld().spawnEntity(loc, EntityType.VILLAGER);
net.minecraft.server.v1_8_R3.Entity nmsEntity = ((CraftEntity) vil).getHandle();
NBTTagCompound tag = nmsEntity.getNBTTag();
if (tag == null) {
tag = new NBTTagCompound();
}
nmsEntity.c(tag);
tag.setInt("NoAI", 1);
nmsEntity.f(tag);
nmsEntity.b(true);
vil.setAI(false);
villagers.add(vil.getUniqueId());
write();
@ -93,10 +85,8 @@ public class Traders implements Listener {
private void onUse(PlayerInteractEvent e) {
if (e.getAction() == Action.RIGHT_CLICK_BLOCK &&
e.hasItem() &&
e.getItem().hasItemMeta() &&
e.getItem().getItemMeta().hasDisplayName() &&
e.getItem().getItemMeta().getDisplayName() == "§rTrader spawner") {
if (e.getItem().getType() == Material.MONSTER_EGG) {
spawner.getItemMeta().equals(e.getItem().getItemMeta())) {
if (e.getItem().getType() == Material.VILLAGER_SPAWN_EGG) {
int yaw = (int)e.getPlayer().getLocation().getYaw() - 45;
if (yaw < 0) yaw += 360;
@ -122,7 +112,9 @@ public class Traders implements Listener {
summonVillager(loc);
e.getPlayer().sendMessage("Trader spawned!");
e.getPlayer().playSound(e.getPlayer().getLocation(), Sound.VILLAGER_YES, 1, 1);
e.getPlayer().playSound(e.getPlayer().getLocation(), Sound.ENTITY_VILLAGER_YES, 1, 1);
e.setCancelled(true);
}
}
}
@ -147,17 +139,16 @@ public class Traders implements Listener {
if (villagers.stream().anyMatch(_v -> _v.equals(v.getUniqueId()))) {
e.setCancelled(true);
ItemStack hand = p.getInventory().getItemInHand();
ItemStack hand = p.getInventory().getItemInMainHand();
if (hand != null &&
hand.hasItemMeta() &&
hand.getItemMeta().hasDisplayName() &&
hand.getItemMeta().getDisplayName().equals("§rTrader eradicator")) {
eradicator.getItemMeta().equals(hand.getItemMeta())) {
if (hand.getType() == Material.STICK) {
villagers.remove(v.getUniqueId());
write();
v.remove();
p.playSound(p.getLocation(), Sound.VILLAGER_DEATH, 1, 1);
p.playSound(p.getLocation(), Sound.ENTITY_VILLAGER_DEATH, 1, 1);
p.sendMessage("Trader removed!");
}
}
@ -170,13 +161,16 @@ public class Traders implements Listener {
public Traders(File tradersFile) throws IOException {
if (!tradersFile.exists()) tradersFile.createNewFile();
villagers = Files.readLines(tradersFile, Charset.defaultCharset())
villagers = Files.readAllLines(Path.of(tradersFile.getAbsolutePath()))
.stream()
.map(v -> UUID.fromString(v))
.collect(Collectors.toList());
file = tradersFile;
spawner = Utility.namedItem(new ItemStack(Material.VILLAGER_SPAWN_EGG), "§rTrader spawner");
eradicator = Utility.namedItem(new ItemStack(Material.STICK), "§rTrader eradicator");
Bukkit.getPluginManager().registerEvents(this, Main.getInstance());
}
}

8
src/main/java/me/topchetoeu/bedwars/engine/trader/dealTypes/EnforcedRankedDeal.java
View File

@ -1,13 +1,14 @@
package me.topchetoeu.bedwars.engine.trader.dealTypes;
import java.util.Hashtable;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import me.topchetoeu.bedwars.engine.Game;
import me.topchetoeu.bedwars.engine.trader.Deal;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.ComponentBuilder;
public class EnforcedRankedDeal implements Deal {
private Rank soldRank;
@ -24,8 +25,8 @@ public class EnforcedRankedDeal implements Deal {
return icon;
}
@Override
public String getDealName(Player p) {
return soldRank.getNextTier(p).getDisplayName();
public BaseComponent[] getDealName(Player p) {
return new ComponentBuilder().append(soldRank.getNextTier(p).getDisplayName()).reset().create();
}
@Override
public Material getPriceType(Player p) {
@ -41,7 +42,6 @@ public class EnforcedRankedDeal implements Deal {
}
@Override
public void commence(Player p) {
p.sendMessage(String.format("§rYou just purchased %s.", getDealName(p)));
soldRank.increasePlayerTier(p, soldRank.getNextTier(p));
}

20
src/main/java/me/topchetoeu/bedwars/engine/trader/dealTypes/ItemDeal.java
View File

@ -10,6 +10,10 @@ import me.topchetoeu.bedwars.engine.BedwarsPlayer;
import me.topchetoeu.bedwars.engine.Game;
import me.topchetoeu.bedwars.engine.WoodenSword;
import me.topchetoeu.bedwars.engine.trader.Deal;
import me.topchetoeu.bedwars.messaging.MessageUtility;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.ComponentBuilder;
public class ItemDeal implements Deal {
private ItemStack item;
@ -25,8 +29,13 @@ public class ItemDeal implements Deal {
}
@Override
public String getDealName(Player p) {
return String.format("§r%dx %s%s", item.getAmount(), Utility.getItemName(item), implemented ? "" : " §4§l(not implemented)§r");
public BaseComponent[] getDealName(Player p) {
ComponentBuilder builder = new ComponentBuilder()
.append(Integer.toString(item.getAmount()))
.append("x ")
.append(Utility.getItemName(item));
if (!implemented) builder.append(" (not implemented)").bold(true).color(ChatColor.RED);
return builder.create();
}
@Override
@ -45,11 +54,14 @@ public class ItemDeal implements Deal {
@Override
public void commence(Player p) {
if (!implemented) {
p.sendMessage("The item you're trying to buy is not implemented yet.");
MessageUtility.parser("player.trade.not-implemented")
.variable("name", getDealName(p))
.variable("price", getPrice(p))
.variable("priceType", getPriceType(p))
.send(p);
return;
}
ItemStack item = getDealItem(p);
p.sendMessage(String.format("You just purchased %s.", getDealName(p)));
ItemStack[] contents = p.getInventory().getContents();
InventoryUtility.giveItem(contents, item);
p.getInventory().setContents(contents);

5
src/main/java/me/topchetoeu/bedwars/engine/trader/dealTypes/Rank.java
View File

@ -104,8 +104,9 @@ public class Rank implements Listener {
for (; i <= targetI; i++) {
tiers.get(i).apply(inv, p, this);
}
ItemStack[] armor = p.getInventory().getArmorContents();
p.getInventory().setContents(inv);
p.getInventory().setArmorContents(armor);
}
currentTier.put(player.getUniqueId(), target);
@ -193,7 +194,9 @@ public class Rank implements Listener {
}
}
ItemStack[] armor = p.getInventory().getArmorContents();
p.getInventory().setContents(inv);
p.getInventory().setArmorContents(armor);
p.updateInventory();
}

6
src/main/java/me/topchetoeu/bedwars/engine/trader/dealTypes/RankTier.java
View File

@ -8,6 +8,8 @@ import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import me.topchetoeu.bedwars.Utility;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.ComponentBuilder;
public class RankTier {
private String name;
@ -17,8 +19,8 @@ public class RankTier {
public String getName() {
return name;
}
public String getDisplayName() {
return Utility.getItemName(icon);
public BaseComponent[] getDisplayName() {
return new ComponentBuilder().append(Utility.getItemName(icon)).reset().create();
}
public ItemStack getIcon() {
return icon;

7
src/main/java/me/topchetoeu/bedwars/engine/trader/dealTypes/RankedDeal.java
View File

@ -7,6 +7,8 @@ import org.bukkit.inventory.ItemStack;
import me.topchetoeu.bedwars.Utility;
import me.topchetoeu.bedwars.engine.Game;
import me.topchetoeu.bedwars.engine.trader.Deal;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.ComponentBuilder;
public class RankedDeal implements Deal {
private Rank soldRank;
@ -29,8 +31,8 @@ public class RankedDeal implements Deal {
return icon;
}
@Override
public String getDealName(Player p) {
return Utility.getItemName(soldTier.getIcon());
public BaseComponent[] getDealName(Player p) {
return new ComponentBuilder().append(Utility.getItemName(soldTier.getIcon())).reset().create();
}
@Override
public Material getPriceType(Player p) {
@ -46,7 +48,6 @@ public class RankedDeal implements Deal {
}
@Override
public void commence(Player p) {
p.sendMessage(String.format("§rYou just purchased %s.", getDealName(p)));
soldRank.increasePlayerTier(p, soldTier);
}

17
src/main/java/me/topchetoeu/bedwars/engine/trader/dealTypes/RankedUpgradeDeal.java
View File

@ -11,6 +11,10 @@ import me.topchetoeu.bedwars.engine.Game;
import me.topchetoeu.bedwars.engine.Team;
import me.topchetoeu.bedwars.engine.trader.Deal;
import me.topchetoeu.bedwars.engine.trader.upgrades.TeamUpgrade;
import me.topchetoeu.bedwars.messaging.MessageUtility;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.ComponentBuilder;
import net.md_5.bungee.api.chat.TextComponent;
public class RankedUpgradeDeal implements Deal {
private TeamUpgradeRank rank;
@ -39,16 +43,19 @@ public class RankedUpgradeDeal implements Deal {
if (upgrade == null) return;
upgrade.addToTeam(t);
upgrade.updateTeam(t);
t.sendMessage(p.getName() + "§r purchased " + upgrade.getDisplayName() + "§r!");
MessageUtility.parser("team.upgrade-purchased")
.variable("player", p.getDisplayName())
.variable("upgrade", getDealName(p))
.send(t);
}
@Override
public String getDealName(Player p) {
if (!Game.isStarted()) return "None";
public BaseComponent[] getDealName(Player p) {
if (!Game.isStarted()) return new BaseComponent[] { new TextComponent("???") };
Team t = Game.instance.getTeam(p);
if (t == null) return "None";
if (t == null) return new BaseComponent[] { new TextComponent("???") };
return rank.getNextTeamUpgrade(t).getDisplayName();
return new ComponentBuilder().reset().append(rank.getNextTeamUpgrade(t).getDisplayName()).create();
}
@Override

8
src/main/java/me/topchetoeu/bedwars/engine/trader/upgrades/EfficiencyTeamUpgrade.java
View File

@ -1,12 +1,11 @@
package me.topchetoeu.bedwars.engine.trader.upgrades;
import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftItemStack;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import me.topchetoeu.bedwars.Utility;
import me.topchetoeu.bedwars.engine.Team;
import net.minecraft.server.v1_8_R3.ItemTool;
public class EfficiencyTeamUpgrade implements TeamUpgrade {
private int level;
@ -53,8 +52,8 @@ public class EfficiencyTeamUpgrade implements TeamUpgrade {
@Override
public void upgradeItem(ItemStack item) {
if (item == null) return;
net.minecraft.server.v1_8_R3.Item nmsItem = CraftItemStack.asNMSCopy(item).getItem();
if (nmsItem instanceof ItemTool) {
if (Utility.isTool(item.getType())) {
item.addEnchantment(Enchantment.DIG_SPEED, level);
}
}
@ -73,7 +72,6 @@ public class EfficiencyTeamUpgrade implements TeamUpgrade {
@Override
public String toString() {
// TODO Auto-generated method stub
return getName();
}
}

6
src/main/java/me/topchetoeu/bedwars/engine/trader/upgrades/ProtectionTeamUpgrade.java
View File

@ -1,12 +1,11 @@
package me.topchetoeu.bedwars.engine.trader.upgrades;
import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftItemStack;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import me.topchetoeu.bedwars.Utility;
import me.topchetoeu.bedwars.engine.Team;
import net.minecraft.server.v1_8_R3.ItemArmor;
public class ProtectionTeamUpgrade implements TeamUpgrade {
private int level;
@ -53,7 +52,7 @@ public class ProtectionTeamUpgrade implements TeamUpgrade {
@Override
public void upgradeItem(ItemStack item) {
if (item == null) return;
if (CraftItemStack.asNMSCopy(item).getItem() instanceof ItemArmor) {
if (Utility.isArmor(item.getType())) {
item.addEnchantment(Enchantment.PROTECTION_ENVIRONMENTAL, level);
}
}
@ -71,7 +70,6 @@ public class ProtectionTeamUpgrade implements TeamUpgrade {
@Override
public String toString() {
// TODO Auto-generated method stub
return getName();
}
}

8
src/main/java/me/topchetoeu/bedwars/engine/trader/upgrades/SharpnessTeamUpgrade.java
View File

@ -1,13 +1,11 @@
package me.topchetoeu.bedwars.engine.trader.upgrades;
import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftItemStack;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import me.topchetoeu.bedwars.Utility;
import me.topchetoeu.bedwars.engine.Team;
import net.minecraft.server.v1_8_R3.ItemAxe;
import net.minecraft.server.v1_8_R3.ItemSword;
public class SharpnessTeamUpgrade implements TeamUpgrade {
private int level;
@ -54,8 +52,7 @@ public class SharpnessTeamUpgrade implements TeamUpgrade {
@Override
public void upgradeItem(ItemStack item) {
if (item == null) return;
net.minecraft.server.v1_8_R3.Item nmsItem = CraftItemStack.asNMSCopy(item).getItem();
if (nmsItem instanceof ItemSword || nmsItem instanceof ItemAxe) {
if (Utility.isWeapon(item.getType())) {
item.addEnchantment(Enchantment.DAMAGE_ALL, level);
}
}
@ -71,7 +68,6 @@ public class SharpnessTeamUpgrade implements TeamUpgrade {
@Override
public String toString() {
// TODO Auto-generated method stub
return getName();
}
}

173
src/main/java/me/topchetoeu/bedwars/messaging/MessageParser.java Normal file
View File

@ -0,0 +1,173 @@
package me.topchetoeu.bedwars.messaging;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Map;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import me.topchetoeu.bedwars.engine.Team;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
public class MessageParser {
private class ChatStyle {
public ChatColor color = ChatColor.WHITE;
public final HashSet<ChatColor> styles = new HashSet<>();
@Override
public String toString() {
return color.toString() + String.join("", styles.stream().map(v -> v.toString()).toList());
}
}
private final Hashtable<String, Object> variables = new Hashtable<>();
private final String raw;
private final char colorChar = '&';
public MessageParser variable(String name, Object value) {
variables.put(name, value);
return this;
}
public MessageParser variables(Map<String, Object> map) {
variables.putAll(map);
return this;
}
private ChatStyle getStyle(String str, ChatStyle _default) {
boolean styling = false;
ChatStyle style = new ChatStyle();
style.color = _default.color;
style.styles.addAll(_default.styles);
for (int i = 0; i < str.length(); i++) {
char curr = str.charAt(i);
if (styling) {
switch (curr) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
style.color = ChatColor.getByChar(curr);
style.styles.clear();
style.styles.addAll(_default.styles);
break;
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
style.styles.add(ChatColor.getByChar(curr));
break;
case 'r':
style.styles.clear();
style.styles.addAll(_default.styles);
style.color = _default.color;
break;
default:
break;
}
styling = false;
}
else if (curr == '§') styling = true;
}
return style;
}
private String replaceVariables() {
if (raw.length() < 2) return raw;
String raw = this.raw + ';';
raw = raw.replace(colorChar, '§');
raw = raw.replace("§§", Character.toString(colorChar));
boolean varMode = false;
StringBuilder varName = new StringBuilder();
StringBuilder currText = new StringBuilder();
ChatStyle _default = new ChatStyle();
_default.color = ChatColor.WHITE;
for (int i = 1; i < raw.length(); i++) {
char curr = raw.charAt(i - 1);
char next = raw.charAt(i);
boolean appendChar = false;
if (curr == '{') {
if (next == '{') {
appendChar = true;
i++;
}
else varMode = true;
}
else if (curr == '}') {
if (next == '}') {
appendChar = true;
i++;
}
else {
Object val = variables.get(varName.toString());
String strVal = "undefined";
if (val != null) {
if (val instanceof BaseComponent[]) strVal = BaseComponent.toLegacyText((BaseComponent[])val);
else strVal = val.toString();
}
ChatStyle color = getStyle(currText.toString(), _default);
currText.append(strVal.replace(colorChar, '§').replace("§§", Character.toString(colorChar)));
currText.append(color);
varName.setLength(0);
varMode = false;
}
}
else appendChar = true;
if (appendChar) {
if (varMode) varName.append(curr);
else currText.append(curr);
}
}
return currText.toString();
}
public BaseComponent[] parse() {
if (raw == null) return null;
return TextComponent.fromLegacyText(replaceVariables());
}
public void send(CommandSender sender) {
BaseComponent[] msg = parse();
if (msg == null) msg = new BaseComponent[] { new TextComponent("Missing message from config.") };
sender.spigot().sendMessage(msg);
}
public void send(Team team) {
BaseComponent[] msg = parse();
if (msg == null) msg = new BaseComponent[] { new TextComponent("Missing message from config.") };
team.sendMessage(msg);
}
public void broadcast() {
BaseComponent[] msg = parse();
if (msg == null) msg = new BaseComponent[] { new TextComponent("Missing message from config.") };
Bukkit.spigot().broadcast(msg);
}
public MessageParser(String msg) {
this.raw = msg;
}
}

25
src/main/java/me/topchetoeu/bedwars/messaging/MessageUtility.java Normal file
View File

@ -0,0 +1,25 @@
package me.topchetoeu.bedwars.messaging;
import java.io.File;
import java.io.IOException;
import org.bukkit.configuration.file.YamlConfiguration;
public class MessageUtility {
private static YamlConfiguration config;
private MessageUtility() {
}
public static void load(File file) throws IOException {
config = YamlConfiguration.loadConfiguration(file);
config.save(file);
}
public static MessageParser parser(String path) {
Object obj = config.get(path);
if (obj == null) return new MessageParser(null);
else return new MessageParser(obj.toString());
}
}

78
src/main/java/me/topchetoeu/bedwars/permissions/PermissionSegmentWildcard.java Normal file
View File

@ -0,0 +1,78 @@
package me.topchetoeu.bedwars.permissions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
public class PermissionSegmentWildcard {
private String prefix;
private List<String> remaining;
public String getPrefix() {
return prefix;
}
public List<String> getRemainingSegments() {
return Collections.unmodifiableList(remaining);
}
public boolean isWildcard() {
return remaining != null;
}
public String toString() {
if (isWildcard()) return prefix + "*" + String.join("*", remaining);
else return prefix;
}
public boolean check(String segment) {
if (isWildcard()) {
for (int i = remaining.size() - 1; i >= 0; i--) {
String curr = remaining.get(i);
int index = segment.lastIndexOf(curr);
if (index == -1) return false;
segment = segment.substring(0, index);
}
return !segment.startsWith(prefix);
}
else return segment.equals(prefix);
}
public PermissionSegmentWildcard(String node, boolean isPrefix) {
this.prefix = node;
if (isPrefix) remaining = Collections.emptyList();
}
public PermissionSegmentWildcard(String prefix, String suffix) {
this.prefix = prefix;
this.remaining = Collections.singletonList(suffix);
}
public PermissionSegmentWildcard(String prefix, String ...remaining) {
this.prefix = prefix;
this.remaining = Arrays.asList(remaining);
}
public PermissionSegmentWildcard(String prefix, Collection<String> remaining) {
this.prefix = prefix;
this.remaining = new ArrayList<>(remaining);
}
public static PermissionSegmentWildcard parse(String str) {
if (str.contains("**")) throw new RuntimeException("Recursive wildcards not allowed.");
String[] segments = str.split("\\*");
if (segments.length == 0) return new PermissionSegmentWildcard("", true);
else if (segments.length == 1) return new PermissionSegmentWildcard(segments[0], false);
else {
List<String> remaining = new ArrayList<>();
Collections.addAll(remaining, segments);
remaining.remove(0);
if (remaining.size() == 0) return new PermissionSegmentWildcard(segments[0], true);
if (remaining.get(remaining.size() - 1).isEmpty())
remaining.remove(remaining.size() - 1);
return new PermissionSegmentWildcard(segments[0], remaining);
}
}
}

84
src/main/java/me/topchetoeu/bedwars/permissions/PermissionWildcard.java Normal file
View File

@ -0,0 +1,84 @@
package me.topchetoeu.bedwars.permissions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
public class PermissionWildcard {
private List<PermissionSegmentWildcard> prefix;
private List<PermissionSegmentWildcard> suffix;
public boolean hasRecursiveWildcard() {
return suffix != null;
}
public PermissionWildcard(boolean isPrefix, Collection<PermissionSegmentWildcard> segments) {
this.prefix = new ArrayList<>(segments);
if (isPrefix) suffix = Collections.emptyList();
}
public PermissionWildcard(boolean isPrefix, PermissionSegmentWildcard ...segments) {
this.prefix = Arrays.asList(segments);
if (isPrefix) suffix = Collections.emptyList();
}
public PermissionWildcard(Collection<PermissionSegmentWildcard> prefix, Collection<PermissionSegmentWildcard> suffix) {
this.prefix = new ArrayList<>(prefix);
this.suffix = new ArrayList<>(suffix);
}
public boolean check(String perm) {
String[] segments = perm.split(".");
if (segments.length < prefix.size()) return false;
if (suffix != null && segments.length < suffix.size()) return false;
int i = 0;
for (; i < prefix.size(); i++) {
if (!prefix.get(i).check(segments[i])) return false;
}
if (hasRecursiveWildcard()) {
int j = 0;
for (i = suffix.size(), j = segments.length; i >= 0; i--, j--) {
if (!prefix.get(i).check(segments[j])) return false;
}
return true;
}
else return i == prefix.size();
}
public String toString() {
String res = String.join(".", prefix.toArray(String[]::new));
if (hasRecursiveWildcard()) {
res += ".**";
if (suffix != null) res += "." + String.join(".", suffix.toArray(String[]::new));
}
return res;
}
public static PermissionWildcard parse(String raw) {
String[] segments = raw.split("\\.");
ArrayList<PermissionSegmentWildcard> prefix = new ArrayList<>();
ArrayList<PermissionSegmentWildcard> suffix = null;
ArrayList<PermissionSegmentWildcard> currList = prefix;
for (String segment : segments) {
if (segment.isEmpty()) throw new RuntimeException("Empty permission segments are not allowed.");
if (segment.equals("**")) {
if (suffix == null) {
currList = suffix = new ArrayList<>();
}
else throw new RuntimeException("Multiple recursive wildcards are not allowed.");
}
else if (segment.contains("**")) throw new RuntimeException("Wildcards must be the only thing in a segment.");
else currList.add(PermissionSegmentWildcard.parse(segment));
}
if (suffix == null) return new PermissionWildcard(false, prefix);
else return new PermissionWildcard(prefix, suffix);
}
}

32
src/main/java/me/topchetoeu/bedwars/permissions/Permissions.java Normal file
View File

@ -0,0 +1,32 @@
package me.topchetoeu.bedwars.permissions;
import java.util.Hashtable;
import org.bukkit.permissions.Permissible;
public class Permissions {
private static final Hashtable<String, PermissionWildcard> cache = new Hashtable<>();
private Permissions() {
}
public static void reset() {
cache.clear();
}
public static final PermissionWildcard getCachedOrParse(String rawWildcard) {
cache.clear();
return cache.containsKey(rawWildcard) ? cache.get(rawWildcard) : PermissionWildcard.parse(rawWildcard);
}
public static boolean hasPermission(Permissible permissible, String permission) {
if (permission == null || permission.isEmpty()) return true;
if (permissible == null) return false;
if (permissible.isOp()) return true;
if (permissible.hasPermission(permission)) return true;
return permissible.getEffectivePermissions().stream().anyMatch(v -> {
return getCachedOrParse(v.getPermission()).check(permission);
});
}
}

55
src/plugin.yml Normal file
View File

@ -0,0 +1,55 @@
name: bedwars-plugin
version: 0.7.0
description: A plugin that enables you to make a bedwars game
authors: [ TopchetoEU, SpaceHQ ]
main: me.topchetoeu.bedwars.Main
api-version: 1.18
commands:
bedwars:
description: A command used to control the bedwars plugin
aliases: [ bw, bedwar ]
permissions:
bedwars:
description: Gives access to all bedwars-related commands
children:
bedwars.config: yes
bedwars.cheat: yes
bedwars.control: yes
bedwars.villagertools: yes
bedwars.config:
description: Gives access to all bedwars configuration commands
children:
bedwars.config.bases: yes
bedwars.config.generators: yes
bedwars.config.bases:
description: Gives access to all base-related commands
children:
bedwars.config.bases.add: yes
bedwars.config.bases.remove: yes
bedwars.config.bases.setspawn: yes
bedwars.config.bases.setgenerator: yes
bedwars.config.bases.setbed: yes
bedwars.config.bases.add:
description: Gives access to base add command
bedwars.config.bases.remove:
description: Gives access to base remove command
bedwars.config.bases.setspawn:
description: Gives access to base set spawn command
bedwars.config.bases.setgenerator:
description: Gives access to base set generator command
bedwars.config.bases.setbed:
description: Gives access to base set bed command
bedwars.cheat:
description: Gives access to all features that allow cheating (like killing, eliminating or breaking other's beds)
children:
bedwars.cheat.kill: yes
bedwars.cheat.revive: yes
bedwars.cheat.breakbed: yes
bedwars.cheat.kill:
description: Gives access to the command /bw kill [player]
bedwars.cheat.revive:
description: Gives access to the command /bw revive [player]
bedwars.cheat.breakbed:
description: Gives access to the command /bw breakbed [team]
bedwars.villagertools:
description: Gives access to the command /bw villagertools