samengine 1.9.0 → 1.10.0

package/dist/types/triangle.d.ts

@@ -1,5 +1,8 @@
 import { Mouse } from "../input.js";
 import { type Vector2d } from "./vector2d.js";
+/**
+ * Triangle shape represented by three points.
+ */
 export type Triangle = {
     x1: number;
     y1: number;
@@ -8,9 +11,29 @@ export type Triangle = {
     x3: number;
     y3: number;
 };
+/**
+ * Creates a triangle from three points.
+ */
 export declare function makeTriangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): Triangle;
+/**
+ * Returns the centroid of the triangle.
+ */
 export declare function centerTriangle(triangle: Triangle): Vector2d;
+/**
+ * Checks whether a point lies inside the triangle.
+ *
+ * Uses an area comparison with a small tolerance to avoid floating point noise.
+ */
 export declare function isPointInTriangle(x: number, y: number, triangle: Triangle): boolean;
+/**
+ * Checks whether the current mouse position is inside the triangle.
+ */
 export declare function isMouseInTriangle(mouse: Mouse, triangle: Triangle): boolean;
+/**
+ * Checks whether the triangle was clicked during the current frame.
+ */
 export declare function isTriangleClicked(mouse: Mouse, triangle: Triangle): boolean;
+/**
+ * Returns the perimeter length of the triangle.
+ */
 export declare function getTrianglePerimeter(triangle: Triangle): number;

package/dist/types/triangle.js

@@ -1,5 +1,7 @@
 // Triangle Type for Hitboxes
