2145 lines
71 KiB
TypeScript
2145 lines
71 KiB
TypeScript
export { };
|
|
|
|
//* note: All enums were moved to mods/utility/enums.ts
|
|
|
|
//? Everything was just dumped in as I looked down the lua_api.md
|
|
|
|
/** @noSelf **/
|
|
interface minetest {
|
|
get_current_modname(): string;
|
|
get_modpath(modName: string): string;
|
|
get_modnames(): string[];
|
|
get_game_info(): GameInfo;
|
|
get_worldpath(): string;
|
|
is_singleplayer(): boolean;
|
|
features(): MinetestFeatures;
|
|
has_feature(featureName: string): boolean;
|
|
get_player_information(playerName: string): PlayerInformation;
|
|
get_player_window_information(playerName: string): WindowInformation;
|
|
mkdir(dir: string): boolean;
|
|
rmdir(dir: string): boolean;
|
|
cpdir(dir: string, dst: string): boolean;
|
|
mvdir(dir: string): boolean;
|
|
get_dir_list(dir: string, isDir: boolean): string[];
|
|
safe_file_write(path: string, content: string): boolean;
|
|
get_version(): MinetestInfo;
|
|
sha1(data: any, raw: boolean): string;
|
|
colorspec_to_colorstring(colorSpec: ColorSpec): string;
|
|
colorspec_to_bytes(colorSpec: ColorSpec): string;
|
|
encode_png(width: number, height: number, data: ColorSpec[] | string, compression: number): string;
|
|
urlencode(url: string): string;
|
|
debug(anything: string): void;
|
|
log(level: LogLevel, text: string): void;
|
|
register_node(nodeName: string, definition: NodeDefinition): void;
|
|
register_craftitem(craftItemName: string, definition: ItemDefinition): void;
|
|
register_tool(toolName: string, definition: ItemDefinition): void;
|
|
override_item(itemName: string, definition: ItemDefinition): void;
|
|
unregister_item(itemName: string): void;
|
|
register_entity(entityName: string, definition: LuaEntity): void;
|
|
register_abm(abm: ABMDefinition): void;
|
|
register_lbm(lbm: LBMDefinition): void;
|
|
register_alias(alias: string, originalName: string): void;
|
|
register_alias_force(alias: string, originalName: string): void;
|
|
register_ore(ore: OreDefinition): void;
|
|
register_biome(biome: BiomeDefinition): void;
|
|
unregister_biome(biomeName: string): void;
|
|
register_decoration(decoration: DecorationDefinition): void;
|
|
register_schematic(schematic: SchematicDefinition): number;
|
|
clear_registered_biomes(): void;
|
|
clear_registered_decorations(): void;
|
|
clear_registered_ores(): void;
|
|
clear_registered_schematics(): void;
|
|
register_craft(craftRecipe: CraftRecipeDefinition): void;
|
|
clear_craft(craftRecipe: CraftRecipeDefinition): void;
|
|
register_chatcommand(commandName: string, definition: ChatCommandDefinition): void;
|
|
override_chatcommand(commandName: string, definition: ChatCommandDefinition): void;
|
|
unregister_chatcommand(commandName: string): void;
|
|
register_privilege(privilegeName: string, definition: PrivilegeDefinition): void;
|
|
register_authentication_handler(authHandler: AuthenticationHandlerDefinition): void;
|
|
register_globalstep(fun: (delta: number) => void): void;
|
|
register_on_mods_loaded(fun: () => void): void;
|
|
register_on_shutdown(fun: () => void): void;
|
|
register_on_placenode(fun: (pos: Vec3, node: NodeTable, placer: ObjectRef, oldNode: NodeTable, itemStack: ItemStackObject, pointedThing: PointedThing) => void): void;
|
|
register_on_dignode(fun: (pos: Vec3, oldNode: NodeTable, digger: ObjectRef) => void): void;
|
|
register_on_punchnode(fun: (pos: Vec3, node: NodeTable, puncher: ObjectRef, pointedThing: PointedThing) => void): void;
|
|
register_on_generated(fun: (minp: Vec3, maxp: Vec3, blockSeed: number) => void): void;
|
|
register_on_newplayer(fun: (player: ObjectRef) => void): void;
|
|
register_on_punchplayer(fun: (player: ObjectRef, hitter: ObjectRef, timeFromLastPunch: number, toolCapabilities: ToolCapabilities, dir: Vec3, damage: number) => void): void;
|
|
register_on_rightclickplayer(fun: (player: ObjectRef, clicker: ObjectRef) => void): void;
|
|
register_on_player_hpchange(fun: (player: ObjectRef, hpChange: number, reason: HPChangeReasonDefinition) => void, modifier: boolean): void;
|
|
register_on_dieplayer(fun: (player: ObjectRef, reason: HPChangeReasonDefinition) => void): void;
|
|
register_on_respawnplayer(fun: (player: ObjectRef) => void): void;
|
|
register_on_prejoinplayer(fun: (name: string, ip: string) => void): void;
|
|
register_on_joinplayer(fun: (player: ObjectRef, lastLogin: string) => void): void;
|
|
register_on_leaveplayer(fun: (player: ObjectRef, timedOut: boolean) => void): void;
|
|
register_on_authplayer(fun: (name: string, ip: string, isSuccess: boolean) => void): void;
|
|
register_on_auth_fail(fun: (name: string, ip: string) => void): void;
|
|
register_on_cheat(fun: (player: ObjectRef, cheat: CheatDefinition) => void): void;
|
|
register_on_chat_message(fun: (name: string, message: string) => void): void;
|
|
register_on_chatcommand(fun: (name: string, command: string, params: string) => boolean): void;
|
|
register_on_player_receive_fields(fun: (player: ObjectRef, formName: string, fields: { string: any; }) => void): void;
|
|
register_on_craft(fun: (itemStack: ItemStackObject, player: ObjectRef, oldCraftGrid: any[], craftInv: string) => void): void;
|
|
register_craft_predict(fun: (itemStack: ItemStackObject, player: ObjectRef, oldCraftGrid: any[], craftInv: string) => void): void;
|
|
register_allow_player_inventory_action(fun: (player: ObjectRef, action: string, inventory: string, inventoryInfo: ActionDefinition) => void): void;
|
|
register_on_player_inventory_action(fun: (player: ObjectRef, action: string, inventory: string, inventoryInfo: ActionDefinition) => void): void;
|
|
register_on_protection_violation(fun: (position: Vec3, name: string) => void): void;
|
|
register_on_item_eat(fun: (hpChange: number, replaceWithItem: boolean, itemStack: ItemStackObject, user: ObjectRef, pointedThing: PointedThing) => void): void;
|
|
register_on_item_pickup(fun: (itemStack: ItemStackObject, picker: ObjectRef, pointedThing: PointedThing, timeFromLastPunch: number, ...any: any) => void): void;
|
|
register_on_priv_grant(fun: (name: string, granter: string, priv: string) => void): void;
|
|
register_on_priv_revoke(fun: (name: string, revoker: string, priv: string) => void): void;
|
|
register_can_bypass_userlimit(fun: (name: string, ip: string) => void): void;
|
|
register_on_modchannel_message(fun: (channelName: string, sender: string, message: string) => void): void;
|
|
register_on_liquid_transformed(fun: (posList: Vec3[], nodeList: string[]) => void): void;
|
|
register_on_mapblocks_changed(fun: (modifiedBlocks: string[], nodeList: any[]) => void): void;
|
|
settings: MinetestSettingsObject;
|
|
setting_get_pos(name: string): Vec3;
|
|
string_to_privs(str: string, delim: string): string;
|
|
privs_to_string(privs: string, delim: string): string;
|
|
get_player_privs(playerName: string): string[];
|
|
check_player_privs(playerOrName: ObjectRef | string, stringListOrMap: string | Map<string, boolean>): boolean | boolean[];
|
|
check_password_entry(playerName: string, entry: string, password: string): boolean;
|
|
get_password_hash(playerName: string, rawPassword: string): string;
|
|
get_player_ip(playerName: string): string;
|
|
get_auth_handler(): AuthenticationHandlerDefinition;
|
|
notify_authentication_modified(playerName: string): void;
|
|
set_player_password(playerName: string, passwordHash: string): void;
|
|
set_player_privs(playerName: string, { string: boolean }): void;
|
|
auth_reload(): void;
|
|
chat_send_all(message: string): void;
|
|
chat_send_player(playerName: string, message: string): void;
|
|
format_chat_message(playerName: string, message: string): void;
|
|
set_node(position: Vec3, nodeTable: NodeTable): void;
|
|
add_node(position: Vec3, nodeTable: NodeTable): void;
|
|
bulk_set_node(positions: Vec3[], nodeTable: NodeTable): void;
|
|
swap_node(position: Vec3, nodeTable: NodeTable): void;
|
|
remove_node(position: Vec3): void;
|
|
get_node(position: Vec3): NodeTable;
|
|
get_node_or_nil(position: Vec3): NodeTable | null;
|
|
get_node_light(position: Vec3, timeOfDay: number): number;
|
|
get_natural_light(position: Vec3, timeOfDay: number): number;
|
|
get_artificial_light(param1: number): number;
|
|
place_node(position: Vec3, nodeTable: NodeTable): void;
|
|
dig_node(position: Vec3): boolean;
|
|
punch_node(position: Vec3): void;
|
|
spawn_falling_node(position: Vec3): [boolean, ObjectRef] | boolean;
|
|
find_nodes_with_meta(pos1: Vec3, pos2: Vec3): Vec3[];
|
|
get_meta(position: Vec3): MetaRef;
|
|
get_node_timer(position: Vec3): NodeTimerObject;
|
|
add_entity(position: Vec3, entityName: string, staticData?: string): ObjectRef | null;
|
|
add_item(position: Vec3, item: ItemStackObject | string): ObjectRef;
|
|
get_player_by_name(playerName: string): ObjectRef;
|
|
get_objects_inside_radius(position: Vec3, radius: number): ObjectRef[];
|
|
get_objects_in_area(pos1: Vec3, pos2: Vec3): ObjectRef[];
|
|
set_timeofday(newTimeOfDay: number): void;
|
|
get_timeofday(): number;
|
|
get_gametime(): number;
|
|
get_day_count(): number;
|
|
find_node_near(position: Vec3, radius: number, nodeNames: string[], searchCenter?: boolean): Vec3 | void;
|
|
find_nodes_in_area(pos1: Vec3, pos2: Vec3, nodeNames: string[], grouped: boolean): any[]; //! FIXME: returns a very specific thing, turn it into an interface
|
|
find_nodes_in_area_under_air(pos1: Vec3, pos2: Vec3, nodeNames: string[]): Vec3[];
|
|
get_perlin(nodeParams: NoiseParams): PerlinNoiseObject;
|
|
get_perlin(seedDiff: number, octaves: number, persistence: number, spread: number): PerlinNoiseObject;
|
|
get_voxel_manip(pos1: Vec3, pos2: Vec3): VoxelManipObject;
|
|
set_gen_notify(flags: GenNotifyFlags, decorationIDs: number[]): void;
|
|
get_gen_notify(): number[];
|
|
get_decoration_id(decorationName: string): number;
|
|
get_mapgen_object(objectName: string): GenNotifyObject;
|
|
get_heat(position: Vec3): number;
|
|
get_humidity(position: Vec3): number;
|
|
get_biome_data(position: Vec3): BiomeDataDefinition | void;
|
|
get_biome_id(biomeName: string): number;
|
|
get_biome_name(biomeID: number): string;
|
|
get_mapgen_setting(settingName: string): MapGenSettingsDefinition;
|
|
set_mapgen_params(mapgenParams: MapGenSettingsDefinition): void;
|
|
get_mapgen_edges(mapgenLimit: number, chunkSize: number): void;
|
|
get_mapgen_setting(settingName: string): MapGenSettingsDefinition;
|
|
get_mapgen_setting_noiseparams(settingName: string): NoiseParams;
|
|
set_mapgen_setting(name: string, value: any, overrideMeta: boolean): void;
|
|
set_noiseparams(name: string, noiseParams: NoiseParams, overrideMeta: boolean): void;
|
|
get_noiseparams(name: string): NoiseParams;
|
|
generate_ores(voxelManip: VoxelManipObject, pos1: Vec3, pos2: Vec3): void;
|
|
generate_decorations(voxelManip: VoxelManipObject, pos1: Vec3, pos2: Vec3): void;
|
|
clear_objects(options: ClearObjectsOptions): void;
|
|
load_area(pos1: Vec3, pos2: Vec3): void;
|
|
emerge_area(pos1: Vec3, pos2: Vec3, fun: EmergeAreaCallback, param: any): void;
|
|
delete_area(pos1: Vec3, pos2: Vec3): void;
|
|
line_of_sight(pos1: Vec3, pos2: Vec3): [boolean, Vec3];
|
|
raycast(pos1: Vec3, pos2: Vec3, hitObjects: boolean, hitLiquids: boolean): RaycastObject;
|
|
find_path(pos1: Vec3, pos2: Vec3, searchDistance: number, maxJump: number, maxDrop: number, algorithm: SearchAlgorithm): Vec3[];
|
|
spawn_tree(position: Vec3, definition: TreeDefinition): void;
|
|
transforming_liquid_add(position: Vec3): void;
|
|
get_node_max_level(position: Vec3): number;
|
|
get_node_level(position: Vec3): number;
|
|
set_node_level(position: Vec3, level: number): number;
|
|
add_node_level(position: Vec3, level: number): number;
|
|
fix_light(pos1: Vec3, pos2: Vec3): boolean;
|
|
check_single_for_falling(position: Vec3): void;
|
|
check_for_falling(position: Vec3): void;
|
|
get_spawn_level(x: number, z: number): number | void;
|
|
mod_channel_join(channelName: string): void;
|
|
get_inventory(position: Vec3): InvRef;
|
|
get_perlin_map(params: NoiseParams, size: Vec3): PerlinNoiseMapObject;
|
|
get_inventory(position: Vec3): InvRef;
|
|
create_detached_inventory(name: string, callbacks: DetachedInventoryCallbacks, playerName: string): InvRef;
|
|
remove_detached_inventory(name: string): boolean;
|
|
do_item_eat(hpChange: number, replaceWithItem: ItemStackObject, itemStack: ItemStackObject, user: ObjectRef, pointedThing: PointedThing): ItemStackObject | void;
|
|
show_formspec(playerName: string, formName: string, formSpec: string): void;
|
|
close_formspec(playerName: string, formName: string): void;
|
|
formspec_escape(escape: string): string;
|
|
explode_table_event(string: string): Map<any, any>;
|
|
explode_textlist_event(string: string): Map<any, any>;
|
|
explode_scrollbar_event(string: string): Map<any, any>;
|
|
inventorycube(img1: string, img2: string, img3: string): string;
|
|
get_pointed_thing_position(pointedThing: PointedThing, above: boolean): Vec3 | void;
|
|
dir_to_facedir(direction: Vec3, is6d: boolean): number;
|
|
facedir_to_dir(faceDir: number): Vec3;
|
|
dir_to_fourdir(direction: Vec3): number;
|
|
fourdir_to_dir(faceDir: number): Vec3;
|
|
dir_to_wallmounted(direction: Vec3): number;
|
|
wallmounted_to_dir(faceDir: number): Vec3;
|
|
dir_to_yaw(direction: Vec3): number;
|
|
yaw_to_dir(yaw: number): Vec3;
|
|
is_colored_paramtype(pType: number): boolean;
|
|
strip_param2_color(param2: number, paramType2: ParamType2): number | void;
|
|
get_node_drops(node: string | NodeTable, toolName: string): string[];
|
|
get_craft_result(input: CraftRecipeCheckDefinition): LuaMultiReturn<[CraftResultObject, CraftRecipeCheckDefinition]>;
|
|
get_craft_recipe(output: string | NodeTable): CraftRecipeDefinition | void;
|
|
get_all_craft_recipes(queryItem: string | NodeTable): CraftRecipeDefinition[] | void;
|
|
handle_node_drops(position: Vec3, drops: string[], digger: ObjectRef): void;
|
|
itemstring_with_palette(item: ItemStackObject, paletteIndex: number): string;
|
|
itemstring_with_color(item: ItemStackObject, colorString: DynamicColorSpec): string;
|
|
rollback_get_node_actions(position: Vec3, range: number, seconds: number, limit: number): Rollback[];
|
|
rollback_revert_actions_by(actor: string, seconds: number): [boolean, string];
|
|
item_place_node(itemStack: ItemStackObject, placer: ObjectRef, pointedThing: PointedThing, param2: number, preventAfterPlace: boolean): [ItemStackObject, Vec3 | void];
|
|
//? Deprecated.
|
|
// item_place_object(itemStack: ItemStackObject, placer: ObjectRef, pointedThing: PointedThing): ItemStackObject
|
|
item_place(itemStack: ItemStackObject, placer: ObjectRef, pointedThing: PointedThing, param2: number): [ItemStackObject, Vec3 | void];
|
|
item_pickup(itemStack: ItemStackObject, picker: ObjectRef, pointedThing: PointedThing, timeFromLastPunch: number, ...any: any): ItemStackObject;
|
|
item_drop(itemStack: ItemStackObject, dropper: ObjectRef | null, position: Vec3): ItemStackObject;
|
|
item_eat(hpChange: number, replaceWithItem: string): void;
|
|
node_punch(position: Vec3, nodeTable: NodeTable, puncher: ObjectRef, pointedThing: PointedThing): void;
|
|
node_dig(position: Vec3, nodeTable: NodeTable, digger: ObjectRef): void;
|
|
after(seconds: number, fun: (...any: any) => void, ...any: any): Job;
|
|
handle_async(fun: (...any: any) => any, callback: (...any: any) => any, ...any: any): any; // any any any any
|
|
register_async_dofile(path: string): void;
|
|
request_shutdown(message: string, reconnect: boolean, delay: number): void;
|
|
cancel_shutdown_requests(): void;
|
|
get_server_status(name: string, joined: boolean): void;
|
|
get_server_uptime(): number;
|
|
get_server_max_lag(): number;
|
|
remove_player(playerName: string): number;
|
|
remove_player_auth(playerName: string): boolean;
|
|
dynamic_add_media(options: DynamicAddMediaOptions, fun: (name: string) => void): void;
|
|
get_ban_list(): string;
|
|
get_ban_description(ipOrName: string): string;
|
|
ban_player(playerName: string): boolean;
|
|
unban_player_or_ip(ipOrName: string): void;
|
|
kick_player(playerName: string, reason: string): boolean;
|
|
disconnect_player(name: string, reason: string): boolean;
|
|
add_particle(definition: ParticleDefinition): void;
|
|
add_particlespawner(definition: ParticleSpawnerDefinition): number;
|
|
delete_particlespawner(id: number, playerName: string): void;
|
|
create_schematic(pos1: Vec3, pos2: Vec3, probabilityList: SchematicProbability[], fileName: string, sliceProbList: SchematicSliceProbability[]): void;
|
|
place_schematic(position: Vec3, schematic: SchematicDefinition | string, rotation: SchematicRotation, replacements: Map<string, string>, forcePlacement: boolean, flags: SchematicPlacementFlag[]): void;
|
|
place_schematic_on_vmanip(voxelManip: VoxelManipObject, position: Vec3, schematic: SchematicDefinition, rotation: SchematicRotation, replacement: Map<string, string>, forcePlacement: boolean, flags: SchematicPlacementFlag[]): void;
|
|
serialize_schematic(schematic: SchematicDefinition, format: SchematicFormat, options: SchematicSerializationOption[]): void;
|
|
read_schematic(schematic: SchematicDefinition | string, options: SchematicReadOptionYSlice[]): Array<any>;
|
|
request_http_api(): HTTPApi;
|
|
get_mod_storage(): MetaRef;
|
|
get_connected_players(): ObjectRef[];
|
|
is_player(thing: ObjectRef): boolean;
|
|
player_exists(playerName: string): boolean;
|
|
hud_replace_builtin(name: HudReplaceBuiltinOption, definition: HudDefinition): void;
|
|
parse_relative_number(arg: ParseRelativeNumberArgument, relativeTo: number): number | void;
|
|
send_join_message(playerName: string): void;
|
|
send_leave_message(playerName: string, timedOut: boolean): void;
|
|
hash_node_position(position: Vec3): number;
|
|
get_position_from_hash(hash: number): Vec3;
|
|
get_item_group(name: string, group: string): number;
|
|
raillike_group(name: string): number;
|
|
get_content_id(name: string): number;
|
|
get_name_from_content_id(id: number): string;
|
|
parse_json(string: string, nullValue: any): Array<any>;
|
|
write_json(data: any[], styled: boolean): string | void;
|
|
serialize(any: any): string;
|
|
deserialize(string: string, safe?: boolean): { [id: string | number | symbol]: any; };
|
|
compress(data: string, method: CompressionMethod, ...any: any): string;
|
|
decompress(data: string, method: CompressionMethod, ...any: any): string;
|
|
rgba(red: number, green: number, blue: number, alpha: number): string;
|
|
encode_base64(string: string): string;
|
|
decode_base64(string: string): string;
|
|
is_protected(position: Vec3, name: string): boolean;
|
|
record_protection_violation(position: Vec3, name: string): void;
|
|
is_creative_enabled(name: string): boolean;
|
|
is_area_protected(pos1: Vec3, pos2: Vec3, playerName: string, interval: number): boolean;
|
|
rotate_and_place(itemStack: ItemStackObject, placer: ObjectRef, pointedThing: PointedThing, infiniteStacks: boolean, orientFlags: RotateAndPlaceOrientationFlag, preventAfterPlace: boolean): ItemStackObject;
|
|
rotate_node(itemStack: ItemStackObject, placer: ObjectRef, pointedThing: PointedThing): void;
|
|
calculate_knockback(player: ObjectRef, hitter: ObjectRef, timeFromLastPunch: number, toolCapabilities: ToolCapabilities, dir: Vec3, distance: number, damage: number): number;
|
|
forceload_block(position: Vec3, transient: boolean, limit: number): boolean;
|
|
forceload_free_block(position: Vec3, transient: boolean): void;
|
|
compare_block_status(position: Vec3, condition: BlockStatusCondition): boolean | void;
|
|
request_insecure_environment(): any;
|
|
global_exists(name: string): boolean;
|
|
|
|
registered_items: { [id: string]: ItemDefinition; };
|
|
registered_nodes: { [id: string]: NodeDefinition; };
|
|
registered_craftitems: { [id: string]: ItemDefinition; };
|
|
registered_tools: { [id: string]: ItemDefinition; };
|
|
registered_entities: { [id: string]: LuaEntity; };
|
|
object_refs: { [id: string]: ObjectRef; };
|
|
luaentities: { [id: string]: LuaEntity; };
|
|
registered_abms: ABMDefinition[];
|
|
registered_lbms: LBMDefinition[];
|
|
registered_aliases: { [id: string]: string; };
|
|
registered_ores: { [id: string]: OreDefinition; };
|
|
registered_biomes: { [id: string]: BiomeDefinition; };
|
|
registered_decorations: { [id: string]: DecorationDefinition; };
|
|
registered_schematics: { [id: string]: SchematicDefinition; };
|
|
registered_chatcommands: { [id: string]: ChatCommandDefinition; };
|
|
registered_privileges: { [id: string]: PrivilegeDefinition; };
|
|
|
|
wrap_text(str: string, limit: number, asTable: boolean): string | string[];
|
|
pos_to_string(position: Vec3, decimalPlaces: number): string;
|
|
string_to_pos(string: string): Vec3;
|
|
string_to_area(positions: string, relativeTo: Vec3): [Vec3, Vec3];
|
|
formspec_escape(string: string): string;
|
|
is_yes(arg: any): boolean;
|
|
is_nan(arg: number): boolean;
|
|
get_us_time(): number;
|
|
pointed_thing_to_face_pos(placer: ObjectRef, pointedThing: PointedThing): Vec3;
|
|
get_tool_wear_after_use(uses: number, initialWear: number): number;
|
|
get_dig_params(groups: string[], toolCapabilities: ToolCapabilities, wear: number): DigParamsReturn;
|
|
get_hit_params(groups: string[], toolCapabilities: ToolCapabilities, timeFromLastPunch: number, wear: number): HitParamsReturn;
|
|
|
|
get_translator(textDomain: string): Translator;
|
|
translate(textDomain: string, ...string: string[]): string;
|
|
|
|
sound_play(spec: SimpleSoundSpec, parameters: SoundParameterTable, ephemeral?: boolean): number;
|
|
sound_stop(handle: number): void;
|
|
sound_fade(handle: number, step: number, gain: number): void;
|
|
|
|
registerTSEntity(clazz: { new(): LuaEntity; }): void;
|
|
|
|
get_color_escape_sequence(color: string): string;
|
|
colorize(color: string, message: string): string;
|
|
get_background_escape_sequence(color: string): string;
|
|
strip_foreground_colors(string: string): string;
|
|
strip_background_colors(string: string): string;
|
|
strip_colors(string: string): string;
|
|
|
|
/**
|
|
* WARNING! THIS IS NOT MEANT TO BE USED IN PRODUCTION!
|
|
* This is only exposed to allow extension!
|
|
*/
|
|
spawn_item(pos: Vec3, item: ItemStackObject | string): ObjectRef | null;
|
|
}
|
|
|
|
|
|
// interface HeightMapObject {
|
|
|
|
// }
|
|
|
|
// interface BiomeMapObject {
|
|
|
|
// }
|
|
|
|
// interface HeatMapObject {
|
|
|
|
// }
|
|
|
|
// interface HumidityMapObject {
|
|
|
|
// }
|
|
|
|
declare global {
|
|
|
|
interface ItemStackObject {
|
|
name: string;
|
|
// count: number
|
|
wear: number;
|
|
metadata: string;
|
|
|
|
is_empty(): boolean;
|
|
get_name(): string;
|
|
set_name(name: string): boolean;
|
|
get_count(): number;
|
|
set_count(count: number): boolean;
|
|
get_wear(): number;
|
|
set_wear(wear: number): boolean;
|
|
get_meta(): MetaRef;
|
|
get_description(): string;
|
|
get_short_description(): string;
|
|
clear(): void;
|
|
replace(item: ItemStackObject | string): void;
|
|
to_string(): string;
|
|
to_table(): any[];
|
|
get_stack_max(): number;
|
|
get_free_space(): number;
|
|
is_known(): boolean;
|
|
get_definition(): ItemDefinition;
|
|
get_tool_capabilities(): ToolCapabilities;
|
|
add_wear(wear: number): void;
|
|
add_wear_by_uses(maxUses: number): void;
|
|
add_item(item: ItemStackObject): ItemStackObject;
|
|
item_fits(item: ItemStackObject): boolean;
|
|
take_item(n: number): ItemStackObject;
|
|
peek_item(n: number): ItemStackObject;
|
|
equals(other: ItemStackObject): boolean;
|
|
}
|
|
|
|
|
|
interface InvRefLocation {
|
|
type: string;
|
|
name: string;
|
|
pos: Vec3;
|
|
}
|
|
|
|
interface InvRef {
|
|
is_empty(listName: string): boolean;
|
|
get_size(listName: string): number;
|
|
set_size(listName: string, size: number): boolean;
|
|
get_width(listName: string): number;
|
|
set_width(listName: string, size: number): void;
|
|
get_stack(listName: string, i: number): ItemStackObject;
|
|
set_stack(listName: string, i: number, stack: ItemStackObject | string): void;
|
|
get_list(listName: string): ItemStackObject[];
|
|
set_list(listName: string, list: ItemStackObject[]): void;
|
|
get_lists(): string[];
|
|
set_lists(lists: ItemStackObject[]): void;
|
|
add_item(listName: string, stack: ItemStackObject | string): ItemStackObject;
|
|
room_for_item(listName: string, stack: ItemStackObject | string): boolean;
|
|
contains_item(listName: string, stack: ItemStackObject | string, matchMeta: boolean): boolean;
|
|
remove_item(listName: string, stack: ItemStackObject | string): ItemStackObject[];
|
|
get_location(): InvRefLocation;
|
|
}
|
|
|
|
interface TreeDefinition {
|
|
axiom: string;
|
|
rules_a: string;
|
|
rules_b: string;
|
|
rules_c: string;
|
|
rules_d: string;
|
|
trunk: string;
|
|
leaves: string;
|
|
leaves2: string;
|
|
leaves2_chance: number;
|
|
angle: number;
|
|
iterations: number;
|
|
random_level: number;
|
|
trunk_type: string;
|
|
thin_branches: boolean;
|
|
fruit: string;
|
|
fruit_chance: number;
|
|
seed: number;
|
|
}
|
|
|
|
type GenNotifyObject = Map<string, Vec3[]>;
|
|
|
|
interface SimpleSoundSpec {
|
|
name?: string;
|
|
gain?: number;
|
|
pitch?: number;
|
|
fade?: number;
|
|
}
|
|
|
|
interface SoundParameterTable extends SimpleSoundSpec {
|
|
start_time?: number;
|
|
loop?: boolean;
|
|
pos?: Vec3;
|
|
object?: ObjectRef;
|
|
to_player?: string;
|
|
max_hear_distance?: number;
|
|
}
|
|
|
|
interface NodeBox {
|
|
type: Nodeboxtype;
|
|
fixed?: boxTable;
|
|
wall_top?: box;
|
|
wall_bottom?: box;
|
|
wall_side?: box;
|
|
connect_top?: box;
|
|
connect_bottom?: box;
|
|
connect_front?: box;
|
|
connect_left?: box;
|
|
connect_back?: box;
|
|
connect_right?: box;
|
|
disconnected_top?: box;
|
|
disconnected_bottom?: box;
|
|
disconnected_front?: box;
|
|
disconnected_left?: box;
|
|
disconnected_back?: box;
|
|
disconnected_right?: box;
|
|
disconnected?: box;
|
|
disconnected_sides?: box;
|
|
}
|
|
|
|
type box = number[];
|
|
|
|
type boxTable = box[];
|
|
|
|
type itemstring = string;
|
|
|
|
|
|
interface GameInfo {
|
|
id: string;
|
|
title: string;
|
|
author: string;
|
|
path: string;
|
|
}
|
|
|
|
interface MinetestFeatures {
|
|
glasslike_framed: boolean;
|
|
nodebox_as_selectionbox: boolean;
|
|
get_all_craft_recipes_works: boolean;
|
|
use_texture_alpha: boolean;
|
|
no_legacy_abms: boolean;
|
|
texture_names_parens: boolean;
|
|
area_store_custom_ids: boolean;
|
|
add_entity_with_staticdata: boolean;
|
|
no_chat_message_prediction: boolean;
|
|
object_use_texture_alpha: boolean;
|
|
object_independent_selectionbox: boolean;
|
|
httpfetch_binary_data: boolean;
|
|
formspec_version_element: boolean;
|
|
area_store_persistent_ids: boolean;
|
|
pathfinder_works: boolean;
|
|
object_step_has_moveresult: boolean;
|
|
direct_velocity_on_players: boolean;
|
|
use_texture_alpha_string_modes: boolean;
|
|
degrotate_240_steps: boolean;
|
|
abm_min_max_y: boolean;
|
|
dynamic_add_media_table: boolean;
|
|
particlespawner_tweenable: boolean;
|
|
get_sky_as_table: boolean;
|
|
get_light_data_buffer: boolean;
|
|
mod_storage_on_disk: boolean;
|
|
compress_zstd: boolean;
|
|
}
|
|
|
|
interface PlayerInformation {
|
|
address: string;
|
|
ip_version: number;
|
|
connection_uptime: number;
|
|
protocol_version: number;
|
|
formspec_version: number;
|
|
lang_code: string;
|
|
min_rtt: number;
|
|
max_rtt: number;
|
|
avg_rtt: number;
|
|
min_jitter: number;
|
|
max_jitter: number;
|
|
avg_jitter: number;
|
|
}
|
|
|
|
interface WindowInformation {
|
|
size: Vec2;
|
|
max_formspec_size: Vec2;
|
|
real_gui_scaling: number;
|
|
real_hud_scaling: number;
|
|
}
|
|
|
|
interface MinetestInfo {
|
|
project: string;
|
|
string: string;
|
|
proto_min: string;
|
|
proto_max: string;
|
|
hash: string;
|
|
is_dev: boolean;
|
|
}
|
|
|
|
interface ColorSpec {
|
|
a: number;
|
|
r: number;
|
|
g: number;
|
|
b: number;
|
|
}
|
|
|
|
interface NodeSoundSpec {
|
|
footstep?: SimpleSoundSpec;
|
|
dig?: SimpleSoundSpec | string;
|
|
dug?: SimpleSoundSpec;
|
|
place?: SimpleSoundSpec;
|
|
place_failed?: SimpleSoundSpec;
|
|
fall?: SimpleSoundSpec;
|
|
}
|
|
|
|
interface ItemDropSpec {
|
|
tools?: string[];
|
|
rarity?: number;
|
|
items?: string[];
|
|
inherit_color?: boolean;
|
|
tool_groups?: string[] | string[][];
|
|
}
|
|
|
|
interface NodeDropSpec {
|
|
max_items?: number;
|
|
items: ItemDropSpec[];
|
|
}
|
|
|
|
interface MapNode {
|
|
name: string;
|
|
prob: number;
|
|
param2: number;
|
|
force_place: boolean;
|
|
}
|
|
|
|
interface NodeTable {
|
|
name: string;
|
|
param1?: number;
|
|
param2?: number;
|
|
}
|
|
|
|
interface PointedThing {
|
|
type: string;
|
|
under: Vec3;
|
|
above: Vec3;
|
|
ref: ObjectRef;
|
|
}
|
|
|
|
interface GroupCap {
|
|
// Allow the end programmer to do it their way.
|
|
times: number[] | { [id: number]: number; },
|
|
uses?: number,
|
|
maxlevel?: number;
|
|
// This is a bolt on specifically for Forgotten Lands. You can still use it though, but it won't do anything without implementation.
|
|
maxdrop?: number;
|
|
}
|
|
|
|
interface ToolCapabilities {
|
|
full_punch_interval?: number;
|
|
max_drop_level?: number;
|
|
groupcaps?: { [id: string]: GroupCap; };
|
|
damage_groups?: { [id: string]: number; };
|
|
punch_attack_uses?: number;
|
|
}
|
|
|
|
interface ItemSounds {
|
|
breaks: SimpleSoundSpec;
|
|
eat: SimpleSoundSpec;
|
|
punch_use: SimpleSoundSpec;
|
|
punch_use_air: SimpleSoundSpec;
|
|
}
|
|
|
|
interface Collision {
|
|
type: string;
|
|
axis: string;
|
|
node_pos: Vec3;
|
|
object: ObjectRef;
|
|
old_velocity: Vec3;
|
|
new_velocity: Vec3;
|
|
}
|
|
|
|
interface MoveResult {
|
|
touching_ground: boolean;
|
|
collides: boolean;
|
|
standing_on_object: boolean;
|
|
collisions: Collision[];
|
|
}
|
|
|
|
|
|
type DynamicColorSpec = (ColorSpec | string);
|
|
|
|
interface ItemDefinition {
|
|
type?: string;
|
|
description?: string;
|
|
short_description?: string;
|
|
groups?: { [id: string]: number; };
|
|
inventory_image?: string;
|
|
inventory_overlay?: string;
|
|
wield_image?: string;
|
|
wield_overlay?: string;
|
|
wield_scale?: Vec3;
|
|
palette?: string;
|
|
color?: string;
|
|
stack_max?: number;
|
|
range?: number;
|
|
liquids_pointable?: boolean;
|
|
light_source?: number;
|
|
tool_capabilities?: ToolCapabilities;
|
|
node_placement_prediction?: string;
|
|
node_dig_prediction?: string;
|
|
sound?: SimpleSoundSpec;
|
|
on_place?(itemStack: ItemStackObject, placer: ObjectRef, pointedThing: PointedThing): void;
|
|
on_secondary_use?(itemStack: ItemStackObject, user: ObjectRef, pointedThing: PointedThing): void;
|
|
on_drop?(itemStack: ItemStackObject, dropper: ObjectRef, position: Vec3): void;
|
|
on_pickup?(itemStack: ItemStackObject, picker: ObjectRef, pointedThing: PointedThing, timeFromLastPunch: number, ...any: any): void;
|
|
on_use?(itemStack: ItemStackObject, user: ObjectRef, pointedThing: PointedThing): void;
|
|
after_use?(itemStack: ItemStackObject, user: ObjectRef, nodeTable: NodeTable, digParams: { string: any; }): void;
|
|
}
|
|
|
|
/** @noSelf */
|
|
interface TileDefinition {
|
|
name: string,
|
|
backface_culling: boolean,
|
|
animation: TileAnimationDefinition;
|
|
}
|
|
|
|
/** @noSelf **/
|
|
interface NodeDefinition {
|
|
description?: string;
|
|
drawtype?: Drawtype;
|
|
visual_scale?: number;
|
|
tiles?: string[] | TileDefinition[];
|
|
overlay_tiles?: string[];
|
|
special_tiles?: string[] | TileDefinition[];
|
|
wield_scale?: Vec3,
|
|
color?: DynamicColorSpec;
|
|
light_source?: number;
|
|
use_texture_alpha?: TextureAlpha;
|
|
palette?: string;
|
|
post_effect_color?: DynamicColorSpec;
|
|
post_effect_color_shaded?: boolean;
|
|
paramtype?: ParamType1;
|
|
paramtype2?: ParamType2;
|
|
place_param2?: number;
|
|
is_ground_content?: boolean;
|
|
sunlight_propagates?: boolean;
|
|
walkable?: boolean;
|
|
groups?: { [id: string]: number; };
|
|
pointable?: boolean;
|
|
diggable?: boolean;
|
|
climbable?: boolean;
|
|
move_resistance?: number;
|
|
buildable_to?: boolean;
|
|
floodable?: boolean;
|
|
liquidtype?: LiquidType;
|
|
liquid_alternative_flowing?: string;
|
|
liquid_alternative_source?: string;
|
|
liquid_viscosity?: number;
|
|
liquid_renewable?: boolean;
|
|
liquid_move_physics?: boolean;
|
|
leveled?: number;
|
|
leveled_max?: number;
|
|
liquid_range?: number;
|
|
drowning?: number;
|
|
damage_per_second?: number;
|
|
node_box?: NodeBox;
|
|
connects_to?: string[];
|
|
connect_sides?: NodeBoxConnections;
|
|
mesh?: string;
|
|
selection_box?: NodeBox;
|
|
collision_box?: NodeBox;
|
|
legacy_facedir_simple?: boolean;
|
|
legacy_wallmounted?: boolean;
|
|
waving?: number;
|
|
sounds?: NodeSoundSpec;
|
|
drop?: NodeDropSpec | string;
|
|
on_construct?(position: Vec3): void;
|
|
on_destruct?(position: Vec3): void;
|
|
after_destruct?(position: Vec3, oldNode: MapNode): void;
|
|
on_flood?(position: Vec3, oldNode: NodeTable, newNode: NodeTable): void;
|
|
preserve_metadata?(position: Vec3, oldNode: NodeTable, oldMeta: NodeTable, drops: ItemStackObject[]): void;
|
|
after_place_node?(position: Vec3, placer: ObjectRef, itemStack: ItemStackObject, pointedThing: PointedThing): void;
|
|
after_dig_node?(position: Vec3, oldNode: NodeTable, oldMeta: string, digger: ObjectRef): void;
|
|
can_dig?(position: Vec3, canDig: ObjectRef): boolean;
|
|
on_punch?(position: Vec3, node: NodeTable, puncher: ObjectRef, pointedThing: PointedThing): void;
|
|
on_rightclick?(position: Vec3, node: NodeTable, clicker: ObjectRef, itemStack: ItemStackObject, pointedThing: PointedThing): void;
|
|
on_dig?(position: Vec3, node: NodeTable, digger: ObjectRef): void;
|
|
on_timer?(position: Vec3, elapsed: number): void;
|
|
on_receive_fields?(position: Vec3, formName: string, fields: { [id: string]: any; }, sender: ObjectRef): void;
|
|
allow_metadata_inventory_move?(position: Vec3, fromList: string, fromIndex: number, toList: string, toIndex: number, count: number, player: ObjectRef): void;
|
|
allow_metadata_inventory_put?(position: Vec3, listName: string, index: number, stack: ItemStackObject, player: ObjectRef): number;
|
|
allow_metadata_inventory_take?(position: Vec3, listName: string, index: number, stack: ItemStackObject, player: ObjectRef): number;
|
|
on_metadata_inventory_move?(position: Vec3, fromList: string, fromIndex: number, toList: string, toIndex: number, count: number, player: ObjectRef): void;
|
|
on_metadata_inventory_put?(position: Vec3, listName: string, index: number, stack: ItemStackObject, player: ObjectRef): void;
|
|
on_metadata_inventory_take?(position: Vec3, listName: string, index: number, stack: ItemStackObject, player: ObjectRef): void;
|
|
on_blast?(position: Vec3, intensity: number): void;
|
|
mod_origin?: string;
|
|
}
|
|
|
|
|
|
|
|
interface MetaRef {
|
|
set_tool_capabilities(toolCapabilities: ToolCapabilities): void;
|
|
contains(key: string): boolean;
|
|
get(key: string): string;
|
|
set_string(key: string, value: string): void;
|
|
get_string(key: string): string;
|
|
set_int(key: string, value: number): void;
|
|
get_int(key: string): number;
|
|
set_float(key: string, value: number): void;
|
|
get_float(key: string): number;
|
|
get_keys(): string[];
|
|
to_table(): MetaData | void;
|
|
from_table(data: MetaData): boolean;
|
|
equals(other: MetaRef): boolean;
|
|
//! FIXME: USE INHERITANCE!
|
|
// node
|
|
get_inventory(): InvRef;
|
|
mark_as_private(nameOrArray: string | string[]): void;
|
|
// timer
|
|
set(timeOut: number, elapsed: number): void;
|
|
start(timeOut: number): void;
|
|
stop(): void;
|
|
get_timeout(): number;
|
|
get_elapsed(): number;
|
|
is_started(): boolean;
|
|
}
|
|
|
|
interface ABMDefinition {
|
|
label: string;
|
|
nodenames: string[];
|
|
neighbors: string[];
|
|
interval: number;
|
|
chance: number;
|
|
min_y: number;
|
|
max_y: number;
|
|
catch_up: number;
|
|
action(pos: Vec3, node: NodeTable, activeObjectCount: number, activeObjectCountWider: number): void;
|
|
}
|
|
|
|
interface LBMDefinition {
|
|
label: string;
|
|
name: string;
|
|
nodenames: string[];
|
|
run_at_every_load: boolean;
|
|
action(pos: Vec3, node: NodeTable, delta: number): void;
|
|
}
|
|
|
|
interface SchematicReadOptionYSlice {
|
|
write_yslice_prob: SchematicReadOptionYSliceOption;
|
|
}
|
|
|
|
interface SchematicData {
|
|
name: string;
|
|
prob: number;
|
|
param1: number;
|
|
param2: number;
|
|
force_place: boolean;
|
|
}
|
|
|
|
interface SchematicProbability {
|
|
pos: Vec3;
|
|
prob: number;
|
|
}
|
|
|
|
interface SchematicSliceProbability {
|
|
ypos: number;
|
|
prob: number;
|
|
}
|
|
|
|
interface SchematicDefinition {
|
|
size: Vec3;
|
|
data: SchematicData[];
|
|
yslice_prob: number[][];
|
|
}
|
|
|
|
|
|
|
|
interface HTTPrequestDefinition {
|
|
url: string;
|
|
timeout: number;
|
|
method: HTTPRequestMethod;
|
|
data: string | { string: string; };
|
|
user_agent: string;
|
|
extra_headers: string[];
|
|
multipart: boolean;
|
|
post_data: string | { string: string; };
|
|
}
|
|
|
|
interface HTTPRequestResult {
|
|
completed: boolean;
|
|
succeeded: boolean;
|
|
timeout: boolean;
|
|
code: number;
|
|
data: string;
|
|
}
|
|
|
|
interface HTTPApi {
|
|
fetch(req: HTTPrequestDefinition, callback: (res: HTTPRequestResult) => void): void;
|
|
fetch_async(req: HTTPrequestDefinition): number;
|
|
fetch_async_get(handle: number): HTTPRequestResult;
|
|
}
|
|
|
|
interface NoiseParams {
|
|
offset: number;
|
|
scale: number;
|
|
spread: Vec3;
|
|
seed: number;
|
|
octaves: number;
|
|
persistence: number;
|
|
lacunarity: number;
|
|
flags: NoiseFlags;
|
|
}
|
|
|
|
interface OreDefinition {
|
|
ore_type: OreType;
|
|
ore: string;
|
|
ore_param2?: number;
|
|
wherein: string;
|
|
clust_scarcity: number;
|
|
clust_num_ores: number;
|
|
clust_size: number;
|
|
y_min: number;
|
|
y_max: number;
|
|
flags?: OreFlags;
|
|
noise_threshold?: number;
|
|
noise_params?: NoiseParams;
|
|
biomes?: string[];
|
|
column_height_min?: number;
|
|
column_height_max?: number;
|
|
column_midpoint_factor?: number;
|
|
np_puff_top?: NoiseParams;
|
|
np_puff_bottom?: NoiseParams;
|
|
random_factor?: number;
|
|
np_stratum_thickness?: NoiseParams;
|
|
stratum_thickness?: number;
|
|
}
|
|
|
|
interface BiomeDefinition {
|
|
name: string;
|
|
node_dust?: string;
|
|
node_top?: string;
|
|
depth_top?: number;
|
|
node_filler?: string;
|
|
depth_filler?: number;
|
|
node_stone?: string;
|
|
node_water_top?: string;
|
|
depth_water_top?: number;
|
|
node_water?: string;
|
|
node_river_water?: string;
|
|
node_riverbed?: string;
|
|
depth_riverbed?: number;
|
|
node_cave_liquid?: string;
|
|
node_dungeon?: string;
|
|
node_dungeon_alt?: string;
|
|
node_dungeon_stair?: string;
|
|
y_max?: number;
|
|
y_min?: number;
|
|
max_pos?: Vec3;
|
|
min_pos?: Vec3;
|
|
vertical_blend?: number;
|
|
heat_point?: number;
|
|
humidity_point?: number;
|
|
}
|
|
|
|
interface DecorationDefinition {
|
|
name: string;
|
|
deco_type?: DecorationType;
|
|
place_on?: string;
|
|
sidelen?: number;
|
|
fill_ratio?: number;
|
|
noise_params?: NoiseParams;
|
|
biomes?: string[];
|
|
y_min?: number;
|
|
y_max?: number;
|
|
spawn_by?: string;
|
|
check_offset?: number;
|
|
num_spawn_by?: number;
|
|
flags?: string | { string: boolean; };
|
|
decoration?: string | string[];
|
|
height?: number;
|
|
height_max?: number;
|
|
param2?: number;
|
|
param2_max?: number;
|
|
place_offset_y?: number;
|
|
schematic?: string | SchematicDefinition | number;
|
|
replacements?: { string: string; };
|
|
rotation?: string;
|
|
}
|
|
|
|
|
|
interface CraftRecipeDefinition {
|
|
type?: CraftRecipeType;
|
|
output?: string;
|
|
recipe: string[][] | string[] | string;
|
|
replacements?: string[];
|
|
additional_wear?: number;
|
|
cooktime?: number;
|
|
burntime?: number;
|
|
}
|
|
|
|
interface CraftResultObject {
|
|
item: ItemStackObject;
|
|
time: number;
|
|
replacements: ItemStackObject[];
|
|
}
|
|
|
|
interface CraftRecipeCheckDefinition {
|
|
method: CraftCheckType;
|
|
width: number;
|
|
items: ItemStackObject[];
|
|
}
|
|
|
|
interface ChatCommandDefinition {
|
|
params: string;
|
|
description: string;
|
|
privs: string[];
|
|
func(name: string, param: string): [boolean, string];
|
|
}
|
|
|
|
interface PrivilegeDefinition {
|
|
description: string;
|
|
give_to_singleplayer: boolean;
|
|
give_to_admin: boolean;
|
|
on_grant(name: string, granterName: string): void;
|
|
on_revoke(name: string, revokerName: string): void;
|
|
}
|
|
|
|
interface AuthenticationHandlerDefinition {
|
|
get_auth(name: string): void;
|
|
create_auth(name: string, password: string): void;
|
|
delete_auth(name: string): void;
|
|
set_password(name: string, password: string): void;
|
|
set_privileges(name: string, privileges: Map<any, any>): void; // ! fixme: this needs to be checked.
|
|
reload(): void;
|
|
record_login(name: string): void;
|
|
iterate(): void;
|
|
}
|
|
|
|
interface HPChangeReasonDefinition {
|
|
type: HPChangeReasonType;
|
|
node: string;
|
|
node_pos: Vec3;
|
|
object: ObjectRef;
|
|
from: string;
|
|
}
|
|
|
|
interface ActionDefinition {
|
|
from_list: string;
|
|
to_list: string;
|
|
from_index: number;
|
|
to_index: number;
|
|
count: number;
|
|
listname: string;
|
|
index: number;
|
|
stack: ItemStackObject;
|
|
}
|
|
|
|
|
|
interface CheatDefinition {
|
|
type: CheatType;
|
|
}
|
|
|
|
|
|
type EmergeAreaCallback = (blockPos: Vec3, action: any, callsRemaining: number, param: any) => void; // ! FIXME: figure out what minetest.EMERGE_CANCELLED EVEN IS!
|
|
|
|
interface BiomeDataDefinition {
|
|
biome: number;
|
|
heat: number;
|
|
humidity: number;
|
|
}
|
|
|
|
interface MapGenSettingsDefinition {
|
|
mgname: string;
|
|
seed: number;
|
|
chunksize: number;
|
|
water_level: number;
|
|
flags: string;
|
|
}
|
|
|
|
|
|
interface MetaData {
|
|
fields: { string: any; };
|
|
inventory: { string: { number: string; }; };
|
|
}
|
|
|
|
function ItemStack(stringOrObject: ItemStackObject | string): ItemStackObject;
|
|
function VoxelManip(_pos1: Vec3, _pos2: Vec3): VoxelManipObject;
|
|
function VoxelArea(_min: Vec3, _max: Vec3): VoxelAreaObject;
|
|
function Raycast(_pos1: Vec3, _pos2: Vec3, _object: boolean, _liquids: boolean): RaycastObject;
|
|
function SecureRandom(): SecureRandomObject;
|
|
function Settings(_: string): MinetestSettingsObject;
|
|
function PcgRandom(seed: number, sequence: number[]): PcgRandomObject;
|
|
function PerlinNoise(params: NoiseParams): PerlinNoiseObject;
|
|
function PerlinNoiseMap(params: NoiseParams, size: Vec3): PerlinNoiseMapObject;
|
|
function PseudoRandom(seed: number): PseudoRandomObject;
|
|
function AreaStore(_: AreaStoreType): AreaStoreObject;
|
|
|
|
namespace vector {
|
|
|
|
function zero(): Vec3;
|
|
function copy(vec: Vec3): Vec3;
|
|
function from_string(s: string, init: string): Vec3;
|
|
function to_string(vec: Vec3): string;
|
|
function direction(vec1: Vec3, vec2: Vec3): Vec3;
|
|
function distance(vec1: Vec3, vec2: Vec3): number;
|
|
function length(vec: Vec3): number;
|
|
function normalize(vec: Vec3): Vec3;
|
|
function floor(vec: Vec3): Vec3;
|
|
function round(vec: Vec3): Vec3;
|
|
function apply(vec: Vec3, fun: (input: number) => number): Vec3;
|
|
function combine(vec1: Vec3, vec2: Vec3, fun: (...any: any) => void): Vec3; //! fixme: test this
|
|
function equals(vec1: Vec3, vec2: Vec3): boolean;
|
|
function sort(vec1: Vec3, vec2: Vec3): [Vec3, Vec3];
|
|
function angle(vec1: Vec3, vec2: Vec3): number;
|
|
function dot(vec1: Vec3, vec2: Vec3): number;
|
|
function cross(vec1: Vec3, vec2: Vec3): number;
|
|
function check(vec: Vec3): boolean;
|
|
function in_area(vec: Vec3, min: Vec3, max: Vec3): boolean;
|
|
|
|
function add(vec: Vec3, scalarOrVec: Vec3 | number): Vec3;
|
|
function subtract(vec: Vec3, scalarOrVec: Vec3 | number): Vec3;
|
|
function multiply(vec: Vec3, scalarOrVec: Vec3 | number): Vec3;
|
|
function divide(vec: Vec3, scalarOrVec: Vec3 | number): Vec3;
|
|
|
|
function rotate(vec: Vec3, radians: number): Vec3;
|
|
function rotate_around_axis(vec: Vec3, vec2: Vec3, radians: number): Vec3;
|
|
function dir_to_rotation(vec: Vec3, up: Vec3): Vec3;
|
|
|
|
// This is created in the utility module because new is a reserved keyword in TS.
|
|
function create3d(x?: number, y?: number, z?: number): Vec3;
|
|
// Everything else is a bolt on created in the utility module.
|
|
function create2d(x?: number, y?: number): Vec2;
|
|
function random(minX: number, maxX: number, minY: number, maxY: number, minZ: number, maxZ: number): Vec3;
|
|
function distance2d(vec1: Vec3, vec2: Vec3): number;
|
|
}
|
|
|
|
interface VoxelManipObject {
|
|
read_from_map(pos1: Vec3, pos2: Vec3): [Vec3, Vec3];
|
|
write_to_map(light: boolean): void;
|
|
get_node_at(position: Vec3): MapNode;
|
|
set_node_at(position: Vec3, node: MapNode): void;
|
|
get_data(buffer?: number[]): number[];
|
|
set_data(buffer?: number[]): number[];
|
|
set_lighting(light: number, p1: Vec3, p2: Vec3): void;
|
|
get_light_data(buffer: number[]): number[];
|
|
set_light_data(lightData: number[]): void;
|
|
get_param2_data(buffer: number[]): number[];
|
|
set_param2_data(param2Data: number[]): void;
|
|
calc_lighting(p1: Vec3, p2: Vec3, propagateShadows: boolean): void;
|
|
update_liquids(): void;
|
|
was_modified(): boolean;
|
|
get_emerged_area(): [Vec3, Vec3];
|
|
}
|
|
|
|
interface VoxelAreaInitializer {
|
|
MinEdge: Vec3;
|
|
MaxEdge: Vec3;
|
|
}
|
|
|
|
interface VoxelAreaObject {
|
|
ystride: number;
|
|
zstride: number;
|
|
new(init: VoxelAreaInitializer): VoxelAreaObject;
|
|
getExtent(): Vec3;
|
|
index(x: number, y: number, z: number): number;
|
|
indexp(p: Vec3): number;
|
|
position(i: number): Vec3;
|
|
contains(x: number, y: number, z: number): boolean;
|
|
containsp(p: Vec3): boolean;
|
|
containsi(i: number): boolean;
|
|
iter(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): Iterator<number>;
|
|
iterp(minp: Vec3, maxp: Vec3): Iterator<number>;
|
|
}
|
|
|
|
interface RaycastObject extends Iterator<PointedThing> { }
|
|
|
|
interface SecureRandomObject {
|
|
next_bytes(count: number): string;
|
|
}
|
|
|
|
|
|
|
|
interface DetachedInventoryCallbacks {
|
|
allow_move(inv: InvRef, fromList: string, fromIndex: number, toList: string, toIndex: number, count: number, player: ObjectRef): number;
|
|
allow_put(inv: InvRef, listName: string, index: number, stack: ItemStackObject, player: ObjectRef): number;
|
|
allow_take(inv: InvRef, listName: string, index: number, stack: ItemStackObject, player: ObjectRef): number;
|
|
on_move(inv: InvRef, fromList: string, fromIndex: number, toList: string, toIndex: number, count: number, player: ObjectRef): void;
|
|
on_put(inv: InvRef, listName: string, index: number, stack: ItemStackObject, player: ObjectRef): void;
|
|
on_take(inv: InvRef, listName: string, index: number, stack: ItemStackObject, player: ObjectRef): void;
|
|
}
|
|
|
|
interface AreaStoreObject {
|
|
get_area(id: number, includeCorners: boolean, includeData: boolean): Array<AreaStoreArea | boolean> | void;
|
|
get_areas_for_pos(pos: Vec3, includeCorners: boolean, includeData: boolean): Array<AreaStoreArea | boolean> | void;
|
|
get_areas_in_area(corner1: Vec3, corner2: Vec3, acceptOverlap: boolean, includeCorners: boolean, includeData: boolean): Array<AreaStoreArea | boolean> | void;
|
|
insert_area(corner1: Vec3, corner2: Vec3, data: string, id: number): number;
|
|
reserve(count: number): void;
|
|
remove_area(id: number): boolean;
|
|
set_cache_params(params: AreaStoreCacheDefinition): void;
|
|
to_string(): string;
|
|
to_file(fileName: string): void;
|
|
from_string(str: string): [boolean, string] | void;
|
|
from_file(fileName: string): [boolean, string] | void;
|
|
}
|
|
|
|
|
|
interface MinetestSettingsObject {
|
|
get(key: string): any;
|
|
get_bool(key: string, defaul?: boolean): boolean | null;
|
|
get_np_group(key: string): NoiseParams;
|
|
get_flags(key: string): { string: boolean; };
|
|
set(key: string, value: string): void;
|
|
set_bool(key: string, value: boolean): void;
|
|
set_np_group(key: string, value: NoiseParams): void;
|
|
remove(key: string): boolean;
|
|
get_names(): string[];
|
|
has(key: string): boolean;
|
|
write(): boolean;
|
|
to_table(): Map<string, any>;
|
|
}
|
|
|
|
interface NametagAttributes {
|
|
text: string;
|
|
color: RGBA;
|
|
bgcolor: RGBA;
|
|
}
|
|
|
|
interface AttachRef {
|
|
parent: ObjectRef;
|
|
bone: string;
|
|
position: Vec3;
|
|
rotation: Vec3;
|
|
forced_visible: boolean;
|
|
}
|
|
|
|
interface BoneOverrideProperty {
|
|
vec: Vec3,
|
|
interpolation: number,
|
|
/** If set to false, it's relative to the animated property. */
|
|
absolute: boolean;
|
|
}
|
|
|
|
interface BoneOverride {
|
|
position?: BoneOverrideProperty,
|
|
rotation?: BoneOverrideProperty,
|
|
scale?: BoneOverrideProperty,
|
|
}
|
|
|
|
interface ObjectRef {
|
|
get_pos(): Vec3;
|
|
set_pos(position: Vec3): void;
|
|
get_velocity(): Vec3;
|
|
add_velocity(velocity: Vec3): void;
|
|
move_to(newPos: Vec3, continuous: boolean): void;
|
|
punch(puncher: ObjectRef, timeFromLastPunch: number, toolCapabilities: ToolCapabilities, dir: Vec3): void;
|
|
right_click(clicker: ObjectRef): void;
|
|
get_hp(): number;
|
|
set_hp(hp: number, reason: HPChangeReasonType): void;
|
|
get_inventory(): InvRef;
|
|
get_wield_list(): string;
|
|
get_wield_index(): number;
|
|
get_wielded_item(): ItemStackObject;
|
|
set_wielded_item(item: ItemStackObject): boolean;
|
|
get_armor_groups(): { string: number; };
|
|
set_armor_groups(groups: { [id: string]: number; }): void;
|
|
get_animation(): Array<Vec2 | number>;
|
|
set_animation(frameRange: Vec2, frameSpeed: number, frameBlend: number, loop: boolean): void;
|
|
set_animation_frame_speed(speed: number): void;
|
|
set_attach(parent: ObjectRef, bone: string, position: Vec3, rotation: Vec3, forcedVisible: boolean): void;
|
|
get_attach(): AttachRef | void;
|
|
get_children(): ObjectRef[];
|
|
set_detach(): void;
|
|
set_bone_override(bone: string, property: BoneOverride | null): void;
|
|
get_bone_override(bone: string): BoneOverride;
|
|
get_bone_overrides(): { [key: string]: BoneOverride; };
|
|
set_properties(objectPropertiesTable: ObjectProperties): void;
|
|
get_properties(): ObjectProperties;
|
|
is_player(): boolean;
|
|
get_nametag_attributes(): NametagAttributes;
|
|
set_nametag_attributes(attributes: NametagAttributes): void;
|
|
remove(): void;
|
|
set_velocity(velocity: Vec3): void;
|
|
set_acceleration(acceleration: Vec3): void;
|
|
get_acceleration(): Vec3;
|
|
set_rotation(rotation: Vec3): void;
|
|
get_rotation(): Vec3;
|
|
set_yaw(yaw: number): void;
|
|
get_yaw(): number;
|
|
set_texture_mod(mod: string): void;
|
|
get_texture_mod(): string;
|
|
set_sprite(startFrame: Vec2, numberOfFrames: number, frameLength: number, selectXByCamera: boolean): void;
|
|
name: string;
|
|
get_luaentity(): LuaEntity;
|
|
get_player_name(): string;
|
|
get_look_dir(): Vec3;
|
|
get_look_vertical(): number;
|
|
get_look_horizontal(): number;
|
|
set_look_vertical(radians: number): void;
|
|
set_look_horizontal(radians: number): void;
|
|
get_look_pitch(): number;
|
|
get_look_yaw(): number;
|
|
set_look_pitch(radians: number): void;
|
|
set_look_yaw(radians: number): void;
|
|
get_breath(): number;
|
|
set_breath(value: number): void;
|
|
set_fov(fov: number, isMultiplier: boolean, transitionTime: number): void;
|
|
get_fov(): number;
|
|
get_meta(): MetaRef;
|
|
set_inventory_formspec(formSpec: string): void;
|
|
get_inventory_formspec(): string;
|
|
set_formspec_prepend(formSpec: string): void;
|
|
get_formspec_prepend(): string;
|
|
get_player_control(): PlayerControlObject;
|
|
get_player_control_bits(): number;
|
|
set_physics_override(override: PhysicsOverride): void;
|
|
get_physics_override(): PhysicsOverride;
|
|
hud_add(definition: HudDefinition): number;
|
|
hud_remove(id: number): void;
|
|
hud_change(id: number, stat: HudElementType, value: any): void;
|
|
hud_get(id: number): HudDefinition;
|
|
hud_set_flags(flags: HudFlags): void;
|
|
hud_get_flags(): HudFlags;
|
|
hud_set_hotbar_itemcount(count: number): void;
|
|
hud_get_hotbar_itemcount(): number;
|
|
hud_set_hotbar_image(textureName: string): void;
|
|
hud_get_hotbar_image(): string;
|
|
hud_set_hotbar_selected_image(textureName: string): void;
|
|
hud_get_hotbar_selected_image(): string;
|
|
set_minimap_modes(mode: MinimapModes, selectedMode: number): void;
|
|
set_sky(parameters: SkyParameters): void;
|
|
get_sky(asTable: true): SkyParameters;
|
|
set_sun(parameters: SunParameters): void;
|
|
get_sun(): SunParameters;
|
|
set_moon(parameters: MoonParameters): void;
|
|
get_moon(): MoonParameters;
|
|
set_stars(parameters: StarParameters): void;
|
|
get_stars(): StarParameters;
|
|
set_clouds(parameters: CloudParameters): void;
|
|
get_clouds(): CloudParameters;
|
|
override_day_night_ratio(ratio: number | void): void;
|
|
get_day_night_ratio(): number | void;
|
|
set_local_animation(idle: Vec2, walk: Vec2, dig: Vec2, walkWhileDig: Vec2, frameSpeed: number): void;
|
|
get_local_animation(): [Vec2, Vec2, Vec2, Vec2, number];
|
|
set_eye_offset(firstPerson: Vec3, thirdPersonBack: Vec3, thirdPersonFront: Vec3): void;
|
|
get_eye_offset(): [Vec3, Vec3, Vec3];
|
|
send_mapblock(blockPos: Vec3): boolean;
|
|
set_lighting(definition: LightingDefinition): void;
|
|
get_lighting(): LightingDefinition;
|
|
respawn(): void;
|
|
}
|
|
|
|
interface PlayerControlObject {
|
|
up: boolean,
|
|
down: boolean,
|
|
left: boolean,
|
|
right: boolean,
|
|
jump: boolean,
|
|
aux1: boolean,
|
|
sneak: boolean,
|
|
dig: boolean,
|
|
place: boolean,
|
|
LMB: boolean,
|
|
RMB: boolean,
|
|
zoom: boolean,
|
|
}
|
|
|
|
enum _Keys {
|
|
up = "up",
|
|
down = "down",
|
|
left = "left",
|
|
right = "right",
|
|
jump = "jump",
|
|
aux1 = "aux1",
|
|
sneak = "sneak",
|
|
dig = "dig",
|
|
place = "place",
|
|
LMB = "LMB",
|
|
RMB = "RMB",
|
|
zoom = "zoom",
|
|
}
|
|
|
|
interface PcgRandomObject {
|
|
next(): number;
|
|
next(min: number, max: number): number;
|
|
rand_normal_dist(min: number, max: number, trials: number): number;
|
|
}
|
|
|
|
interface PerlinNoiseObject {
|
|
get_2d(position: Vec2): number;
|
|
get_3d(position: Vec3): number;
|
|
}
|
|
|
|
interface PerlinNoiseMapObject {
|
|
get_2d_map(pos: Vec2): number[][];
|
|
get_3d_map(pos: Vec3): number[][][];
|
|
get_2d_map_flat(pos: Vec2, buffer: number[]): number[];
|
|
get_3d_map_flat(pos: Vec3, buffer: number[]): number[];
|
|
calc_2d_map(pos: Vec2): void;
|
|
calc_3d_map(pos: Vec3): void;
|
|
get_map_slice(sliceOffset: Vec3, sliceSize: Vec3, buffer: number[]): number[];
|
|
}
|
|
|
|
interface PseudoRandomObject {
|
|
next(): number;
|
|
next(min: number, max: number): number;
|
|
}
|
|
|
|
interface PhysicsOverride {
|
|
speed: number;
|
|
jump: number;
|
|
gravity: number;
|
|
speed_climb: number;
|
|
speed_crouch: number;
|
|
liquid_fluidity: number;
|
|
liquid_fluidity_smooth: number;
|
|
liquid_sink: number;
|
|
acceleration_default: number;
|
|
acceleration_air: number;
|
|
sneak: boolean;
|
|
sneak_glitch: boolean;
|
|
new_move: boolean;
|
|
}
|
|
|
|
interface SkyParametersColor {
|
|
day_sky: DynamicColorSpec;
|
|
day_horizon: DynamicColorSpec;
|
|
dawn_sky: DynamicColorSpec;
|
|
dawn_horizon: DynamicColorSpec;
|
|
nigh_sky: DynamicColorSpec;
|
|
night_horizon: DynamicColorSpec;
|
|
indoors: DynamicColorSpec;
|
|
fog_sun_tint: DynamicColorSpec;
|
|
fog_moon_tint: DynamicColorSpec;
|
|
fog_tint_type: SkyParametersFogTintType;
|
|
}
|
|
|
|
interface SkyParametersFog {
|
|
fog_distance: number;
|
|
fog_start: number;
|
|
}
|
|
|
|
interface SkyParameters {
|
|
base_color: DynamicColorSpec;
|
|
body_orbit_tilt: number;
|
|
type: SkyParametersType;
|
|
textures: string[];
|
|
clouds: boolean;
|
|
sky_color: SkyParametersColor;
|
|
fog: SkyParametersFog;
|
|
}
|
|
|
|
interface SunParameters {
|
|
visible: boolean;
|
|
texture: string;
|
|
tonemap: string;
|
|
sunrise: string;
|
|
sunrise_visible: boolean;
|
|
scale: number;
|
|
}
|
|
|
|
interface MoonParameters {
|
|
visible: boolean;
|
|
texture: string;
|
|
tonemap: string;
|
|
scale: number;
|
|
}
|
|
|
|
interface StarParameters {
|
|
visible: boolean;
|
|
day_opacity: number;
|
|
count: number;
|
|
star_color: DynamicColorSpec;
|
|
scale: number;
|
|
}
|
|
|
|
interface CloudParameters {
|
|
density: number;
|
|
color: DynamicColorSpec;
|
|
ambient: DynamicColorSpec;
|
|
height: number;
|
|
thickness: number;
|
|
speed: Vec2;
|
|
}
|
|
|
|
interface LightShadowsSpec {
|
|
intensity: number;
|
|
}
|
|
|
|
interface LightExposureSpec {
|
|
luminance_min: number;
|
|
luminance_max: number;
|
|
exposure_correction: number;
|
|
speed_dark_bright: number;
|
|
speed_bright_dark: number;
|
|
center_weight_power: number;
|
|
}
|
|
|
|
interface LightingDefinition {
|
|
saturation?: number;
|
|
shadows?: LightShadowsSpec;
|
|
exposure?: LightExposureSpec;
|
|
}
|
|
|
|
type CollisionBox = Array<number>;
|
|
|
|
interface ObjectProperties {
|
|
hp_max?: number;
|
|
breath_max?: number;
|
|
zoom_fov?: number;
|
|
eye_height?: number;
|
|
physical?: boolean;
|
|
wield_item?: string;
|
|
collide_with_objects?: boolean;
|
|
collisionbox?: CollisionBox;
|
|
selectionbox?: number[];
|
|
pointable?: boolean;
|
|
visual?: EntityVisual;
|
|
visual_size?: Vec3 | Vec2;
|
|
mesh?: string;
|
|
textures?: string[];
|
|
colors?: DynamicColorSpec[];
|
|
use_texture_alpha?: boolean;
|
|
spritediv?: Vec2;
|
|
initial_sprite_basepos?: Vec2;
|
|
is_visible?: boolean;
|
|
makes_footstep_sound?: boolean;
|
|
automatic_rotate?: number;
|
|
stepheight?: number;
|
|
automatic_face_movement_dir?: number;
|
|
automatic_face_movement_max_rotation_per_sec?: number;
|
|
backface_culling?: boolean;
|
|
glow?: number;
|
|
nametag?: string;
|
|
nametag_color?: ColorSpec;
|
|
nametag_bgcolor?: ColorSpec;
|
|
infotext?: string;
|
|
static_save?: boolean;
|
|
damage_texture_modifier?: string;
|
|
shaded?: boolean;
|
|
show_on_minimap?: boolean;
|
|
}
|
|
|
|
interface LuaEntity {
|
|
__index?: LuaEntity;
|
|
initial_properties?: ObjectProperties;
|
|
name: string;
|
|
object: ObjectRef;
|
|
on_activate?(staticData: string, delta: number): void;
|
|
on_deactivate?(removal: boolean): void;
|
|
on_step?(delta: number, moveResult: MoveResult): void;
|
|
on_punch?(puncher: ObjectRef, timeFromLastPunch: number, toolCapabilities: ToolCapabilities, dir: Vec3, damage: number): void;
|
|
on_death?(killer: ObjectRef): void;
|
|
on_rightclick?(clicker: ObjectRef): void;
|
|
on_attach_child?(child: ObjectRef): void;
|
|
on_detach_child?(child: ObjectRef): void;
|
|
on_detach?(parent: ObjectRef): void;
|
|
get_staticdata?(): string;
|
|
}
|
|
|
|
|
|
|
|
interface MinimapModes {
|
|
type: MinimapType;
|
|
label: string;
|
|
size: number;
|
|
texture: string;
|
|
scale: number;
|
|
}
|
|
|
|
interface HudFlags {
|
|
hotbar: boolean;
|
|
healthbar: boolean;
|
|
crosshair: boolean;
|
|
wielditem: boolean;
|
|
breathbar: boolean;
|
|
minimap: boolean;
|
|
minimap_radar: boolean;
|
|
basic_debug: boolean;
|
|
}
|
|
|
|
interface HudDefinition {
|
|
hud_elem_type: HudElementType;
|
|
position: Vec2;
|
|
name: string;
|
|
scale: Vec2;
|
|
text: string;
|
|
text2: string;
|
|
number: number;
|
|
item: number;
|
|
direction: number;
|
|
alignment: Vec2;
|
|
offset: Vec2;
|
|
world_pos: Vec3;
|
|
size: Vec2;
|
|
z_index: number;
|
|
style: number;
|
|
}
|
|
|
|
interface TileAnimationDefinition {
|
|
type?: TileAnimationType;
|
|
aspect_w?: number;
|
|
aspect_h?: number;
|
|
length?: number;
|
|
frames_w?: number;
|
|
frames_h?: number;
|
|
frame_length?: number;
|
|
}
|
|
|
|
interface Rollback {
|
|
actor: string;
|
|
pos: Vec3;
|
|
time: number;
|
|
oldnode: string;
|
|
newnode: string;
|
|
}
|
|
|
|
interface Job {
|
|
cancel(): void;
|
|
}
|
|
|
|
interface DynamicAddMediaOptions {
|
|
filepath: string;
|
|
to_player: string;
|
|
ephemeral: boolean;
|
|
}
|
|
|
|
interface ParticleBounceDefinition {
|
|
min: number;
|
|
max: number;
|
|
bias: number;
|
|
}
|
|
|
|
interface ParticleDefinition {
|
|
pos: Vec3;
|
|
velocity: Vec3;
|
|
acceleration: Vec3;
|
|
expirationtime: number;
|
|
size: number;
|
|
collisiondetection: boolean;
|
|
collision_removal: boolean;
|
|
object_collision: boolean;
|
|
vertical: boolean;
|
|
texture: string;
|
|
playername: string;
|
|
animation: TileAnimationDefinition;
|
|
glow: number;
|
|
node: NodeTable;
|
|
node_tile: NodeSoundSpec;
|
|
drag: Vec3;
|
|
bounce: ParticleBounceDefinition;
|
|
}
|
|
|
|
interface ParticleSpawnerTweenDefinition extends Array<number | ParticleSpawnerRangeDefinition> {
|
|
// {number | ParticleSpawnerRangeDefinition}
|
|
style: ParticleSpawnerTweenStyle;
|
|
reps: number;
|
|
start: number;
|
|
}
|
|
|
|
interface ParticleSpawnerRangeDefinition {
|
|
min: Vec3;
|
|
max: Vec3;
|
|
bias: number;
|
|
pos_tween: ParticleSpawnerTweenDefinition;
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
}
|
|
|
|
type ParticleSpawnerTextureScaleTween = Array<Vec2>;
|
|
|
|
interface ParticleSpawnerTextureDefinition {
|
|
name: string;
|
|
alpha: number;
|
|
alpha_tween: number[];
|
|
scale: number | Vec2;
|
|
scale_tween: ParticleSpawnerTextureScaleTween;
|
|
blend: ParticleSpawnerTextureBlend;
|
|
animation: TileAnimationDefinition;
|
|
}
|
|
|
|
interface TexturePoolComponentTweenDefinition extends Array<number> {
|
|
style: ParticleSpawnerTweenStyle;
|
|
reps: number;
|
|
}
|
|
|
|
interface TexturePoolComponentDefinition {
|
|
name: string;
|
|
fade: TexturePoolComponentFade;
|
|
alpha: number;
|
|
scale: number;
|
|
animation: TileAnimationDefinition;
|
|
alpha_tween: TexturePoolComponentTweenDefinition;
|
|
}
|
|
|
|
type ParticleSpawnerTexturePoolDefinition = Array<string | TexturePoolComponentDefinition>;
|
|
|
|
interface ParticleSpawnerAttractionDefinition {
|
|
kind: ParticleSpawnerAttractionType;
|
|
strength: Vec2;
|
|
origin: Vec3;
|
|
direction: Vec3;
|
|
origin_attached: ObjectRef;
|
|
direction_attached: ObjectRef;
|
|
die_on_contact: boolean;
|
|
}
|
|
|
|
interface ParticleSpawnerDefinition {
|
|
maxpos: Vec3;
|
|
minpos: Vec3;
|
|
pos: number | ParticleSpawnerRangeDefinition;
|
|
vel: Vec3RangeBias;
|
|
acc: Vec3RangeBias;
|
|
jitter: Vec3RangeBias;
|
|
drag: Vec3RangeBias;
|
|
bounce: Vec3RangeBias;
|
|
exptime: Vec2;
|
|
attract: ParticleSpawnerAttractionDefinition;
|
|
radius: Vec3RangeBias;
|
|
pos_tween: ParticleSpawnerTweenDefinition;
|
|
texture: string | ParticleSpawnerTextureDefinition;
|
|
texpool: ParticleSpawnerTexturePoolDefinition;
|
|
}
|
|
|
|
interface AreaStoreArea {
|
|
min: Vec3;
|
|
max: Vec3;
|
|
data: string;
|
|
}
|
|
|
|
interface AreaStoreCacheDefinition {
|
|
enabled: boolean;
|
|
block_radius: number;
|
|
limit: number;
|
|
}
|
|
|
|
interface Vec2 {
|
|
x: number;
|
|
y: number;
|
|
}
|
|
|
|
interface Vec3 extends Vec2 {
|
|
__eq(other: Vec3): boolean;
|
|
__unm(): Vec3;
|
|
__add(other: Vec3): Vec3;
|
|
__sub(other: Vec3): Vec3;
|
|
__mul(other: Vec3): Vec3;
|
|
__div(other: Vec3): Vec3;
|
|
|
|
z: number;
|
|
}
|
|
|
|
|
|
interface Vec3RangeBias {
|
|
min: Vec3;
|
|
max: Vec3;
|
|
bias: Vec3;
|
|
}
|
|
|
|
interface RGBA {
|
|
r: number;
|
|
g: number;
|
|
b: number;
|
|
a: number;
|
|
}
|
|
|
|
|
|
interface DigParamsReturn {
|
|
diggable: boolean;
|
|
time: number;
|
|
wear: number;
|
|
groups: string[];
|
|
tool_capabilities: ToolCapabilities;
|
|
}
|
|
|
|
interface HitParamsReturn {
|
|
hp: number;
|
|
wear: number;
|
|
groups: string[];
|
|
tool_capabilities: ToolCapabilities;
|
|
time_from_last_punch: number;
|
|
}
|
|
|
|
interface NodeTimerObject {
|
|
set(timeOut: number, elapsed: number): void;
|
|
start(timeOut: number): void;
|
|
stop(): void;
|
|
get_timeout(): number;
|
|
get_elapsed(): number;
|
|
is_started(): boolean;
|
|
}
|
|
|
|
function dump(object: any, name?: string, dumped?: any[]): string;
|
|
|
|
function dump2(object: any, dumped?: any[]): string;
|
|
|
|
interface Translator {
|
|
__call(...string: string[]): string;
|
|
}
|
|
|
|
|
|
// You can just bolt onto namespaces apparently!
|
|
namespace math {
|
|
function hypot(x: number, y: number): number;
|
|
function sign(x: number, tolerance: number): number;
|
|
function factorial(x: number): number;
|
|
function round(x: number): number;
|
|
// Clamp is a bolt on created in.
|
|
function clamp(min: number, max: number, input: number): number;
|
|
// So is this.
|
|
function cosFromSin(sin: number, angle: number): number;
|
|
// And this (required to D/Java style float to int truncation)
|
|
function truncate(floating: number): number;
|
|
function fma(x: number, y: number, z: number): number;
|
|
function invsqrt(r: number): number;
|
|
function safeAsin(r: number): number;
|
|
}
|
|
|
|
namespace string {
|
|
function split(str: string, separator: string, includeEmpty: box, maxSplits: number, sepIsPattern: boolean): string;
|
|
function trim(str: string): string;
|
|
}
|
|
namespace table {
|
|
function copy(table: LuaTable): LuaTable;
|
|
function indexof(list: LuaTable, val: any): number;
|
|
function insert_all(table: LuaTable, otherTable: LuaTable): LuaTable;
|
|
function key_value_swap(t: LuaTable): LuaTable;
|
|
function shuffle(table: LuaTable, from: number, to: number, randomFunc: () => number): LuaTable;
|
|
}
|
|
}
|
|
|
|
// Very annoying enums.
|
|
// Why do they point to themselves? I dunno, it works though.
|
|
//! If you don't have your mod depend on the utility library, this will just blow up when you try to use it. :D
|
|
|
|
declare interface EntityVisual {
|
|
cube: EntityVisual,
|
|
sprite: EntityVisual,
|
|
upright_sprite: EntityVisual,
|
|
mesh: EntityVisual,
|
|
wielditem: EntityVisual,
|
|
item: EntityVisual;
|
|
}
|
|
|
|
declare interface SchematicRotation {
|
|
zero: SchematicRotation,
|
|
ninety: SchematicRotation,
|
|
oneEighty: SchematicRotation,
|
|
twoSeventy: SchematicRotation,
|
|
random: SchematicRotation;
|
|
}
|
|
|
|
declare interface SchematicPlacementFlag {
|
|
place_center_x: SchematicPlacementFlag,
|
|
place_center_y: SchematicPlacementFlag,
|
|
place_center_z: SchematicPlacementFlag;
|
|
}
|
|
|
|
declare interface SchematicFormat {
|
|
mts: SchematicFormat,
|
|
lua: SchematicFormat;
|
|
}
|
|
|
|
declare interface SchematicSerializationOption {
|
|
lua_use_comments: SchematicSerializationOption,
|
|
lua_num_indent_spaces: SchematicSerializationOption;
|
|
}
|
|
|
|
declare interface SchematicReadOptionYSliceOption {
|
|
none: SchematicReadOptionYSliceOption,
|
|
low: SchematicReadOptionYSliceOption,
|
|
all: SchematicReadOptionYSliceOption;
|
|
}
|
|
|
|
declare interface HTTPRequestMethod {
|
|
GET: HTTPRequestMethod,
|
|
POST: HTTPRequestMethod,
|
|
PUT: HTTPRequestMethod,
|
|
DELETE: HTTPRequestMethod;
|
|
}
|
|
|
|
|
|
declare interface OreType {
|
|
scatter: OreType,
|
|
sheet: OreType,
|
|
puff: OreType,
|
|
blob: OreType,
|
|
vein: OreType,
|
|
stratum: OreType;
|
|
}
|
|
|
|
declare interface OreFlags {
|
|
puff_cliffs: OreFlags,
|
|
puff_additive_composition: OreFlags;
|
|
}
|
|
|
|
declare interface NoiseFlags {
|
|
defaults: NoiseFlags,
|
|
eased: NoiseFlags,
|
|
absvalue: NoiseFlags;
|
|
}
|
|
|
|
declare interface DecorationType {
|
|
simple: DecorationType,
|
|
schematic: DecorationType;
|
|
}
|
|
|
|
declare interface DecorationFlags {
|
|
liquid_surface: DecorationFlags,
|
|
force_placement: DecorationFlags,
|
|
all_floors: DecorationFlags,
|
|
all_ceilings: DecorationFlags,
|
|
place_center_x: DecorationFlags,
|
|
place_center_y: DecorationFlags,
|
|
place_center_z: DecorationFlags;
|
|
}
|
|
|
|
|
|
declare interface ParamType1 {
|
|
light: ParamType1,
|
|
none: ParamType1;
|
|
}
|
|
|
|
declare interface ParamType2 {
|
|
flowingliquid: ParamType2,
|
|
wallmounted: ParamType2,
|
|
facedir: ParamType2,
|
|
fourdir: ParamType2,
|
|
leveled: ParamType2,
|
|
degrotate: ParamType2,
|
|
meshoptions: ParamType2,
|
|
color: ParamType2,
|
|
colorfacedir: ParamType2,
|
|
color4dir: ParamType2,
|
|
colorwallmounted: ParamType2,
|
|
glasslikeliquidlevel: ParamType2,
|
|
colordegrotate: ParamType2;
|
|
}
|
|
|
|
declare interface Drawtype {
|
|
normal: Drawtype,
|
|
airlike: Drawtype,
|
|
liquid: Drawtype,
|
|
flowingliquid: Drawtype,
|
|
glasslike: Drawtype,
|
|
glasslike_framed: Drawtype,
|
|
glasslike_framed_optional: Drawtype,
|
|
allfaces: Drawtype,
|
|
allfaces_optional: Drawtype,
|
|
torchlike: Drawtype,
|
|
signlike: Drawtype,
|
|
plantlike: Drawtype,
|
|
firelike: Drawtype,
|
|
fencelike: Drawtype,
|
|
raillike: Drawtype,
|
|
nodebox: Drawtype,
|
|
mesh: Drawtype,
|
|
plantlike_rooted: Drawtype;
|
|
}
|
|
|
|
|
|
declare interface Nodeboxtype {
|
|
regular: Nodeboxtype,
|
|
fixed: Nodeboxtype,
|
|
wallmounted: Nodeboxtype,
|
|
connected: Nodeboxtype;
|
|
}
|
|
|
|
|
|
declare interface LogLevel {
|
|
none: LogLevel,
|
|
error: LogLevel,
|
|
warning: LogLevel,
|
|
action: LogLevel,
|
|
info: LogLevel,
|
|
verbose: LogLevel;
|
|
}
|
|
|
|
declare interface TextureAlpha {
|
|
opaque: TextureAlpha,
|
|
clip: TextureAlpha,
|
|
blend: TextureAlpha;
|
|
}
|
|
|
|
declare interface LiquidType {
|
|
none: LiquidType,
|
|
source: LiquidType,
|
|
flowing: LiquidType;
|
|
}
|
|
|
|
declare interface NodeBoxConnections {
|
|
top: NodeBoxConnections,
|
|
bottom: NodeBoxConnections,
|
|
front: NodeBoxConnections,
|
|
left: NodeBoxConnections,
|
|
back: NodeBoxConnections,
|
|
right: NodeBoxConnections;
|
|
}
|
|
|
|
declare interface CraftRecipeType {
|
|
shapeless: CraftRecipeType,
|
|
toolrepair: CraftRecipeType,
|
|
cooking: CraftRecipeType,
|
|
fuel: CraftRecipeType;
|
|
}
|
|
|
|
declare interface CraftCheckType {
|
|
normal: CraftCheckType,
|
|
cooking: CraftCheckType,
|
|
fuel: CraftCheckType;
|
|
}
|
|
|
|
declare interface HPChangeReasonType {
|
|
set_hp: HPChangeReasonType,
|
|
punch: HPChangeReasonType,
|
|
fall: HPChangeReasonType,
|
|
node_damage: HPChangeReasonType,
|
|
drown: HPChangeReasonType,
|
|
respawn: HPChangeReasonType;
|
|
}
|
|
|
|
declare interface CheatType {
|
|
moved_too_fast: CheatType,
|
|
interacted_too_far: CheatType,
|
|
interacted_with_self: CheatType,
|
|
interacted_while_dead: CheatType,
|
|
finished_unknown_dig: CheatType,
|
|
dug_unbreakable: CheatType,
|
|
dug_too_fast: CheatType;
|
|
}
|
|
|
|
declare interface ClearObjectsOptions {
|
|
full: ClearObjectsOptions,
|
|
quick: ClearObjectsOptions;
|
|
}
|
|
|
|
declare interface GenNotifyFlags {
|
|
dungeon: GenNotifyFlags,
|
|
temple: GenNotifyFlags,
|
|
cave_begin: GenNotifyFlags,
|
|
cave_end: GenNotifyFlags,
|
|
large_cave_begin: GenNotifyFlags,
|
|
large_cave_end: GenNotifyFlags,
|
|
decoration: GenNotifyFlags;
|
|
}
|
|
|
|
declare interface SearchAlgorithm {
|
|
aStarNoprefetch: SearchAlgorithm,
|
|
aStar: SearchAlgorithm,
|
|
dijkstra: SearchAlgorithm;
|
|
}
|
|
|
|
|
|
declare interface SkyParametersType {
|
|
regular: SkyParametersType,
|
|
skybox: SkyParametersType,
|
|
plain: SkyParametersType;
|
|
}
|
|
|
|
declare interface SkyParametersFogTintType {
|
|
custom: SkyParametersFogTintType,
|
|
default: SkyParametersFogTintType;
|
|
}
|
|
|
|
declare interface MinimapType {
|
|
off: MinimapType,
|
|
surface: MinimapType,
|
|
radar: MinimapType,
|
|
texture: MinimapType;
|
|
}
|
|
|
|
declare interface HudElementType {
|
|
image: HudElementType,
|
|
text: HudElementType,
|
|
statbar: HudElementType,
|
|
inventory: HudElementType,
|
|
waypoint: HudElementType,
|
|
image_waypoint: HudElementType,
|
|
compass: HudElementType,
|
|
minimap: HudElementType;
|
|
}
|
|
|
|
declare interface HudReplaceBuiltinOption {
|
|
breath: HudReplaceBuiltinOption,
|
|
health: HudReplaceBuiltinOption;
|
|
}
|
|
|
|
|
|
declare interface ParseRelativeNumberArgument {
|
|
number: ParseRelativeNumberArgument,
|
|
relativeToPlus: ParseRelativeNumberArgument,
|
|
relativeTo: ParseRelativeNumberArgument;
|
|
}
|
|
|
|
declare interface CompressionMethod {
|
|
deflate: CompressionMethod,
|
|
zstd: CompressionMethod;
|
|
}
|
|
|
|
declare interface RotateAndPlaceOrientationFlag {
|
|
invert_wall: RotateAndPlaceOrientationFlag,
|
|
force_wall: RotateAndPlaceOrientationFlag,
|
|
force_ceiling: RotateAndPlaceOrientationFlag,
|
|
force_floor: RotateAndPlaceOrientationFlag,
|
|
force_facedir: RotateAndPlaceOrientationFlag;
|
|
}
|
|
|
|
declare interface BlockStatusCondition {
|
|
unknown: BlockStatusCondition,
|
|
emerging: BlockStatusCondition,
|
|
loaded: BlockStatusCondition,
|
|
active: BlockStatusCondition;
|
|
}
|
|
|
|
declare interface TileAnimationType {
|
|
vertical_frames: TileAnimationType,
|
|
sheet_2d: TileAnimationType;
|
|
}
|
|
|
|
declare interface ParticleSpawnerTweenStyle {
|
|
fwd: ParticleSpawnerTweenStyle,
|
|
rev: ParticleSpawnerTweenStyle,
|
|
pulse: ParticleSpawnerTweenStyle,
|
|
flicker: ParticleSpawnerTweenStyle;
|
|
}
|
|
|
|
declare interface ParticleSpawnerTextureBlend {
|
|
alpha: ParticleSpawnerTextureBlend,
|
|
add: ParticleSpawnerTextureBlend,
|
|
screen: ParticleSpawnerTextureBlend,
|
|
sub: ParticleSpawnerTextureBlend;
|
|
}
|
|
|
|
declare interface ParticleSpawnerAttractionType {
|
|
none: ParticleSpawnerAttractionType,
|
|
point: ParticleSpawnerAttractionType,
|
|
line: ParticleSpawnerAttractionType,
|
|
plane: ParticleSpawnerAttractionType;
|
|
}
|
|
|
|
declare interface AreaStoreType {
|
|
libSpatial: AreaStoreType;
|
|
}
|
|
|
|
declare interface TexturePoolComponentFade {
|
|
in: TexturePoolComponentFade,
|
|
out: TexturePoolComponentFade;
|
|
}
|
|
|
|
declare global {
|
|
const minetest: minetest;
|
|
const EntityVisual: EntityVisual;
|
|
const SchematicRotation: SchematicRotation;
|
|
const SchematicPlacementFlag: SchematicPlacementFlag;
|
|
const SchematicFormat: SchematicFormat;
|
|
const SchematicSerializationOption: SchematicSerializationOption;
|
|
const SchematicReadOptionYSliceOption: SchematicReadOptionYSliceOption;
|
|
const HTTPRequestMethod: HTTPRequestMethod;
|
|
const OreType: OreType;
|
|
const OreFlags: OreFlags;
|
|
const NoiseFlags: NoiseFlags;
|
|
const DecorationType: DecorationType;
|
|
const DecorationFlags: DecorationFlags;
|
|
const ParamType1: ParamType1;
|
|
const ParamType2: ParamType2;
|
|
const Drawtype: Drawtype;
|
|
const Nodeboxtype: Nodeboxtype;
|
|
const LogLevel: LogLevel;
|
|
const TextureAlpha: TextureAlpha;
|
|
const LiquidType: LiquidType;
|
|
const NodeBoxConnections: NodeBoxConnections;
|
|
const CraftRecipeType: CraftRecipeType;
|
|
const CraftCheckType: CraftCheckType;
|
|
const HPChangeReasonType: HPChangeReasonType;
|
|
const CheatType: CheatType;
|
|
const ClearObjectsOptions: ClearObjectsOptions;
|
|
const GenNotifyFlags: GenNotifyFlags;
|
|
const SearchAlgorithm: SearchAlgorithm;
|
|
const SkyParametersType: SkyParametersType;
|
|
const SkyParametersFogTintType: SkyParametersFogTintType;
|
|
const MinimapType: MinimapType;
|
|
const HudElementType: HudElementType;
|
|
const HudReplaceBuiltinOption: HudReplaceBuiltinOption;
|
|
const ParseRelativeNumberArgument: ParseRelativeNumberArgument;
|
|
const CompressionMethod: CompressionMethod;
|
|
const RotateAndPlaceOrientationFlag: RotateAndPlaceOrientationFlag;
|
|
const BlockStatusCondition: BlockStatusCondition;
|
|
const TileAnimationType: TileAnimationType;
|
|
const ParticleSpawnerTweenStyle: ParticleSpawnerTweenStyle;
|
|
const ParticleSpawnerTextureBlend: ParticleSpawnerTextureBlend;
|
|
const ParticleSpawnerAttractionType: ParticleSpawnerAttractionType;
|
|
const AreaStoreType: AreaStoreType;
|
|
const TexturePoolComponentFade: TexturePoolComponentFade;
|
|
} |