Redstoner/Modules
Archived
0
Fork 0
Code Activity

Re-wrote BlockPlaceMods

Browse Source
This commit is contained in:
David
2019-01-03 23:24:31 +01:00
parent adbb2c9cb2
commit ff348a6e3f
20 changed files with 586 additions and 886 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/main/java/com/redstoner/modules/blockplacemods/BlockPlaceMod.java Normal file
View File

@@ -0,0 +1,42 @@
package com.redstoner.modules.blockplacemods;
import com.redstoner.modules.datamanager.DataManager;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
public class BlockPlaceMod implements Listener {
public final String name;
public final String[] aliases;
public final String description;
public final ModType type;
public final String typeDescription;
public final boolean enabledByDefault;
protected BlockPlaceMod(String name, String description, ModType type, String typeDescription, boolean enabledByDefault, String... aliases) {
this.name = name;
this.aliases = aliases;
this.description = description;
this.type = type;
this.typeDescription = typeDescription;
this.enabledByDefault = enabledByDefault;
}
protected final boolean hasEnabled(Player player) {
String uuid = player.getUniqueId().toString();
return (boolean) DataManager.getOrDefault(uuid, "BlockPlaceMods", name, enabledByDefault);
}
protected final Object getState(Player player) {
String uuid = player.getUniqueId().toString();
return DataManager.getOrDefault(uuid, "BlockPlaceMods", name + "_state", null);
}
public boolean onEnable() {
return true;
}
public void onDisable() {}
}

28
src/main/java/com/redstoner/modules/blockplacemods/BlockPlaceMods.cmd Normal file
View File

@@ -0,0 +1,28 @@
command bpm {
alias set;
alias toggle;
perm blockplacemods.use;
type player;
[empty] {
help Lists the block place mods and their statuses.;
run list_mods;
}
reset [string:mod] {
Help Resets the specified mod's settings to the default value.;
run reset_mod mod;
}
[string:mod] {
help Toggles a block place mod.;
run toggle_mod mod;
}
[string:mod] [string:value] {
help Sets the specified mod's state to the specified value. Only works for mods that have a state.;
run set_mod_value mod value;
}
}

430
src/main/java/com/redstoner/modules/blockplacemods/BlockPlaceMods.java
View File