-// Function to create an Object of Type triangle
+/**
+ * Creates a triangle from three points.
+ */
 export function makeTriangle(x1, y1, x2, y2, x3, y3) {
     return {
         x1: x1,
@@ -14,14 +16,20 @@ export function makeTriangle(x1, y1, x2, y2, x3, y3) {
 function getTriangleArea(x1, y1, x2, y2, x3, y3) {
     return Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
 }
-// Function to get the Center of the Triangle
+/**
+ * Returns the centroid of the triangle.
+ */
 export function centerTriangle(triangle) {
     return {
         x: (triangle.x1 + triangle.x2 + triangle.x3) / 3,
         y: (triangle.y1 + triangle.y2 + triangle.y3) / 3
     };
 }
-// Check if a Point is in the Triangle using barycentric coordinates
+/**
+ * Checks whether a point lies inside the triangle.
+ *
+ * Uses an area comparison with a small tolerance to avoid floating point noise.
+ */
 export function isPointInTriangle(x, y, triangle) {
     const areaTriangle = getTriangleArea(triangle.x1, triangle.y1, triangle.x2, triangle.y2, triangle.x3, triangle.y3);
     const area1 = getTriangleArea(x, y, triangle.x2, triangle.y2, triangle.x3, triangle.y3);
@@ -29,15 +37,21 @@ export function isPointInTriangle(x, y, triangle) {
     const area3 = getTriangleArea(triangle.x1, triangle.y1, triangle.x2, triangle.y2, x, y);
     return Math.abs(areaTriangle - (area1 + area2 + area3)) < 0.01;
 }
-// Check if Mouse is in the Triangle
+/**
+ * Checks whether the current mouse position is inside the triangle.
+ */
 export function isMouseInTriangle(mouse, triangle) {
     return isPointInTriangle(mouse.x, mouse.y, triangle);
 }
-// Function to check if a Triangle is clicked
+/**
+ * Checks whether the triangle was clicked during the current frame.
+ */
 export function isTriangleClicked(mouse, triangle) {
     return isMouseInTriangle(mouse, triangle) && mouse.justPressed;
 }
-// Get the Perimeter of the Triangle
+/**
+ * Returns the perimeter length of the triangle.
+ */
 export function getTrianglePerimeter(triangle) {
     const side1 = Math.sqrt((triangle.x2 - triangle.x1) * (triangle.x2 - triangle.x1) +
         (triangle.y2 - triangle.y1) * (triangle.y2 - triangle.y1));

package/dist/types/vector2d.d.ts

@@ -1,15 +1,57 @@
+/**
+ * Two-dimensional vector for positions, directions, velocities, and sizes.
+ */
 export type Vector2d = {
     x: number;
     y: number;
 };
+/**
+ * Creates a new 2D vector.
+ */
 export declare function makeVector2d(x: number, y: number): Vector2d;
+/**
+ * Adds two vectors and returns a new vector.
+ */
 export declare function add2d(vector1: Vector2d, vector2: Vector2d): Vector2d;
+/**
+ * Subtracts `vector2` from `vector1` and returns a new vector.
+ */
 export declare function subtract2d(vector1: Vector2d, vector2: Vector2d): Vector2d;
+/**
+ * Returns the Euclidean length/magnitude of a vector.
+ */
 export declare function length2d(vector: Vector2d): number;
+/**
+ * Normalizes a vector to length `1`.
+ *
+ * Important: this function mutates and returns the original vector object. Zero
+ * vectors are returned unchanged.
+ */
 export declare function normalize2d(vector: Vector2d): Vector2d;
+/**
+ * Returns the dot product of two vectors.
+ */
 export declare function dot2d(v1: Vector2d, v2: Vector2d): number;
+/**
+ * Returns the distance between two vector positions.
+ */
 export declare function distance2d(v1: Vector2d, v2: Vector2d): number;
+/**
+ * Clamps each component of `vector` between the matching `min` and `max`
+ * component.
+ */
 export declare function clamp2d(vector: Vector2d, min: Vector2d, max: Vector2d): Vector2d;
+/**
+ * Linearly interpolates each component from `start` to `end`.
+ *
+ * `t.x` controls x interpolation and `t.y` controls y interpolation.
+ */
 export declare function lerp2d(start: Vector2d, end: Vector2d, t: Vector2d): Vector2d;
+/**
+ * Maps each vector component from one numeric range into another range.
+ */
 export declare function map2d(value: Vector2d, inMin: Vector2d, inMax: Vector2d, outMin: Vector2d, outMax: Vector2d): Vector2d;
+/**
+ * Multiplies both vector components by a scalar.
+ */
 export declare function scale2d(value: Vector2d, vscale: number): Vector2d;

package/dist/types/vector2d.js

@@ -1,33 +1,46 @@
 // 2 Dimensional Vector Type
 import { clamp, lerp, map, scale } from "../utils/math.js";
-// Function to create an Object of Type Vector2D
+/**
+ * Creates a new 2D vector.
+ */
 export function makeVector2d(x, y) {
     return {
         x: x,
         y: y
     };
 }
-// Function to add 2 Vectors together
+/**
+ * Adds two vectors and returns a new vector.
+ */
 export function add2d(vector1, vector2) {
     return {
         x: vector1.x + vector2.x,
         y: vector1.y + vector2.y,
     };
 }
-// Function to subtract 2 Vectors from each other
+/**
+ * Subtracts `vector2` from `vector1` and returns a new vector.
+ */
 export function subtract2d(vector1, vector2) {
     return {
         x: vector1.x - vector2.x,
         y: vector1.y - vector2.y,
     };
 }
-// Function to get the length from an Vector
+/**
+ * Returns the Euclidean length/magnitude of a vector.
+ */
 export function length2d(vector) {
     let produkt = vector.x * vector.x + vector.y * vector.y;
     let root = Math.sqrt(produkt);
     return root;
 }
-// Function to normalize a Vector 2d
+/**
+ * Normalizes a vector to length `1`.
+ *
+ * Important: this function mutates and returns the original vector object. Zero
+ * vectors are returned unchanged.
+ */
 export function normalize2d(vector) {
     // Check if the Vector is zero because then you dont need to
     // calculate sth
@@ -39,38 +52,53 @@ export function normalize2d(vector) {
     vector.y = vector.y / root;
     return vector;
 }
-// Function to make scalar produkt from an Vector
+/**
+ * Returns the dot product of two vectors.
+ */
 export function dot2d(v1, v2) {
     return (v1.x * v2.x + v1.y * v2.y);
 }
 // crossprodukt (only for 3 Dimensinal Vectors)
-// Calculate the Distance between 2 Vectors
+/**
+ * Returns the distance between two vector positions.
+ */
 export function distance2d(v1, v2) {
     let tmp = subtract2d(v1, v2);
     return length2d(tmp);
 }
-// Function to clamp a Vector 2d
+/**
+ * Clamps each component of `vector` between the matching `min` and `max`
+ * component.
+ */
 export function clamp2d(vector, min, max) {
     return {
         x: clamp(vector.x, min.x, max.x),
         y: clamp(vector.y, min.y, max.y),
     };
 }
-// Lerp for a 2d Vector
+/**
+ * Linearly interpolates each component from `start` to `end`.
+ *
+ * `t.x` controls x interpolation and `t.y` controls y interpolation.
+ */
 export function lerp2d(start, end, t) {
     return {
         x: lerp(start.x, end.x, t.x),
         y: lerp(start.y, end.y, t.y),
     };
 }
-// Map Function for a 2d Vector
+/**
+ * Maps each vector component from one numeric range into another range.
+ */
 export function map2d(value, inMin, inMax, outMin, outMax) {
     return {
         x: map(value.x, inMin.x, inMax.x, outMin.x, outMax.x),
         y: map(value.y, inMin.y, inMax.y, outMin.y, outMax.y),
     };
 }
-// Function to scale a Vector
+/**
+ * Multiplies both vector components by a scalar.
+ */
 export function scale2d(value, vscale) {
     return {
         x: scale(value.x, vscale),

package/dist/types/vector3d.d.ts

@@ -1,16 +1,54 @@
+/**
+ * Three-dimensional vector for positions, directions, and velocities.
+ */
 export type Vector3d = {
     x: number;
     y: number;
     z: number;
 };
+/**
+ * Creates a new 3D vector.
+ */
 export declare function makeVector3d(x: number, y: number, z: number): Vector3d;
+/**
+ * Adds two vectors and returns a new vector.
+ */
 export declare function add3d(vector1: Vector3d, vector2: Vector3d): Vector3d;
+/**
+ * Subtracts `vector2` from `vector1` and returns a new vector.
+ */
 export declare function subtract3d(vector1: Vector3d, vector2: Vector3d): Vector3d;
+/**
+ * Returns the Euclidean length/magnitude of a 3D vector.
+ */
 export declare function length3d(vector: Vector3d): number;
+/**
+ * Normalizes a vector to length `1`.
+ *
+ * Important: this function mutates and returns the original vector object.
+ */
 export declare function normalize3d(vector: Vector3d): Vector3d;
+/**
+ * Returns the dot product of two vectors.
+ */
 export declare function dot3d(v1: Vector3d, v2: Vector3d): number;
+/**
+ * Returns the cross product of two 3D vectors.
+ */
 export declare function crossprodukt3d(v1: Vector3d, v2: Vector3d): Vector3d;
+/**
+ * Returns the distance between two 3D vector positions.
+ */
 export declare function distance3d(v1: Vector3d, v2: Vector3d): number;
+/**
+ * Clamps vector components between the matching `min` and `max` components.
+ */
 export declare function clamp3d(vector: Vector3d, min: Vector3d, max: Vector3d): Vector3d;
+/**
+ * Linearly interpolates each component from `start` to `end`.
+ */
 export declare function lerp3d(start: Vector3d, end: Vector3d, t: Vector3d): Vector3d;
+/**
+ * Maps each vector component from one numeric range into another range.
+ */
 export declare function map3d(value: Vector3d, inMin: Vector3d, inMax: Vector3d, outMin: Vector3d, outMax: Vector3d): Vector3d;

package/dist/types/vector3d.js

@@ -1,6 +1,8 @@
 // 3d Vector
 import { clamp, lerp, map } from "../utils/math.js";
-// Function to create an Object of Type Vector3D
+/**
+ * Creates a new 3D vector.
+ */
 export function makeVector3d(x, y, z) {
     return {
         x: x,
@@ -8,7 +10,9 @@ export function makeVector3d(x, y, z) {
         z: z
     };
 }
-// Function to add 2 Vectors together
+/**
+ * Adds two vectors and returns a new vector.
+ */
 export function add3d(vector1, vector2) {
     return {
         x: vector1.x + vector2.x,
@@ -16,7 +20,9 @@ export function add3d(vector1, vector2) {
         z: vector1.z + vector2.z,
     };
 }
-// Function to subtract 2 Vectors from each other
+/**
+ * Subtracts `vector2` from `vector1` and returns a new vector.
+ */
 export function subtract3d(vector1, vector2) {
     return {
         x: vector1.x - vector2.x,
@@ -24,13 +30,19 @@ export function subtract3d(vector1, vector2) {
         z: vector1.z - vector2.z,
     };
 }
-// Function to get the length from an Vector
+/**
+ * Returns the Euclidean length/magnitude of a 3D vector.
+ */
 export function length3d(vector) {
     let produkt = vector.x * vector.x + vector.y * vector.y + vector.z * vector.z;
     let root = Math.sqrt(produkt);
     return root;
 }
-// Function to normalize a Vector 2d
+/**
+ * Normalizes a vector to length `1`.
+ *
+ * Important: this function mutates and returns the original vector object.
+ */
 export function normalize3d(vector) {
     // Check if the Vector is zero because then you dont need to
     // calculate sth
@@ -43,11 +55,15 @@ export function normalize3d(vector) {
     vector.z = vector.z / root;
     return vector;
 }
-// Function to make scalar produkt from an Vector
+/**
+ * Returns the dot product of two vectors.
+ */
 export function dot3d(v1, v2) {
     return (v1.x * v2.x + v1.y * v2.y + v1.z * v2.z);
 }
-// Function to calculate the cross produkt
+/**
+ * Returns the cross product of two 3D vectors.
+ */
 export function crossprodukt3d(v1, v2) {
     return {
         x: (v1.y * v2.z - v1.z * v2.y),
@@ -55,12 +71,16 @@ export function crossprodukt3d(v1, v2) {
         z: (v1.x * v2.y - v1.y * v2.x),
     };
 }
-// Calculate the Distance between 2 Vectors
+/**
+ * Returns the distance between two 3D vector positions.
+ */
 export function distance3d(v1, v2) {
     let tmp = subtract3d(v1, v2);
     return length3d(tmp);
 }
-// Function to clamp a Vector 3d
+/**
+ * Clamps vector components between the matching `min` and `max` components.
+ */
 export function clamp3d(vector, min, max) {
     return {
         x: clamp(vector.x, min.x, max.x),
@@ -68,7 +88,9 @@ export function clamp3d(vector, min, max) {
         z: clamp(vector.y, min.y, max.y),
     };
 }
-// Lerp for a 3d Vector
+/**
+ * Linearly interpolates each component from `start` to `end`.
+ */
 export function lerp3d(start, end, t) {
     return {
         x: lerp(start.x, end.x, t.x),
@@ -76,7 +98,9 @@ export function lerp3d(start, end, t) {
         z: lerp(start.y, end.y, t.y),
     };
 }
-// Map Function for a 3d Vector
+/**
+ * Maps each vector component from one numeric range into another range.
+ */
 export function map3d(value, inMin, inMax, outMin, outMax) {
     return {
         x: map(value.x, inMin.x, inMax.x, outMin.x, outMax.x),

package/dist/utils/index.d.ts

@@ -1,5 +1,14 @@
 export { clamp, lerp, map, scale } from "./math.js";
-export type { ParseOptions as MarkdownParseOptions } from "./markdown.js";
-export { parse as parseMarkdown, parseToDocument as parseMarkdownToDocument, exportcss as exportMarkdownCSS } from "./markdown.js";
-export type { JSONValue } from "./jsonc-parser.js";
-export { parseJSONC } from "./jsonc-parser.js";
+/**
+ * Creates a small deterministic 32-bit hash from a string.
+ *
+ * Used internally by the immediate-mode HTML UI to turn labels into stable
+ * numeric ids. This is not a cryptographic hash.
+ */
+export declare function hash(str: string): number;
+/**
+ * Shuffles an array in place using the Fisher-Yates algorithm.
+ *
+ * The same array instance is returned for convenient chaining.
+ */
+export declare function shuffle<T>(array: T[]): T[];

package/dist/utils/index.js

@@ -1,5 +1,29 @@
 // Utils Package
 // Math Utilities
 export { clamp, lerp, map, scale } from "./math.js";
-export { parse as parseMarkdown, parseToDocument as parseMarkdownToDocument, exportcss as exportMarkdownCSS } from "./markdown.js";
-export { parseJSONC } from "./jsonc-parser.js";
+/**
+ * Creates a small deterministic 32-bit hash from a string.
+ *
+ * Used internally by the immediate-mode HTML UI to turn labels into stable
+ * numeric ids. This is not a cryptographic hash.
+ */
+export function hash(str) {
+    let h = 0;
+    for (let i = 0; i < str.length; i++) {
+        h = (h << 5) - h + str.charCodeAt(i);
+        h |= 0; // 32bit int
+    }
+    return h;
+}
+/**
+ * Shuffles an array in place using the Fisher-Yates algorithm.
+ *
+ * The same array instance is returned for convenient chaining.
+ */
+export function shuffle(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+    return array;
+}

package/dist/utils/logger/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Function to get the Date for the Logger
+ * @returns String for the current Date
+ */
+export declare function getDate(): string;
+/**
+ * Logger Class for samengine
+ */
+export declare class Logger {
+    constructor();
+    log(input: string): void;
+    warn(input: string): void;
+    error(input: string): void;
+}
+/**
+ * Logger Class with the same functions but they are doing nothing
+ * to remove the console logs in the export
+ */
+export declare class ExportLogger {
+    constructor();
+    log(input: string): void;
+    warn(input: string): void;
+    error(input: string): void;
+}

package/dist/utils/logger/index.js

@@ -0,0 +1,44 @@
+// Logger
+/**
+ * Function to get the Date for the Logger
+ * @returns String for the current Date
+ */
+export function getDate() {
+    const now = new Date();
+    const time = `[${now.getHours().toString().padStart(2, "0")}:` +
+        `${now.getMinutes().toString().padStart(2, "0")}:` +
+        `${now.getSeconds().toString().padStart(2, "0")}.` +
+        `${now.getMilliseconds().toString().padStart(3, "0")}]`;
+    return time;
+}
+/**
+ * Logger Class for samengine
+ */
+export class Logger {
+    constructor() { }
+    log(input) {
+        console.log(`${getDate()} ${input}`);
+    }
+    warn(input) {
+        console.warn(`${getDate()} ${input}`);
+    }
+    error(input) {
+        console.error(`${getDate()} ${input}`);
+    }
+}
+/**
+ * Logger Class with the same functions but they are doing nothing
+ * to remove the console logs in the export
+ */
+export class ExportLogger {
+    constructor() { }
+    log(input) {
+        // Empty
+    }
+    warn(input) {
+        // Empty
+    }
+    error(input) {
+        // Empty
+    }
+}

package/dist/utils/math.d.ts

@@ -1,4 +1,22 @@
+/**
+ * Restricts a number to the inclusive range between `min` and `max`.
+ */
 export declare function clamp(input: number, min: number, max: number): number;
+/**
+ * Linear interpolation between `start` and `end`.
+ *
+ * `t = 0` returns `start`, `t = 1` returns `end`, and values between them blend.
+ */
 export declare function lerp(start: number, end: number, t: number): number;
+/**
+ * Maps a number from one range into another range.
+ *
+ * Example: `map(5, 0, 10, 0, 100)` returns `50`.
+ */
 export declare function map(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+/**
+ * Multiplies two numbers.
+ *
+ * Kept as a tiny utility so vector helpers can use the same naming style.
+ */
 export declare function scale(n1: number, n2: number): number;

package/dist/utils/math.js

@@ -1,16 +1,30 @@
-// Clamp
+/**
+ * Restricts a number to the inclusive range between `min` and `max`.
+ */
 export function clamp(input, min, max) {
     return Math.min(Math.max(input, min), max);
 }
-// Lerp
+/**
+ * Linear interpolation between `start` and `end`.
+ *
+ * `t = 0` returns `start`, `t = 1` returns `end`, and values between them blend.
+ */
 export function lerp(start, end, t) {
     return (start + (end - start) * t);
 }
-// Map
+/**
+ * Maps a number from one range into another range.
+ *
+ * Example: `map(5, 0, 10, 0, 100)` returns `50`.
+ */
 export function map(value, inMin, inMax, outMin, outMax) {
     return (outMax - outMin) * ((value - inMin) / (inMax - inMin)) + outMin;
 }
-// Scale
+/**
+ * Multiplies two numbers.
+ *
+ * Kept as a tiny utility so vector helpers can use the same naming style.
+ */
 export function scale(n1, n2) {
     return n1 * n2;
 }