WarScript API Reference

Language

WarScript syntax reference — constructions, data types, and operators.

Basic Constructions

Variables

# plain types
a1 = 123
a2 = "hello world"

# class instance
left_tree_node = new TreeNode [ 1 ]
tree_node = new TreeNode [ 3, left_tree_node, new TreeNode [ 2 ] ]

# array
example_array = { 1, 2, "three", new TreeNode [ 4 ] }
empty_array = {}

Conditions

if a1 > 5 and tree_node :: value == 3
    # statements
elif a2 == "hello" or a3 == "world"
    # statements
else
    # statements
end

Print

print a1 + a2 + tree_node :: value

Import

import "lib/common.ws"

Functions

fun fibonacci_number [ n ]
    if n < 2
        return n
    end
    return fibonacci_number [ n - 1 ] + fibonacci_number [ n - 2 ]
end

Loops

# for loop
loop i in 0..10
    # statements
end

# with step
loop i in 0..100 by 5
    # statements
end

# while loop
loop health > 0
    # statements
end

# for-each
loop item in items
    # statements
end

# break and next
loop i in 0..10
    if i == 5
        break
    end
    if i == 3
        next
    end
end

Exceptions

class MyException [message]
end

begin
    raise new MyException ["Error message"]
rescue error
    print error :: message
ensure
    print "Always runs"
end

Data Types

Numeric

number1 = 1
number2 = 3.21
number3 = .543
number4 = -1

Text

text = "hello world"
print text{1}
text{1} = "a"

Logical

logical1 = true
logical2 = false

Class

class Lamp [ type, is_on ]
    fun turn_on
        is_on = true
    end

    fun turn_off
        is_on = false
    end

    fun set_is_on [ is_on ]
        this :: is_on = is_on
    end
end

lamp = new Lamp [ "Halogen", false ]

# get/set properties
lamp_is_on = lamp :: is_on
lamp :: type = "Led"

# invoke functions
lamp :: turn_off []

# inheritance
class DerivedClass: BaseClass [ property ]
end

Arrays

items = { 1, 2, "three" }

# get/set by index
value = items{1}
items{1} = 123

# append
items << 3

Null

value = null

NativeObject<T>

fun on_unit_died[unit]
    print Unit_get_position[unit]
end

Operators

Operators ordered by precedence (lowest to highest):