@defold-typescript/types 0.5.5 → 0.7.0

package/generated/go.d.ts

@@ -2,6 +2,11 @@
 import type { Hash, Matrix4, Opaque, Quaternion, Url, Vector, Vector3, Vector4 } from "../src/core-types";
 
 declare global {
+  /**
+   * Functions, core hooks, messages and constants for manipulation of
+   * game objects. The "go" namespace is accessible from game object script
+   * files.
+   */
   namespace go {
     /**
      * in-back
@@ -322,11 +327,13 @@ declare global {
      *
      * @param self - reference to the script state to be used for storing data
      * @example
-     * ```lua
-     * function final(self)
-     *     -- report finalization
-     *     msg.post("my_friend_instance", "im_dead", {my_stats = self.some_value})
-     * end
+     * ```ts
+     * export default defineScript({
+     *   final(self) {
+     *     // report finalization
+     *     msg.post("my_friend_instance", "im_dead", { my_stats: self.some_value });
+     *   },
+     * });
      * ```
      */
     export function final(self: Opaque<"userdata">): void;
@@ -530,11 +537,13 @@ declare global {
      *
      * @param self - reference to the script state to be used for storing data
      * @example
-     * ```lua
-     * function init(self)
-     *     -- set up useful data
-     *     self.my_value = 1
-     * end
+     * ```ts
+     * export default defineScript({
+     *   init() {
+     *     // set up useful data
+     *     return { my_value: 1 };
+     *   },
+     * });
      * ```
      */
     export function init(self: Opaque<"userdata">): void;
@@ -646,32 +655,38 @@ declare global {
      * @param action - a table containing the input data, see above for a description
      * @returns optional boolean to signal if the input should be consumed (not passed on to others) or not, default is false
      * @example
-     * ```lua
-     * This example demonstrates how a game object instance can be moved as a response to user input.
-     * function init(self)
-     *     -- acquire input focus
-     *     msg.post(".", "acquire_input_focus")
-     *     -- maximum speed the instance can be moved
-     *     self.max_speed = 2
-     *     -- velocity of the instance, initially zero
-     *     self.velocity = vmath.vector3()
-     * end
-     *
-     * function update(self, dt)
-     *     -- move the instance
-     *     go.set_position(go.get_position() + dt * self.velocity)
-     * end
-     *
-     * function on_input(self, action_id, action)
-     *     -- check for movement input
-     *     if action_id == hash("right") then
-     *         if action.released then -- reset velocity if input was released
-     *             self.velocity = vmath.vector3()
-     *         else -- update velocity
-     *             self.velocity = vmath.vector3(action.value * self.max_speed, 0, 0)
-     *         end
-     *     end
-     * end
+     * ```ts
+     * // This example demonstrates how a game object instance can be moved as a response to user input.
+     * export default defineScript({
+     *   init() {
+     *     // acquire input focus
+     *     msg.post(".", "acquire_input_focus");
+     *     return {
+     *       // maximum speed the instance can be moved
+     *       max_speed: 2,
+     *       // velocity of the instance, initially zero
+     *       velocity: vmath.vector3(),
+     *     };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // move the instance
+     *     go.set_position(go.get_position().add(self.velocity.mul(dt)));
+     *   },
+     *
+     *   on_input(self, action_id, action) {
+     *     // check for movement input
+     *     if (action_id === hash("right")) {
+     *       if (action.released) {
+     *         // reset velocity if input was released
+     *         self.velocity = vmath.vector3();
+     *       } else {
+     *         // update velocity
+     *         self.velocity = vmath.vector3(action.value * self.max_speed, 0, 0);
+     *       }
+     *     }
+     *   },
+     * });
      * ```
      */
     export function on_input(self: Opaque<"userdata">, action_id: Hash, action: Record<string | number, unknown>): boolean | unknown;
@@ -686,29 +701,34 @@ declare global {
      * @param message - a table containing the message data
      * @param sender - address of the sender
      * @example
-     * ```lua
-     * This example demonstrates how a game object instance, called "a", can communicate with another instance, called "b". It
-     * is assumed that both script components of the instances has id "script".
-     * Script of instance "a":
-     * function init(self)
-     *     -- let b know about some important data
-     *     msg.post("b#script", "my_data", {important_value = 1})
-     * end
-     *
-     * Script of instance "b":
-     * function init(self)
-     *     -- store the url of instance "a" for later use, by specifying nil as socket we
-     *     -- automatically use our own socket
-     *     self.a_url = msg.url(nil, go.get_id("a"), "script")
-     * end
-     *
-     * function on_message(self, message_id, message, sender)
-     *     -- check message and sender
-     *     if message_id == hash("my_data") and sender == self.a_url then
-     *         -- use the data in some way
-     *         self.important_value = message.important_value
-     *     end
-     * end
+     * ```ts
+     * // This example demonstrates how a game object instance, called "a", can communicate with another instance, called "b". It
+     * // is assumed that both script components of the instances has id "script".
+     *
+     * // a.script — Script of instance "a":
+     * export default defineScript({
+     *   init() {
+     *     // let b know about some important data
+     *     msg.post("b#script", "my_data", { important_value: 1 });
+     *   },
+     * });
+     *
+     * // b.script — Script of instance "b":
+     * export default defineScript({
+     *   init() {
+     *     // store the url of instance "a" for later use, by specifying undefined as socket we
+     *     // automatically use our own socket
+     *     return { a_url: msg.url(undefined, go.get_id("a"), "script") };
+     *   },
+     *
+     *   on_message(self, message_id, message, sender) {
+     *     // check message and sender
+     *     if (message_id === hash("my_data") && sender === self.a_url) {
+     *       // use the data in some way
+     *       self.important_value = message.important_value;
+     *     }
+     *   },
+     * });
      * ```
      */
     export function on_message(self: Opaque<"userdata">, message_id: Hash, message: Record<string | number, unknown>, sender: Url): void;
@@ -718,69 +738,46 @@ declare global {
      *
      * @param self - reference to the script state to be used for storing data
      * @example
-     * ```lua
-     * This example demonstrates how to tweak the speed of a game object instance that is moved on user input.
-     * function init(self)
-     *     -- acquire input focus
-     *     msg.post(".", "acquire_input_focus")
-     *     -- maximum speed the instance can be moved, this value is tweaked in the on_reload function below
-     *     self.max_speed = 2
-     *     -- velocity of the instance, initially zero
-     *     self.velocity = vmath.vector3()
-     * end
-     *
-     * function update(self, dt)
-     *     -- move the instance
-     *     go.set_position(go.get_position() + dt * self.velocity)
-     * end
-     *
-     * function on_input(self, action_id, action)
-     *     -- check for movement input
-     *     if action_id == hash("right") then
-     *         if action.released then -- reset velocity if input was released
-     *             self.velocity = vmath.vector3()
-     *         else -- update velocity
-     *             self.velocity = vmath.vector3(action.value * self.max_speed, 0, 0)
-     *         end
-     *     end
-     * end
-     *
-     * function on_reload(self)
-     *     -- edit this value and reload the script component
-     *     self.max_speed = 100
-     * end
-     * ```
-     */
-    export function on_reload(self: Opaque<"userdata">): void;
-    /**
-     * This function defines a property which can then be used in the script through the self-reference.
-     * The properties defined this way are automatically exposed in the editor in game objects and collections which use the script.
-     * Note that you can only use this function outside any callback-functions like init and update.
-     *
-     * @param name - the id of the property
-     * @param value - default value of the property. In the case of a url, only the empty constructor msg.url() is allowed. In the case of a resource one of the resource constructors (eg resource.atlas(), resource.font() etc) is expected.
-     * @example
      * ```ts
-     * // This example defines a property "health" in a script. The health is decreased
-     * // whenever someone sends a "take_damage" message to the script.
-     * go.property("health", 100);
-     *
+     * // This example demonstrates how to tweak the speed of a game object instance that is moved on user input.
      * export default defineScript({
-     *   init(self) {
-     *     // prints 100 to the output
-     *     print(self.health);
+     *   init() {
+     *     // acquire input focus
+     *     msg.post(".", "acquire_input_focus");
+     *     return {
+     *       // maximum speed the instance can be moved, this value is tweaked in the on_reload function below
+     *       max_speed: 2,
+     *       // velocity of the instance, initially zero
+     *       velocity: vmath.vector3(),
+     *     };
      *   },
      *
-     *   on_message(self, message_id, message) {
-     *     if (message_id === hash("take_damage")) {
-     *       self.health = self.health - message.damage;
-     *       print(`Ouch! My health is now: ${self.health}`);
+     *   update(self, dt) {
+     *     // move the instance
+     *     go.set_position(go.get_position().add(self.velocity.mul(dt)));
+     *   },
+     *
+     *   on_input(self, action_id, action) {
+     *     // check for movement input
+     *     if (action_id === hash("right")) {
+     *       if (action.released) {
+     *         // reset velocity if input was released
+     *         self.velocity = vmath.vector3();
+     *       } else {
+     *         // update velocity
+     *         self.velocity = vmath.vector3(action.value * self.max_speed, 0, 0);
+     *       }
      *     }
      *   },
+     *
+     *   on_reload(self) {
+     *     // edit this value and reload the script component
+     *     self.max_speed = 100;
+     *   },
      * });
      * ```
      */
-    export function property(name: string, value: number | Hash | Url | Vector3 | Vector4 | Quaternion | Opaque<"resource"> | boolean): void;
+    export function on_reload(self: Opaque<"userdata">): void;
     /**
      * Sets the parent for a game object instance. This means that the instance will exist in the geometrical space of its parent,
      * like a basic transformation hierarchy or scene graph. If no parent is specified, the instance will be detached from any parent and exist in world
@@ -884,17 +881,19 @@ declare global {
      * @param self - reference to the script state to be used for storing data
      * @param dt - the time-step of the frame update
      * @example
-     * ```lua
-     * This example demonstrates how to move a game object instance through the script component:
-     * function init(self)
-     *     -- set initial velocity to be 1 along world x-axis
-     *     self.my_velocity = vmath.vector3(1, 0, 0)
-     * end
-     *
-     * function update(self, dt)
-     *     -- move the game object instance
-     *     go.set_position(go.get_position() + dt * self.my_velocity)
-     * end
+     * ```ts
+     * // This example demonstrates how to move a game object instance through the script component:
+     * export default defineScript({
+     *   init() {
+     *     // set initial velocity to be 1 along world x-axis
+     *     return { my_velocity: vmath.vector3(1, 0, 0) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // move the game object instance
+     *     go.set_position(go.get_position().add(self.my_velocity.mul(dt)));
+     *   },
+     * });
      * ```
      */
     export function update(self: Opaque<"userdata">, dt: number): void;

package/generated/graphics.d.ts

@@ -1,5 +1,8 @@
 /** @noSelfInFile */
 declare global {
+  /**
+   * Graphics functions and constants.
+   */
   namespace graphics {
     const BLEND_FACTOR_CONSTANT_ALPHA: number & { readonly __brand: "graphics.BLEND_FACTOR_CONSTANT_ALPHA" };
     const BLEND_FACTOR_CONSTANT_COLOR: number & { readonly __brand: "graphics.BLEND_FACTOR_CONSTANT_COLOR" };