1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
---
title: Computations
weight: 2
---
Computations are values. They may read from the memory, but do not modify it.
### TEXT
{{< fatecode >}}(text [C0: COMPUTATION]...[CN: COMPUTATION]){{< /fatecode >}}
Returns a `text` value containing the text representation of `C0`...`CN`.
**Examples:** `(text just a few strings)`,
`(text (string just a single string))`, `(text There are (+ 3 1) lights!)`,
`(text (text (text well...)))`.
**Aliases:** `text`.
### VARIABLE | REFERENCE
{{< fatecode >}}(var {String}){{< /fatecode >}}
Returns the value of the variable `{String}`, or a reference to it if
applicable. In cases where no `text` or `string` value is expected, using
`{String}` instead of `(var {String})` will work as a shortcut.
Structure members can be accessed by using `.` in `{String}`. Collection
(`list` or `set`) elements can be similarly accessed by their index.
**Examples:** `(var my_list)`, `(var my_list.0)`, `(var my_list.0.name)`.
**Aliases:** `var`, `variable`.
### STRING
{{< fatecode >}}(string {String}){{< /fatecode >}}
Returns a `string` value corresponding to `{String}`. This can be used
to disambiguate strings and variable names, as well as to create strings with
spaces.
**Examples:**
`(string just a single string)`, `(string var0_is_not_a_var)`
**Aliases:** `string`.
### SEQUENCE | PROCEDURE
{{< fatecode >}}(sequence {String}){{< /fatecode >}}
Returns a `[SEQUENCE]` value corresponding to the sequence named `{String}`.
Said sequence can be defined at a later point.
**Examples:** `(sequence the_cave)`, `(sequence end_credits)`.
**Aliases:** `seq`, `sequence`.
### STRUCTURE FIELD ACCESS
{{< fatecode >}}{Structure Variable Name}.{Field Name}{{< /fatecode >}}
{{< fatecode >}}(struct:field {String} [STRUCTURE]){{< /fatecode >}}
Accesses the `{String}` field of the structure `[STRUCTURE]`. Using `.` to
access fields is recommended over the use of this operator when possible. The
returned value can act as a reference.
**Examples:** `claude.health_points`, `(struct:field health_points jack)`,
`(struct:field stamina (car (list:pop_left character_list)))`
**Aliases:** `struct:field`, `struct:get`, `struct:getfield`,
`struct:get_field`.
### TEMPORARY VARIABLES
{{< fatecode >}}(let
(
({V0: String} [C0: COMPUTATION])
...
({VN: String} [CN: COMPUTATION])
)
[result: COMPUTATION]
){{< /fatecode >}}
Defines a hierarchical level and local variables `V0` ... `VN` with values `C0` ... `CN`, and returns the value of `result`.
**Examples:**
**Aliases:**
### CAST
{{< fatecode >}}(cast [TYPE] [COMPUTATION*]){{< /fatecode >}}
Transforms `[COMPUTATION*]` into a value of type `[TYPE]`. Note that the variable
shorthand cannot be used for `[COMPUTATION*]`. The following type changes are
allowed:
* `[FLOAT]` to `[FLOAT]`, `[INT]`, and `[STRING]`.
* `[INT]` to `[FLOAT]`, `[INT]`, and `[STRING]`.
* `[BOOL]` to `[BOOL]` and `[STRING]`.
* `[STRING]` to `[BOOL]` (`true` and `false`), `[FLOAT]`, `[INT]`, and`[STRING]`.
**Examples:**
**Aliases:**
### RANDOM NUMBER
{{< fatecode >}}(rand [I0: INT] [IN: INT]){{< /fatecode >}}
Returns a random number between `I0` and `IN` (inclusive).
**Examples:**
**Aliases:**
## Basic Operators
### BOOL OPERATORS
{{< fatecode >}}(and [B0: BOOL] ... [BN: BOOL]){{< /fatecode >}}
Standard conjunction (minimum of 2 arguments).
{{< fatecode >}}(or [B0: BOOL] ... [BN: BOOL]){{< /fatecode >}}
Standard disjunction (minimum of 2 arguments).
{{< fatecode >}}(not [BOOL]){{< /fatecode >}}
Standard negation.
{{< fatecode >}}(implies [B0: BOOL] [B1: BOOL]){{< /fatecode >}}
Standard implication.
{{< fatecode >}}(one_in [B0: BOOL] ... [BN: BOOL]){{< /fatecode >}}
true if, and only if, exactly one of the operands is true.
**Examples:**
**Aliases:**
### MATH OPERATORS
All operands must be of the same type, which is also the type returned by the
operation.
{{< fatecode >}}(+ [N0: NUMBER] ... [NN: NUMBER]){{< /fatecode >}}
Standard addition (minimum of 2 arguments).
{{< fatecode >}}(- [N0: NUMBER] ... [NN: NUMBER]){{< /fatecode >}}
Standard substraction (minimum of 2 arguments).
{{< fatecode >}}(* [N0: NUMBER] ... [NN: NUMBER]){{< /fatecode >}}
Standard multiplication (minimum of 2 arguments).
{{< fatecode >}}(/ [N0: NUMBER] [N1: NUMBER]){{< /fatecode >}}
Standard division. Note that a division on integers is indeed a integer
division.
{{< fatecode >}}(^ [N0: NUMBER] [N1: NUMBER]){{< /fatecode >}}
Standard exponentiation.
{{< fatecode >}}(% [I0: INT] [I1: INT]){{< /fatecode >}}
Standard modulo operation.
{{< fatecode >}}(min [N0: NUMBER] ... [NN: NUMBER]){{< /fatecode >}}
Lowest value among the operands.
{{< fatecode >}}(max [N0: NUMBER] ... [NN: NUMBER]){{< /fatecode >}}
Highest value among the operands.
{{< fatecode >}}(clamp [N0: NUMBER] [N1: NUMBER] [N2: NUMBER]){{< /fatecode >}}
Equivalent to `(max N0 (min N1 N2))`.
{{< fatecode >}}(abs [NUMBER]){{< /fatecode >}}
Positive value of `[NUMBER]`.
**Examples:**
**Aliases:**
### COMPARISON OPERATORS
{{< fatecode >}}(= [C0: COMPUTATION] ... [CN: COMPUTATION]){{< /fatecode >}}
True if, and only if, all operands are equal.
{{< fatecode >}}(< [C0: COMPARABLE] [C1: COMPARABLE]){{< /fatecode >}}
True if, and only if, `C0` is strictly lower than `C1`.
{{< fatecode >}}(=< [C0: COMPARABLE] [C1: COMPARABLE]){{< /fatecode >}}
True if, and only if, `C0` is lower or equal to/than `C1`.
{{< fatecode >}}(> [C0: COMPARABLE] [C1: COMPARABLE]){{< /fatecode >}}
True if, and only if, `C0` is strictly higher than `C1`.
{{< fatecode >}}(>= [C0: COMPARABLE] [C1: COMPARABLE]){{< /fatecode >}}
True if, and only if, `C0` is higher or equal to/than `C1`.
**Examples:**
**Aliases:**
|
