Fractal Block World

Environment Variables


This documentation was created for the following version of the program: 1.01.22
One can toggle the console (while in game) by pressing the '~' key.

Commands can be entered while in the console. For example, entering the command "exit" will cause the program to exit.

The game has "environment variables" that can be accessed through the console. The "get" command prints the value of the specified environment variable.

The "ls" command lists all variables that start with a given prefix. Note: in addition to environment variables, there are "directories" which are simply a prefix of an environment variable name that ends with a period. The ls command lists variables and directories with the given prefix.

Variables can be changed using the "set" command, assuming you have access to do so. Note that all access is granted by enabling cheat codes.

Environment variables are important because you can set them in the "program_startup" script that is run when the program starts up. You can use this for advanced customization.

This document contains a dump of all environment variables.

This document was created by running the program and calling the "gendoc" console command.

Green entries represent directories, whereas grey ones represent individual environment variables. Some variables or directories are documented with blue text.


package (dir)

package.state (dir)

package.state.globals (dir)

package.state.globals.foo (bool)

package.state.globals.dingle (bool)

package.state.globals.sound (dir)

package.state.globals.sound.player_hurt_sounds_enabled (bool)

package.state.globals.flashes (dir)

package.state.globals.flashes.enable (bool)

package.state.input (dir)

package.state.input.binds (dir)

package.state.input.binds.SEMICOLON (dir)

package.state.input.binds.SEMICOLON.downup (string)

package.state.input.binds.RSHIFT (dir)

package.state.input.binds.RSHIFT.downup (string)

package.state.input.binds.RCTRL (dir)

package.state.input.binds.RCTRL.downup (string)

package.state.input.binds.RALT (dir)

package.state.input.binds.RALT.downup (string)

package.state.input.binds.QUOTE (dir)

package.state.input.binds.QUOTE.downup (string)

package.state.input.binds.LEFT (dir)

package.state.input.binds.LEFT.downup (string)

package.state.input.binds.UP (dir)

package.state.input.binds.UP.downup (string)

package.state.input.binds.LALT (dir)

package.state.input.binds.LALT.downup (string)

package.state.input.binds.HOME (dir)

package.state.input.binds.HOME.downup (string)

package.state.input.binds.EQUALS (dir)

package.state.input.binds.EQUALS.downup (string)

package.state.input.binds.COMMA (dir)

package.state.input.binds.COMMA.downup (string)

package.state.input.binds.MOUSEWHEEL_UP (dir)

package.state.input.binds.MOUSEWHEEL_UP.use (string)

package.state.input.binds.MOUSE2 (dir)

package.state.input.binds.MOUSE2.downup (string)

package.state.input.binds.BACKSPACE (dir)

package.state.input.binds.BACKSPACE.downup (string)

package.state.input.binds.SLASH (dir)

package.state.input.binds.SLASH.downup (string)

package.state.input.binds.F12 (dir)

package.state.input.binds.F12.downup (string)

package.state.input.binds.F11 (dir)

package.state.input.binds.F11.downup (string)

package.state.input.binds.F10 (dir)

package.state.input.binds.F10.downup (string)

package.state.input.binds.F8 (dir)

package.state.input.binds.F8.downup (string)

package.state.input.binds.DKEY_RBRACKET (dir)

package.state.input.binds.DKEY_RBRACKET.downup (string)

package.state.input.binds.F7 (dir)

package.state.input.binds.F7.downup (string)

package.state.input.binds.MINUS (dir)

package.state.input.binds.MINUS.downup (string)

package.state.input.binds.F6 (dir)

package.state.input.binds.F6.downup (string)

package.state.input.binds.RIGHT (dir)

package.state.input.binds.RIGHT.downup (string)

package.state.input.binds.S (dir)

package.state.input.binds.S.downup (string)

package.state.input.binds.LCTRL (dir)

package.state.input.binds.LCTRL.downup (string)

package.state.input.binds.Q (dir)

package.state.input.binds.Q.downup (string)

package.state.input.binds.P (dir)

package.state.input.binds.P.downup (string)

package.state.input.binds.O (dir)

package.state.input.binds.O.downup (string)

package.state.input.binds.V (dir)

package.state.input.binds.V.downup (string)

package.state.input.binds.SPACE (dir)

package.state.input.binds.SPACE.downup (string)

package.state.input.binds.N (dir)

package.state.input.binds.N.downup (string)

package.state.input.binds.RBRACKET (dir)

package.state.input.binds.RBRACKET.downup (string)

package.state.input.binds.E (dir)

package.state.input.binds.E.downup (string)

package.state.input.binds.U (dir)

package.state.input.binds.U.downup (string)

package.state.input.binds.G (dir)

package.state.input.binds.G.downup (string)

package.state.input.binds.7 (dir)

package.state.input.binds.7.downup (string)

package.state.input.binds.D (dir)

package.state.input.binds.D.downup (string)

package.state.input.binds.L (dir)

package.state.input.binds.L.downup (string)

package.state.input.binds.F (dir)

package.state.input.binds.F.downup (string)

package.state.input.binds.A (dir)

package.state.input.binds.A.downup (string)

package.state.input.binds.B (dir)

package.state.input.binds.B.downup (string)

package.state.input.binds.TAB (dir)

package.state.input.binds.TAB.downup (string)

package.state.input.binds.M (dir)

package.state.input.binds.M.downup (string)

package.state.input.binds.K (dir)

package.state.input.binds.K.downup (string)

package.state.input.binds.H (dir)

package.state.input.binds.H.downup (string)

package.state.input.binds.ENTER (dir)

package.state.input.binds.ENTER.downup (string)

package.state.input.binds.X (dir)

package.state.input.binds.X.downup (string)

package.state.input.binds.DKEY_LBRACKET (dir)

package.state.input.binds.DKEY_LBRACKET.downup (string)

package.state.input.binds.Y (dir)

package.state.input.binds.Y.downup (string)

package.state.input.binds.I (dir)

package.state.input.binds.I.downup (string)

package.state.input.binds.W (dir)

package.state.input.binds.W.downup (string)

package.state.input.binds.6 (dir)

package.state.input.binds.6.downup (string)

package.state.input.binds.F9 (dir)

package.state.input.binds.F9.downup (string)

package.state.input.binds.R (dir)

package.state.input.binds.R.downup (string)

package.state.input.binds.J (dir)

package.state.input.binds.J.downup (string)

package.state.input.binds.Z (dir)

package.state.input.binds.Z.downup (string)

package.state.input.binds.MOUSE1 (dir)

package.state.input.binds.MOUSE1.downup (string)

package.state.input.binds.1 (dir)

package.state.input.binds.1.downup (string)

package.state.input.binds.2 (dir)

package.state.input.binds.2.downup (string)

package.state.input.binds.LBRACKET (dir)

package.state.input.binds.LBRACKET.downup (string)

package.state.input.binds.END (dir)

package.state.input.binds.END.downup (string)

package.state.input.binds.DOWN (dir)

package.state.input.binds.DOWN.downup (string)

package.state.input.binds.4 (dir)

package.state.input.binds.4.downup (string)

package.state.input.binds.PERIOD (dir)

package.state.input.binds.PERIOD.downup (string)

package.state.input.binds.8 (dir)

package.state.input.binds.8.downup (string)

package.state.input.binds.0 (dir)

package.state.input.binds.0.downup (string)

package.state.input.binds.GRAVE (dir)

package.state.input.binds.GRAVE.downup (string)

package.state.input.binds.5 (dir)

package.state.input.binds.5.downup (string)

package.state.input.binds.DELETE (dir)

package.state.input.binds.DELETE.downup (string)

package.state.input.binds.BACKSLASH (dir)

package.state.input.binds.BACKSLASH.downup (string)

package.state.input.binds.F1 (dir)

package.state.input.binds.F1.downup (string)

package.state.input.binds.9 (dir)

package.state.input.binds.9.downup (string)

package.state.input.binds.C (dir)

package.state.input.binds.C.downup (string)

package.state.input.binds.ESC (dir)

package.state.input.binds.ESC.downup (string)

package.state.input.binds.T (dir)

package.state.input.binds.T.downup (string)

package.state.input.binds.LSHIFT (dir)

package.state.input.binds.LSHIFT.downup (string)

package.state.input.binds.F2 (dir)

package.state.input.binds.F2.downup (string)

package.state.input.binds.MOUSEWHEEL_DOWN (dir)

package.state.input.binds.MOUSEWHEEL_DOWN.use (string)

package.state.input.binds.F5 (dir)

package.state.input.binds.F5.downup (string)

package.state.input.binds.3 (dir)

package.state.input.binds.3.downup (string)

package.state.input.binds.F3 (dir)

package.state.input.binds.F3.downup (string)

package.state.input.binds.F4 (dir)

package.state.input.binds.F4.downup (string)

menu (dir)

menu.text_color (vector)
The color of text in the main menu.

menu.back_alpha_dark (float)
The darker background alpha of windows in the main menu. Some windows have a darker background than others.

menu.back_color (vector)
The background color of windows in the main menu.

menu.in_load_error (bool)
Whether the user is in a menu to deal with an error from loading a game. These menus are essentially popup menus.

menu.ent_press_key_prompt (bool)
Whether a message appears to use an item (that can be used) when the player has their crosshair on it. This var should probably be removed.

menu.in_main (bool)
If true, the game is paused (if there is a game loaded) and the user is in the main menu.

menu.last_player_name (string)
The player name associated to the last game that was played. This is useful because when the user loads a game, the user will probably want to select this name.

menu.back_alpha (float)
The background alpha of windows in the main menu.

menu.was_in_menu (bool)
True iff last cycle the player was either in the main menu, the console, or a game menu. This is needed because once the player opens some kind of menu from normal gameplay, all the input keys must be "cleared".

menu.render_world_behind (bool)
If true, then when in a main menu, the world will be rendered behind the menu. Note: if the frame rate is too low, the world will NOT be rendered behind the menu.

menu.in_package (bool)
If true, the game is paused and the user is in menu that comes with the package.

menu.load_error (dir)
If there is an error loading a game, the user must deal with a popup menu. Some of these menus allow the user to resume the load while forcing the value of a var. To resume the load, we must store the params that were passed to the loading function.

menu.load_error.2 (dir)

menu.load_error.2.has (bool)

menu.load_error.2.force_expected_package_ver (string)

menu.load_error.2.force_expected_eng_ver (string)

menu.load_error.1 (dir)

menu.load_error.1.override_eng_ver (string)

menu.load_error.1.type_new (bool)

menu.load_error.1.has (bool)

menu.load_error.1.new (dir)

menu.load_error.1.new.world_seed (int)

menu.load_error.1.new.player (string)

menu.load_error.1.new.starting_config_file (string)

metagame (dir)
Variables that start with "game" are removed just before we load a game. However, variables that start with "metagame" are not. That is, metagame vars can last longer than one loaded game. So you can set metagame.cheat.god to true, then load a different game and it will still be true.

metagame.cheat (dir)
Some cheat codes are defined by the package, and so you can enable them, save the game, exit the program, start the program again, load the game, and the cheat code will be enabled again. Other cheat codes, such as the ones here, are system cheat codes. They are not stored when the program exits. On the other hand, they are not associated to any game. So you can set metagame.cheat.god to true, load a different game, than god mode will still be on.

