samengine 1.6.4

package/dist/sound/audioplayer.d.ts

@@ -0,0 +1,17 @@
+export declare class SoundSystem {
+    private ctx;
+    private bufferCache;
+    private activeSources;
+    private masterGain;
+    constructor();
+    load(url: string): Promise<AudioBuffer>;
+    play(url: string, options?: {
+        volume?: number;
+        loop?: boolean;
+        playbackRate?: number;
+    }): Promise<AudioBufferSourceNode>;
+    stopAll(): void;
+    setVolume(v: number): void;
+    resume(): Promise<void>;
+    pause(): Promise<void>;
+}

package/dist/sound/audioplayer.js

@@ -0,0 +1,84 @@
+export class SoundSystem {
+    constructor() {
+        this.bufferCache = new Map();
+        this.activeSources = new Set();
+        // 👉 zuerst globalen nehmen, sonst neuen erstellen
+        this.ctx = window.__audioCtx ?? new AudioContext();
+        this.masterGain = this.ctx.createGain();
+        this.masterGain.gain.value = 1;
+        this.masterGain.connect(this.ctx.destination);
+    }
+    // ================= LOAD =================
+    async load(url) {
+        if (this.bufferCache.has(url)) {
+            return this.bufferCache.get(url);
+        }
+        let arrayBuffer;
+        // Check if resource is embedded in single-file export
+        const loadResource = window.__loadResource;
+        if (loadResource) {
+            const dataUri = loadResource(url);
+            if (dataUri) {
+                // Convert data URI to ArrayBuffer
+                const response = await fetch(dataUri);
+                arrayBuffer = await response.arrayBuffer();
+            }
+            else {
+                // Fallback to fetch if resource not found
+                const res = await fetch(url);
+                arrayBuffer = await res.arrayBuffer();
+            }
+        }
+        else {
+            // Normal fetch for multi-file export
+            const res = await fetch(url);
+            arrayBuffer = await res.arrayBuffer();
+        }
+        const buffer = await this.ctx.decodeAudioData(arrayBuffer);
+        this.bufferCache.set(url, buffer);
+        return buffer;
+    }
+    // ================= PLAY =================
+    async play(url, options = {}) {
+        const buffer = await this.load(url);
+        const source = this.ctx.createBufferSource();
+        source.buffer = buffer;
+        source.loop = options.loop ?? false;
+        source.playbackRate.value = options.playbackRate ?? 1;
+        const gain = this.ctx.createGain();
+        gain.gain.value = options.volume ?? 1;
+        source.connect(gain);
+        gain.connect(this.masterGain);
+        source.start(0);
+        this.activeSources.add(source);
+        source.onended = () => {
+            this.activeSources.delete(source);
+        };
+        return source;
+    }
+    // ================= STOP =================
+    stopAll() {
+        for (const s of this.activeSources) {
+            try {
+                s.stop();
+            }
+            catch { }
+        }
+        this.activeSources.clear();
+    }
+    // ================= GLOBAL VOLUME =================
+    setVolume(v) {
+        this.masterGain.gain.value = v;
+    }
+    // ================= CONTEXT CONTROL =================
+    async resume() {
+        if (this.ctx.state === "suspended") {
+            await this.ctx.resume();
+        }
+    }
+    async pause() {
+        if (this.ctx.state === "running") {
+            await this.ctx.suspend();
+        }
+    }
+}

package/dist/sound/index.d.ts

@@ -0,0 +1 @@
+export { SoundSystem } from "./audioplayer.js";

package/dist/sound/index.js

@@ -0,0 +1,2 @@
+// Sound Part
+export { SoundSystem } from "./audioplayer.js";

package/dist/texture.d.ts

