Options | |||
---|---|---|---|

Option | Param | Description | |

-H |
--no-header |
Suppress the syntax information section in BMG text files. | |

-B |
--brief |
Suppress the output of the description and print only function type and syntax. | |

-l |
--long |
Usually only the function syntax is compared to the keywords. But if --long is set, the descriptions are compared too. |

Function Reference | ||
---|---|---|

File Type |
Return Value & Function Name & Parameters |
Description |

* | int$(...) |
This debug function returns the number of parameters. |

* | *abs(val) |
Returns the absolute value of 'val'. If 'val' is a vector, the absolute value of each component is calculated. The return type is identical to the type of 'val'. |

* | flt|vecacos(val) |
Returns the arc cosine of 'val' in degree. If 'val' is a vector, the arc cosine of each component is calculated. |

* | flt|vecasin(val) |
Returns the arc sine of 'val' in degree. If 'val' is a vector, the arc sine of each component is calculated. |

* | flt|vecatan(val) |
Returns the arc tangent of 'val' in degree. If 'val' is a vector, the arc tangent of each component is calculated. |

* | floatatan2(x,z) |
Returns the arc tangent of 'z/x' in degree, using the signs of the two arguments to determine the quadrant of the result. Both arguments are converted to a float before operation. If 'x' is a vector, its x component is used. If 'z' is a vector, its z component is used. |

* | vectoraxisRot(pt,deg,axis1,axis2) |
The point 'pt' is rotated around the axis 'axis1->axis2' by 'deg' degree, which is a scalar. The other 3 parameters are converted to vectors before operation. |

* | intbe(val,n) |
Convert 'val' to integer, limit it to 'n' bytes (1-8) and mark it for big endian usage. |

* | flt|vecbezier(pos,v1,va[,vb],v2) |
Calculate the position 'pos' on a bezier curve going from 'v1' to 'v2'. 'va' and 'vb' are helper points. If 'vb' is not set, a quadratic bezier curve is calculated. Otherwise 'va' and 'vb' are set and a cubic bezier curve is calculated. Position 0.0 returns 'v1' and position 1.0 'v2'. All position values between 0.0 and 1.0 return a point of the calculated bezier curve between points 'v1' and 'v2'. If 'pos' is a vector, different positions for each coordinate are used.
If any parameter is a vector, all parameters are converted to vectors and the result is a vector. Otherwise all parameters are converted to floats and the result is a float. |

* | floatcalcNormals(p1,p2[,helper][,r]]) |
This function calculates 3 right-angled normals (index 0..2) for the vector 'p1..p2', 'normal[0]' is the direction of this vector. Is 'helper' is set, it is used to determine the direction of normal[1]. All 3 normals are multiplied by the factor 'r'. The function returns the distance between 'p1' and 'p2'. To get the normals, use function getNormal(). |

* | *ceil(val) |
Returns the smallest integral value that is not less than 'val'. If 'val' is a vector, the calculation is done for each component. The return type is identical to the type of 'val'. |

* | intchat$n_races(n) |
Create a chat modus for LE-CODE setup. N is a values between 1 and 512 and defines the number of races. The parameters are used to select random scenarios between 1 and 8. |

* | flt|veccos(val) |
Returns the cosine of 'val', where 'val' is given in degree. If 'val' is a vector, the cosine of each component is calculated. |

* | vectorcross(v1,v2) |
Returns the cross product of the 2 vectors 'v1' and 'v2'. |

* | floatdir([v1,]v2) |
The 3D direction in degree from position 'v1' to 'v2' is calculated. If 'v1' is not set, v(0,0,0) is used. The Z coordiante of the result is always 0.0. |

* | floatdot(v1,v2) |
Returns the dot product of the 2 vectors 'v1' and 'v2'. |

* | *echo(p1,...) |
This debug function prints all parameters, each in a separate line, and returns the first parameter. |

* | flt|vecexp(val) |
Returns the value of e (the base of natural logarithms) raised to the power of 'val'. If 'val' is a vector, the calculation is done for each component. |

* | strextract(str,pos1,pos2) |
Extract all characters of string STR including position POS1 and excluding position POS2. Positions <0 are relative to the end of STR and adjusted. If POS1 ëÑPOS2, an empty string is returned. |

* | floatfloat(val) |
Converts 'val' to a float value. Strings are scanned for a float. |

