Merge branch 'main' of https://github.com/MinecraftFunctionPlusPlus/MCFPPGuide

Author: Alumopper

docs/en/overview.md

@@ -8,7 +8,7 @@ nav:
 
 # MCFPP Overview
 
-Before the start: sentences of mcfpp is end up with semicolon.
+Before the start: statements of mcfpp is end up with semicolon.
 
 ## Project information file in JSON format<Badge type="tip">WIP</Badge>
 
@@ -43,7 +43,7 @@ Project information file is situated on root of engineering catalogue, As an ent
 
 ### Variables
 
-Declare : `type identifier (= expr)?;`
+Defination : `type identifier (= expr)?;`
 
 Such as : `int i = 5 + p;`，`int x,y,z;`
 
@@ -76,11 +76,11 @@ During Compiling, If any variable has been defined as literal, like `int i = 5;`
 
 - const
 
-`const` means a variable is always constant. That is, its value is given during compilation, and never changes. Such as `const int i = 5;`, `i` will be seem as constant during compiling. Constant is always static during compiling, and its value must be clear when we declare it, can't assign after declaring.
+`const` means a variable is always constant. That is, its value is given during compilation, and never changes. Such as `const int i = 5;`, `i` will be seem as constant during compiling. Constant is always static during compiling, and its value must be clear when we define it, can't assign after declaring.
 
 - import <Badge type="warning">Deprecated</Badge>
 
-`import` means a variable is import variable, it's value is imported from other place. Such as `import int i;`, `i` will be seen as import variable after compile. Often, variable only can be used after assignment, but if we use `import` modifier, Then variable can be used after declaration without assignment.
+`import` means a variable is import variable, it's value is imported from other place. Such as `import int i;`, `i` will be seen as import variable after compile. Often, variable only can be used after assignment, but if we use `import` modifier, Then variable can be used after defination without assignment.
 
 ### Comment
 