@@ -0,0 +1,37 @@
+import { Rect } from "./types/rectangle.js";
+export type Texture = HTMLImageElement | undefined;
+export type DrawOptions = {
+    width?: number;
+    height?: number;
+    rotation?: number;
+    flipX?: boolean;
+    flipY?: boolean;
+    scale?: number;
+};
+export declare function loadTextureAsync(src: string): Promise<HTMLImageElement>;
+export declare function getTexture(src: string): Texture;
+export declare function drawTexture(ctx: CanvasRenderingContext2D, texture: Texture, x: number, y: number, options?: DrawOptions): void;
+export type TextureAtlas = {
+    image: HTMLImageElement;
+    frames: Record<string, Rect>;
+};
+export declare function loadAtlas(imageSrc: string, dataSrc: string): Promise<TextureAtlas>;
+export declare function drawAtlasFrame(ctx: CanvasRenderingContext2D, atlas: TextureAtlas, frameName: string, x: number, y: number, options?: DrawOptions): void;
+export declare class AnimationPlayer {
+    animation: Animation;
+    private time;
+    private currentFrameIndex;
+    private finished;
+    constructor(animation: Animation);
+    update(deltaTime: number): void;
+    getCurrentFrame(): string;
+    reset(): void;
+    isFinished(): boolean;
+}
+export type Animation = {
+    frames: string[];
+    fps: number;
+    loop?: boolean;
+};
+export declare function drawAnimation(ctx: CanvasRenderingContext2D, atlas: TextureAtlas, player: AnimationPlayer, x: number, y: number, options?: DrawOptions): void;
+export declare function getFlipFromDirection(dir: number): boolean;

package/dist/texture.js

