samengine 1.9.1 → 1.10.1

package/dist/types/circle.d.ts

@@ -1,14 +1,40 @@
 import { Mouse } from "../input.js";
 import { type Vector2d } from "./vector2d.js";
+/**
+ * Circle shape used for drawing, hit tests, and simple collision checks.
+ *
+ * `x` and `y` are the center of the circle.
+ */
 export type Circle = {
     x: number;
     y: number;
     radius: number;
 };
+/**
+ * Creates a circle object.
+ */
 export declare function makeCircle(x: number, y: number, radius: number): Circle;
+/**
+ * Returns the center of the circle as a `Vector2d`.
+ */
 export declare function centerCircle(circle: Circle): Vector2d;
+/**
+ * Checks whether a point is inside or on the border of a circle.
+ */
 export declare function isPointInCircle(x: number, y: number, circle: Circle): boolean;
+/**
+ * Checks whether the current mouse position is inside a circle.
+ */
 export declare function isMouseInCircle(mouse: Mouse, circle: Circle): boolean;
+/**
+ * Checks whether a circle was clicked during the current frame.
+ */
 export declare function isCircleClicked(mouse: Mouse, circle: Circle): boolean;
+/**
+ * Checks whether two circles overlap or touch.
+ */
 export declare function isCircleColliding(circle1: Circle, circle2: Circle): boolean;
+/**
+ * Returns the center-to-center distance between two circles.
+ */
 export declare function getCircleDistance(circle1: Circle, circle2: Circle): number;

package/dist/types/circle.js

@@ -1,5 +1,7 @@
 // Circle Type for Hitboxes
