string ga_command(string command);

void ga_save(bool play_sound);
void ga_load();
void ga_exit();
void ga_exit_with_error();

void ga_print(string line);
void ga_flush();

void ga_console_print(string line);

void ga_dump_lua_env();

void ga_debug_push(string frame);
void ga_debug_pop(string frame);
void ga_debug_line(string line);

void ga_load_user_script(string mod_name);

void ga_return_b(string var, bool value);

float ga_get_game_time();
float ga_get_level_time(int level);
int   ga_get_sys_time();

bool ga_get_game_paused();

int ga_get_high_precision_timer();

void ga_srand(int seed);
int ga_rand();
float ga_randf();
float ga_randf_range(float min_f, float max_f);
int ga_randi(int min_i, int max_i);

int ga_chunk_id_to_seed(int chunk_id);
int ga_path_to_seed(string path);
int ga_chunk_id_and_lbp_to_seed(int chunk_id, LocalBlockPos lbp);
int ga_bp_to_seed(int level, BlockPos bp);

int ga_chunk_seed(int chunk_id);                 //Deprecated.
int ga_lbp_seed_pos(int chunk_id, int lbp_hash); //Deprecated.
int ga_block_seed_pos(int level, BlockPos bp);   //Deprecated.

//Setting if var exists.
bool ga_exists(string var);

//Getting the type of a var.
string ga_get_var_type(string var);

//Env var creating 1.
void ga_create_b(string var);
void ga_create_i(string var);
void ga_create_f(string var);
void ga_create_v(string var);
void ga_create_s(string var);

//Env var creating 2.
void ga_init_b(string var, bool value);
void ga_init_i(string var, int value);
void ga_init_f(string var, float value);
void ga_init_v(string var, Vector value);
void ga_init_s(string var, string value);

//Env var getting.
bool   ga_get_b(string var);
int    ga_get_i(string var);
float  ga_get_f(string var);
Vector ga_get_v(string var);
string ga_get_s(string var);

//Env var getting helpers.
bool ga_b_exists_and_true(string var);

//Env var setting.
void ga_set_b(string var, bool value);
void ga_set_i(string var, int value);
void ga_set_f(string var, float value);
void ga_set_v(string var, Vector value);
void ga_set_s(string var, string value);

//Additional env var setting.
void ga_toggle_b(string var);
void ga_set_i_by_delta(string var, int delta);
void ga_set_f_by_delta(string var, float delta);
void ga_set_v_by_delta(string var, Vector delta);

//Testing which variables exist.
bool ga_exists_sys_for_get(string var);
bool ga_exists_sys_for_set(string var);

//System var getting.
bool   ga_get_sys_b(string var);
int    ga_get_sys_i(string var);
float  ga_get_sys_f(string var);
Vector ga_get_sys_v(string var);
string ga_get_sys_s(string var);

//System var setting.
void ga_set_sys_b(string var, bool value);
void ga_set_sys_i(string var, int value);
void ga_set_sys_f(string var, float value);
void ga_set_sys_v(string var, Vector value);
void ga_set_sys_s(string var, string value);

//Functions for the current package.

bool ga_package_var_exists(string var);

void ga_package_init_b(string var, bool value);
void ga_package_init_i(string var, int value);
void ga_package_init_f(string var, float value);
void ga_package_init_v(string var, Vector value);
void ga_package_init_s(string var, string value);

bool   ga_package_get_b(string var);
int    ga_package_get_i(string var);
float  ga_package_get_f(string var);
Vector ga_package_get_v(string var);
string ga_package_get_s(string var);

void ga_package_set_b(string var, bool value);
void ga_package_set_i(string var, int value);
void ga_package_set_f(string var, float value);
void ga_package_set_v(string var, Vector value);
void ga_package_set_s(string var, string value);

void package_var_remove(string var);

//Functions for any package.

bool ga_package2_var_exists(string package, string var);

void ga_package2_init_b(string package, string var, bool value);
void ga_package2_init_i(string package, string var, int value);
void ga_package2_init_f(string package, string var, float value);
void ga_package2_init_v(string package, string var, Vector value);
void ga_package2_init_s(string package, string var, string value);