@@ -0,0 +1,171 @@
+import { dlog } from "./logger.js";
+const textures = {};
+function getresourcepath(path) {
+    return "resources/" + path;
+}
+// Function to load a Texture Async
+export function loadTextureAsync(src) {
+    return new Promise((resolve, reject) => {
+        // Wenn schon geladen
+        const existing = getTexture(src);
+        if (existing)
+            return resolve(existing);
+        const img = new Image();
+        // 🔹 Hier Pfad modifizieren, z.B. Prefix hinzufügen
+        let finalSrc = getresourcepath(src);
+        const cacheKey = finalSrc;
+        // Check if resources are embedded (single file build)
+        const embeddedResources = window.__resources;
+        if (embeddedResources && embeddedResources[src]) {
+            // Use embedded resource (data URI)
+            finalSrc = embeddedResources[src];
+        }
+        img.onload = () => {
+            // Cache speichern - always use the same cache key for consistency
+            textures[cacheKey] = img;
+            resolve(img);
+        };
+        img.onerror = () => {
+            const msg = `❌ Failed to load texture: ${finalSrc}`;
+            console.error(msg);
+            reject(new Error(msg));
+        };
+        // 🔹 Bild laden mit finalem Pfad
+        img.src = finalSrc;
+    });
+}
+// Function to get the Texture
+export function getTexture(src) {
+    return textures[getresourcepath(src)];
+}
+// Function to draw a texture to the Screen
+export function drawTexture(ctx, texture, x, y, options = {}) {
+    const { width, height, rotation = 0, flipX = false, flipY = false, scale = 1 } = options;
+    if (!texture) {
+        dlog("Texture not found");
+        ctx.fillStyle = "magenta";
+        ctx.fillRect(x, y, (width ?? 32) * scale, (height ?? 32) * scale);
+        return;
+    }
+    const w = (width ?? texture.width) * scale; // 🔹 scale anwenden
+    const h = (height ?? texture.height) * scale; // 🔹 scale anwenden
+    ctx.save();
+    const cx = x + w / 2;
+    const cy = y + h / 2;
+    ctx.translate(cx, cy);
+    ctx.rotate(rotation);
+    ctx.scale(flipX ? -1 : 1, flipY ? -1 : 1);
+    ctx.drawImage(texture, -w / 2, -h / 2, w, h);
+    ctx.restore();
+}
+// Funtion to load an Atlas
+//
+// JSON Format for the LoadAtlas Function
+//
+// {
+//   "frames": {
+//     "player_idle_0": { "x": 0, "y": 0, "w": 32, "h": 32 },
+//     "player_idle_1": { "x": 32, "y": 0, "w": 32, "h": 32 }
+//   }
+// }
+//
+export async function loadAtlas(imageSrc, dataSrc) {
+    const [image, data] = await Promise.all([
+        loadTextureAsync(imageSrc),
+        fetch(getresourcepath(dataSrc)).then(r => r.json())
+    ]);
+    return {
+        image,
+        frames: data.frames
+    };
+}
+export function drawAtlasFrame(ctx, atlas, frameName, x, y, options = {}) {
+    const { width, height, rotation = 0, flipX = false, flipY = false, scale = 1 } = options;
+    const frame = atlas.frames[frameName];
+    if (!frame) {
+        dlog(`Frame not found: ${frameName}`);
+        return;
+    }
+    const w = (width ?? frame.width) * scale;
+    const h = (height ?? frame.height) * scale;
+    ctx.save();
+    const cx = x + w / 2;
+    const cy = y + h / 2;
+    ctx.translate(cx, cy);
+    ctx.rotate(rotation);
+    ctx.scale(flipX ? -1 : 1, flipY ? -1 : 1);
+    ctx.drawImage(atlas.image, frame.x, frame.y, frame.width, frame.height, -w / 2, -h / 2, w, h);
+    ctx.restore();
+}
+//
+//
+// Animation Player
+//
+//
+//
+// // Define Animation
+// const walkAnimation: Animation = {
+//     frames: ["walk_0", "walk_1", "walk_2", "walk_3"],
+//     fps: 8,
+//     loop: true
+// };
+//
+// const player = new AnimationPlayer(walkAnimation);
+//
+// // Game Loop
+// function update(dt: number) {
+//     player.update(dt);
+// }
+//
+// function render(ctx: CanvasRenderingContext2D) {
+//     drawAnimation(ctx, atlas, player, 100, 100, 64, 64);
+// }
+//
+//
+// Animation Player Class
+export class AnimationPlayer {
+    // Konstruktor Function
+    constructor(animation) {
+        this.animation = animation;
+        this.time = 0;
+        this.currentFrameIndex = 0;
+        this.finished = false;
+    }
+    update(deltaTime) {
+        if (this.finished)
+            return;
+        this.time += deltaTime;
+        const frameDuration = 1 / this.animation.fps;
+        while (this.time >= frameDuration) {
+            this.time -= frameDuration;
+            this.currentFrameIndex++;
+            if (this.currentFrameIndex >= this.animation.frames.length) {
+                if (this.animation.loop) {
+                    this.currentFrameIndex = 0;
+                }
+                else {
+                    this.currentFrameIndex = this.animation.frames.length - 1;
+                    this.finished = true;
+                }
+            }
+        }
+    }
+    getCurrentFrame() {
+        return this.animation.frames[this.currentFrameIndex];
+    }
+    reset() {
+        this.time = 0;
+        this.currentFrameIndex = 0;
+        this.finished = false;
+    }
+    isFinished() {
+        return this.finished;
+    }
+}
+export function drawAnimation(ctx, atlas, player, x, y, options = {}) {
+    const frame = player.getCurrentFrame();
+    drawAtlasFrame(ctx, atlas, frame, x, y, options);
+}
+export function getFlipFromDirection(dir) {
+    return dir < 0; // links = true
+}

package/dist/types/circle.d.ts

