sandstone 1.0.0-beta.0 → 1.0.0-beta.2

package/src/arguments/generated/data/enchantment.ts

@@ -0,0 +1,75 @@
+import type { EnchantmentEffectComponentMap } from 'sandstone/arguments/generated/data/enchantment/effect_component.ts'
+import type { Registry } from 'sandstone/arguments/generated/registry.ts'
+import type { EquipmentSlotGroup } from 'sandstone/arguments/generated/util/slot.ts'
+import type { Text } from 'sandstone/arguments/generated/util/text.ts'
+import type { EnchantmentClass, NBTInt, TagClass } from 'sandstone'
+
+export type Enchantment = {
+  description: Text,
+  exclusive_set?: ((
+        | Registry['minecraft:enchantment']
+        | `#${Registry['minecraft:tag/enchantment']}`
+        | TagClass<'enchantment'>
+        | EnchantmentClass)
+      | Array<(Registry['minecraft:enchantment'] | EnchantmentClass)>),
+  supported_items: ((
+      | Registry['minecraft:item'] | `#${Registry['minecraft:tag/item']}` | TagClass<'item'>)
+      | Array<Registry['minecraft:item']>),
+  /**
+   * Item types for which this Enchantment shows up in Enchanting Tables and on traded equipment.
+   *
+   * Must be a subset of `supported_items`.
+   */
+  primary_items?: ((
+      | Registry['minecraft:item'] | `#${Registry['minecraft:tag/item']}` | TagClass<'item'>)
+      | Array<Registry['minecraft:item']>),
+  /**
+   * How commonly the Enchantment appears, compared to the total combined `weight` of all available Enchantments.
+   *
+   * Value:
+   * Range: 1..1024
+   */
+  weight: NBTInt<{
+    min: 1,
+  }>,
+  /**
+   * Maximum level of the enchantment.
+   *
+   * Value:
+   * Range: 1..255
+   */
+  max_level: NBTInt<{
+    min: 1,
+  }>,
+  /**
+   * Minimum experience cost.
+   */
+  min_cost: EnchantmentCost,
+  /**
+   * Maximum experience cost.
+   */
+  max_cost: EnchantmentCost,
+  /**
+   * Halved when an Enchantment is added to a book.
+   * The effective fee is multiplied by the level of the Enchantment.
+   *
+   * Value:
+   * Range: 0..
+   */
+  anvil_cost: NBTInt<{
+    min: 0,
+  }>,
+  slots: Array<EquipmentSlotGroup>,
+  effects?: EnchantmentEffectComponentMap,
+}
+
+export type EnchantmentCost = {
+  /**
+   * Base cost at level 1.
+   */
+  base: NBTInt,
+  /**
+   * Cost increase per level above 1.
+   */
+  per_level_above_first: NBTInt,
+}

package/src/arguments/generated/data/gametest/test_environment.ts

