Fast Builder Lambda

Fast BuilderLambda is a special version of Fast Builder that based on gopher tunnel. This edition is much more powerful and professional than Project Alpha.

Installation / Building

Linux

First of all clone the source code

git clone https://github.com/CAIMEOX/Phoenix.git

cd into the project library
```
cd Phoenix
```
Build Fast Builder lambda
```
go build
```
Run Fast Builder Lambda
```
./phoenix
```

Usage

Prepare

Create a new file named config.toml in project root directory with content below.

[Connection]
# RemoteAddress is the address of the server you want to entry.
RemoteAddress = "127.0.0.1:19132"
[User]
# Enable auth if you need to authenticate to the server.
Auth = true
# Set to the operator
User = "CAIMEOX"
Bot = "CAIMEO_Bot"
[Debug]
Enabled = false 
[Lib]
# Load Standard library, includes basic arithmetic functions like +, - and array operations.
Std = true
# Load your own Fast Builder Script.
# Check scripts/example.scm for more information.
Script = ["path_to_script1.scm","path_to_script2.scm"]

Launch Fast Builder, soon the Bot will join the targeted server.
Entry the world.

REPL

Bot will start a interactive interpreter session on your chat screen. You can send text chat to interact with the Fast Builder System. The "/" is needless and you can execute it by simply send it as a chat message.

Language reference

There are two major reasons why use scheme :

Scheme places an emphasis on Functional programming and Recursive Implementation.

Scheme is quite expressive and extensible. (which makes it much powerful than shell)

Fast Builder use scheme, a dialect of lisp, as the command language. Similar to lisp, a simple command or function call is done by surrounding the function with their parameters in a parenthesis.

(function param1 param2)
; Anything following a ';' is a comment

A single function can return a single value which can be a integer, floating point, string, a Go native struct, or even a nil value. Unlike in C/C++, Go, Java, or Rust, lisp doesn't have to start from a main function. Like python, the interpreter just reads the given file or any kind of input, and evaluates them on the fly.

By default the interpreter includes many functions built that allows to do some basic arithmetic.

Language Inbuilt

Defining variables, assignment, loops, etc., are built into the interpreter. In fact those are keywords. There are a handful of keywords in scheme.

var
- defining a new variable, if the passed name is already defined this throws an error.
- syntax : (var VARIABLE_NAME INIT_VALUE)
- examples:
```
(var name "CAIMEO")
(var age 15)
```
set
- setting value to the variable. if the variable name passed is not defined, this throws an error.
- syntax: (set VARIABLE_NAME VALUE)
- examples:
```
; Set default block
(set block "tnt")
```
fn
- function declaration

return

return a value
syntax : (return VALUE|VARIABLE_NAME)

examples:

(return "Charon is lovely!")
(return "Lisp is awesome")
(return 114514)

progn
- run a list of lisp expressions, to be discussed later.
loop
- loop is a type of loop construct.
- This loop is like while loop in C.
in
- in is another kind of loop construct.
- similar to the one in python. for i in list: ...
if
- condition construct of scheme.
match
- switch...case condition construct of scheme
eval
- eval keyword is used to evaluate a string as a scheme expression and return the evaluated value.
- syntax : (eval LISP_EXPRESSION)
- example : (eval "(+ 9 7)") => 16
delete
- delete is used to delete a variable from the interpreter's memory.
- syntax : (delete VARIABLE_NAME)
- example : (delete age)

Basic Types

Like any other language, there are some inbuilt types like int, string, float etc., Defining them is very simple. 1 is a simple integer. 3.14 is a simple floating point decimal. "simple string" is a simple string. true or false can be used for denoting the Boolean.

; Interpreter automatically recognizes the number and assigns the variable age with an integer value of 16.
(var age 16)
; Get the type of age
; => Eval : int
(type age)
; Similar to this all other variables can be set up.
; Arrays can be set up like following :
(var fruits ["apple" "orange" "banana" "Papaya"])
; The arrays defined can contain any types of variables.
(var any ["caimeo" 11 "torrekie" 233])

