samengine 1.6.5 → 1.7.0

package/dist/build/index.d.ts

@@ -1 +1 @@
-export { version } from "./version.js";
+export declare function version(): string;

package/dist/build/index.js

@@ -1,2 +1,4 @@
-// Export the Version
-export { version } from "./version.js";
+// Function to get the Version
+export function version() {
+    return "1.7.0";
+}

package/dist/index.d.ts

@@ -3,7 +3,8 @@ export { renderText, renderBitmapText, drawRect, drawRectOutline, drawCircle, dr
 export type { Mouse } from "./input.js";
 export { setupInput, isKeyJustPressed, resetInput, getMouse } from "./input.js";
 export { dlog } from "./logger.js";
-export { saveGame, loadGame, clearSave } from "./save.js";
+export type { SaveData } from "./save.js";
+export { SAVE_KEY, saveGame, loadGame, clearSave, exportSave } from "./save.js";
 export type { Texture, DrawOptions, TextureAtlas, Animation, } from "./texture.js";
 export { loadTextureAsync, getTexture, drawTexture, loadAtlas, drawAtlasFrame, AnimationPlayer, drawAnimation, getFlipFromDirection, } from "./texture.js";
 export { createCanvas, enableFullscreen, setupFullscreenButton } from "./html.js";

package/dist/index.js

@@ -5,8 +5,7 @@ export { renderText, renderBitmapText, drawRect, drawRectOutline, drawCircle, dr
 export { setupInput, isKeyJustPressed, resetInput, getMouse } from "./input.js";
 // Logging
 export { dlog } from "./logger.js";
-// Save System
-export { saveGame, loadGame, clearSave } from "./save.js";
+export { SAVE_KEY, saveGame, loadGame, clearSave, exportSave } from "./save.js";
 export { loadTextureAsync, getTexture, drawTexture, loadAtlas, drawAtlasFrame, AnimationPlayer, drawAnimation, getFlipFromDirection, } from "./texture.js";
 // HTML Generation
 export { createCanvas, enableFullscreen, setupFullscreenButton } from "./html.js";

package/dist/physics/collision.d.ts

@@ -0,0 +1,24 @@
+import { Vector2d } from "../types/vector2d.js";
+import { PhysicsObject } from "./physicsObject.js";
+export type Collider = {
+    type: "circle";
+    radius: number;
+} | {
+    type: "box";
+    width: number;
+    height: number;
+};
+export declare function aabbCollision(a: PhysicsObject, b: PhysicsObject): {
+    normal: Vector2d;
+    penetration: number;
+} | null;
+export declare function circleCollision(a: PhysicsObject, b: PhysicsObject): {
+    normal: Vector2d;
+    penetration: number;
+} | null;
+export declare function circleBoxCollision(circleObj: PhysicsObject, boxObj: PhysicsObject): {
+    normal: Vector2d;
+    penetration: number;
+} | null;
+export declare function resolveCollision(a: PhysicsObject, b: PhysicsObject, normal: Vector2d): void;
+export declare function positionalCorrection(a: PhysicsObject, b: PhysicsObject, normal: Vector2d, penetration: number): void;

package/dist/physics/collision.js

@@ -0,0 +1,94 @@
+import { add2d, dot2d, length2d, makeVector2d, normalize2d, scale2d, subtract2d } from "../types/vector2d.js";
+import { clamp } from "../utils/math.js";
+export function aabbCollision(a, b) {
+    const posA = a.body.position;
+    const posB = b.body.position;
+    const boxA = a.collider;
+    const boxB = b.collider;
+    const halfA = makeVector2d(boxA.width / 2, boxA.height / 2);
+    const halfB = makeVector2d(boxB.width / 2, boxB.height / 2);
+    const diff = subtract2d(posB, posA);
+    const overlapX = halfA.x + halfB.x - Math.abs(diff.x);
+    const overlapY = halfA.y + halfB.y - Math.abs(diff.y);
+    if (overlapX > 0 && overlapY > 0) {
+        // kleinste Achse bestimmen
+        if (overlapX < overlapY) {
+            return {
+                normal: makeVector2d(Math.sign(diff.x), 0),
+                penetration: overlapX,
+            };
+        }
+        else {
+            return {
+                normal: makeVector2d(0, Math.sign(diff.y)),
+                penetration: overlapY,
+            };
+        }
+    }
+    return null;
+}
+export function circleCollision(a, b) {
+    const posA = a.body.position;
+    const posB = b.body.position;
+    const diff = subtract2d(posB, posA);
+    const dist = length2d(diff);
+    const rA = a.collider.radius;
+    const rB = b.collider.radius;
+    if (dist < rA + rB) {
+        return {
+            normal: normalize2d(diff),
+            penetration: rA + rB - dist,
+        };
+    }
+    return null;
+}
+export function circleBoxCollision(circleObj, boxObj) {
+    const circle = circleObj.collider;
+    const box = boxObj.collider;
+    const circlePos = circleObj.body.position;
+    const boxPos = boxObj.body.position;
+    const half = makeVector2d(box.width / 2, box.height / 2);
+    // nächster Punkt auf Box
+    const closestX = clamp(circlePos.x, boxPos.x - half.x, boxPos.x + half.x);
+    const closestY = clamp(circlePos.y, boxPos.y - half.y, boxPos.y + half.y);
+    const closest = makeVector2d(closestX, closestY);
+    const diff = subtract2d(circlePos, closest);
+    const dist = length2d(diff);
+    if (dist < circle.radius) {
+        const normal = dist === 0
+            ? makeVector2d(0, -1) // fallback
+            : normalize2d(diff);
+        return {
+            normal,
+            penetration: circle.radius - dist,
+        };
+    }
+    return null;
+}
+export function resolveCollision(a, b, normal) {
+    const rv = subtract2d(b.body.velocity, a.body.velocity);
+    const velAlongNormal = dot2d(rv, normal);
+    if (velAlongNormal > 0)
+        return;
+    const restitution = Math.min(a.body.restitution, b.body.restitution);
+    const invMassA = a.body.isStatic ? 0 : 1 / a.body.mass;
+    const invMassB = b.body.isStatic ? 0 : 1 / b.body.mass;
+    const j = -(1 + restitution) * velAlongNormal /
+        (invMassA + invMassB);
+    const impulse = scale2d(normal, j);
+    if (!a.body.isStatic)
+        a.body.velocity = subtract2d(a.body.velocity, scale2d(impulse, invMassA));
+    if (!b.body.isStatic)
+        b.body.velocity = subtract2d(b.body.velocity, scale2d(impulse, invMassB));
+}
+export function positionalCorrection(a, b, normal, penetration) {
+    const percent = 0.8; // Stärke
+    const slop = 0.01;
+    const invMassA = a.body.isStatic ? 0 : 1 / a.body.mass;
+    const invMassB = b.body.isStatic ? 0 : 1 / b.body.mass;
+    const correction = scale2d(scale2d(normal, Math.max(penetration - slop, 0) / (invMassA + invMassB)), percent);
+    if (!a.body.isStatic)
+        a.body.position = subtract2d(a.body.position, scale2d(correction, invMassA));
+    if (!b.body.isStatic)
+        b.body.position = add2d(b.body.position, scale2d(correction, invMassB));
+}

package/dist/physics/physicsEngine.d.ts

@@ -0,0 +1,7 @@
+import { Vector2d } from "../types/vector2d.js";
+import { PhysicsObject } from "./physicsObject.js";
+export declare class PhysicsWorld {
+    objects: PhysicsObject[];
+    gravity: Vector2d;
+    step(dt: number): void;
+}

package/dist/physics/physicsEngine.js

@@ -0,0 +1,63 @@
+import { makeVector2d, scale2d, add2d } from "../types/vector2d.js";
+import { aabbCollision, circleBoxCollision, circleCollision, positionalCorrection, resolveCollision } from "./collision.js";
+// Exapmle for a Use Case
+// const world = new PhysicsWorld();
+// const ball1 = new PhysicsObject(
+//   new RigidBody(new Vec2(100, 100), 1, 0.9),
+//   { type: "circle", radius: 20 }
+// );
+// const ball2 = new PhysicsObject(
+//   new RigidBody(new Vec2(200, 100), 1, 0.9),
+//   { type: "circle", radius: 20 }
+// );
+// world.objects.push(ball1, ball2);
+// // Game Loop
+// function update(dt: number) {
+//   world.step(dt);
+// }
+export class PhysicsWorld {
+    constructor() {
+        this.objects = [];
+        this.gravity = makeVector2d(0, 500); // px/s²
+    }
+    step(dt) {
+        // Bewegung
+        for (const obj of this.objects) {
+            if (obj.body.isStatic)
+                continue;
+            obj.body.velocity = add2d(obj.body.velocity, scale2d(this.gravity, dt));
+            obj.body.position = add2d(obj.body.position, scale2d(obj.body.velocity, dt));
+        }
+        // Kollisionen
+        for (let i = 0; i < this.objects.length; i++) {
+            for (let j = i + 1; j < this.objects.length; j++) {
+                const a = this.objects[i];
+                const b = this.objects[j];
+                let collision = null;
+                // Circle vs Circle
+                if (a.collider.type === "circle" && b.collider.type === "circle") {
+                    collision = circleCollision(a, b);
+                }
+                // Box vs Box
+                else if (a.collider.type === "box" && b.collider.type === "box") {
+                    collision = aabbCollision(a, b);
+                }
+                // Circle vs Box
+                else if (a.collider.type === "circle" && b.collider.type === "box") {
+                    collision = circleBoxCollision(a, b);
+                }
+                // Box vs Circle (umdrehen!)
+                else if (a.collider.type === "box" && b.collider.type === "circle") {
+                    collision = circleBoxCollision(b, a);
+                    if (collision) {
+                        collision.normal = scale2d(collision.normal, -1);
+                    }
+                }
+                if (collision) {
+                    resolveCollision(a, b, collision.normal);
+                    positionalCorrection(a, b, collision.normal, collision.penetration);
+                }
+            }
+        }
+    }
+}

package/dist/physics/physicsObject.d.ts

@@ -0,0 +1,15 @@
+import { Vector2d } from "../types/vector2d.js";
+import { Collider } from "./collision.js";
+export declare class RigidBody {
+    position: Vector2d;
+    velocity: Vector2d;
+    mass: number;
+    restitution: number;
+    isStatic: boolean;
+    constructor(pos: Vector2d, mass?: number, restitution?: number, isStatic?: boolean);
+}
+export declare class PhysicsObject {
+    body: RigidBody;
+    collider: Collider;
+    constructor(body: RigidBody, collider: Collider);
+}

package/dist/physics/physicsObject.js

@@ -0,0 +1,16 @@
+import { makeVector2d } from "../types/vector2d.js";
+export class RigidBody {
+    constructor(pos, mass = 1, restitution = 0.8, isStatic = false) {
+        this.position = pos;
+        this.velocity = makeVector2d(0, 0);
+        this.mass = isStatic ? Infinity : mass;
+        this.restitution = restitution;
+        this.isStatic = isStatic;
+    }
+}
+export class PhysicsObject {
+    constructor(body, collider) {
+        this.body = body;
+        this.collider = collider;
+    }
+}

package/dist/save.d.ts

@@ -1,5 +1,6 @@
-type SaveData = Record<string, any>;
+export type SaveData = Record<string, any>;
+export declare let SAVE_KEY: string;
 export declare function saveGame(data: SaveData): void;
 export declare function loadGame(): SaveData | null;
 export declare function clearSave(): void;
-export {};
+export declare function exportSave(): void;

package/dist/save.js

@@ -1,4 +1,5 @@
-const SAVE_KEY = "my_game_save";
+// Please rename the SaveKey
+export let SAVE_KEY = "my_game_save";
 export function saveGame(data) {
     try {
         const json = JSON.stringify(data);
@@ -25,3 +26,23 @@ export function clearSave() {
     localStorage.removeItem(SAVE_KEY);
     console.log("Save cleared!");
 }
+export function exportSave() {
+    try {
+        const json = localStorage.getItem(SAVE_KEY);
+        if (!json) {
+            console.warn("No save data found.");
+            return;
+        }
+        const blob = new Blob([json], { type: "application/json" });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = "savegame.json";
+        a.click();
+        URL.revokeObjectURL(url);
+        console.log("Save exported!");
+    }
+    catch (err) {
+        console.error("Export failed:", err);
+    }
+}

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export { type Vector2d, makeVector2d, add2d, subtract2d, length2d, normalize2d, dot2d, distance2d, clamp2d, lerp2d, map2d } from "./vector2d.js";
+export { type Vector2d, makeVector2d, add2d, subtract2d, length2d, normalize2d, dot2d, distance2d, clamp2d, lerp2d, map2d, scale2d } 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";

package/dist/types/index.js

@@ -1,6 +1,6 @@
 // Types Export
 // Vector 2D
-export { makeVector2d, add2d, subtract2d, length2d, normalize2d, dot2d, distance2d, clamp2d, lerp2d, map2d } from "./vector2d.js";
+export { makeVector2d, add2d, subtract2d, length2d, normalize2d, dot2d, distance2d, clamp2d, lerp2d, map2d, scale2d } from "./vector2d.js";
 // Vector 3D
 export { makeVector3d, add3d, subtract3d, length3d, normalize3d, dot3d, crossprodukt3d, distance3d, clamp3d, lerp3d, map3d } from "./vector3d.js";
 // Color Type

package/dist/types/vector2d.d.ts

@@ -12,3 +12,4 @@ 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;
+export declare function scale2d(value: Vector2d, vscale: number): Vector2d;

package/dist/types/vector2d.js

@@ -1,5 +1,5 @@
 // 2 Dimensional Vector Type
-import { clamp, lerp, map } from "../utils/math.js";
+import { clamp, lerp, map, scale } from "../utils/math.js";
 // Function to create an Object of Type Vector2D
 export function makeVector2d(x, y) {
     return {
@@ -70,3 +70,10 @@ export function map2d(value, inMin, inMax, outMin, outMax) {
         y: map(value.y, inMin.y, inMax.y, outMin.y, outMax.y),
     };
 }
+// Function to scale a Vector
+export function scale2d(value, vscale) {
+    return {
+        x: scale(value.x, vscale),
+        y: scale(value.y, vscale),
+    };
+}

package/dist/utils/index.d.ts

@@ -1,4 +1,4 @@
-export { clamp, lerp, map } from "./math.js";
+export { clamp, lerp, map, scale } from "./math.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";

package/dist/utils/index.js

@@ -1,6 +1,6 @@
 // Utils Package
 // Math Utilities
-export { clamp, lerp, map } from "./math.js";
+export { clamp, lerp, map, scale } from "./math.js";
 // Markdown Parser
 export { parse as parseMarkdown, parseToDocument as parseMarkdownToDocument, exportcss as exportMarkdownCSS } from "./markdown.js";
 export { parseJSONC } from "./jsonc-parser.js";

package/dist/utils/math.d.ts

@@ -1,3 +1,4 @@
 export declare function clamp(input: number, min: number, max: number): number;
 export declare function lerp(start: number, end: number, t: number): number;
 export declare function map(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+export declare function scale(n1: number, n2: number): number;

package/dist/utils/math.js

@@ -10,3 +10,7 @@ export function lerp(start, end, t) {
 export function map(value, inMin, inMax, outMin, outMax) {
     return (outMax - outMin) * ((value - inMin) / (inMax - inMin)) + outMin;
 }
+// Scale
+export function scale(n1, n2) {
+    return n1 * n2;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "samengine",
-  "version": "1.6.5",
+  "version": "1.7.0",
   "description": "A TypeScript game library to make HTML Games",
   "sideEffects": false,
   "files": [
@@ -29,7 +29,6 @@
     "@types/node": "^25.5.2",
     "typescript": "^6.0.2"
   },
-  "dependencies": {},
   "repository": {
     "type": "git",
     "url": "https://github.com/shadowdara/samengine"

package/dist/build/version.d.ts

@@ -1 +0,0 @@
-export declare function version(): string;

package/dist/build/version.js

@@ -1,4 +0,0 @@
-// Function to get the Version
-export function version() {
-    return "1.6.5";
-}