bool   ga_package2_get_b(string package, string var);
int    ga_package2_get_i(string package, string var);
float  ga_package2_get_f(string package, string var);
Vector ga_package2_get_v(string package, string var);
string ga_package2_get_s(string package, string var);

void ga_package2_set_b(string package, string var, bool value);
void ga_package2_set_i(string package, string var, int value);
void ga_package2_set_f(string package, string var, float value);
void ga_package2_set_v(string package, string var, Vector value);
void ga_package2_set_s(string package, string var, string value);

void ga_package2_var_remove(string package, string var);

bool   ga_dyn_exists(string var);
string ga_dyn_get_var_type(string var);

void ga_dyn_create_b(string var);
void ga_dyn_create_i(string var);
void ga_dyn_create_f(string var);
void ga_dyn_create_v(string var);
void ga_dyn_create_s(string var);

void ga_dyn_init_b(string var, bool value);
void ga_dyn_init_i(string var, int value);
void ga_dyn_init_f(string var, float value);
void ga_dyn_init_v(string var, Vector value);
void ga_dyn_init_s(string var, string value);

bool   ga_dyn_get_b(string var);
int    ga_dyn_get_i(string var);
float  ga_dyn_get_f(string var);
Vector ga_dyn_get_v(string var);
string ga_dyn_get_s(string var);

bool   ga_dyn_get_b_maybe(string var, bool default_value);
int    ga_dyn_get_i_maybe(string var, int default_value);
float  ga_dyn_get_f_maybe(string var, float default_value);
Vector ga_dyn_get_v_maybe(string var, Vector default_value);
string ga_dyn_get_s_maybe(string var, string default_value);

bool ga_dyn_b_exists_and_true(string var);

void ga_dyn_set_b(string var, bool value);
void ga_dyn_set_i(string var, int value);
void ga_dyn_set_f(string var, float value);
void ga_dyn_set_v(string var, Vector value);
void ga_dyn_set_s(string var, string value);

void ga_dyn_toggle_b(string var);
void ga_dyn_set_i_by_delta(string var, int delta);
void ga_dyn_set_f_by_delta(string var, float delta);
void ga_dyn_set_v_by_delta(string var, Vector delta);

void ga_dyn_remove(string var);

void   ga_dyn_node_itr_start(string prefix);
string ga_dyn_node_itr_next();

void   ga_dyn_leaf_itr_start(string prefix);
string ga_dyn_leaf_itr_next();

void ga_dyn_dump();

void ga_tex_keep_alive(string tex_name);
LIST ga_get_tex_names_with_prefix(string prefix);

string ga_sound_name_to_fn(string sound);
LIST ga_get_sound_names_with_prefix(string prefix);

void ga_play_sound(string sound);
void ga_play_sound_menu(string sound);

void ga_play_music(string sound);
void ga_stop_music();
string ga_get_current_music_fn();

void ga_play_playlist(string playlist);
bool ga_playlist_exists(string playlist);

void ga_enable_non_escape_binds(bool value);
void ga_enable_escape_bind(bool value);
string ga_what_binds_to_action(string action);

string ga_mesh_get_tex(string mesh_name);
float  ga_mesh_get_radius(string mesh_name);
float  ga_mesh_get_inv_radius(string mesh_name);

string ga_get_package_name();
LIST ga_get_current_packages();

bool ga_is_cheating_enabled();

bool ga_get_hardcore_mode();
void ga_set_hardcore_mode(bool value);

//Life and death (game stuff).
bool ga_kill_player();

bool   ga_use_object_exists();
string ga_use_object_get_type();

bool          ga_look_object_bent_exists();
int           ga_look_object_bent_get_chunk_id();
LocalBlockPos ga_look_object_bent_get_lbp();

bool ga_look_object_ment_exists();
int  ga_look_object_ment_inst_id();

bool          ga_look_object_block_exists();
int           ga_look_object_block_get_chunk_id();
LocalBlockPos ga_look_object_block_get_lbp();
int           ga_look_object_block_get_normal_side();
Vector        ga_look_object_block_get_lp();

void ga_hud_msg(string msg, float duration);