-// Function to create an Object of Type Circle
+/**
+ * Creates a circle object.
+ */
 export function makeCircle(x, y, radius) {
     return {
         x: x,
@@ -7,31 +9,43 @@ export function makeCircle(x, y, radius) {
         radius: radius,
     };
 }
-// Function to get the Center of the Circle as Vector2d
+/**
+ * Returns the center of the circle as a `Vector2d`.
+ */
 export function centerCircle(circle) {
     return { x: circle.x, y: circle.y };
 }
-// Check if a Point is in the Circle
+/**
+ * Checks whether a point is inside or on the border of a circle.
+ */
 export function isPointInCircle(x, y, circle) {
     const distance = Math.sqrt((x - circle.x) * (x - circle.x) +
         (y - circle.y) * (y - circle.y));
     return distance <= circle.radius;
 }
-// Check if Mouse is in the Circle
+/**
+ * Checks whether the current mouse position is inside a circle.
+ */
 export function isMouseInCircle(mouse, circle) {
     return isPointInCircle(mouse.x, mouse.y, circle);
 }
-// Function to check if a Circle is clicked
+/**
+ * Checks whether a circle was clicked during the current frame.
+ */
 export function isCircleClicked(mouse, circle) {
     return isMouseInCircle(mouse, circle) && mouse.justPressed;
 }
-// Check if two Circles collide
+/**
+ * Checks whether two circles overlap or touch.
+ */
 export function isCircleColliding(circle1, circle2) {
     const distance = Math.sqrt((circle1.x - circle2.x) * (circle1.x - circle2.x) +
         (circle1.y - circle2.y) * (circle1.y - circle2.y));
     return distance <= (circle1.radius + circle2.radius);
 }
-// Check if Circle collides with Rectangle (imported from rectangle.ts would cause circular dependency)
+/**
+ * Returns the center-to-center distance between two circles.
+ */
 export function getCircleDistance(circle1, circle2) {
     return Math.sqrt((circle1.x - circle2.x) * (circle1.x - circle2.x) +
         (circle1.y - circle2.y) * (circle1.y - circle2.y));

package/dist/types/color.d.ts

@@ -1,9 +1,26 @@
+/**
+ * RGBA color object.
+ *
+ * `r`, `g`, and `b` are expected in the 0-255 range. `a` is optional and can be
+ * used by callers as an alpha channel value.
+ */
 export type Color = {
     r: number;
     g: number;
     b: number;
     a?: number;
 };
+/**
+ * Creates a color object.
+ */
 export declare function makeColor(r: number, g: number, b: number, a?: number): Color;
+/**
+ * Returns the RGB inverse of a color while preserving alpha if it exists.
+ */
 export declare function invertcolor(color: Color): Color;
+/**
+ * Inverts a hex color in `#rrggbb` or `rrggbb` format.
+ *
+ * The returned value always starts with `#`.
+ */
 export declare function invertHexColor(hex: string): string;

package/dist/types/color.js

@@ -1,4 +1,6 @@
-// Function to create an Object of Type Color
+/**
+ * Creates a color object.
+ */
 export function makeColor(r, g, b, a) {
     return {
         r: r,
@@ -7,6 +9,9 @@ export function makeColor(r, g, b, a) {
         a: a
     };
 }
+/**
+ * Returns the RGB inverse of a color while preserving alpha if it exists.
+ */
 export function invertcolor(color) {
     return {
         r: 255 - color.r,
@@ -15,6 +20,11 @@ export function invertcolor(color) {
         ...(color.a !== undefined ? { a: color.a } : {}) // optional alpha behalten
     };
 }
+/**
+ * Inverts a hex color in `#rrggbb` or `rrggbb` format.
+ *
+ * The returned value always starts with `#`.
+ */
 export function invertHexColor(hex) {
     // Entferne das führende #
     const cleanHex = hex.replace('#', '');

package/dist/types/index.d.ts

@@ -4,4 +4,4 @@ export { type Color, makeColor, invertcolor, invertHexColor } from "./color.js";
 export { type Rect, makeRect, centerRectX, centerRectY, centerRect, isPointInRect, isMouseInRect, isRectClicked } from "./rectangle.js";
 export { type Circle, makeCircle, centerCircle, isPointInCircle, isMouseInCircle, isCircleClicked, isCircleColliding, getCircleDistance } from "./circle.js";
 export { type Triangle, makeTriangle, centerTriangle, isPointInTriangle, isMouseInTriangle, isTriangleClicked, getTrianglePerimeter, } from "./triangle.js";
-export { type Button, makeButton, clickedButton, drawButton } from "./button.js";
+export { type Button, makeButton, clickedButton, drawButton, isButtonhovered, isButtonpressed } from "./button.js";

package/dist/types/index.js

@@ -12,4 +12,4 @@ export { makeCircle, centerCircle, isPointInCircle, isMouseInCircle, isCircleCli
 // Triangle Type
 export { makeTriangle, centerTriangle, isPointInTriangle, isMouseInTriangle, isTriangleClicked, getTrianglePerimeter, } from "./triangle.js";
 // Button Type
-export { makeButton, clickedButton, drawButton } from "./button.js";
+export { makeButton, clickedButton, drawButton, isButtonhovered, isButtonpressed } from "./button.js";

package/dist/types/rectangle.d.ts

@@ -1,5 +1,11 @@
 import { type Mouse } from "../input.js";
 import { type Vector2d } from "./vector2d.js";
+/**
+ * Axis-aligned rectangle used for drawing, UI, and simple hit tests.
+ *
+ * `x` and `y` describe the top-left corner. `width` and `height` extend to the
+ * right and downward in normal canvas coordinates.
+ */
 export type Rect = {
     x: number;
     y: number;
@@ -7,10 +13,33 @@ export type Rect = {
     height: number;
     borderRadius?: number;
 };
+/**
+ * Creates a rectangle object.
+ */
 export declare function makeRect(x: number, y: number, width: number, height: number, borderRadius?: number): Rect;
+/**
+ * Returns the horizontal center coordinate of a rectangle.
+ */
 export declare function centerRectX(rect: Rect): number;
+/**
+ * Returns the vertical center coordinate of a rectangle.
+ */
 export declare function centerRectY(rect: Rect): number;
+/**
+ * Returns the rectangle center as a `Vector2d`.
+ */
 export declare function centerRect(rect: Rect): Vector2d;
+/**
+ * Checks whether a point is inside or on the border of a rectangle.
+ */
 export declare function isPointInRect(x: number, y: number, rect: Rect): boolean;
+/**
+ * Checks whether the current mouse position is inside a rectangle.
+ */
 export declare function isMouseInRect(mouse: Mouse, rect: Rect): boolean;
+/**
+ * Checks whether a rectangle was clicked during the current frame.
+ *
+ * This depends on `mouse.justPressed`, so call it before `resetInput()`.
+ */
 export declare function isRectClicked(mouse: Mouse, rect: Rect): boolean;

package/dist/types/rectangle.js

@@ -1,5 +1,7 @@
 // Rectangle Type for Hitboxes
-// Function to create an Object of Type rect
+/**
+ * Creates a rectangle object.
+ */
 export function makeRect(x, y, width, height, borderRadius = 0) {
     return {
         x: x,
@@ -9,34 +11,48 @@ export function makeRect(x, y, width, height, borderRadius = 0) {
         borderRadius: borderRadius
     };
 }
-// Function to get the Center of the Width of the Object
+/**
+ * Returns the horizontal center coordinate of a rectangle.
+ */
 export function centerRectX(rect) {
     return (rect.x + (rect.width / 2));
 }
-// Function to get the Center of the Height of the Object
+/**
+ * Returns the vertical center coordinate of a rectangle.
+ */
 export function centerRectY(rect) {
     return (rect.y + (rect.height / 2));
 }
-// Get the Center of a Rectangle
+/**
+ * Returns the rectangle center as a `Vector2d`.
+ */
 export function centerRect(rect) {
     let vector = { x: centerRectX(rect), y: centerRectY(rect) };
     return vector;
 }
-// Check if a Point in the Rectangle
+/**
+ * Checks whether a point is inside or on the border of a rectangle.
+ */
 export function isPointInRect(x, y, rect) {
     return (x >= rect.x &&
         x <= rect.x + rect.width &&
         y >= rect.y &&
         y <= rect.y + rect.height);
 }
-// Is Rectangle Hovered
+/**
+ * Checks whether the current mouse position is inside a rectangle.
+ */
 export function isMouseInRect(mouse, rect) {
     return (mouse.x >= rect.x &&
         mouse.x <= rect.x + rect.width &&
         mouse.y >= rect.y &&
         mouse.y <= rect.y + rect.height);
 }
-// Function to check if a Rectangle is clicked  
+/**
+ * Checks whether a rectangle was clicked during the current frame.
+ *
+ * This depends on `mouse.justPressed`, so call it before `resetInput()`.
+ */
 export function isRectClicked(mouse, rect) {
     return isMouseInRect(mouse, rect) && mouse.justPressed;
 }

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;