sandstone 1.1.6 → 1.2.1

package/src/flow/Flow.ts

@@ -1,8 +1,6 @@
 import type {
   Registry,
-  ContainerSlotSelector,
   Coordinates,
-  EntitySlotSelector,
   JSONTextComponent,
   MultipleEntitiesArgument,
   MultiplePlayersArgument,
@@ -11,6 +9,7 @@ import type {
   SymbolBlock,
   SymbolMcdocBlockStates,
 } from 'sandstone/arguments'
+import type { ItemSlotSource } from '../commands/implementations/world/item'
 import type {
   ConditionClass,
   DataPointClass,
@@ -21,7 +20,7 @@ import type {
 import { parseJSONText, Score } from 'sandstone/variables'
 import type { DataPointPickClass, MCFunctionClass, PredicateClass, SandstoneCore } from '../core'
 import type { LiteralUnion, NamespacedLiteralUnion } from '../utils'
-import { AndNode, ConditionNode, NotNode, OrNode, SandstoneConditions, type BlockConditionNode, type ItemsBlockConditionNode, type ItemsEntityConditionNode } from './conditions'
+import { AndNode, ConditionNode, NotNode, OrNode, SandstoneConditions, type BlockConditionNode, type ItemsBlockConditionNode, type ItemsEntityConditionNode, type SlotsBlockConditionNode, type SlotsEntityConditionNode } from './conditions'
 import type { ItemPredicate } from './conditions/variables/items'
 import { IfStatement } from './if_else'
 import type { ForOfIterator } from './loops'
@@ -486,24 +485,57 @@ export class Flow {
      * Test for items in a block entity's inventory slots.
      *
      * @param sourcePos Position of the block entity to test.
-     * @param slots Slots to test (e.g., `'container.*'`, `'container.0'`).
+     * @param slotSource Slot source to test (e.g., `'container.*'`, inline slot source, or a slot source reference).
      * @param itemPredicate Item predicate to match against.
      */
-    block: (sourcePos: Coordinates, slots: ContainerSlotSelector, itemPredicate: ItemPredicate) => ItemsBlockConditionNode
+    block: (sourcePos: Coordinates, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) => ItemsBlockConditionNode
     /**
      * Test for items in an entity's inventory slots.
      *
      * @param source Entity to test.
-     * @param slots Slots to test (e.g., `'inventory.*'`, `'hotbar.0'`, `'armor.chest'`).
+     * @param slotSource Slot source to test (e.g., `'inventory.*'`, inline slot source, or a slot source reference).
      * @param itemPredicate Item predicate to match against.
      */
-    entity: (source: MultipleEntitiesArgument, slots: EntitySlotSelector, itemPredicate: ItemPredicate) => ItemsEntityConditionNode
+    entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) => ItemsEntityConditionNode
   } {
     return {
-      block: (sourcePos: Coordinates, slots: ContainerSlotSelector, itemPredicate: ItemPredicate) =>
-        new SandstoneConditions.ItemsBlock(this.sandstoneCore, sourcePos, slots, itemPredicate),
-      entity: (source: MultipleEntitiesArgument, slots: EntitySlotSelector, itemPredicate: ItemPredicate) =>
-        new SandstoneConditions.ItemsEntity(this.sandstoneCore, source, slots, itemPredicate),
+      block: (sourcePos: Coordinates, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) =>
+        new SandstoneConditions.ItemsBlock(this.sandstoneCore, sourcePos, slotSource, itemPredicate),
+      entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource, itemPredicate: ItemPredicate) =>
+        new SandstoneConditions.ItemsEntity(this.sandstoneCore, source, slotSource, itemPredicate),
+    }
+  }
+
+  /**
+   * Counts slots from a slot source that are present in a block entity or entity.
+   *
+   * @example
+   * ```ts
+   * _.if(_.slots.entity('@p', 'inventory.*'), () => { ... })
+   * _.if(_.slots.block(abs(0, 64, 0), { type: 'minecraft:slot_range', slots: 'armor.chest' }), () => { ... })
+   * ```
+   */
+  get slots(): {
+    /**
+     * Count slots from a slot source that are present in a block entity.
+     *
+     * @param sourcePos Position of the block entity to test.
+     * @param slotSource Slot source (e.g., `'container.*'`, inline slot source, or a slot source reference).
+     */
+    block: (sourcePos: Coordinates, slotSource: ItemSlotSource) => SlotsBlockConditionNode
+    /**
+     * Count slots from a slot source that are present in an entity.
+     *
+     * @param source Entity to test.
+     * @param slotSource Slot source (e.g., `'inventory.*'`, inline slot source, or a slot source reference).
+     */
+    entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource) => SlotsEntityConditionNode
+  } {
+    return {
+      block: (sourcePos: Coordinates, slotSource: ItemSlotSource) =>
+        new SandstoneConditions.SlotsBlock(this.sandstoneCore, sourcePos, slotSource),
+      entity: (source: MultipleEntitiesArgument, slotSource: ItemSlotSource) =>
+        new SandstoneConditions.SlotsEntity(this.sandstoneCore, source, slotSource),
     }
   }
 