* | *floor(val) |
Returns the largest integral value that is not greater than 'val'. If 'val' is a vector, the calculation is done for each component. The return type is identical to the type of 'val'. |

* | vectorgetNormal(index) |
This function returns the normal 'index' (0..2) of the last call of function calcNormals(). If 'index' is invalid, $NONE is returned. |

* | floathDir([v1,]v2) |
'hDir()' is the old name for 'yDir()'. The horizontal direction in degree from position 'v1' to 'v2' is calculated. If 'v1' is not set, v(0,0,0) is used. |

* | floathLen(v1[,v2]) |
Returns the horizontal length of the vector 'v1' (ignoring the y component). If 'v2' is set, the horizontal distance of both points is returned. |

* | floathLen2(v1[,v2]) |
Returns the square of the horizontal length of the vector 'v1' (ignoring the y component). If 'v2' is set, the horizontal square distance of both points is returned. |

* | vectorhRot(pt,deg[,origin]) |
'hRot()' is the old name for 'yRot()'. The point 'pt' is horizontal rotated around 'origin' by 'deg' degree. If 'pt' is a scalar, 'vz(pt)' is used. If 'origin' is not set, v(0,0,0) is used. |

* | intif$engine(...) |
Create a condition for KMP/GOBJ references. The parameters are used to select engine types. Available values: EN$BATTLE, EN$50, EN$100, EN$150 and EN$200. Use EN$150M, EN$200M for mirror modes. Additional short cuts: EN$150X for EN$150,EN$150M, EN$200X for EN$200,EN$200M, and EN$MIRROR for EN$150M,EN$200M. A negative index deselects an engine mode. '*' is a short cut for all modes. |

* | intif$random(...) |
Create a condition for KMP/GOBJ references. The parameters are used to select random scenarios between 1 and 8. A negative value deselects a scenario. '*' is a short cut for the parameter list '1,2,3,4,5,6,7,8'. |

* | intifLevel() |
This debug function returns the current IF..ENDIF level (number of active '@if's). |

* | intint(val) |
Converts 'val' to an integer value. Strings are scanned for an integer. |

* | intisDef(name) |
Returns 2, if variable 'name' is defined, or 1, if a variable with the base name is defined as vector, or 0, if it is not defined. |

* | intisFloat(name) |
Returns 2, if variable 'name' is defined as float with a value >0, or 1, if it is a float with a value <=0. Otherwise it returns 0. |

* | intisFunction(name) |
Returns 1, if 'name' is defined as system function, or 2, if 'name' is defined as user function, or 3, if 'name' is defined as system and as user function. Otherwise it's not a function and 0 is returned. |

* | intisInt(name) |
Returns 2, if variable 'name' is defined as an integer with a value >0, or 1, if it is an integer with a value <=0. Otherwise it returns 0. |

* | intisKCL() |
Returns 2, if the source is a KCL or OBJ named 'course.kcl' or 'course.txt' or 'course.txt.kcl', 1 if the source is any other KCL or OBJ, and 0 else. |

* | intisKMP() |
Returns 2, if the source is a KMP (binary or text) named 'course.kmp' or 'course.txt' or 'course.txt.kmp', 1 if the source is any other KMP (binary or text), and 0 else. |

* | intisLEX() |
Returns 2, if the source is a LEX (binary or text) named 'course.lex' or 'course.txt' or 'course.txt.lex', 1 if the source is any other LEX (binary or text), and 0 else. |

* | intisMacro(name) |
Returns 2, if 'name' is defined as user function, or 1, if 'name' is defined as simple macro. Otherwise it's not a macro or user function and 0 is returned. |

* | intisMDL() |
Returns 1, if the source is a MDL (binary or text). Otherwise it returns 0. |

* | intisNumeric(name) |
Returns 1, if variable 'name' is an integer, float or vector. Otherwise it returns 0. |

* | intisScalar(name) |
Returns 2, if variable 'name' is an integer or float with a value >0, or 1, if it is an integer or float with a value <=0. Otherwise it returns 0. |

* | intisStr(name) |
Returns 2, if variable 'name' is defined as string with 1 or more characters, or 1, if it is a string without characters. Otherwise it returns 0. |

* | intisVector(name) |
Returns 1, if variable 'name' is defined as vector. Otherwise it returns 0. |