@@ -1,17 +1,5 @@
package com.redstoner.modules.blockplacemods;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import com.nemez.cmdmgr.Command;
import com.redstoner.annotations.AutoRegisterListener;
import com.redstoner.annotations.Commands;
@@ -19,188 +7,268 @@ import com.redstoner.annotations.Version;
import com.redstoner.misc.CommandHolderType;
import com.redstoner.misc.Main;
import com.redstoner.modules.Module;
import com.redstoner.modules.blockplacemods.mods.Mod;
import com.redstoner.modules.blockplacemods.mods.ModAbstract;
import com.redstoner.modules.blockplacemods.mods.ModToggledAbstract;
import com.redstoner.utils.CommandException;
import com.redstoner.utils.CommandMap;
import com.redstoner.modules.blockplacemods.mods.ModBetterDirectional;
import com.redstoner.modules.blockplacemods.mods.ModCauldron;
import com.redstoner.modules.blockplacemods.mods.ModSlab;
import com.redstoner.modules.datamanager.DataManager;
import net.nemez.chatapi.click.Message;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
@Commands(CommandHolderType.None)
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Commands (CommandHolderType.File)
@AutoRegisterListener
@Version(major = 4, minor = 1, revision = 1, compatible = 4)
public final class BlockPlaceMods implements Module, Listener
{
@Version (major = 4, minor = 1, revision = 1, compatible = 4)
public class BlockPlaceMods implements Module, Listener {
private static final Map<String, BlockPlaceMod> mods = new HashMap<>();
private static final List<BlockPlaceMod> enabledMods = new ArrayList<>();
private final BlockPlaceMod[] modsToRegister = {
new ModCauldron(),
new ModSlab(),
new ModBetterDirectional("Observer", Material.OBSERVER, "observers", false),
new ModBetterDirectional("Piston", Material.PISTON, "pistons", false),
};
@Override
public boolean onEnable()
{
ModAbstract.registerAll(getLogger());
for (Mod mod : new ArrayList<>(ModAbstract.getMods().values()))
{
mod.registerListeners();
}
try
{
Map<String, org.bukkit.command.Command> commandMap = CommandMap.getCommandMap();
org.bukkit.command.Command command = new BlockPlaceModsCommand();
for (String alias : getCommandAliases())
{
commandMap.put(alias, command);
public boolean onEnable() {
for (BlockPlaceMod mod : modsToRegister) {
mods.put(mod.name.toLowerCase(), mod);
for (String alias : mod.aliases) {
mods.put(alias.toLowerCase(), mod);
}
if (mod.onEnable()) {
enabledMods.add(mod);
Bukkit.getPluginManager().registerEvents(mod, Main.plugin);
} else {
getLogger().warn("Block place mod failed to enable, see any errors above!");
}
}
catch (ReflectiveOperationException ex)
{
ex.printStackTrace();
return false;
}
return true;
}
@Override
public void postEnable()
{
setPrefix("BPM");
}
@Override
public void onDisable()
{
for (Mod mod : ModAbstract.getMods().values())
{
mod.unregisterListeners();
public void onDisable() {
for (BlockPlaceMod mod : enabledMods) {
mod.onDisable();
HandlerList.unregisterAll(mod);
}
try
{
Map<String, org.bukkit.command.Command> commandMap = CommandMap.getCommandMap();
for (String alias : getCommandAliases())
{
org.bukkit.command.Command command = commandMap.get(alias);
if (command != null && command.getClass() == BlockPlaceModsCommand.class)
{
commandMap.remove(alias);
}
}
}
catch (Exception ignored)
{}
enabledMods.clear();
mods.clear();
}
private static String[] getCommandAliases()
{
String pluginName = Main.plugin.getName().toLowerCase();
// @noformat
return new String[]{"mod", pluginName + ":mod",
"set", pluginName + ":set",
"toggle", pluginName + ":toggle"
};
// @format
}
@Command(hook = "mod_empty")
public void onModEmptyCommand(CommandSender sender)
{
onModCommand(sender, "");
}
@Command(hook = "mod")
public void onModCommand(CommandSender sender, String input)
{
String[] args = new ArrayList<>(Arrays.asList(input.split(" "))).stream()
.filter(x -> x != null && !x.trim().isEmpty()).toArray(String[]::new);
String prefix = "";
String message;
try
{
if (args.length > 0)
{
Mod target = ModAbstract.getMod(args[0].toLowerCase());
if (target != null)
{
prefix += "&7[&2" + capitalize(target.getName()) + "&7]:&a ";
if (!(sender instanceof Player))
{
message = "&cYou must be a player to use any block place mod";
@Command (async = Command.AsyncType.ALWAYS, hook = "list_mods")
public void listMods(CommandSender sender) {
Player player = (Player) sender;
String uuid = player.getUniqueId().toString();
Message msg = new Message(sender, sender);
msg.appendText(ChatColor.DARK_GREEN + "--==[BlockPlaceMods]==--\n");
msg.appendText(ChatColor.GRAY + "TIP: Hover over the following messages to see a description :)\n\n");
for (BlockPlaceMod mod : modsToRegister) {
msg.appendTextHover(
ChatColor.DARK_PURPLE + "["
+ ChatColor.DARK_BLUE + mod.name
+ ChatColor.DARK_PURPLE + "]",
ChatColor.GREEN + mod.description
);
msg.appendText(" ");
boolean enabled = (boolean) DataManager.getOrDefault(uuid, "BlockPlaceMods", mod.name, mod.enabledByDefault);
msg.appendTextHover(
enabledMods.contains(mod) ? ChatColor.GREEN + "Loaded" : ChatColor.DARK_RED + "Not loaded",
ChatColor.GRAY + (enabledMods.contains(mod) ? "The mod is working fine." : "Something is wrong!")
);
msg.appendText(ChatColor.RESET + ", ");
msg.appendTextHover(
enabled ? ChatColor.GREEN + "Enabled" : ChatColor.DARK_RED + "Disabled",
ChatColor.GRAY + (enabled ? "You have this mod enabled." : "You have disabled this mod!")
);
if (mod.type != ModType.STATELESS) {
Object state = DataManager.getOrDefault(uuid, "BlockPlaceMods", mod.name + "_state", null);
if (state != null) {
msg.appendText(ChatColor.AQUA + " -> ");
switch (mod.type) {
case STRING:
msg.appendTextHover(ChatColor.GOLD + state.toString(), "String value - " + mod.typeDescription);
break;
case INTEGER:
case UNSIGNED_INTEGER:
msg.appendTextHover(ChatColor.DARK_GREEN + state.toString(), "Integer value - " + mod.typeDescription);
break;
case REDSTONE_LEVEL:
msg.appendTextHover(ChatColor.RED + state.toString(), "Redstone level - " + mod.typeDescription);
}
else
{
message = target.runCommand((Player) sender, Arrays.copyOfRange(args, 1, args.length));
msg.appendTextHover(
enabled ? ChatColor.GREEN + "Enabled" : ChatColor.DARK_RED + "Disabled",
ChatColor.GRAY + (enabled ? "You have this mod enabled." : "You have disabled this mod!")
);
}
}
}
msg.send();
}
@Command (async = Command.AsyncType.ALWAYS, hook = "reset_mod")
public void resetMod(CommandSender sender, String mod) {
BlockPlaceMod bpm = mods.get(mod.toLowerCase());
Message msg = new Message(sender, sender);
msg.appendText(ChatColor.DARK_GREEN + "[BlockPlaceMods] ");
if (bpm == null) {
msg.appendText(ChatColor.DARK_RED + "That mod does not exist!");
} else {
Player player = (Player) sender;
DataManager.removeData(player.getUniqueId().toString(), "BlockPlaceMods", bpm.name);
DataManager.removeData(player.getUniqueId().toString(), "BlockPlaceMods", bpm.name + "_state");
msg.appendText(ChatColor.GREEN + "Successfully reset the settings for: " + ChatColor.DARK_PURPLE + bpm.name);
}
msg.send();
}
@Command (async = Command.AsyncType.ALWAYS, hook = "toggle_mod")
public void toggleMod(CommandSender sender, String mod) {
BlockPlaceMod bpm = mods.get(mod.toLowerCase());
Message msg = new Message(sender, sender);
msg.appendText(ChatColor.DARK_GREEN + "[BlockPlaceMods] ");
if (bpm == null) {
msg.appendText(ChatColor.DARK_RED + "That mod does not exist!");
} else {
Player player = (Player) sender;
String uuid = player.getUniqueId().toString();
boolean current = (boolean) DataManager.getOrDefault(uuid, "BlockPlaceMods", bpm.name, bpm.enabledByDefault);
DataManager.setData(uuid, "BlockPlaceMods", bpm.name, !current);
msg.appendText(
ChatColor.GREEN + "The " + ChatColor.DARK_PURPLE + bpm.name
+ ChatColor.GREEN + " mod has been "
+ (current ? ChatColor.RED + "Disabled!" : ChatColor.GREEN + "Enabled!")
);
}
msg.send();
}
@Command (async = Command.AsyncType.ALWAYS, hook = "set_mod_value")
public void setModValue(CommandSender sender, String mod, String value) {
BlockPlaceMod bpm = mods.get(mod.toLowerCase());
Message msg = new Message(sender, sender);
msg.appendText(ChatColor.DARK_GREEN + "[BlockPlaceMods] ");
if (bpm == null) {
msg.appendText(ChatColor.DARK_RED + "That mod does not exist!");
} else {
Player player = (Player) sender;
String uuid = player.getUniqueId().toString();
switch (bpm.type) {
case STATELESS:
msg.appendText(ChatColor.DARK_RED + "You cannot change the value of a stateless mod!");
break;
case STRING:
DataManager.setData(uuid, "BlockPlaceMods", bpm.name + "_state", value);
msg.appendText(
ChatColor.GREEN + "Changed the value of "
+ ChatColor.DARK_PURPLE + bpm.name + ChatColor.GREEN
+ " to: " + ChatColor.GRAY + value
);
break;
case INTEGER:
try {
DataManager.setData(uuid, "BlockPlaceMods", bpm.name + "_state", Integer.parseInt(value));
} catch (NumberFormatException e) {
msg.appendText(ChatColor.RED + "The specified value must be an integer!");
break;
}
}
else if (args[0].equalsIgnoreCase("help"))
{
message = commandHelp(sender, args);
}
else
{
message = "&cThat argument could not be recognized";
}
}
else
{
message = commandHelp(sender, args);
msg.appendText(
ChatColor.GREEN + "Changed the value of "
+ ChatColor.DARK_PURPLE + bpm.name + ChatColor.GREEN
+ " to: " + ChatColor.GRAY + value
);
break;
case UNSIGNED_INTEGER:
try {
int val = Integer.parseInt(value);
if (val < 0) {
msg.appendText(ChatColor.RED + "The specified value must be a positive integer!");
break;
}
DataManager.setData(uuid, "BlockPlaceMods", bpm.name + "_state", val);
} catch (NumberFormatException e) {
msg.appendText(ChatColor.RED + "The specified value must be a positive integer!");
break;
}
msg.appendText(
ChatColor.GREEN + "Changed the value of "
+ ChatColor.DARK_PURPLE + bpm.name + ChatColor.GREEN
+ " to: " + ChatColor.GRAY + value
);
break;
case REDSTONE_LEVEL:
try {
int val = Integer.parseInt(value);
if (val < 1 || val > 15) {
msg.appendText(ChatColor.RED + "The specified value must be an integer between 0 (exclusive) and 15 (inclusive)!");
break;
}
DataManager.setData(uuid, "BlockPlaceMods", bpm.name + "_state", val);
} catch (NumberFormatException e) {
msg.appendText(ChatColor.RED + "The specified value must be an integer between 0 (exclusive) and 15 (inclusive)!");
break;
}
msg.appendText(
ChatColor.GREEN + "Changed the value of "
+ ChatColor.DARK_PURPLE + bpm.name + ChatColor.GREEN
+ " to: " + ChatColor.GRAY + value
);
break;
}
}
catch (CommandException ex)
{
message = " &c" + ex.getMessage();
}
catch (Throwable t)
{
message = " &cAn unexpected error occurred while executing this command.";
t.printStackTrace();
}
getLogger().message(sender, prefix + message);
}
private String commandHelp(CommandSender sender, String[] args)
{
StringBuilder result = new StringBuilder("§7BlockPlaceMods adds some redstone-centric utilities");
result.append("\n").append(ChatColor.GRAY.toString()).append("Available mods:");
List<Mod> mods = new ArrayList<>(new HashSet<>(ModAbstract.getMods().values()));
mods.sort(Comparator.<Mod> comparingInt(m -> ModToggledAbstract.class.isInstance(m) ? 1 : -1)
.thenComparing(Mod::getName));
for (Mod mod : mods)
{
result.append("\n").append(ChatColor.AQUA.toString()).append("/mod ").append(ChatColor.ITALIC.toString())
.append(mod.getName());
for (String alias : mod.getAliases())
{
result.append('|').append(alias);
}
result.append(ChatColor.GRAY.toString()).append(" - ").append(mod.getDescription());
}
return result.toString();
}
private static String capitalize(String modName)
{
if (modName.isEmpty())
{
return modName;
}
char first = modName.charAt(0);
if (first != (first = Character.toUpperCase(first)))
{
char[] result = modName.toCharArray();
result[0] = first;
return String.valueOf(result);
}
return modName;
}
private class BlockPlaceModsCommand extends org.bukkit.command.Command
{
public BlockPlaceModsCommand()
{
super("mod");
String[] aliases = getCommandAliases();
setAliases(Arrays.asList(Arrays.copyOfRange(aliases, 1, aliases.length)));
}
@Override
public boolean execute(CommandSender sender, String label, String[] args)
{
onModCommand(sender, String.join(" ", args));
return true;
}
msg.send();
}
}

9
src/main/java/com/redstoner/modules/blockplacemods/ModType.java Normal file
View File

@@ -0,0 +1,9 @@
package com.redstoner.modules.blockplacemods;
public enum ModType {
STATELESS,
INTEGER,
UNSIGNED_INTEGER,
STRING,
REDSTONE_LEVEL
}

24
src/main/java/com/redstoner/modules/blockplacemods/mods/Mod.java
View File

@@ -1,24 +0,0 @@
package com.redstoner.modules.blockplacemods.mods;
import org.bukkit.entity.Player;
import com.redstoner.utils.CommandException;
import java.util.Set;
public interface Mod
{
String getName();
String getDescription();
Set<String> getAliases();
Object getDefault();
String runCommand(Player sender, String[] args) throws CommandException;
void registerListeners();
void unregisterListeners();
}

94
src/main/java/com/redstoner/modules/blockplacemods/mods/ModAbstract.java
View File

@@ -1,94 +0,0 @@
package com.redstoner.modules.blockplacemods.mods;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryType;
import com.redstoner.misc.Main;
import com.redstoner.modules.ModuleLogger;
import com.redstoner.modules.datamanager.DataManager;
public abstract class ModAbstract implements Mod, Listener
{
private static final Map<String, Mod> mods = new HashMap<>();
private final String name;
private final Set<String> aliases;
private static ModuleLogger logger;
public static Map<String, Mod> getMods()
{
return Collections.unmodifiableMap(mods);
}
public static Mod getMod(String name)
{
return mods.get(name);
}
public static void registerMod(Mod mod)
{
mods.put(mod.getName(), mod);
for (String alias : mod.getAliases())
{
mods.putIfAbsent(alias, mod);
}
}
public static void registerAll(final ModuleLogger logger)
{
ModAbstract.logger = logger;
registerMod(new ModToggledCauldron());
registerMod(new ModToggledPiston());
registerMod(new ModToggledObserver());
registerMod(new ModToggledStep());
registerMod(new ModToggledTorch());
registerMod(new ModInventory("dropper", InventoryType.DROPPER));
registerMod(new ModInventory("furnace", InventoryType.FURNACE));
registerMod(new ModInventory("hopper", InventoryType.HOPPER));
}
public ModAbstract(String name)
{
this.name = Objects.requireNonNull(name);
this.aliases = new HashSet<>(2);
logger.info("Loaded mod " + name);
}
@Override
public String getName()
{
return name;
}
@Override
public Set<String> getAliases()
{
return aliases;
}
@Override
public void registerListeners()
{
Bukkit.getPluginManager().registerEvents(this, Main.plugin);
}
@Override
public void unregisterListeners()
{
HandlerList.unregisterAll(this);
}
protected void reset(Player player)
{
DataManager.removeData(player.getUniqueId().toString(), "BlockPlaceMods", getName());
}
}

73
src/main/java/com/redstoner/modules/blockplacemods/mods/ModBetterDirectional.java Normal file
View File

@@ -0,0 +1,73 @@
package com.redstoner.modules.blockplacemods.mods;
import com.redstoner.modules.blockplacemods.BlockPlaceMod;
import com.redstoner.modules.blockplacemods.ModType;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.data.Directional;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockPlaceEvent;
public class ModBetterDirectional extends BlockPlaceMod {
private static final BlockFace[][][] dirMap = {
{
{ null, null, null },
{ null, BlockFace.WEST, null }, // (-1, 0, 0)
{ null, null, null }
},
{
{ null, BlockFace.DOWN, null }, // (0, -1, 0)
{ BlockFace.NORTH, BlockFace.SELF, BlockFace.SOUTH }, // (0, 0, x)
{ null, BlockFace.UP, null } // (0, 1, 0)
},
{
{ null, null, null },
{ null, BlockFace.EAST, null }, // (1, 0, 0)
{ null, null, null }
}
};
private final Material material;
public ModBetterDirectional(String name, Material material, String materialPlural, boolean enabledByDefault) {
super(
name,
"With this mod enabled " + materialPlural + " are placed with the bottom on the block clicked.",
ModType.STATELESS,
null,
enabledByDefault,
"BetterDirectional" + material.name().toLowerCase()
);
this.material = material;
}
@EventHandler (priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event) {
if (
event.getBlock().getType() == material
&& !event.getPlayer().isSneaking()
&& hasEnabled(event.getPlayer())
&& event.getPlayer().getGameMode() == GameMode.CREATIVE
) {
Block block = event.getBlock();
Directional data = (Directional) block.getBlockData();
data.setFacing(getDirection(event));
block.setBlockData(data);
}
}
private BlockFace getDirection(BlockPlaceEvent event) {
Location original = event.getBlockPlaced().getLocation();
Location against = event.getBlockAgainst().getLocation();
Location dir = original.subtract(against);
return dirMap[dir.getBlockX() + 1][dir.getBlockY() + 1][dir.getBlockZ() + 1];
}
}

63
src/main/java/com/redstoner/modules/blockplacemods/mods/ModCauldron.java Normal file
View File

@@ -0,0 +1,63 @@
package com.redstoner.modules.blockplacemods.mods;
import com.redstoner.modules.blockplacemods.BlockPlaceMod;
import com.redstoner.modules.blockplacemods.ModType;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.data.Levelled;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.player.PlayerInteractEvent;
public class ModCauldron extends BlockPlaceMod {
public ModCauldron() {
super(
"Cauldron",
"With this mod enabled cauldrons are placed filled and cycle on a shiftless right click with an empty hand.",
ModType.STATELESS,
null,
true,
"CauldronFill", "AutoCauldron"
);
}
@EventHandler
public void onPlayerInteract(PlayerInteractEvent event) {
if (
event.getAction() == Action.RIGHT_CLICK_BLOCK
&& !event.isCancelled()
&& !event.getPlayer().isSneaking()
&& event.getClickedBlock().getType() == Material.CAULDRON
&& hasEnabled(event.getPlayer())
&& event.getPlayer().getGameMode() == GameMode.CREATIVE
&& event.getPlayer().getInventory().getItemInMainHand().getType() == Material.AIR
) {
Block block = event.getClickedBlock();
Levelled data = (Levelled) block.getBlockData();
int newLevel = (data.getLevel() + 1) % (data.getMaximumLevel() + 1);
data.setLevel(newLevel);
block.setBlockData(data);
}
}
@EventHandler (priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event) {
if (
event.getBlock().getType() == Material.CAULDRON
&& !event.getPlayer().isSneaking()
&& hasEnabled(event.getPlayer())
&& event.getPlayer().getGameMode() == GameMode.CREATIVE
) {
Block block = event.getBlock();
Levelled data = (Levelled) block.getBlockData();
data.setLevel(data.getMaximumLevel());
block.setBlockData(data);
}
}
}

195
src/main/java/com/redstoner/modules/blockplacemods/mods/ModInventory.java
View File

@@ -1,195 +0,0 @@
package com.redstoner.modules.blockplacemods.mods;
import com.redstoner.modules.datamanager.DataManager;
import com.redstoner.utils.CommandException;
import com.redstoner.utils.ItemProperties;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.block.BlockState;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import java.util.Arrays;
public class ModInventory extends ModAbstract
{
protected InventoryType inventoryType;
public ModInventory(String name, InventoryType inventoryType)
{
super(name);
this.inventoryType = inventoryType;
}
private static int highestUsedIndex(ItemStack[] items)
{
for (int i = items.length - 1; i >= 0; i--)
{
if (items[i] != null)
{
return i;
}
}
return -1;
}
@Override
public String getDescription()
{
return "Controls " + inventoryType.name().toLowerCase() + " placement content";
}
@Override
public String runCommand(Player sender, String[] args) throws CommandException
{
if (args.length > 0)
{
if (args[0].equalsIgnoreCase("clear"))
{
reset(sender);
return "Reset data successfully";
}
try
{
int slot = Integer.parseInt(args[0]);
if (slot >= inventoryType.getDefaultSize())
{
throw new CommandException(
"Slot number " + slot + " is too high for " + inventoryType.toString().toLowerCase() + "s");
}
if (slot < 0)
{
throw new CommandException("Slot number " + slot + " is negative");
}
// Set the stored item to the item in the sender's hand
ItemStack item = sender.getInventory().getItemInMainHand();
if (item == null || item.getType() == Material.AIR || item.getAmount() == 0)
{
// Remove the item.
// Set item to null to ensure correct itemName below.
item = null;
if (present(sender))
{
set(sender, slot, null);
}
}
else
{
set(sender, slot, item);// don't need to clone because the reference isn't kept
}
String itemName = item == null ? "nothing"
: item.getAmount() + " " + item.getType().toString().toLowerCase().replace("_", "");
return "Set the item in slot " + slot + " to " + itemName;
}
catch (NumberFormatException ex)
{
if (!args[0].equalsIgnoreCase("help"))
{
throw new CommandException("Expected a number indicating the slot that you want to set");
}
}
}
StringBuilder message = new StringBuilder();
message.append(" &a### &3Container Mod&a Help ###\n");
message.append("&7").append(getDescription()).append('\n');
message.append("&6/mod ").append(getName().toLowerCase())
.append("&o <slot> &bsets the item in slot to your hand\n");
message.append("&6/mod ").append(getName().toLowerCase()).append("&o clear &bclears the data\n");
message.append("&6/mod ").append(getName().toLowerCase()).append("&o help &bshows this help page\n");
return message.toString();
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event)
{
if (present(event.getPlayer()) && event.getPlayer().getGameMode() == GameMode.CREATIVE)
{
BlockState state = event.getBlock().getState();
if (state instanceof InventoryHolder)
{
Inventory inv = ((InventoryHolder) state).getInventory();
if (inv.getType() == inventoryType)
{
ItemStack[] data = get(event.getPlayer());
inv.setContents(data);
state.update();
}
}
}
}
protected ItemStack[] get(Player player)
{
Object obj = DataManager.getData(player.getUniqueId().toString(), "BlockPlaceMods", getName());
if (obj == null)
return getDefault();
JSONArray array = (JSONArray) obj;
ItemStack[] items = new ItemStack[Math.min(inventoryType.getDefaultSize(), array.size())];
for (int i = 0, n = items.length; i < n; i++)
{
Object obj2 = array.get(i);
if (obj2 instanceof JSONObject)
{ // if null, items[i] remains null
items[i] = new ItemProperties().loadFrom((JSONObject) obj2).toItemStack();
}
}
return items;
}
protected void set(Player player, int index, ItemStack item)
{
ItemStack[] data = get(player);
if (item == null)
{
if (index < data.length)
{
data[index] = null;
}
}
else
{
if (index >= data.length)
{
data = Arrays.copyOf(data, index + 1);
}
data[index] = item;
}
set(player, data);
}
@SuppressWarnings("unchecked")
protected void set(Player player, ItemStack[] data)
{
if (highestUsedIndex(data) == -1)
reset(player);
else
{
JSONArray array = new JSONArray();
for (int i = 0, n = highestUsedIndex(data); i < n; i++)
{
ItemStack item = data[i];
array.add(item == null ? null : new ItemProperties(item).toJSONObject());
}
DataManager.setData(player.getUniqueId().toString(), "BlockPlaceMods", getName(), array);
}
}
protected boolean present(Player player)
{
return get(player) != null;
}
@Override
public ItemStack[] getDefault()
{
return new ItemStack[0];
}
}

39
src/main/java/com/redstoner/modules/blockplacemods/mods/ModSlab.java Normal file
View File

@@ -0,0 +1,39 @@
package com.redstoner.modules.blockplacemods.mods;
import com.redstoner.modules.blockplacemods.BlockPlaceMod;
import com.redstoner.modules.blockplacemods.ModType;
import org.bukkit.GameMode;
import org.bukkit.block.Block;
import org.bukkit.block.data.type.Slab;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockPlaceEvent;
public class ModSlab extends BlockPlaceMod {
public ModSlab() {
super(
"Slab",
"With this mod enabled Slabs are placed on the top half of the block unless you are sneaking.",
ModType.STATELESS,
null,
true,
"Step", "AutoSlab", "AutoStep", "SlabRotation", "StepRotation"
);
}
@EventHandler (priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event) {
if (
event.getBlock().getBlockData() instanceof Slab
&& !event.getPlayer().isSneaking()
&& hasEnabled(event.getPlayer())
&& event.getPlayer().getGameMode() == GameMode.CREATIVE
) {
Block block = event.getBlock();
Slab data = (Slab) block.getBlockData();
data.setType(Slab.Type.TOP);
block.setBlockData(data);
}
}
}

80
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledAbstract.java
View File

@@ -1,80 +0,0 @@
package com.redstoner.modules.blockplacemods.mods;
import com.redstoner.modules.datamanager.DataManager;
import com.redstoner.utils.CommandException;
import org.bukkit.entity.Player;
public abstract class ModToggledAbstract extends ModAbstract
{
protected boolean enabledByDefault;
public ModToggledAbstract(String name, boolean enabledByDefault) {
super(name);
this.enabledByDefault = enabledByDefault;
}
@Override
public Boolean getDefault() {
return enabledByDefault;
}
protected boolean hasEnabled(Player player)
{
return (boolean) DataManager.getOrDefault(player.getUniqueId().toString(), "BlockPlaceMods", getName(),
enabledByDefault);
}
protected boolean setEnabled(Player sender, boolean enabled)
{
if (enabled == hasEnabled(sender))
return false;
if (enabled == enabledByDefault)
reset(sender);
else
DataManager.setData(sender.getUniqueId().toString(), "BlockPlaceMods", getName(), enabled);
return true;
}
@Override
public String runCommand(Player sender, String[] args) throws CommandException
{
if (args.length == 0 || args[0].equalsIgnoreCase("toggle"))
{
boolean enabled = hasEnabled(sender);
setEnabled(sender, !enabled);
return !enabled ? "Enabled" : "Disabled";
}
if (args[0].equalsIgnoreCase("help"))
{
StringBuilder message = new StringBuilder();
message.append(" &a### &3Toggled Mod&a Help ###");
message.append("\n&7").append(getDescription());
message.append("\n&6/mod ").append(getName()).append("&o (toggle) &btoggles state");
message.append("\n&6/mod ").append(getName()).append("&o on/off &bsets state");
message.append("\n&6/mod ").append(getName()).append("&o help &bshows this help page");
return message.toString();
}
final boolean enable;
switch (args[0].toLowerCase())
{
case "on":
case "enable":
case "true":
enable = true;
break;
case "off":
case "disable":
case "false":
enable = false;
break;
default:
throw new CommandException("Input '" + args[0] + "' was not understood. "
+ "Use one of: \non, enable, true, off, disable, false.");
}
if (!setEnabled(sender, enable))
{
throw new CommandException("Was already " + (enable ? "enabled" : "disabled"));
}
return enable ? "Enabled" : "Disabled";
}
}

49
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledCauldron.java
View File

@@ -1,49 +0,0 @@
package com.redstoner.modules.blockplacemods.mods;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.player.PlayerInteractEvent;
public class ModToggledCauldron extends ModToggledAbstract
{
public ModToggledCauldron()
{
super("cauldron", false);
}
@Override
public String getDescription()
{
return "If active, placed cauldrons are filled, and they cycle on shiftless right click with redstone or fist";
}
@SuppressWarnings("deprecation")
@EventHandler
public void onPlayerInteract(PlayerInteractEvent event)
{
if (event.getAction() == Action.RIGHT_CLICK_BLOCK && !event.getPlayer().isSneaking()
&& event.getClickedBlock().getType() == Material.CAULDRON && hasEnabled(event.getPlayer())
&& (event.getPlayer().getGameMode() == GameMode.CREATIVE)
&& (event.getPlayer().getInventory().getItemInMainHand().getType() == Material.AIR))
{
Block block = event.getClickedBlock();
block.setData((byte) ((block.getData() - 1) & 0x3));
}
}
@SuppressWarnings("deprecation")
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event)
{
if (event.getBlock().getType() == Material.CAULDRON && !event.getPlayer().isSneaking()
&& hasEnabled(event.getPlayer()) && (event.getPlayer().getGameMode() == GameMode.CREATIVE))
{
event.getBlock().setData((byte) 3);
}
}
}

40
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledLogPlaceAbstract.java
View File

@@ -1,40 +0,0 @@
package com.redstoner.modules.blockplacemods.mods;
import org.bukkit.GameMode;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockPlaceEvent;
/**
* A mod that makes placement of directional blocks act the way placement of logs does normally.
* Quartz pillar placement works like this too.
*
* Placed blocks face the block you clicked to place them.
*/
public abstract class ModToggledLogPlaceAbstract extends ModToggledAbstract {
protected ModToggledLogPlaceAbstract(String name, boolean enabledByDefault) {
super(name, enabledByDefault);
}
@SuppressWarnings("deprecation")
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event)
{
Player player = event.getPlayer();
Block block;
if (hasEnabled(player) && !player.isSneaking() && player.getGameMode() == GameMode.CREATIVE
&& isApplicableToPlacedBlock(block = event.getBlock()))
{
block.setData((byte) getBlockDataForFacing(block.getFace(event.getBlockAgainst())));
}
}
protected abstract int getBlockDataForFacing(BlockFace direction);
protected abstract boolean isApplicableToPlacedBlock(Block block);
}

43
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledObserver.java
View File

@@ -1,43 +0,0 @@
package com.redstoner.modules.blockplacemods.mods;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
public class ModToggledObserver extends ModToggledLogPlaceAbstract {
protected ModToggledObserver() {
super("observer", false);
}
@Override
public String getDescription() {
return "If active, observers face the block you place them against";
}
@Override
protected boolean isApplicableToPlacedBlock(Block block) {
return block.getType() == Material.OBSERVER;
}
@Override
protected int getBlockDataForFacing(BlockFace direction) {
switch (direction) {
case UP:
return 0;
default:
case DOWN:
return 1;
case SOUTH:
return 2;
case NORTH:
return 3;
case EAST:
return 4;
case WEST:
return 5;
}
}
}

46
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledPiston.java
View File

@@ -1,46 +0,0 @@
package com.redstoner.modules.blockplacemods.mods;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
public class ModToggledPiston extends ModToggledLogPlaceAbstract
{
public ModToggledPiston()
{
super("piston", false);
}
@Override
public String getDescription()
{
return "If active, pistons face the block you place them against";
}
@Override
protected boolean isApplicableToPlacedBlock(Block block) {
Material type = block.getType();
return type == Material.PISTON_BASE || type == Material.PISTON_STICKY_BASE;
}
@Override
protected int getBlockDataForFacing(BlockFace direction) {
switch (direction)
{
default:
case DOWN:
return 0;
case UP:
return 1;
case NORTH:
return 2;
case SOUTH:
return 3;
case WEST:
return 4;
case EAST:
return 5;
}
}
}

40
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledStep.java
View File

@@ -1,40 +0,0 @@
package com.redstoner.modules.blockplacemods.mods;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockPlaceEvent;
public class ModToggledStep extends ModToggledAbstract
{
public ModToggledStep()
{
super("step", true);
getAliases().add("slab");
}
@Override
public String getDescription()
{
return "If active, placed steps will always turn upside-down";
}
@SuppressWarnings("deprecation")
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event)
{
if (isStep(event.getBlock().getType()) && !event.getPlayer().isSneaking() && hasEnabled(event.getPlayer()))
{
byte data = event.getBlock().getData();
if (data != (data |= 0x8))
{
event.getBlock().setData(data);
}
}
}
private boolean isStep(Material block)
{
return block == Material.STEP || block == Material.STONE_SLAB2;
}
}

91
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledTorch.java
View File

@@ -1,91 +0,0 @@
package com.redstoner.modules.blockplacemods.mods;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockPlaceEvent;
import com.redstoner.misc.Main;
public class ModToggledTorch extends ModToggledAbstract
{
private final Set<Block> torchesPlaced = new HashSet<>();
public ModToggledTorch()
{
super("torch", true);
Bukkit.getScheduler().scheduleSyncRepeatingTask(Main.plugin, this::updateTorches, 2, 2);
}
@Override
public String getDescription()
{
return "If active, redstone torches placed on a redstone block disappear quickly";
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event)
{
final Player player = event.getPlayer();
if (!player.isSneaking() && player.getGameMode() == GameMode.CREATIVE && hasEnabled(player)
&& event.getBlock().getType() == Material.REDSTONE_TORCH_ON)
{
if (isAttachedToRedstoneBlock(event.getBlock()))
{
torchesPlaced.add(event.getBlock());
}
}
}
@SuppressWarnings("deprecation")
private boolean isAttachedToRedstoneBlock(Block block)
{
BlockFace towardsAgainst = getFaceTowardsBlockAgainst(block.getData());
return towardsAgainst != null && block.getRelative(towardsAgainst).getType() == Material.REDSTONE_BLOCK;
}
private BlockFace getFaceTowardsBlockAgainst(byte data)
{
switch (data)
{
case 1:
return BlockFace.WEST;
case 2:
return BlockFace.EAST;
case 3:
return BlockFace.NORTH;
case 4:
return BlockFace.SOUTH;
case 5:
return BlockFace.DOWN;
default:
return null;
}
}
private void updateTorches()
{
for (Iterator<Block> it = torchesPlaced.iterator(); it.hasNext();)
{
Block block = it.next();
if (block.getType() == Material.REDSTONE_TORCH_OFF)
{
block.setType(Material.AIR);
it.remove();
}
else if (block.getType() != Material.REDSTONE_TORCH_ON || !isAttachedToRedstoneBlock(block))
{
it.remove();
}
}
}
}

80
src/main/java/com/redstoner/modules/blockplacemods/mods/ModTorch.java Normal file
View File

@@ -0,0 +1,80 @@
package com.redstoner.modules.blockplacemods.mods;
import com.redstoner.misc.Main;
import com.redstoner.modules.blockplacemods.BlockPlaceMod;
import com.redstoner.modules.blockplacemods.ModType;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.material.RedstoneTorch;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ModTorch extends BlockPlaceMod {
private static final Map<Block, Block> monitorBlocks = new HashMap<>();
private int monitorId = -1;
public ModTorch() {
super(
"Torch",
"With this mod enabled redstone torches placed on redstone blocks get auto removed after they turn off.",
ModType.STATELESS,
null,
true,
"AutoTorch", "TorchRemoval", "RedstoneTorch"
);
}
@Override
public boolean onEnable() {
monitorId = Bukkit.getScheduler().scheduleSyncRepeatingTask(Main.plugin, () -> {
for (Block block : monitorBlocks.keySet()) {
Block against = monitorBlocks.get(block);
if (block.getType() != Material.REDSTONE_TORCH || against.getType() != Material.REDSTONE_BLOCK) {
monitorBlocks.remove(block);
return;
}
RedstoneTorch data = (RedstoneTorch) block.getBlockData();
if (!data.isPowered()) {
block.setType(Material.AIR);
}
}
}, 2, 2);
return monitorId != -1;
}
@Override
public void onDisable() {
Bukkit.getScheduler().cancelTask(monitorId);
monitorId = -1;
}
@EventHandler (priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event) {
if (
event.getBlock().getType() == Material.REDSTONE_TORCH
&& !event.getPlayer().isSneaking()
&& hasEnabled(event.getPlayer())
&& event.getPlayer().getGameMode() == GameMode.CREATIVE
) {
Block block = event.getBlock();
Block against = event.getBlockAgainst();
if (against.getType() == Material.REDSTONE_BLOCK) {
monitorBlocks.put(block, against);
}
}
}
}

3
src/main/java/com/redstoner/modules/blockplacemods/mods/module.info
View File

@@ -1,3 +0,0 @@
displayName:
category:
description:

3
src/main/java/com/redstoner/modules/blockplacemods/module.info Normal file
View File

@@ -0,0 +1,3 @@
displayName: BlockPlaceMods
category: Other
description: Adds features to block placing.