package/src/flow/conditions/command.ts

@@ -20,14 +20,7 @@ export class CommandConditionNode extends SingleConditionNode {
     const store = sandstoneCore.pack.commands.execute.store[type]
     this.variable = sandstoneCore.pack.Variable(undefined, 'condition')
 
-    // Snapshot before/after so commands the callback commits land in `preNodes` instead of
-    // staying on the user MCFunction body, where they'd be stranded when visitor extraction
-    // moves the surrounding condition chain elsewhere.
-    const mcFunction = sandstoneCore.getCurrentMCFunctionOrThrow()
-    const before = mcFunction.body.length
     command(store(this.variable))
-    const after = mcFunction.body.length
-    this.preNodes = mcFunction.body.splice(before, after - before)
   }
 
   getCondition(): unknown[] {

package/src/flow/conditions/condition.ts

@@ -18,15 +18,6 @@ export type GenericConditionType = {
 }
 
 export abstract class ConditionNode extends Node {
-  /**
-   * Optional commands that must run before this condition's predicate is evaluated.
-   * Conditions that emit side-effect commands at construction time (e.g. `data.equals`
-   * building an `execute store result ...`) capture them here so the visitor pass can
-   * re-emit them at the correct location — inline before the IfNode, or inside the
-   * child MCFunction when AND/OR extracts. Pure predicates leave it unset.
-   */
-  preNodes?: Node[]
-
   abstract getValue: (negated?: boolean) => string
 }
 

package/src/flow/conditions/index.ts

@@ -11,6 +11,7 @@ import * as variables from './variables'
 export const SandstoneConditions = {
   Advancement: resources.AdvancementConditionNode,
   Predicate: resources.PredicateConditionNode,
+  SlotSource: resources.SlotSourceConditionNode,
   Tag: resources.TagConditionNode,
 
   Biome: variables.BiomeConditionNode,
@@ -20,6 +21,8 @@ export const SandstoneConditions = {
   Function: variables.FunctionConditionNode,
   ItemsBlock: variables.ItemsBlockConditionNode,
   ItemsEntity: variables.ItemsEntityConditionNode,
+  SlotsBlock: variables.SlotsBlockConditionNode,
+  SlotsEntity: variables.SlotsEntityConditionNode,
   Loaded: variables.LoadedConditionNode,
   DataPointExists: variables.DataPointExistsConditionNode,
   DataPointEquals: variables.DataPointEqualsConditionNode,

package/src/flow/conditions/resources/index.ts

@@ -1,3 +1,4 @@
 export * from './advancement'
 export * from './predicate'
+export * from './slotSource'
 export * from './tag'

package/src/flow/conditions/resources/slotSource.ts

@@ -0,0 +1,21 @@
+import type { SandstoneCore } from 'sandstone/core'
+import { SingleConditionNode } from '../condition'
+
+/**
+ * Condition node representing a slot source being tested against `@s`.
+ *
+ * Expands to `execute if slots entity @s <slotSource>`, which counts the number of slots from
+ * the slot source that are present on the executing entity.
+ */
+export class SlotSourceConditionNode extends SingleConditionNode {
+  constructor(
+    sandstoneCore: SandstoneCore,
+    public slotSource: string,
+  ) {
+    super(sandstoneCore)
+  }
+
+  getCondition(): unknown[] {
+    return ['slots', 'entity', '@s', this.slotSource]
+  }
+}

package/src/flow/conditions/variables/dataPoint.ts

@@ -1,5 +1,5 @@
 import type { NBTObject } from 'sandstone/arguments/nbt'
-import type { DataPointPickClass, Node, SandstoneCore } from 'sandstone/core'
+import type { DataPointPickClass, SandstoneCore } from 'sandstone/core'
 import type { DataPointClass, Score } from 'sandstone/variables'
 import { SingleConditionNode } from '../condition'
 
@@ -29,19 +29,11 @@ export class DataPointEqualsConditionNode extends SingleConditionNode {
     const { DataVariable, Variable, commands } = sandstoneCore.pack
     const { execute } = commands
 
-    // Snapshot the user MCFunction body length before/after the entire side-effecting
-    // sequence — both the `data modify ... set from <source>` emitted by DataVariable (which
-    // copies the source into the anonymous storage) AND the `execute store result ... set
-    // value` written by `execute.store.result().run()`. They belong together: the first
-    // loads the data, the second overwrites it with `value`, and the subsequent
-    // `if score matches 0..` only makes sense after both have run.
-    const mcFunction = sandstoneCore.getCurrentMCFunctionOrThrow()
-    const before = mcFunction.body.length
     const anon = DataVariable(this.dataPoint)
+
     this.conditional = Variable()
+
     execute.store.result(this.conditional).run(() => anon.set(this.value as unknown as DataPointClass))
-    const after = mcFunction.body.length
-    this.preNodes = mcFunction.body.splice(before, after - before)
   }
 
   getValue = (negated?: boolean) =>

package/src/flow/conditions/variables/items.ts

@@ -1,7 +1,8 @@
-import type { Coordinates, ContainerSlotSelector, EntitySlotSelector, MultipleEntitiesArgument, Registry } from 'sandstone/arguments'
+import type { Coordinates, MultipleEntitiesArgument, Registry } from 'sandstone/arguments'
 import type { SandstoneCore } from 'sandstone/core/sandstoneCore'
 import { coordinatesParser, targetParser } from 'sandstone/variables'
 import type { ItemPredicateClass } from 'sandstone/variables/ItemPredicate'
+import type { ItemSlotSource } from '../../../commands/implementations/world/item'
 import { SingleConditionNode } from '../condition'
 
 /** Item predicate for matching items in inventory slots. */
@@ -14,20 +15,23 @@ export type ItemPredicate = Registry['minecraft:item'] | ItemPredicateClass
  * ```ts
  * // Check if chest has any diamonds
  * _.if(_.items.block(abs(0, 64, 0), 'container.*', 'minecraft:diamond'), () => { ... })
+ *
+ * // Check using an inline slot source
+ * _.if(_.items.block(abs(0, 64, 0), { type: 'minecraft:slot_range', slots: 'container.0' }, 'minecraft:diamond'), () => { ... })
  * ```
  */
 export class ItemsBlockConditionNode extends SingleConditionNode {
   constructor(
     sandstoneCore: SandstoneCore,
     private sourcePos: Coordinates,
-    private slots: ContainerSlotSelector,
+    private slotSource: ItemSlotSource,
     private itemPredicate: ItemPredicate,
   ) {
     super(sandstoneCore)
   }
 
   getCondition() {
-    return ['items', 'block', coordinatesParser(this.sourcePos), this.slots, `${this.itemPredicate}`]
+    return ['items', 'block', coordinatesParser(this.sourcePos), this.slotSource, `${this.itemPredicate}`]
   }
 }
 
@@ -44,13 +48,57 @@ export class ItemsEntityConditionNode extends SingleConditionNode {
   constructor(
     sandstoneCore: SandstoneCore,
     private source: MultipleEntitiesArgument,
-    private slots: EntitySlotSelector,
+    private slotSource: ItemSlotSource,
     private itemPredicate: ItemPredicate,
   ) {
     super(sandstoneCore)
   }
 
   getCondition() {
-    return ['items', 'entity', targetParser(this.source), this.slots, `${this.itemPredicate}`]
+    return ['items', 'entity', targetParser(this.source), this.slotSource, `${this.itemPredicate}`]
+  }
+}
+
+/**
+ * Condition node for counting slots from a slot source on a block entity.
+ *
+ * @example
+ * ```ts
+ * _.if(_.slots.block(abs(0, 64, 0), 'container.*'), () => { ... })
+ * ```
+ */
+export class SlotsBlockConditionNode extends SingleConditionNode {
+  constructor(
+    sandstoneCore: SandstoneCore,
+    private sourcePos: Coordinates,
+    private slotSource: ItemSlotSource,
+  ) {
+    super(sandstoneCore)
+  }
+
+  getCondition() {
+    return ['slots', 'block', coordinatesParser(this.sourcePos), this.slotSource]
+  }
+}
+
+/**
+ * Condition node for counting slots from a slot source on an entity.
+ *
+ * @example
+ * ```ts
+ * _.if(_.slots.entity('@p', 'inventory.*'), () => { ... })
+ * ```
+ */
+export class SlotsEntityConditionNode extends SingleConditionNode {
+  constructor(
+    sandstoneCore: SandstoneCore,
+    private source: MultipleEntitiesArgument,
+    private slotSource: ItemSlotSource,
+  ) {
+    super(sandstoneCore)
+  }
+
+  getCondition() {
+    return ['slots', 'entity', targetParser(this.source), this.slotSource]
   }
 }

package/src/pack/pack.ts

@@ -29,6 +29,7 @@ import type {
   ChatTypeClassArguments,
   DamageTypeClassArguments,
   DataPointPickClass,
+  DecoratedPotPatternClassArguments,
   DialogClassArguments,
   EnchantmentClassArguments,
   EnchantmentProviderClassArguments,
@@ -51,6 +52,7 @@ import type {
   PredicateClassArguments,
   RecipeClassArguments,
   ShaderClassArguments,
+  SlotSourceClassArguments,
   SoundEventArguments,
   SoundsIndexArguments,
   SulfurCubeArchetypeClassArguments,
@@ -77,6 +79,7 @@ import {
   BlockStateDefinitionClass,
   ChatTypeClass,
   DamageTypeClass,
+  DecoratedPotPatternClass,
   DialogClass,
   EnchantmentClass,
   EnchantmentProviderClass,
@@ -99,6 +102,7 @@ import {
   RecipeClass,
   SandstoneCore,
   ShaderClass,
+  SlotSourceClass,
   SoundEventClass,
   SoundsIndexClass,
   SulfurCubeArchetypeClass,
@@ -314,11 +318,11 @@ export class SandstonePack {
     }
     return {
       datapack: {
-        packFormat: 111,
+        packFormat: 112,
         description: 'A Sandstone datapack',
       },
       resourcepack: {
-        packFormat: 92,
+        packFormat: 93,
         description: 'A Sandstone resource pack',
       },
     }
@@ -444,7 +448,7 @@ export class SandstonePack {
     let pack = this.packTypes.get('datapack') as DataPack
 
     if (!pack) {
-      const options = this.packOptions.datapack ?? { packFormat: 111, description: 'A Sandstone datapack' }
+      const options = this.packOptions.datapack ?? { packFormat: 112, description: 'A Sandstone datapack' }
       pack = this.packTypes.set('datapack', new DataPack(false, options)).get('datapack') as DataPack
     }
 
@@ -455,7 +459,7 @@ export class SandstonePack {
     let pack = this.packTypes.get('resourcepack') as ResourcePack
 
     if (!pack) {
-      const options = this.packOptions.resourcepack ?? { packFormat: 92, description: 'A Sandstone resource pack' }
+      const options = this.packOptions.resourcepack ?? { packFormat: 93, description: 'A Sandstone resource pack' }
       pack = this.packTypes
         .set('resourcepack', new ResourcePack(options))
         .get('resourcepack') as ResourcePack
@@ -465,12 +469,11 @@ export class SandstonePack {
   }
 
   setupLantern = () => {
-    const loadStatus = this.Objective.create('load.status', 'dummy', undefined, { useDefaultNamespace: false, alreadyExists: true })
+    const loadStatus = this.Objective.create('load.status', 'dummy', undefined, { useDefaultNamespace: false })
 
     const privateInit = this.Tag('function', 'load:_private/init', [
       this.MCFunction('load:_private/init', () => {
         this.commands.comment('Reset scoreboards so packs can set values accurate for current load.')
-        this.commands.scoreboard.objectives.add(loadStatus.name, 'dummy')
         loadStatus.reset()
       }),
     ])
@@ -1122,6 +1125,15 @@ export class SandstonePack {
       ...options,
     })
 
+  DecoratedPotPattern = (name: string, decoratedPotPattern: DecoratedPotPatternClassArguments['json'], options?: Omit<Partial<DecoratedPotPatternClassArguments>, 'json'>) =>
+    new DecoratedPotPatternClass(this.core, name, {
+      json: decoratedPotPattern,
+      creator: 'user',
+      addToSandstoneCore: true,
+      onConflict: conflictDefaults('decorated_pot_pattern') as DecoratedPotPatternClassArguments['onConflict'],
+      ...options,
+    })
+
   ItemModifier = (name: string, itemModifier: ItemModifierClassArguments['json'], options?: Omit<Partial<ItemModifierClassArguments>, 'json'>) =>
     new ItemModifierClass(this.core, name, {
       json: itemModifier,
@@ -1162,6 +1174,15 @@ export class SandstonePack {
       ...options,
     })
 
+  SlotSource = (name: string, slotSource: SlotSourceClassArguments['json'], options?: Omit<Partial<SlotSourceClassArguments>, 'json'>) =>
+    new SlotSourceClass(this.core, name, {
+      json: slotSource,
+      creator: 'user',
+      addToSandstoneCore: true,
+      onConflict: conflictDefaults('slot_source') as SlotSourceClassArguments['onConflict'],
+      ...options,
+    })
+
   SulfurCubeArchetype = (name: string, sulfurCubeArchetype: SulfurCubeArchetypeClassArguments['json'], options?: Omit<Partial<SulfurCubeArchetypeClassArguments>, 'json'>) =>
     new SulfurCubeArchetypeClass(this.core, name, {
       json: sulfurCubeArchetype,
@@ -1356,7 +1377,7 @@ export class SandstonePack {
       json,
       creator: 'user',
       addToSandstoneCore: true,
-      onConflict: conflictDefaults('block_definition') as BlockStateDefinitionArguments<JSON>['onConflict'],
+      onConflict: conflictDefaults('blockstate') as BlockStateDefinitionArguments<JSON>['onConflict'],
       ...options,
     })
   }