@defold-typescript/types 0.49.0 → 0.50.0

package/generated/versions/defold-1.13.2/tilemap.d.ts

@@ -0,0 +1,206 @@
+/** @noSelfInFile */
+import type { Hash, Url } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions and messages used to manipulate tile map components.
+   */
+  namespace tilemap {
+    type TRANSFORM = typeof tilemap.H_FLIP | typeof tilemap.ROTATE_180 | typeof tilemap.ROTATE_270 | typeof tilemap.ROTATE_90 | typeof tilemap.V_FLIP;
+    /**
+     * flip tile horizontally
+     */
+    const H_FLIP: number & { readonly __brand: "tilemap.H_FLIP" };
+    /**
+     * rotate tile 180 degrees clockwise
+     */
+    const ROTATE_180: number & { readonly __brand: "tilemap.ROTATE_180" };
+    /**
+     * rotate tile 270 degrees clockwise
+     */
+    const ROTATE_270: number & { readonly __brand: "tilemap.ROTATE_270" };
+    /**
+     * rotate tile 90 degrees clockwise
+     */
+    const ROTATE_90: number & { readonly __brand: "tilemap.ROTATE_90" };
+    /**
+     * flip tile vertically
+     */
+    const V_FLIP: number & { readonly __brand: "tilemap.V_FLIP" };
+    /**
+     * Get the bounds for a tile map. This function returns multiple values:
+     * The lower left corner index x and y coordinates (1-indexed),
+     * the tile map width and the tile map height.
+     * The resulting values take all tile map layers into account, meaning that
+     * the bounds are calculated as if all layers were collapsed into one.
+     *
+     * @param url - the tile map
+     * @returns `[x, y, w, h]`:
+     * - `x` — x coordinate of the bottom left corner. **⚠️ 1-based; passed to Defold unchanged.**
+     * - `y` — y coordinate of the bottom left corner. **⚠️ 1-based; passed to Defold unchanged.**
+     * - `w` — number of columns (width) in the tile map
+     * - `h` — number of rows (height) in the tile map
+     * @example
+     * ```ts
+     * // get the level bounds.
+     * const [x, y, w, h] = tilemap.get_bounds("/level#tilemap");
+     * ```
+     */
+    function get_bounds(url: string | Hash | Url): LuaMultiReturn<[number, number, number, number]>;
+    /**
+     * Get the tile set at the specified position in the tilemap.
+     * The position is identified by the tile index starting at origin
+     * with index 1, 1. (see tilemap.set_tile())
+     * Which tile map and layer to query is identified by the URL and the
+     * layer name parameters.
+     *
+     * @param url - the tile map
+     * @param layer - name of the layer for the tile
+     * @param x - x-coordinate of the tile. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param y - y-coordinate of the tile. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns index of the tile
+     * @example
+     * ```ts
+     * function tile_under_player(self: { player_x: number; player_y: number }) {
+     *   // get the tile under the player.
+     *   const tileno = tilemap.get_tile("/level#tilemap", "foreground", self.player_x, self.player_y);
+     * }
+     * ```
+     */
+    function get_tile(url: string | Hash | Url, layer: string | Hash, x: number, y: number): number;
+    /**
+     * Get the tile information at the specified position in the tilemap.
+     * The position is identified by the tile index starting at origin
+     * with index 1, 1. (see tilemap.set_tile())
+     * Which tile map and layer to query is identified by the URL and the
+     * layer name parameters.
+     *
+     * @param url - the tile map
+     * @param layer - name of the layer for the tile
+     * @param x - x-coordinate of the tile. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param y - y-coordinate of the tile. **⚠️ 1-based; passed to Defold unchanged.**
+     * @returns full tile information
+     * @example
+     * ```ts
+     * function tile_info_under_player(self: { player_x: number; player_y: number }) {
+     *   // get the tile under the player.
+     *   const tile_info = tilemap.get_tile_info("/level#tilemap", "foreground", self.player_x, self.player_y);
+     *   pprint(tile_info);
+     *   // {
+     *   //    index = 0,
+     *   //    h_flip = false,
+     *   //    v_flip = true,
+     *   //    rotate_90 = false
+     *   // }
+     * }
+     * ```
+     */
+    function get_tile_info(url: string | Hash | Url, layer: string | Hash, x: number, y: number): { index: number; h_flip: boolean; v_flip: boolean; rotate_90: boolean };
+    /**
+     * Retrieves all the tiles for the specified layer in the tilemap.
+     * It returns a table of rows where the keys are the
+     * tile positions (see tilemap.get_bounds()).
+     * You can iterate it using `tiles[row_index][column_index]`.
+     *
+     * @param url - the tilemap
+     * @param layer - the name of the layer for the tiles
+     * @returns a table of rows representing the layer
+     * @example
+     * ```ts
+     * const [left, bottom, columns_count, rows_count] = tilemap.get_bounds("#tilemap");
+     * const tiles = tilemap.get_tiles("#tilemap", "layer");
+     * let tile = 0;
+     * let count = 0;
+     * for (let row_index = bottom; row_index <= bottom + rows_count - 1; row_index++) {
+     *   for (let column_index = left; column_index <= left + columns_count - 1; column_index++) {
+     *     tile = tiles.get(row_index)?.get(column_index) ?? 0;
+     *     count = count + 1;
+     *   }
+     * }
+     * ```
+     */
+    function get_tiles(url: string | Hash | Url, layer: string | Hash): LuaTable<number, LuaTable<number, number>>;
+    /**
+     * Resets a shader constant for a tile map component.
+     * The constant must be defined in the material assigned to the tile map.
+     * Resetting a constant through this function implies that the value defined in the material will be used.
+     * Which tile map to reset a constant for is identified by the URL.
+     *
+     * @param url - the tile map that should have a constant reset
+     * @param constant - name of the constant
+     * @example
+     * ```ts
+     * tilemap.reset_constant("#tilemap", "tint");
+     * ```
+     */
+    function reset_constant(url: string | Hash | Url, constant: string | Hash): void;
+    /**
+     * Replace a tile in a tile map with a new tile.
+     * The coordinates of the tiles are indexed so that the "first" tile just
+     * above and to the right of origin has coordinates 1,1.
+     * Tiles to the left of and below origin are indexed 0, -1, -2 and so forth.
+     *
+     * ```text
+     * +-------+-------+------+------+
+     * |  0,3  |  1,3  | 2,3  | 3,3  |
+     * +-------+-------+------+------+
+     * |  0,2  |  1,2  | 2,2  | 3,2  |
+     * +-------+-------+------+------+
+     * |  0,1  |  1,1  | 2,1  | 3,1  |
+     * +-------O-------+------+------+
+     * |  0,0  |  1,0  | 2,0  | 3,0  |
+     * +-------+-------+------+------+
+     * ```
+     *
+     * The coordinates must be within the bounds of the tile map as it were created.
+     * That is, it is not possible to extend the size of a tile map by setting tiles outside the edges.
+     * To clear a tile, set the tile to number 0. Which tile map and layer to manipulate is identified by the URL and the layer name parameters.
+     *
+     * @param url - the tile map
+     * @param layer - name of the layer for the tile
+     * @param x - x-coordinate of the tile. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param y - y-coordinate of the tile. **⚠️ 1-based; passed to Defold unchanged.**
+     * @param tile - index of new tile to set. 0 resets the cell
+     * @param transform_bitmask - optional flip and/or rotation should be applied to the tile
+     * @example
+     * ```ts
+     * function set_tiles(self: { player_x: number; player_y: number }, x: number, y: number) {
+     *   // Clear the tile under the player.
+     *   tilemap.set_tile("/level#tilemap", "foreground", self.player_x, self.player_y, 0);
+     *
+     *   // Set tile with different combination of flip and rotation
+     *   tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.H_FLIP + tilemap.V_FLIP + tilemap.ROTATE_90);
+     *   tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.H_FLIP + tilemap.ROTATE_270);
+     *   tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.V_FLIP + tilemap.H_FLIP);
+     *   tilemap.set_tile("#tilemap", "layer1", x, y, 0, tilemap.ROTATE_180);
+     * }
+     * ```
+     */
+    function set_tile(url: string | Hash | Url, layer: string | Hash, x: number, y: number, tile: number, transform_bitmask?: tilemap.TRANSFORM | number): boolean;
+    /**
+     * Sets the visibility of the tilemap layer
+     *
+     * @param url - the tile map
+     * @param layer - name of the layer for the tile
+     * @param visible - should the layer be visible
+     * @example
+     * ```ts
+     * // Disable rendering of the layer
+     * tilemap.set_visible("/level#tilemap", "foreground", false);
+     * ```
+     */
+    function set_visible(url: string | Hash | Url, layer: string | Hash, visible: boolean): void;
+    interface properties {
+      /**
+       * The material used when rendering the tile map. The type of the property is hash.
+       */
+      material: Hash;
+      /**
+       * The tile source used when rendering the tile map. The type of the property is hash.
+       */
+      tile_source: Hash;
+    }
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/timer.d.ts

@@ -0,0 +1,136 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Timers allow you to set a delay and a callback to be called when the timer completes.
+   *
+   * The timers created with this API are updated with the collection timer where they
+   * are created. If you pause or speed up the collection (using `set_time_step`) it will
+   * also affect the new timer.
+   */
+  namespace timer {
+    /**
+     * Timer information
+     */
+    interface info {
+      /**
+       * Time remaining until the next callback.
+       */
+      time_remaining: number;
+      /**
+       * Timer interval.
+       */
+      delay: number;
+      /**
+       * Whether the timer repeats until cancelled.
+       */
+      repeating: boolean;
+    }
+    type timer_handle = number;
+    /**
+     * Indicates an invalid timer handle
+     */
+    const INVALID_TIMER_HANDLE: number & { readonly __brand: "timer.INVALID_TIMER_HANDLE" };
+    /**
+     * You may cancel a timer from inside a timer callback.
+     * Cancelling a timer that is already executed or cancelled is safe.
+     *
+     * @param handle - the timer handle returned by timer.delay()
+     * @returns `true` if the timer was active and cancelled, `false` if the timer was already cancelled or complete
+     * @example
+     * ```ts
+     * function cancel_ticking(self: { handle: number }) {
+     *   self.handle = timer.delay(1, true, () => print("print every second"));
+     *   // ...
+     *   const cancelled = timer.cancel(self.handle);
+     *   if (!cancelled) {
+     *     print("the timer is already cancelled");
+     *   }
+     * }
+     * ```
+     */
+    function cancel(handle: number): boolean;
+    /**
+     * Adds a timer and returns a unique handle.
+     * You may create more timers from inside a timer callback.
+     * Using a delay of 0 will result in a timer that triggers at the next frame just before
+     * script update functions.
+     * If you want a timer that triggers on each frame, set delay to 0.0f and repeat to true.
+     * Timers created within a script will automatically die when the script is deleted.
+     *
+     * @param delay - time interval in seconds
+     * @param repeating - true = repeat timer until cancel, false = one-shot timer
+     * @param callback - timer callback function
+     *
+     * `self`
+     * script_instance The current script instance
+     * `handle`
+     * timer_handle The handle of the timer
+     * `time_elapsed`
+     * number The elapsed time - on first trigger it is time since timer.delay call, otherwise time since last trigger
+     * @returns identifier for the create timer, returns timer.INVALID_TIMER_HANDLE if the timer can not be created
+     * @example
+     * A simple one-shot timer
+     * ```ts
+     * timer.delay(1, false, () => print("print in one second"));
+     * ```
+     * @example
+     * Repetitive timer which canceled after 10 calls
+     * ```ts
+     * function call_every_second(self: unknown, handle: unknown, time_elapsed: unknown) {
+     *   const state = self as { counter: number };
+     *   state.counter = state.counter + 1;
+     *   print("Call #", state.counter);
+     *   if (state.counter === 10) {
+     *     timer.cancel(handle as number); // cancel timer after 10 calls
+     *   }
+     * }
+     *
+     * function start_counting(self: { counter: number }) {
+     *   self.counter = 0;
+     *   timer.delay(1, true, call_every_second);
+     * }
+     * ```
+     */
+    function delay(delay: number, repeating: boolean, callback: (self: unknown, handle: number, time_elapsed: number) => void): number;
+    /**
+     * Get information about timer.
+     *
+     * @param handle - the timer handle returned by timer.delay()
+     * @returns timer information, or `nil` if the timer is cancelled or complete
+     * @example
+     * ```ts
+     * function report_ticking(self: { handle: number }) {
+     *   self.handle = timer.delay(1, true, () => print("print every second"));
+     *   // ...
+     *   const result = timer.get_info(self.handle);
+     *   if (!result) {
+     *     print("the timer is already cancelled or complete");
+     *   } else {
+     *     pprint(result); // delay, time_remaining, repeating
+     *   }
+     * }
+     * ```
+     */
+    function get_info(handle: number): timer.info | undefined;
+    /**
+     * Manual triggering a callback for a timer.
+     *
+     * @param handle - the timer handle returned by timer.delay()
+     * @returns `true` if the timer was active and triggered, `false` if the timer was already cancelled or complete
+     * @example
+     * ```ts
+     * function trigger_ticking(self: { handle: number }) {
+     *   self.handle = timer.delay(1, true, () => print("print every second or manually by timer.trigger"));
+     *   // ...
+     *   const triggered = timer.trigger(self.handle);
+     *   if (!triggered) {
+     *     print("the timer is already cancelled or complete");
+     *   }
+     * }
+     * ```
+     */
+    function trigger(handle: number): boolean;
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/types.d.ts

@@ -0,0 +1,61 @@
+/** @noSelfInFile */
+import type { Hash, Matrix4, Quaternion, Url, Vector, Vector3, Vector4 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for checking Defold userdata types.
+   */
+  namespace types {
+    /**
+     * Check if passed type is hash.
+     *
+     * @param var_ - Variable to check type
+     * @returns True if passed type is hash
+     */
+    function is_hash(var_: unknown): var_ is Hash;
+    /**
+     * Check if passed type is matrix4.
+     *
+     * @param var_ - Variable to check type
+     * @returns True if passed type is matrix4
+     */
+    function is_matrix4(var_: unknown): var_ is Matrix4;
+    /**
+     * Check if passed type is quaternion.
+     *
+     * @param var_ - Variable to check type
+     * @returns True if passed type is quaternion
+     */
+    function is_quat(var_: unknown): var_ is Quaternion;
+    /**
+     * Check if passed type is URL.
+     *
+     * @param var_ - Variable to check type
+     * @returns True if passed type is URL
+     */
+    function is_url(var_: unknown): var_ is Url;
+    /**
+     * Check if passed type is vector.
+     *
+     * @param var_ - Variable to check type
+     * @returns True if passed type is vector
+     */
+    function is_vector(var_: unknown): var_ is Vector;
+    /**
+     * Check if passed type is vector3.
+     *
+     * @param var_ - Variable to check type
+     * @returns True if passed type is vector3
+     */
+    function is_vector3(var_: unknown): var_ is Vector3;
+    /**
+     * Check if passed type is vector4.
+     *
+     * @param var_ - Variable to check type
+     * @returns True if passed type is vector4
+     */
+    function is_vector4(var_: unknown): var_ is Vector4;
+  }
+}
+
+export {};