@defold-typescript/library-types 0.22.0 → 0.24.0

package/generated/orthographic.camera.d.ts

@@ -6,14 +6,14 @@
  */
 declare module 'orthographic.camera' {
 	/**
-	 * Follow a game object.
+	 * Follow one or more game objects. When following multiple objects the camera will follow the center point between the objects.
 	 * @param camera_id undefined for the first camera
-	 * @param target Game object to follow
+	 * @param targets Game object(s) to follow
 	 * @param options Options
 	 */
 	export function follow(
 		camera_id: Hash | Url | undefined,
-		target: Hash | Url,
+		targets: Hash | Url | (Hash | Url)[],
 		options?: {
 			/**
 			 *  Lerp from current position to target position with lerp as t.
@@ -54,6 +54,24 @@ declare module 'orthographic.camera' {
 		zoom: number,
 	): void;
 
+	/**
+	 * Get if the camera is configured to use automatic zoom level.
+	 * @param camera_id undefined for the first camera
+	 */
+	export function get_automatic_zoom(
+		camera_id: Hash | Url | undefined,
+	): boolean;
+
+	/**
+	 * Set if the camera should use automatic zoom level.
+	 * @param camera_id undefined for the first camera
+	 * @param enabled True if automatic zoom should be enabled
+	 */
+	export function set_automatic_zoom(
+		camera_id: Hash | Url | undefined,
+		enabled: boolean,
+	): void;
+
 	/**
 	 * Shake the camera.
 	 * @param camera_id undefined for the first camera
@@ -133,12 +151,6 @@ declare module 'orthographic.camera' {
 		camera_id: Hash | Url | undefined,
 	): Matrix4;
 
-	/**
-	 * Get the current projection id of the camera.
-	 * @param camera_id undefined for the first camera
-	 */
-	export function get_projection_id(camera_id: Hash | Url | undefined): Hash;
-
 	/**
 	 * Apply a recoil effect to the camera. The recoil will decay using linear interpolation.
 	 * @param camera_id
@@ -214,18 +226,13 @@ declare module 'orthographic.camera' {
 	): Vector4;
 
 	/**
-	 * Translate world coordinates to screen coordinates, based on the view and projection of the camera, optionally taking into account an adjust mode. This is useful when manually culling game objects and you need to determine if a world coordinate will be visible or not. It can also be used to position gui nodes on top of game objects.
+	 * Translate world coordinates to screen coordinates, based on the view and projection of the camera. This is useful when manually culling game objects and you need to determine if a world coordinate will be visible or not. It can also be used to position gui nodes on top of game objects.
 	 * @param camera_id undefined for the first camera
 	 * @param world World coordinates to convert
-	 * @param adjust_mode One of gui.ADJUST_FIT, gui.ADJUST_ZOOM and gui.ADJUST_STRETCH, or undefined to not take into account the adjust mode.
 	 */
 	export function world_to_screen(
 		camera_id: Hash | Url | undefined,
 		world: Vector3,
-		adjust_mode?:
-			| typeof gui.ADJUST_FIT
-			| typeof gui.ADJUST_STRETCH
-			| typeof gui.ADJUST_ZOOM,
 	): Vector3;
 
 	/**
@@ -252,26 +259,6 @@ declare module 'orthographic.camera' {
 		world: Vector3,
 	): Vector3;
 
-	/**
-	 * Add a custom projector that can be used by cameras in your project (see configuration above).
-	 * @param projector_id  Id of the projector. Used as a value in the projection field of the camera script.
-	 * @param projector_fn The function to call when a projection matrix is needed for the camera. The function will receive the id, near_z and far_z values of the camera.
-	 */
-	export function add_projector(
-		projector_id: Hash,
-		projector_fn: (id: Hash, near_z: number, far_z: number) => void,
-	): void;
-
-	/**
-	 * Set a specific projector for a camera. This must be either one of the predefined projectors (see above) or a custom projector added using `camera.add_projector()`.
-	 * @param camera_id undefined for the first camera
-	 * @param projector_id  Id of the projector.
-	 */
-	export function use_projector(
-		camera_id: Hash | Url | undefined,
-		projector_id: Hash,
-	): void;
-
 	/**
 	 * Set window scaling factor (basically retina or no retina screen). There is no built-in way to detect if Defold is running on a retina or non retina screen. This information combined with the High DPI setting in game.project can be used to ensure that the zoom behaves the same way regardless of screen type and High DPI setting. You can use an extension such as DefOS to get the window scaling factor.
 	 * @param scaling_factor Current window scaling factor
@@ -288,8 +275,6 @@ declare module 'orthographic.camera' {
 	export const SHAKE_VERTICAL: Hash;
 	export const SHAKE_HORIZONTAL: Hash;
 
-	export const ORTHOGRAPHIC_RENDER_SCRIPT_USED: boolean;
-
 	export const MSG_DISABLE: Hash;
 	export const MSG_UNFOLLOW: Hash;
 	export const MSG_FOLLOW: Hash;
@@ -302,7 +287,8 @@ declare module 'orthographic.camera' {
 	export const MSG_BOUNDS: Hash;
 	export const MSG_UPDATE_CAMERA: Hash;
 	export const MSG_ZOOM_TO: Hash;
-	export const MSG_USE_PROJECTION: Hash;
+	/** Posted to a camera to turn automatic zoom on or off. */
+	export const MSG_SET_AUTOMATIC_ZOOM: Hash;
 	export const MSG_VIEWPORT: Hash;
 	export const MSG_ENABLE: Hash;
 }

package/generated/orthographic.d.ts

@@ -0,0 +1,155 @@
+/** @noSelfInFile */
+/** @noResolution */
+declare module 'orthographic.camera' {
+  /**
+   * (synthesized)
+   * Defold `orthographic` API namespace.
+   */
+  export namespace orthographic {
+    /**
+     * Limits the camera position to within the specified rectangle.
+     *
+     * @param camera_id - nil for the first camera
+     * @param left - Left edge of the camera bounds
+     * @param top - Top edge of camera bounds
+     * @param right - Right edge of camera bounds
+     * @param bottom - Bottom edge of camera bounds
+     */
+    function bounds(camera_id: Hash | Url | undefined, left: number, top: number, right: number, bottom: number): void;
+    /**
+     * If following a game object this will add a deadzone around the camera position where the camera position will not update. If the target moves to the edge of the deadzone the camera will start to follow until the target returns within the bounds of the deadzone.
+     *
+     * @param camera_id - nil for the first camera
+     * @param left - Number of pixels to the left of the camera
+     * @param top - Number of pixels above the camera
+     * @param right - Number of pixels to the right of the camera
+     * @param bottom - Number of pixels below the camera
+     */
+    function deadzone(camera_id: Hash | Url | undefined, left: number, top: number, right: number, bottom: number): void;
+    /**
+     * Follow one or more game objects. When following multiple objects the camera will follow the center point between the objects.
+     *
+     * @param camera_id - nil for the first camera
+     * @param targets - Game object(s) to follow
+     * @param options - Options (see below)
+     */
+    function follow(camera_id: Hash | Url | undefined, targets: Hash | Url | Record<string | number, unknown>, options?: Record<string | number, unknown>): void;
+    /**
+     * Change the camera follow offset.
+     *
+     * @param camera_id - nil for the first camera
+     * @param offset - Camera offset from target position.
+     */
+    function follow_offset(camera_id: Hash | Url | undefined, offset: Vector3): void;
+    /**
+     * Get if the camera is configured to use automatic zoom level.
+     *
+     * @returns True if automatic zoom is enabled
+     */
+    function get_automatic_zoom(): boolean;
+    /**
+     * Get the display size, as specified in game.project.
+     */
+    function get_display_size(): LuaMultiReturn<[number, number]>;
+    /**
+     * Get the current offset of the camera (caused by shake or recoil)
+     *
+     * @param camera_id - nil for the first camera
+     * @returns The current offset of the camera
+     */
+    function get_offset(camera_id?: Hash | Url): Vector3;
+    /**
+     * Get the current projection of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @returns The current projection
+     */
+    function get_projection(camera_id?: Hash | Url): Matrix4;
+    /**
+     * Get the current view of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @returns The current view
+     */
+    function get_view(camera_id?: Hash | Url): Matrix4;
+    /**
+     * Get the current viewport of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     */
+    function get_viewport(camera_id?: Hash | Url): LuaMultiReturn<[number, number, number, number]>;
+    /**
+     * Get the current window size. The default values will be the ones specified in game.project.
+     */
+    function get_window_size(): LuaMultiReturn<[number, number]>;
+    /**
+     * Get the current zoom level of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @returns The current zoom of the camera
+     */
+    function get_zoom(camera_id?: Hash | Url): number;
+    /**
+     * Apply a recoil effect to the camera. The recoil will decay using linear interpolation.
+     *
+     * @param offset - Offset to apply to the camera. Defaults to 0.05
+     * @param duration - Duration of the recoil, in seconds. Defaults to 0.5
+     */
+    function recoil(camera_id: Hash | Url, offset: Vector3, duration?: number): void;
+    /**
+     * Translate screen coordinates to world coordinates, based on the view and projection of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @param screen - Screen coordinates to convert
+     * @returns World coordinates
+     */
+    function screen_to_world(camera_id: Hash | Url | undefined, screen: Vector3): Vector3;
+    /**
+     * Translate screen boundaries (corners) to world coordinates, based on the view and projection of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @returns Screen bounds (x = left, y = top, z = right, w = bottom)
+     */
+    function screen_to_world_bounds(camera_id?: Hash | Url): Vector4;
+    /**
+     * Set if the camera should use automatic zoom level.
+     *
+     * @param enabled - True if automatic zoom should be enabled
+     */
+    function set_automatic_zoom(enabled: boolean): void;
+    /**
+     * Change the zoom level of the camera.
+     *
+     * @param camera_id - nil for the first camera
+     * @param zoom - The new zoom level of the camera
+     */
+    function set_zoom(camera_id: Hash | Url | undefined, zoom: number): void;
+    /**
+     * Shake the camera.
+     *
+     * @param intensity - Intensity of the shake, in percent of screen. Defaults to 0.05
+     * @param duration - Duration of the shake, in seconds. Defaults to 0.5
+     * @param direction - Direction of the shake. Possible values: `both`, `horizontal`, `vertical`. Defaults to `both`.
+     * @param cb - Function to call when the shake has finished. Optional.
+     */
+    function shake(camera_id: Hash | Url, intensity?: number, duration?: number, direction?: Hash, cb?: (...args: unknown[]) => unknown): void;
+    /**
+     * Stop shaking the camera.
+     */
+    function stop_shaking(camera_id: Hash | Url): void;
+    /**
+     * Stop following a game object.
+     *
+     * @param camera_id - nil for the first camera
+     */
+    function unfollow(camera_id?: Hash | Url): void;
+    /**
+     * Translate world coordinates to screen coordinates, based on the view and projection of the camera. This is useful when manually culling game objects and you need to determine if a world coordinate will be visible or not. It can also be used to position gui nodes on top of game objects.
+     *
+     * @param camera_id - nil for the first camera
+     * @param world - World coordinates to convert
+     * @returns Screen coordinates
+     */
+    function world_to_screen(camera_id: Hash | Url | undefined, world: Vector3): Vector3;
+  }
+}

package/generated/panthera.d.ts

@@ -0,0 +1,170 @@
+/** @noResolution */
+declare module 'panthera.panthera' {
+	interface panthera_animation {
+		adapter: panthera_adapter;
+		speed: number;
+		current_time: number;
+		nodes: LuaTable;
+		childs?: panthera_animation[] | undefined;
+		get_node: (node_id: string) => Opaque<"node">;
+		animation_id?: string | undefined;
+		previous_animation_id?: string | undefined;
+		animation_path: string;
+		animation_keys_index: number;
+		events?: LuaTable | undefined;
+		timer_id?: number | undefined;
+	}
+	interface panthera_options {
+		is_loop?: boolean | undefined;
+		is_skip_init?: boolean | undefined;
+		is_detached?: boolean | undefined;
+		speed?: number | undefined;
+		easing?: string | Opaque<"constant"> | undefined;
+		callback?: ((animation_id: string) => undefined) | undefined;
+		callback_event?: ((event_id: string, node: Opaque<"node"> | undefined, string_value: string, number_value: number) => undefined) | undefined;
+	}
+	interface panthera_options_tweener {
+		speed?: number | undefined;
+		is_loop?: boolean | undefined;
+		easing?: string | Opaque<"constant"> | undefined;
+		callback?: ((animation_id: string) => undefined) | undefined;
+		callback_event?: ((event_id: string, node: Opaque<"node"> | undefined, string_value: string, number_value: number) => undefined) | undefined;
+		is_reverse?: boolean | undefined;
+		from?: number | undefined;
+		to?: number | undefined;
+	}
+	interface panthera {
+		SPEED: number;
+	}
+	interface panthera_adapter {
+		get_node: (node_id: string) => Opaque<"node">;
+		get_easing: (easing_id: string) => Hash;
+		tween_animation_key: (node: Opaque<"node">, property_id: string, easing: Hash | number[], duration: number, end_value: number) => undefined;
+		trigger_animation_key: (node: Opaque<"node">, property_id: string, value: unknown) => undefined;
+		event_animation_key: (node: Opaque<"node">, key: panthera_animation_data_animation_key) => undefined;
+		set_node_property: (node: Opaque<"node">, property_id: string, value: number | string) => boolean;
+		stop_tween: (node: Opaque<"node">, property_id: string) => undefined;
+		is_node_valid: (node: Opaque<"node">) => boolean;
+	}
+	interface panthera_logger {
+		trace: (logger: panthera_logger, message: string, data: unknown | undefined) => void;
+		debug: (logger: panthera_logger, message: string, data: unknown | undefined) => void;
+		info: (logger: panthera_logger, message: string, data: unknown | undefined) => void;
+		warn: (logger: panthera_logger, message: string, data: unknown | undefined) => void;
+		error: (logger: panthera_logger, message: string, data: unknown | undefined) => void;
+	}
+	interface panthera_animation_data_node {
+	}
+	interface panthera_animation_data_metadata {
+		gui_path: string;
+		fps: number;
+		settings: LuaTable;
+		gizmo_steps: LuaTable;
+		template_animation_paths: LuaTable<string, string>;
+	}
+	interface panthera_animation_data_animation {
+		duration: number;
+		animation_id: string;
+		initial_state: string;
+		animation_keys: panthera_animation_data_animation_key[];
+	}
+	interface panthera_animation_data {
+		name: string;
+		nodes: panthera_animation_data_node[];
+		animations: panthera_animation_data_animation[];
+		metadata: panthera_animation_data_metadata;
+		group_animation_keys: LuaTable<string, LuaTable<string, LuaTable<string, panthera_animation_data_animation_key[]>>>;
+		animations_dict: LuaTable<string, panthera_animation_data_animation>;
+	}
+	interface panthera_animation_project_file {
+		data: panthera_animation_data;
+		format: string;
+		version: string;
+		type: string;
+	}
+	interface panthera_animation_data_animation_key {
+		key_type: number;
+		node_id: string;
+		property_id: string;
+		start_time: number;
+		duration: number;
+		start_value: number;
+		end_value: number;
+		easing: string;
+		easing_custom?: number[] | Vector | undefined;
+		start_data: string;
+		data: string;
+		event_id: string;
+		is_editor_only: boolean;
+	}
+	/**
+	 * Customize the logging mechanism used by Panthera Runtime. You can use Defold Log library or provide a custom logger.
+	 */
+	export function set_logger(this: void, logger_instance?: panthera_logger | LuaTable | undefined): void;
+	/**
+	 * Load and create a game object animation state from a Lua table or JSON file.
+	 */
+	export function create_go(this: void, animation_or_path: string | LuaTable, collection_name?: string | undefined, objects?: LuaTable<string | Hash, string | Hash> | undefined): panthera_animation;
+	/**
+	 * Load and create a GUI animation state from a Lua table or JSON file.
+	 */
+	export function create_gui(this: void, animation_or_path: string | LuaTable, template?: string | undefined, nodes?: LuaTable<string | Hash, Opaque<"node">> | undefined): panthera_animation;
+	/**
+	 * Load an animation from a Lua table or JSON file and create an animation state using a specified adapter.
+	 */
+	export function create(this: void, animation_or_path: string | LuaTable, adapter: panthera_adapter, get_node: (node_id: string) => Opaque<"node">): panthera_animation;
+	/**
+	 * Clone an existing animation state object, enabling multiple instances of the same animation to play simultaneously or independently.
+	 */
+	export function clone_state(this: void, animation_state: panthera_animation): panthera_animation;
+	/**
+	 * Play an animation with specified ID and options.
+	 */
+	export function play(this: void, animation_state: panthera_animation, animation_id: string, options?: panthera_options | undefined): void;
+	/**
+	 * Play animation with easing support using tweener. Allows for non-linear animation playback with custom easing functions.
+	 */
+	export function play_tweener(this: void, animation_state: panthera_animation, animation_id: string, options?: panthera_options_tweener | undefined): void;
+	/**
+	 * Play animation as a child of the current animation state, allowing multiple animations to run independently and simultaneously.
+	 *
+	 * This creates a detached animation that runs in parallel with the main animation state without affecting it.
+	 * The child animation will be automatically cleaned up when it completes.
+	 */
+	export function play_detached(this: void, animation_state: panthera_animation, animation_id: string, options?: panthera_options | undefined): void;
+	/**
+	 * Set the current time of an animation. This function stops any currently playing animation.
+	 */
+	export function set_time(this: void, animation_state: panthera_animation, animation_id: string, time: number, event_callback?: ((event_id: string, node: Opaque<"node"> | undefined, string_value: string, number_value: number) => void) | undefined): boolean;
+	/**
+	 * Retrieve the current playback time in seconds of an animation. If the animation is not playing, the function returns 0.
+	 */
+	export function get_time(this: void, animation_state: panthera_animation): number;
+	/**
+	 * Stop a currently playing animation. The animation will be stopped at current time.
+	 */
+	export function stop(this: void, animation_state: panthera_animation): boolean;
+	/**
+	 * Retrieve the total duration of a specific animation.
+	 */
+	export function get_duration(this: void, animation_state: panthera_animation, animation_id: string): number;
+	/**
+	 * Check if an animation is currently playing.
+	 */
+	export function is_playing(this: void, animation_state: panthera_animation): boolean;
+	/**
+	 * Get the ID of the last animation that was started.
+	 */
+	export function get_latest_animation_id(this: void, animation_state: panthera_animation): string | undefined;
+	/**
+	 * Return a list of animation IDs from the created animation state.
+	 */
+	export function get_animations(this: void, animation_state: panthera_animation): string[];
+	/**
+	 * Reload animations from JSON files, useful for development and debugging.
+	 *
+	 * The animations loaded from Lua tables will not be reloaded.
+	 * Animation will be reloaded only at desktop.
+	 */
+	export function reload_animation(this: void, animation_path?: string | undefined): void;
+}

package/generated/{persist.persist.d.ts → persist.d.ts}

@@ -31,4 +31,7 @@ declare module 'persist.persist' {
 	 * Returns an `object`, or `undefined` if the file does not exist.
 	 */
 	export function load(file_name: string): {} | undefined;
+
+	/** Checks if a file exists. */
+	export function exists(file_name: string): boolean;
 }

package/generated/{platypus.platypus.d.ts → platypus.d.ts}

@@ -67,6 +67,15 @@ declare module 'platypus.platypus' {
 	export const DOUBLE_JUMP: Hash;
 	export const WALL_SLIDE: Hash;
 
+	/** Value for `collisions.separation` selecting raycast separation. */
+	export const SEPARATION_RAYS: Hash;
+	/**
+	 * Value for `collisions.separation` selecting shape separation. Platypus warns
+	 * at runtime that this mode is no longer supported and only raycast separation
+	 * is; the constant still exists.
+	 */
+	export const SEPARATION_SHAPES: Hash;
+
 	type Direction = number;
 	export const DIR_UP: Direction;
 	export const DIR_LEFT: Direction;

package/generated/proto.d.ts

@@ -0,0 +1,146 @@
+/** @noResolution */
+declare module 'proto.proto' {
+	/**
+	 * Download Defold annotations from here: https://github.com/astrochili/defold-annotations/releases/
+	 * Logger interface
+	 */
+	interface proto_logger {
+		trace: (logger: proto_logger, message: string, data: unknown | undefined) => void;
+		debug: (logger: proto_logger, message: string, data: unknown | undefined) => void;
+		info: (logger: proto_logger, message: string, data: unknown | undefined) => void;
+		warn: (logger: proto_logger, message: string, data: unknown | undefined) => void;
+		error: (logger: proto_logger, message: string, data: unknown | undefined) => void;
+	}
+	interface Lexer {
+		__call(): void;
+		test(): void;
+		expected(): void;
+		pos2loc(): void;
+		error(): void;
+		opterror(): void;
+		whitespace(): void;
+		comment(): void;
+		line_end(): void;
+		eof(): void;
+		keyword(): void;
+		ident(): void;
+		full_ident(): void;
+		integer(): void;
+		number(): void;
+		quote(): void;
+		structure(): void;
+		array(): void;
+		constant(): void;
+		option_name(): void;
+		type_name(): void;
+		__call(): void;
+		test(): void;
+		expected(): void;
+		pos2loc(): void;
+		error(): void;
+		opterror(): void;
+		whitespace(): void;
+		comment(): void;
+		line_end(): void;
+		eof(): void;
+		keyword(): void;
+		ident(): void;
+		full_ident(): void;
+		integer(): void;
+		number(): void;
+		quote(): void;
+		table(): void;
+		constant(): void;
+		option_name(): void;
+		type_name(): void;
+	}
+	interface Parser {
+		error(): void;
+		addpath(): void;
+		parsefile(): void;
+		parse(): void;
+		resolve(): void;
+		compile(): void;
+		compilefile(): void;
+		load(): void;
+		loadfile(): void;
+		error(): void;
+		addpath(): void;
+		parsefile(): void;
+		parse(): void;
+		resolve(): void;
+		compile(): void;
+		compilefile(): void;
+		load(): void;
+		loadfile(): void;
+	}
+	interface toplevel {
+		package(): void;
+		"import"(): void;
+		message(): void;
+		enum(): void;
+		option(): void;
+		extend(): void;
+		service(): void;
+		package(): void;
+		"import"(): void;
+		message(): void;
+		enum(): void;
+		option(): void;
+		extend(): void;
+		service(): void;
+	}
+	interface msg_body {
+		message(): void;
+		enum(): void;
+		extend(): void;
+		extensions(): void;
+		reserved(): void;
+		oneof(): void;
+		option(): void;
+		message(): void;
+		enum(): void;
+		extend(): void;
+		extensions(): void;
+		reserved(): void;
+		oneof(): void;
+	}
+	interface svr_body {
+		rpc(): void;
+		option(): void;
+		rpc(): void;
+	}
+	interface proto {
+	}
+	/**
+	 * Loads proto files from the specified paths in the game.project
+	 * Under the "proto.proto_paths" key in the game.project
+	 */
+	export function init(this: void, proto_config_or_path: LuaTable | string): void;
+	/**
+	 * Set the logger instance
+	 */
+	export function set_logger(this: void, logger_instance?: proto_logger | undefined): void;
+	/**
+	 * Create a new instance of the proto message
+	 */
+	export function get(this: void, proto_type: string): LuaTable;
+	/**
+	 * Encode data to bytes
+	 */
+	export function encode(this: void, proto_type: string, data: LuaTable): string;
+	/**
+	 * Decode bytes to lua table
+	 */
+	export function decode(this: void, proto_type: string, bytes?: string | undefined): LuaTable;
+	/**
+	 * Verify data to match the proto_type. Return data with all default values according to proto_type, remove extra fields
+	 */
+	export function verify(this: void, proto_type: string, data: LuaTable): LuaTable;
+	/**
+	 * Update data to match the proto_type.
+	 * - All default values will be added to the data if they are not present
+	 * - All extra fields will be removed from the data
+	 */
+	export function update_with_default_messages(this: void, proto_type: string, data: LuaTable): void;
+}