package com.xfestudio.xfeservermanager.core.trigger; import java.util.List; import java.util.Map; import java.util.Set; /** Supported built-in event, comparison and action vocabulary. Custom events remain extensible. */ public final class TriggerCatalog { public static final List EVENTS = List.of( "schedule.daily", "schedule.interval", "server.started", "server.stopping", "player.join", "player.leave", "player.chat", "player.command", "player.command_trigger", "player.death", "player.respawn", "player.dimension_change", "player.advancement", "player.item_pickup", "player.item_drop", "player.item_use", "player.item_use_finish", "player.item_craft", "player.attack", "player.hurt", "player.heal", "player.interact", "player.entity_interact", "player.sleep", "player.wake", "block.break", "block.place", "block.change", "block.grow", "block.tool_modify", "entity.spawn", "entity.remove", "entity.death", "world.explosion", "world.weather_change", "world.load", "world.unload", "chunk.load", "chunk.unload", "variable.changed", "menu.open", "menu.close", "menu.control", "economy.balance_changed", "economy.deposit", "economy.withdraw", "economy.set", "economy.transfer", "protection.item_overflow", "protection.mob_overflow", "protection.entity_overflow", "protection.mod_entity_overflow", "protection.spawn_burst", "protection.command_block_rate", "protection.slow_tick", "protection.loaded_chunk_overflow", "protection.memory_pressure", "region.enter", "region.leave", "region.stay", "custom"); public static final List OPERATORS = List.of( "eq", "neq", "contains", "not_contains", "starts_with", "not_starts_with", "ends_with", "not_ends_with", "matches", "not_matches", "gt", "gte", "lt", "lte", "between", "not_between", "in", "not_in", "exists", "not_exists", "empty", "not_empty", "true", "false"); public static final List ACTIONS = List.of( "send_player", "broadcast", "title", "actionbar", "sound", "server_command", "player_command", "kick", "teleport", "give_item", "clear_inventory", "set_gamemode", "add_effect", "remove_effects", "heal", "feed", "set_time", "set_weather", "whitelist_add", "whitelist_remove", "ban", "pardon", "log", "variable", "wait", "run_trigger", "open_menu", "close_menu", "economy_deposit", "economy_withdraw", "economy_set_balance", "economy_transfer", "economy_deposit_player", "economy_withdraw_player", "economy_set_player_balance", "economy_transfer_players", "set_health", "set_food", "set_experience", "set_spawnpoint", "scoreboard_set", "scoreboard_add", "team_join", "team_leave", "advancement_grant", "advancement_revoke", "spawn_entity", "damage_entity", "teleport_entity", "remove_entity", "set_entity_attribute", "tag_entity", "set_block", "fill_blocks", "explosion", "lightning", "set_difficulty", "set_gamerule", "world_border"); public static final Map> ACTION_PARAMETERS = Map.ofEntries( Map.entry("send_player", List.of("message")), Map.entry("broadcast", List.of("message")), Map.entry("title", List.of("title", "subtitle", "numberPrecision", "fadeIn", "stay", "fadeOut")), Map.entry("actionbar", List.of("message")), Map.entry("sound", List.of("sound", "volume", "pitch")), Map.entry("server_command", List.of("command", "showFeedback")), Map.entry("player_command", List.of("command", "showFeedback")), Map.entry("kick", List.of("message")), Map.entry("teleport", List.of("destination")), Map.entry("give_item", List.of("item", "count")), Map.entry("clear_inventory", List.of("item", "maxCount")), Map.entry("set_gamemode", List.of("gamemode")), Map.entry("add_effect", List.of("effect", "duration", "amplifier")), Map.entry("remove_effects", List.of()), Map.entry("heal", List.of()), Map.entry("feed", List.of()), Map.entry("set_time", List.of("time")), Map.entry("set_weather", List.of("weather", "duration")), Map.entry("whitelist_add", List.of()), Map.entry("whitelist_remove", List.of()), Map.entry("ban", List.of("reason")), Map.entry("pardon", List.of()), Map.entry("log", List.of("message", "level")), Map.entry("variable", List.of("name", "operation", "value", "extra")), Map.entry("wait", List.of("mode", "value", "timeout", "pollTicks", "field", "operator", "expected")), Map.entry("run_trigger", List.of("triggerId", "waitForCompletion")), Map.entry("open_menu", List.of("menuId")), Map.entry("close_menu", List.of()), Map.entry("economy_deposit", List.of("currency", "amount", "reason")), Map.entry("economy_withdraw", List.of("currency", "amount", "reason")), Map.entry("economy_set_balance", List.of("currency", "amount", "reason")), Map.entry("economy_transfer", List.of("currency", "amount", "target", "reason")), Map.entry("economy_deposit_player", List.of("player", "currency", "amount", "reason")), Map.entry("economy_withdraw_player", List.of("player", "currency", "amount", "reason")), Map.entry("economy_set_player_balance", List.of("player", "currency", "amount", "reason")), Map.entry("economy_transfer_players", List.of("source", "target", "currency", "amount", "reason")), Map.entry("set_health", List.of("value")), Map.entry("set_food", List.of("value")), Map.entry("set_experience", List.of("amount", "mode")), Map.entry("set_spawnpoint", List.of("position")), Map.entry("scoreboard_set", List.of("objective", "value")), Map.entry("scoreboard_add", List.of("objective", "value")), Map.entry("team_join", List.of("team")), Map.entry("team_leave", List.of()), Map.entry("advancement_grant", List.of("advancement")), Map.entry("advancement_revoke", List.of("advancement")), Map.entry("spawn_entity", List.of("entityType", "position", "nbt")), Map.entry("damage_entity", List.of("selector", "amount", "damageType")), Map.entry("teleport_entity", List.of("selector", "destination")), Map.entry("remove_entity", List.of("selector")), Map.entry("set_entity_attribute", List.of("selector", "attribute", "value")), Map.entry("tag_entity", List.of("selector", "operation", "tag")), Map.entry("set_block", List.of("dimension", "position", "block", "mode")), Map.entry("fill_blocks", List.of("dimension", "from", "to", "block", "mode")), Map.entry("explosion", List.of("dimension", "position", "power", "fire")), Map.entry("lightning", List.of("dimension", "position")), Map.entry("set_difficulty", List.of("difficulty")), Map.entry("set_gamerule", List.of("rule", "value")), Map.entry("world_border", List.of("operation", "value", "seconds"))); private static final Set EVENT_SET = Set.copyOf(EVENTS); private static final Set OPERATOR_SET = Set.copyOf(OPERATORS); private static final Set ACTION_SET = Set.copyOf(ACTIONS); private static final Set PLAYER_CONTEXT_ACTIONS = Set.of( "send_player", "title", "actionbar", "sound", "player_command", "kick", "teleport", "give_item", "clear_inventory", "set_gamemode", "add_effect", "remove_effects", "heal", "feed", "whitelist_add", "whitelist_remove", "ban", "pardon", "open_menu", "close_menu", "economy_deposit", "economy_withdraw", "economy_set_balance", "economy_transfer", "set_health", "set_food", "set_experience", "set_spawnpoint", "scoreboard_set", "scoreboard_add", "team_join", "team_leave", "advancement_grant", "advancement_revoke"); private static final Set ONLINE_PLAYER_ACTIONS = Set.of( "send_player", "title", "actionbar", "sound", "player_command", "kick", "teleport", "give_item", "clear_inventory", "set_gamemode", "add_effect", "remove_effects", "heal", "feed", "open_menu", "close_menu", "set_health", "set_food", "set_experience", "set_spawnpoint", "scoreboard_set", "scoreboard_add", "team_join", "team_leave", "advancement_grant", "advancement_revoke"); private static final Set RESOURCE_ACTIONS = Set.of("sound", "give_item", "add_effect"); private TriggerCatalog() { } public static void validate(TriggerDefinition.Program program) { String event = program.event().type(); boolean builtIn = EVENT_SET.contains(event) && !event.equals("custom"); if (!builtIn && !event.matches("custom\\.[a-z0-9_.-]+")) { throw new IllegalArgumentException("unsupported trigger event: " + event); } validateEventConfiguration(program.event()); program.conditions().forEach(condition -> { if (!OPERATOR_SET.contains(condition.operator())) { throw new IllegalArgumentException("unsupported condition operator: " + condition.operator()); } if (Set.of("matches", "not_matches").contains(condition.operator())) { TriggerEvaluator.validateRegex(condition.value()); } if (Set.of("gt", "gte", "lt", "lte").contains(condition.operator())) { finiteNumber(condition.value(), "numeric comparison value"); } if (Set.of("between", "not_between").contains(condition.operator())) { TriggerEvaluator.validateNumberRange(condition.value()); } }); if (program.actions().isEmpty()) throw new IllegalArgumentException("a trigger needs at least one action"); Set declaredVariables = program.event().variables().stream() .map(variable -> variable.visibility().equals("global") ? "global." + variable.name() : variable.name()) .collect(java.util.stream.Collectors.toSet()); program.actions().forEach(action -> { if (!ACTION_SET.contains(action.type())) { throw new IllegalArgumentException("unsupported trigger action: " + action.type()); } Set acceptedParameters = Set.copyOf(ACTION_PARAMETERS.get(action.type())); for (String parameter : action.parameters().keySet()) { if (!acceptedParameters.contains(parameter)) { throw new IllegalArgumentException(action.type() + " does not accept parameter " + parameter); } } String primary = switch (action.type()) { case "server_command", "player_command" -> "command"; case "sound" -> "sound"; case "title" -> "title"; case "teleport" -> "destination"; case "give_item" -> "item"; case "set_gamemode" -> "gamemode"; case "add_effect" -> "effect"; case "set_time" -> "time"; case "set_weather" -> "weather"; case "variable" -> "name"; case "wait" -> "mode"; case "run_trigger" -> "triggerId"; case "open_menu" -> "menuId"; case "economy_deposit", "economy_withdraw", "economy_set_balance", "economy_transfer", "economy_deposit_player", "economy_withdraw_player", "economy_set_player_balance", "economy_transfer_players" -> "currency"; case "set_health", "set_food" -> "value"; case "set_experience" -> "amount"; case "set_spawnpoint" -> "position"; case "scoreboard_set", "scoreboard_add" -> "objective"; case "team_join" -> "team"; case "team_leave" -> null; case "advancement_grant", "advancement_revoke" -> "advancement"; case "spawn_entity" -> "entityType"; case "damage_entity", "teleport_entity", "remove_entity", "set_entity_attribute", "tag_entity" -> "selector"; case "set_block", "fill_blocks" -> "block"; case "explosion", "lightning" -> "position"; case "set_difficulty" -> "difficulty"; case "set_gamerule" -> "rule"; case "world_border" -> "operation"; case "clear_inventory", "remove_effects", "heal", "feed", "whitelist_add", "whitelist_remove", "ban", "pardon", "close_menu" -> null; default -> "message"; }; if (primary != null && (!action.parameters().containsKey(primary) || action.parameters().get(primary) == null || action.parameters().get(primary).isBlank())) { throw new IllegalArgumentException(action.type() + " requires " + primary); } if (PLAYER_CONTEXT_ACTIONS.contains(action.type()) && !providesPlayerContext(event)) { throw new IllegalArgumentException(action.type() + " requires a player-context event; use broadcast/log/server actions instead"); } if (event.equals("player.leave") && ONLINE_PLAYER_ACTIONS.contains(action.type())) { throw new IllegalArgumentException(action.type() + " cannot run after the player has left; use broadcast/log or identity-list actions instead"); } action.parameters().values().forEach(TriggerEvaluator::validateTemplateVariables); validateActionParameters(action); if (action.type().equals("variable")) { String name = action.parameters().getOrDefault("name", "").strip(); if (!TriggerEvaluator.hasTemplateVariable(name) && !declaredVariables.contains(name) && !name.matches("global\\.[A-Za-z_][A-Za-z0-9_-]{0,47}")) { throw new IllegalArgumentException("variable action references an undeclared variable: " + name); } } }); } private static void validateActionParameters(TriggerDefinition.Action action) { Map values = action.parameters(); if (RESOURCE_ACTIONS.contains(action.type())) { String key = action.type().equals("sound") ? "sound" : action.type().equals("give_item") ? "item" : "effect"; resourceIdentifier(values.get(key), key); } switch (action.type()) { case "server_command", "player_command" -> { String command = values.get("command"); if (command.length() > 32_768 || command.indexOf('\n') >= 0 || command.indexOf('\r') >= 0) { throw new IllegalArgumentException("trigger command must be a single line of at most 32768 characters"); } enumeration(values.getOrDefault("showFeedback", "false"), "showFeedback", Set.of("true", "false")); } case "sound" -> { decimalRange(values.getOrDefault("volume", "1"), "volume", 0, 1_000); decimalRange(values.getOrDefault("pitch", "1"), "pitch", 0, 2); } case "title" -> { integerRange(values.getOrDefault("numberPrecision", "2"), "numberPrecision", 0, TriggerEvaluator.MAX_MESSAGE_FRACTION_DIGITS); integerRange(values.getOrDefault("fadeIn", "10"), "fadeIn", 0, 12_000); integerRange(values.getOrDefault("stay", "70"), "stay", 0, 12_000); integerRange(values.getOrDefault("fadeOut", "20"), "fadeOut", 0, 12_000); } case "teleport" -> { String destination = values.get("destination").strip(); if (destination.indexOf('\n') >= 0 || destination.indexOf('\r') >= 0 || destination.length() > 256) { throw new IllegalArgumentException("teleport destination must be a single line of at most 256 characters"); } } case "give_item" -> integerRange(values.getOrDefault("count", "1"), "count", 1, 6_400); case "clear_inventory" -> { String item = values.getOrDefault("item", "").strip(); if (!item.isEmpty()) resourceIdentifier(item, "item"); String maximum = values.getOrDefault("maxCount", "").strip(); if (!maximum.isEmpty()) integerRange(maximum, "maxCount", 0, Integer.MAX_VALUE); } case "set_gamemode" -> enumeration(values.get("gamemode"), "gamemode", Set.of("survival", "creative", "adventure", "spectator")); case "add_effect" -> { integerRange(values.getOrDefault("duration", "30"), "duration", 1, 1_000_000); integerRange(values.getOrDefault("amplifier", "0"), "amplifier", 0, 255); } case "set_time" -> { String time = values.get("time").strip().toLowerCase(java.util.Locale.ROOT); if (!Set.of("day", "night", "noon", "midnight").contains(time)) { integerRange(time, "time", 0, 24_000); } } case "set_weather" -> { enumeration(values.get("weather"), "weather", Set.of("clear", "rain", "thunder")); integerRange(values.getOrDefault("duration", "300"), "duration", 1, 1_000_000); } case "log" -> enumeration(values.getOrDefault("level", "info"), "level", Set.of("debug", "info", "warn", "error")); case "variable" -> { String name = values.getOrDefault("name", "").strip(); if (!name.matches("(?:global\\.)?[A-Za-z_][A-Za-z0-9_-]{0,47}")) { throw new IllegalArgumentException("variable action requires a valid variable name"); } enumeration(values.getOrDefault("operation", "set"), "variable operation", Set.of( "set", "parse", "add", "subtract", "multiply", "divide", "modulo", "increment", "decrement", "append", "prepend", "replace", "regex_replace", "trim", "upper", "lower", "escape_json", "escape_command", "escape_regex", "toggle", "list_add", "list_remove", "array_add", "array_insert", "array_remove", "array_remove_at", "array_set", "dictionary_put", "dictionary_remove", "dictionary_merge", "clear")); } case "wait" -> { String modeValue = values.getOrDefault("mode", "duration"); enumeration(modeValue, "wait mode", Set.of("duration", "ticks", "game_time", "condition")); String mode = modeValue.strip().toLowerCase(java.util.Locale.ROOT); integerRange(values.getOrDefault("timeout", "0"), "wait timeout", 0, 86_400); integerRange(values.getOrDefault("pollTicks", "20"), "wait pollTicks", 1, 72_000); if (TriggerEvaluator.hasTemplateVariable(modeValue)) { // Runtime validation selects the mode after template rendering. } else if (mode.equals("duration")) { decimalRange(values.getOrDefault("value", "0"), "wait value", 0, 86_400_000); } else if (mode.equals("ticks")) { integerRange(values.getOrDefault("value", "0"), "wait ticks", 0, 86_400_000); } else if (mode.equals("game_time")) { integerRange(values.getOrDefault("value", "0"), "wait game time", 0, Integer.MAX_VALUE); } else { TriggerDefinition.Condition condition = new TriggerDefinition.Condition( values.get("field"), values.getOrDefault("operator", "eq"), values.getOrDefault("expected", "")); if (!TriggerEvaluator.hasTemplateVariable(condition.operator()) && !OPERATOR_SET.contains(condition.operator())) { throw new IllegalArgumentException("unsupported wait operator: " + condition.operator()); } } } case "run_trigger" -> { if (!TriggerEvaluator.hasTemplateVariable(values.getOrDefault("triggerId", ""))) { try { java.util.UUID.fromString(values.getOrDefault("triggerId", "").strip()); } catch (IllegalArgumentException invalid) { throw new IllegalArgumentException("run_trigger requires a trigger UUID", invalid); } } enumeration(values.getOrDefault("waitForCompletion", "false"), "waitForCompletion", Set.of("true", "false")); } case "open_menu" -> { if (!TriggerEvaluator.hasTemplateVariable(values.getOrDefault("menuId", ""))) { try { java.util.UUID.fromString(values.getOrDefault("menuId", "").strip()); } catch (IllegalArgumentException invalid) { throw new IllegalArgumentException("open_menu requires a menu UUID", invalid); } } } case "economy_deposit", "economy_withdraw", "economy_set_balance", "economy_transfer", "economy_deposit_player", "economy_withdraw_player", "economy_set_player_balance", "economy_transfer_players" -> { String currency = values.getOrDefault("currency", ""); if (!TriggerEvaluator.hasTemplateVariable(currency) && !currency.matches("(?:[a-z][a-z0-9_]{0,31}|[0-9a-fA-F-]{36})")) { throw new IllegalArgumentException("economy currency must be a code or UUID"); } String amount = values.getOrDefault("amount", ""); if (!TriggerEvaluator.hasTemplateVariable(amount)) { try { java.math.BigDecimal parsed = new java.math.BigDecimal(amount); if (!Set.of("economy_set_balance", "economy_set_player_balance").contains(action.type()) && parsed.signum() <= 0) { throw new NumberFormatException(); } } catch (RuntimeException invalid) { throw new IllegalArgumentException("economy amount must be a decimal number", invalid); } } String reason = values.getOrDefault("reason", "Trigger economy operation"); if (reason.isBlank() || reason.length() > 512) { throw new IllegalArgumentException("economy reason must contain 1-512 characters"); } if (action.type().equals("economy_transfer") && values.getOrDefault("target", "").isBlank()) { throw new IllegalArgumentException("economy_transfer requires target"); } if (Set.of("economy_deposit_player", "economy_withdraw_player", "economy_set_player_balance").contains(action.type())) { economyIdentity(values.get("player"), "player"); } if (action.type().equals("economy_transfer_players")) { economyIdentity(values.get("source"), "source"); economyIdentity(values.get("target"), "target"); } } case "set_health" -> decimalRange(values.get("value"), "health", 0, 2_048); case "set_food" -> integerRange(values.get("value"), "food", 0, 20); case "set_experience" -> { integerRange(values.get("amount"), "experience", 0, Integer.MAX_VALUE); enumeration(values.getOrDefault("mode", "points"), "experience mode", Set.of("points", "levels")); } case "set_spawnpoint" -> coordinateTriple(values.get("position"), "position"); case "scoreboard_set", "scoreboard_add" -> { safeWord(values.get("objective"), "objective", 64); integerRange(values.getOrDefault("value", "0"), "score", Integer.MIN_VALUE, Integer.MAX_VALUE); } case "team_join" -> safeWord(values.get("team"), "team", 64); case "advancement_grant", "advancement_revoke" -> resourceIdentifier(values.get("advancement"), "advancement"); case "spawn_entity" -> { resourceIdentifier(values.get("entityType"), "entityType"); coordinateTriple(values.getOrDefault("position", "~ ~ ~"), "position"); boundedSingleLine(values.getOrDefault("nbt", ""), "nbt", 16_384, true); } case "damage_entity" -> { selector(values.get("selector")); decimalRange(values.getOrDefault("amount", "1"), "damage amount", 0, 1_000_000); String damageType = values.getOrDefault("damageType", ""); if (!damageType.isBlank()) resourceIdentifier(damageType, "damageType"); } case "teleport_entity" -> { selector(values.get("selector")); coordinateTriple(values.get("destination"), "destination"); } case "remove_entity" -> selector(values.get("selector")); case "set_entity_attribute" -> { selector(values.get("selector")); resourceIdentifier(values.get("attribute"), "attribute"); decimalRange(values.get("value"), "attribute value", -1_000_000, 1_000_000); } case "tag_entity" -> { selector(values.get("selector")); enumeration(values.getOrDefault("operation", "add"), "tag operation", Set.of("add", "remove")); safeWord(values.get("tag"), "tag", 128); } case "set_block" -> { resourceIdentifier(values.getOrDefault("dimension", "minecraft:overworld"), "dimension"); coordinateTriple(values.get("position"), "position"); boundedSingleLine(values.get("block"), "block", 1_024, false); enumeration(values.getOrDefault("mode", "replace"), "set block mode", Set.of("replace", "destroy", "keep")); } case "fill_blocks" -> { resourceIdentifier(values.getOrDefault("dimension", "minecraft:overworld"), "dimension"); coordinateTriple(values.get("from"), "from"); coordinateTriple(values.get("to"), "to"); boundedSingleLine(values.get("block"), "block", 1_024, false); enumeration(values.getOrDefault("mode", "replace"), "fill mode", Set.of("replace", "destroy", "keep", "hollow", "outline")); } case "explosion" -> { resourceIdentifier(values.getOrDefault("dimension", "minecraft:overworld"), "dimension"); coordinateTriple(values.get("position"), "position"); decimalRange(values.getOrDefault("power", "4"), "explosion power", 0, 128); enumeration(values.getOrDefault("fire", "false"), "explosion fire", Set.of("true", "false")); } case "lightning" -> { resourceIdentifier(values.getOrDefault("dimension", "minecraft:overworld"), "dimension"); coordinateTriple(values.get("position"), "position"); } case "set_difficulty" -> enumeration(values.get("difficulty"), "difficulty", Set.of("peaceful", "easy", "normal", "hard")); case "set_gamerule" -> { safeWord(values.get("rule"), "gamerule", 128); boundedSingleLine(values.getOrDefault("value", ""), "gamerule value", 128, false); } case "world_border" -> { enumeration(values.get("operation"), "world border operation", Set.of("size", "add", "center", "damage_amount", "damage_buffer", "warning_distance", "warning_time")); boundedSingleLine(values.getOrDefault("value", ""), "world border value", 128, false); integerRange(values.getOrDefault("seconds", "0"), "world border seconds", 0, 86_400); } default -> { } } } private static void resourceIdentifier(String value, String name) { if (TriggerEvaluator.hasTemplateVariable(value)) return; if (value == null || !value.strip().matches("(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+")) { throw new IllegalArgumentException(name + " must be a valid resource identifier"); } } private static void economyIdentity(String value, String name) { if (value == null || value.isBlank() || value.length() > 128 || value.indexOf('\r') >= 0 || value.indexOf('\n') >= 0) { throw new IllegalArgumentException("economy " + name + " must be a player name, UUID, or template variable"); } } private static void selector(String value) { if (TriggerEvaluator.hasTemplateVariable(value)) return; boundedSingleLine(value, "selector", 512, false); String normalized = value.strip(); if (!normalized.matches("(?:@[aep][^\\r\\n ]{0,509}|[A-Za-z0-9_]{1,16}|[0-9a-fA-F-]{36})")) { throw new IllegalArgumentException("selector must be a player/entity selector, name, or UUID"); } } private static void coordinateTriple(String value, String name) { if (TriggerEvaluator.hasTemplateVariable(value)) return; if (value == null || !value.strip().matches("(?:[~^](?:-?(?:\\d+(?:\\.\\d*)?|\\.\\d+))?|-?(?:\\d+(?:\\.\\d*)?|\\.\\d+))" + "(?:\\s+(?:[~^](?:-?(?:\\d+(?:\\.\\d*)?|\\.\\d+))?|-?(?:\\d+(?:\\.\\d*)?|\\.\\d+))){2}")) { throw new IllegalArgumentException(name + " must contain exactly three coordinates"); } } private static void safeWord(String value, String name, int maximum) { if (TriggerEvaluator.hasTemplateVariable(value)) return; if (value == null || !value.strip().matches("[A-Za-z0-9_.:-]{1," + maximum + "}")) { throw new IllegalArgumentException(name + " contains unsupported characters"); } } private static void boundedSingleLine(String value, String name, int maximum, boolean emptyAllowed) { if (TriggerEvaluator.hasTemplateVariable(value)) return; String normalized = value == null ? "" : value.strip(); if ((!emptyAllowed && normalized.isEmpty()) || normalized.length() > maximum || normalized.indexOf('\r') >= 0 || normalized.indexOf('\n') >= 0) { throw new IllegalArgumentException(name + " must be a bounded single line"); } } private static void enumeration(String value, String name, Set accepted) { if (TriggerEvaluator.hasTemplateVariable(value)) return; if (value == null || !accepted.contains(value.strip().toLowerCase(java.util.Locale.ROOT))) { throw new IllegalArgumentException(name + " must be one of " + accepted); } } private static void integerRange(String value, String name, int minimum, int maximum) { if (TriggerEvaluator.hasTemplateVariable(value)) return; try { long parsed = Long.parseLong(value.strip()); if (parsed < minimum || parsed > maximum) throw new NumberFormatException(); } catch (RuntimeException exception) { throw new IllegalArgumentException(name + " must be between " + minimum + " and " + maximum, exception); } } private static void decimalRange(String value, String name, double minimum, double maximum) { if (TriggerEvaluator.hasTemplateVariable(value)) return; double parsed = finiteNumber(value, name); if (parsed < minimum || parsed > maximum) { throw new IllegalArgumentException(name + " must be between " + minimum + " and " + maximum); } } private static double finiteNumber(String value, String name) { try { double parsed = Double.parseDouble(value.strip()); if (!Double.isFinite(parsed)) throw new NumberFormatException(); return parsed; } catch (RuntimeException exception) { throw new IllegalArgumentException(name + " must be a finite number", exception); } } private static boolean providesPlayerContext(String event) { return event.startsWith("player.") || event.equals("block.break") || event.equals("block.place") || event.equals("block.tool_modify") || event.startsWith("menu.") || event.startsWith("economy.") || event.startsWith("region.") || event.startsWith("custom."); } private static void validateEventConfiguration(TriggerDefinition.TriggerEvent event) { if (event.type().equals(TriggerCommandConfiguration.EVENT_TYPE)) { TriggerCommandConfiguration.parse(event); return; } if (!event.arguments().isEmpty()) { throw new IllegalArgumentException("command arguments require the player.command_trigger event"); } if (event.type().equals("schedule.daily")) { rejectUnknownEventParameters(event, Set.of("time", "timezone")); String time = event.configuration().getOrDefault("time", ""); try { java.time.LocalTime.parse(time); java.time.ZoneId.of(event.configuration().getOrDefault("timezone", "UTC")); } catch (java.time.DateTimeException exception) { throw new IllegalArgumentException("daily schedule needs a valid time and timezone", exception); } } if (event.type().equals("schedule.interval")) { rejectUnknownEventParameters(event, Set.of("seconds")); TriggerIntervalSchedule.totalSeconds(event.configuration()); return; } if (event.type().startsWith("protection.")) { validateProtectionEvent(event); return; } if (event.type().startsWith("region.")) { rejectUnknownEventParameters(event, Set.of("regionId")); String region = event.configuration().getOrDefault("regionId", ""); if (!region.matches("[a-z][a-z0-9_.-]{1,63}")) { throw new IllegalArgumentException("region event requires a regionId"); } return; } if (!event.type().equals("schedule.daily") && !event.configuration().isEmpty()) { throw new IllegalArgumentException(event.type() + " does not accept event configuration parameters"); } } private static void validateProtectionEvent(TriggerDefinition.TriggerEvent event) { Set accepted = switch (event.type()) { case "protection.item_overflow", "protection.mob_overflow", "protection.entity_overflow" -> Set.of("threshold", "scope", "cooldownSeconds"); case "protection.mod_entity_overflow" -> Set.of("threshold", "namespace", "cooldownSeconds"); case "protection.slow_tick" -> Set.of("threshold", "consecutive", "cooldownSeconds"); default -> Set.of("threshold", "cooldownSeconds"); }; rejectUnknownEventParameters(event, accepted); int maximum = event.type().equals("protection.memory_pressure") ? 99 : Integer.MAX_VALUE; int minimum = event.type().equals("protection.memory_pressure") ? 50 : event.type().equals("protection.slow_tick") ? 50 : 1; integerRange(event.configuration().getOrDefault("threshold", ""), "protection threshold", minimum, maximum); integerRange(event.configuration().getOrDefault("cooldownSeconds", "60"), "protection cooldownSeconds", 1, 86_400); if (Set.of("protection.item_overflow", "protection.mob_overflow", "protection.entity_overflow").contains(event.type())) { enumeration(event.configuration().getOrDefault("scope", "dimension"), "protection scope", Set.of("dimension", "chunk")); } if (event.type().equals("protection.mod_entity_overflow")) { String namespace = event.configuration().getOrDefault("namespace", "").strip(); if (!namespace.matches("[a-z0-9_.-]{1,64}")) { throw new IllegalArgumentException("mod entity protection requires a namespace"); } } if (event.type().equals("protection.slow_tick")) { integerRange(event.configuration().getOrDefault("consecutive", "1"), "protection consecutive", 1, 1_200); } } private static void rejectUnknownEventParameters( TriggerDefinition.TriggerEvent event, Set accepted) { for (String parameter : event.configuration().keySet()) { if (!accepted.contains(parameter)) { throw new IllegalArgumentException(event.type() + " does not accept event configuration parameter " + parameter); } } } }