metagame.cheat.noclip (bool)

metagame.cheat.shrink_any (bool)

metagame.cheat.enabled (bool)

metagame.cheat.god (bool)

metagame.input (dir)

metagame.input.binds (dir)
There are input events, and then there are input actions. Input events are bound to input actions. For example, metagame.input.binds.input.6.down may be set to CUSTOM_03.

metagame.input.binds.actions (dir)
There are two kinds of input actions: custom and package. Custom input actions are specified here. When an action is executed, the string will be executed as a console command. Package input actions, on the other hand, are defined by the package in the binds.txt file. All package input actions should start with "PACKAGE".

metagame.input.binds.actions.CUSTOM_40 (dir)

metagame.input.binds.actions.CUSTOM_40.secondary (string)

metagame.input.binds.actions.CUSTOM_40.nickname (string)

metagame.input.binds.actions.CUSTOM_40.primary (string)

metagame.input.binds.actions.CUSTOM_39 (dir)

metagame.input.binds.actions.CUSTOM_39.secondary (string)

metagame.input.binds.actions.CUSTOM_39.nickname (string)

metagame.input.binds.actions.CUSTOM_39.primary (string)

metagame.input.binds.actions.CUSTOM_36 (dir)

metagame.input.binds.actions.CUSTOM_36.secondary (string)

metagame.input.binds.actions.CUSTOM_36.nickname (string)

metagame.input.binds.actions.CUSTOM_36.primary (string)

metagame.input.binds.actions.CUSTOM_35 (dir)

metagame.input.binds.actions.CUSTOM_35.secondary (string)

metagame.input.binds.actions.CUSTOM_35.nickname (string)

metagame.input.binds.actions.CUSTOM_35.primary (string)

metagame.input.binds.actions.CUSTOM_34 (dir)

metagame.input.binds.actions.CUSTOM_34.secondary (string)

metagame.input.binds.actions.CUSTOM_34.nickname (string)

metagame.input.binds.actions.CUSTOM_34.primary (string)

metagame.input.binds.actions.CUSTOM_38 (dir)

metagame.input.binds.actions.CUSTOM_38.secondary (string)

metagame.input.binds.actions.CUSTOM_38.nickname (string)

metagame.input.binds.actions.CUSTOM_38.primary (string)

metagame.input.binds.actions.CUSTOM_32 (dir)

metagame.input.binds.actions.CUSTOM_32.secondary (string)

metagame.input.binds.actions.CUSTOM_32.nickname (string)

metagame.input.binds.actions.CUSTOM_32.primary (string)

metagame.input.binds.actions.CUSTOM_28 (dir)

metagame.input.binds.actions.CUSTOM_28.secondary (string)

metagame.input.binds.actions.CUSTOM_28.nickname (string)

metagame.input.binds.actions.CUSTOM_28.primary (string)

metagame.input.binds.actions.CUSTOM_27 (dir)

metagame.input.binds.actions.CUSTOM_27.secondary (string)

metagame.input.binds.actions.CUSTOM_27.nickname (string)

metagame.input.binds.actions.CUSTOM_27.primary (string)

metagame.input.binds.actions.CUSTOM_26 (dir)

metagame.input.binds.actions.CUSTOM_26.secondary (string)

metagame.input.binds.actions.CUSTOM_26.nickname (string)

metagame.input.binds.actions.CUSTOM_26.primary (string)

metagame.input.binds.actions.CUSTOM_25 (dir)

metagame.input.binds.actions.CUSTOM_25.secondary (string)

metagame.input.binds.actions.CUSTOM_25.nickname (string)

metagame.input.binds.actions.CUSTOM_25.primary (string)

metagame.input.binds.actions.CUSTOM_24 (dir)

metagame.input.binds.actions.CUSTOM_24.secondary (string)

metagame.input.binds.actions.CUSTOM_24.nickname (string)

metagame.input.binds.actions.CUSTOM_24.primary (string)

metagame.input.binds.actions.CUSTOM_11 (dir)

metagame.input.binds.actions.CUSTOM_11.secondary (string)

metagame.input.binds.actions.CUSTOM_11.nickname (string)

metagame.input.binds.actions.CUSTOM_11.primary (string)

metagame.input.binds.actions.CUSTOM_04 (dir)

metagame.input.binds.actions.CUSTOM_04.secondary (string)

metagame.input.binds.actions.CUSTOM_04.nickname (string)

metagame.input.binds.actions.CUSTOM_04.primary (string)

metagame.input.binds.actions.CUSTOM_37 (dir)

metagame.input.binds.actions.CUSTOM_37.secondary (string)

metagame.input.binds.actions.CUSTOM_37.nickname (string)

metagame.input.binds.actions.CUSTOM_37.primary (string)

metagame.input.binds.actions.CUSTOM_08 (dir)

metagame.input.binds.actions.CUSTOM_08.secondary (string)

metagame.input.binds.actions.CUSTOM_08.nickname (string)

metagame.input.binds.actions.CUSTOM_08.primary (string)

metagame.input.binds.actions.CUSTOM_06 (dir)

metagame.input.binds.actions.CUSTOM_06.secondary (string)

metagame.input.binds.actions.CUSTOM_06.nickname (string)

metagame.input.binds.actions.CUSTOM_06.primary (string)

metagame.input.binds.actions.CUSTOM_02 (dir)

metagame.input.binds.actions.CUSTOM_02.secondary (string)

metagame.input.binds.actions.CUSTOM_02.nickname (string)

metagame.input.binds.actions.CUSTOM_02.primary (string)

metagame.input.binds.actions.CUSTOM_23 (dir)

metagame.input.binds.actions.CUSTOM_23.secondary (string)

metagame.input.binds.actions.CUSTOM_23.nickname (string)

metagame.input.binds.actions.CUSTOM_23.primary (string)

metagame.input.binds.actions.CUSTOM_07 (dir)

metagame.input.binds.actions.CUSTOM_07.secondary (string)

metagame.input.binds.actions.CUSTOM_07.nickname (string)

metagame.input.binds.actions.CUSTOM_07.primary (string)

metagame.input.binds.actions.CUSTOM_10 (dir)

metagame.input.binds.actions.CUSTOM_10.secondary (string)

metagame.input.binds.actions.CUSTOM_10.nickname (string)

metagame.input.binds.actions.CUSTOM_10.primary (string)

metagame.input.binds.actions.CUSTOM_01 (dir)

metagame.input.binds.actions.CUSTOM_01.secondary (string)

metagame.input.binds.actions.CUSTOM_01.nickname (string)

metagame.input.binds.actions.CUSTOM_01.primary (string)

metagame.input.binds.actions.CUSTOM_29 (dir)

metagame.input.binds.actions.CUSTOM_29.secondary (string)

metagame.input.binds.actions.CUSTOM_29.nickname (string)

metagame.input.binds.actions.CUSTOM_29.primary (string)

metagame.input.binds.actions.CUSTOM_03 (dir)

metagame.input.binds.actions.CUSTOM_03.secondary (string)

metagame.input.binds.actions.CUSTOM_03.nickname (string)

metagame.input.binds.actions.CUSTOM_03.primary (string)

metagame.input.binds.actions.CUSTOM_16 (dir)

metagame.input.binds.actions.CUSTOM_16.secondary (string)

metagame.input.binds.actions.CUSTOM_16.nickname (string)

metagame.input.binds.actions.CUSTOM_16.primary (string)

metagame.input.binds.actions.CUSTOM_12 (dir)

metagame.input.binds.actions.CUSTOM_12.secondary (string)

metagame.input.binds.actions.CUSTOM_12.nickname (string)

metagame.input.binds.actions.CUSTOM_12.primary (string)

metagame.input.binds.actions.CUSTOM_30 (dir)

metagame.input.binds.actions.CUSTOM_30.secondary (string)

metagame.input.binds.actions.CUSTOM_30.nickname (string)

metagame.input.binds.actions.CUSTOM_30.primary (string)

metagame.input.binds.actions.CUSTOM_13 (dir)

metagame.input.binds.actions.CUSTOM_13.secondary (string)

metagame.input.binds.actions.CUSTOM_13.nickname (string)

metagame.input.binds.actions.CUSTOM_13.primary (string)

metagame.input.binds.actions.CUSTOM_31 (dir)

metagame.input.binds.actions.CUSTOM_31.secondary (string)

metagame.input.binds.actions.CUSTOM_31.nickname (string)

metagame.input.binds.actions.CUSTOM_31.primary (string)

metagame.input.binds.actions.CUSTOM_14 (dir)

metagame.input.binds.actions.CUSTOM_14.secondary (string)

metagame.input.binds.actions.CUSTOM_14.nickname (string)

metagame.input.binds.actions.CUSTOM_14.primary (string)

metagame.input.binds.actions.CUSTOM_20 (dir)

metagame.input.binds.actions.CUSTOM_20.secondary (string)

metagame.input.binds.actions.CUSTOM_20.nickname (string)

metagame.input.binds.actions.CUSTOM_20.primary (string)

metagame.input.binds.actions.CUSTOM_33 (dir)

metagame.input.binds.actions.CUSTOM_33.secondary (string)

metagame.input.binds.actions.CUSTOM_33.nickname (string)

metagame.input.binds.actions.CUSTOM_33.primary (string)

metagame.input.binds.actions.CUSTOM_05 (dir)

metagame.input.binds.actions.CUSTOM_05.secondary (string)

metagame.input.binds.actions.CUSTOM_05.nickname (string)

metagame.input.binds.actions.CUSTOM_05.primary (string)

metagame.input.binds.actions.CUSTOM_22 (dir)

metagame.input.binds.actions.CUSTOM_22.secondary (string)

metagame.input.binds.actions.CUSTOM_22.nickname (string)

metagame.input.binds.actions.CUSTOM_22.primary (string)

metagame.input.binds.actions.CUSTOM_17 (dir)

metagame.input.binds.actions.CUSTOM_17.secondary (string)

metagame.input.binds.actions.CUSTOM_17.nickname (string)

metagame.input.binds.actions.CUSTOM_17.primary (string)

metagame.input.binds.actions.CUSTOM_15 (dir)

metagame.input.binds.actions.CUSTOM_15.secondary (string)

metagame.input.binds.actions.CUSTOM_15.nickname (string)

metagame.input.binds.actions.CUSTOM_15.primary (string)

metagame.input.binds.actions.CUSTOM_09 (dir)

metagame.input.binds.actions.CUSTOM_09.secondary (string)

metagame.input.binds.actions.CUSTOM_09.nickname (string)

metagame.input.binds.actions.CUSTOM_09.primary (string)

metagame.input.binds.actions.CUSTOM_18 (dir)

metagame.input.binds.actions.CUSTOM_18.secondary (string)

metagame.input.binds.actions.CUSTOM_18.nickname (string)

metagame.input.binds.actions.CUSTOM_18.primary (string)

metagame.input.binds.actions.CUSTOM_19 (dir)

metagame.input.binds.actions.CUSTOM_19.secondary (string)

metagame.input.binds.actions.CUSTOM_19.nickname (string)

metagame.input.binds.actions.CUSTOM_19.primary (string)

metagame.input.binds.actions.CUSTOM_21 (dir)

metagame.input.binds.actions.CUSTOM_21.secondary (string)

