@defold-typescript/types 0.5.4 → 0.6.0

package/generated/msg.d.ts

@@ -2,6 +2,9 @@
 import type { Hash, Url } from "../src/core-types";
 
 declare global {
+  /**
+   * Functions for passing messages and constructing URL objects.
+   */
   namespace msg {
     /**
      * This is equivalent to `msg.url(nil)` or `msg.url("#")`, which creates an url to the current
@@ -49,16 +52,16 @@ declare global {
      * @param fragment - fragment of the URL
      * @returns a new URL
      * @example
-     * ```lua
-     * local my_socket = "main" -- specify by valid name
-     * local my_path = hash("/my_collection/my_gameobject") -- specify as string or hash
-     * local my_fragment = "component" -- specify as string or hash
-     * local my_url = msg.url(my_socket, my_path, my_fragment)
+     * ```ts
+     * const my_socket = "main"; // specify by valid name
+     * const my_path = hash("/my_collection/my_gameobject"); // specify as string or hash
+     * const my_fragment = "component"; // specify as string or hash
+     * const my_url = msg.url(my_socket, my_path, my_fragment);
      *
-     * print(my_url) --> url: [main:/my_collection/my_gameobject#component]
-     * print(my_url.socket) --> 786443 (internal numeric value)
-     * print(my_url.path) --> hash: [/my_collection/my_gameobject]
-     * print(my_url.fragment) --> hash: [component]
+     * print(my_url); // => url: [main:/my_collection/my_gameobject#component]
+     * print(my_url.socket); // => 786443 (internal numeric value)
+     * print(my_url.path); // => hash: [/my_collection/my_gameobject]
+     * print(my_url.fragment); // => hash: [component]
      * ```
      */
     function url(socket?: string | Hash, path?: string | Hash, fragment?: string | Hash): Url;

package/generated/particlefx.d.ts

@@ -2,6 +2,10 @@
 import type { Hash, Url, Vector4 } from "../src/core-types";
 
 declare global {
+  /**
+   * Functions and properties for controlling particle effect component playback and
+   * shader constants.
+   */
   namespace particlefx {
     /**
      * The emitter is not spawning any particles, but has particles that are still alive.
@@ -40,19 +44,21 @@ declare global {
      * - `particlefx.EMITTER_STATE_SPAWNING`
      * - `particlefx.EMITTER_STATE_POSTSPAWN`
      * @example
-     * ```lua
-     * How to play a particle fx when a game object is created.
-     * The callback receives the hash of the path to the particlefx, the hash of the id
-     * of the emitter, and the new state of the emitter as particlefx.EMITTER_STATE_.
-     * local function emitter_state_change(self, id, emitter, state)
-     *   if emitter == hash("exhaust") and state == particlefx.EMITTER_STATE_POSTSPAWN then
-     *     -- exhaust is done spawning particles...
-     *   end
-     * end
+     * ```ts
+     * // How to play a particle fx when a game object is created.
+     * // The callback receives the hash of the path to the particlefx, the hash of the id
+     * // of the emitter, and the new state of the emitter as particlefx.EMITTER_STATE_.
+     * function emitter_state_change(self, id, emitter, state) {
+     *   if (emitter === hash("exhaust") && state === particlefx.EMITTER_STATE_POSTSPAWN) {
+     *     // exhaust is done spawning particles...
+     *   }
+     * }
      *
-     * function init(self)
-     *     particlefx.play("#particlefx", emitter_state_change)
-     * end
+     * export default defineScript({
+     *   init(self) {
+     *     particlefx.play("#particlefx", emitter_state_change);
+     *   },
+     * });
      * ```
      */
     function play(url: string | Hash | Url, emitter_state_function?: (self: unknown, id: unknown, emitter: unknown, state: unknown) => void): void;
@@ -66,14 +72,18 @@ declare global {
      * @param emitter - the id of the emitter
      * @param constant - the name of the constant
      * @example
-     * ```lua
-     * The following examples assumes that the particle FX has id "particlefx", it
-     * contains an emitter with the id "emitter" and that the default-material in builtins is used, which defines the constant "tint".
-     * If you assign a custom material to the sprite, you can reset the constants defined there in the same manner.
-     * How to reset the tinting of particles from an emitter:
-     * function init(self)
-     *     particlefx.reset_constant("#particlefx", "emitter", "tint")
-     * end
+     * ```ts
+     * // The following examples assume that the particle FX has id "particlefx", it
+     * // contains an emitter with the id "emitter" and that the default-material in
+     * // builtins is used, which defines the constant "tint".
+     * // If you assign a custom material to the sprite, you can reset the constants
+     * // defined there in the same manner.
+     * // How to reset the tinting of particles from an emitter:
+     * export default defineScript({
+     *   init(self) {
+     *     particlefx.reset_constant("#particlefx", "emitter", "tint");
+     *   },
+     * });
      * ```
      */
     function reset_constant(url: string | Hash | Url, emitter: string | Hash, constant: string | Hash): void;
@@ -89,14 +99,18 @@ declare global {
      * @param constant - the name of the constant
      * @param value - the value of the constant
      * @example
-     * ```lua
-     * The following examples assumes that the particle FX has id "particlefx", it
-     * contains an emitter with the id "emitter" and that the default-material in builtins is used, which defines the constant "tint".
-     * If you assign a custom material to the sprite, you can reset the constants defined there in the same manner.
-     * How to tint particles from an emitter red:
-     * function init(self)
-     *     particlefx.set_constant("#particlefx", "emitter", "tint", vmath.vector4(1, 0, 0, 1))
-     * end
+     * ```ts
+     * // The following examples assume that the particle FX has id "particlefx", it
+     * // contains an emitter with the id "emitter" and that the default-material in
+     * // builtins is used, which defines the constant "tint".
+     * // If you assign a custom material to the sprite, you can reset the constants
+     * // defined there in the same manner.
+     * // How to tint particles from an emitter red:
+     * export default defineScript({
+     *   init(self) {
+     *     particlefx.set_constant("#particlefx", "emitter", "tint", vmath.vector4(1, 0, 0, 1));
+     *   },
+     * });
      * ```
      */
     function set_constant(url: string | Hash | Url, emitter: string | Hash, constant: string | Hash, value: Vector4): void;
@@ -109,12 +123,14 @@ declare global {
      * @param options - Options when stopping the particle fx. Supported options:
      * - boolean `clear`: instantly clear spawned particles
      * @example
-     * ```lua
-     * How to stop a particle fx when a game object is deleted and immediately also clear
-     * any spawned particles:
-     * function final(self)
-     *     particlefx.stop("#particlefx", { clear = true })
-     * end
+     * ```ts
+     * // How to stop a particle fx when a game object is deleted and immediately also
+     * // clear any spawned particles:
+     * export default defineScript({
+     *   final(self) {
+     *     particlefx.stop("#particlefx", { clear: true });
+     *   },
+     * });
      * ```
      */
     function stop(url: string | Hash | Url, options?: { clear?: boolean }): void;

package/generated/physics.d.ts

@@ -2,6 +2,11 @@
 import type { Hash, Url, Vector3 } from "../src/core-types";
 
 declare global {
+  /**
+   * Functions and messages for collision object physics interaction
+   * with other objects (collisions and ray-casting) and control of
+   * physical behaviors.
+   */
   namespace physics {
     /**
      * The following properties are available when connecting a joint of `JOINT_TYPE_FIXED` type:
@@ -62,13 +67,15 @@ declare global {
      *
      * @returns gravity vector of collection
      * @example
-     * ```lua
-     * function init(self)
-     *     local gravity = physics.get_gravity()
-     *     -- Inverse gravity!
-     *     gravity = -gravity
-     *     physics.set_gravity(gravity)
-     * end
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     let gravity = physics.get_gravity();
+     *     // Inverse gravity!
+     *     gravity = -gravity;
+     *     physics.set_gravity(gravity);
+     *   },
+     * });
      * ```
      */
     function get_gravity(): Vector3;
@@ -178,25 +185,27 @@ declare global {
      * boolean Set to `true` to return all ray cast hits. If `false`, it will only return the closest hit.
      * @returns It returns a list. If missed it returns `nil`. See ray_cast_response for details on the returned values.
      * @example
-     * ```lua
-     * How to perform a ray cast synchronously:
-     * function init(self)
-     *     self.groups = {hash("world"), hash("enemy")}
-     * end
+     * ```ts
+     * // How to perform a ray cast synchronously:
+     * export default defineScript({
+     *   init(self) {
+     *     self.groups = [hash("world"), hash("enemy")];
+     *   },
      *
-     * function update(self, dt)
-     *     -- request ray cast
-     *     local result = physics.raycast(from, to, self.groups, {all=true})
-     *     if result ~= nil then
-     *         -- act on the hit (see 'ray_cast_response')
-     *         for _,result in ipairs(results) do
-     *             handle_result(result)
-     *         end
-     *     end
-     * end
+     *   update(self, dt) {
+     *     // request ray cast
+     *     const result = physics.raycast(from, to, self.groups, { all: true });
+     *     if (result !== undefined) {
+     *       // act on the hit (see 'ray_cast_response')
+     *       for (const result of results) {
+     *         handle_result(result);
+     *       }
+     *     }
+     *   },
+     * });
      * ```
      */
-    function raycast(from: Vector3, to: Vector3, groups: Record<string | number, unknown>, options?: { all?: boolean }): Record<string | number, unknown> | unknown;
+    function raycast(from: Vector3, to: Vector3, groups: Hash[], options?: { all?: boolean }): Record<string | number, unknown> | unknown;
     /**
      * Ray casts are used to test for intersections against collision objects in the physics world.
      * Collision objects of types kinematic, dynamic and static are tested against. Trigger objects
@@ -213,28 +222,30 @@ declare global {
      * @param groups - a lua table containing the hashed groups for which to test collisions against
      * @param request_id - a number in range [0,255]. It will be sent back in the response for identification, 0 by default
      * @example
-     * ```lua
-     * How to perform a ray cast asynchronously:
-     * function init(self)
-     *     self.my_groups = {hash("my_group1"), hash("my_group2")}
-     * end
+     * ```ts
+     * // How to perform a ray cast asynchronously:
+     * export default defineScript({
+     *   init(self) {
+     *     self.my_groups = [hash("my_group1"), hash("my_group2")];
+     *   },
      *
-     * function update(self, dt)
-     *     -- request ray cast
-     *     physics.raycast_async(my_start, my_end, self.my_groups)
-     * end
+     *   update(self, dt) {
+     *     // request ray cast
+     *     physics.raycast_async(my_start, my_end, self.my_groups);
+     *   },
      *
-     * function on_message(self, message_id, message, sender)
-     *     -- check for the response
-     *     if message_id == hash("ray_cast_response") then
-     *         -- act on the hit
-     *     elseif message_id == hash("ray_cast_missed") then
-     *         -- act on the miss
-     *     end
-     * end
+     *   on_message(self, message_id, message, sender) {
+     *     // check for the response
+     *     if (message_id === hash("ray_cast_response")) {
+     *       // act on the hit
+     *     } else if (message_id === hash("ray_cast_missed")) {
+     *       // act on the miss
+     *     }
+     *   },
+     * });
      * ```
      */
-    function raycast_async(from: Vector3, to: Vector3, groups: Record<string | number, unknown>, request_id?: number): void;
+    function raycast_async(from: Vector3, to: Vector3, groups: Hash[], request_id?: number): void;
     /**
      * Only one physics world event listener can be set at a time.
      *
@@ -251,82 +262,85 @@ declare global {
      * `data`
      * table The callback value data is a table that contains event-related data. See the documentation for details on the messages.
      * @example
-     * ```lua
-     * local function physics_world_listener(self, events)
-     *   for _,event in ipairs(events):
-     *       local event_type = event['type']
-     *       if event_type == hash("contact_point_event") then
-     *           pprint(event)
-     *           -- {
-     *           --  distance = 2.1490633487701,
-     *           --  applied_impulse = 0
-     *           --  a = { --[[0x113f7c6c0]]
-     *           --    group = hash: [box],
-     *           --    id = hash: [/box]
-     *           --    mass = 0,
-     *           --    normal = vmath.vector3(0.379, 0.925, -0),
-     *           --    position = vmath.vector3(517.337, 235.068, 0),
-     *           --    instance_position = vmath.vector3(480, 144, 0),
-     *           --    relative_velocity = vmath.vector3(-0, -0, -0),
-     *           --  },
-     *           --  b = { --[[0x113f7c840]]
-     *           --    group = hash: [circle],
-     *           --    id = hash: [/circle]
-     *           --    mass = 0,
-     *           --    normal = vmath.vector3(-0.379, -0.925, 0),
-     *           --    position = vmath.vector3(517.337, 235.068, 0),
-     *           --    instance_position = vmath.vector3(-0.0021, 0, -0.0022),
-     *           --    relative_velocity = vmath.vector3(0, 0, 0),
-     *           --  },
-     *           -- }
-     *       elseif event == hash("collision_event") then
-     *           pprint(event)
-     *           -- {
-     *           --  a = {
-     *           --          group = hash: [default],
-     *           --          position = vmath.vector3(183, 666, 0),
-     *           --          id = hash: [/go1]
-     *           --      },
-     *           --  b = {
-     *           --          group = hash: [default],
-     *           --          position = vmath.vector3(185, 704.05865478516, 0),
-     *           --          id = hash: [/go2]
-     *           --      }
-     *           -- }
-     *       elseif event ==  hash("trigger_event") then
-     *           pprint(event)
-     *           -- {
-     *           --  enter = true,
-     *           --  b = {
-     *           --      group = hash: [default],
-     *           --      id = hash: [/go2]
-     *           --  },
-     *           --  a = {
-     *           --      group = hash: [default],
-     *           --      id = hash: [/go1]
-     *           --  }
-     *           -- },
-     *       elseif event ==  hash("ray_cast_response") then
-     *           pprint(event)
-     *           --{
-     *           --  group = hash: [default],
-     *           --  request_id = 0,
-     *           --  position = vmath.vector3(249.92222595215, 249.92222595215, 0),
-     *           --  fraction = 0.68759721517563,
-     *           --  normal = vmath.vector3(0, 1, 0),
-     *           --  id = hash: [/go]
-     *           -- }
-     *       elseif event ==  hash("ray_cast_missed") then
-     *           pprint(event)
-     *           -- {
-     *           --  request_id = 0
-     *           --},
-     *       end
-     * end
+     * ```ts
+     * function physics_world_listener(self, events) {
+     *   for (const event of events) {
+     *     const event_type = event["type"];
+     *     if (event_type === hash("contact_point_event")) {
+     *       pprint(event);
+     *       // {
+     *       //  distance = 2.1490633487701,
+     *       //  applied_impulse = 0
+     *       //  a = { --[[0x113f7c6c0]]
+     *       //    group = hash: [box],
+     *       //    id = hash: [/box]
+     *       //    mass = 0,
+     *       //    normal = vmath.vector3(0.379, 0.925, -0),
+     *       //    position = vmath.vector3(517.337, 235.068, 0),
+     *       //    instance_position = vmath.vector3(480, 144, 0),
+     *       //    relative_velocity = vmath.vector3(-0, -0, -0),
+     *       //  },
+     *       //  b = { --[[0x113f7c840]]
+     *       //    group = hash: [circle],
+     *       //    id = hash: [/circle]
+     *       //    mass = 0,
+     *       //    normal = vmath.vector3(-0.379, -0.925, 0),
+     *       //    position = vmath.vector3(517.337, 235.068, 0),
+     *       //    instance_position = vmath.vector3(-0.0021, 0, -0.0022),
+     *       //    relative_velocity = vmath.vector3(0, 0, 0),
+     *       //  },
+     *       // }
+     *     } else if (event === hash("collision_event")) {
+     *       pprint(event);
+     *       // {
+     *       //  a = {
+     *       //          group = hash: [default],
+     *       //          position = vmath.vector3(183, 666, 0),
+     *       //          id = hash: [/go1]
+     *       //      },
+     *       //  b = {
+     *       //          group = hash: [default],
+     *       //          position = vmath.vector3(185, 704.05865478516, 0),
+     *       //          id = hash: [/go2]
+     *       //      }
+     *       // }
+     *     } else if (event === hash("trigger_event")) {
+     *       pprint(event);
+     *       // {
+     *       //  enter = true,
+     *       //  b = {
+     *       //      group = hash: [default],
+     *       //      id = hash: [/go2]
+     *       //  },
+     *       //  a = {
+     *       //      group = hash: [default],
+     *       //      id = hash: [/go1]
+     *       //  }
+     *       // },
+     *     } else if (event === hash("ray_cast_response")) {
+     *       pprint(event);
+     *       // {
+     *       //  group = hash: [default],
+     *       //  request_id = 0,
+     *       //  position = vmath.vector3(249.92222595215, 249.92222595215, 0),
+     *       //  fraction = 0.68759721517563,
+     *       //  normal = vmath.vector3(0, 1, 0),
+     *       //  id = hash: [/go]
+     *       // }
+     *     } else if (event === hash("ray_cast_missed")) {
+     *       pprint(event);
+     *       // {
+     *       //  request_id = 0
+     *       // },
+     *     }
+     *   }
+     * }
      *
-     * function init(self)
-     *     physics.set_event_listener(physics_world_listener)
-     * end
+     * export default defineScript({
+     *   init(self) {
+     *     physics.set_event_listener(physics_world_listener);
+     *   },
+     * });
      * ```
      */
     function set_event_listener(callback?: (self: unknown, events: unknown) => void): void;
@@ -337,11 +351,13 @@ declare global {
      *
      * @param gravity - the new gravity vector
      * @example
-     * ```lua
-     * function init(self)
-     *     -- Set "upside down" gravity for this collection.
-     *     physics.set_gravity(vmath.vector3(0, 10.0, 0))
-     * end
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     // Set "upside down" gravity for this collection.
+     *     physics.set_gravity(vmath.vector3(0, 10.0, 0));
+     *   },
+     * });
      * ```
      */
     function set_gravity(gravity: Vector3): void;
@@ -364,11 +380,13 @@ declare global {
      * @param url - the collision object that should flip its shapes
      * @param flip - `true` if the collision object should flip its shapes, `false` if not
      * @example
-     * ```lua
-     * function init(self)
-     *     self.fliph = true -- set on some condition
-     *     physics.set_hflip("#collisionobject", self.fliph)
-     * end
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     self.fliph = true; // set on some condition
+     *     physics.set_hflip("#collisionobject", self.fliph);
+     *   },
+     * });
      * ```
      */
     function set_hflip(url: string | Hash | Url, flip: boolean): void;
@@ -432,11 +450,13 @@ declare global {
      * @param url - the collision object that should flip its shapes
      * @param flip - `true` if the collision object should flip its shapes, `false` if not
      * @example
-     * ```lua
-     * function init(self)
-     *     self.flipv = true -- set on some condition
-     *     physics.set_vflip("#collisionobject", self.flipv)
-     * end
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     self.flipv = true; // set on some condition
+     *     physics.set_vflip("#collisionobject", self.flipv);
+     *   },
+     * });
      * ```
      */
     function set_vflip(url: string | Hash | Url, flip: boolean): void;
@@ -447,8 +467,8 @@ declare global {
      * @param collisionobject - the collision object whose mass needs to be updated.
      * @param mass - the new mass value to set for the collision object.
      * @example
-     * ```lua
-     *  physics.update_mass("#collisionobject", 14)
+     * ```ts
+     * physics.update_mass("#collisionobject", 14);
      * ```
      */
     function update_mass(collisionobject: string | Hash | Url, mass: number): void;