void ga_hud_reg_damage_from_dir(int damage, Vector dir);
void ga_hud_reg_damage_from_dir_color(int damage, Vector dir, Vector color);
void ga_hud_reg_dir_tex(string name, string tex, Vector dir, float duration);

void ga_shrink();
void ga_shrink2(Vector lp);
void ga_grow();
void ga_grow2(Vector lp);

void ga_tele(string path, Vector offset);
void ga_set_tele_back(string path, Vector offset);
void ga_tele_back();

void ga_tele_same_level(Vector lp);

int  ga_get_fertile_radius(int level_delta);
void ga_set_fertile_radius(int level_delta, int radius);

int  ga_get_level_radius(int level_delta);
void ga_set_level_radius(int level_delta, int radius);

void ga_explore_while(string func, string win);

void ga_worldgen_main_dummy(string bt, string arg);
void ga_worldgen_refresh_state_var(string var);
void ga_worldgen_refresh_state_all();

//Window related.
void ga_window_push(string win_name);
void ga_window_pop();
void ga_window_pop_all();
void ga_hud_window_add(string win_name, int priority);
void ga_hud_window_remove(string win_name);

//These 3 functions are deprecated.
void ga_main_menu_push(string win_name);
void ga_main_menu_pop();
void ga_main_menu_pop_all(bool return_to_game);

LIST ga_get_window_stack_display_names();
LIST ga_main_menu_get_stack_display_names(); //Deprecated.
void ga_open_title_menu();
void ga_open_console();
void ga_close_console();
bool ga_get_program_has_focus();
void ga_set_game_paused_while_on_win_stack(bool value);

//Viewer queries.
int ga_get_viewer_chunk_id();
int ga_get_viewer_ancestor_chunk_id(int level);
string ga_get_viewer_chunk_bt();
int ga_get_viewer_level();
Vector ga_get_viewer_offset();
Vector ga_get_viewer_lp(int level);
BlockPos ga_get_viewer_bp(int level);
string ga_get_viewer_path();
string ga_get_viewer_path_ext();
Vector ga_get_vec_to_viewer(int level, Vector lp);
float ga_lbp_dist_to_viewer(int chunk_id, int lbp_hash);
float ga_block_dist_to_viewer(int level, BlockPos bp);

//Cached ment variables.
Vector ga_ment_get_var_special_vec_to_viewer(int inst_id);
float ga_ment_get_var_special_dist_to_viewer(int inst_id);

string ga_bent_get_type(int level, BlockPos bp);

void ga_bent_add(int level, BlockPos bp, string type, float rl);
void ga_bent_add_i(int level, BlockPos bp, string type, int param, float rl);
void ga_bent_add_s(int level, BlockPos bp, string type, string param, float rl);

void ga_bent_set_param_i(int level, BlockPos bp, int value, float rl);
void ga_bent_set_param_s(int level, BlockPos bp, string value, float rl);
int    ga_bent_get_param_i(int level, BlockPos bp);
string ga_bent_get_param_s(int level, BlockPos bp);

void ga_bent_remove_temp(int level, BlockPos bp, int num_sec);
void ga_bent_remove_perm(int level, BlockPos bp);

LIST ga_bent_sphere_query(int level, Vector lp, float radius);
CLASS ga_search_for_bent_in_chunk(int chunk_id, string bent_type);

LIST ga_get_bent_names_with_prefix(string prefix);

bool ga_ment_type_var_exists(string type, string var);

bool   ga_ment_get_static_b(string type, string var);
int    ga_ment_get_static_i(string type, string var);
float  ga_ment_get_static_f(string type, string var);
Vector ga_ment_get_static_v(string type, string var);
string ga_ment_get_static_s(string type, string var);

bool ga_ment_static_b_exists_and_true(string type, string var);

void ga_ment_start(int level, Vector lp, string type);
void ga_ment_end();
void ga_ment_init_set_b(string key, bool value);
void ga_ment_init_set_i(string key, int value);
void ga_ment_init_set_f(string key, float value);
void ga_ment_init_set_v(string key, Vector value);
void ga_ment_init_set_s(string key, string value);

bool   ga_ment_var_exists(int inst_id, string var);
string ga_ment_get_var_type(int inst_id, string var);

bool   ga_ment_b_exists_and_true(int inst_id, string var);