metagame.input.binds.actions.CUSTOM_21.nickname (string)

metagame.input.binds.actions.CUSTOM_21.primary (string)

metagame.input.mouse (dir)

metagame.input.mouse.sensitivity (dir)
You can adjust the mouse sensitivity for the game (turning the player's head) and also for windows where there is a cursor. These are adjusted separately. Also, the x and y components of the sensitivity are set separately.

metagame.input.mouse.sensitivity.windows (dir)

metagame.input.mouse.sensitivity.windows.y (float)

metagame.input.mouse.sensitivity.windows.x (float)

metagame.input.mouse.sensitivity.game (dir)

metagame.input.mouse.sensitivity.game.invert_y (bool)

metagame.input.mouse.sensitivity.game.x (float)

metagame.input.mouse.sensitivity.game.y (float)

metagame.player (dir)

metagame.player.model (dir)
If 3rd person mode is enabled, these vars specify the Quake 2 character model used for the player's body. You must specify the md2 file itself (for the mesh and the animation frames) as well as the single texture associated to the mesh.

metagame.player.model.q2md2 (dir)

metagame.player.model.q2md2.tex (string)
The name of the jpg file to use for the player. For example, "Input/Q2MD2_Models/MODEL_NAME/MODEL_NAME.jpg".

metagame.player.model.q2md2.md2 (string)
The name of the md2 file to use for the player. For example, "Input/Q2MD2_Models/MODEL_NAME/MODEL_NAME.md2".

metagame.player.camera (dir)

metagame.player.camera.3rdp (dir)

metagame.player.camera.3rdp.enabled (bool)
If this is true, then instead of looking at the world from the player's perspective, we instead look at the player from slightly behind him. This is intended for games with gravity.

display (dir)

display.fullscreen (bool)
Whether or not the program is run on fullscreen or windowed mode.

display.has_inner_focus (bool)
This is true when the program's window is in focus (in the sense of the operating system) and the user has clicked in the body of the program's window. The point is when this is true, the (system) mouse cursor is hidden. Note that the user can resize the game's window (if the game is being run in windowed mode) without the cursor being hidden.

display.hud (dir)

display.hud.show_dir (bool)
Normally, when the viewer turns towards one of the 6 cardinal directions, either "UP", "DOWN", "LEFT", "RIGHT", "FRONT", or "BACK" will be displayed. However when this var is set to false, the displaying of this text is disabled.

display.hud.hide_all_huds (bool)
When this is true, the system hud (on the upper half of the screen) is not rendered, and the package defined hud windows (on the lower half of the screen) are not rendered (or updated) either. This is intended for taking a screenshot of the world.

display.hud.show_loading_graph_in_menus (bool)
Even when the player is in a menu (even the main menu), the "exploration" process continues. This is the process of creating and destroying chunks. When this var is set to true, a graph showing the progress of this process is displayed in the main menu.

display.hud.diegetic (dir)

display.hud.diegetic.scale_y (float)
The (diegetic) HUD is scaled in the y direction by this factor.

display.hud.diegetic.scale_x (float)
The (diegetic) HUD is scaled in the x direction by this factor.

display.hud.diegetic.use (bool)
When this is true, the HUD is rendered in the world as opposed on the screen on top of the world. This var should not be used by the user: it is set internally by the engine. See also display.stereoscope.use_diegetic_hud.

display.hud.diegetic.dist (float)
The distance from the camera to the plane that contains the (diegetic) HUD.

display.hud.msg (dir)
The "hud message" is what shows up in the center of the screen, above the crosshairs, to display a message to the user. There can only be one hud message at a time, and the last hud message only lasts for a certain amount of time.

display.hud.msg.color (vector)
The color of the text of the hud message.

display.hud.msg.back_alpha (float)
The alpha of the background behind the hud message.

display.hud.msg.back_color (vector)
The color of the background behind the hud message.

display.hud.side_displays (dir)
On the upper left and upper right of the screen there are displays showing things like frame rate or what level the player is on. These are called "side displays". This displays are read in from Lua files stored in Data/Packages/base/Windows/HUD/SideDisplays/ and Input/HUD/SideDisplays.

display.hud.side_displays.state (string)

display.hud.side_displays.width (float)

display.hud.side_displays.height (float)
The width of each side display. 1.0 is the distance from the left of the screen to the right.

display.hud.attack_display (dir)
The attack display shows colored circles in the center of the screen when the player is hit by enemy attacks. The location of the circle depends on where the attack came from. The size of the circle represents the damage done by the attack.

display.hud.attack_display.screen_x_stretch (float)
The factor by which to stretch the entire attack display in the x direction. Note: the screen is 1.0 wide, and 1.0 high.

display.hud.attack_display.type (string)
This var should be set to either "sphere" or "cylinder". Use the sphere type for a 6 degrees of freedom package.

display.hud.attack_display.keep_time (float)
How many seconds an attack circle stays on the screen, before it turns invisible and disappears.

display.hud.attack_display.enable (bool)
This var represents whether or not the attack display should be shown.

display.hud.attack_display.dot_radius (float)
The radius of an attack circle is proportional to this var times the damage done by the attack.

display.hud.attack_display.90_deg_radius (float)
The distance from the center of the screen attack circles are displayed which come from attacks that are 90 degrees from where the player is looking.

display.hud.attack_display.color (vector)
The color of the attack circles.

display.hud.crosshair (dir)
The crosshair texture is called "crosshair". So, you can change the crosshair texture by changing the file associated to the "crosshair" texture name in "Data/PACKAGE/Textures/texture_names.txt".

display.hud.crosshair.hide (bool)
If true, the crosshair will not be shown.

display.hud.crosshair.x_scale (float)
The size of the crosshair in the x direction is this var times display.hud.crosshair.scale.

display.hud.crosshair.color (vector)
The color to shade the crosshair texture.

display.hud.crosshair.scale (float)
The size of the crosshair, in the y direction.

display.screen (dir)

display.screen.height (int)
This is like display.screen.width, but for the height instead.

display.screen.width (int)
The current screen width in pixels.

display.stereoscope (dir)

display.stereoscope.red_on_left (bool)
If this is true, then the left eye is rendered to the red channel.

display.stereoscope.only_render_left (bool)
This is just for debugging. During stereoscopic mode, if this var is true then only the left camera is used for rendering.

display.stereoscope.dist_between_eyes (float)
The distance between the two cameras when stereoscopic rendering occurs. Note: each block is 1.0 wide.

display.stereoscope.3d_red_blue_glasses_enabled (bool)
If true, then two images will be rendered (from slightly different camera positions). One will be rendered in red, and the other in blue.

display.stereoscope.elastic_accum (float)
This is a helper variable that is used internally to update elastic_scale.

display.stereoscope.use_diegetic_hud (bool)
When the game renders in stereoscopic mode, this var specfies whether or not the HUD is diegetic (is suspended in front of the player in the world).

display.stereoscope.elastic_scale (float)
This will gradually return to the value of 1.0 when it is changed. This is used make the distance between eye change less abrupt when the player shrinks or grows.

display.stereoscope.elastic_recovery (float)
This dictates how quickly elastic_scale recovers. A high number means faster recovery. 0.1 is very fast, and 0.05 is medium speed.

display.screen_mode (dir)

display.screen_mode.windowed (dir)

display.screen_mode.windowed.height (int)
This is like display.screen_mode.windowed.width, but for the height instead.

display.screen_mode.windowed.width (int)
The requested windowed width in pixels. When using windowed mode, the program will try using this width, unless display.screen.use_desktop_res is true.

display.screen_mode.windowed.pos (dir)

display.screen_mode.windowed.pos.y (int)
The last y coordinate position of the window when it was in windowed mode.

display.screen_mode.windowed.pos.x (int)
The last x coordinate position of the window when it was in windowed mode.

display.screen_mode.fullscreen (dir)

display.screen_mode.fullscreen.height (int)
This is like display.screen_mode.fullscreen.width, but for the height instead.

display.screen_mode.fullscreen.use_desktop_res (bool)
If true (and display.fullscreen is true), then the desktop resolution will be used for setting the vars display.screen.width and display.screen.height. If false, the vars display.screen_mode.fullscreen.width and display.screen_mode.fullscreen.height will be used instead.

display.screen_mode.fullscreen.width (int)
The requested fullscreen width in pixels. When using fullscreen mode, the program will try using this width, unless display.screen_mode.fullscreen.use_desktop_res is true.

display.camera_params (dir)

display.camera_params.vfov (float)
This is the "vertical field of view" of the game's camera.

display.camera_params.a_ratio (dir)

display.camera_params.a_ratio.use_screen_resolution (bool)
If this is set to true, then the variable display.camera_params.a_ratio.value will be set to the screen width divided by the screen height.

display.camera_params.a_ratio.value (float)
Let the aratio be the value of this var. Let vfov be the value of display.camera_params.vfov. The hfov (horizontal field of view) is set to vfov * aratio. The world is rendered using the vfov and the hfov.

display.screenshot (dir)

display.screenshot.display_msg (bool)

display.screenshot.last_ss_used_steam (bool)

display.screenshot.fn_ext (string)
This should be either "jpg" or "png". This specifies the filetype of screenshots that are generated.

display.screenshot.use_steam (bool)
If true, then the Steam API will be used to take screenshots when Steam is running. Otherwise, the game will use its own function to take screenshots.

sound (dir)

sound.rep_required_delta (float)
When two identical sounds are played very close to each other in time, the second one will not be played. This var specifies how long we have to wait after the first sound before the second can be played.

sound.global_volume (float)
The sound volume. This should be between 0.0 and 1.0.

engine (dir)

engine.exit_on_error (bool)
Some program errors will not cause the program to exit. However if this var is true, then when the program encounters many of these errors it will exit explicitly.

engine.soft_loading (bool)
When this is true, when the player reloads the game, the engine will not reload certain package data (such as basic entities and moving entities). That is, the engine will retain certain package data between loads.

engine.constant_saving (bool)
If either of the vars engine.constant_saving or game.constant_saving are true, then the game will be saved every few seconds automatically.

engine.load_stage (string)

engine.last_loaded_player (string)

engine.version (string)
The version of the program. An example would be "0.92.0".

engine.error (dir)

engine.error.thread_inf_loop (dir)

engine.error.thread_inf_loop.chunk_name (string)
The name of the chunk being processed by a thread that is not responding.

engine.error.thread_inf_loop.occured (bool)
When true, one of the threads responsible for procedural world generation is not responding. There is no safe way to kill a thread that is not responding, so when this error occurs the program must quit.

engine.ments (dir)

engine.ments.disable_updates (bool)
When true, the engine will NOT perform any update functions on moving entities.

engine.ments.disable_rendering (bool)
When true, the engine will NOT render moving entities.

engine.worldgen (dir)

engine.worldgen.save_input (bool)
When this is true, the input used to generate a chunk is saved in the corresponding chunk file. See also "engine.worldgen.save_input". If use_saved_input is true, then this var save_input should be true as well.

engine.worldgen.use_saved_input (bool)
When a chunk is procedurally generated, this processes uses certain input (such as the block type of the chunk being generated. When use_saved_input is true, then 1) when we create a chunk we store the input used in a chunk file and 2) when later we recreate the same chunk, we can just use the saved input. This is useful because acquiring the input would otherwise result in a chain reaction where we need to create the entire chunk tree from the root up until the target chunk we want to generate. So in situations where we are thousands of levels deep in the chunk tree, setting use_saved_input to true is a huge speed improvement.