@@ -0,0 +1,14 @@
+import { Mouse } from "../input.js";
+import { type Vector2d } from "./vector2d.js";
+export type Circle = {
+    x: number;
+    y: number;
+    radius: number;
+};
+export declare function makeCircle(x: number, y: number, radius: number): Circle;
+export declare function centerCircle(circle: Circle): Vector2d;
+export declare function isPointInCircle(x: number, y: number, circle: Circle): boolean;
+export declare function isMouseInCircle(mouse: Mouse, circle: Circle): boolean;
+export declare function isCircleClicked(mouse: Mouse, circle: Circle): boolean;
+export declare function isCircleColliding(circle1: Circle, circle2: Circle): boolean;
+export declare function getCircleDistance(circle1: Circle, circle2: Circle): number;

package/dist/types/circle.js

@@ -0,0 +1,38 @@
+// Circle Type for Hitboxes
+// Function to create an Object of Type Circle
+export function makeCircle(x, y, radius) {
+    return {
+        x: x,
+        y: y,
+        radius: radius,
+    };
+}
+// Function to get the Center of the Circle as Vector2d
+export function centerCircle(circle) {
+    return { x: circle.x, y: circle.y };
+}
+// Check if a Point is in the 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
+export function isMouseInCircle(mouse, circle) {
+    return isPointInCircle(mouse.x, mouse.y, circle);
+}
+// Function to check if a Circle is clicked
+export function isCircleClicked(mouse, circle) {
+    return isMouseInCircle(mouse, circle) && mouse.justPressed;
+}
+// Check if two Circles collide
+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)
+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

@@ -0,0 +1,9 @@
+export type Color = {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+};
+export declare function makeColor(r: number, g: number, b: number, a?: number): Color;
+export declare function invertcolor(color: Color): Color;
+export declare function invertHexColor(hex: string): string;

package/dist/types/color.js

@@ -0,0 +1,27 @@
+// Function to create an Object of Type Color
+export function makeColor(r, g, b, a) {
+    return {
+        r: r,
+        g: g,
+        b: b,
+        a: a
+    };
+}
+export function invertcolor(color) {
+    return {
+        r: 255 - color.r,
+        g: 255 - color.g,
+        b: 255 - color.b,
+        ...(color.a !== undefined ? { a: color.a } : {}) // optional alpha behalten
+    };
+}
+export function invertHexColor(hex) {
+    // Entferne das führende #
+    const cleanHex = hex.replace('#', '');
+    // Wandeln in R, G, B
+    const r = 255 - parseInt(cleanHex.slice(0, 2), 16);
+    const g = 255 - parseInt(cleanHex.slice(2, 4), 16);
+    const b = 255 - parseInt(cleanHex.slice(4, 6), 16);
+    // Zurück in Hex-String
+    return '#' + [r, g, b].map(x => x.toString(16).padStart(2, '0')).join('');
+}

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export { type Vector2d, makeVector2d, add2d, subtract2d, length2d, normalize2d, dot2d, distance2d, clamp2d, lerp2d, map2d } from "./vector2d.js";
+export { type Vector3d, makeVector3d, add3d, subtract3d, length3d, normalize3d, dot3d, crossprodukt3d, distance3d, clamp3d, lerp3d, map3d } from "./vector3d.js";
+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";

package/dist/types/index.js

@@ -0,0 +1,13 @@
+// Types Export
+// Vector 2D
+export { makeVector2d, add2d, subtract2d, length2d, normalize2d, dot2d, distance2d, clamp2d, lerp2d, map2d } from "./vector2d.js";
+// Vector 3D
+export { makeVector3d, add3d, subtract3d, length3d, normalize3d, dot3d, crossprodukt3d, distance3d, clamp3d, lerp3d, map3d } from "./vector3d.js";
+// Color Type
+export { makeColor, invertcolor, invertHexColor } from "./color.js";
+// Retangle Type
+export { makeRect, centerRectX, centerRectY, centerRect, isPointInRect, isMouseInRect, isRectClicked } from "./rectangle.js";
+// Circle Type
+export { makeCircle, centerCircle, isPointInCircle, isMouseInCircle, isCircleClicked, isCircleColliding, getCircleDistance } from "./circle.js";
+// Triangle Type
+export { makeTriangle, centerTriangle, isPointInTriangle, isMouseInTriangle, isTriangleClicked, getTrianglePerimeter, } from "./triangle.js";