bool   ga_ment_get_b(int inst_id, string var);
int    ga_ment_get_i(int inst_id, string var);
float  ga_ment_get_f(int inst_id, string var);
Vector ga_ment_get_v(int inst_id, string var);
string ga_ment_get_s(int inst_id, string var);

void ga_ment_set_var_rl_only(int inst_id, string var, float rl);
    
void ga_ment_set_b(int inst_id, string var, bool value);
void ga_ment_set_i(int inst_id, string var, int value);
void ga_ment_set_f(int inst_id, string var, float value);
void ga_ment_set_v(int inst_id, string var, Vector value);
void ga_ment_set_s(int inst_id, string var, string value);

void ga_ment_toggle_b(int inst_id, string var);
void ga_ment_set_i_by_delta(int inst_id, string var, int delta);
void ga_ment_set_f_by_delta(int inst_id, string var, float delta);
void ga_ment_set_v_by_delta(int inst_id, string var, Vector delta);

int ga_ment_inst_id_to_code_id(int inst_id);
int ga_ment_code_id_to_inst_id(int code_id);

bool ga_ment_exists(int inst_id);

ga_ment_respawn(int inst_id);
ga_ment_remove(int inst_id);
ga_ment_remove_perm(int inst_id);
ga_ment_remove_with_respawn_length(int inst_id, float respawn_length);

ga_ment_respawn_now(int inst_id);
ga_ment_remove_now(int inst_id);
ga_ment_remove_perm_now(int inst_id);
ga_ment_remove_with_respawn_length_now(int inst_id, float respawn_length);

string ga_ment_get_type(int inst_id);
Vector ga_ment_get_lp(int inst_id);
Vector ga_ment_get_sllp(int inst_id);
int    ga_ment_get_start_level(int inst_id);
int    ga_ment_get_level(int inst_id);
int    ga_ment_get_chunk_id(int inst_id);
float  ga_ment_get_radius(int inst_id);
void ga_ment_dump(int inst_id);

void ga_ment_tele(int inst_id, int chunk_id, Vector offset);

LIST ga_ment_sphere_query(
    int level, int min_level, int max_level,
    Vector lp, float radius);

void ga_ment_set_alarm(
    int inst_id, float alarm_game_time, string alarm_name);
void ga_ment_set_alarm_on_level(
    int inst_id, int level, float alarm_level_time, string alarm_name);

void ga_ment_all_dump();

void ga_ment_vec_to_another_ment(int inst_id_1, int inst_id_2);

LIST ga_get_ment_names_with_prefix(string prefix);

void ga_particle_add(CLASS args);
void ga_particle_explosion(CLASS args);
void ga_particle_trail(CLASS args);
void ga_particle_ring(CLASS args);

bool ga_bt_exists(string bt);
bool ga_bt_var_exists(string bt, string var);
bool ga_bt_get_physically_solid(string bt);

LIST ga_get_block_names_with_prefix(string prefix);

//Old block type getting functions.
string ga_block_get(int level, BlockPos bp);
string ga_get_cocoon_block_of_chunk(int level, BlockPos vcp);

//New block type getting functions.
string ga_bp_to_bt(int level, BlockPos bp);
string ga_chunk_id_and_lbp_to_bt(int chunk_id, LocalBlockPos lbp);
string ga_chunk_id_to_bt(int chunk_id);
string ga_vcp_to_bt(int level, ViewerCentricPos vcp);

void ga_block_change_rl(
    int level, BlockPos bp, string new_bt, float rl);
void ga_block_change_rl_default(
    int level, BlockPos bp, string new_bt);
void ga_block_change_perm(
    int level, BlockPos bp, string new_bt);

bool   ga_block_var_exists(int level, BlockPos bp, string var);
string ga_block_get_var_type(int level, BlockPos bp, string var);

bool   ga_block_get_b(int level, BlockPos bp, string var);
int    ga_block_get_i(int level, BlockPos bp, string var);
float  ga_block_get_f(int level, BlockPos bp, string var);
Vector ga_block_get_v(int level, BlockPos bp, string var);
string ga_block_get_s(int level, BlockPos bp, string var);