engine.worldgen.num_threads (int)
The number of threads used for procedural world generation. When this is zero, the main thread does all the procedural world generation. When this is n > 0, then the main thread does not do procedural world generation but instead n worker threads do the job. In the case of a fatal error in the procedural world generation code, it is better for num_threads to be zero. This var should be set before the program starts. Changing the var while the program is running will have no effect.

engine.worldgen.num_load_threads (int)
Loading a chunk consists of 3 parts: 1) procedurally generating it, 2) loading's its chunk file (if it has one), and 3) perorming pre-processing so the main thread does not have to. The number of threads that do task 1) is controlled by engine.worldgen.num_threads (and this is the majority of the work). The number of threads that together do tasks 2 and 3 is controlled by this variable: engine.worldgen.num_load_threads.

engine.render (dir)

engine.render.max_frames_per_sec (int)

engine.render.handle_visray_false (string)
This specifies what should happen to chunks that DO intersect the view frustum but ARE NOT render relevant. If this var is set to "cocoon_render", then the block that occupies the same space as the chunk is rendered. This looks fine and is pretty fast. This should be the typical setting, and often the chunk is a proto chunk anyway so no rendering detail is lost. If this var is set to "full_render", then the chunk is rendered fully. This is very slow. If this var is set to "no_render", then the chunk is not rendered at all (not even as a block). This looks awful, but is fast.

engine.render.disable_world (bool)
When true, the engine will NOT render the world, including all entities inside the world.

engine.render.opengl (dir)

engine.render.opengl.no_shaders_on_typical (bool)
Consider typical rendering (no red/blue glasses mode). If this var is true, then during typical rendering no custom shaders are used (rendering uses the "fixed function pileline"). This var does not affect red/blue glasses mode, because in this mode shaders are required to render to grayscale.

engine.render.rr (dir)
rr stands for "render relevant". Let X = the value of engine.render.rr.created_time. Let Y = the value of engine.render.rr.visray_hit_interval. A chunk is render relevant iff either it has been created (added to the chunk tree) within the last X seconds, or it has been hit by a visray within the last Y seconds.

engine.render.rr.visray_hit_time (float)
10.0 is a good value for this.

engine.render.rr.created_time (float)
3.0 is a good value for this.

engine.save (dir)

engine.save.dyn_vars (dir)

engine.save.dyn_vars.num_next (int)
During a save, after num_first many dynamic variables are stored synchronously, during each subsequent frame num_next many dynamic variables are saved. This allows the player to continue playing the game why the game is being saved. We recommend a value of 5000 for this variable. If this variable is not positive, it will be set to 5000.

engine.save.dyn_vars.num_first (int)
When the game is saved, this number of dynamic variables are initially saved. We recommend a value of 20,000 for this variable. To have ALL variables saved synchronously, set this variable to -1. See also "engine.save.dyn_vars.num_next".

engine.visray (dir)
Every second, many visibility rays (visrays) are shot from the player's location. The purpose is to try to determine what chunks are visible from the player's position. Only chunks hit by a visray within the recent past are rendered, or updated.

engine.visray.update_interval (float)
After each time a chunk is hit by a visray, we will preform update functions for the chunk (for ments, particles, etc) for at least engine.visray.update_interval many seconds.

engine.visray.enabled (bool)
If fase, then no visrays are shot out and no system in the engine excepts visrays to hit chunks.

engine.visray.rays_per_sec (int)
The number of visrays shot from the player's position per second. Although visrays are shot in all directions, more are focused towards the direction where the player is looking.

engine.cutting (dir)

engine.cutting.enabled (bool)
Currently, this engine is not doing any "cutting".

engine.textures (dir)
Textures are loaded lazily in this program. That is, when a texture is needed, we either loaded it then and there (synchronously) or we load it asyncronously. When a texture is loaded asyncronously, then until we have the texture, we either use in place of it a black texture or a goofy pretty texture.

engine.textures.delete_time (float)
If a texture has been loaded but has not been used for this amount of time, then we delete it from memory. It can always be reloaded later if needed.

engine.textures.use_not_loaded_pretty_tex (bool)
Whether or not we should use a goofy pretty texture, instead of a black texture, while we are waiting to load a texture asyncronously.

engine.textures.async (bool)
Whether or not textures should be loaded synchronously or asyncronously.

engine.textures.pixel_load_per_frame (int)
How many pixels can be loaded synchronously in a frame before we must load the remaining textures asyncronously.

engine.surfaces (dir)

engine.surfaces.show_quad_algorithm (bool)
The "quad algorithm" is what I am calling the algorithm I invented when working on Infinifrag 2 to greedily merge surface m by n quads together for rendering a block world. When this var is true, these individual quads are shown (before a vertex buffer object for the chunk is created).

engine.lua (dir)

engine.lua.check_args (bool)
Then this is true, whenever a Lua script calls a C++ API function, the C++ side will check that 1) the number of arguments is correct, 2) no argument is nil, and 3) every argument is of the correct type. We highly recommend setting this variable to true. If it is false, the program will hard crash if Lua calls a C++ API function incorrectly.

engine.lua.rogue_global_watchdog (bool)
In the Lua programming language, within a function you must put the keyword "local" before a declaration otherwise it will be global. If this watchdog variable is set to true, then every so often the system will look for global Lua variables that should not exist. If it finds any, then it exits the program.

engine.bents (dir)

engine.bents.disable_rendering (bool)
When true, the engine will NOT render basic entities.

engine.particles (dir)

engine.particles.disable (bool)
When true, particle effects will not be rendered, and particles will not be updated.

engine.particles.min_dist (float)
Certain particle effects in the game have the "use min distance" property. These particle effects will not create particles that are within min_dist of the player.

engine.particles.sort_period (float)
Every so often, particles are sorted by their distance to the player. This var specifies how many seconds between times at which we sort.

engine.particles.throttle (dir)
Once there are too many particles in the world, whenever a new particle is requested to be created, it will only actually be created with a small probability P. Let V = "engine.particles.trottle". If the number of particles is between V.1.num and V.2.num, the probability P is V.1.frac. If the number of particles is between V.2.num and V.3.num, the probability P is V.2.frac. Finally, if the number of particles is over V.3.num, the probability P is V.3.frac.

engine.particles.throttle.3 (dir)

engine.particles.throttle.3.frac (float)

engine.particles.throttle.3.num (int)

engine.particles.throttle.1 (dir)

engine.particles.throttle.1.frac (float)

engine.particles.throttle.1.num (int)

engine.particles.throttle.2 (dir)

engine.particles.throttle.2.frac (float)

engine.particles.throttle.2.num (int)

engine.rayalg (dir)

engine.rayalg.disable (bool)
The ray algorithm is what is used when an entity is moved through the world and we need to find what it collides with. When this var is true, the engine disables this algorithm (so no collisions are detected).

engine.chunks (dir)

engine.chunks.show_proto_chunks (bool)
When a chunk is first added to the chunk tree, it is an empty shell: a proto chunk. Only later is it populated. If this var is set to true, then instead of rendering a solid proto chunk normally, it is rendered using a special texture to show that it is a proto chunk.

engine.chunks.show_chunk_lines (bool)
If true, then around each chunk in the active chunk tree will be drawn a wireframe cube.

engine.requests (dir)

engine.requests.type (string)

engine.requests.load_game (dir)

engine.requests.load_game.first_time (bool)

engine.requests.load_game.player_name (string)

engine.exploration (dir)

engine.exploration.last_force_recalc ()

engine.exploration.tethered (bool)
Normally when the user moves from one chunk to the next, all chunks on that level shift so that the following is always true: the chunk that contains the center point of the player is the central chunk for that level. However when this var is set to false, this shifting does NOT occur.

engine.exploration.disable (bool)
Exploration is the process of adding and removing chunks from the active chunk tree as the user moves through the world. When this var is true, the engine will NOT perform exploration.

engine.exploration.bait_and_switch (bool)
When true, will do all the work to create a chunk, but at the last minute (just before we populate the chunk in the chunk tree) we remove everything from the populate data except blocks).

engine.exploration.fertile_radius (dir)
The fertile radius of the viewer level is "engine.exploration.fertile_radius.0". The radius of viewer level - 1 is "engine.exploration.fertile_radius.1", etc. The default values for these are the maximum of 3 and the level radius. Also, they should all be at least 1. The fertile radius of a level specifies how far away from the viewer that chunks can contain entities other than blocks.

engine.exploration.fertile_radius.9 (int)

engine.exploration.fertile_radius.8 (int)

engine.exploration.fertile_radius.7 (int)

engine.exploration.fertile_radius.6 (int)

engine.exploration.fertile_radius.5 (int)

engine.exploration.fertile_radius.0 (int)

engine.exploration.fertile_radius.1 (int)

engine.exploration.fertile_radius.3 (int)

engine.exploration.fertile_radius.2 (int)

engine.exploration.fertile_radius.4 (int)

engine.exploration.level_radius (dir)
The radius of the viewer level is "engine.exploration.level_radius.0". The radius of viewer level - 1 is "engine.exploration.level_radius.1", etc. The default values for these are 3,3,2,1,0,0,0,0,0...The radius of a level specifies how far away from the viewer that chunks can be created and maintained.

engine.exploration.level_radius.9 (int)

engine.exploration.level_radius.8 (int)

engine.exploration.level_radius.7 (int)

engine.exploration.level_radius.6 (int)

engine.exploration.level_radius.5 (int)

engine.exploration.level_radius.0 (int)

engine.exploration.level_radius.1 (int)

engine.exploration.level_radius.3 (int)

engine.exploration.level_radius.2 (int)

engine.exploration.level_radius.4 (int)

game (dir)
When a game is loaded, variables will be added here. When a game is closed, these variables will be removed. There are a few exceptions: a few variables need to exist here even if there is no game loaded. One such var is "game.state.world_loaded". Another is game.version.error.1.forced_preferred_engine_ver.

game.constant_saving (bool)

game.globals (dir)
These are vars created by the package, as opposed to "system" game vars.

game.globals.temp (dir)

game.globals.temp.hurt_sound_cooldown_6_2 (float)

game.globals.temp.hurt_sound_cooldown_7_1 (float)

game.globals.temp.hurt_sound_cooldown_2_2 (float)

game.globals.temp.hurt_sound_cooldown_2_1 (float)

game.globals.temp.hurt_sound_cooldown_1_2 (float)

game.globals.temp.hurt_sound_cooldown_1_1 (float)

game.globals.temp.hurt_sound_cooldown_3_1 (float)

game.globals.temp.hurt_sound_cooldown_7_2 (float)

game.globals.temp.hurt_sound_cooldown_5_1 (float)

game.globals.temp.hurt_sound_cooldown_3_2 (float)

game.globals.temp.hurt_sound_cooldown_4_2 (float)

game.globals.temp.hurt_sound_cooldown_4_1 (float)

game.globals.temp.hurt_sound_cooldown_5_2 (float)

game.globals.temp.hurt_sound_cooldown_6_1 (float)

game.globals.xar (dir)