package/dist/types/rectangle.d.ts

@@ -0,0 +1,16 @@
+import { type Mouse } from "../input.js";
+import { type Vector2d } from "./vector2d.js";
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    borderRadius?: number;
+};
+export declare function makeRect(x: number, y: number, width: number, height: number, borderRadius?: number): Rect;
+export declare function centerRectX(rect: Rect): number;
+export declare function centerRectY(rect: Rect): number;
+export declare function centerRect(rect: Rect): Vector2d;
+export declare function isPointInRect(x: number, y: number, rect: Rect): boolean;
+export declare function isMouseInRect(mouse: Mouse, rect: Rect): boolean;
+export declare function isRectClicked(mouse: Mouse, rect: Rect): boolean;

package/dist/types/rectangle.js

@@ -0,0 +1,41 @@
+// Rectangle Type for Hitboxes
+// Function to create an Object of Type rect
+export function makeRect(x, y, width, height, borderRadius = 0) {
+    return {
+        x: x,
+        y: y,
+        height: height,
+        width: width,
+        borderRadius: borderRadius
+    };
+}
+// Function to get the Center of the Width of the Object
+export function centerRectX(rect) {
+    return (rect.x + (rect.width / 2));
+}
+// Function to get the Center of the Height of the Object
+export function centerRectY(rect) {
+    return (rect.y + (rect.height / 2));
+}
+// Get the Center of a Rectangle
+export function centerRect(rect) {
+    let vector = { x: centerRectX(rect), y: centerRectY(rect) };
+    return vector;
+}
+// Check if a Point in the Rectangle
+export function isPointInRect(x, y, rect) {
+    return (x >= rect.x &&
+        x <= rect.x + rect.width &&
+        y >= rect.y &&
+        y <= rect.y + rect.height);
+}
+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  
+export function isRectClicked(mouse, rect) {
+    return isMouseInRect(mouse, rect) && mouse.justPressed;
+}

package/dist/types/triangle.d.ts

@@ -0,0 +1,16 @@
+import { Mouse } from "../input.js";
+import { type Vector2d } from "./vector2d.js";
+export type Triangle = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x3: number;
+    y3: number;
+};
+export declare function makeTriangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): Triangle;
+export declare function centerTriangle(triangle: Triangle): Vector2d;
+export declare function isPointInTriangle(x: number, y: number, triangle: Triangle): boolean;
+export declare function isMouseInTriangle(mouse: Mouse, triangle: Triangle): boolean;
+export declare function isTriangleClicked(mouse: Mouse, triangle: Triangle): boolean;
+export declare function getTrianglePerimeter(triangle: Triangle): number;

package/dist/types/triangle.js

@@ -0,0 +1,49 @@
+// Triangle Type for Hitboxes
+// Function to create an Object of Type triangle
+export function makeTriangle(x1, y1, x2, y2, x3, y3) {
+    return {
+        x1: x1,
+        x2: x2,
+        x3: x3,
+        y1: y1,
+        y2: y2,
+        y3: y3,
+    };
+}
+// Helper function to calculate the area of a triangle (used for point-in-triangle)
+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
+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
+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);
+    const area2 = getTriangleArea(triangle.x1, triangle.y1, x, y, triangle.x3, triangle.y3);
+    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
+export function isMouseInTriangle(mouse, triangle) {
+    return isPointInTriangle(mouse.x, mouse.y, triangle);
+}
+// Function to check if a Triangle is clicked
+export function isTriangleClicked(mouse, triangle) {
+    return isMouseInTriangle(mouse, triangle) && mouse.justPressed;
+}
+// Get the Perimeter 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));
+    const side2 = Math.sqrt((triangle.x3 - triangle.x2) * (triangle.x3 - triangle.x2) +
+        (triangle.y3 - triangle.y2) * (triangle.y3 - triangle.y2));
+    const side3 = Math.sqrt((triangle.x1 - triangle.x3) * (triangle.x1 - triangle.x3) +
+        (triangle.y1 - triangle.y3) * (triangle.y1 - triangle.y3));
+    return side1 + side2 + side3;
+}

