slifer 0.2.2 → 0.2.3

package/index.ts

@@ -1,4 +1,11 @@
 import { SliferClass } from "./src/slifer";
 
+export { Image } from './src/engine/image';
+export { Vector2 } from './src/engine/vector';
+export { Rectangle } from './src/engine/rectangle';
+export { Timer } from './src/engine/time';
+export { AudioSource } from './src/modules/audio'
+
 const Slifer = new SliferClass();
-export default Slifer;
+export default Slifer;
+

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "slifer",
-    "version": "0.2.2",
+    "version": "0.2.3",
     "description": "A game framework made for bun and typescript",
     "module": "index.ts",
     "devDependencies": {

package/src/engine/image.ts

@@ -0,0 +1,28 @@
+import { type Pointer, ptr } from 'bun:ffi';
+import { libsdl } from '../ffi';
+import { Vector2 } from './vector';
+
+export class Image {
+    public readonly pointer: Pointer;
+    public readonly size: Vector2;
+    public flipH: boolean = false;
+
+    constructor(texture: Pointer) {
+        this.pointer = texture;
+
+        const _wArr = new Uint32Array(1);
+        const _hArr = new Uint32Array(1);
+
+        libsdl.symbols.SDL_QueryTexture(
+            texture,
+            null,
+            null,
+            ptr(_wArr),
+            ptr(_hArr)
+        );
+
+        this.size = new Vector2(_wArr[0], _hArr[0]);
+    }
+
+}
+

package/src/engine/rectangle.ts

@@ -1,8 +1,8 @@
 import { ptr } from "bun:ffi";
-import Vector2 from "./vector";
+import { Vector2 } from "./vector";
 
-class Rectangle {
-    private readonly pointer;
+export class Rectangle {
+    public readonly pointer;
     public position: Vector2;
     public size: Vector2;
 
@@ -20,6 +20,18 @@ class Rectangle {
     static empty() {
         return new Rectangle(new Vector2(0, 0), new Vector2(0, 0));
     }
+
+    public isColliding(rectangle: Rectangle) : boolean {
+    	if (
+    		this.position.x < rectangle.position.x + rectangle.size.x &&
+    		this.position.x + this.size.x > rectangle.position.x &&
+    		this.position.y < rectangle.position.y + rectangle.size.y &&
+    		this.position.y + this.size.y > rectangle.position.y
+    	) {
+    		return true;
+    	}
+
+    	return false;
+    }
 }
 
-export default Rectangle;

package/src/engine/time.ts

@@ -1,34 +1,79 @@
 import { libsdl } from "../ffi";
 
-class Time {
-    static #instance: Time;
+export class Timer {
 
-    private lastframe: number = 0;
-    private firstFrame: number = 0;
+	private mStartTicks;
+	private mPausedTicks;
+	private mPaused;
+	private mStarted;
+	
+    
+    constructor() {
+    	this.mStartTicks = 0;
+    	this.mPausedTicks = 0;
+    	this.mPaused = false;
+    	this.mStarted = false;
+    }
+    
+   	public start() {
+   		this.mStarted = true;
 
-    private constructor() {}
+   		this.mPaused = false;
 
-    public static get instance() {
-        if (!Time.#instance) {
-            Time.#instance = new Time();
-        }
+   		this.mStartTicks = libsdl.symbols.SDL_GetTicks();
+		this.mPausedTicks = 0;
+   	}
 
-        return Time.#instance;
-    }
+   	public stop() {
+   		this.mStarted = false;
+   		this.mPaused = true;
 
-    public init() {
-        this.firstFrame = Number(libsdl.symbols.SDL_GetPerformanceCounter());
-    }
+   		this.mStartTicks = 0;
+   		this.mPausedTicks = 0;
+   	}
 
-    public calcDelta(): number {
-        this.lastframe = this.firstFrame;
-        this.firstFrame = Number(libsdl.symbols.SDL_GetPerformanceCounter());
-        const deltaTime =
-            ((this.firstFrame - this.lastframe) * 1000) /
-            Number(libsdl.symbols.SDL_GetPerformanceFrequency());
+   	public pause() {
+		if (this.mStarted && !this.mPaused) {
+			this.mPaused = true;
 
-        return deltaTime;
-    }
+			this.mPausedTicks = libsdl.symbols.SDL_GetTicks() - this.mStartTicks;
+			this.mStartTicks = 0;
+		}
+   	}
+
+   	public unpause() {
+		if (this.mStarted && this.mPaused) {
+			this.mPaused = false;
+
+			this.mStartTicks = libsdl.symbols.SDL_GetTicks() - this.mPausedTicks;
+			this.mPausedTicks = 0;
+		}
+   	}
+
+   	public getTicks() {
+   		let time = 0;
+
+   		if (this.mStarted) {
+   			if (this.mPaused) {
+   				time = this.mPausedTicks;
+   			} else {
+   				time = libsdl.symbols.SDL_GetTicks() - this.mStartTicks;
+   			}
+   		}
+
+   		return time;
+   	}
+
+   	public isStarted() {
+   		return this.mStarted;
+   	}
+
+   	public isPaused() {
+   		return (this.mPaused && this.mStarted);
+   	}
+
+   	
+
+    
 }
 
-export default Time;

package/src/engine/vector.ts

@@ -1,4 +1,4 @@
-class Vector2 {
+export class Vector2 {
     public x;
     public y;
 
@@ -45,5 +45,3 @@ class Vector2 {
         return new Vector2(vec1.x + vec2.x, vec1.y + vec2.y);
     }
 }
-
-export default Vector2;

package/src/engine/window.ts

@@ -1,5 +1,5 @@
 import { type Pointer } from "bun:ffi";
-import Vector2 from "./vector";
+import { Vector2 } from "./vector";
 import { libsdl } from "../ffi";
 
 class Window {

package/src/ffi.ts

@@ -12,6 +12,8 @@ if (process.platform == "win32") {
     libImageImport = await import("../libs/libSDL2_image.dll");
     //@ts-expect-error
     libTTFImport = await import("../libs/libSDL2_ttf.dll");
+    //@ts-expect-error
+    libMixerImport = await import("../libs/libSDL2_mixer.dll");
 } else if (process.platform == "darwin") {
     //@ts-expect-error
     libSDLImport = await import("../libs/libSDL2.dylib");
@@ -30,7 +32,6 @@ if (process.platform == "win32") {
     libTTFImport = await import("../libs/libSDL2_ttf.so");
     //@ts-expect-error
     libMixerImport = await import("../libs/libSDL2_mixer.so");
-
 }
 
 /** @internal */
@@ -206,10 +207,20 @@ export const libsdl = dlopen(libSDLImport.default, {
         args: ["pointer", "cstring"],
         returns: "void",
     },
-    SDL_LoadWAV_RW: {
-        args: ["cstring", "pointer", "pointer", "pointer"],
+    SDL_GetTicks: {
+        returns: "uint32_t",
+    },
+    SDL_Delay: {
+        args: ["uint32_t"],
+    },
+    SDL_GetKeyboardState: {
+        args: ["pointer"],
         returns: "pointer",
     },
+    SDL_GetScancodeFromName: {
+        args: ["cstring"],
+        returns: "int",
+    },
 });
 
 /** @internal */

package/src/modules/audio.ts

@@ -17,7 +17,7 @@ class Audio {
     }
 }
 
-class AudioSource {
+export class AudioSource {
     public readonly pointer;
 
     constructor(path: string) {

package/src/modules/graphics.ts

@@ -1,8 +1,9 @@
-import { libimage, libsdl, libttf } from "../ffi";
+import { libimage, libsdl } from "../ffi";
 import { type Pointer, ptr } from "bun:ffi";
-import Rectangle from "../engine/rectangle";
+import { Image } from "../engine/image";
+import { Rectangle } from "../engine/rectangle";
 import Color from "../color";
-import Vector2 from "../engine/vector";
+import { Vector2 } from "../engine/vector";
 import Renderer from "../engine/renderer";
 
 class Graphics {
@@ -109,7 +110,8 @@ class Graphics {
         image: Image,
         position: Vector2,
         rotation?: number,
-        scale?: Vector2
+        scale?: Vector2,
+        flipH?: boolean
     ) {
         // Define destination rect
         const dstRect = new Uint32Array(4);
@@ -126,30 +128,19 @@ class Graphics {
             ptr(dstRect),
             rotation ? rotation : 0,
             null,
-            null
+            flipH ? Number(flipH) : 0
         );
     }
-}
-
-class Image {
-    public readonly pointer: Pointer;
-    public readonly size: Vector2;
-
-    constructor(texture: Pointer) {
-        this.pointer = texture;
-
-        const _wArr = new Uint32Array(1);
-        const _hArr = new Uint32Array(1);
 
-        libsdl.symbols.SDL_QueryTexture(
-            texture,
-            null,
-            null,
-            ptr(_wArr),
-            ptr(_hArr)
+    public drawRect(rectangle: Rectangle, color: Color) {
+        libsdl.symbols.SDL_SetRenderDrawColor(
+            Renderer.pointer,
+            color.r,
+            color.g,
+            color.b,
+            color.a
         );
-
-        this.size = new Vector2(_wArr[0], _hArr[0]);
+        libsdl.symbols.SDL_RenderFillRect(Renderer.pointer, rectangle.pointer);
     }
 }
 

package/src/modules/keyboard.ts

@@ -1,12 +1,12 @@
 import { libsdl } from "../ffi";
+import { toArrayBuffer } from "bun:ffi";
 
 /** @internal */
 class Keyboard {
     static #instance: Keyboard;
 
-    static downKeyMap = new Map<string, boolean>();
-    static pressedKeyMap = new Map<string, boolean>();
-    static releasedKeyMap = new Map<string, boolean>();
+    static keyState: DataView;
+    static pressMap = new Map<string, number>();
 
     private constructor() {}
 
@@ -27,63 +27,49 @@ class Keyboard {
         return keyName;
     }
 
-    static setKeyDown(key: number): void {
-        const keyName = Keyboard.convertScancodeToKey(key);
-        this.downKeyMap.set(keyName.toLowerCase(), true);
-        this.releasedKeyMap.set(keyName.toLowerCase(), false);
-    }
-
-    static setKeyUp(key: number) {
-        const keyName = Keyboard.convertScancodeToKey(key);
-        this.downKeyMap.set(keyName.toLowerCase(), false);
-        this.pressedKeyMap.set(keyName.toLowerCase(), false);
-    }
-
-    /**
-     *
-     * @param key string of key
-     * @returns if the key is being held down
-     */
-    isDown(key: keys) {
-        const _state = Keyboard.downKeyMap.get(key);
-        if (_state == undefined) return false;
-
-        return _state;
+    static getStates() {
+        const state = libsdl.symbols.SDL_GetKeyboardState(null);
+        if (state == null) return;
+        const myArr = new DataView(toArrayBuffer(state, 0, 512));
+        
+        for (let i = 0; i < 512; ++i) {
+            if (myArr.getUint8(i) == 1) {
+                const keyName = this.convertScancodeToKey(i).toLowerCase();
+                const kmGet = this.pressMap.get(keyName);
+                if (kmGet == undefined || kmGet == 0) {
+                    this.pressMap.set(keyName, 1);
+                } else if (kmGet == 1) {
+                    this.pressMap.set(keyName, 2);
+                }
+            } else if (myArr.getUint8(i) == 0) {
+                const keyName = this.convertScancodeToKey(i).toLowerCase();
+                this.pressMap.set(keyName, 0);
+            }
+        }
     }
 
-    /**
-     *
-     * @param key string of key
-     * @returns if key is pressed. Returns only once
-     */
-    isPressed(key: keys) {
-        const _pressedState = Keyboard.pressedKeyMap.get(key);
-        const _downState = Keyboard.downKeyMap.get(key);
-
-        if (_downState == true) {
-            if (_pressedState == false || _pressedState == undefined) {
-                Keyboard.pressedKeyMap.set(key, true);
-                return true;
-            }
+    public isPressed(key: keys) {
+        /*
+        const scancode = libsdl.symbols.SDL_GetScancodeFromName(
+            Buffer.from(key + "\x00")
+        );
+        const thisval = Keyboard.keyState.getUint8(scancode);
+        */
+
+        const kmGet = Keyboard.pressMap.get(key);
+        if (kmGet == 1) {
+            return true;
         }
 
+
         return false;
     }
 
-    /**
-     *
-     * @param key string of key
-     * @returns if key is released. Returns only once
-     */
-    isReleased(key: keys) {
-        const _releasedState = Keyboard.releasedKeyMap.get(key);
-        const _downState = Keyboard.downKeyMap.get(key);
-
-        if (_downState == false) {
-            if (_releasedState == false || undefined) {
-                Keyboard.releasedKeyMap.set(key, true);
-                return true;
-            }
+
+    public isDown(key: keys) {
+        const kmGet = Keyboard.pressMap.get(key);
+        if (kmGet == 1 || kmGet == 2) {
+            return true;
         }
 
         return false;

package/src/modules/mouse.ts

@@ -1,6 +1,6 @@
 import { libsdl } from "../ffi";
 import { ptr } from "bun:ffi";
-import Vector2 from "../engine/vector";
+import {Vector2} from "../engine/vector";
 
 /** @internal */
 class Mouse {

package/src/slifer.ts

@@ -5,9 +5,9 @@ import Mouse from "./modules/mouse";
 import Audio from "./modules/audio";
 import Window from "./engine/window";
 import Renderer from "./engine/renderer";
-import Vector2 from "./engine/vector";
-import Time from "./engine/time";
-import { ptr } from "bun:ffi";
+import { Vector2 } from "./engine/vector";
+import { Timer } from "./engine/time";
+import { ptr, toArrayBuffer } from "bun:ffi";
 import { initLibraries } from "./engine";
 import { version } from "../package.json";
 
@@ -23,8 +23,13 @@ export class SliferClass {
     public dt: number = 0;
     public isRunning: boolean = true;
 
+    private fps = 60;
+    private ticksPerFrame = 1000 / this.fps;
+    private capTimer: Timer;
+
     constructor() {
         initLibraries();
+        this.capTimer = new Timer();
     }
 
     /**
@@ -40,9 +45,6 @@ export class SliferClass {
         // Create the renderer
         Renderer.createRenderer();
 
-        // Start delta time calculations
-        Time.instance.init();
-
         // Return the window object
         return window;
     }
@@ -51,11 +53,13 @@ export class SliferClass {
      * @returns if the window should close
      */
     shouldClose(): boolean {
+        this.capTimer.start();
+
         // Clear the renderer
         Renderer.clear();
 
         // Calculate delta time
-        this.dt = Time.instance.calcDelta();
+        // this.dt = Time.instance.calcDelta();
 
         // Poll Events
         const eventArray = new Uint16Array(32);
@@ -67,16 +71,6 @@ export class SliferClass {
                 case 256:
                     this.isRunning = false;
                     break;
-                // Keydown event
-                case 768:
-                    var scancode = eventArray[8];
-                    Keyboard.setKeyDown(scancode);
-                    break;
-                // Keyup event
-                case 769:
-                    var scancode = eventArray[8];
-                    Keyboard.setKeyUp(scancode);
-                    break;
                 // Mouse down event
                 case 1025:
                     const _dbtn = eventArray[8] - 256;
@@ -90,6 +84,13 @@ export class SliferClass {
             }
         }
 
+        Keyboard.getStates();
+
+        const frameTicks = this.capTimer.getTicks();
+        if (frameTicks < this.ticksPerFrame) {
+            libsdl.symbols.SDL_Delay(this.ticksPerFrame - frameTicks);
+        }
+
         return !this.isRunning;
     }