初始化并且写了些东西

src/main/java/top/sunsetlab/PluginMain.java

@@ -0,0 +1,30 @@
+package top.sunsetlab;
+
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.java.JavaPlugin;
+import top.sunsetlab.event.EventListener;
+import top.sunsetlab.utils.ActionManager;
+import top.sunsetlab.utils.StructureManager;
+
+import java.util.logging.Logger;
+
+public class PluginMain extends JavaPlugin implements Listener {
+    public static final String VERSION = "0.0.1-alpha";
+    public static final boolean DEBUG = true;
+    public static Logger LOGGER;
+    public static StructureManager structureManager;
+    public static ActionManager actionManager;
+    public static JavaPlugin plugin;
+
+    @Override
+    public void onEnable() {
+        plugin = this;
+        LOGGER = getLogger();
+        structureManager = new StructureManager();
+        structureManager.load();
+        actionManager = new ActionManager();
+        actionManager.load();
+        getLogger().info("Plugin ver" + VERSION + "loaded." + (DEBUG?"(DEBUG)":""));
+        getServer().getPluginManager().registerEvents(new EventListener(), this);
+    }
+}

src/main/java/top/sunsetlab/actions/ActionLightning.java

@@ -0,0 +1,12 @@
+package top.sunsetlab.actions;
+
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+
+public class ActionLightning implements IActionBase{
+    @Override
+    public boolean call(Location location, Player caller) {
+        location.getWorld().strikeLightning(location);
+        return true;
+    }
+}

src/main/java/top/sunsetlab/actions/IActionBase.java

@@ -0,0 +1,8 @@
+package top.sunsetlab.actions;
+
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+
+public interface IActionBase {
+    boolean call(Location location, Player caller);
+}

src/main/java/top/sunsetlab/event/EventListener.java

@@ -0,0 +1,43 @@
+package top.sunsetlab.event;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import top.sunsetlab.PluginMain;
+import top.sunsetlab.utils.JsonStructure;
+
+import java.util.ArrayList;
+
+public class EventListener implements Listener {
+    @EventHandler
+    public void clickEvent(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        if (event.getPlayer().getInventory().getItemInMainHand().getType() != Material.GLOWSTONE_DUST) {
+            return;
+        }
+        if (event.getClickedBlock() != null && event.getClickedBlock().getType() != Material.REDSTONE_WIRE) {
+            return;
+        }
+
+        Bukkit.getScheduler().runTaskAsynchronously(PluginMain.plugin, () -> {
+            String structid = PluginMain.structureManager.match(event.getClickedBlock().getLocation());
+            if (structid == null) {
+                return;
+            }
+            JsonStructure structure = PluginMain.structureManager.getStructure(structid);
+            if (structure == null) {
+                return;
+            }
+            ArrayList<String> actions = structure.getActions();
+            for (String action : actions) {
+                PluginMain.actionManager.call(action, event.getClickedBlock().getLocation(), event.getPlayer());
+            }
+        });
+        event.setCancelled(true);
+    }
+}

src/main/java/top/sunsetlab/utils/ActionManager.java

@@ -0,0 +1,47 @@
+package top.sunsetlab.utils;
+
+import com.google.gson.Gson;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import top.sunsetlab.PluginMain;
+import top.sunsetlab.actions.IActionBase;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+class ActionList {
+    ArrayList<String> locations;
+}
+
+public class ActionManager {
+    private final HashMap<String, JsonAction> actions;
+    public ActionManager() {
+        actions = new HashMap<>();
+    }
+
+    public void load() {
+        InputStream is = ActionManager.class.getResourceAsStream("/actions.json");
+        if (is == null) {
+            throw new RuntimeException("actions.json file not found!");
+        }
+        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
+        Gson gson = new Gson();
+        ActionList actionList = gson.fromJson(reader, ActionList.class);
+        for (String location : actionList.locations) {
+            JsonAction action = new JsonAction(location);
+            actions.put(action.getId(), action);
+        }
+        PluginMain.LOGGER.info("Loaded " + actions.size() + " actions.");
+    }
+
+    public boolean call(String actionId, Location location, Player caller) {
+        JsonAction action = actions.get(actionId);
+        if (action == null) {
+            throw new RuntimeException("Invalid action id " + actionId);
+        }
+        return action.run(location, caller);
+    }
+}

src/main/java/top/sunsetlab/utils/JsonAction.java

@@ -0,0 +1,57 @@
+package top.sunsetlab.utils;
+
+import com.google.gson.Gson;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import top.sunsetlab.actions.IActionBase;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+class ActionData {
+    String id;
+    String classname;
+}
+
+public class JsonAction {
+    private final ActionData data;
+
+    public JsonAction(String location) {
+        InputStream is = JsonAction.class.getResourceAsStream("/" + location);
+        if (is == null) {
+            throw new RuntimeException(location + " not found");
+        }
+        BufferedReader br = new BufferedReader(new InputStreamReader(is));
+        Gson gson = new Gson();
+        data = gson.fromJson(br, ActionData.class);
+    }
+
+    public boolean run(Location location, Player caller) {
+        try {
+            Class<?> clazz = Class.forName(data.classname);
+            if (!IActionBase.class.isAssignableFrom(clazz)) {
+                throw new RuntimeException(data.classname + " is not a Action");
+            }
+            Constructor<?> constructor = clazz.getConstructor();
+            IActionBase action = (IActionBase) constructor.newInstance();
+            return action.call(location, caller);
+        }catch (ClassNotFoundException
+                | NoSuchMethodException
+                | SecurityException
+                | InstantiationException
+                | IllegalAccessException
+                | IllegalArgumentException
+                | InvocationTargetException e) {
+            throw new RuntimeException(
+                    "Something went wrong while trying to run action " + data.id + ":",
+                    e);
+        }
+    }
+
+    public String getId() {
+        return data.id;
+    }
+}