package/dist/types/vector2d.d.ts

@@ -0,0 +1,14 @@
+export type Vector2d = {
+    x: number;
+    y: number;
+};
+export declare function makeVector2d(x: number, y: number): Vector2d;
+export declare function add2d(vector1: Vector2d, vector2: Vector2d): Vector2d;
+export declare function subtract2d(vector1: Vector2d, vector2: Vector2d): Vector2d;
+export declare function length2d(vector: Vector2d): number;
+export declare function normalize2d(vector: Vector2d): Vector2d;
+export declare function dot2d(v1: Vector2d, v2: Vector2d): number;
+export declare function distance2d(v1: Vector2d, v2: Vector2d): number;
+export declare function clamp2d(vector: Vector2d, min: Vector2d, max: Vector2d): Vector2d;
+export declare function lerp2d(start: Vector2d, end: Vector2d, t: Vector2d): Vector2d;
+export declare function map2d(value: Vector2d, inMin: Vector2d, inMax: Vector2d, outMin: Vector2d, outMax: Vector2d): Vector2d;

package/dist/types/vector2d.js

@@ -0,0 +1,72 @@
+// 2 Dimensional Vector Type
+import { clamp, lerp, map } from "../utils/math.js";
+// Function to create an Object of Type Vector2D
+export function makeVector2d(x, y) {
+    return {
+        x: x,
+        y: y
+    };
+}
+// Function to add 2 Vectors together
+export function add2d(vector1, vector2) {
+    return {
+        x: vector1.x + vector2.x,
+        y: vector1.y + vector2.y,
+    };
+}
+// Function to subtract 2 Vectors from each other
+export function subtract2d(vector1, vector2) {
+    return {
+        x: vector1.x - vector2.x,
+        y: vector1.y - vector2.y,
+    };
+}
+// Function to get the length from an 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
+export function normalize2d(vector) {
+    // Check if the Vector is zero because then you dont need to
+    // calculate sth
+    if (vector.x == 0 && vector.y == 0) {
+        return vector;
+    }
+    let root = length2d(vector);
+    vector.x = vector.x / root;
+    vector.y = vector.y / root;
+    return vector;
+}
+// Function to make scalar produkt from an Vector
+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
+export function distance2d(v1, v2) {
+    let tmp = subtract2d(v1, v2);
+    return length2d(tmp);
+}
+// Function to clamp a Vector 2d
+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
+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
+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),
+    };
+}

package/dist/types/vector3d.d.ts

@@ -0,0 +1,16 @@
+export type Vector3d = {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare function makeVector3d(x: number, y: number, z: number): Vector3d;
+export declare function add3d(vector1: Vector3d, vector2: Vector3d): Vector3d;
+export declare function subtract3d(vector1: Vector3d, vector2: Vector3d): Vector3d;
+export declare function length3d(vector: Vector3d): number;
+export declare function normalize3d(vector: Vector3d): Vector3d;
+export declare function dot3d(v1: Vector3d, v2: Vector3d): number;
+export declare function crossprodukt3d(v1: Vector3d, v2: Vector3d): Vector3d;
+export declare function distance3d(v1: Vector3d, v2: Vector3d): number;
+export declare function clamp3d(vector: Vector3d, min: Vector3d, max: Vector3d): Vector3d;
+export declare function lerp3d(start: Vector3d, end: Vector3d, t: Vector3d): Vector3d;
+export declare function map3d(value: Vector3d, inMin: Vector3d, inMax: Vector3d, outMin: Vector3d, outMax: Vector3d): Vector3d;