redscript-mc 2.5.0 → 2.6.2

package/src/__tests__/stdlib/state.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Tests for stdlib/state.mcrs — scoreboard-based state machine.
+ * Verifies compilation succeeds and all state machine functions are emitted.
+ */
+
+import { compile } from '../../emit/compile'
+import * as fs from 'fs'
+import * as path from 'path'
+
+const STATE_STDLIB = path.join(__dirname, '../../stdlib/state.mcrs')
+const stateSrc = fs.readFileSync(STATE_STDLIB, 'utf-8')
+
+function compileWith(extra: string): { path: string; content: string }[] {
+  const result = compile(stateSrc + '\n' + extra, { namespace: 'test' })
+  return result.files
+}
+
+describe('stdlib/state.mcrs', () => {
+  // ── Compilation ──────────────────────────────────────────────────────────
+
+  test('compiles without errors', () => {
+    expect(() => {
+      const result = compile(stateSrc, { namespace: 'test' })
+      expect(result.files.length).toBeGreaterThan(0)
+    }).not.toThrow()
+  })
+
+  // ── get_state / set_state ─────────────────────────────────────────────────
+
+  test('get_state function is emitted', () => {
+    const files = compileWith(`@keep fn t() -> int { return get_state(@s); }`)
+    expect(files.some(f => f.path.includes('get_state'))).toBe(true)
+  })
+
+  test('set_state function is emitted', () => {
+    const files = compileWith(`@keep fn t() { set_state(@s, 1); }`)
+    expect(files.some(f => f.path.includes('set_state'))).toBe(true)
+  })
+
+  test('get_state and set_state compile in sequence', () => {
+    const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 2);
+        return get_state(@s);
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  // ── is_state ──────────────────────────────────────────────────────────────
+
+  test('is_state function is emitted', () => {
+    const files = compileWith(`@keep fn t() -> int { return is_state(@s, 0); }`)
+    expect(files.some(f => f.path.includes('is_state'))).toBe(true)
+  })
+
+  test('is_state check after set compiles', () => {
+    const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 1);
+        return is_state(@s, 1);
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('is_state returns 0 branch compiles', () => {
+    const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 0);
+        return is_state(@s, 5);
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  // ── transition ────────────────────────────────────────────────────────────
+
+  test('transition function is emitted', () => {
+    const files = compileWith(`@keep fn t() -> int { return transition(@s, 0, 1); }`)
+    expect(files.some(f => f.path.includes('transition'))).toBe(true)
+  })
+
+  test('transition success path compiles', () => {
+    const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 0);
+        return transition(@s, 0, 1);
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('transition failure path compiles', () => {
+    const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 2);
+        return transition(@s, 0, 1);
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('chained transitions compile', () => {
+    const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 0);
+        let ok1: int = transition(@s, 0, 1);
+        let ok2: int = transition(@s, 1, 2);
+        return ok1 + ok2;
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  // ── init_state ────────────────────────────────────────────────────────────
+
+  test('init_state function is emitted', () => {
+    const files = compileWith(`@keep fn t() { init_state(@s, 0); }`)
+    expect(files.some(f => f.path.includes('init_state'))).toBe(true)
+  })
+
+  test('init_state only initialises once — second call is no-op', () => {
+    const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, -1);
+        init_state(@s, 0);
+        init_state(@s, 99);
+        return get_state(@s);
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  test('init_state skipped when state already set', () => {
+    const files = compileWith(`
+      @keep fn t() -> int {
+        set_state(@s, 1);
+        init_state(@s, 0);
+        return get_state(@s);
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+
+  // ── Combined usage ────────────────────────────────────────────────────────
+
+  test('full state machine lifecycle compiles', () => {
+    const files = compileWith(`
+      let STATE_IDLE: int = 0
+      let STATE_COMBAT: int = 1
+      let STATE_DEAD: int = 2
+
+      @keep fn tick() {
+        init_state(@s, STATE_IDLE);
+        let in_combat: int = is_state(@s, STATE_COMBAT);
+        if (in_combat == 1) {
+          let ok: int = transition(@s, STATE_COMBAT, STATE_DEAD);
+        }
+      }
+    `)
+    expect(files.length).toBeGreaterThan(0)
+  })
+})

package/src/__tests__/typechecker-strict.test.ts

@@ -102,22 +102,22 @@ fn test() {
     })
   })
 
-  describe('int/float implicit conversion checks', () => {
-    it('detects int assigned to float variable', () => {
-      // int literal assigned to float — different types
+  describe('int/fixed implicit conversion checks', () => {
+    it('detects int assigned to fixed variable', () => {
+      // int literal assigned to fixed — different types
       const errors = typeCheck(`
 fn test() {
-    let x: float = 5;
+    let x: fixed = 5;
 }
 `)
       expect(errors.length).toBeGreaterThan(0)
-      expect(errors[0].message).toContain('cannot implicitly convert int to float')
-      expect(errors[0].message).toContain('as float')
+      expect(errors[0].message).toContain('cannot implicitly convert int to fixed')
+      expect(errors[0].message).toContain('as fixed')
     })
 
-    it('detects float assigned to int variable', () => {
+    it('detects fixed assigned to int variable', () => {
       const errors = typeCheck(`
-fn get_f() -> float {
+fn get_f() -> fixed {
     return 3.14;
 }
 fn test() {
@@ -128,25 +128,25 @@ fn test() {
       expect(errors[0].message).toContain('cannot implicitly convert')
     })
 
-    it('detects int/float return type mismatch', () => {
+    it('detects int/fixed return type mismatch', () => {
       const errors = typeCheck(`
-fn get_float() -> float {
+fn get_fixed() -> fixed {
     return 5;
 }
 `)
       expect(errors.length).toBeGreaterThan(0)
-      expect(errors[0].message).toContain('cannot implicitly convert int to float')
-      expect(errors[0].message).toContain('as float')
+      expect(errors[0].message).toContain('cannot implicitly convert int to fixed')
+      expect(errors[0].message).toContain('as fixed')
     })
 
-    it('detects float/int return type mismatch', () => {
+    it('detects fixed/int return type mismatch', () => {
       const errors = typeCheck(`
 fn get_int() -> int {
     return 3.14;
 }
 `)
       expect(errors.length).toBeGreaterThan(0)
-      expect(errors[0].message).toContain('cannot implicitly convert float to int')
+      expect(errors[0].message).toContain('cannot implicitly convert fixed to int')
       expect(errors[0].message).toContain('as int')
     })
 
@@ -159,29 +159,29 @@ fn test() {
       expect(errors).toHaveLength(0)
     })
 
-    it('allows float assigned to float variable', () => {
+    it('allows fixed assigned to fixed variable', () => {
       const errors = typeCheck(`
-fn get_f() -> float {
+fn get_f() -> fixed {
     return 3.14;
 }
 fn test() {
-    let x: float = get_f();
+    let x: fixed = get_f();
 }
 `)
       expect(errors).toHaveLength(0)
     })
 
-    it('blocks compilation on int→float mismatch', () => {
+    it('blocks compilation on int→fixed mismatch', () => {
       expect(() => compileStrict(`
-fn get_float() -> float {
+fn get_fixed() -> fixed {
     return 5;
 }
 `)).toThrow()
     })
 
-    it('int→float mismatch demoted to warning in lenient mode', () => {
+    it('int→fixed mismatch demoted to warning in lenient mode', () => {
       const result = compileLenient(`
-fn get_float() -> float {
+fn get_fixed() -> fixed {
     return 5;
 }
 `)

package/src/__tests__/typechecker.test.ts

@@ -144,9 +144,11 @@ fn test() {
     })
 
     it('rejects unsupported f-string placeholder types', () => {
+      // entity type is not allowed in f-string
       const errors = typeCheck(`
 fn test() {
-    say(f"Flag: {true}");
+    let e: entity = @s
+    say(f"Flag: {e}");
 }
 `)
       expect(errors.length).toBeGreaterThan(0)
@@ -658,10 +660,10 @@ fn handle(player: Player) {}
     it('rejects mismatched event signatures', () => {
       const errors = typeCheck(`
 @on(BlockBreak)
-fn handle_break(player: Player) {}
+fn handle_break() {}
 `)
       expect(errors.length).toBeGreaterThan(0)
-      expect(errors[0].message).toContain('must declare 2 parameter(s)')
+      expect(errors[0].message).toContain('must declare 1 parameter(s)')
     })
   })
 })

package/src/ast/types.ts

@@ -27,7 +27,7 @@ export interface Span {
 // Type Nodes
 // ---------------------------------------------------------------------------
 
-export type PrimitiveType = 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double' | 'format_string'
+export type PrimitiveType = 'int' | 'bool' | 'float' | 'fixed' | 'string' | 'void' | 'BlockPos' | 'byte' | 'short' | 'long' | 'double' | 'format_string'
 
 // Entity type hierarchy
 export type EntityTypeName =
@@ -179,6 +179,7 @@ export type Expr =
   | { kind: 'tuple_lit'; elements: Expr[]; span?: Span }
   | { kind: 'some_lit'; value: Expr; span?: Span }  // Some(expr)
   | { kind: 'none_lit'; span?: Span }               // None
+  | { kind: 'type_cast'; expr: Expr; targetType: TypeNode; span?: Span }  // expr as Type
 
 export type LiteralExpr =
   | Extract<Expr, { kind: 'int_lit' }>
@@ -222,6 +223,17 @@ export type ExecuteSubcommand =
   | { kind: 'store_result'; target: string; targetObj: string }
   | { kind: 'store_success'; target: string; targetObj: string }
 
+// ---------------------------------------------------------------------------
+// Match Patterns
+// ---------------------------------------------------------------------------
+
+export type MatchPattern =
+  | { kind: 'PatSome'; binding: string }   // Some(x)
+  | { kind: 'PatNone' }                    // None
+  | { kind: 'PatInt'; value: number }      // 1, 2, 3
+  | { kind: 'PatWild' }                    // _
+  | { kind: 'PatExpr'; expr: Expr }        // legacy: range_lit or other expr
+
 export type Stmt =
   | { kind: 'let';        name: string; type?: TypeNode; init: Expr; span?: Span }
   | { kind: 'let_destruct'; names: string[]; type?: TypeNode; init: Expr; span?: Span }
@@ -233,9 +245,10 @@ export type Stmt =
   | { kind: 'while';      cond: Expr; body: Block; span?: Span }
   | { kind: 'for';        init?: Stmt; cond: Expr; step: Expr; body: Block; span?: Span }
   | { kind: 'foreach';    binding: string; iterable: Expr; body: Block; executeContext?: string; span?: Span }
-  | { kind: 'for_range';  varName: string; start: Expr; end: Expr; body: Block; span?: Span }
+  | { kind: 'for_range';  varName: string; start: Expr; end: Expr; inclusive?: boolean; body: Block; span?: Span }
   | { kind: 'for_in_array'; binding: string; arrayName: string; lenExpr: Expr; body: Block; span?: Span }
-  | { kind: 'match';      expr: Expr; arms: { pattern: Expr | null; body: Block }[]; span?: Span }
+  | { kind: 'for_each';    binding: string; array: Expr; body: Block; span?: Span }
+  | { kind: 'match';      expr: Expr; arms: { pattern: MatchPattern; body: Block }[]; span?: Span }
   | { kind: 'if_let_some'; binding: string; init: Expr; then: Block; else_?: Block; span?: Span }
   | { kind: 'as_block';   selector: EntitySelector; body: Block; span?: Span }
   | { kind: 'at_block';   selector: EntitySelector; body: Block; span?: Span }

package/src/emit/compile.ts

@@ -19,6 +19,7 @@ import { coroutineTransform, type CoroutineInfo } from '../optimizer/coroutine'
 import { analyzeBudget } from '../lir/budget'
 import { McVersion, DEFAULT_MC_VERSION } from '../types/mc-version'
 import { TypeChecker } from '../typechecker'
+import { isEventTypeName } from '../events/types'
 
 export interface CompileOptions {
   namespace?: string
@@ -58,12 +59,15 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
   const tokens = lexer.tokenize()
   const parser = new Parser(tokens, processedSource, filePath)
   const ast = parser.parse(namespace)
+  warnings.push(...parser.warnings)
 
   // Merge library imports (files with `module library;`) into AST
   for (const li of preprocessed.libraryImports ?? []) {
     const libPreprocessed = preprocessSourceWithMetadata(li.source, { filePath: li.filePath })
     const libTokens = new Lexer(libPreprocessed.source, li.filePath).tokenize()
-    const libAst = new Parser(libTokens, libPreprocessed.source, li.filePath).parse(namespace)
+    const libParser = new Parser(libTokens, libPreprocessed.source, li.filePath)
+    const libAst = libParser.parse(namespace)
+    warnings.push(...libParser.warnings)
     for (const fn of libAst.declarations) fn.isLibraryFn = true
     ast.declarations.push(...libAst.declarations)
     ast.structs.push(...libAst.structs)
@@ -94,6 +98,8 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
   {
     const checker = new TypeChecker(processedSource, filePath)
     const typeErrors = checker.check(ast)
+    // Collect lint warnings (non-blocking — always added regardless of error mode)
+    warnings.push(...checker.getWarnings())
     if (typeErrors.length > 0) {
       if (lenient) {
         for (const e of typeErrors) {
@@ -114,11 +120,12 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
     // Stage 2b: Monomorphize generic functions
     const hir = monomorphize(hirRaw)
 
-    // Extract @tick, @load, @coroutine, and @schedule functions from HIR (before decorator info is lost)
+    // Extract @tick, @load, @coroutine, @schedule, and @on handlers from HIR (before decorator info is lost)
     const tickFunctions: string[] = []
     const loadFunctions: string[] = []
     const coroutineInfos: CoroutineInfo[] = []
     const scheduleFunctions: Array<{ name: string; ticks: number }> = []
+    const eventHandlers = new Map<string, string[]>()
     for (const fn of hir.functions) {
       for (const dec of fn.decorators) {
         if (dec.name === 'tick') tickFunctions.push(fn.name)
@@ -133,6 +140,13 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
         if (dec.name === 'schedule') {
           scheduleFunctions.push({ name: fn.name, ticks: dec.args?.ticks ?? 1 })
         }
+        if (dec.name === 'on' && dec.args?.eventType) {
+          const evType = dec.args.eventType as string
+          if (isEventTypeName(evType)) {
+            if (!eventHandlers.has(evType)) eventHandlers.set(evType, [])
+            eventHandlers.get(evType)!.push(`${namespace}:${fn.name}`)
+          }
+        }
       }
     }
 
@@ -168,8 +182,23 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
       warnings.push(diag.message)
     }
 
+    // Stage 6.5: Validate LIR score_set values are in MC int32 range
+    const INT32_MAX = 2147483647
+    const INT32_MIN = -2147483648
+    for (const fn of lirOpt.functions) {
+      for (const instr of fn.instructions) {
+        if (instr.kind === 'score_set' && (instr.value > INT32_MAX || instr.value < INT32_MIN)) {
+          warnings.push(
+            `[ConstantOverflow] function '${fn.name}': ` +
+            `scoreboard immediate ${instr.value} is outside MC int32 range [${INT32_MIN}, ${INT32_MAX}]. ` +
+            `This indicates a constant-folding overflow bug — please report this.`
+          )
+        }
+      }
+    }
+
     // Stage 7: LIR → .mcfunction
-    const files = emit(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions, generateSourceMap, mcVersion })
+    const files = emit(lirOpt, { namespace, tickFunctions, loadFunctions, scheduleFunctions, generateSourceMap, mcVersion, eventHandlers })
 
     return { files, warnings, success: true as const }
   } catch (err) {

package/src/emit/index.ts

@@ -23,6 +23,8 @@ export interface EmitOptions {
   generateSourceMap?: boolean
   /** Target Minecraft version; controls which MC features are used in codegen */
   mcVersion?: McVersion
+  /** Map of EventTypeName → list of fully-qualified function references for @on handlers */
+  eventHandlers?: Map<string, string[]>
 }
 
 // ---------------------------------------------------------------------------
@@ -97,6 +99,27 @@ export function emit(module: LIRModule, options: EmitOptions): DatapackFile[] {
     })
   }
 
+  // Event handler tag files: data/rs/tags/function/on_<event>.json
+  const EVENT_TAG_NAMES: Record<string, string> = {
+    PlayerJoin: 'on_player_join',
+    PlayerDeath: 'on_player_death',
+    EntityKill: 'on_entity_kill',
+    ItemUse: 'on_item_use',
+    BlockBreak: 'on_block_break',
+  }
+
+  if (options.eventHandlers) {
+    for (const [evType, handlers] of options.eventHandlers) {
+      const tagName = EVENT_TAG_NAMES[evType]
+      if (tagName && handlers.length > 0) {
+        files.push({
+          path: `data/rs/tags/function/${tagName}.json`,
+          content: JSON.stringify({ values: handlers }, null, 2) + '\n',
+        })
+      }
+    }
+  }
+
   return files
 }
 
@@ -176,7 +199,7 @@ function emitInstr(instr: LIRInstr, ns: string, obj: string, mcVersion: McVersio
       return `execute store result storage ${instr.ns} ${instr.path} ${instr.type} ${instr.scale} run scoreboard players get ${slot(instr.src)}`
 
     case 'store_nbt_to_score':
-      return `execute store result score ${slot(instr.dst)} run data get storage ${instr.ns} ${instr.path} ${instr.scale}`
+      return `execute store result score ${slot(instr.dst)} run data get storage ${instr.ns} ${instr.path} ${Number.isInteger(instr.scale) ? instr.scale.toFixed(1) : instr.scale}`
 
     case 'nbt_set_literal':
       return `data modify storage ${instr.ns} ${instr.path} set value ${instr.value}`

package/src/emit/modules.ts

@@ -507,7 +507,8 @@ function rewriteStmt(stmt: Stmt, symbolMap: Map<string, string>): void {
     case 'match':
       rewriteExpr(stmt.expr, symbolMap)
       for (const arm of stmt.arms) {
-        if (arm.pattern) rewriteExpr(arm.pattern, symbolMap)
+        // PatExpr wraps a legacy Expr that may contain symbol refs
+        if (arm.pattern.kind === 'PatExpr') rewriteExpr(arm.pattern.expr, symbolMap)
         rewriteBlock(arm.body, symbolMap)
       }
       break

package/src/events/types.ts

@@ -13,8 +13,11 @@ export const EVENT_TYPES = {
   },
   BlockBreak: {
     tag: 'rs.just_broke_block',
-    params: ['player: Player', 'block: string'],
+    params: ['player: Player'],
     detection: 'advancement',
+    // Note: block type is NOT available as a runtime parameter — MC has no mechanism
+    // to pass event data to function tags. Use minecraft.mined:<block> scoreboard
+    // stats for per-block detection, or check the block at player's position in handler.
   },
   EntityKill: {
     tag: 'rs.just_killed',
@@ -61,7 +64,7 @@ function toTypeNode(typeName: string): TypeNode {
     return { kind: 'entity', entityType: 'Player' }
   }
 
-  if (typeName === 'string' || typeName === 'int' || typeName === 'bool' || typeName === 'float' || typeName === 'void' || typeName === 'BlockPos' || typeName === 'byte' || typeName === 'short' || typeName === 'long' || typeName === 'double') {
+  if (typeName === 'string' || typeName === 'int' || typeName === 'bool' || typeName === 'float' || typeName === 'fixed' || typeName === 'void' || typeName === 'BlockPos' || typeName === 'byte' || typeName === 'short' || typeName === 'long' || typeName === 'double') {
     return { kind: 'named', name: typeName }
   }
 

package/src/examples/capture_the_flag.mcrs

@@ -151,7 +151,7 @@ fn check_flag_capture() {
         let dist: int = distance_to(p, BLUE_BASE_X, BASE_Y, BLUE_BASE_Z);
         if (dist < 5) {
             game.blue_score = game.blue_score + 1;
-            announce("§e[CTF] §9Blue Team §ascores! §f(" + game.blue_score + "/" + WIN_SCORE + ")");
+            announce(f"§e[CTF] §9Blue Team §ascores! §f({game.blue_score}/{WIN_SCORE})");
             tag_remove(p, "has_flag");
             effect_clear(p, "minecraft:glowing");
             place_flags();
@@ -164,7 +164,7 @@ fn check_flag_capture() {
         let dist: int = distance_to(p, RED_BASE_X, BASE_Y, RED_BASE_Z);
         if (dist < 5) {
             game.red_score = game.red_score + 1;
-            announce("§e[CTF] §cRed Team §ascores! §f(" + game.red_score + "/" + WIN_SCORE + ")");
+            announce(f"§e[CTF] §cRed Team §ascores! §f({game.red_score}/{WIN_SCORE})");
             tag_remove(p, "has_flag");
             effect_clear(p, "minecraft:glowing");
             place_flags();

package/src/examples/hunger_games.mcrs

@@ -182,7 +182,7 @@ fn shrink_border() {
         }
         
         // worldborder set game.current_border 60
-        announce("§c[Hunger Games] §eBorder is shrinking! Current size: " + game.current_border);
+        announce(f"§c[Hunger Games] §eBorder is shrinking! Current size: {game.current_border}");
         
         // Update bossbar
         bossbar_set_max("hg_border", INITIAL_BORDER);
@@ -225,7 +225,7 @@ fn check_alive() {
     game.alive_count = alive;
     
     // Update scoreboard display
-    actionbar(@a, "§cAlive: " + alive);
+    actionbar(@a, f"§cAlive: {alive}");
     
     // Check for victory
     if (alive <= 1) {
@@ -246,7 +246,7 @@ fn declare_winner(winner: selector) {
     
     title(@a, "§6Winner!");
     announce("§c[Hunger Games] §6Game Over!");
-    announce("§aWinner's kills: " + kills);
+    announce(f"§aWinner's kills: {kills}");
     
     // Victory effects
     totem_effect(winner);
@@ -276,7 +276,7 @@ fn on_player_death(player: selector, killer: selector) {
     // gamemode spectator player
     
     let kills: int = scoreboard_get(killer, "hg_kills");
-    announce("§c☠ §7A player was eliminated! Killer now has " + kills + " kills");
+    announce(f"§c☠ §7A player was eliminated! Killer now has {kills} kills");
 }
 
 // ===== Reset Game =====

package/src/examples/parkour_race.mcrs

@@ -92,7 +92,7 @@ fn race_tick() {
             let time: int = scoreboard_get(p, "pk_time");
             let seconds: int = time / 20;
             let ms: int = (time % 20) * 5;
-            actionbar(p, "§e⏱ " + seconds + "." + ms + "s");
+            actionbar(p, f"§e⏱ {seconds}.{ms}s");
             
             // Check fall
             check_fall(p);
@@ -109,7 +109,7 @@ fn check_fall(player: selector) {
     execute if entity player[y=..50] run {
         let cp: int = scoreboard_get(player, "pk_checkpoint");
         respawn_at_checkpoint(player, cp);
-        tell(player, "§cFell! Returning to checkpoint " + cp);
+        tell(player, f"§cFell! Returning to checkpoint {cp}");
         angry(player);
     }
 }
@@ -157,7 +157,7 @@ fn reach_checkpoint(player: selector, cp: int) {
     scoreboard_set(player, "pk_checkpoint", cp);
     
     title(player, "");
-    subtitle(player, "§aCheckpoint " + cp + " / " + CHECKPOINT_COUNT);
+    subtitle(player, f"§aCheckpoint {cp} / {CHECKPOINT_COUNT}");
     
     happy(player);
     playsound("minecraft:entity.experience_orb.pickup", "player", player);
@@ -194,19 +194,19 @@ fn finish_race(player: selector) {
         // First completion
         scoreboard_set(player, "pk_best", time);
         title(player, "§6Finished!");
-        subtitle(player, "§e" + seconds + "." + ms + "s §7(first record)");
-        announce("§b[Parkour] §fA player finished! Time: §e" + seconds + "." + ms + "s");
+        subtitle(player, f"§e{seconds}.{ms}s §7(first record)");
+        announce(f"§b[Parkour] §fA player finished! Time: §e{seconds}.{ms}s");
     } else {
         if (time < best) {
             // New record!
             scoreboard_set(player, "pk_best", time);
             title(player, "§6New Record!");
-            subtitle(player, "§e" + seconds + "." + ms + "s");
-            announce("§b[Parkour] §6New Record! §fTime: §e" + seconds + "." + ms + "s");
+            subtitle(player, f"§e{seconds}.{ms}s");
+            announce(f"§b[Parkour] §6New Record! §fTime: §e{seconds}.{ms}s");
             totem_effect(player);
         } else {
             title(player, "§aFinished!");
-            subtitle(player, "§e" + seconds + "." + ms + "s");
+            subtitle(player, f"§e{seconds}.{ms}s");
         }
     }