@@ -134,13 +134,13 @@ for(forinit;bool;forupdate){
 
 ## Namespace 
 
-Each file's namespace can be declared independently 
+Each file's namespace can be defined independently 
 
 ```cpp
 namespace xxx;
 ```
 
-If the file haven't declared a separate namespace, the namespace defaults to the namespace set in the project configuration file.
+If the file haven't define a separate namespace, the namespace defaults to the namespace set in the project configuration file.
 
 ## Function 
 
@@ -156,7 +156,7 @@ func test(int i) -> int{
 
 ```
 
-Function's namespace is decided by the file's namespace. If the file haven't declared a separate namespace, the namespace defaults to the namespace set in the project configuration file.
+Function's namespace is decided by the file's namespace. If the file haven't defined a separate namespace, the namespace defaults to the namespace set in the project configuration file.
 
 :::tip Tip
 In mcfpp, function name can contains most utf-8 characters, but the compiled mcfunction's name will only contains characters, underline and numbers. The illegal characters will be replaced by `_uxxxx`.
@@ -291,15 +291,15 @@ class Student{
 
 ### Abstract
 
-Add `abstract` keyword before class can declare the class as abstract class. Abstract function can't be instantiate.
+Add `abstract` keyword before class can define the class as abstract class. Abstract function can't be instantiate.
 
-Add `abstract` keyword before function can declare the function as abstract function. Abstract function can't include function body.
+Add `abstract` keyword before function can define the function as abstract function. Abstract function can't include function body.
 
 ### Extension Function
 
-Extension Function makes you can "add" function to current types. And don't need to create new derived type, recompile or change original data type by other methods. Extension function declares out of the class, but it also can be called, as other functions in the class.
+Extension Function makes you can "add" function to current types. And don't need to create new derived type, recompile or change original data type by other methods. Extension function defined out of the class, but it also can be called, as other functions in the class.
 
-Declares extension function in the form of `Class name.Function name`, for example:
+Define extension function in the form of `Class name.Function name`, for example:
 
 ```cpp
 namespace test;
@@ -341,13 +341,13 @@ interface InterfaceName{
 }
 ```
 
-You can declare abstract function in the interface. Interface can inherit from other interfaces.
+You can define abstract function in the interface. Interface can inherit from other interfaces.
 
 ## Template <Badge type="tip">WIP</Badge>
 
 Structure is a datatype that totally makes up by score board. So structure only can contain score board, that's `int` type variables as members.
 
-When declaring field, we can ignore type ‘int'. Except this, structure is almost the same as class.
+During the defination of field, we can ignore type ‘int'. Except this, structure is almost the same as class.
 
 Here's an example of structure:
 
@@ -387,9 +387,9 @@ MNI is similar with the JNI in Java, is a kind of programming framework, makes t
 
 ### native function
 
-native can be declared in classes or functions, Used to run a specific Java function when **compiling**.
+native can be defined in classes or functions, Used to run a specific Java function when **compiling**.
 
-It's declaration is like this:
+It's defination is like this:
 
 ```cpp
 func test(params...) -> returnType = packagename.classname.funcname;  

docs/en/quickstart/02base/01variables.md

@@ -4,19 +4,19 @@ lastUpdated: true
 
 # Variable
 
-## Declaration of variables
+## Defination of variables 
 
-Same as other languages, you can declare some variables in MCFPP for store, transfer and process data.
+Same as other languages, you can define some variables in MCFPP for store, transfer and process data.
 
-The declaration of data is like this:
+The defination of data is like this:
 
 ```mcfpp
 #Type of data Identifier of data (optional: = expression or value )
 int i = 5;
 int b = i * 6;
 ```
 
-The identifier of variable can be the combination of any characters and numbers. In one scope, a name of variable only can declared once.
+The identifier of variable can be the combination of any characters and numbers. In one scope, a name of variable only can defined once.
 
 ## Type of variable 
 

docs/en/quickstart/02base/03logic-statements.md

@@ -2,25 +2,25 @@
 lastUpdated: true
 ---
 
-# 逻辑语句
+# Logic statements 
 
 ::: tip
-MCFPP中的逻辑语句和C/Java中的逻辑语句完全一致。如果你对其他语言足够熟悉，你可以跳过这一节。
+The logic statement of MCFPP is totally the same as in C/Java. You can skip this chapter if you already know it.
 :::
 
-## if语句
+## if statement
 
-`if`语句是一种条件语句，它用来判断一个条件是否成立。如果条件成立，那么`if`语句中的代码块将会被执行。`if`语句的语法如下：
+`if` statement is a condition statement, it can used to determine a condition is true or false. If true, then the code in the `if` statement block will be execute. The grammar of `if` is:
 
 ```mcfpp
 if (condition){
     #code
 }
 ```
 
-`condition`是一个布尔表达式，它的值为`true`或`false`。如果`condition`的值为`true`，那么`#code`中的代码块将会被执行。
+`condition` is a boolean expression, it’s value is `true` or `false`. If the value of `condition` is `true`, then `#code` will be execute.
 
-`if`语句还可以和`else`语句一起使用，`else`语句用来在`if`语句的条件不成立时执行代码块。`if-else`语句的语法如下：
+`if` statement can be used together with `else` statement, `else` statement used to execute the code when the condition in `if`is false. The grammar of `if-else` is shown:
 
 ```mcfpp
 if (condition){
@@ -30,9 +30,9 @@ if (condition){
 }
 ```
 
-`condition`是一个布尔表达式，它的值为`true`或`false`。如果`condition`的值为`true`，那么`#code1`中的代码块将会被执行；否则，`#code2`中的代码块将会被执行。
+`condition` is a boolean expression, it’s value is `true` or `false`. If the value of `condition` is `true`, then `#code1‘ will be execute; Else, ’#code2‘ will be execute.
 
-可以使用`else if`语句用来在`if`语句的条件不成立时判断另一个条件。`if-else if-else`语句的语法如下：
+We can use `else if` to add another condition when `if` is false. The grammar of `if-else if-else` is shown below:
 
 ```mcfpp
 if (condition1){
@@ -44,47 +44,47 @@ if (condition1){
 }
 ```
 
-## while语句和do-while语句
+## while statement and do-while statement
 
-`while`语句是一种循环语句，它用来重复执行一个代码块，直到条件不成立。`while`语句的语法如下：
+`while` is a loop statement, it can execute a code block repeatedly, until the condition is false. The grammar of `while` statement is:
 
 ```mcfpp
 while (condition){
     #code
 }
 ```
 
-`condition`是一个布尔表达式。如果`condition`的值为`true`，那么则执行`#code`代表的代码块。此后，再次判断`condition`的值，如果`condition`的值为`true`，那么`#code`代表代码块将会被执行；如此循环，直到`condition`的值为`false`。
+`condition` is an boolean expression, when `condition` is `true`, it’ll execute the code block in `#code`. Then, determine the value of `condition` again. If value of `condition` is `true`, then `#code` will be execute; loop again and again, until the value of `condition` is `false`.
 
-`do-while`语句和`while`类似，但是无论条件是否成立，它都会先执行因此循环体中的语句，而后再判断条件来决定是否继续进行。`do-while`语句的语法如下：
+`do-while` statement is similar with `while` statement, but no matter the condition is true or false, it’ll execute the statement in the loop once, and then determine the condition to see continue execution or not. The grammar of `do-while` is shown below:
 
 ```mcfpp
 do{
     #code
 }while (condition);
 ```
 
-## for语句
+## for statement 
 
-`for`语句是循环的一种稍复杂的版本，它的语法如下：
+`for` statement is a more complex version of loop, it’s grammar is:
 
 ```mcfpp
 for (forinit; condition; forupdate){
     #code
 }
 ```
 
-`forinit`是一个初始化表达式，它用来初始化循环变量。`condition`是一个布尔表达式，它用来判断循环是否继续。`forupdate`是一个更新表达式，它用来更新循环变量。`#code`代表了循环体，即循环体中的代码。在运行的时候，`for`语句的执行过程如下：
+`forinit` is an initialization expression, used to initialize loop variable. `condition` is a boolean expression, used to determine if the loop keeps going on. `forupdate` is a update expression, used to update the variable of the loop. `#code` represents the loop body, which is the code in the loop. The execute process of `for` is shown below:
 
-1. 执行`forinit`，初始化循环变量。
-2. 判断`condition`的值，如果`condition`的值为`true`，则执行`#code`代表的代码块，然后执行`forupdate`，更新循环变量，再次判断`condition`的值。
-3. 如果`condition`的值为`false`，则退出循环。
+1. Execute `forinit`, initialize the loop variable.
+2. Determine the value of `condition`, if the value of `condition` is `true`, execute `#code`, then execute `forupdate`, to update the loop variable, and determine the value of `condition` again.
+3. If the value of `condition` is `false`, exit the loop.
 
-`for`循环中，`forinit`声明的变量只在`for`循环中有效。
+In `for` loop, the declaration of variable `forinit` only valid in the `for` loop.
 
-## break和continue语句
+## break and continue statement
 
-`break`语句用来跳出整个循环，`continue`语句用来跳过本次循环。例如：
+`break` statement used to jump out the whole loop, `continue` statement used to skip the current loop. For example:
 
 ```mcfpp
 for (int i = 0; i < 10; i++){
@@ -98,6 +98,6 @@ for (int i = 0; i < 10; i++){
 }
 ```
 
-在上面的例子中，当`i`的值为`5`时，`break`语句会跳出整个循环；当`i`的值为`3`时，`continue`语句会跳过本次循环，直接进行下一次循环。因此，i在每次循环中的变化为：`0`，`1`，`2`，`4`，`5`，最后跳出循环。
+In this example, when the value of `i` is `5`, `break`will jump out of the loop; when the value of `i` is `3`, `continue` will jump this loop, go to the next loop directly. So, the change of I in each loop are:`0`，`1`，`2`，`4`，`5`, and finally jump out.
 
-`break`和`continue`语句只能在循环中使用。
+`break` and `continue` statement only can be used in the loop

docs/en/quickstart/02base/04top-statements.md

@@ -2,9 +2,9 @@
 lastUpdated: true
 ---
 
-# 顶层语句
+# Top statement 
 
-在MCFPP中，允许在文件的开始直接编写语句而无需额外定义函数，即顶层语句。顶层语句处于一个隐式的函数中，这个函数每个文件有且只有一个，且不能被外部调用。它的返回值类型为`void`。
+In MCFPP, allows programming statements in the start of the file and don’t need to define extra function, that’s the top statement. Top statement places in a hidden function, each file have one and only one of this function, and it cannot be called externally. Its returned value’s type is `void`.
 
 ```mcfpp
 print("Top statement");
@@ -14,9 +14,9 @@ func main(){
 }
 ```
 
-在编译后，会生成两个函数——分别对应main函数以及顶层语句对应的默认函数。
+After compiling, it’ll form two functions —— corresponding to main function and the default functions of top statement respectively.
 
-顶层语句只能在文件的开始编写，即在函数定义或类定义之前。顶层语句可以调用文件中声明的其他函数和类
+Top statement only can program in the start of the file, which is before the defination of any functions or classes. Top statement can call the other functions and classes that’s defined in the file.
 
 ```mcfpp
 main();

docs/en/quickstart/03namespace/01namespace.md

@@ -2,23 +2,23 @@
 lastUpdate: true
 ---
 
-# 命名空间
+# Namespace 
 
-MCFPP中的命名空间和MC中的命名空间是同一种东西。这也意味着，命名空间只能是小写字母、数字，点和下划线的组合。
+The namespace in MCFPP is same as the namespace in Minecraft. That means, namespace only can be the combination of lowercase letters, numbers, dots and underlines.
 
-你可以在文件中声明一个命名空间，这样文件中的所有函数和变量都会被放置在这个命名空间中。例如：
+You can declare a namespace in a file, so all functions and variables in the file will be placed in the namespace. For example:
 
 ```mcfpp
 namespace test;
 
-func test(){    # test:test函数
+func test(){    # test:test function 
     print(i);
 }
 ```
 
-一个文件中只能声明一次命名空间。
+You can only define namespace once in a file.
 
-同样的，你也可以在项目配置文件中声明这个命名空间。
+The same, you can also define this namespace in the project configuration file.
 
 ```json
 {
@@ -31,7 +31,7 @@ func test(){    # test:test函数
         "D:/workspace/mcfpp/another_project.json"
     ],
     "targetPath":"./out",
-    //工程的默认命名空间。可选，默认为default // [!code focus]
+    //The default namespace of the project. Optional, default is ‘default’ // [!code focus]
     "namespace":"mcfpp" // [!code focus]
 }
 ```

docs/en/quickstart/04function/01define-and-call.md

@@ -2,53 +2,54 @@
 lastUpdate: true
 ---
 
-# 定义和调用
+# Define and call
 
-MCFPP函数的定义方式和C/Java有较大的区别，而更加接近于Python的语法。
+The way of define function in MCFPP has some differences with C/Java, and more similar to the grammar of Python.
 
-## 函数定义
+## Function definition 
 
-MCFPP中，函数的定义语法如下：
+In MCFPP, the grammar of define a function is shown below:
 
 ```mcfpp
 func functionName(parameter1, parameter2, ...) -> returnType{
-    #函数体
+    #Function body
 }
 ```
 
-`func`是函数的关键字，`functionName`是函数的标识符或者说名字，而紧随其后的`parameter1, parameter2, ...`则是函数的参数列表，`returnType`是可选的，即函数的返回类型。函数体则是由`{}`包裹的一系列语句。下面是一个实际的例子：
+`func` is the key word of function `functionName` is the identifier or name of the function, the following `parameter1, parameter2, ...` is the parameter list of the function,`returnType`is optional, which is the returned type of the function. Function body is a series of statements surrounded by `{}`. Here’s a example below:
 
 ```mcfpp
 func add(int a, int b) -> int{
     return a + b;
 }
 ```
 
-这个函数的名字是`add`，它有两个整数类型的参数`a`和`b`，返回值也是一个整数类型。这个函数的作用是把两个参数相加并返回结果。
+The name of the function is `add`, it have two integer-type parameters `a` and `b`, return value is also integer type. Its function is add the two parameters and return them.
 
 ## return
 
-`return`和Minecraft中的`return`命令作用相同，都是用于返回函数的返回值。它的语法即为`return expression;`，其中`expression`是一个表达式，它的值就是函数的返回值。
+`return` is same as the `return` command in Minecraft, both used to return the returned value of the function. It’s grammar is `return expression;`, `expression` is an expression, it’s value is the returned value of the function.
 
-如果一个函数定义了返回值类型，那么它的每一个分支都必须有`return`语句，即函数必定返回一个值。且`return`语句返回的值必须和函数的返回值类型相同，或者是返回值类型的子类型。
+If a function defined the type of the returned value, then each branch of it must have `return` statement, so the function must would return a value. And the value that `return` statement returned must have the same type as the type of return value of the function, or the subtype of the returned value’s type.
 
-如果一个函数没有定义返回值类型，那么默认为`void`，即不会返回任何值。这个时候，`return`语句仍然是可用的，但是它的语法变为`return;`，即不带任何表达式。它将会起到立刻终止函数运行的作用。
+If a function haven’t defined the return value’s type, then the default is `void`, which won’t return any value. Now, `return` statement is still available, but its grammar becomes `return;`, without any expression. Its function is stop the function immediately.
 
-## 函数的调用
+## Call of function 
 
-MCFPP中，函数的调用语法和C/Java一样，即`functionName(parameter1, parameter2, ...);`。其中，`functionName`是函数的名字，`parameter1, parameter2, ...`是要传递给函数的参数。下面是一个实际的例子：
+In MCFPP, grammar of call function is the same as in C/Java 
+, that’s `functionName(parameter1, parameter2, ...);`. In it, the `functionName` is the name of function,`parameter1, parameter2, ...` are the parameters to the function, here’s the example:
 
 ```mcfpp
 func test(){
-    print(add(1, 2));  #上面定义的add函数
+    print(add(1, 2));  #the add function defined before 
 }
 ```
 
-这个例子中，`test`函数调用了`add`函数，并传递了两个参数`1`和`2`。`add`函数返回了`3`，因此`test`函数将会打印出`3`。
+In this example, `test` function called `add` function, and sent two parameters `1` and `2`. `add` function returns `3`, so the `test` function will print `3`.
 
-## 函数的传参
+## The argument of function 
 
-函数中，对参数的修改不会影响到函数外部的变量。例如：
+In the function, the change to the parameter won’t affect the variables out of the function. For example:
 
 ```mcfpp
 func test(int a){
@@ -58,8 +59,8 @@ func test(int a){
 void main(){
     int a = 0;
     test(a);
-    print(a);   #输出0
+    print(a);   #output 0
 }
 ```
 
-在这个例子中，`test`函数对传入的参数`a`进行了修改，但是`main`函数中的`a`并没有受到影响。
+In this case, `test` function modified the passed in parameter `a`, but the `a` in `main` function haven’t been affected.