feat: 初始化 KubeJS 文件结构

kubejs/client_scripts/_main_.js

@@ -0,0 +1,3 @@
+// priority: 100
+
+console.info(`${global.LOG_PREFIX} 加载客户端内容`);

kubejs/config/client.properties

@@ -0,0 +1,15 @@
+#KubeJS Client Properties
+#Sun Jul 03 17:12:21 SGT 2022
+backgroundColor=2E3440
+barBorderColor=ECEFF4
+exportAtlases=false
+menuBackgroundBrightness=64
+disableRecipeBook=false
+title=
+barColor=ECEFF4
+overrideColors=false
+fmlLogColor=ECEFF4
+showTagNames=true
+fmlMemoryColor=ECEFF4
+menuBackgroundScale=32.0
+menuInnerBackgroundBrightness=32

kubejs/config/common.properties

@@ -0,0 +1,9 @@
+#KubeJS Common Properties
+#Sun Jul 03 17:12:16 SGT 2022
+announceReload=true
+disableClassFilter=false
+serverOnly=false
+hideServerScriptErrors=false
+packmode=default
+printRemappedClasses=false
+debugInfo=false

kubejs/jsconfig.json

@@ -0,0 +1,6 @@
+{
+    "compilerOptions": {
+        "lib": ["ES5", "ES2015"],
+        "typeRoots": ["./probe/generated", "./probe/user"]
+    }
+}

kubejs/probe/generated/constants.d.ts

@@ -0,0 +1,23 @@
+/// <reference path="./globals.d.ts" />
+declare const settings: Internal.ServerSettings;
+declare const console: Internal.ConsoleJS;
+declare const RARITY_RARE: Rarity;
+declare const HOUR: 3600000;
+declare const SLOT_FEET: EquipmentSlot;
+declare const SLOT_HEAD: EquipmentSlot;
+// declare const global: {};
+declare const MAIN_HAND: Hand;
+declare const SLOT_LEGS: EquipmentSlot;
+declare const AIR_BLOCK: Internal.class_2189;
+declare const RARITY_UNCOMMON: Rarity;
+declare const AIR_ITEM: Internal.class_1739;
+declare const SLOT_CHEST: EquipmentSlot;
+declare const RARITY_EPIC: Rarity;
+declare const Painter: Internal.Painter;
+declare const SECOND: 1000;
+declare const MINUTE: 60000;
+declare const SLOT_OFFHAND: EquipmentSlot;
+declare const RARITY_COMMON: Rarity;
+declare const Client: Internal.ClientWrapper;
+declare const SLOT_MAINHAND: EquipmentSlot;
+declare const OFF_HAND: Hand;

kubejs/probe/generated/events.d.ts