game.globals.xar.normal_bent_touch_dist (float)

game.globals.xar.rocket_mode (bool)

game.globals.xar.emp_end_time (float)

game.globals.xar.damage_5x_stacking_time ()

game.globals.xar.xp_5x_stacking_time ()

game.globals.xar.first_life (bool)

game.globals.xar.invun_stacking_time ()

game.globals.xar.movement (dir)

game.globals.xar.movement.extra_impulse (vector)

game.globals.xar.movement.forward (bool)

game.globals.xar.movement.up (bool)

game.globals.xar.movement.back (bool)

game.globals.xar.movement.spin_cw (bool)

game.globals.xar.movement.spin_value (float)

game.globals.xar.movement.left (bool)

game.globals.xar.movement.rocket (bool)

game.globals.xar.movement.spin_ccw (bool)

game.globals.xar.movement.right (bool)

game.globals.xar.movement.down (bool)

game.globals.xar.movement.brake (bool)

game.globals.xar.door_unlocked (dir)

game.globals.xar.door_unlocked.hell (bool)

game.globals.xar.door_unlocked.i3 (bool)

game.globals.xar.door_unlocked.i1 (bool)

game.globals.xar.door_unlocked.burlington (bool)

game.globals.xar.door_unlocked.i2 (bool)

game.globals.xar.difficulty (dir)

game.globals.xar.difficulty.hard_4_once (bool)

game.globals.xar.difficulty.hard_4 (bool)

game.globals.xar.difficulty.hard_3_once (bool)

game.globals.xar.difficulty.hard_3 (bool)

game.globals.xar.difficulty.easy_1 (bool)

game.globals.xar.difficulty.hard_2_once (bool)

game.globals.xar.difficulty.hardcore (bool)

game.globals.xar.difficulty.locked_in (bool)

game.globals.xar.difficulty.easy_2_once (bool)

game.globals.xar.difficulty.easy_1_once (bool)

game.globals.xar.difficulty.hard_1_once (bool)

game.globals.xar.difficulty.hard_1 (bool)

game.globals.xar.difficulty.easy_2 (bool)

game.globals.xar.difficulty.normal (bool)

game.globals.xar.difficulty.normal_once (bool)

game.globals.xar.difficulty.hard_2 (bool)

game.globals.xar.difficulty.curve (dir)

game.globals.xar.difficulty.curve.enabled (bool)

game.globals.xar.difficulty.curve.player_in_damage (dir)

game.globals.xar.difficulty.curve.player_in_damage.last_time ()

game.globals.xar.difficulty.curve.player_in_damage.total (int)

game.globals.xar.inv_exec (dir)

game.globals.xar.inv_exec.wep_script_last_wep (int)

game.globals.xar.inv_exec.primary (bool)

game.globals.xar.inv_exec.cur_wep (int)

game.globals.xar.inv_exec.starting_shoot (bool)

game.globals.xar.inv_exec.last_fire_time ()

game.globals.xar.inv_exec.wep_script_in (bool)

game.globals.xar.player (dir)

game.globals.xar.player.tracking_marker_dist ()

game.globals.xar.player.tracking_marker_dir (vector)

game.globals.xar.player.cheat_comon_markers (bool)

game.globals.xar.player.tracking_marker (int)

game.globals.xar.player.tracking_marker_hide (bool)

game.globals.xar.player.tracking_marker_last_id (int)

game.globals.xar.player.tracking_marker_path (string)

game.globals.xar.player.cur_wep (int)

game.globals.xar.player.tracking_marker_last_time ()

game.globals.xar.player.gun8 (dir)

game.globals.xar.player.gun8.last_last_mode (int)

game.globals.xar.player.gun8.ammo_level (int)

game.globals.xar.player.gun8.ammo (int)

game.globals.xar.player.gun8.last_mode (int)

game.globals.xar.player.gun8.freeze_time_level (int)

game.globals.xar.player.gun8.last_sound_time (float)

game.globals.xar.player.gun8.damage_level (int)

game.globals.xar.player.gun8.radius_level (int)

game.globals.xar.player.gun8.mode2 (dir)

game.globals.xar.player.gun8.mode2.equipped (bool)

game.globals.xar.player.gun8.mode2.has (bool)

game.globals.xar.player.gun8.mode1 (dir)

game.globals.xar.player.gun8.mode1.equipped (bool)

game.globals.xar.player.gun8.mode1.has (bool)

game.globals.xar.player.gun7 (dir)

game.globals.xar.player.gun7.last_last_mode (int)

game.globals.xar.player.gun7.ammo_level (int)

game.globals.xar.player.gun7.ammo (int)

game.globals.xar.player.gun7.fire_period_level (int)

game.globals.xar.player.gun7.last_mode (int)

game.globals.xar.player.gun7.damage_level (int)

game.globals.xar.player.gun7.mode4 (dir)

game.globals.xar.player.gun7.mode4.equipped (bool)

game.globals.xar.player.gun7.mode4.has (bool)

game.globals.xar.player.gun7.mode3 (dir)

game.globals.xar.player.gun7.mode3.equipped (bool)

game.globals.xar.player.gun7.mode3.has (bool)

game.globals.xar.player.gun7.mode1 (dir)

game.globals.xar.player.gun7.mode1.equipped (bool)

game.globals.xar.player.gun7.mode1.has (bool)

game.globals.xar.player.gun7.mode2 (dir)

game.globals.xar.player.gun7.mode2.equipped (bool)

game.globals.xar.player.gun7.mode2.has (bool)

game.globals.xar.player.gun0 (dir)

game.globals.xar.player.gun0.last_last_mode (int)

game.globals.xar.player.gun0.charge (int)

game.globals.xar.player.gun0.start_shoot_time (float)

game.globals.xar.player.gun0.ammo_level (int)

game.globals.xar.player.gun0.ammo (int)

game.globals.xar.player.gun0.speed_level (int)

game.globals.xar.player.gun0.damage_level (int)

game.globals.xar.player.gun0.last_mode (int)

game.globals.xar.player.gun0.mode2 (dir)

game.globals.xar.player.gun0.mode2.equipped (bool)

game.globals.xar.player.gun0.mode2.has (bool)

game.globals.xar.player.gun0.mode1 (dir)

game.globals.xar.player.gun0.mode1.equipped (bool)

game.globals.xar.player.gun0.mode1.has (bool)

game.globals.xar.player.gun6 (dir)

game.globals.xar.player.gun6.last_last_mode (int)

game.globals.xar.player.gun6.last_mode (int)

game.globals.xar.player.gun6.num_level (int)

game.globals.xar.player.gun6.speed_level (int)

game.globals.xar.player.gun6.damage_level (int)

game.globals.xar.player.gun6.ammo_level (int)

game.globals.xar.player.gun6.ammo (int)

game.globals.xar.player.gun6.fire_period_level (int)

game.globals.xar.player.gun6.mode2 (dir)

game.globals.xar.player.gun6.mode2.equipped (bool)

game.globals.xar.player.gun6.mode2.has (bool)

game.globals.xar.player.gun6.mode1 (dir)

game.globals.xar.player.gun6.mode1.equipped (bool)

game.globals.xar.player.gun6.mode1.has (bool)

game.globals.xar.player.gun9 (dir)

game.globals.xar.player.gun9.last_last_mode (int)

game.globals.xar.player.gun9.last_mode (int)

game.globals.xar.player.gun9.ammo_level (int)

game.globals.xar.player.gun9.ammo (int)

game.globals.xar.player.gun9.speed_level (int)

game.globals.xar.player.gun9.damage_level (int)

game.globals.xar.player.gun9.radius_level (int)

game.globals.xar.player.gun9.mode3 (dir)

game.globals.xar.player.gun9.mode3.equipped (bool)

game.globals.xar.player.gun9.mode3.has (bool)

game.globals.xar.player.gun9.mode1 (dir)

game.globals.xar.player.gun9.mode1.equipped (bool)

game.globals.xar.player.gun9.mode1.has (bool)

game.globals.xar.player.gun9.mode2 (dir)

game.globals.xar.player.gun9.mode2.equipped (bool)

game.globals.xar.player.gun9.mode2.has (bool)

game.globals.xar.player.armor (dir)

game.globals.xar.player.armor.regen (float)

game.globals.xar.player.armor.regen_level (int)

game.globals.xar.player.armor.counter (float)

game.globals.xar.player.armor.amount (int)

game.globals.xar.player.armor.max (int)

game.globals.xar.player.arcade (dir)

game.globals.xar.player.arcade.inside (bool)

game.globals.xar.player.arcade.ammo (dir)

game.globals.xar.player.arcade.ammo.0 (int)

game.globals.xar.player.arcade.ammo.9 (int)

game.globals.xar.player.arcade.ammo.8 (int)

game.globals.xar.player.arcade.ammo.7 (int)

game.globals.xar.player.arcade.ammo.2 (int)

game.globals.xar.player.arcade.ammo.4 (int)

game.globals.xar.player.arcade.ammo.1 (int)

game.globals.xar.player.arcade.ammo.3 (int)

game.globals.xar.player.arcade.ammo.6 (int)

game.globals.xar.player.arcade.ammo.5 (int)

game.globals.xar.player.hive_attack (dir)

game.globals.xar.player.hive_attack.last_time (float)

game.globals.xar.player.hive_attack.meter (float)

game.globals.xar.player.markers (dir)

game.globals.xar.player.markers.num_short (int)

game.globals.xar.player.health (dir)

game.globals.xar.player.health.regen_level (int)

game.globals.xar.player.health.extra_regen (float)

game.globals.xar.player.health.extra_regen_level (int)

game.globals.xar.player.health.amount (int)

game.globals.xar.player.health.regen (float)

game.globals.xar.player.health.level (int)

game.globals.xar.player.health.counter (float)

game.globals.xar.player.health.max (int)

game.globals.xar.player.health.too_much_counter (float)

game.globals.xar.player.trophy (dir)

game.globals.xar.player.trophy.alpha_cube (bool)

game.globals.xar.player.trophy.apple_tree (bool)

game.globals.xar.player.trophy.credits (bool)

game.globals.xar.player.trophy.amethyst_maze (bool)

game.globals.xar.player.trophy.emerald (bool)

game.globals.xar.player.trophy.topaz (bool)

game.globals.xar.player.trophy.edge_of_world (bool)

game.globals.xar.player.trophy.sponge_beta (bool)

game.globals.xar.player.trophy.sponge_alpha (bool)

game.globals.xar.player.trophy.black_cube (bool)

game.globals.xar.player.trophy.small_black_flower (bool)

game.globals.xar.player.trophy.moon_ice (bool)

game.globals.xar.player.trophy.williston_caves (bool)

game.globals.xar.player.trophy.williston (bool)

game.globals.xar.player.trophy.bristol (bool)

game.globals.xar.player.trophy.raspberry (bool)

game.globals.xar.player.trophy.mylantis (bool)

game.globals.xar.player.trophy.lighthouse (bool)

game.globals.xar.player.trophy.green_apple_club (bool)

game.globals.xar.player.trophy.hell_flower (bool)

game.globals.xar.player.trophy.library_i1 (bool)

game.globals.xar.player.trophy.river (bool)

game.globals.xar.player.trophy.denver (bool)

game.globals.xar.player.trophy.botany_lab_6 (bool)