bool ga_block_b_exists_and_true(int level, BlockPos bp, string var);

void ga_block_set_b(int level, BlockPos bp, string var, bool value);
void ga_block_set_i(int level, BlockPos bp, string var, int value);
void ga_block_set_f(int level, BlockPos bp, string var, float value);
void ga_block_set_v(int level, BlockPos bp, string var, Vector value);
void ga_block_set_s(int level, BlockPos bp, string var, string value);

void ga_block_toggle_b(int level, BlockPos bp, string var);
void ga_block_set_i_by_delta(int level, BlockPos bp, string var, int delta);
void ga_block_set_f_by_delta(int level, BlockPos bp, string var, float delta);
void ga_block_set_v_by_delta(int level, BlockPos bp, string var, Vector delta);

string ga_get_most_common_bt_in_chunk(int chunk_id);

CLASS ga_search_for_bt_in_chunk(int chunk_id, string bt);
CLASS ga_search_for_bt_in_chunk_random(int chunk_id, string bt);
void ga_search_and_replace_bt_in_chunk_perm(int chunk_id string bt1, string bt2);

//Alternate API for block vars.
bool   ga_chunk_var_exists(int level, ViewerCentricPos vcp, string var);
bool   ga_chunk_get_b(int level, ViewerCentricPos vcp, string var);
int    ga_chunk_get_i(int level, ViewerCentricPos vcp, string var);
float  ga_chunk_get_f(int level, ViewerCentricPos vcp, string var);
Vector ga_chunk_get_v(int level, ViewerCentricPos vcp, string var);
string ga_chunk_get_s(int level, ViewerCentricPos vcp, string var);
void   ga_chunk_set_b(int level, ViewerCentricPos vcp, string var, bool value);
void   ga_chunk_set_i(int level, ViewerCentricPos vcp, string var, int value);
void   ga_chunk_set_f(int level, ViewerCentricPos vcp, string var, float value);
void   ga_chunk_set_v(int level, ViewerCentricPos vcp, string var, Vector value);
void   ga_chunk_set_s(int level, ViewerCentricPos vcp, string var, string value);

string ga_get_respawn_path();
BlockPos ga_get_respawn_lbp();
void ga_set_respawn_point(string path, BlockPos lbp);
void ga_set_respawn_cb(string func, string win);

//The following are deprecated.
//Use Data/Packages/base/Game/game_base_wp_system.lua instead.
string ga_get_emergency_waypoint_path();
void   ga_add_waypoint_sloppy(string path, string name_override);
void   ga_add_waypoint_sloppy_in_only(string path, string name_override);

int              ga_chunk_id_to_level(int chunk_id);
ViewerCentricPos ga_chunk_id_to_vcp(int chunk_id);
BlockPos         ga_chunk_id_to_bp(int chunk_id);
string           ga_chunk_id_to_path(int chunk_id);

int ga_vcp_to_chunk_id(int level, BlockPos vcp);
int ga_path_to_chunk_id(string path);

BlockPos ga_chunk_id_and_lbp_to_bp(int chunk_id, BlockPos lbp);
BlockPos ga_lbp_to_bp(BlockPos vcp, LocalBlockPos lbp);

BlockPos         ga_vcp_to_bp(int level, ViewerCentricPos vcp);
ViewerCentricPos ga_bp_to_vcp(int level, BlockPos bp);

int ga_bp_to_chunk_id(int level, BlockPos bp);

int              ga_chunk_id_to_parent_chunk_id(int chunk_id);
BlockPos         ga_bp_to_parent_bp(int level, BlockPos bp);
ViewerCentricPos ga_bp_to_parent_vcp(BlockPos bp);
int              ga_bp_to_parent_chunk_id(int level, BlockPos bp);

BlockPos ga_bp_to_ancestor_bp(int source_level, BlockPos source_bp, int target_level);
int      ga_chunk_id_to_ancestor_chunk_id(int source_chunk_id, int target_level);

string        ga_bp_to_path(int level, BlockPos bp);
LocalBlockPos ga_bp_to_lbp(BlockPos bp);