@@ -0,0 +1,48 @@
+/// <reference path="./globals.d.ts" />
+/// <reference path="./registries.d.ts" />
+declare function onEvent(name: "recipes.serializer.special.flag", handler: (event: Internal.SpecialRecipeSerializerManager) => void);
+declare function onEvent(name: "player.chest.opened", handler: (event: Internal.ChestEventJS) => void);
+declare function onEvent(name: "player.advancement", handler: (event: Internal.PlayerAdvancementEventJS) => void);
+declare function onEvent(name: "recipes.type_registry", handler: (event: Internal.RecipeTypeRegistryEventJS) => void);
+declare function onEvent(name: "sound.registry", handler: (event: Internal.SoundRegistryEventJS) => void);
+declare function onEvent(name: "recipes.compostables", handler: (event: Internal.CompostablesRecipeEventJS) => void);
+declare function onEvent(name: "item.registry.armor_tiers", handler: (event: Internal.ItemArmorTierEventJS) => void);
+declare function onEvent(name: "client.generate_assets", handler: (event: Internal.ClientGenerateAssetsEventJS) => void);
+declare function onEvent(name: "client.paint_screen", handler: (event: Internal.ScreenPaintEventJS) => void);
+declare function onEvent(name: "item.model_properties", handler: (event: Internal.ItemModelPropertiesEventJS) => void);
+declare function onEvent(name: "client.painter_updated", handler: (event: Internal.PainterUpdatedEventJS) => void);
+declare function onEvent(name: "command.registry", handler: (event: Internal.CommandRegistryEventJS) => void);
+declare function onEvent(name: "command.run", handler: (event: Internal.CommandEventJS) => void);
+declare function onEvent(name: "item.food_eaten", handler: (event: Internal.ItemFoodEatenEventJS) => void);
+declare function onEvent(name: "item.registry.tool_tiers", handler: (event: Internal.ItemToolTierEventJS) => void);
+declare function onEvent(name: "player.chest.closed", handler: (event: Internal.ChestEventJS) => void);
+declare function onEvent(name: "minecraft.sound_event.registry", handler: (event: Registry.Sound_event) => void);
+declare function onEvent(name: "sound_event.registry", handler: (event: Registry.Sound_event) => void);
+declare function onEvent(name: "minecraft.fluid.registry", handler: (event: Registry.Fluid) => void);
+declare function onEvent(name: "fluid.registry", handler: (event: Registry.Fluid) => void);
+declare function onEvent(name: "minecraft.block.registry", handler: (event: Registry.Block) => void);
+declare function onEvent(name: "block.registry", handler: (event: Registry.Block) => void);
+declare function onEvent(name: "minecraft.item.registry", handler: (event: Registry.Item) => void);
+declare function onEvent(name: "item.registry", handler: (event: Registry.Item) => void);
+declare function onEvent(name: "minecraft.enchantment.registry", handler: (event: Registry.Enchantment) => void);
+declare function onEvent(name: "enchantment.registry", handler: (event: Registry.Enchantment) => void);
+declare function onEvent(name: "minecraft.mob_effect.registry", handler: (event: Registry.Mob_effect) => void);
+declare function onEvent(name: "mob_effect.registry", handler: (event: Registry.Mob_effect) => void);
+declare function onEvent(name: "minecraft.entity_type.registry", handler: (event: Registry.Entity_type) => void);
+declare function onEvent(name: "entity_type.registry", handler: (event: Registry.Entity_type) => void);
+declare function onEvent(name: "minecraft.block_entity_type.registry", handler: (event: Registry.Block_entity_type) => void);
+declare function onEvent(name: "block_entity_type.registry", handler: (event: Registry.Block_entity_type) => void);
+declare function onEvent(name: "minecraft.potion.registry", handler: (event: Registry.Potion) => void);
+declare function onEvent(name: "potion.registry", handler: (event: Registry.Potion) => void);
+declare function onEvent(name: "minecraft.particle_type.registry", handler: (event: Registry.Particle_type) => void);
+declare function onEvent(name: "particle_type.registry", handler: (event: Registry.Particle_type) => void);
+declare function onEvent(name: "minecraft.motive.registry", handler: (event: Registry.Motive) => void);
+declare function onEvent(name: "motive.registry", handler: (event: Registry.Motive) => void);
+declare function onEvent(name: "minecraft.custom_stat.registry", handler: (event: Registry.Custom_stat) => void);
+declare function onEvent(name: "custom_stat.registry", handler: (event: Registry.Custom_stat) => void);
+declare function onEvent(name: "minecraft.point_of_interest_type.registry", handler: (event: Registry.Point_of_interest_type) => void);
+declare function onEvent(name: "point_of_interest_type.registry", handler: (event: Registry.Point_of_interest_type) => void);
+declare function onEvent(name: "minecraft.villager_type.registry", handler: (event: Registry.Villager_type) => void);
+declare function onEvent(name: "villager_type.registry", handler: (event: Registry.Villager_type) => void);
+declare function onEvent(name: "minecraft.villager_profession.registry", handler: (event: Registry.Villager_profession) => void);
+declare function onEvent(name: "villager_profession.registry", handler: (event: Registry.Villager_profession) => void);

kubejs/probe/generated/events.documented.d.ts