@@ -0,0 +1,109 @@
+import type { SymbolGameRule } from 'sandstone/arguments/generated/dispatcher.ts'
+import type { Registry } from 'sandstone/arguments/generated/registry.ts'
+import type { RootNBT } from 'sandstone/arguments/nbt.ts'
+import type { MCFunctionClass, NBTInt, WorldClockClass } from 'sandstone'
+
+export type AllOffTestEnvironment = {
+  definitions: Array<TestEnvironment>,
+}
+
+export type BoolGameRule = {
+  rule: `${any}${string}`,
+  value: boolean,
+}
+
+export type ClockTimeTestEnvironment = {
+  clock: (Registry['minecraft:world_clock'] | WorldClockClass),
+  /**
+   * Value:
+   * Range: 0..
+   */
+  time: NBTInt<{
+    min: 0,
+  }>,
+}
+
+export type FunctionTestEnvironment = {
+  setup?: (`${string}:${string}` | MCFunctionClass),
+  teardown?: (`${string}:${string}` | MCFunctionClass),
+}
+
+export type GameRulesTestEnvironment = {
+  rules: ({
+    [Key in Extract<Registry['minecraft:game_rule'], string>]?: (Key extends keyof SymbolGameRule
+      ? SymbolGameRule[Key]
+      : RootNBT)
+  }),
+}
+
+export type IntGameRule = {
+  rule: `${any}${string}`,
+  value: NBTInt,
+}
+
+export type TestEnvironment = NonNullable<({
+  [S in Extract<Registry['minecraft:test_environment_definition_type'], string>]?: ({
+    type: S,
+  } & (S extends keyof SymbolTestEnvironmentDefinition ? SymbolTestEnvironmentDefinition[S] : RootNBT))
+}[Registry['minecraft:test_environment_definition_type']])>
+
+export type TimeOfDayTestEnvironment = {
+  /**
+   * Value:
+   * Range: 0..
+   */
+  time: NBTInt<{
+    min: 0,
+  }>,
+}
+
+export type Weather = ('clear' | 'rain' | 'thunder')
+
+export type WeatherTestEnvironment = {
+  /**
+   * Value:
+   *
+   *  - Clear(`clear`)
+   *  - Rain(`rain`)
+   *  - Thunder(`thunder`)
+   */
+  weather: Weather,
+}
+type TestEnvironmentDefinitionDispatcherMap = {
+  'all_of': TestEnvironmentDefinitionAllOf,
+  'minecraft:all_of': TestEnvironmentDefinitionAllOf,
+  'clock_time': TestEnvironmentDefinitionClockTime,
+  'minecraft:clock_time': TestEnvironmentDefinitionClockTime,
+  'function': TestEnvironmentDefinitionFunction,
+  'minecraft:function': TestEnvironmentDefinitionFunction,
+  'game_rules': TestEnvironmentDefinitionGameRules,
+  'minecraft:game_rules': TestEnvironmentDefinitionGameRules,
+  'time_of_day': TestEnvironmentDefinitionTimeOfDay,
+  'minecraft:time_of_day': TestEnvironmentDefinitionTimeOfDay,
+  'weather': TestEnvironmentDefinitionWeather,
+  'minecraft:weather': TestEnvironmentDefinitionWeather,
+}
+type TestEnvironmentDefinitionKeys = keyof TestEnvironmentDefinitionDispatcherMap
+type TestEnvironmentDefinitionFallback = (
+  | TestEnvironmentDefinitionAllOf
+  | TestEnvironmentDefinitionClockTime
+  | TestEnvironmentDefinitionFunction
+  | TestEnvironmentDefinitionGameRules
+  | TestEnvironmentDefinitionTimeOfDay
+  | TestEnvironmentDefinitionWeather)
+type TestEnvironmentDefinitionAllOf = AllOffTestEnvironment
+type TestEnvironmentDefinitionClockTime = ClockTimeTestEnvironment
+type TestEnvironmentDefinitionFunction = FunctionTestEnvironment
+type TestEnvironmentDefinitionGameRules = GameRulesTestEnvironment
+type TestEnvironmentDefinitionTimeOfDay = TimeOfDayTestEnvironment
+type TestEnvironmentDefinitionWeather = WeatherTestEnvironment
+export type SymbolTestEnvironmentDefinition<CASE extends
+  | 'map'
+  | 'keys'
+  | '%fallback'
+  | '%none'
+  | '%unknown' = 'map'> = CASE extends 'map'
+  ? TestEnvironmentDefinitionDispatcherMap
+  : CASE extends 'keys'
+    ? TestEnvironmentDefinitionKeys
+    : CASE extends '%fallback' ? TestEnvironmentDefinitionFallback : never

package/src/arguments/generated/data/gametest.ts