//See base/Game/std.lua for
//lbp_to_bp, bp_to_vcp, bp_to_lbp, local_to_level_pos,
//level_to_local_pos, lp_to_vcp, lp_to_offset, bp, block_center,
//lbph_to_lbp, lbp_to_lbph, lp_to_bp, etc.

Vector ga_chunk_id_and_offset_to_lp(int chunk_id, Vector offset);
Vector ga_offset_to_lp(BlockPos vcp, Vector offset); 

CLASS ga_level_scale_factor(int source_level, int target_level);
CLASS ga_convert_lp(
    int source_level, int target_level, Vector source_lp);

CLASS ga_finest_chunk_containing_point(int level, Vector lp);

//Much of this is in "base/Game/std.lua".

CLASS ga_path_diff(string path1, string path2);

void ga_camera_set_look(Vector look, Vector up);
void ga_move_set_desired_travel(Vector travel);
void ga_move_set_roll(float roll);
bool ga_move_get_on_sure_footing();
void ga_move_set_ledge_guards(bool on);

void ga_move_set_body_spirit();
void ga_move_set_body_spirit_off();
bool ga_move_set_body_ground(
    Vector trans, float radius, float bot_to_eye, float eye_to_top);
bool ga_move_set_body_fly(
    Vector trans, float radius, bool use_true_up);

void ga_player_model_set_look();
void ga_player_model_q2md2_set_cmd(string cmd);
void ga_player_model_q2md2_set_state(string state);

bool ga_vis_test_level(int level, Vector lp_start, Vector lp_end);

CLASS ga_ray_cast(
    int level, Vector lp_start, Vector dir,
    int min_level, int max_level);

void ga_render_skip_next_frame();
void ga_render_push_matrix();
void ga_render_pop_matrix();
void ga_render_matrix_load_identity();
void ga_render_matrix_row_major(
    float m11, float m12, float m13, float m14,
    float m21, float m22, float m23, float m24,
    float m31, float m32, float m33, float m34,
    float m41, float m42, float m43, float m44);
void ga_render_matrix_translated(float trans_x, float trans_y, float trans_z);
void ga_render_matrix_scaled(float scale_x, float scale_y, float scale_z);
void ga_render_matrix_rotated(
    float angle,
    Vector axis);
void ga_render_matrix_frame(
    Vector look,
    Vector up,
    Vector left);
void ga_render_matrix_frame_from_ment(int inst_id);

void ga_render_ment_typical(int inst_id);
void ga_render_mesh(string mesh_name);
void ga_render_mesh_with_tex(
    string mesh_name,
    string tex_name);
void ga_render_mesh_with_tex_alpha(
    string mesh_name,
    string tex_name,
    float alpha);
void ga_render_mesh_with_tex_no_lighting(
    string mesh_name,
    string tex_name);
void ga_render_mesh_with_tex_alpha_no_lighting(
    string mesh_name,
    string tex_name,
    float alpha);

void ga_render_line(
    Vector v1,
    Vector v2);
void ga_render_line_thick(
    Vector v1,
    Vector v2,
    float thickness);
void ga_render_triangle(
    Vector v1,
    Vector v2,
    Vector v3,
    float u1, float v1,
    float u2, float v2,
    float u3, float v3,
    string tex);
Vector ga_render_get_color();
void ga_render_color(
    Vector color);

void ga_render_set_depth_test_enabled(bool value);
void ga_render_clear_depth_buffer();

//These are described in another chapter.
//These are in addition to the previous "windows" functions.

string ga_reboot_dyn_itr_get();
void ga_reboot_dyn_itr_next();
bool ga_reboot_dyn_itr_at_end();
void ga_reboot_dyn_itr_save();

int    ga_open_file_for_writing(string file_name);
int    ga_open_named_pipe(string name);
void   ga_write(int handle, string str);
string ga_read(int handle);
void   ga_close_file(int handle);

bool ga_get_is_colorblind();
Vector ga_get_colorblind_closest(Vector color);
Vector ga_get_colorblind_bynum(int num);
void ga_set_colorblind_bynum(int num, Vector color);

Vector ga_color_code_to_vec(string code);
string ga_color_vec_to_code(Vector color);
string ga_txt_strip_esc_seq(string input);

void ga_copy_to_clipboard(string str);
string ga_paste_from_clipboard();