Conditions

There are 2 conditional constructs in scheme language.

if
match

if

syntax

(if (CONDITION)
  (SUCCESS_CLAUSE) ;; single expression
  (FAILURE_CLAUSE) ;; single clause, optional.
  )

example

(var age 22)
(if (> age 18)
  (println "You are an adult")
  (println "You are not an adult"))
; Tips: If you want to do more than a single expression in any of the clauses, throw a progn.
; If the else clause is not required just leave the FAILURE_CLAUSE empty or () .
(if (> age 18)
    (progn
      (println "You are an adult")
      (set r18_access true)))

Return

In scheme if can also return a value based on a condition. So consider the previous example. The variable r18_access is set to true. Here is another way to do it.

(var r18_access (if (> age 18) true false))
; This can be written as:
(if (> age 18)
  (var r18_access true)
  (var r18_access false))

match

match conditional is similar to switch...case in C/C++. But there are no other keywords used unlike in C/C++ (like case, break). You can match any kind of variable like strings, floats, etc.,

syntax

(match MATCH_VARIABLE
    CASE_1_VARIABLE (CASE_1_BODY)
    CASE_2_VARIABLE (CASE_2_BODY)
    CASE_3_VARIABLE (CASE_3_BODY)
    CASE_4_VARIABLE (CASE_4_BODY)
    _               (DEFAULT_CASE_BODY)  ;; `default:` is here denoted as `_`
    )

example

(var number 1)
(match number
    0    (println "zero")
    1    (println "one")           ;; In this case this will succeed
    2    (println "two")
    3    (println "three")
    4    (println "four")
    5    (println "five")
    6    (println "six")
    7    (println "seven")
    8    (println "eight")
    9    (println "nine")
    _    (println "greater than 10")
)
; Similar to if, match can return values
; numberString = "one"
(var number 1)
(var numberString (match number
                    0    "zero"
                    1    "one"
                    2    "two"
                    3    "three"
                    4    "four"
                    5    "five"
                    6    "six"
                    7    "seven"
                    8    "eight"
                    9    "nine"
                    _    "greater than 10"
                ))

Loops

There are two loop constructs

loop
in

loop

loop is a simple C/C++ while loop kind of construct. It will run the loop body unless the condition is false.

syntax
```
(loop CONDITION
	(LOOP_BODY))
```

example

(var numbers [1 2 3 4 5 6 7])
(var sum 0)

(var i 0)
(var sum2 0)

(loop (< i (len numbers))
      (progn
        (set sum2 (+ sum2 (array-index numbers i)))
        (set i (+ i 1))
        ))

in

in loop is used for traversing through an array easily. It is like python's for i in range(5) construct.

syntax
```
(in ARRAY ARRAY_VARIABLE LOOP_BODY)
```

example

(var numbers [1 2 3 4 5 6 7])
(var sum 0)

(in numbers number
    (progn
      (set sum (+ sum number))))

Basic Fast Builder Functions

After learning the basic elements of the Scheme, it's time to learn about Fast Builder functions. Fast Builder will create a new Space that based on Overworld where all the operations will occur here by default. Certainly you can create your own Space that used for Linear transformation or applying other advanced space mapping.

Fetcher

get

(get) 
; Set the default position to the current position of you. This function always returns Nil

Builder

Fast Builder offers many simple geometry structures generator. They will return an Array contains Vectors.

circle

; facing, available values: x,y,z
(circle radius inner-radius height facing)

sphere
```
(sphere raidus inner-radius)
```
ellipse
```
(ellipse length width height facing)
```

You have to apply plot function to generate structures in Minecraft world.

(plot Vectors)
; Examples:
(plot (round 5 3 4 "y"))
(plot (sphere 10 9))