* | intle(val,n) |
Convert 'val' to integer, limit it to 'n' bytes (1-8) and mark it for little endian usage. |

* | strleft(str,len) |
Extract the left LEN characters of string STR. If LEN<0, then extract all but not the last -LEN characters. |

* | int/fltlen(v1[,v2]) |
If 'v1' is a string, then 'v2' is ignored and the length of the string is returned as integer. Otherwise the length of the vector 'v1' is returned as float. If 'v2' is set, the distance of both points is returned. |

* | floatlen2(v1[,v2]) |
Returns the square of the length of the vector 'v1'. If 'v2' is set, the square distance of both points is returned. |

* | intline() |
This debug function returns the current line number. |

* | flt|veclog(val[,base]) |
If base is not set or invalid, the function returns the natural logarithm of 'val'. Otherwise base is converted to a float and logarithm with the entered base is returned (=log(val)/log(base)). If 'val' is a vector, the calculation is done for each component. |

* | intloopCount([level]) |
This debug function returns the loop counter of the specified loop level. If 'level' is omitted, the loop count of the current loop is returned. |

* | intloopLevel() |
This debug function returns the current loop level (number of active loops). |

* | *max(p1,...) |
Returns the maximum value of all parameters. If at least one parameter is a vector, the result is a vector too and the maximum value of each component is calculated. |

* | *mean(p1,...) |
Returns the arithmetic mean of all parameters. If at least one parameter is a vector, the result is a vector too and the maximum value of each component is calculated. The result type is UNSET, FLOAT or VECTOR, but never INT. |

* | strmid(str,pos[,len]) |
Extract LEN characters of string STR beginning at postition POS. If POS<0, then a position relative to the end of STR is used. If LEN<0, then extract all but not the last -LEN characters. If LEN is not set, then extract all characters until end of string. |

* | *min(p1,...) |
Returns the minimum value of all parameters. If at least one parameter is a vector, the result is a vector too and the minimum value of each component is calculated. |

* | *minMax(val,minval,maxval) |
Returns 'max(min(val,minval),maxval)': Limit the value 'val' by 'minval' and 'maxval'. The return type is identical to the type of 'val'. |

* | intmSec() |
Returns the number of milliseconds since an unspecific timer start. Use differences between 2 calls to get the elapsed time. The 3 functions sec(), mSec() and uSec() use the same time base. |

* | *param(index) |
Returns the value of the macro or function parameter with the entered 1-based index. Therefor the private variable '$N' and one of '$1', '$2', ... are read. |

* | flt|vecpos(pos,p1,p2) |
This function returns the relative position 'pos' on the axis 'p1' to 'p2' by calculating 'p1+pos*(p2-p1)'. If one of the 3 arguments is a vector, the result is also a vector. |

* | flt|vecpow(a,b) |
Returns the value of 'a' raised to the power of 'b'. If 'a' is a vector, each component is raised by 'b'. The operator ** does the same, but have integer support. |

* | strprint(format,...) |
Create a string like sprintf() of other programming languages. See https://szs.wiimm.de/doc/print for details. |

* | intptInConvexPolygon(pt,p1,..,pN) |
All parameters are converted into vectors, but only the x and z coordinates are used. 'p1..pN' are up to 100 vertices of a convex polygon. The function returns 1, if the point 'pt' is inside the polygon (including the lines), and 0 otherwise.
Function status() will return the direction of the polygon: -1 for counterclockwise, +1 for clockwise and 0 for unknown. |

* | intptsInConvexQuad(q1,q2,q3,q4,pt1,...,ptN) |
All parameters are converted into vectors, but only the x and z coordinates are used. 'q1..q4' define a convex quadrilateral, and 'pt1..ptN' is a list of up to 100 points. The functions returns the number of points, that are inside the quadrilateral. Points on the line are counted as inside too.
Function status() will return the direction of the quadrilateral: -1 for counterclockwise, +1 for clockwise and 0 for unknown. |

* | intptsInConvexTri(t1,t2,t3,pt1,...,ptN) |
All parameters are converted into vectors, but only the x and z coordinates are used. 't1..t3' define a convex triangle, and 'pt1..ptN' is a list of up to 100 points. The functions returns the number of points, that are inside the triangle. Points on the line are counted as inside too.
Function status() will return the direction of the triangle: -1 for counterclockwise, +1 for clockwise and 0 for unknown. |