src/main/java/top/sunsetlab/utils/JsonStructure.java

@@ -0,0 +1,111 @@
+package top.sunsetlab.utils;
+
+import com.google.gson.Gson;
+import org.bukkit.Location;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Registry;
+import org.bukkit.World;
+import org.bukkit.block.BlockType;
+import top.sunsetlab.PluginMain;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Objects;
+import java.util.logging.Level;
+
+class JsonStructureData {
+    ArrayList<String> structure;
+    HashMap<String,String> marks;
+    int[] center;
+    String id;
+    ArrayList<String> actions;
+}
+
+public class JsonStructure {
+    private final JsonStructureData data;
+    private final String structure_loc;
+
+    public JsonStructure(String location) throws RuntimeException {
+        InputStream file = JsonStructure.class.getResourceAsStream("/" + location);
+        if (file == null) {
+            throw new RuntimeException(location + " not found");
+        }
+        InputStreamReader reader = new InputStreamReader(file);
+        BufferedReader bufferedReader = new BufferedReader(reader);
+        Gson gson = new Gson();
+        data = gson.fromJson(bufferedReader, JsonStructureData.class);
+        structure_loc = location;
+    }
+
+    public boolean match(Location pos) {
+        World world = pos.getWorld();
+        Location currentpos = new Location(
+                world,
+                pos.getX() - data.center[0],
+                pos.getY(),
+                pos.getZ() - data.center[1]
+        );
+        Location startpos = currentpos.clone();
+        Location endpos = new Location(
+                world,
+                pos.getX() + data.center[0],
+                pos.getY(),
+                pos.getZ() + data.center[1]
+        );
+        if (PluginMain.DEBUG) {
+            PluginMain.LOGGER.log(Level.INFO, "Matching structure " + structure_loc
+                    + "; From " + currentpos + " To " + endpos);
+        }
+        while (!currentpos.equals(endpos)) {
+            int rx = currentpos.getBlockX() -  startpos.getBlockX();
+            int rz = currentpos.getBlockZ() -  startpos.getBlockZ();
+//            if (PluginMain.DEBUG) {
+//                PluginMain.LOGGER.log(Level.INFO, "Matching location "
+//                        + currentpos
+//                        + "(relative (" + rx + "," + rz + "))");
+//            }
+            String mark = String.valueOf(data.structure.get(rz).charAt(rx));
+            String type = data.marks.get(mark);
+            if (type == null) {
+                throw new RuntimeException("In Structure "+ structure_loc +"; Undefined mark: " + mark);
+            }
+            NamespacedKey key = NamespacedKey.fromString(type);
+            if (key == null) {
+                throw new RuntimeException("In Structure "+ structure_loc +"; Invalid key: " + type);
+            }
+            BlockType blockType = Registry.BLOCK.get(key);
+            if (blockType == null) {
+                throw new RuntimeException("In Structure "+ structure_loc +"; Invalid block type: " + type);
+            }
+            if (!Objects.equals(world.getBlockAt(currentpos).getType().asBlockType(), blockType)) {
+                if (PluginMain.DEBUG) {
+                    PluginMain.LOGGER.log(Level.INFO, "Block Mismatch at " + currentpos
+                            + "(relative (" + rx + "," + rz + "))"
+                            + "; Expected " + blockType
+                            + ", but got " + world.getBlockAt(currentpos).getType());
+                }
+                return false;
+            }
+            currentpos.add(1,0,0);
+            if (currentpos.getBlockX() == endpos.getBlockX() + 1) {
+                currentpos.setX(startpos.getBlockX());
+                currentpos.setZ(currentpos.getBlockZ() + 1);
+                if (currentpos.getBlockZ() == endpos.getBlockZ() + 1) {
+                    break;
+                }
+            }
+        }
+        return true;
+    }
+
+    public String getId() {
+        return data.id;
+    }
+
+    public ArrayList<String> getActions() {
+        return data.actions;
+    }
+}

src/main/java/top/sunsetlab/utils/StructureManager.java

@@ -0,0 +1,52 @@
+package top.sunsetlab.utils;
+
+import com.google.gson.Gson;
+import org.bukkit.Location;
+import top.sunsetlab.PluginMain;
+
+import javax.annotation.Nullable;
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.logging.Level;
+
+class StructureList {
+    ArrayList<String> locations = new ArrayList<>();
+}
+
+public class StructureManager {
+    private final HashMap<String,JsonStructure> structures;
+    public StructureManager() {
+        structures = new HashMap<>();
+    }
+
+    public void load() {
+        InputStream is = StructureList.class.getResourceAsStream("/structures.json");
+        if (is == null) {
+            throw new RuntimeException("structures.json not found");
+        }
+        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(is));
+        Gson gson = new Gson();
+        StructureList list = gson.fromJson(bufferedReader, StructureList.class);
+        for (String location : list.locations) {
+            JsonStructure structure = new JsonStructure(location);
+            structures.put(structure.getId(), structure);
+        }
+        PluginMain.LOGGER.log(Level.INFO, "Loaded " + structures.size() + " structures");
+    }
+
+    public @Nullable String match(Location location) {
+        for (JsonStructure structure : structures.values()) {
+            if (structure.match(location)) {
+                return structure.getId();
+            }
+        }
+        return null;
+    }
+
+    public @Nullable JsonStructure getStructure(String id) {
+        return structures.get(id);
+    }
+}