redscript-mc 2.5.0 → 2.6.2

package/src/stdlib/state.mcrs

@@ -0,0 +1,65 @@
+// State machine helpers for Minecraft datapacks.
+// Usage: import "stdlib/state.mcrs"
+//
+// Provides scoreboard-backed state machine primitives. The `rs.state` objective
+// must be created at datapack load:
+//   scoreboard objectives add rs.state dummy
+//
+// Typical usage:
+//   // Define state constants in your own code:
+//   let STATE_IDLE: int = 0
+//   let STATE_COMBAT: int = 1
+//   let STATE_DEAD: int = 2
+//
+//   // Initialise entity state once on spawn:
+//   init_state(@s, STATE_IDLE)
+//
+//   // Transition on event:
+//   let ok: int = transition(@s, STATE_IDLE, STATE_COMBAT)
+//
+//   // Dispatch per-tick logic:
+//   if (is_state(@s, STATE_COMBAT) == 1) { ... }
+
+module library
+
+/// Read the current state of an entity.
+/// Returns -1 if the entity has not been initialised (score is 0 = unset in MC,
+/// but we reserve -1 as the sentinel for "never set via init_state").
+fn get_state(entity: selector) -> int {
+    return scoreboard_get(entity, "rs.state");
+}
+
+/// Write a state value to an entity.
+fn set_state(entity: selector, state: int) {
+    scoreboard_set(entity, "rs.state", state);
+}
+
+/// Check whether an entity is currently in the given state.
+/// Returns 1 if yes, 0 if no.
+fn is_state(entity: selector, state: int) -> int {
+    let cur: int = get_state(entity);
+    if (cur == state) {
+        return 1;
+    }
+    return 0;
+}
+
+/// Initialise an entity's state only if it has not been set yet (score == -1).
+/// Call once on spawn / load to avoid overwriting an in-progress state.
+fn init_state(entity: selector, initial: int) {
+    let cur: int = get_state(entity);
+    if (cur == -1) {
+        set_state(entity, initial);
+    }
+}
+
+/// Attempt a guarded transition from `from` to `to`.
+/// Only performs the transition when the entity is currently in `from`.
+/// Returns 1 on success, 0 if the entity was not in `from`.
+fn transition(entity: selector, from: int, to: int) -> int {
+    if (is_state(entity, from) == 1) {
+        set_state(entity, to);
+        return 1;
+    }
+    return 0;
+}

package/src/stdlib/world.mcrs

@@ -90,3 +90,27 @@ fn glass_box(x1: int, y1: int, z1: int, x2: int, y2: int, z2: int) {
     fill(x1, y1, z1, x2, y2, z2, "minecraft:glass");
     fill(x1 + 1, y1 + 1, z1 + 1, x2 - 1, y2 - 1, z2 - 1, "minecraft:air");
 }
+
+// ─── Sun angle helpers ────────────────────────────────────────────────────────
+//
+// MC day = 24000 ticks. Tick 0 = sunrise, tick 6000 = noon, tick 18000 = midnight.
+// Results are ×10000:
+//   sun_altitude: range [-900000, 900000]  (−90° to +90°, max at noon)
+//   sun_azimuth:  range [0, 3600000)       (0° = east, increases west over day)
+
+/// sun_altitude(ticks): sun elevation above horizon ×10000
+/// noon (6000) → 900000 (+90°), midnight (18000) → -900000 (-90°)
+/// Uses sin_fixed (requires math.mcrs).
+fn sun_altitude(ticks: int): int {
+    // angle = ticks * 360 / 24000 degrees
+    // noon: 6000 * 360 / 24000 = 90° → sin(90°) = 1000 → 1000 * 900 = 900000 ✓
+    let deg: int = ticks * 360 / 24000;
+    return sin_fixed(deg) * 900;
+}
+
+/// sun_azimuth(ticks): compass angle of sun ×10000
+/// tick 0 → 0 (east), increases linearly to 3600000 over 24000 ticks
+fn sun_azimuth(ticks: int): int {
+    // 3600000 / 24000 = 150; multiply first to avoid int32 overflow
+    return ticks * 150 % 3600000;
+}