* | intptsInCuboid(cube_min,cube_max,pt1,...) |
All parameters are converted to vectors. 'cube_*' describe 2 diagonal corners of a rectangular cuboid, assuming that 'cube_min<=cube_max' is true for each coordinate. The functions returns the number of points ('pt1', 'pt2', ...) that are inside of the cube including the border. |

* | intptsInCuboidS(cube1,cube2,pt1,...) |
This is the sloppy version of ptInCuboid(): All parameters are converted to vectors. 'cube*' describe any 2 diagonal corners of a rectangular cuboid. The functions returns the number of points ('pt1', 'pt2', ...) that are inside of the cube including the border. |

* | *random([max]) |
Returns a random number between 0 and 'max', but never equal 'max'. The return type is identical to the type of 'max'. If 'max' is not set, use float 1.0 instead. If 'max' is a vector, a vector with three random floats will be returned. |

* | strremove(str,pos1,pos2) |
Create a copy of string STR and remove all characters including position POS1 and excluding position POS2. Positions <0 are relative to the end of STR and adjusted. If POS1 ëÑPOS2, nothing is removed and the complete STR is returned. |

* | *result() |
Returns the last include, macro or function result. The value is usually '$NONE', unless the command '@RETURN' is used. |

* | strright(str,len) |
Extract the right LEN characters of string STR. If LEN<0, then extract all but not the first -LEN characters. |

* | vectorrot(pt,deg_vector[,origin]) |
The point 'pt' is rotated around 'origin'. The rotation is done for the x-, y- and z-axis in this order. All parameters are converted to vectors before the operation. If 'origin' is not set, v(0,0,0) is used. |

* | *round(val) |
Returns the rounded integer value of 'val'. If 'val' is a vector, the calculation is done for each component. The return type is identical to the type of 'val'. |

* | scalarscalar(val) |
If 'val' is a string, it is scanned for a number and converted first. If 'val' is a float or a vector, a float value is returned. Otherwise an integer value is returned. |

* | *scanExpr(val) |
If 'val' is a string, scan it for an expression. Otherwise return 'val'. |

* | *scanVal(val) |
If 'val' is a string, scan it for a value. Otherwise return 'val'. |

* | intsec() |
Returns the number of seconds since an unspecific timer start. Use differences between 2 calls to get the elapsed time. The 3 functions sec(), mSec() and uSec() use the same time base. |

* | *select(sel,p0,p1,...,pN) |
First convert 'sel' to an integer. If 'sel' is less or equal 0, 'p0' is returned. If 'sel' is greater or equal N, 'pN' is returned. Otherwise 'sel' is between 0 and N and 'p(sel)' is returned. |

* | intsideOfLine(a,b,pt) |
All parameters are converted into vectors, but only the x and z coordinates are used. Vectors 'a' and 'b' define a line (from a to b). The function returns -1, if the point 'pt' is on the left side of the line, or +1, if the point is on the right side, or 0 if the point is on the line. |

* | *sign(val) |
Returns the sign of 'val': -1 if 'val<0'; 0, if 'val==0'; +1 if 'val>0'. If 'val' is a vector, the sign of each component is calculated. The return type is identical to the type of 'val'. |

* | flt|vecsin(val) |
Returns the sine of 'val', where 'val' is given in degree. If 'val' is a vector, the sine of each component is calculated. |

* | intsourceLevel() |
This debug function returns the current source level (number of open files and macros). |

* | flt|vecsqrt(val) |
Returns the nonnegative square root of 'abs(val)'. If 'val' is a vector, the square root of each component is calculated. |

* | intstatus() |
Some function support a return value and an additionally status. This function will return the last set status. |

* | strstr(val) |
Converts 'val' to a string value. |

* | flt|vectan(val) |
Returns the tangent of 'val', where 'val' is given in degree. If 'val' is a vector, the tangent of each component is calculated. |

* | *trunc(val) |
Returns the nearest integer not larger in absolute value than 'val' (rounding towards zero). If 'val' is a vector, the calculation is done for each component. The return type is identical to the type of 'val'. |

