Repo-Mirror/Custom-Fishing
9
0
Fork 0
mirror of https://github.com/Xiao-MoMi/Custom-Fishing.git synced 2025-12-28 19:39:06 +00:00
Code Issues Releases Activity

1.3.0.4

Browse Source
This commit is contained in:
Xiao-MoMi
2023-03-23 23:22:37 +08:00
parent d014889d65
commit 48ba5d8c01
34 changed files with 794 additions and 904 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/main/java/net/momirealms/customfishing/api/CustomFishingAPI.java
View File

@@ -100,4 +100,20 @@ public class CustomFishingAPI {
public static int getCertainLootCatchAmount(String id, UUID uuid) {
return CustomFishing.getInstance().getStatisticsManager().getFishAmount(uuid, id);
}
/**
* If an item exists in item library
* @param type type
* @param key key
* @return exist
*/
public static boolean doesItemExist(String type, String key) {
return switch (type) {
case "loot" -> CustomFishing.getInstance().getLootManager().hasLoot(key);
case "rod" -> CustomFishing.getInstance().getEffectManager().getRodItem(key) != null;
case "bait" -> CustomFishing.getInstance().getEffectManager().getBaitItem(key) != null;
case "util" -> CustomFishing.getInstance().getEffectManager().getUtilItem(key) != null;
default -> false;
};
}
}

58
src/main/java/net/momirealms/customfishing/commands/AbstractMainCommand.java Normal file
View File

@@ -0,0 +1,58 @@
package net.momirealms.customfishing.commands;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabExecutor;
import org.jetbrains.annotations.NotNull;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public abstract class AbstractMainCommand implements TabExecutor {
protected final Map<String, AbstractSubCommand> subCommandMap;
public AbstractMainCommand() {
this.subCommandMap = new ConcurrentHashMap<>();
}
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
List<String> argList = Arrays.asList(args);
if (argList.size() < 1) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.nonArgs);
return true;
}
AbstractSubCommand subCommand = subCommandMap.get(argList.get(0));
if (subCommand != null)
return subCommand.onCommand(sender, argList.subList(1, argList.size()));
else {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.unavailableArgs);
return true;
}
}
@Override
public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, String[] args) {
List<String> argList = Arrays.asList(args);
if (argList.size() <= 1) {
List<String> returnList = new ArrayList<>(subCommandMap.keySet());
returnList.removeIf(str -> !str.startsWith(args[0]));
return returnList;
}
AbstractSubCommand subCommand = subCommandMap.get(argList.get(0));
if (subCommand != null)
return subCommand.onTabComplete(sender, argList.subList(1, argList.size()));
else
return Collections.singletonList("");
}
public void regSubCommand(AbstractSubCommand executor) {
subCommandMap.put(executor.getSubCommand(), executor);
}
public Map<String, AbstractSubCommand> getSubCommandMap() {
return subCommandMap;
}
}

63
src/main/java/net/momirealms/customfishing/commands/AbstractSubCommand.java
View File

@@ -17,10 +17,12 @@
package net.momirealms.customfishing.commands;
import net.momirealms.customfishing.api.CustomFishingAPI;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.Collections;
@@ -29,22 +31,20 @@ import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
public abstract class AbstractSubCommand implements SubCommand {
public abstract class AbstractSubCommand {
private final String command;
private Map<String, SubCommand> subCommandMap;
private Map<String, AbstractSubCommand> subCommandMap;
public AbstractSubCommand(String command, Map<String, SubCommand> subCommandMap) {
public AbstractSubCommand(String command) {
this.command = command;
this.subCommandMap = subCommandMap;
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (subCommandMap == null || args.size() < 1) {
return true;
}
SubCommand subCommand = subCommandMap.get(args.get(0));
AbstractSubCommand subCommand = subCommandMap.get(args.get(0));
if (subCommand == null) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.unavailableArgs);
} else {
@@ -53,7 +53,6 @@ public abstract class AbstractSubCommand implements SubCommand {
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (subCommandMap == null)
return Collections.singletonList("");
@@ -62,37 +61,65 @@ public abstract class AbstractSubCommand implements SubCommand {
returnList.removeIf(str -> !str.startsWith(args.get(0)));
return returnList;
}
SubCommand subCmd = subCommandMap.get(args.get(0));
AbstractSubCommand subCmd = subCommandMap.get(args.get(0));
if (subCmd != null)
return subCommandMap.get(args.get(0)).onTabComplete(sender, args.subList(1, args.size()));
return Collections.singletonList("");
}
@Override
public String getSubCommand() {
return command;
}
@Override
public Map<String, SubCommand> getSubCommands() {
public Map<String, AbstractSubCommand> getSubCommands() {
return Collections.unmodifiableMap(subCommandMap);
}
@Override
public void regSubCommand(SubCommand command) {
public void regSubCommand(AbstractSubCommand command) {
if (subCommandMap == null) {
subCommandMap = new ConcurrentHashMap<>();
}
subCommandMap.put(command.getSubCommand(), command);
}
public void setSubCommandMap(Map<String, SubCommand> subCommandMap) {
this.subCommandMap = subCommandMap;
protected boolean noConsoleExecute(CommandSender commandSender) {
if (!(commandSender instanceof Player)) {
AdventureUtil.consoleMessage(MessageManager.prefix + MessageManager.noConsole);
return true;
}
return false;
}
protected void giveItemMsg(CommandSender sender, String name, String item, int amount){
String string = MessageManager.prefix + MessageManager.giveItem.replace("{Amount}", String.valueOf(amount)).replace("{Player}",name).replace("{Item}",item);
AdventureUtil.sendMessage(sender, string);
protected boolean itemNotExist(CommandSender commandSender, String type, String key) {
if (!CustomFishingAPI.doesItemExist(type, key)) {
AdventureUtil.sendMessage(commandSender, MessageManager.prefix + MessageManager.itemNotExist);
return true;
}
return false;
}
protected boolean playerNotOnline(CommandSender commandSender, String player) {
if (Bukkit.getPlayer(player) == null) {
AdventureUtil.sendMessage(commandSender, MessageManager.prefix + MessageManager.notOnline.replace("{Player}", player));
return true;
}
return false;
}
protected boolean lackArgs(CommandSender commandSender, int required, int current) {
if (required > current) {
AdventureUtil.sendMessage(commandSender, MessageManager.prefix + MessageManager.lackArgs);
return true;
}
return false;
}
protected void giveItemMsg(CommandSender sender, String name, String item, int amount) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.giveItem.replace("{Amount}", String.valueOf(amount)).replace("{Player}",name).replace("{Item}",item));
}
protected void getItemMsg(CommandSender sender, String item, int amount) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.getItem.replace("{Amount}", String.valueOf(amount)).replace("{Item}", item));
}
protected List<String> online_players() {

70
src/main/java/net/momirealms/customfishing/commands/FishingBagCommand.java
View File

@@ -23,80 +23,29 @@ import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabExecutor;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
import java.util.List;
public class FishingBagCommand implements TabExecutor {
private final Map<String, SubCommand> subCommandMap;
public class FishingBagCommand extends AbstractMainCommand {
public FishingBagCommand() {
subCommandMap = new ConcurrentHashMap<>();
regSubCommand(OpenCommand.INSTANCE);
}
public void regSubCommand(SubCommand executor) {
subCommandMap.put(executor.getSubCommand(), executor);
}
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
if (!ConfigManager.enableFishingBag) return true;
List<String> argList = Arrays.asList(args);
if (argList.size() < 1) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.nonArgs);
return true;
}
SubCommand subCommand = subCommandMap.get(argList.get(0));
if (subCommand != null)
return subCommand.onCommand(sender, argList.subList(1, argList.size()));
else {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.unavailableArgs);
return true;
}
}
@Override
public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
List<String> argList = Arrays.asList(args);
if (argList.size() <= 1) {
List<String> returnList = new ArrayList<>(subCommandMap.keySet());
returnList.removeIf(str -> !str.startsWith(args[0]));
return returnList;
}
SubCommand subCommand = subCommandMap.get(argList.get(0));
if (subCommand != null)
return subCommand.onTabComplete(sender, argList.subList(1, argList.size()));
else
return Collections.singletonList("");
}
public Map<String, SubCommand> getSubCommandMap() {
return subCommandMap;
}
public static class OpenCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new OpenCommand();
public static final OpenCommand INSTANCE = new OpenCommand();
private OpenCommand() {
super("open", null);
super("open");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (!(sender instanceof Player player)) {
AdventureUtil.consoleMessage(MessageManager.prefix + MessageManager.noConsole);
return true;
}
if (super.noConsoleExecute(sender)) return true;
Player player = (Player) sender;
if (args.size() == 0) {
if (!sender.hasPermission("fishingbag.open")) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.noPerm);
@@ -123,11 +72,8 @@ public class FishingBagCommand implements TabExecutor {
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (!ConfigManager.enableFishingBag || !sender.hasPermission("customfishing.admin")) return null;
if (args.size() == 1) {
return online_players().stream()
.filter(cmd -> cmd.startsWith(args.get(0)))
.collect(Collectors.toList());
if (ConfigManager.enableFishingBag && sender.hasPermission("customfishing.admin") && args.size() == 1) {
return filterStartingWith(online_players(), args.get(0));
}
return null;
}

60
src/main/java/net/momirealms/customfishing/commands/MainCommand.java
View File

@@ -19,71 +19,17 @@ package net.momirealms.customfishing.commands;
import net.momirealms.customfishing.commands.subcmd.*;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabExecutor;
import org.jetbrains.annotations.NotNull;
import net.momirealms.customfishing.commands.subcmd.item.ItemsCommand;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class MainCommand implements TabExecutor {
private final Map<String, SubCommand> subCommandMap;
public class MainCommand extends AbstractMainCommand {
public MainCommand() {
subCommandMap = new ConcurrentHashMap<>();
regDefaultSubCommands();
}
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
List<String> argList = Arrays.asList(args);
if (argList.size() < 1) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.nonArgs);
return true;
}
SubCommand subCommand = subCommandMap.get(argList.get(0));
if (subCommand != null)
return subCommand.onCommand(sender, argList.subList(1, argList.size()));
else {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.unavailableArgs);
return true;
}
}
private void regDefaultSubCommands() {
regSubCommand(ReloadCommand.INSTANCE);
regSubCommand(ItemsCommand.INSTANCE);
regSubCommand(CompetitionCommand.INSTANCE);
regSubCommand(ImportCommand.INSTANCE);
regSubCommand(SellShopCommand.INSTANCE);
regSubCommand(OpenBagCommand.INSTANCE);
regSubCommand(StatisticsCommand.INSTANCE);
}
public void regSubCommand(SubCommand executor) {
subCommandMap.put(executor.getSubCommand(), executor);
}
@Override
public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, String[] args) {
List<String> argList = Arrays.asList(args);
if (argList.size() <= 1) {
List<String> returnList = new ArrayList<>(subCommandMap.keySet());
returnList.removeIf(str -> !str.startsWith(args[0]));
return returnList;
}
SubCommand subCommand = subCommandMap.get(argList.get(0));
if (subCommand != null)
return subCommand.onTabComplete(sender, argList.subList(1, argList.size()));
else
return Collections.singletonList("");
}
public Map<String, SubCommand> getSubCommandMap() {
return subCommandMap;
regSubCommand(HelpCommand.INSTANCE);
}
}

