Syntax Cheatsheet ​

command "tp",
command "teleport" {                          // aliases share one body
    permission: "swoftlang.teleport"
    description: "Teleport a player"

    arguments {
        player: Player = sender               // one-token default
        target: either<Player|Location>       // union type, no default
    }

    execute {
        if args.player is not a Player {
            send "<red>You can only teleport players" to sender
            halt
        }
        teleport args.player to args.target
        send "<lime>Teleported ${sender} to ${args.target}"
    }
}

event PlayerChat {
    priority: 0

    execute {
        set event.message to "[Filtered] ${event.message}"
        if event.message contains "badword" {
            cancel event
        }
    }
}

command "vars" {
    execute {
        set x to 10                    // declare/assign a local
        set x to x + 1                 // reassign
        set sender.health to 20.0      // property write (see Properties)
        set held to sender.held_item   // property read into a local
    }
}

command "ops" {
    execute {
        set x to 1 + 2 * 3                       // 7 — precedence
        set y to (1 + 2) * 3                     // 9 — parens group
        set ok to x > 6 and not (y < 5)
        if "SwoftLang" contains "swoft" {        // case-insensitive substring
            send "yes" to sender
        }
        if x is a Number and ok is not a String {
            send "typed" to sender
        }
    }
}

command "interp" {
    execute {
        set who to sender.name
        send "Hello ${who}, health ${sender.health}"          // simple paths
        send "Sum: ${1 + 2 * 3}, upper: ${uppercase(who)}"    // full expressions
    }
}

command "flow" {
    execute {
        // if / else if / else
        set x to 7
        if x = 5 {
            send "five" to sender
        } else if x = 7 {
            send "seven" to sender
        } else {
            send "other" to sender
        }

        // counted loop; optional counter runs 1..N
        loop 3 times as i {
            send "iteration ${i}" to sender
        }
        loop 3 times {
            send "again" to sender
        }

        // while (runtime guard stops runaway loops at 100,000 iterations)
        set n to 3
        while n > 0 {
            set n to n - 1
        }

        // iterate a list
        loop all_players() as p {
            send "hi ${p.name}" to p
        }
        loop all players as p {                   // sugar for all_players()
            send "hey ${p.name}" to p
        }
        loop first 5 of all_players() as p {      // cap the iteration count
            send "you're early" to p
        }

        halt                                       // stop this script run
        send "never reached" to sender
    }
}

command "terse" {
    execute {
        // any body can be exactly one brace-free statement
        set x to 7
        if x > 5 send "big" to sender
        else if x = 5 send "exact" to sender
        else halt

        loop 3 times as i send "i = ${i}" to sender
        async send "from a task" to sender

        // a dangling else binds to the nearest if
        if x > 0 if x > 100 send "huge" to sender
        else send "positive, not huge" to sender
    }
}

function factorial(n: int) {
    if n <= 1 {
        return 1
    }
    return n * factorial(n - 1)               // recursion (depth cap 256)
}

function greet(player: Player) {
    send "Welcome, ${player}!" to player
}

command "demo" {
    execute {
        set f to factorial(5)                 // call as expression
        greet(sender)                         // call as statement
        call greet(sender)                    // optional 'call' keyword
        return                                // bare return = stop, like halt
    }
}

function double(x: Integer) return x * 2      // brace-free body

command "lambda" {
    execute {
        set triple to function(x: Integer) return x * 3
        send "${triple(4)}" to sender         // 12: call through the variable

        set count to 0
        set inc to function() set count to count + 1
        inc()                                 // closures capture by reference
        send "${count}" to sender             // 1

        set task to async function(p: Player) {
            wait 1 seconds
            send "later" to p
        }
        spawn task(sender)                    // spawn works on async lambdas
    }
}

command "find" {
    arguments {
        who: optional<Player>                 // optional command argument
    }
    execute {
        set found to player("Notch")          // player() : optional<Player>

        if found exists {
            send "hi ${found.name}" to found  // narrowed to Player here
        } else {
            send "offline" to sender
        }
        if found is missing {
            send "still missing" to sender
        }

        set target to args.who otherwise sender   // optional<T> otherwise T -> T
        set label to none                         // the missing value
        set title to label otherwise "guest"
        send "${title}" to target
    }
}

command "props" {
    execute {
        set sender.health to sender.max_health
        set sender.location.y to sender.location.y + 10   // wither + one teleport
        set sender.held_item.amount to 32
        set sender.gamemode to "creative"                 // enum-validated string
    }
}

async function countdown(target: Player, from: Integer) {
    loop from times as i {
        send "<yellow>${from - i + 1}..." to target
        wait 1 seconds
    }
    send "<lime>Go!" to target
}

async function double_it(x: Integer) {
    wait 1 ticks
    return x * 2
}

command "start" {
    execute {
        spawn countdown(sender, 3)      // fire-and-forget from sync code
        async {                          // anonymous fire-and-forget block
            wait 10 ticks
            send "ready" to sender
        }
        send "started" to sender         // runs immediately, no blocking
    }
}

command "race" {
    execute async {                      // whole handler is async
        wait 5 ticks
        set doubled to double_it(21)     // direct async call: sequential
        send "result ${doubled}" to sender
    }
}

storage {
  backend: files "data/swoftlang"     // or: sqlite "path.db" | mysql { ... } | mongodb "uri"
  flush: every 30 seconds             // write-behind cadence (default 30s)
}

persistent total_joins: Integer = 0            // global scalar, default required
persistent kills for Player: Integer = 0       // keyed by subject

event PlayerJoin {
    execute {
        set total_joins to total_joins + 1
    }
}

import "music"                           // stdlib/addon by name (addon path)
                                         // import "./lib/util.sw" — relative form

var greeting_count = 0                   // module-level var: private, shared state

export function greet(target: Player) {  // 'export' makes it importable
    set greeting_count to greeting_count + 1
    send "hello (#${greeting_count})" to target
}

function helper() return 1               // un-exported = private to this file