* | inttype(name) |
Returns the type of the variable 'name' (TYPE$UNSET, TYPE$INT, TYPE$FLOAT, TYPE$VECTOR, TYPE$STR, TYPE$X, TYPE$Y, TYPE$Z) or value 'TYPE$UNDEF', if it is not defined. It is guaranteed, that 'TYPE$UNDEF < TYPE$UNSET < all_others'. |

* | vectorunit(v1[,v2]) |
Returns the unit vector of the vector 'v1'. If 'v2' is set, then the unit vector for the difference 'v2-v1' is returned. |

* | intuSec() |
Returns the number of microseconds since an unspecific timer start. Use differences between 2 calls to get the elapsed time. This timer has an overflow at about 35 minutes. The 3 functions sec(), mSec() and uSec() use the same time base. |

* | vectorv([val]) |
Defines a vector. If 'val' is a vector, it is copied. Otherwise 'val' is used for the x coordinate and y and z are set to 0.0. If 'val' is not set, 0.0 is used.
This function is used if an internal conversion to a vector is needed. |

* | vectorv(x[,y],z) |
Defines a vector by using the entered coordinates. If 'y' is not set, use 0.0 instead. If 'x', 'y' or 'z' is a vector itself, the corespondent coordinate is used. |

* | vectorv3(val) |
Create a vector with all 3 components equal to 'val' |

* | *var(name,val) |
If variable 'name' is defined and valid, return its value. Otherwise return 'val'. |

* | vectorvd(len,deg[,y]) |
Creates a vector of length 'len' and horizontal angle 'deg' (degree). Value 'y' (if not set: 0.0) is used for the height. |

* | vectorvx(x[,v]) |
Read the vector 'v' and replace the x component by 'x'. If 'x' is a vector, its x component is used. If 'v' is not set, use v(0,0,0) instead. |

* | vectorvy(y[,v]) |
Read the vector 'v' and replace the y component by 'y'. If 'y' is a vector, its y component is used. If 'v' is not set, use v(0,0,0) instead. |

* | vectorvz(z[,v]) |
Read the vector 'v' and replace the z component by 'z'. If 'z' is a vector, its z component is used. If 'v' is not set, use v(0,0,0) instead. |

* | floatx(val_1,...,val_n) |
Scan all parameters (at least 1 must exist) and find the first vector. If found, return its x component. If no vector exists, return the last value 'val_n'.
Confirming the rules above, 'x(val)' means: If 'val' is a vector, return its x component. Otherwise convert 'val' to a float and return it. |

* | floatxDir([v1,]v2) |
The functions returns the direction in degree of point 'v2' relative to the x-axis of point 'v1'. If 'v1' is not set, v(0,0,0) is used. |

* | vectorxRot(pt,deg[,origin]) |
The point 'pt' is rotated around the x-axis of 'origin' by 'deg' degree. If 'pt' is a scalar, 'vy(pt)' is used. If 'origin' is not set, v(0,0,0) is used. |

* | floaty(val_1,...,val_n) |
Scan all parameters (at least 1 must exist) and find the first vector. If found, return its y component. If no vector exists, return the last value 'val_n'.
Confirming the rules above, 'y(val)' means: If 'val' is a vector, return its y component. Otherwise convert 'val' to a float and return it. |

* | floatyDir([v1,]v2) |
The functions returns the direction in degree of point 'v2' relative to the y-axis of point 'v1'. If 'v1' is not set, v(0,0,0) is used. |

* | vectoryRot(pt,deg[,origin]) |
The point 'pt' is rotated around the y-axis of 'origin' by 'deg' degree. If 'pt' is a scalar, 'vz(pt)' is used. If 'origin' is not set, v(0,0,0) is used. This is the classical horizontal rotation. |

* | floatz(val_1,...,val_n) |
Scan all parameters (at least 1 must exist) and find the first vector. If found, return its z component. If no vector exists, return the last value 'val_n'.
Confirming the rules above, 'z(val)' means: If 'val' is a vector, return its z component. Otherwise convert 'val' to a float and return it. |

* | floatzDir([v1,]v2) |
The functions returns the direction in degree of point 'v2' relative to the z-axis of point 'v1'. If 'v1' is not set, v(0,0,0) is used. |

* | vectorzRot(pt,deg[,origin]) |
The point 'pt' is rotated around the z-axis of 'origin' by 'deg' degree. If 'pt' is a scalar, 'vx(pt)' is used. If 'origin' is not set, v(0,0,0) is used. |