package/src/typechecker/index.ts

@@ -127,6 +127,8 @@ const BUILTIN_SIGNATURES: Record<string, BuiltinSignature> = {
 
 export class TypeChecker {
   private collector: DiagnosticCollector
+  private filePath?: string
+  private lintWarnings: string[] = []
   private functions: Map<string, FnDecl> = new Map()
   private implMethods: Map<string, Map<string, FnDecl>> = new Map()
   private structs: Map<string, Map<string, TypeNode>> = new Map()
@@ -154,6 +156,7 @@ export class TypeChecker {
 
   constructor(source?: string, filePath?: string) {
     this.collector = new DiagnosticCollector(source, filePath)
+    this.filePath = filePath
   }
 
   private getNodeLocation(node: unknown): { line: number; col: number } {
@@ -169,6 +172,19 @@ export class TypeChecker {
     this.collector.error('TypeError', message, line, col)
   }
 
+  private warnLint(message: string, node?: unknown): void {
+    const { line, col } = this.getNodeLocation(node)
+    const filePart = this.filePath ? `${this.filePath}:` : ''
+    this.lintWarnings.push(
+      `${filePart}line ${line}, col ${col}: ${message}`
+    )
+  }
+
+  /** Returns lint warnings (non-blocking). */
+  getWarnings(): string[] {
+    return this.lintWarnings
+  }
+
   /**
    * Type check a program. Returns collected errors.
    */
@@ -403,17 +419,19 @@ export class TypeChecker {
       case 'match':
         this.checkExpr(stmt.expr)
         for (const arm of stmt.arms) {
-          if (arm.pattern) {
-            this.checkExpr(arm.pattern)
+          if (arm.pattern.kind === 'PatExpr') {
+            // Legacy: check the wrapped expression against the subject type
+            this.checkExpr(arm.pattern.expr)
             const subjectType = this.inferType(stmt.expr)
-            const patternType = this.inferType(arm.pattern)
+            const patternType = this.inferType(arm.pattern.expr)
             // Skip check if either type is unknown (void) — struct field access not yet inferred
             const isUnknown = (t: TypeNode) => t.kind === 'named' && t.name === 'void'
             if (!isUnknown(subjectType) && !isUnknown(patternType) &&
                 !this.typesMatch(subjectType, patternType)) {
-              this.report('Match arm pattern type must match subject type', arm.pattern)
+              this.report('Match arm pattern type must match subject type', arm.pattern.expr)
             }
           }
+          // PatSome / PatNone / PatInt / PatWild are structurally typed — no expr to check
           this.checkBlock(arm.body)
         }
         break
@@ -538,10 +556,23 @@ export class TypeChecker {
     if (!this.currentReturnType) return
 
     const expectedType = this.currentReturnType
-    
+
     if (stmt.value) {
       const actualType = this.inferType(stmt.value, expectedType)
       this.checkExpr(stmt.value, expectedType)
+
+      // Warn when returning a float-typed result of arithmetic — the arithmetic
+      // itself is the problem, not just the type annotation.
+      const returnIsFloat = expectedType.kind === 'named' && expectedType.name === 'float'
+      if (returnIsFloat && stmt.value.kind === 'binary') {
+        const arithmeticOps = ['+', '-', '*', '/', '%']
+        if (arithmeticOps.includes(stmt.value.op)) {
+          this.warnLint(
+            `[FloatArithmetic] 'float' is a system boundary type (MC NBT float); use 'fixed' for arithmetic instead.`,
+            stmt.value
+          )
+        }
+      }
       
       if (this.isNumericMismatch(expectedType, actualType)) {
         // Explicit numeric conversion required for return statements
@@ -587,10 +618,34 @@ export class TypeChecker {
         this.checkStaticCallExpr(expr)
         break
 
-      case 'binary':
+      case 'binary': {
         this.checkExpr(expr.left)
         this.checkExpr(expr.right)
+        const arithmeticOps = ['+', '-', '*', '/', '%']
+        if (arithmeticOps.includes(expr.op)) {
+          const leftType = this.inferType(expr.left)
+          const rightType = this.inferType(expr.right)
+          const leftIsString = leftType.kind === 'named' && (leftType.name === 'string' || leftType.name === 'format_string')
+          const rightIsString = rightType.kind === 'named' && (rightType.name === 'string' || rightType.name === 'format_string')
+          if (leftIsString || rightIsString) {
+            // String concatenation with + is not supported. Use f-strings instead.
+            this.report(
+              `[StringConcat] String concatenation with '+' is not supported. Use f-strings instead: f"text{variable}" — e.g. f"Score: {score}"`,
+              expr
+            )
+          }
+          // Warn when float is used in arithmetic — float is a MC NBT system boundary type
+          const leftIsFloat = leftType.kind === 'named' && leftType.name === 'float'
+          const rightIsFloat = rightType.kind === 'named' && rightType.name === 'float'
+          if (leftIsFloat || rightIsFloat) {
+            this.warnLint(
+              `[FloatArithmetic] 'float' is a system boundary type (MC NBT); use 'fixed' for arithmetic. Float arithmetic results are undefined.`,
+              expr
+            )
+          }
+        }
         break
+      }
 
       case 'is_check': {
         this.checkExpr(expr.expr)
@@ -659,7 +714,7 @@ export class TypeChecker {
           const isUnknown = partType.kind === 'named' && partType.name === 'void'
           if (
             !isUnknown &&
-            !(partType.kind === 'named' && (partType.name === 'int' || partType.name === 'string' || partType.name === 'format_string'))
+            !(partType.kind === 'named' && ['int', 'string', 'format_string', 'fixed', 'double', 'bool', 'byte', 'short', 'long'].includes(partType.name))
           ) {
             this.report(
               `f-string placeholder must be int or string, got ${this.typeToString(partType)}`,
@@ -715,6 +770,9 @@ export class TypeChecker {
       case 'long_lit':
       case 'double_lit':
         break
+      case 'type_cast':
+        this.checkExpr(expr.expr)
+        break
     }
   }
 
@@ -926,7 +984,7 @@ export class TypeChecker {
           // Entity marker (void) - allow all members
           if (varType.name !== 'void') {
             // Only warn for primitive types
-            if (['int', 'bool', 'float', 'string', 'byte', 'short', 'long', 'double'].includes(varType.name)) {
+            if (['int', 'bool', 'float', 'fixed', 'string', 'byte', 'short', 'long', 'double'].includes(varType.name)) {
               this.report(
                 `Cannot access member '${expr.field}' on ${this.typeToString(varType)}`,
                 expr
@@ -1062,7 +1120,7 @@ export class TypeChecker {
       case 'int_lit':
         return { kind: 'named', name: 'int' }
       case 'float_lit':
-        return { kind: 'named', name: 'float' }
+        return { kind: 'named', name: 'fixed' }
       case 'byte_lit':
         return { kind: 'named', name: 'byte' }
       case 'short_lit':
@@ -1211,6 +1269,9 @@ export class TypeChecker {
         if (expectedType?.kind === 'option') return expectedType
         return { kind: 'option', inner: { kind: 'named', name: 'void' } }
       }
+      case 'type_cast':
+        // The result type of (expr as T) is T
+        return this.normalizeType(expr.targetType)
       case 'lambda':
         return this.inferLambdaType(
           expr,
@@ -1323,13 +1384,18 @@ export class TypeChecker {
     return this.selfTypeStack[this.selfTypeStack.length - 1]
   }
 
-  /** Returns true if expected/actual are a numeric type mismatch (int vs float). */
+  /** Returns true if expected/actual are a numeric type mismatch (int vs float/fixed/double).
+   * These pairs are NOT implicitly compatible — require explicit `as` cast.
+   * Only int↔byte/short/long remain implicitly compatible (MC NBT narrowing). */
   private isNumericMismatch(expected: TypeNode, actual: TypeNode): boolean {
     if (expected.kind !== 'named' || actual.kind !== 'named') return false
     const numericPairs = [
       ['int', 'float'], ['float', 'int'],
+      ['int', 'fixed'], ['fixed', 'int'],
       ['int', 'double'], ['double', 'int'],
       ['float', 'double'], ['double', 'float'],
+      ['fixed', 'double'], ['double', 'fixed'],
+      // float and fixed are compatible (float is deprecated alias for fixed)
     ]
     return numericPairs.some(([e, a]) => expected.name === e && actual.name === a)
   }
@@ -1363,12 +1429,19 @@ export class TypeChecker {
       // void matches anything (for inferred types)
       if (actual.name === 'void') return true
       if (expected.name === actual.name) return true
-      // int→float/double implicit promotion in function calls (not for let/return — handled separately)
-      const numericPromotion = [
-        ['int', 'float'], ['int', 'double'], ['float', 'double'],
-        ['float', 'int'], ['double', 'int'], ['double', 'float'],
+      // float is a deprecated alias for fixed — they are interchangeable
+      const floatFixed = (expected.name === 'float' || expected.name === 'fixed') &&
+        (actual.name === 'float' || actual.name === 'fixed')
+      if (floatFixed) return true
+      // No implicit numeric promotions between int/fixed/double/float.
+      // Users must use explicit `as` casts: x as fixed, x as double, etc.
+      // Only byte/short/long ↔ int remain implicitly compatible (MC NBT type narrowing).
+      const nbtNarrowing = [
+        ['int', 'byte'], ['byte', 'int'],
+        ['int', 'short'], ['short', 'int'],
+        ['int', 'long'], ['long', 'int'],
       ]
-      if (numericPromotion.some(([e, a]) => expected.name === e && actual.name === a)) return true
+      if (nbtNarrowing.some(([e, a]) => expected.name === e && actual.name === a)) return true
       return false
     }
 

package/test_trig.ts

@@ -0,0 +1,43 @@
+import { compile } from './src/emit/compile'
+import { MCRuntime } from './src/runtime'
+import * as fs from 'fs'
+
+const MATH = fs.readFileSync('./src/stdlib/math.mcrs', 'utf-8')
+const src = 'fn test_sin90(): int { return sin_fixed(90); }'
+const NS = 'test'
+const r = compile(src, {namespace: NS, librarySources:[MATH]})
+
+// Check _math_init
+const initFile = r.files.find((f: any) => f.path.includes('_math_init'))
+if (initFile) {
+  console.log('_math_init content:')
+  console.log(initFile.content)
+}
+
+// Check a sin file
+const sin2 = r.files.find((f: any) => f.path.includes('sin_fixed__then_2'))
+if (sin2) {
+  console.log('sin_fixed__then_2 content:')
+  console.log(sin2.content)
+}
+
+const rt = new MCRuntime(NS)
+for (const f of r.files) {
+  if (!f.path.endsWith('.mcfunction')) continue
+  const m = f.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/)
+  if (!m) continue
+  rt.loadFunction(m[1]+':'+m[2], f.content.split('\n'))
+}
+rt.execFunction('test:load')
+rt.execFunction('test:test_sin90')
+const val = rt.getScore('$ret', '__test')
+console.log('sin_fixed(90) =', val, '(expected 1000)')
+
+// Check storage
+const storage = (rt as any).storage
+console.log('Storage keys:', [...storage.keys()])
+if (storage.has('math:tables')) {
+  const t = storage.get('math:tables')
+  console.log('math:tables keys:', Object.keys(t))
+  if (t.sin) console.log('sin[0..5]:', t.sin.slice(0, 5), '...', 'sin[90]:', t.sin[90])
+}