2
src/main/java/net/momirealms/customfishing/commands/SellFishCommand.java
View File

@@ -46,4 +46,4 @@ public class SellFishCommand implements TabExecutor {
public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
return null;
}
}
}

37
src/main/java/net/momirealms/customfishing/commands/SubCommand.java
View File

@@ -1,37 +0,0 @@
/*
* Copyright (C) <2022> <XiaoMoMi>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package net.momirealms.customfishing.commands;
import org.bukkit.command.CommandSender;
import java.util.List;
import java.util.Map;
public interface SubCommand {
boolean onCommand(CommandSender sender, List<String> args);
List<String> onTabComplete(CommandSender sender, List<String> args);
String getSubCommand();
Map<String, SubCommand> getSubCommands();
void regSubCommand(SubCommand subCommand);
}

120
src/main/java/net/momirealms/customfishing/commands/subcmd/BaitCommand.java
View File

@@ -1,120 +0,0 @@
/*
* Copyright (C) <2022> <XiaoMoMi>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package net.momirealms.customfishing.commands.subcmd;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.commands.SubCommand;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import net.momirealms.customfishing.util.ItemStackUtil;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class BaitCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new BaitCommand();
public BaitCommand() {
super("bait", null);
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (args.size() < 2) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
}
else if (args.get(0).equalsIgnoreCase("get")) {
if (sender instanceof Player player){
if (!CustomFishing.getInstance().getEffectManager().getBaitItems().containsKey(args.get(1))) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.itemNotExist);
return true;
}
if (args.size() == 2){
ItemStackUtil.givePlayerBait(player, args.get(1), 1);
AdventureUtil.playerMessage(player, MessageManager.prefix + MessageManager.getItem.replace("{Amount}", "1").replace("{Item}", args.get(1)));
} else {
if (Integer.parseInt(args.get(2)) < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerBait(player, args.get(1), Integer.parseInt(args.get(2)));
AdventureUtil.playerMessage(player, MessageManager.prefix + MessageManager.getItem.replace("{Amount}", args.get(2)).replace("{Item}", args.get(1)));
}
} else {
AdventureUtil.consoleMessage(MessageManager.prefix + MessageManager.noConsole);
}
}
else if (args.get(0).equalsIgnoreCase("give")) {
if (args.size() < 3){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
return true;
}
Player player = Bukkit.getPlayer(args.get(1));
if (player == null){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.notOnline.replace("{Player}", args.get(1)));
return true;
}
if (!CustomFishing.getInstance().getEffectManager().getBaitItems().containsKey(args.get(2))) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.itemNotExist);
return true;
}
if (args.size() == 3){
ItemStackUtil.givePlayerBait(player, args.get(2), 1);
super.giveItemMsg(sender, args.get(1), args.get(2), 1);
} else {
if (Integer.parseInt(args.get(3)) < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerBait(player, args.get(2), Integer.parseInt(args.get(3)));
super.giveItemMsg(sender, args.get(1), args.get(2), Integer.parseInt(args.get(3)));
}
}
return true;
}
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return List.of("get", "give");
} else if (args.size() == 2) {
if (args.get(0).equals("get")) {
return filterStartingWith(baits(), args.get(1));
} else if (args.get(0).equals("give")) {
return filterStartingWith(online_players(), args.get(1));
}
} else if (args.size() == 3) {
if (args.get(0).equals("get")) {
return List.of("1", "2", "4", "8", "16", "32", "64");
} else if (args.get(0).equals("give")) {
return filterStartingWith(baits(), args.get(2));
}
} else if (args.size() == 4 && args.get(0).equals("give")) {
return List.of("1", "2", "4", "8", "16", "32", "64");
}
return null;
}
private List<String> baits() {
return new ArrayList<>(CustomFishing.getInstance().getEffectManager().getBaitItems().keySet());
}
}

11
src/main/java/net/momirealms/customfishing/commands/subcmd/CompetitionCommand.java
View File

@@ -19,7 +19,6 @@ package net.momirealms.customfishing.commands.subcmd;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.commands.SubCommand;
import net.momirealms.customfishing.fishing.competition.CompetitionSchedule;
import net.momirealms.customfishing.manager.ConfigManager;
import net.momirealms.customfishing.manager.MessageManager;
@@ -31,19 +30,15 @@ import java.util.List;
public class CompetitionCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new CompetitionCommand();
public static final CompetitionCommand INSTANCE = new CompetitionCommand();
public CompetitionCommand() {
super("competition", null);
super("competition");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (!ConfigManager.enableCompetition) return true;
if (args.size() < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
return true;
}
if (!ConfigManager.enableCompetition || super.lackArgs(sender, 1, args.size())) return true;
switch (args.get(0)) {
case "start" -> {
if (args.size() < 2) {

49
src/main/java/net/momirealms/customfishing/commands/subcmd/HelpCommand.java Normal file
View File

@@ -0,0 +1,49 @@
package net.momirealms.customfishing.commands.subcmd;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.util.AdventureUtil;
import org.bukkit.command.CommandSender;
import java.util.List;
public class HelpCommand extends AbstractSubCommand {
public static final HelpCommand INSTANCE = new HelpCommand();
public HelpCommand() {
super("help");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
AdventureUtil.sendMessage(sender, "<#4169E1>/customfishing");
AdventureUtil.sendMessage(sender, " <gray>├─<white>reload <#87CEFA>Reload the plugin");
AdventureUtil.sendMessage(sender, " <gray>├─<white>forceopenbag <player> <#87CEFA>Force a player to open his fishing bag");
AdventureUtil.sendMessage(sender, " <gray>├─<white>sellshop <player> <#87CEFA>Force a player to open sell shop");
AdventureUtil.sendMessage(sender, " <gray>├─<white>competition");
AdventureUtil.sendMessage(sender, " <gray>│ ├─<white>start <id> <#87CEFA>Start a competition");
AdventureUtil.sendMessage(sender, " <gray>│ ├─<white>end <#87CEFA>End the ongoing competition");
AdventureUtil.sendMessage(sender, " <gray>│ └─<white>cancel <#87CEFA>Cancel the ongoing competition");
AdventureUtil.sendMessage(sender, " <gray>├─<white>items");
AdventureUtil.sendMessage(sender, " <gray>│ ├─<white>loot");
AdventureUtil.sendMessage(sender, " <gray>│ │ ├─<white>get <id> [amount]");
AdventureUtil.sendMessage(sender, " <gray>│ │ ├─<white>give <player> <id> [amount]");
AdventureUtil.sendMessage(sender, " <gray>│ │ └─<white>import <key> <#87CEFA>Import the item in hand");
AdventureUtil.sendMessage(sender, " <gray>│ ├─<white>rod");
AdventureUtil.sendMessage(sender, " <gray>│ │ ├─<white>get <id> [amount]");
AdventureUtil.sendMessage(sender, " <gray>│ │ └─<white>give <player> <id> [amount]");
AdventureUtil.sendMessage(sender, " <gray>│ ├─<white>bait");
AdventureUtil.sendMessage(sender, " <gray>│ │ ├─<white>get <id> [amount]");
AdventureUtil.sendMessage(sender, " <gray>│ │ └─<white>give <player> <id> [amount]");
AdventureUtil.sendMessage(sender, " <gray>│ └─<white>util");
AdventureUtil.sendMessage(sender, " <gray>│ ├─<white>et <id> [amount]");
AdventureUtil.sendMessage(sender, " <gray>│ └─<white>give <player> <id> [amount]");
AdventureUtil.sendMessage(sender, " <gray>└─<white>statistics");
AdventureUtil.sendMessage(sender, " <gray>├─<white>reset <player> <#87CEFA>Reset a player's statistics");
AdventureUtil.sendMessage(sender, " <gray>└─<white>set <player> <id> <value> <#87CEFA>Set certain statistics' value");
AdventureUtil.sendMessage(sender, "<#4169E1>/fishingbag");
AdventureUtil.sendMessage(sender, " <gray>└─<white>open [player] <#87CEFA>Open the fishing bag");
AdventureUtil.sendMessage(sender, "<#4169E1>/sellshop <#87CEFA>Open the sell shop");
return true;
}
}

64
src/main/java/net/momirealms/customfishing/commands/subcmd/ImportCommand.java
View File

@@ -1,64 +0,0 @@
/*
* Copyright (C) <2022> <XiaoMoMi>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package net.momirealms.customfishing.commands.subcmd;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.commands.SubCommand;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import net.momirealms.customfishing.util.ItemStackUtil;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.Collections;
import java.util.List;
public class ImportCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new ImportCommand();
public ImportCommand() {
super("import", null);
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (args.size() < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
return true;
} else if (sender instanceof Player player) {
if (ItemStackUtil.saveToFile(player.getInventory().getItemInMainHand(), args.get(0))) {
AdventureUtil.playerMessage(player, MessageManager.prefix + "Done! File is saved to /CustomFishing/loots/imported.yml");
}
else {
AdventureUtil.playerMessage(player, MessageManager.prefix + "<red>Error. The item can't be null or there already exists loot with that key name");
}
} else {
AdventureUtil.consoleMessage(MessageManager.prefix + MessageManager.noConsole);
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return Collections.singletonList("<key>");
}
return super.onTabComplete(sender, args);
}
}

140
src/main/java/net/momirealms/customfishing/commands/subcmd/LootCommand.java
View File

@@ -1,140 +0,0 @@
/*
* Copyright (C) <2022> <XiaoMoMi>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package net.momirealms.customfishing.commands.subcmd;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.commands.SubCommand;
import net.momirealms.customfishing.fishing.loot.DroppedItem;
import net.momirealms.customfishing.fishing.loot.Loot;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import net.momirealms.customfishing.util.ItemStackUtil;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class LootCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new LootCommand();
public LootCommand() {
super("loot", null);
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (args.size() < 2) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
}
else if (args.get(0).equalsIgnoreCase("get")) {
if (sender instanceof Player player){
if (!loots().contains(args.get(1))){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.itemNotExist);
return true;
}
if (args.size() == 2) {
ItemStackUtil.givePlayerLoot(player, args.get(1), 1);
AdventureUtil.playerMessage(player, MessageManager.prefix + MessageManager.getItem.replace("{Amount}", "1").replace("{Item}", args.get(1)));
} else {
if (Integer.parseInt(args.get(2)) < 1) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerLoot(player, args.get(1), Integer.parseInt(args.get(2)));
AdventureUtil.playerMessage(player, MessageManager.prefix + MessageManager.getItem.replace("{Amount}", args.get(2)).replace("{Item}", args.get(1)));
}
} else {
AdventureUtil.consoleMessage(MessageManager.prefix + MessageManager.noConsole);
}
}
else if (args.get(0).equalsIgnoreCase("give")) {
if (args.size() < 3){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
return true;
}
Player player = Bukkit.getPlayer(args.get(1));
if (player == null){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.notOnline.replace("{Player}", args.get(1)));
return true;
}
if (!loots().contains(args.get(2))){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.itemNotExist);
return true;
}
if (args.size() == 3){
ItemStackUtil.givePlayerLoot(player, args.get(2), 1);
super.giveItemMsg(sender, args.get(1), args.get(2), 1);
} else {
if (Integer.parseInt(args.get(3)) < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerLoot(player, args.get(2), Integer.parseInt(args.get(3)));
super.giveItemMsg(sender, args.get(1), args.get(2), Integer.parseInt(args.get(3)));
}
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return List.of("get", "give");
}
else if (args.size() == 2) {
if ("get".equals(args.get(0))) {
return filterStartingWith(loots(), args.get(1));
}
else if ("give".equals(args.get(0))) {
return filterStartingWith(online_players(), args.get(1));
}
}
else if (args.size() == 3) {
if ("get".equals(args.get(0))) {
return List.of("1", "2", "4", "8", "16", "32", "64");
}
else if ("give".equals(args.get(0))) {
return filterStartingWith(loots(), args.get(2));
}
}
else if (args.size() == 4 && "give".equals(args.get(0))) {
return List.of("1", "2", "4", "8", "16", "32", "64");
}
return null;
}
private List<String> loots() {
List<String> loots = new ArrayList<>();
for (Map.Entry<String, Loot> en : CustomFishing.getInstance().getLootManager().getWaterLoots().entrySet()) {
if (en.getValue() instanceof DroppedItem) {
loots.add(en.getKey());
}
}
for (Map.Entry<String, Loot> en : CustomFishing.getInstance().getLootManager().getLavaLoots().entrySet()) {
if (en.getValue() instanceof DroppedItem) {
loots.add(en.getKey());
}
}
return loots;
}
}

36
src/main/java/net/momirealms/customfishing/commands/subcmd/OpenBagCommand.java
View File

@@ -2,10 +2,7 @@ package net.momirealms.customfishing.commands.subcmd;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.commands.SubCommand;
import net.momirealms.customfishing.manager.ConfigManager;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -14,37 +11,30 @@ import java.util.List;
public class OpenBagCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new OpenBagCommand();
public static final OpenBagCommand INSTANCE = new OpenBagCommand();
private OpenBagCommand() {
super("forceopenbag", null);
super("forceopenbag");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (!ConfigManager.enableFishingBag) return true;
if (args.size() < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
return true;
}
if (args.size() == 1) {
Player viewer = Bukkit.getPlayer(args.get(0));
if (viewer == null) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.playerNotExist);
return true;
}
viewer.closeInventory();
CustomFishing.getInstance().getBagDataManager().openFishingBag(viewer, viewer, false);
}
if (!ConfigManager.enableFishingBag
|| super.lackArgs(sender, 1, args.size())
|| playerNotOnline(sender, args.get(0))
) return true;
Player viewer = Bukkit.getPlayer(args.get(0));
assert viewer != null;
viewer.closeInventory();
CustomFishing.getInstance().getBagDataManager().openFishingBag(viewer, viewer, false);
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (!ConfigManager.enableFishingBag) return null;
if (args.size() == 1) {
if (ConfigManager.enableFishingBag && args.size() == 1) {
return filterStartingWith(online_players(), args.get(0));
}
return super.onTabComplete(sender, args);
return null;
}
}
}

16
src/main/java/net/momirealms/customfishing/commands/subcmd/ReloadCommand.java
View File

@@ -20,7 +20,6 @@ package net.momirealms.customfishing.commands.subcmd;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.commands.SubCommand;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import org.bukkit.command.CommandSender;
@@ -29,20 +28,17 @@ import java.util.List;
public final class ReloadCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new ReloadCommand();
public static final ReloadCommand INSTANCE = new ReloadCommand();
private ReloadCommand() {
super("reload", null);
super("reload");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (args.size() < 1) {
long time1 = System.currentTimeMillis();
CustomFishing.getInstance().reload();
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.reload.replace("{time}", String.valueOf(System.currentTimeMillis() - time1)));
return true;
}
return super.onCommand(sender, args);
long time1 = System.currentTimeMillis();
CustomFishing.getInstance().reload();
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.reload.replace("{time}", String.valueOf(System.currentTimeMillis() - time1)));
return true;
}
}

122
src/main/java/net/momirealms/customfishing/commands/subcmd/RodCommand.java
View File

@@ -1,122 +0,0 @@
/*
* Copyright (C) <2022> <XiaoMoMi>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package net.momirealms.customfishing.commands.subcmd;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.commands.SubCommand;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import net.momirealms.customfishing.util.ItemStackUtil;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class RodCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new RodCommand();
public RodCommand() {
super("rod", null);
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (args.size() < 2) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
return true;
}
if (args.get(0).equalsIgnoreCase("get")) {
if (sender instanceof Player player){
if (!CustomFishing.getInstance().getEffectManager().getRodItems().containsKey(args.get(1))){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.itemNotExist);
return true;
}
if (args.size() == 2){
ItemStackUtil.givePlayerRod(player, args.get(1), 1);
AdventureUtil.playerMessage(player, MessageManager.prefix + MessageManager.getItem.replace("{Amount}", "1").replace("{Item}", args.get(1)));
} else {
if (Integer.parseInt(args.get(2)) < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerRod(player, args.get(1), Integer.parseInt(args.get(2)));
AdventureUtil.playerMessage(player, MessageManager.prefix + MessageManager.getItem.replace("{Amount}", args.get(2)).replace("{Item}", args.get(1)));
}
} else {
AdventureUtil.consoleMessage(MessageManager.prefix + MessageManager.noConsole);
}
}
else if (args.get(0).equalsIgnoreCase("give")) {
if (args.size() < 3){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
return true;
}
Player player = Bukkit.getPlayer(args.get(1));
if (player == null){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.notOnline.replace("{Player}", args.get(1)));
return true;
}
if (!CustomFishing.getInstance().getEffectManager().getRodItems().containsKey(args.get(2))){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.itemNotExist);
return true;
}
if (args.size() == 3) {
ItemStackUtil.givePlayerRod(player, args.get(2), 1);
super.giveItemMsg(sender, args.get(1), args.get(2), 1);
} else {
if (Integer.parseInt(args.get(3)) < 1) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerRod(player, args.get(2), Integer.parseInt(args.get(3)));
super.giveItemMsg(sender, args.get(1), args.get(2), Integer.parseInt(args.get(3)));
}
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return List.of("get", "give");
} else if (args.size() == 2) {
if (args.get(0).equals("get")) {
return filterStartingWith(rods(), args.get(1));
} else if (args.get(0).equals("give")) {
return filterStartingWith(online_players(), args.get(1));
}
} else if (args.size() == 3) {
if (args.get(0).equals("get")) {
return List.of("1","2","4","8","16","32","64");
} else if (args.get(0).equals("give")) {
return filterStartingWith(rods(), args.get(2));
}
} else if (args.size() == 4 && args.get(0).equals("give")) {
return List.of("1","2","4","8","16","32","64");
}
return null;
}
private List<String> rods() {
return new ArrayList<>(CustomFishing.getInstance().getEffectManager().getRodItems().keySet());
}
}

26
src/main/java/net/momirealms/customfishing/commands/subcmd/SellShopCommand.java
View File

@@ -2,9 +2,6 @@ package net.momirealms.customfishing.commands.subcmd;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.commands.SubCommand;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -13,25 +10,19 @@ import java.util.List;
public class SellShopCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new SellShopCommand();
public static final SellShopCommand INSTANCE = new SellShopCommand();
public SellShopCommand() {
super("sellshop", null);
super("sellshop");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (args.size() < 1) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
return true;
}
if (super.lackArgs(sender, 1, args.size())
|| playerNotOnline(sender, args.get(0))
) return true;
Player player = Bukkit.getPlayer(args.get(0));
if (player == null) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.notOnline.replace("{Player}", args.get(0)));
return true;
}
assert player != null;
player.closeInventory();
CustomFishing.getInstance().getSellManager().openGuiForPlayer(player);
return true;
@@ -39,6 +30,9 @@ public class SellShopCommand extends AbstractSubCommand {
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
return online_players();
if (args.size() == 1) {
return filterStartingWith(online_players(), args.get(0));
}
return null;
}
}

76
src/main/java/net/momirealms/customfishing/commands/subcmd/StatisticsCommand.java
View File

@@ -2,7 +2,6 @@ package net.momirealms.customfishing.commands.subcmd;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.commands.SubCommand;
import net.momirealms.customfishing.fishing.loot.Loot;
import net.momirealms.customfishing.manager.ConfigManager;
import net.momirealms.customfishing.manager.MessageManager;
@@ -16,55 +15,49 @@ import java.util.stream.Collectors;
public class StatisticsCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new StatisticsCommand();
public static final StatisticsCommand INSTANCE = new StatisticsCommand();
public StatisticsCommand() {
super("statistics", null);
super("statistics");
regSubCommand(SetCommand.INSTANCE);
regSubCommand(ResetCommand.INSTANCE);
}
public static class SetCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new SetCommand();
public static final SetCommand INSTANCE = new SetCommand();
public SetCommand() {
super("set", null);
super("set");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (!ConfigManager.enableStatistics) return true;
if (args.size() < 3) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
return true;
}
if (!ConfigManager.enableStatistics
|| super.lackArgs(sender, 3, args.size())
|| super.playerNotOnline(sender, args.get(0))
) return true;
int amount = Integer.parseInt(args.get(2));
if (amount < 0) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.negativeStatistics);
return true;
}
if (CustomFishing.getInstance().getLootManager().hasLoot(args.get(1))) {
Player player = Bukkit.getPlayer(args.get(0));
if (player != null) {
CustomFishing.getInstance().getStatisticsManager().setData(player.getUniqueId(), args.get(1), amount);
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.setStatistics.replace("{Player}", args.get(0)).replace("{Amount}", args.get(2)).replace("{Loot}", args.get(1)));
}
else {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.notOnline.replace("{Player}", args.get(0)));
}
}
else {
Loot loot = CustomFishing.getInstance().getLootManager().getLoot(args.get(1));
if (loot == null || loot.isDisableStats()) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.statisticsNotExists);
return true;
}
Player player = Bukkit.getPlayer(args.get(0));
assert player != null;
CustomFishing.getInstance().getStatisticsManager().setData(player.getUniqueId(), args.get(1), amount);
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.setStatistics.replace("{Player}", args.get(0)).replace("{Amount}", args.get(2)).replace("{Loot}", args.get(1)));
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return online_players().stream()
.filter(player_name -> player_name.startsWith(args.get(0)))
.collect(Collectors.toList());
return filterStartingWith(online_players(), args.get(0));
}
if (args.size() == 2) {
return CustomFishing.getInstance().getLootManager().getAllLoots().stream()
@@ -73,48 +66,37 @@ public class StatisticsCommand extends AbstractSubCommand {
.collect(Collectors.toList());
}
if (args.size() == 3) {
return List.of("0","1","2","4","8","16","32","64");
return filterStartingWith(List.of("0","1","2","4","8","16","32","64"), args.get(2));
}
return super.onTabComplete(sender, args);
return null;
}
}
public static class ResetCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new ResetCommand();
public static final ResetCommand INSTANCE = new ResetCommand();
public ResetCommand() {
super("reset", null);
super("reset");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (!ConfigManager.enableStatistics) return true;
if (args.size() < 1) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
return true;
}
if (!ConfigManager.enableStatistics
|| super.lackArgs(sender, 1, args.size())
|| super.playerNotOnline(sender, args.get(0))
) return true;
Player player = Bukkit.getPlayer(args.get(0));
if (player != null) {
if (CustomFishing.getInstance().getStatisticsManager().reset(player.getUniqueId())) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.resetStatistics);
}
else {
AdventureUtil.sendMessage(sender, MessageManager.prefix + "Internal Error, player's data is not loaded");
}
}
else {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.notOnline.replace("{Player}", args.get(0)));
}
assert player != null;
if (CustomFishing.getInstance().getStatisticsManager().reset(player.getUniqueId())) AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.resetStatistics);
else AdventureUtil.sendMessage(sender, MessageManager.prefix + "Internal Error, player's data is not loaded");
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return online_players().stream()
.filter(player_name -> player_name.startsWith(args.get(0)))
.collect(Collectors.toList());
return filterStartingWith(online_players(), args.get(0));
}
return null;
}

121
src/main/java/net/momirealms/customfishing/commands/subcmd/UtilCommand.java
View File

@@ -1,121 +0,0 @@
/*
* Copyright (C) <2022> <XiaoMoMi>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package net.momirealms.customfishing.commands.subcmd;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.commands.SubCommand;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import net.momirealms.customfishing.util.ItemStackUtil;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class UtilCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new UtilCommand();
public UtilCommand() {
super("util", null);
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (args.size() < 2) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
}
else if (args.get(0).equalsIgnoreCase("get")) {
if (sender instanceof Player player){
if (!CustomFishing.getInstance().getEffectManager().getUtilItems().containsKey(args.get(1))){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.itemNotExist);
return true;
}
if (args.size() == 2){
ItemStackUtil.givePlayerUtil(player, args.get(1), 1);
AdventureUtil.playerMessage(player, MessageManager.prefix + MessageManager.getItem.replace("{Amount}", "1").replace("{Item}", args.get(1)));
} else {
if (Integer.parseInt(args.get(2)) < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerUtil(player, args.get(1), Integer.parseInt(args.get(2)));
AdventureUtil.playerMessage(player, MessageManager.prefix + MessageManager.getItem.replace("{Amount}", args.get(2)).replace("{Item}", args.get(1)));
}
} else {
AdventureUtil.consoleMessage(MessageManager.prefix + MessageManager.noConsole);
}
}
else if (args.get(0).equalsIgnoreCase("give")) {
if (args.size() < 3){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.lackArgs);
return true;
}
Player player = Bukkit.getPlayer(args.get(1));
if (player == null){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.notOnline.replace("{Player}", args.get(1)));
return true;
}
if (!CustomFishing.getInstance().getEffectManager().getUtilItems().containsKey(args.get(2))){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.itemNotExist);
return true;
}
if (args.size() == 3){
ItemStackUtil.givePlayerUtil(player, args.get(2), 1);
super.giveItemMsg(sender, args.get(1), args.get(2), 1);
} else {
if (Integer.parseInt(args.get(3)) < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerUtil(player, args.get(2), Integer.parseInt(args.get(3)));
super.giveItemMsg(sender, args.get(1), args.get(2), Integer.parseInt(args.get(3)));
}
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return List.of("get", "give");
} else if (args.size() == 2) {
if (args.get(0).equals("get")) {
return filterStartingWith(utils(), args.get(1));
} else if (args.get(0).equals("give")) {
return filterStartingWith(online_players(), args.get(1));
}
} else if (args.size() == 3) {
if (args.get(0).equals("get")) {
return List.of("1","2","4","8","16","32","64");
} else if (args.get(0).equals("give")) {
return filterStartingWith(utils(), args.get(2));
}
} else if (args.size() == 4 && args.get(0).equals("give")) {
return List.of("1","2","4","8","16","32","64");
}
return null;
}
private List<String> utils() {
return new ArrayList<>(CustomFishing.getInstance().getEffectManager().getUtilItems().keySet());
}
}

122
src/main/java/net/momirealms/customfishing/commands/subcmd/item/BaitCommand.java Normal file
View File

@@ -0,0 +1,122 @@
/*
* Copyright (C) <2022> <XiaoMoMi>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package net.momirealms.customfishing.commands.subcmd.item;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import net.momirealms.customfishing.util.ItemStackUtil;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class BaitCommand extends AbstractSubCommand {
public static final BaitCommand INSTANCE = new BaitCommand();
public BaitCommand() {
super("bait");
regSubCommand(GetCommand.INSTANCE);
regSubCommand(GiveCommand.INSTANCE);
}
public static class GetCommand extends AbstractSubCommand {
public static final GetCommand INSTANCE = new GetCommand();
public GetCommand() {
super("get");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (super.lackArgs(sender, 1, args.size())
|| super.noConsoleExecute(sender)
|| super.itemNotExist(sender, "bait", args.get(0))
) return true;
if (args.size() == 1){
ItemStackUtil.givePlayerBait((Player) sender, args.get(0), 1);
super.getItemMsg(sender, args.get(0), 1);
} else {
if (Integer.parseInt(args.get(1)) < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerBait((Player) sender, args.get(0), Integer.parseInt(args.get(1)));
super.getItemMsg(sender, args.get(0), Integer.parseInt(args.get(1)));
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return filterStartingWith(new ArrayList<>(CustomFishing.getInstance().getEffectManager().getBaitItems().keySet()), args.get(0));
} else if (args.size() == 2) {
return filterStartingWith(List.of("1", "2", "4", "8", "16", "32", "64"), args.get(1));
}
return null;
}
}
public static class GiveCommand extends AbstractSubCommand {
public static final GiveCommand INSTANCE = new GiveCommand();
public GiveCommand() {
super("give");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (super.lackArgs(sender, 2, args.size())
|| playerNotOnline(sender, args.get(0))
|| itemNotExist(sender, "bait", args.get(1))
) return true;
if (args.size() == 2){
ItemStackUtil.givePlayerBait(Bukkit.getPlayer(args.get(0)), args.get(1), 1);
super.giveItemMsg(sender, args.get(0), args.get(1), 1);
}
else if (args.size() == 3) {
if (Integer.parseInt(args.get(2)) < 1) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerBait(Bukkit.getPlayer(args.get(0)), args.get(1), Integer.parseInt(args.get(2)));
super.giveItemMsg(sender, args.get(0), args.get(1), Integer.parseInt(args.get(2)));
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return filterStartingWith(online_players(), args.get(0));
} else if (args.size() == 2) {
return filterStartingWith(new ArrayList<>(CustomFishing.getInstance().getEffectManager().getBaitItems().keySet()), args.get(1));
} else if (args.size() == 3) {
return filterStartingWith(List.of("1", "2", "4", "8", "16", "32", "64"), args.get(2));
}
return null;
}
}
}

20
src/main/java/net/momirealms/customfishing/commands/subcmd/ItemsCommand.java → src/main/java/net/momirealms/customfishing/commands/subcmd/item/ItemsCommand.java
View File

@@ -15,33 +15,19 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package net.momirealms.customfishing.commands.subcmd;
package net.momirealms.customfishing.commands.subcmd.item;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.commands.SubCommand;
import org.bukkit.command.CommandSender;
import java.util.List;
public class ItemsCommand extends AbstractSubCommand {
public static final SubCommand INSTANCE = new ItemsCommand();
public static final ItemsCommand INSTANCE = new ItemsCommand();
public ItemsCommand() {
super("items", null);
super("items");
regSubCommand(UtilCommand.INSTANCE);
regSubCommand(RodCommand.INSTANCE);
regSubCommand(BaitCommand.INSTANCE);
regSubCommand(LootCommand.INSTANCE);
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
return super.onCommand(sender, args);
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
return super.onTabComplete(sender, args);
}
}

152
src/main/java/net/momirealms/customfishing/commands/subcmd/item/LootCommand.java Normal file
View File

@@ -0,0 +1,152 @@
/*
* Copyright (C) <2022> <XiaoMoMi>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package net.momirealms.customfishing.commands.subcmd.item;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import net.momirealms.customfishing.util.ItemStackUtil;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class LootCommand extends AbstractSubCommand {
public static final LootCommand INSTANCE = new LootCommand();
public LootCommand() {
super("loot");
regSubCommand(GiveCommand.INSTANCE);
regSubCommand(GetCommand.INSTANCE);
regSubCommand(ImportCommand.INSTANCE);
}
public static class GiveCommand extends AbstractSubCommand {
public static final GiveCommand INSTANCE = new GiveCommand();
public GiveCommand() {
super("give");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (super.lackArgs(sender, 2, args.size())
|| playerNotOnline(sender, args.get(0))
|| itemNotExist(sender, "loot", args.get(1))
) return true;
if (args.size() == 2){
ItemStackUtil.givePlayerLoot(Bukkit.getPlayer(args.get(0)), args.get(1), 1);
super.giveItemMsg(sender, args.get(0), args.get(1), 1);
}
else if (args.size() == 3) {
if (Integer.parseInt(args.get(2)) < 1) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerLoot(Bukkit.getPlayer(args.get(0)), args.get(1), Integer.parseInt(args.get(2)));
super.giveItemMsg(sender, args.get(0), args.get(1), Integer.parseInt(args.get(2)));
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return filterStartingWith(online_players(), args.get(0));
} else if (args.size() == 2) {
return filterStartingWith(new ArrayList<>(CustomFishing.getInstance().getLootManager().getAllKeys()), args.get(1));
} else if (args.size() == 3) {
return filterStartingWith(List.of("1", "2", "4", "8", "16", "32", "64"), args.get(2));
}
return null;
}
}
public static class GetCommand extends AbstractSubCommand {
public static final GetCommand INSTANCE = new GetCommand();
public GetCommand() {
super("get");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (super.lackArgs(sender, 1, args.size())
|| super.noConsoleExecute(sender)
|| super.itemNotExist(sender, "loot", args.get(0))
) return true;
if (args.size() == 1){
ItemStackUtil.givePlayerLoot((Player) sender, args.get(0), 1);
super.getItemMsg(sender, args.get(0), 1);
} else {
if (Integer.parseInt(args.get(1)) < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerLoot((Player) sender, args.get(0), Integer.parseInt(args.get(1)));
super.getItemMsg(sender, args.get(0), Integer.parseInt(args.get(1)));
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return filterStartingWith(CustomFishing.getInstance().getLootManager().getAllKeys(), args.get(0));
} else if (args.size() == 2) {
return filterStartingWith(List.of("1", "2", "4", "8", "16", "32", "64"), args.get(1));
}
return null;
}
}
public static class ImportCommand extends AbstractSubCommand {
public static final ImportCommand INSTANCE = new ImportCommand();
public ImportCommand() {
super("import");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (super.noConsoleExecute(sender)
|| lackArgs(sender, 1, args.size())
) return true;
Player player = (Player) sender;
if (ItemStackUtil.saveToFile(player.getInventory().getItemInMainHand(), args.get(0))) AdventureUtil.playerMessage(player, MessageManager.prefix + "Done! File is saved to /CustomFishing/loots/imported.yml");
else AdventureUtil.playerMessage(player, MessageManager.prefix + "<red>Error. The item can't be null or there already exists loot with that key name");
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return Collections.singletonList("<key>");
}
return super.onTabComplete(sender, args);
}
}
}

122
src/main/java/net/momirealms/customfishing/commands/subcmd/item/RodCommand.java Normal file
View File

@@ -0,0 +1,122 @@
/*
* Copyright (C) <2022> <XiaoMoMi>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package net.momirealms.customfishing.commands.subcmd.item;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import net.momirealms.customfishing.util.ItemStackUtil;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class RodCommand extends AbstractSubCommand {
public static final RodCommand INSTANCE = new RodCommand();
public RodCommand() {
super("rod");
regSubCommand(GetCommand.INSTANCE);
regSubCommand(GiveCommand.INSTANCE);
}
public static class GiveCommand extends AbstractSubCommand {
public static final GiveCommand INSTANCE = new GiveCommand();
public GiveCommand() {
super("give");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (super.lackArgs(sender, 2, args.size())
|| playerNotOnline(sender, args.get(0))
|| itemNotExist(sender, "rod", args.get(1))
) return true;
if (args.size() == 2){
ItemStackUtil.givePlayerRod(Bukkit.getPlayer(args.get(0)), args.get(1), 1);
super.giveItemMsg(sender, args.get(0), args.get(1), 1);
}
else if (args.size() == 3) {
if (Integer.parseInt(args.get(2)) < 1) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerRod(Bukkit.getPlayer(args.get(0)), args.get(1), Integer.parseInt(args.get(2)));
super.giveItemMsg(sender, args.get(0), args.get(1), Integer.parseInt(args.get(2)));
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return filterStartingWith(online_players(), args.get(0));
} else if (args.size() == 2) {
return filterStartingWith(new ArrayList<>(CustomFishing.getInstance().getEffectManager().getRodItems().keySet()), args.get(1));
} else if (args.size() == 3) {
return filterStartingWith(List.of("1", "2", "4", "8", "16", "32", "64"), args.get(2));
}
return null;
}
}
public static class GetCommand extends AbstractSubCommand {
public static final GetCommand INSTANCE = new GetCommand();
public GetCommand() {
super("get");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (super.lackArgs(sender, 1, args.size())
|| super.noConsoleExecute(sender)
|| super.itemNotExist(sender, "rod", args.get(0))
) return true;
if (args.size() == 1){
ItemStackUtil.givePlayerRod((Player) sender, args.get(0), 1);
super.getItemMsg(sender, args.get(0), 1);
} else {
if (Integer.parseInt(args.get(1)) < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerRod((Player) sender, args.get(0), Integer.parseInt(args.get(1)));
super.getItemMsg(sender, args.get(0), Integer.parseInt(args.get(1)));
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return filterStartingWith(new ArrayList<>(CustomFishing.getInstance().getEffectManager().getRodItems().keySet()), args.get(0));
} else if (args.size() == 2) {
return filterStartingWith(List.of("1", "2", "4", "8", "16", "32", "64"), args.get(1));
}
return null;
}
}
}

122
src/main/java/net/momirealms/customfishing/commands/subcmd/item/UtilCommand.java Normal file
View File

@@ -0,0 +1,122 @@
/*
* Copyright (C) <2022> <XiaoMoMi>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package net.momirealms.customfishing.commands.subcmd.item;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.commands.AbstractSubCommand;
import net.momirealms.customfishing.manager.MessageManager;
import net.momirealms.customfishing.util.AdventureUtil;
import net.momirealms.customfishing.util.ItemStackUtil;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class UtilCommand extends AbstractSubCommand {
public static final UtilCommand INSTANCE = new UtilCommand();
public UtilCommand() {
super("util");
regSubCommand(GetCommand.INSTANCE);
regSubCommand(GiveCommand.INSTANCE);
}
public static class GetCommand extends AbstractSubCommand {
public static final GetCommand INSTANCE = new GetCommand();
public GetCommand() {
super("get");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (super.lackArgs(sender, 1, args.size())
|| super.noConsoleExecute(sender)
|| super.itemNotExist(sender, "util", args.get(0))
) return true;
if (args.size() == 1){
ItemStackUtil.givePlayerUtil((Player) sender, args.get(0), 1);
super.getItemMsg(sender, args.get(0), 1);
} else {
if (Integer.parseInt(args.get(1)) < 1){
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerUtil((Player) sender, args.get(0), Integer.parseInt(args.get(1)));
super.getItemMsg(sender, args.get(0), Integer.parseInt(args.get(1)));
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return filterStartingWith(new ArrayList<>(CustomFishing.getInstance().getEffectManager().getUtilItems().keySet()), args.get(0));
} else if (args.size() == 2) {
return filterStartingWith(List.of("1", "2", "4", "8", "16", "32", "64"), args.get(1));
}
return null;
}
}
public static class GiveCommand extends AbstractSubCommand {
public static final GiveCommand INSTANCE = new GiveCommand();
public GiveCommand() {
super("give");
}
@Override
public boolean onCommand(CommandSender sender, List<String> args) {
if (super.lackArgs(sender, 2, args.size())
|| playerNotOnline(sender, args.get(0))
|| itemNotExist(sender, "util", args.get(1))
) return true;
if (args.size() == 2){
ItemStackUtil.givePlayerUtil(Bukkit.getPlayer(args.get(0)), args.get(1), 1);
super.giveItemMsg(sender, args.get(0), args.get(1), 1);
}
else if (args.size() == 3) {
if (Integer.parseInt(args.get(2)) < 1) {
AdventureUtil.sendMessage(sender, MessageManager.prefix + MessageManager.wrongAmount);
return true;
}
ItemStackUtil.givePlayerUtil(Bukkit.getPlayer(args.get(0)), args.get(1), Integer.parseInt(args.get(2)));
super.giveItemMsg(sender, args.get(0), args.get(1), Integer.parseInt(args.get(2)));
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, List<String> args) {
if (args.size() == 1) {
return filterStartingWith(online_players(), args.get(0));
} else if (args.size() == 2) {
return filterStartingWith(new ArrayList<>(CustomFishing.getInstance().getEffectManager().getUtilItems().keySet()), args.get(1));
} else if (args.size() == 3) {
return filterStartingWith(List.of("1", "2", "4", "8", "16", "32", "64"), args.get(2));
}
return null;
}
}
}

1
src/main/java/net/momirealms/customfishing/fishing/action/VanillaXPImpl.java
View File

@@ -21,7 +21,6 @@ import net.kyori.adventure.key.Key;
import net.kyori.adventure.sound.Sound;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.util.AdventureUtil;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.ExperienceOrb;
import org.bukkit.entity.Player;

1
src/main/java/net/momirealms/customfishing/fishing/mode/ModeOneGame.java
View File

@@ -21,7 +21,6 @@ import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.fishing.bar.ModeOneBar;
import net.momirealms.customfishing.manager.FishingManager;
import net.momirealms.customfishing.util.AdventureUtil;
import org.bukkit.entity.FishHook;
import org.bukkit.entity.Player;
public class ModeOneGame extends FishingGame {

1
src/main/java/net/momirealms/customfishing/fishing/totem/ActivatedTotem.java
View File

@@ -30,7 +30,6 @@ import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
public class ActivatedTotem extends BukkitRunnable {

1
src/main/java/net/momirealms/customfishing/integration/job/JobsRebornImpl.java
View File

@@ -18,7 +18,6 @@
package net.momirealms.customfishing.integration.job;
import com.gamingmesh.jobs.Jobs;
import com.gamingmesh.jobs.PlayerManager;
import com.gamingmesh.jobs.container.Job;
import com.gamingmesh.jobs.container.JobProgression;
import com.gamingmesh.jobs.container.JobsPlayer;

1
src/main/java/net/momirealms/customfishing/integration/quest/OldBetonQuestCFQuest.java
View File

@@ -31,7 +31,6 @@ import pl.betoncraft.betonquest.api.Objective;
import pl.betoncraft.betonquest.config.Config;
import pl.betoncraft.betonquest.exceptions.InstructionParseException;
import pl.betoncraft.betonquest.exceptions.QuestRuntimeException;
import pl.betoncraft.betonquest.objectives.FishObjective;
import pl.betoncraft.betonquest.utils.LogUtils;
import pl.betoncraft.betonquest.utils.PlayerConverter;

1
src/main/java/net/momirealms/customfishing/manager/EffectManager.java
View File

@@ -30,7 +30,6 @@ import org.jetbrains.annotations.Nullable;
import java.io.File;
import java.util.HashMap;
import java.util.Objects;
import java.util.Set;
public class EffectManager extends Function {

30
src/main/java/net/momirealms/customfishing/manager/LootManager.java
View File

@@ -19,9 +19,8 @@ package net.momirealms.customfishing.manager;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.fishing.MiniGameConfig;
import net.momirealms.customfishing.fishing.action.*;
import net.momirealms.customfishing.fishing.action.Action;
import net.momirealms.customfishing.fishing.loot.*;
import net.momirealms.customfishing.fishing.requirements.*;
import net.momirealms.customfishing.object.Function;
import net.momirealms.customfishing.object.LeveledEnchantment;
import net.momirealms.customfishing.util.AdventureUtil;
@@ -35,8 +34,6 @@ import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.MemorySection;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.inventory.ItemStack;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -171,7 +168,7 @@ public class LootManager extends Function {
);
setActions(mobSection, loot);
setRequirements(mobSection.getConfigurationSection("requirements"), loot);
loot.setRequirements(ConfigUtil.getRequirements(mobSection.getConfigurationSection("requirements")));
if (mobSection.getBoolean("in-lava", false)) lavaLoots.put(key, loot);
else waterLoots.put(key, loot);
@@ -238,7 +235,7 @@ public class LootManager extends Function {
}
setActions(lootSection, loot);
setRequirements(lootSection.getConfigurationSection("requirements"), loot);
loot.setRequirements(ConfigUtil.getRequirements(lootSection.getConfigurationSection("requirements")));
if (key.equals("vanilla")) {
vanilla_loot = loot;
continue;
@@ -272,12 +269,6 @@ public class LootManager extends Function {
}
}
private void setRequirements(ConfigurationSection section, Loot loot) {
loot.setRequirements(ConfigUtil.getRequirements(section));
}
private MiniGameConfig[] getMiniGames(ConfigurationSection section) {
String[] games = section.getStringList("mini-game").size() == 0 ? new String[]{section.getString("mini-game", null)} : section.getStringList("mini-game").toArray(new String[0]);
MiniGameConfig[] gameConfigs = new MiniGameConfig[games.length];
@@ -309,6 +300,21 @@ public class LootManager extends Function {
return loots;
}
public ArrayList<String> getAllKeys() {
ArrayList<String> loots = new ArrayList<>();
for (Map.Entry<String, Loot> en : CustomFishing.getInstance().getLootManager().getWaterLoots().entrySet()) {
if (en.getValue() instanceof DroppedItem) {
loots.add(en.getKey());
}
}
for (Map.Entry<String, Loot> en : CustomFishing.getInstance().getLootManager().getLavaLoots().entrySet()) {
if (en.getValue() instanceof DroppedItem) {
loots.add(en.getKey());
}
}
return loots;
}
@Nullable
public List<String> getCategories(String categoryID) {
return category.get(categoryID);

1
src/main/java/net/momirealms/customfishing/manager/SellManager.java
View File

@@ -30,7 +30,6 @@ import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.api.event.SellFishEvent;
import net.momirealms.customfishing.data.PlayerSellData;
import net.momirealms.customfishing.fishing.loot.Item;
import net.momirealms.customfishing.integration.papi.PlaceholderManager;
import net.momirealms.customfishing.listener.InventoryListener;
import net.momirealms.customfishing.listener.JoinQuitListener;
import net.momirealms.customfishing.listener.WindowPacketListener;

4
src/main/java/net/momirealms/customfishing/object/DynamicText.java
View File

@@ -18,15 +18,11 @@
package net.momirealms.customfishing.object;
import net.momirealms.customfishing.CustomFishing;
import net.momirealms.customfishing.fishing.competition.Competition;
import net.momirealms.customfishing.fishing.competition.ranking.RankingInterface;
import net.momirealms.customfishing.integration.papi.PlaceholderManager;
import net.momirealms.customfishing.manager.MessageManager;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
public class DynamicText {

4
src/main/resources/categories/default.yml
View File

@@ -3,10 +3,6 @@
# %fishingstats_category_total_<id>% get the total number of a certain category's fish caught
# %fishingstats_category_progress_<id>% get the player's exploration of this category of fish
normal_fish:
- pufferfish
- cod
- salmon
- tropical_fish
- tuna_fish
- pike_fish
- gold_fish

28
src/main/resources/messages/messages_english.yml
View File

@@ -2,35 +2,35 @@
#https://docs.adventure.kyori.net/minimessage/format.html
messages:
prefix: '<gradient:#0070B3:#A0EACF>[CustomFishing] </gradient>'
reload: 'Reloaded'
reload: '<white>Reloaded. Took <green>{time}ms'
no-perm: 'You don''t have permission!'
not-online: 'That player is not online!'
item-not-exist: 'That item does not exist!'
player-not-exist: 'That player does not exist!'
escape: 'It has been too long since the fish is hooked. Oh my god, it escaped!'
give-item: 'Successfully given players {Player} {Amount}x {Item}.'
give-item: 'Successfully given player {Player} {Amount}x {Item}.'
get-item: 'Successfully obtained {Amount}x {Item}.'
no-console: 'This command cannot be executed from the console!'
wrong-amount: 'You cannot give a player an item with a negative quantity!'
lack-args: 'Insufficient parameters.'
wrong-amount: 'You can''t set an negative amount of items!'
lack-args: 'Insufficient arguments.'
none-args: 'None arguments!'
invalid-args: 'Invalid arguments!'
possible-loots: 'Possible loots here: '
reach-sell-limit: 'You have earned a lot from selling fish! Come tomorrow.'
reach-sell-limit: 'You have earned too much from selling fish! Come tomorrow.'
split-char: ', '
no-loot: 'There''s no fish in this place!'
competition-ongoing: 'There is currently a fishing tournament in progress! Start fishing to join the contest for a prize!'
players-not-enough: 'The number of players is not enough for the fishing contest to be held as scheduled!'
competition-ongoing: 'There is currently a fishing competition in progress! Start fishing to join the competition for a prize!'
players-not-enough: 'The number of players is not enough for the fishing competition to be started as scheduled!'
no-rank: 'No Rank'
force-competition-success: 'Forced to start a fishing contest'
force-competition-failure: 'This contest does not exist'
force-competition-end: 'Forced to end the current contest'
force-competition-cancel: 'Forced to cancel the contest'
hook-other-entity: 'The bobber is hooked on another entity!'
no-rod: 'You have to obtain a special rod to get loots!'
force-competition-success: 'Forced to start a fishing competition'
force-competition-failure: 'This competition does not exist'
force-competition-end: 'Forced to end the current competition'
force-competition-cancel: 'Forced to cancel the competition'
hook-other-entity: 'The hook is hooked on another entity!'
no-rod: 'You have to fish with a special rod to get loots!'
no-player: 'No player'
no-score: 'No score'
set-statistics: 'Successfully set {Player}''s {Loot} statistics to {Amount}'
reset-statistics: 'Successfully reset {Player}''s statistics'
negative-statistics: 'Amount should be a value no lower than zero'
statistics-not-exist: 'That statistics does not exist'
statistics-not-exist: 'The statistics does not exist'