redscript-mc 1.2.16 → 1.2.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.16",
+  "version": "1.2.17",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/index.js",
   "bin": {

package/src/builtins/metadata.ts

@@ -1029,16 +1029,13 @@ export const BUILTIN_METADATA: Record<string, BuiltinDef> = {
 export function builtinToDeclaration(def: BuiltinDef): string {
   const lines: string[] = []
 
-  // Doc comments
+  // Doc comments (English only)
   lines.push(`/// ${def.doc}`)
-  if (def.docZh) {
-    lines.push(`/// ${def.docZh}`)
-  }
 
   // Param docs
   for (const p of def.params) {
-    const opt = p.required ? '' : '?'
-    lines.push(`/// @param ${p.name}${opt} ${p.doc}`)
+    const optTag = p.required ? '' : ' (optional)'
+    lines.push(`/// @param ${p.name} ${p.doc}${optTag}`)
   }
 
   // Returns
@@ -1051,13 +1048,9 @@ export function builtinToDeclaration(def: BuiltinDef): string {
     lines.push(`/// @example ${ex.split('\n')[0]}`)
   }
 
-  // Signature
+  // Signature - use default value syntax instead of ? for optional params
   const paramStrs = def.params.map(p => {
-    const opt = p.required ? '' : '?'
     let type = p.type
-    // Map to .d.mcrs types
-    if (type === 'selector') type = 'selector'
-    if (type === 'BlockPos') type = 'BlockPos'
     if (type === 'effect') type = 'string'
     if (type === 'sound') type = 'string'
     if (type === 'block') type = 'string'
@@ -1065,8 +1058,10 @@ export function builtinToDeclaration(def: BuiltinDef): string {
     if (type === 'entity') type = 'string'
     if (type === 'dimension') type = 'string'
     if (type === 'nbt') type = 'string'
-    if (type === 'coord') type = 'coord'
-    return `${p.name}${opt}: ${type}`
+    if (!p.required && p.default !== undefined) {
+      return `${p.name}: ${type} = ${p.default}`
+    }
+    return `${p.name}: ${type}`
   })
 
   const retType = def.returns

package/src/lexer/index.ts

@@ -298,6 +298,15 @@ export class Lexer {
           value += this.advance()
         }
       }
+      // Check for ident (e.g. ~height → macro variable offset)
+      if (/[a-zA-Z_]/.test(this.peek())) {
+        let ident = ''
+        while (/[a-zA-Z0-9_]/.test(this.peek())) {
+          ident += this.advance()
+        }
+        // Store as rel_coord with embedded ident: ~height
+        value += ident
+      }
       this.addToken('rel_coord', value, startLine, startCol)
       return
     }

package/src/lowering/index.ts

@@ -371,6 +371,13 @@ export class Lowering {
     return expr.name
   }
 
+  private tryGetMacroParamByName(name: string): string | null {
+    if (!this.currentFnParamNames.has(name)) return null
+    if (this.constValues.has(name)) return null
+    if (this.stringValues.has(name)) return null
+    return name
+  }
+
   /**
    * Converts an expression to a string for use as a builtin arg.
    * If the expression is a macro param, returns `$(name)` and sets macroParam.
@@ -380,6 +387,19 @@ export class Lowering {
     if (macroParam) {
       return { str: `$(${macroParam})`, macroParam }
     }
+    // Handle ~ident (e.g. ~height) - relative coord with variable offset
+    if (expr.kind === 'rel_coord' || expr.kind === 'local_coord') {
+      const val = expr.value  // e.g. "~height" or "^depth"
+      const prefix = val[0]   // ~ or ^
+      const rest = val.slice(1)
+      // If rest is an identifier (not a number), treat as macro param
+      if (rest && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(rest)) {
+        const paramName = this.tryGetMacroParamByName(rest)
+        if (paramName) {
+          return { str: `${prefix}$(${paramName})`, macroParam: paramName }
+        }
+      }
+    }
     if (expr.kind === 'struct_lit' || expr.kind === 'array_lit') {
       return { str: this.exprToSnbt(expr) }
     }

package/src/parser/index.ts

@@ -260,12 +260,21 @@ export class Parser {
   private parseConstDecl(): ConstDecl {
     const constToken = this.expect('const')
     const name = this.expect('ident').value
-    this.expect(':')
-    const type = this.parseType()
+    let type: TypeNode | undefined
+    if (this.match(':')) {
+      type = this.parseType()
+    }
     this.expect('=')
     const value = this.parseLiteralExpr()
     this.match(';')
-    return this.withLoc({ name, type, value }, constToken)
+    // Infer type from value if not provided
+    const inferredType: TypeNode = type ?? (
+      value.kind === 'str_lit' ? { kind: 'named', name: 'string' } :
+      value.kind === 'bool_lit' ? { kind: 'named', name: 'bool' } :
+      value.kind === 'float_lit' ? { kind: 'named', name: 'float' } :
+      { kind: 'named', name: 'int' }
+    )
+    return this.withLoc({ name, type: inferredType, value }, constToken)
   }
 
   private parseGlobalDecl(mutable: boolean): GlobalDecl {