game.globals.xar.player.trophy.botany_lab_5 (bool)

game.globals.xar.player.trophy.red_maze_flower (bool)

game.globals.xar.player.trophy.willow_tree (bool)

game.globals.xar.player.trophy.inner_core (bool)

game.globals.xar.player.trophy.zube_castle (bool)

game.globals.xar.player.trophy.botany_lab_3 (bool)

game.globals.xar.player.trophy.botany_lab_2 (bool)

game.globals.xar.player.trophy.ying_tower (bool)

game.globals.xar.player.trophy.blue_bubble (bool)

game.globals.xar.player.trophy.health_tower (bool)

game.globals.xar.player.trophy.willow_tree_dark (bool)

game.globals.xar.player.trophy.infinity_flower (bool)

game.globals.xar.player.trophy.blue_bubble_breach (bool)

game.globals.xar.player.trophy.burlington_cols (bool)

game.globals.xar.player.trophy.tweed_cave (bool)

game.globals.xar.player.trophy.catacombs (bool)

game.globals.xar.player.trophy.ying_island_3 (bool)

game.globals.xar.player.trophy.blue_mushroom (bool)

game.globals.xar.player.trophy.ying_flower (bool)

game.globals.xar.player.trophy.ying_island_2 (bool)

game.globals.xar.player.trophy.library_ying (bool)

game.globals.xar.player.trophy.wig_prison (bool)

game.globals.xar.player.trophy.moon_beta (bool)

game.globals.xar.player.trophy.tau_caves_map (bool)

game.globals.xar.player.trophy.salmon_mushroom (bool)

game.globals.xar.player.trophy.sapphire_maze (bool)

game.globals.xar.player.trophy.jericho (bool)

game.globals.xar.player.trophy.small_cannon_pyramid (bool)

game.globals.xar.player.trophy.blackberry (bool)

game.globals.xar.player.trophy.ice_cube (bool)

game.globals.xar.player.trophy.botany_lab_4 (bool)

game.globals.xar.player.trophy.noob_flower (bool)

game.globals.xar.player.trophy.cactus (bool)

game.globals.xar.player.trophy.orange (bool)

game.globals.xar.player.trophy.richmond (bool)

game.globals.xar.player.trophy.stoney_cave_3 (bool)

game.globals.xar.player.trophy.ying_island_1 (bool)

game.globals.xar.player.trophy.large_cannon_pyramid (bool)

game.globals.xar.player.trophy.moon_alpha (bool)

game.globals.xar.player.trophy.desert_cave (bool)

game.globals.xar.player.trophy.emp_castle (bool)

game.globals.xar.player.trophy.ying_exit_maze (bool)

game.globals.xar.player.trophy.botany_lab_1 (bool)

game.globals.xar.player.trophy.richmond_sewers (bool)

game.globals.xar.player.trophy.small_yellow_flower (bool)

game.globals.xar.player.trophy.stoney_cave_2 (bool)

game.globals.xar.player.trophy.ying_island_4 (bool)

game.globals.xar.player.trophy.richmond_caves (bool)

game.globals.xar.player.trophy.stoney_cave_1 (bool)

game.globals.xar.player.trophy.toronto (bool)

game.globals.xar.player.trophy.toronto_underground (bool)

game.globals.xar.player.trophy.stoney_church (bool)

game.globals.xar.player.trophy.montreal (bool)

game.globals.xar.player.trophy.danville (bool)

game.globals.xar.player.trophy.aladdin_cave (bool)

game.globals.xar.player.trophy.small_blue_flower_1 (bool)

game.globals.xar.player.trophy.small_blue_flower_2 (bool)

game.globals.xar.player.trophy.mystic_vine (bool)

game.globals.xar.player.trophy.weed_rings (bool)

game.globals.xar.player.trophy.fanatic_spire (bool)

game.globals.xar.player.trophy.farmhouse (bool)

game.globals.xar.player.trophy.creeping_jeni (bool)

game.globals.xar.player.trophy.violets (bool)

game.globals.xar.player.trophy.planet_clay (bool)

game.globals.xar.player.trophy.library_i3 (bool)

game.globals.xar.player.trophy.moon_fire_rate (bool)

game.globals.xar.player.trophy.iolite (bool)

game.globals.xar.player.trophy.colchester (bool)

game.globals.xar.player.trophy.yellow_mushroom (bool)

game.globals.xar.player.trophy.jackfruit (bool)

game.globals.xar.player.trophy.large_white_flower (bool)

game.globals.xar.player.trophy.sun (bool)

game.globals.xar.player.trophy.desert_flower (bool)

game.globals.xar.player.trophy.jumbo_yellow_flower (bool)

game.globals.xar.player.trophy.black_mushroom (bool)

game.globals.xar.player.trophy.red_mushroom (bool)

game.globals.xar.player.trophy.tangerine (bool)

game.globals.xar.player.trophy.burlington (bool)

game.globals.xar.player.trophy.tegan_garden (bool)

game.globals.xar.player.trophy.library_space (bool)

game.globals.xar.player.trophy.library_i2 (bool)

game.globals.xar.player.trophy.moon_gamma (bool)

game.globals.xar.player.trophy.sponge_pure (bool)

game.globals.xar.player.trophy.ice_castle (bool)

game.globals.xar.player.trophy.moon_tau (bool)

game.globals.xar.player.trophy.planet_small_minigun (bool)

game.globals.xar.player.trophy.small_white_flower (bool)

game.globals.xar.player.trophy.laser_genesis (bool)

game.globals.xar.player.gold (dir)

game.globals.xar.player.gold.max (int)

game.globals.xar.player.gold.amount (int)

game.globals.xar.player.shield (dir)

game.globals.xar.player.shield.counter (float)

game.globals.xar.player.shield.amount (int)

game.globals.xar.player.shield.max (int)

game.globals.xar.player.gun1 (dir)

game.globals.xar.player.gun1.last_last_mode (int)

game.globals.xar.player.gun1.last_mode (int)

game.globals.xar.player.gun1.damage_level (int)

game.globals.xar.player.gun1.fire_period_level (int)

game.globals.xar.player.gun1.ammo_level (int)

game.globals.xar.player.gun1.ammo (int)

game.globals.xar.player.gun1.ammo_regen_level (int)

game.globals.xar.player.gun1.counter (float)

game.globals.xar.player.gun1.speed_level (int)

game.globals.xar.player.gun1.mode4 (dir)

game.globals.xar.player.gun1.mode4.equipped (bool)

game.globals.xar.player.gun1.mode4.has (bool)

game.globals.xar.player.gun1.mode3 (dir)

game.globals.xar.player.gun1.mode3.equipped (bool)

game.globals.xar.player.gun1.mode3.has (bool)

game.globals.xar.player.gun1.mode5 (dir)

game.globals.xar.player.gun1.mode5.equipped (bool)

game.globals.xar.player.gun1.mode5.has (bool)

game.globals.xar.player.gun1.mode1 (dir)

game.globals.xar.player.gun1.mode1.equipped (bool)

game.globals.xar.player.gun1.mode1.has (bool)

game.globals.xar.player.gun1.mode2 (dir)

game.globals.xar.player.gun1.mode2.equipped (bool)

game.globals.xar.player.gun1.mode2.has (bool)

game.globals.xar.player.gun3 (dir)

game.globals.xar.player.gun3.last_last_mode (int)

game.globals.xar.player.gun3.ammo_level (int)

game.globals.xar.player.gun3.ammo (int)

game.globals.xar.player.gun3.damage_level (int)

game.globals.xar.player.gun3.last_mode (int)

game.globals.xar.player.gun3.freeze_time_level (int)

game.globals.xar.player.gun3.num_level (int)

game.globals.xar.player.gun3.mode2 (dir)

game.globals.xar.player.gun3.mode2.equipped (bool)

game.globals.xar.player.gun3.mode2.has (bool)

game.globals.xar.player.gun3.mode1 (dir)

game.globals.xar.player.gun3.mode1.equipped (bool)

game.globals.xar.player.gun3.mode1.has (bool)

game.globals.xar.player.gun4 (dir)

game.globals.xar.player.gun4.last_last_mode (int)

game.globals.xar.player.gun4.last_mode (int)

game.globals.xar.player.gun4.radius_level (int)

game.globals.xar.player.gun4.speed_level (int)

game.globals.xar.player.gun4.damage_level (int)

game.globals.xar.player.gun4.ammo_level (int)

game.globals.xar.player.gun4.ammo (int)

game.globals.xar.player.gun4.fire_period_level (int)

game.globals.xar.player.gun4.mode4 (dir)

game.globals.xar.player.gun4.mode4.equipped (bool)

game.globals.xar.player.gun4.mode4.has (bool)

game.globals.xar.player.gun4.mode3 (dir)

game.globals.xar.player.gun4.mode3.equipped (bool)

game.globals.xar.player.gun4.mode3.has (bool)

game.globals.xar.player.gun4.mode5 (dir)

game.globals.xar.player.gun4.mode5.equipped (bool)

game.globals.xar.player.gun4.mode5.has (bool)

game.globals.xar.player.gun4.mode1 (dir)

game.globals.xar.player.gun4.mode1.equipped (bool)

game.globals.xar.player.gun4.mode1.has (bool)

game.globals.xar.player.gun4.mode2 (dir)

game.globals.xar.player.gun4.mode2.equipped (bool)

game.globals.xar.player.gun4.mode2.has (bool)

game.globals.xar.player.gun2 (dir)

game.globals.xar.player.gun2.last_last_mode (int)

game.globals.xar.player.gun2.last_mode (int)

game.globals.xar.player.gun2.num_level (int)

game.globals.xar.player.gun2.speed_level (int)

game.globals.xar.player.gun2.damage_level (int)

game.globals.xar.player.gun2.ammo_level (int)

game.globals.xar.player.gun2.ammo (int)

game.globals.xar.player.gun2.fire_period_level (int)

game.globals.xar.player.gun2.mode3 (dir)

game.globals.xar.player.gun2.mode3.equipped (bool)

game.globals.xar.player.gun2.mode3.has (bool)

game.globals.xar.player.gun2.mode1 (dir)

game.globals.xar.player.gun2.mode1.equipped (bool)

game.globals.xar.player.gun2.mode1.has (bool)

game.globals.xar.player.gun2.mode2 (dir)

game.globals.xar.player.gun2.mode2.equipped (bool)

game.globals.xar.player.gun2.mode2.has (bool)

game.globals.xar.player.gun5 (dir)

game.globals.xar.player.gun5.last_last_mode (int)

game.globals.xar.player.gun5.last_mode (int)

game.globals.xar.player.gun5.speed_level (int)

game.globals.xar.player.gun5.damage_level (int)

game.globals.xar.player.gun5.ammo_level (int)

game.globals.xar.player.gun5.ammo (int)

game.globals.xar.player.gun5.fire_period_level (int)

game.globals.xar.player.gun5.bucket (dir)

game.globals.xar.player.gun5.bucket.19 (int)

game.globals.xar.player.gun5.bucket.17 (int)

game.globals.xar.player.gun5.bucket.16 (int)

game.globals.xar.player.gun5.bucket.14 (int)

game.globals.xar.player.gun5.bucket.12 (int)

game.globals.xar.player.gun5.bucket.11 (int)