@@ -0,0 +1,119 @@
+import type { TestEnvironment } from 'sandstone/arguments/generated/data/gametest/test_environment.ts'
+import type { Registry } from 'sandstone/arguments/generated/registry.ts'
+import type { RootNBT } from 'sandstone/arguments/nbt.ts'
+import type { NBTInt, StructureClass, TestEnvironmentClass } from 'sandstone'
+
+export type BlockBasedTestInstance = TestData
+
+export type FunctionTestInstance = (TestData & {
+  /**
+   * Test function (Java code) to run.
+   */
+  function: Registry['minecraft:test_function'],
+})
+
+export type Rotation = ('none' | 'clockwise_90' | '180' | 'counterclockwise_90')
+
+export type TestData = {
+  /**
+   * The test environment to run this test as part of.
+   */
+  environment: ((Registry['minecraft:test_environment'] | TestEnvironmentClass) | TestEnvironment),
+  /**
+   * Structure NBT file to use for the test.
+   */
+  structure: (Registry['minecraft:structure'] | StructureClass),
+  /**
+   * Maximum number of ticks allowed to pass before the test is considered timed out.
+   *
+   * Value:
+   * Range: 1..
+   */
+  max_ticks: NBTInt<{
+    min: 1,
+  }>,
+  /**
+   * Ticks to wait after placing the structure before starting the test. Defaults to `0`.
+   *
+   * Value:
+   * Range: 0..
+   */
+  setup_ticks?: NBTInt<{
+    min: 0,
+  }>,
+  /**
+   * Whether the test is considered required to pass for the full test suite to pass. Defaults to `true`.
+   */
+  required?: boolean,
+  /**
+   * Rotation to apply to the test structure. Defaults to `none`.
+   *
+   * Value:
+   *
+   *  - None(`none`)
+   *  - Clockwise90(`clockwise_90`)
+   *  - Clockwise180(`180`)
+   *  - CounterClockwise90(`counterclockwise_90`)
+   */
+  rotation?: Rotation,
+  /**
+   * If `true`, test is not included as part of automated test runs. Defaults to `false`.
+   */
+  manual_only?: boolean,
+  /**
+   * Number of attempts to run the test. Defaults to `1`.
+   *
+   * Value:
+   * Range: 1..
+   */
+  max_attempts?: NBTInt<{
+    min: 1,
+  }>,
+  /**
+   * Number of attempts that must succeed for the test to be considered successful. Defaults to `1`.
+   *
+   * Value:
+   * Range: 1..
+   */
+  required_successes?: NBTInt<{
+    min: 1,
+  }>,
+  /**
+   * Whether the test needs clear access to the sky. Defaults to `false`.
+   * If `false`, test is enclosed in barrier blocks. If `true`, the top is left open.
+   */
+  sky_access?: boolean,
+  /**
+   * Additional padding in blocks placed around the structure. Defaults to `0`.
+   *
+   * Value:
+   * Range: 0..128
+   */
+  padding?: NBTInt<{
+    min: 0,
+  }>,
+}
+
+export type TestInstance = NonNullable<({
+  [S in Extract<Registry['minecraft:test_instance_type'], string>]?: ({
+    type: S,
+  } & (S extends keyof SymbolTestInstance ? SymbolTestInstance[S] : RootNBT))
+}[Registry['minecraft:test_instance_type']])>
+type TestInstanceDispatcherMap = {
+  'block_based': TestInstanceBlockBased,
+  'minecraft:block_based': TestInstanceBlockBased,
+  'function': TestInstanceFunction,
+  'minecraft:function': TestInstanceFunction,
+}
+type TestInstanceKeys = keyof TestInstanceDispatcherMap
+type TestInstanceFallback = (TestInstanceBlockBased | TestInstanceFunction)
+type TestInstanceBlockBased = BlockBasedTestInstance
+type TestInstanceFunction = FunctionTestInstance
+export type SymbolTestInstance<CASE extends
+  | 'map'
+  | 'keys'
+  | '%fallback'
+  | '%none'
+  | '%unknown' = 'map'> = CASE extends 'map'
+  ? TestInstanceDispatcherMap
+  : CASE extends 'keys' ? TestInstanceKeys : CASE extends '%fallback' ? TestInstanceFallback : never

package/src/arguments/generated/data/item_modifier.ts

@@ -0,0 +1,3 @@
+import type { LootFunction } from 'sandstone/arguments/generated/data/loot.ts'
+
+export type ItemModifier = (LootFunction | Array<LootFunction>)

package/src/arguments/generated/data/loot/condition.ts