@@ -0,0 +1,739 @@
+/// <reference path="./globals.d.ts" />
+/// <reference path="./registries.d.ts" />
+/**
+* Fired when you need to add some datapack json to the server.
+*
+* Low priority event is fired first, as they will be overriden later.
+*
+* And vise versa for high priority events.
+*/
+declare function onEvent(name: "server.datapack.low_priority", handler: (event: Internal.DataPackEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.chunk_generator", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.height_provider_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.material_condition", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired on an entity is spawned.
+*/
+declare function onEvent(name: "entity.spawned", handler: (event: Internal.EntitySpawnedEventJS) => void);
+/**
+* Fired by different tag everytime when a player:
+* - ticks
+* - logged in
+* - logged out
+*/
+declare function onEvent(name: "player.tick", handler: (event: Internal.SimplePlayerEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.material_rule", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.activity", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when player clicked a non-air, non-fluid block.
+*
+* This event is called only once.
+*/
+declare function onEvent(name: "block.left_click", handler: (event: Internal.BlockLeftClickEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.placed_feature", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.template_pool", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when ticking on client side.
+*/
+declare function onEvent(name: "client.tick", handler: (event: Internal.ClientTickEventJS) => void);
+/**
+* Fired when a living entity is about to die.
+*
+* If the entity's HP <= 0, the entity will fall and get removed.
+*
+* If the event is not cancelled, the entity will die and drop loots.
+*/
+declare function onEvent(name: "entity.death", handler: (event: Internal.LivingEntityDeathEventJS) => void);
+/**
+* Fired when you need to modify properties of an item.
+*/
+declare function onEvent(name: "item.modification", handler: (event: Internal.ItemModificationEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.chunk_status", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.noise", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.sensor_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.items", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.trunk_placer_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.loot_condition_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.blocks", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired by different tag when the game:
+* - is initializing
+* - is post-initializing
+*/
+declare function onEvent(name: "init", handler: (event: Internal.StartupEventJS) => void);
+/**
+* Fired when you need to modify recipes.
+*/
+declare function onEvent(name: "recipes", handler: (event: Internal.RecipeEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.int_provider_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "block.tags", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired by different tag everytime when a player:
+* - ticks
+* - logged in
+* - logged out
+*/
+declare function onEvent(name: "player.logged_in", handler: (event: Internal.SimplePlayerEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.entity_types", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.loot_pool_entry_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.memory_module_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.motive", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.feature_size_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when the chest loot table is registering.
+*/
+declare function onEvent(name: "chest.loot_tables", handler: (event: Internal.ChestLootEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.position_source_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to remove worldgen.
+*/
+declare function onEvent(name: "worldgen.remove", handler: (event: Internal.WorldgenRemoveEventJS) => void);
+/**
+* Fired to register special handlers for tooltips on items.
+*/
+declare function onEvent(name: "item.tooltip", handler: (event: Internal.ItemTooltipEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.block_entity_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.game_events", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.structure_pool_element", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when a block is placed.
+*
+* Note that the entity can be `null`, if the placer is a dispenser, etc.
+*/
+declare function onEvent(name: "block.place", handler: (event: Internal.BlockPlaceEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.custom_stat", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.stat_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.block_state_provider_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.loot_function_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.dimension_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.attribute", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to remove worldgen.
+*/
+declare function onEvent(name: "worldgen.add", handler: (event: Internal.WorldgenAddEventJS) => void);
+/**
+* Fired when you need to modify properties of a block.
+*/
+declare function onEvent(name: "block.modification", handler: (event: Internal.BlockModificationEventJS) => void);
+/**
+* Fired when the inventory of player is changed.
+*/
+declare function onEvent(name: "player.inventory.changed", handler: (event: Internal.InventoryChangedEventJS) => void);
+/**
+* Fired when the gift loot table (cat, villager, etc.) is registering.
+*/
+declare function onEvent(name: "gift.loot_tables", handler: (event: Internal.GiftLootEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.particle_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.foliage_placer_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.recipe_serializer", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when the fishing loot table is registering.
+*/
+declare function onEvent(name: "fishing.loot_tables", handler: (event: Internal.FishingLootEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "fluid.tags", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired by different tag when the level:
+* - loads
+* - ticks
+* - unloads
+*/
+declare function onEvent(name: "level.tick", handler: (event: Internal.SimpleLevelEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.enchantment", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.mob_effect", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.loot_score_provider_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.noise_settings", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.point_of_interest_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired by different tag when the server:
+* - loads
+* - ticks
+* - unloads
+*/
+declare function onEvent(name: "server.tick", handler: (event: Internal.ServerEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.structure_placement", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.biome_source", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.pos_rule_test", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when the player:
+* - opens the inventory
+* - closes the inventory
+*/
+declare function onEvent(name: "player.inventory.opened", handler: (event: Internal.InventoryEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.loot_number_provider_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.recipe_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.loot_nbt_provider_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.configured_structure_feature", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.block_predicate_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when a living entity is hurt.
+*
+* If cancelled, the attack will do no effect.
+*/
+declare function onEvent(name: "entity.hurt", handler: (event: Internal.LivingEntityHurtEventJS) => void);
+/**
+* Fired by different tag when the game:
+* - is initializing
+* - is post-initializing
+*/
+declare function onEvent(name: "postinit", handler: (event: Internal.StartupEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.structure_feature", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.configured_feature", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when the generic loot table is registering.
+* Note that this is unused.
+*/
+declare function onEvent(name: "generic.loot_tables", handler: (event: Internal.GenericLootEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.feature", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.density_function_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired by different tag when the server:
+* - loads
+* - ticks
+* - unloads
+*/
+declare function onEvent(name: "server.load", handler: (event: Internal.ServerEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.float_provider_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add some datapack json to the server.
+*
+* Low priority event is fired first, as they will be overriden later.
+*
+* And vise versa for high priority events.
+*/
+declare function onEvent(name: "server.datapack.high_priority", handler: (event: Internal.DataPackEventJS) => void);
+/**
+* Fired when you need to add some datapack json to the server.
+*
+* Low priority event is fired first, as they will be overriden later.
+*
+* And vise versa for high priority events.
+*/
+declare function onEvent(name: "server.datapack.last", handler: (event: Internal.DataPackEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.schedule", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired by different tag when the level:
+* - loads
+* - ticks
+* - unloads
+*/
+declare function onEvent(name: "level.load", handler: (event: Internal.SimpleLevelEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.structure_piece", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.density_function", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when player right clicks on an Entity.
+*
+* Note that both main hand and off hand will be called if not cancelled.
+*
+* On cancellation, Result.SUCCESS is returned, thus making player swing his arm.
+*/
+declare function onEvent(name: "item.entity_interact", handler: (event: Internal.ItemEntityInteractEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.structure_processor", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.sound_event", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when the player tossed an item.
+*/
+declare function onEvent(name: "item.toss", handler: (event: Internal.ItemTossEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "item.tags", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when the entity loot table is registering.
+*/
+declare function onEvent(name: "entity.loot_tables", handler: (event: Internal.EntityLootEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.rule_test", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when the client is initalizing.
+*/
+declare function onEvent(name: "client.init", handler: (event: Internal.ClientEventJS) => void);
+/**
+* Fired when a block is broken by player. This will not be fired by other means, like TNT.
+*
+* On fabric, the experience returned is always `null`.
+*/
+declare function onEvent(name: "block.break", handler: (event: Internal.BlockBreakEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.structure_set", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.tree_decorator_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when player right clicks with item on hand.
+*
+* Note that this will only be fired when hand has item.
+*
+* On cancellation, Result.SUCCESS is returned, thus making player swing his arm.
+*/
+declare function onEvent(name: "item.right_click", handler: (event: Internal.ItemRightClickEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.placement_modifier_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.villager_profession", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when the player:
+* - opens the inventory
+* - closes the inventory
+*/
+declare function onEvent(name: "player.inventory.closed", handler: (event: Internal.InventoryEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.villager_type", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when an item is about to be picked up by the player.
+*/
+declare function onEvent(name: "item.pickup", handler: (event: Internal.ItemPickupEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.processor_list", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.fluids", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.configured_carver", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.carver", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when the block loot table is registering.
+*/
+declare function onEvent(name: "block.loot_tables", handler: (event: Internal.BlockLootEventJS) => void);
+/**
+* Fired by different tag when the client is:
+* - logged in
+* - logged out
+*/
+declare function onEvent(name: "client.logged_in", handler: (event: Internal.ClientLoggedInEventJS) => void);
+/**
+* Fired when player right clicks on an Block that is not fluid.
+*
+* Note that both main hand and off hand will be called if not cancelled.
+*
+* On cancellation, Result.SUCCESS is returned, thus making player swing his arm.
+*/
+declare function onEvent(name: "block.right_click", handler: (event: Internal.BlockRightClickEventJS) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.menu", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.potion", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add, change tags of things.
+*
+* However, due to the type erasure of Java, Probe can not determine what
+* can be used here, please refer to the tag string itself.
+*/
+declare function onEvent(name: "tags.worldgen.biome", handler: (event: Internal.TagEventJS<any>) => void);
+/**
+* Fired when you need to add some datapack json to the server.
+*
+* Low priority event is fired first, as they will be overriden later.
+*
+* And vise versa for high priority events.
+*/
+declare function onEvent(name: "server.datapack.first", handler: (event: Internal.DataPackEventJS) => void);

kubejs/probe/generated/names.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="./globals.d.ts" />
+const Vec3d: typeof Vec3
+const Direction: typeof Facing
+const Text: typeof Component

kubejs/probe/generated/registries.d.ts

@@ -0,0 +1,81 @@
+/// <reference path="./globals.d.ts" />
+declare namespace Registry {
+    class Sound_event extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.SoundEventBuilder;
+        create(id: string): Internal.SoundEventBuilder;
+    }
+    class Fluid extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.FluidBuilder;
+        create(id: string): Internal.FluidBuilder;
+    }
+    class Block extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.BasicBlockJS$Builder;
+        create(id: string, type: "detector"): Internal.DetectorBlock$Builder;
+        create(id: string, type: "slab"): Internal.SlabBlockBuilder;
+        create(id: string, type: "stairs"): Internal.StairBlockBuilder;
+        create(id: string, type: "fence"): Internal.FenceBlockBuilder;
+        create(id: string, type: "fence_gate"): Internal.FenceGateBlockBuilder;
+        create(id: string, type: "wall"): Internal.WallBlockBuilder;
+        create(id: string, type: "wooden_pressure_plate"): Internal.WoodenPressurePlateBlockBuilder;
+        create(id: string, type: "stone_pressure_plate"): Internal.StonePressurePlateBlockBuilder;
+        create(id: string, type: "wooden_button"): Internal.WoodenButtonBlockBuilder;
+        create(id: string, type: "stone_button"): Internal.StoneButtonBlockBuilder;
+        create(id: string, type: "falling"): Internal.FallingBlockBuilder;
+        create(id: string, type: "crop"): Internal.CropBlockBuilder;
+        create(id: string): Internal.BasicBlockJS$Builder;
+    }
+    class Item extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.BasicItemJS$Builder;
+        create(id: string, type: "sword"): Internal.SwordItemBuilder;
+        create(id: string, type: "pickaxe"): Internal.PickaxeItemBuilder;
+        create(id: string, type: "axe"): Internal.AxeItemBuilder;
+        create(id: string, type: "shovel"): Internal.ShovelItemBuilder;
+        create(id: string, type: "hoe"): Internal.HoeItemBuilder;
+        create(id: string, type: "helmet"): Internal.ArmorItemBuilder$Helmet;
+        create(id: string, type: "chestplate"): Internal.ArmorItemBuilder$Chestplate;
+        create(id: string, type: "leggings"): Internal.ArmorItemBuilder$Leggings;
+        create(id: string, type: "boots"): Internal.ArmorItemBuilder$Boots;
+        create(id: string, type: "music_disc"): Internal.RecordItemJS$Builder;
+        create(id: string): Internal.BasicItemJS$Builder;
+    }
+    class Enchantment extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.EnchantmentBuilder;
+        create(id: string): Internal.EnchantmentBuilder;
+    }
+    class Mob_effect extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.BasicMobEffect$Builder;
+        create(id: string): Internal.BasicMobEffect$Builder;
+    }
+    class Entity_type extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+    }
+    class Block_entity_type extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+    }
+    class Potion extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.PotionBuilder;
+        create(id: string): Internal.PotionBuilder;
+    }
+    class Particle_type extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.ParticleTypeBuilder;
+        create(id: string): Internal.ParticleTypeBuilder;
+    }
+    class Motive extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.MotiveBuilder;
+        create(id: string): Internal.MotiveBuilder;
+    }
+    class Custom_stat extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.CustomStatBuilder;
+        create(id: string): Internal.CustomStatBuilder;
+    }
+    class Point_of_interest_type extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.PoiTypeBuilder;
+        create(id: string): Internal.PoiTypeBuilder;
+    }
+    class Villager_type extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.VillagerTypeBuilder;
+        create(id: string): Internal.VillagerTypeBuilder;
+    }
+    class Villager_profession extends Internal.RegistryObjectBuilderTypes$RegistryEventJS<any> {
+        create(id: string, type: "basic"): Internal.VillagerProfessionBuilder;
+        create(id: string): Internal.VillagerProfessionBuilder;
+    }
+}

kubejs/probe/user/constants.d.ts

@@ -0,0 +1,6 @@
+declare const global: {
+
+  /** 日志前缀 */
+  LOG_PREFIX: string;
+
+};

kubejs/server_scripts/_main_.js

@@ -0,0 +1,8 @@
+// priority: 100
+
+settings.logAddedRecipes = true;
+settings.logErroringRecipes = true;
+settings.logRemovedRecipes = true;
+settings.logSkippedRecipes = false;
+
+console.info(`${global.LOG_PREFIX} 加载服务端内容`);

kubejs/startup_scripts/_main_.js

@@ -0,0 +1,5 @@
+// priority: 100
+
+global.LOG_PREFIX = '[KubeJS]';
+
+console.info(`${global.LOG_PREFIX} 启动`);