game.globals.xar.player.gun5.bucket.1 (int)

game.globals.xar.player.gun5.bucket.4 (int)

game.globals.xar.player.gun5.bucket.next_release_time ()

game.globals.xar.player.gun5.bucket.18 (int)

game.globals.xar.player.gun5.bucket.15 (int)

game.globals.xar.player.gun5.bucket.2 (int)

game.globals.xar.player.gun5.bucket.20 (int)

game.globals.xar.player.gun5.bucket.5 (int)

game.globals.xar.player.gun5.bucket.3 (int)

game.globals.xar.player.gun5.bucket.8 (int)

game.globals.xar.player.gun5.bucket.6 (int)

game.globals.xar.player.gun5.bucket.9 (int)

game.globals.xar.player.gun5.bucket.13 (int)

game.globals.xar.player.gun5.bucket.7 (int)

game.globals.xar.player.gun5.bucket.10 (int)

game.globals.xar.player.gun5.mode1 (dir)

game.globals.xar.player.gun5.mode1.equipped (bool)

game.globals.xar.player.gun5.mode1.has (bool)

game.globals.xar.player.gun5.mode2 (dir)

game.globals.xar.player.gun5.mode2.equipped (bool)

game.globals.xar.player.gun5.mode2.has (bool)

game.globals.xar.hud (dir)

game.globals.xar.hud.show_icons (bool)

game.globals.xar.hud.show_experience (bool)

game.globals.xar.hud.show_gold (bool)

game.globals.xar.hud.show_markers (bool)

game.globals.xar.hud.show_game_time (bool)

game.globals.xar.hud.show_health (bool)

game.globals.xar.hud.disable_hud (bool)

game.globals.xar.hud.show_ammo (bool)

game.globals.xar.hud.show_play_time (bool)

game.globals.xar.hud.flash (dir)

game.globals.xar.hud.flash.color (vector)

game.globals.xar.hud.flash.alpha (float)

game.globals.xar.hud.flash.last_time ()

game.globals.xar.hud.flash.duration ()

game.globals.xar.hud.msg (dir)

game.globals.xar.hud.msg.show_spiral_of_death_msg (bool)

game.globals.xar.hud.msg.disable_msgs (bool)

game.globals.xar.hud.msg.show_saved_game_msg (bool)

game.globals.xar.create_start_pos (dir)

game.globals.xar.create_start_pos.cur_level (int)

game.globals.xar.create_start_pos.which_try (int)

game.globals.xar.create_start_pos.next_seed (int)

game.globals.xar.create_start_pos.splash (string)

game.globals.xar.create_start_pos.global_tries_max (int)

game.globals.xar.create_start_pos.state (string)

game.globals.xar.create_start_pos.global_tries (int)

game.globals.xar.create_start_pos.frac (float)

game.globals.xar.create_start_pos.tries (dir)

game.globals.xar.create_start_pos.tries.space_mid_filament_1 (int)

game.globals.xar.create_start_pos.tries.space_mid (int)

game.globals.xar.messages (dir)

game.globals.xar.messages.slot5 (dir)

game.globals.xar.messages.slot5.ttl (float)

game.globals.xar.messages.slot5.msg (string)

game.globals.xar.messages.slot4 (dir)

game.globals.xar.messages.slot4.ttl (float)

game.globals.xar.messages.slot4.msg (string)

game.globals.xar.messages.slot3 (dir)

game.globals.xar.messages.slot3.ttl (float)

game.globals.xar.messages.slot3.msg (string)

game.globals.xar.messages.slot1 (dir)

game.globals.xar.messages.slot1.ttl (float)

game.globals.xar.messages.slot1.msg (string)

game.globals.xar.messages.slot2 (dir)

game.globals.xar.messages.slot2.ttl (float)

game.globals.xar.messages.slot2.msg (string)

game.globals.xar.inf2 (dir)

game.globals.xar.inf2.movement (dir)

game.globals.xar.inf2.movement.mod (string)

game.globals.xar.cheat (dir)

game.globals.xar.cheat.free_markers (bool)

game.globals.xar.cheat.inf2 (dir)

game.globals.xar.cheat.inf2.secondary_bt (string)

game.globals.xar.cheat.inf2.enabled (bool)

game.globals.xar.cheat.inf2.primary_bt (string)

game.globals.xar.input (dir)

game.globals.xar.input.use_primary_uses_object (bool)

game.globals.xar.input.holding_drop_marker (bool)

game.globals.xar.input.holding_telekinesis_start ()

game.globals.xar.input.holding_drop_marker_start ()

game.globals.xar.credits (dir)

game.globals.xar.credits.start_time ()

game.globals.xar.credits.won_game_play_time ()

game.globals.xar.credits.won_game (bool)

game.globals.xar.credits.won_game_game_time ()

game.globals.xar.experience (dir)

game.globals.xar.experience.this_second (int)

game.globals.xar.experience.last_time (float)

game.globals.xar.experience.to_next_level (int)

game.globals.xar.experience.level_step (int)

game.globals.xar.experience.last_claimed_milestone_level (int)

game.globals.xar.experience.last_second (int)

game.globals.xar.experience.level (int)

game.globals.xar.experience.total (int)

game.globals.xar.experience.to_next_level_max (int)

game.globals.xar.hurt_sound (dir)

game.globals.xar.hurt_sound.damage (int)

game.globals.xar.hurt_sound.last_time ()

game.globals.xar.key_time (dir)

game.globals.xar.key_time.dans_house (float)

game.globals.xar.key_time.blue (float)

game.globals.xar.key_time.yellow (float)

game.globals.xar.key_time.green_combo (string)

game.globals.xar.key_time.green (float)

game.globals.xar.key_time.laser_genesis (float)

game.globals.xar.key_time.universe (float)

game.requests (dir)
Some actions do not happen immediately, but are instead requested to happen later when it is appropriate.

game.requests.type (string)
There can only be one request at a time. This var represents the current request type, such as "close" or descend.

game.requests.respawn (dir)

game.requests.respawn.str_param (string)

game.requests.tele (dir)

game.requests.tele.target_offset (vector)

game.requests.tele.path (string)

game.requests.descend (dir)

game.requests.descend.source_offset (vector)

game.requests.before_tele (dir)

game.requests.before_tele.offset (vector)

game.requests.before_tele.path (string)

game.requests.ascend (dir)

game.requests.ascend.source_offset (vector)

game.input (dir)
These vars may eventually be moved to metagame.input.

game.input.last_input_time (float)
The last time there was any keyboard or mouse button input.

game.input.disable_non_escape_binds (bool)

game.input.mouse (dir)

game.input.mouse.wheel_value (int)

game.input.quick_cmd (dir)

game.input.quick_cmd.partial (string)

game.input.quick_cmd.entering (bool)

game.player (dir)

game.player.level (int)
The level the player is on. 0 means the root of the chunk tree.

game.player.alive (bool)
This variable may eventually be removed.

game.player.name (string)
The name of the player.We must be able to create a directory of this name.

game.player.path (string)
The path of the player from the root of the chunk tree. EMPTY_PATH means it is the path of length zero.Otherwise, this var should be something like 4a7_e39.

game.player.pos_valid (bool)

game.player.block_telefrag_time ()
This is recalculated every few seconds. These returns the first time at which a block which intersects the bbox of the player will be reverted. This queries blocks on all levels.

game.player.health_max (int)
Right now this is needed for the attack display, but that may eventually change.

game.player.camera (dir)

game.player.camera.up (vector)
The direction pointing 90 degrees from where the player is looking, towards the top of the screen.

game.player.camera.left (vector)
The direction pointing 90 degrees from where the player is looking, towards the left hand side of the screen.

game.player.camera.offset (vector)
The position of the player within the center chunk on the level of the player. The x,y,z components of this vector should always be between 0.0 and chunk_width. Because the player is in the center chunk for his level, this offset var is also the level coordinates of the player.

game.player.camera.look (vector)
Where direction where the player is looking. This vector, along with left and up, should have length one.

game.player.move (dir)

game.player.move.last_pos_diff (vector)
The game is updated 25 times per second. This var represents the difference in the player's position between the last two updates. This can be used for package defined lua scripts to create momentum.

game.player.move.disable_head_turn (bool)
When set to true, moving the mouse does not cause the player's head to move.

game.player.move.mode (string)
This can be either "fly" or "ground". This determines how collision detection works with the player. In fly mode, the player is modeled using a sphere. In ground mode, the player is modeled using a cylinder.

game.player.move.ground (dir)
When the move mode is "ground", the player is modeled as a cylinder, pointed in the Z direction.

game.player.move.ground.eye_to_top (float)
This is the distance from the eyes of the player to the top of the player cylinder.

game.player.move.ground.radius (float)
This var is the radius of the player cylinder.

game.player.move.ground.bot_to_eye (float)
This is the distance from the bottom of the player cylinder to the eyes of the player. The eyes are the center of the player.

game.player.move.fly (dir)

game.player.move.fly.use_true_up (bool)
When set true, the direction from the center of the screen to the top of the screen will always point towards the positive z direction. Said another way, the "game.player.camera.left" vector will always be in the XY plane. This only has effect if the movement mode is "fly".

game.player.move.fly.radius (float)
In fly mode, the player is modeled using a sphere. This is the radius of that sphere.

game.player.waypoint (dir)

game.player.waypoint.temp (string)
The chunk path of the temp waypoint, if a temp waypoint is being used.

game.player.respawn (dir)

game.player.respawn.path (string)
The chunk path of the chunk were the player will be respawned.

game.player.respawn.valid (bool)
This specifies whether there is a valid respawn location. If false, the player cannot be respawned.

game.player.respawn.pos (dir)
The block position, within the respawn chunk, where the player should be respawned. Note: this is be changed to a single var!

game.player.respawn.pos.x (int)

game.player.respawn.pos.z (int)

game.player.respawn.pos.y (int)

game.package (dir)
When a new game is created, these vars are read in from the starting configuration file. Then, for the rest of the process of creating a new game, these vars are used.

game.package.name (string)
The name of the package being used.

game.package.chunk_width (int)

game.package.genesis (bool)
Whether or not the engine should use genesis mode. Note: there is a hard coded variable that can override this to make the program genesis only.

game.package.seed (int)
The seed used to generate the world. Note: the starting configuration file can specify that the user can pick their own seed when creating a new game.

game.package.config_desc (string)
A description of the initial configuration.

game.package.starting_pos_file (string)
The name of the starting configuration file used.

game.package.world_nodes (dir)

game.package.world_nodes.root_name (string)
The name of the chunk file (without the .lua at the end) to be used for the root of the chunk tree. Note: the value __FBW_DEFAULT__ can be used here, in which case the C++ hardcoded Xar world root will be used.

game.window (dir)

game.window.hud (dir)

game.window.hud.hide_system_hud (bool)
When true, the system hud will not be rendered. The system hud includes the crosshair, attack display, and the side displays (in the upper left and upper right).

game.state (dir)

game.state.saving_in_progress (bool)
When this is true, the game is in the process of being saved asynchronously.

game.state.exit_when_done (bool)
When this is true, the program will exit as soon as all other essential processing is done (saving locked loop, copy dir locked loop, etc).

game.state.world_loaded (bool)
This is a very important var. This says whether or not a game has been loaded. In other words, this is true iff there is a current game in play.