@@ -0,0 +1,291 @@
+import type {
+  DamageSourcePredicate,
+  EntityPredicate,
+  ItemPredicate,
+  LocationPredicate,
+} from 'sandstone/arguments/generated/data/advancement/predicate.ts'
+import type { LevelBasedValue } from 'sandstone/arguments/generated/data/enchantment/level_based_value.ts'
+import type { EntityTarget, LootCondition } from 'sandstone/arguments/generated/data/loot.ts'
+import type { IntRange, NumberProvider } from 'sandstone/arguments/generated/data/util.ts'
+import type { SymbolMcdocBlockStates } from 'sandstone/arguments/generated/dispatcher.ts'
+import type { Registry } from 'sandstone/arguments/generated/registry.ts'
+import type {
+  EnchantmentClass,
+  NBTFloat,
+  NBTInt,
+  NBTLong,
+  ObjectiveClass,
+  PredicateClass,
+  WorldClockClass,
+} from 'sandstone'
+
+export type AllOf = {
+  /**
+   * Passes when all of these conditions pass.
+   */
+  terms: Array<LootCondition>,
+}
+
+export type Alternative = {
+  terms: Array<LootCondition>,
+}
+
+export type AnyOf = {
+  /**
+   * Passes when any of these conditions pass.
+   */
+  terms: Array<LootCondition>,
+}
+
+export type BlockStateProperty = {
+  block: Registry['minecraft:block'],
+  properties?: SymbolMcdocBlockStates<'%none'>,
+}
+
+export type DamageSourceProperties = {
+  predicate: DamageSourcePredicate,
+}
+
+export type EnchantmentActiveCheck = {
+  active: boolean,
+}
+
+export type EntityProperties = {
+  /**
+   * Value:
+   *
+   *  - This(`this`)
+   *  - Killer(`killer`)
+   *  - Attacker(`attacker`)
+   *  - DirectKiller(`direct_killer`)
+   *  - DirectAttacker(`direct_attacker`)
+   *  - KillerPlayer(`killer_player`)
+   *  - AttackingPlayer(`attacking_player`)
+   *  - TargetEntity(`target_entity`)
+   *  - InteractingEntity(`interacting_entity`)
+   */
+  entity: EntityTarget,
+  predicate: EntityPredicate,
+}
+
+export type EntityScores = {
+  /**
+   * Value:
+   *
+   *  - This(`this`)
+   *  - Killer(`killer`)
+   *  - Attacker(`attacker`)
+   *  - DirectKiller(`direct_killer`)
+   *  - DirectAttacker(`direct_attacker`)
+   *  - KillerPlayer(`killer_player`)
+   *  - AttackingPlayer(`attacking_player`)
+   *  - TargetEntity(`target_entity`)
+   *  - InteractingEntity(`interacting_entity`)
+   */
+  entity: EntityTarget,
+  scores: ({
+    [Key in Extract<string | ObjectiveClass, string>]?: IntRange
+  }),
+}
+
+export type Inverted = {
+  term: LootCondition,
+}
+
+export type KilledByPlayer = {
+  inverse?: boolean,
+}
+
+export type LocationCheck = {
+  offsetX?: NBTInt,
+  offsetY?: NBTInt,
+  offsetZ?: NBTInt,
+  predicate: LocationPredicate,
+}
+
+export type MatchTool = {
+  predicate: ItemPredicate,
+}
+
+export type RandomChance = {
+  /**
+   * Clamps to a float between `0` & `1` (inclusive).
+   */
+  chance: NumberProvider,
+}
+
+export type RandomChanceWithEnchantedBonus = {
+  /**
+   * Value:
+   * Range: 0..1
+   */
+  unenchanted_chance: NBTFloat<{
+    leftExclusive: false,
+    rightExclusive: false,
+    min: 0,
+    max: 1,
+  }>,
+  enchanted_chance: LevelBasedValue,
+  enchantment: (Registry['minecraft:enchantment'] | EnchantmentClass),
+}
+
+export type RandomChanceWithLooting = {
+  /**
+   * Value:
+   * Range: 0..1
+   */
+  chance: NBTFloat<{
+    leftExclusive: false,
+    rightExclusive: false,
+    min: 0,
+    max: 1,
+  }>,
+  /**
+   * Looting adjustment to the base success rate. Formula is `chance + (looting_level * looting_multiplier)` .
+   */
+  looting_multiplier: NBTFloat,
+}
+
+export type Reference = {
+  /**
+   * A cyclic reference causes a parsing failure.
+   */
+  name: (`${string}:${string}` | PredicateClass),
+}
+
+export type TableBonus = {
+  enchantment: (Registry['minecraft:enchantment'] | EnchantmentClass),
+  /**
+   * Probabilities for each enchantment level
+   */
+  chances: Array<NBTFloat<{
+    leftExclusive: false,
+    rightExclusive: false,
+    min: 0,
+    max: 1,
+  }>>,
+}
+
+export type TimeCheck = {
+  /**
+   * The world clock to check.
+   */
+  clock: (Registry['minecraft:world_clock'] | WorldClockClass),
+  /**
+   * Check the current game tick.
+   */
+  value: IntRange,
+  /**
+   * Game tick supplied to `value` check gets modulo-divided by this.
+   * For example, if set to 24000, `value` operates on a time period of days.
+   */
+  period?: NBTLong,
+}
+
+export type ValueCheck = {
+  /**
+   * Clamps to an integer.
+   */
+  value: NumberProvider,
+  /**
+   * Passes when `value` is within this range.
+   */
+  range: IntRange,
+}
+
+export type WeatherCheck = {
+  raining?: boolean,
+  thundering?: boolean,
+}
+type LootConditionDispatcherMap = {
+  'all_of': LootConditionAllOf,
+  'minecraft:all_of': LootConditionAllOf,
+  'alternative': LootConditionAlternative,
+  'minecraft:alternative': LootConditionAlternative,
+  'any_of': LootConditionAnyOf,
+  'minecraft:any_of': LootConditionAnyOf,
+  'block_state_property': LootConditionBlockStateProperty,
+  'minecraft:block_state_property': LootConditionBlockStateProperty,
+  'damage_source_properties': LootConditionDamageSourceProperties,
+  'minecraft:damage_source_properties': LootConditionDamageSourceProperties,
+  'enchantment_active_check': LootConditionEnchantmentActiveCheck,
+  'minecraft:enchantment_active_check': LootConditionEnchantmentActiveCheck,
+  'entity_properties': LootConditionEntityProperties,
+  'minecraft:entity_properties': LootConditionEntityProperties,
+  'entity_scores': LootConditionEntityScores,
+  'minecraft:entity_scores': LootConditionEntityScores,
+  'inverted': LootConditionInverted,
+  'minecraft:inverted': LootConditionInverted,
+  'killed_by_player': LootConditionKilledByPlayer,
+  'minecraft:killed_by_player': LootConditionKilledByPlayer,
+  'location_check': LootConditionLocationCheck,
+  'minecraft:location_check': LootConditionLocationCheck,
+  'match_tool': LootConditionMatchTool,
+  'minecraft:match_tool': LootConditionMatchTool,
+  'random_chance': LootConditionRandomChance,
+  'minecraft:random_chance': LootConditionRandomChance,
+  'random_chance_with_enchanted_bonus': LootConditionRandomChanceWithEnchantedBonus,
+  'minecraft:random_chance_with_enchanted_bonus': LootConditionRandomChanceWithEnchantedBonus,
+  'random_chance_with_looting': LootConditionRandomChanceWithLooting,
+  'minecraft:random_chance_with_looting': LootConditionRandomChanceWithLooting,
+  'reference': LootConditionReference,
+  'minecraft:reference': LootConditionReference,
+  'table_bonus': LootConditionTableBonus,
+  'minecraft:table_bonus': LootConditionTableBonus,
+  'time_check': LootConditionTimeCheck,
+  'minecraft:time_check': LootConditionTimeCheck,
+  'value_check': LootConditionValueCheck,
+  'minecraft:value_check': LootConditionValueCheck,
+  'weather_check': LootConditionWeatherCheck,
+  'minecraft:weather_check': LootConditionWeatherCheck,
+}
+type LootConditionKeys = keyof LootConditionDispatcherMap
+type LootConditionFallback = (
+  | LootConditionAllOf
+  | LootConditionAlternative
+  | LootConditionAnyOf
+  | LootConditionBlockStateProperty
+  | LootConditionDamageSourceProperties
+  | LootConditionEnchantmentActiveCheck
+  | LootConditionEntityProperties
+  | LootConditionEntityScores
+  | LootConditionInverted
+  | LootConditionKilledByPlayer
+  | LootConditionLocationCheck
+  | LootConditionMatchTool
+  | LootConditionRandomChance
+  | LootConditionRandomChanceWithEnchantedBonus
+  | LootConditionRandomChanceWithLooting
+  | LootConditionReference
+  | LootConditionTableBonus
+  | LootConditionTimeCheck
+  | LootConditionValueCheck
+  | LootConditionWeatherCheck)
+type LootConditionAllOf = AllOf
+type LootConditionAlternative = Alternative
+type LootConditionAnyOf = AnyOf
+type LootConditionBlockStateProperty = BlockStateProperty
+type LootConditionDamageSourceProperties = DamageSourceProperties
+type LootConditionEnchantmentActiveCheck = EnchantmentActiveCheck
+type LootConditionEntityProperties = EntityProperties
+type LootConditionEntityScores = EntityScores
+type LootConditionInverted = Inverted
+type LootConditionKilledByPlayer = KilledByPlayer
+type LootConditionLocationCheck = LocationCheck
+type LootConditionMatchTool = MatchTool
+type LootConditionRandomChance = RandomChance
+type LootConditionRandomChanceWithEnchantedBonus = RandomChanceWithEnchantedBonus
+type LootConditionRandomChanceWithLooting = RandomChanceWithLooting
+type LootConditionReference = Reference
+type LootConditionTableBonus = TableBonus
+type LootConditionTimeCheck = TimeCheck
+type LootConditionValueCheck = ValueCheck
+type LootConditionWeatherCheck = WeatherCheck
+export type SymbolLootCondition<CASE extends
+  | 'map'
+  | 'keys'
+  | '%fallback'
+  | '%none'
+  | '%unknown' = 'map'> = CASE extends 'map'
+  ? LootConditionDispatcherMap
+  : CASE extends 'keys' ? LootConditionKeys : CASE extends '%fallback' ? LootConditionFallback : never