game.state.paused (bool)
True iff the game is paused. This will happen if the user is in a menu.

game.state.reboot_player (dir)

game.state.reboot_player.locked (bool)
When this is true, a player is being "rebooted". Rebooting consists of copying globlal vars, deleting the player folder, then recreating the player folder with the saved global vars.

game.state.saving (dir)

game.state.saving.saved_chunks (int)
How many modified chunks have been saved so far (since the game as been saved locked).

game.state.saving.locked (bool)
This is true iff the program is locked because a game is being saved. Saving occurs asyncronously, but it locks the program.

game.state.saving.total_chunks (int)
How many total modified chunks need to be saved (while the game is save locked).

game.state.copy_dir (dir)

game.state.copy_dir.locked (bool)
This is true iff the program is locked because a directory is being copied asyncronously.

game.version (dir)

game.version.first_engine_version (string)
The version of the engine that was used when the player was first created.

game.version.error (dir)
When we try to load a game, we may encounter an error that will terminate the loading. The errors lister here have to do with the version of the engine or the version of the package.

game.version.error.2 (dir)
Each save file stores the engine version and the package version used the last time the game was played. If when loading a game these do not match the actual engine or package version, that will terminate the loading.

game.version.error.2.expected_package_ver (string)
The package version used the last time the game was played.

game.version.error.2.expected_engine_ver (string)
The engine version used the last time the game was played.

game.version.error.1 (dir)
When loading a game, the version of the engine may not match the preferred engine version specified in the light_params.txt file of the package.

game.version.error.1.forced_preferred_engine_ver (string)
Whether to force the loading of the game, using this var to override the preferred engine version instead of the one in "light_params.txt".

game.time (dir)

game.time.acc (float)
The game is updated 25 times per second. Call these the major updates. However the game is rendered more often. During a rendering frame, this var represents how many seconds have passed since the last major update.

game.time.last_update ()
The game time of the last major update.

game.time.last_save ()
The game time of when the game was last saved. This is important for the option to save the game every few seconds.

game.time.rem_frac (float)
The game is updated 25 times per second. Call these the major updates. However the game is rendered more often. During a rendering frame, this var represents how far the game is from the last major update to the next major update. So 0.1 means the last major update just happened, and 0.9 means we are almost to the next major update.

game.time.elapsed (float)
The game time that has elapsed since the last update. That is, game.time.total minus game.time.last_update should equal game.time.elapsed.

game.time.total ()
The game time. This starts at 0.0 when the player starts a new game. For every second, this advances by one. However, it can also be advanced by sleeping. So, it is not necessarily how many total seconds the player has been playing the game.

game.time.play ()
How many seconds the player has been playing the game, since they started it as a new game. This should normally equal game.time.total, unless the player slept in the game which would advance the game.time.total time but not the game.time.play time.

stats (dir)

stats.num_cc (int)
The number of chunk changes (CC) objects. A chunk changes object stores the changes that have been made to a chunk.

stats.num_ments (int)
This is updated periodically. This is the total number of moving entities in the active chunk tree.

stats.num_particles (int)
This is updated periodically. This is the total number of particles in the active chunk tree.

stats.num_rendered_quads_vbo (int)
The number of quads that have been rendered as part of a vertex buffer object from the last render cycle.

stats.in_dps (int)
A helper var to compute last_id_dps. This should probably be removed.

stats.last_in_dps (int)
The total damage done to the player during the last second long time period.

stats.pending_chunks (int)
This is the total number of chunks which we have requested to populate (that have not yet been populated). Note: populating entails creating from procedural world generation code.

stats.last_fps_time (float)
A helper var to compute the fps. This should probably be removed.

stats.fps (int)
The frames per second. Specifically, this is the number of frames the occurred during the last second long time period.

stats.num_chunks (int)
This is updated periodically. This is the total number of chunks in the active chunk tree.

stats.game_fps (int)
The fps the last time the game was unpaused. This is needed to determine if the world should be rendered behind the main menus.

stats.fps_count (int)
A helper var to compute the fps. This should probably be removed.

stats.num_blocks (int)
This is updated periodically. This is the total number of blocks in the active chunk tree. Note that in a chunk, we only store those blocks whose type are different from the default block type of that chunk.

stats.num_squares (int)
This is updated periodically. This is the total number of individual exposed 1x1 squares. These are what the player sees when they see blocks.

stats.num_squares_int (int)
This is updated periodically. This is the number of "internal" squares. There are two types of squares: internal and external. An internal square is between a solid block B1 and an empty block B2 where B1 and B2 are in the chunk. An external square is where B1 is in one chunk but B2 is in a different chunk.

stats.num_quads (int)
This is updated periodically. This is the total number of surface quads in the active chunk tree. Note that the blocks of the world are rendered using their surface quads.

stats.num_squares_ext (int)
This is updated periodically. This is the number of "external" squares. See the documendation for stats.num_squares_int

stats.num_rendered_quads_imm (int)
The number of quads that have been rendered in immediate mode from the last render cycle.

stats.last_loading_bars_time (float)
The loading bar graph shows using colors how many chunks should be removed from the chunk tree vs how many are good. This var represents the last time the loading bar graph was updated. This should probably be removed.

stats.loading_bar_graph (dir)
These vars return the number of chunks in certain categories, sorted by level. Level 0 is the viewer's level. Level 1 is the viewer's level - 1, etc. Red means outside level radius and hit by a vis ray. Yellow means outside level radius and NOT hit by a vis ray. Green means inside level radius and hit by a vis ray. Blue means inside level radius and NOT hit by a vis ray.

stats.loading_bar_graph.9 (dir)

stats.loading_bar_graph.9.green (int)

stats.loading_bar_graph.9.red (int)

stats.loading_bar_graph.9.blue (int)

stats.loading_bar_graph.9.yellow (int)

stats.loading_bar_graph.8 (dir)

stats.loading_bar_graph.8.green (int)

stats.loading_bar_graph.8.red (int)

stats.loading_bar_graph.8.blue (int)

stats.loading_bar_graph.8.yellow (int)

stats.loading_bar_graph.7 (dir)

stats.loading_bar_graph.7.green (int)

stats.loading_bar_graph.7.red (int)

stats.loading_bar_graph.7.blue (int)

stats.loading_bar_graph.7.yellow (int)

stats.loading_bar_graph.6 (dir)

stats.loading_bar_graph.6.green (int)

stats.loading_bar_graph.6.red (int)

stats.loading_bar_graph.6.blue (int)

stats.loading_bar_graph.6.yellow (int)

stats.loading_bar_graph.5 (dir)

stats.loading_bar_graph.5.green (int)

stats.loading_bar_graph.5.red (int)

stats.loading_bar_graph.5.blue (int)

stats.loading_bar_graph.5.yellow (int)

stats.loading_bar_graph.0 (dir)

stats.loading_bar_graph.0.green (int)

stats.loading_bar_graph.0.red (int)

stats.loading_bar_graph.0.blue (int)

stats.loading_bar_graph.0.yellow (int)

stats.loading_bar_graph.1 (dir)

stats.loading_bar_graph.1.green (int)

stats.loading_bar_graph.1.red (int)

stats.loading_bar_graph.1.blue (int)

stats.loading_bar_graph.1.yellow (int)

stats.loading_bar_graph.3 (dir)

stats.loading_bar_graph.3.green (int)

stats.loading_bar_graph.3.red (int)

stats.loading_bar_graph.3.blue (int)

stats.loading_bar_graph.3.yellow (int)

stats.loading_bar_graph.2 (dir)

stats.loading_bar_graph.2.green (int)

stats.loading_bar_graph.2.red (int)

stats.loading_bar_graph.2.blue (int)

stats.loading_bar_graph.2.yellow (int)

stats.loading_bar_graph.4 (dir)

stats.loading_bar_graph.4.green (int)

stats.loading_bar_graph.4.red (int)

stats.loading_bar_graph.4.blue (int)

stats.loading_bar_graph.4.yellow (int)

home (dir)
This is a place for the user to create their own variables. This can be done with the "let" command.

home.readme (string)

console (dir)
You can open the console in game by pressing "~". These vars describe the behavior of the console. They mostly regard the look and feel of it.

console.calc_num_cols (int)
This is a read only variable. It represents the max number of characters that can be in any line of the console window. This is determined from console.num_lines (which determines the height of each line) and console.char_hw_ratio. Also, the value must be less than or equal to console.max_cols.

console.type_repeat_speed (float)
After the user holds down a key in the console for a sufficiently long amount of time, this is how many times the character is entered per second.

console.type_repeat_delay (float)
When the user holds down a key in the console, this is how long it takes before the character will be entered repeatedly.

console.char_hw_ratio (float)
The height to width ratio of any character. Note: the screen has width 1.0 and height 1.0.

console.cwd (string)
This var is not being used.

console.in (bool)
Whether or not the console is open.

console.max_cols (int)
The value of console.calc_num_cols will always be forced to be less thank or equal to console.max_cols.

console.height (float)
The fraction of the screen the console takes up when open. So a value of 1.0 means it takes up the entire screen. Note that the height of each line is console.height / console.num_lines.

console.prmt (string)
The string displayed on the left of the line that the user is currently typing into. By default this is "$ ".

console.num_lines (int)
The number of console lines displayed on the screen at any one time.

console.tilde_closes (bool)
Whether or not pressing the tilde key closes the console (when in the console).

console.style (dir)

console.style.text_color (vector)
The (default) text color in the console window.

console.style.back_alpha (float)
The alpha of the background of the console window.

console.style.back_color (vector)
The background color of the console window.

console.style.colored_text (dir)

console.style.colored_text.basic (dir)
The most basic way to color text displayed by the console is with the basic escape sequence ^N where N is between 0 and 7 inclusive. For example, by default "^1stop" will display the word "stop" in red. Which basic escape sequences correspond to what colors can be specified here. So if console.style.colored_text.basic.1 is set to (0.0, 1.0, 0.0), then "^1stop" will display the word "stop" in green. Note that a more advanced way to use colors is with the escape sequence ^xrrggbb, a sequence of 6 hex characters (lowercase).

console.style.colored_text.basic.7 (vector)

console.style.colored_text.basic.6 (vector)

console.style.colored_text.basic.5 (vector)

console.style.colored_text.basic.0 (vector)

console.style.colored_text.basic.1 (vector)

console.style.colored_text.basic.3 (vector)

console.style.colored_text.basic.2 (vector)

console.style.colored_text.basic.4 (vector)

debug (dir)

debug.log_stack (bool)
The program maintains what is essentially a call stack. If the program exists on an error, then we print the stack to the standard output file. Indeed, every thread has its own stack. We print the stack of the thread that called our exit function. If this variable debug.log_stack, then whenever we push or pop the main thread's stack, then this will be outputted to the standard output file.

debug.charlie (bool)
Do not modify this var. This is used sometimes by the engine for debugging.

debug.bomb (bool)
Every so often, the program checks this var. If it is true, the program will exit. To exit the program immediately, use the exit command.

time (dir)

time.elapsed (float)
The number of seconds that have elapsed since TimeSystem::UpdateTime() was called. This should be called at least 25 times per second. It can even be called hundreds of times per second.

time.current (float)
The number of seconds that have elapsed since the program started.