slifer 0.2.3 → 0.2.5

package/src/modules/graphics.ts

@@ -1,148 +1,78 @@
-import { libimage, libsdl } from "../ffi";
-import { type Pointer, ptr } from "bun:ffi";
-import { Image } from "../engine/image";
-import { Rectangle } from "../engine/rectangle";
-import Color from "../color";
-import { Vector2 } from "../engine/vector";
-import Renderer from "../engine/renderer";
+import Vector2 from "../engine/vector2";
+import { libsdl } from "../ffi";
+import { ptr } from 'bun:ffi';
 
-class Graphics {
-    static #instance: Graphics;
+import type Image from "../engine/image";
+import Render from "../engine/render";
+import type Color from "../engine/color";
+import type Rectangle from "../engine/rectangle";
 
-    static #fontPointer: Pointer;
-
-    public static get instance() {
-        if (!Graphics.#instance) {
-            Graphics.#instance = new Graphics();
-        }
-
-        return Graphics.#instance;
-    }
-    /**
-     * Slifers draw function. Used to draw everything to the screen.
-     */
-    public render() {
-        libsdl.symbols.SDL_RenderPresent(Renderer.pointer);
-    }
-
-    /**
-     * Create a new color. All values are from 0-255
-     *
-     * @param r red value
-     * @param g green value
-     * @param b blue value
-     * @param a alpha value
-     * @returns Color object
-     */
-    public makeColor(r: number, g: number, b: number, a: number) {
-        const _color = new Color(r, g, b, a);
-        return _color;
-    }
-
-    /**
-     * Sets the background of the window to a color of choice.
-     *
-     * Make sure this is put in the top level of the while loop
-     * as it will clear the renderer.
-     *
-     * @param color Color object. Make using Slifer.Graphics.makeColor
-     */
-    public setBackground(color: Color) {
-        libsdl.symbols.SDL_SetRenderDrawColor(
-            Renderer.pointer,
-            color.r,
-            color.g,
-            color.b,
-            color.a
-        );
-        libsdl.symbols.SDL_RenderClear(Renderer.pointer);
-    }
+/** @internal */
+export default class Graphics {
 
-    /**
-     * Loads a new image
-     *
-     * @param path string path to image
-     * @returns Image ready to draw
-     */
-    public loadImage(path: string): Image {
-        const _path = Buffer.from(path + "\x00");
-        const surface = libimage.symbols.IMG_Load(_path);
-        if (surface == null) throw `Image failed to load`;
-        const texture = libsdl.symbols.SDL_CreateTextureFromSurface(
-            Renderer.pointer,
-            surface
-        );
-        if (texture == null) throw `Image failed to be created`;
-        return new Image(texture);
+    render() : void {
+        libsdl.symbols.SDL_RenderPresent(Render.pointer);
     }
+    
+    draw(image: Image, position: Vector2) : void {
 
-    /**
-     * Method to draw to the screen simply
-     *
-     * @param image Image object to draw. Made using Slifer.Graphics.loadImage
-     * @param position position to draw the image
-     *
-     */
-    public draw(image: Image, position: Vector2) {
-        const dstRect = new Uint32Array(4);
-        dstRect[0] = position.x;
-        dstRect[1] = position.y;
-        dstRect[2] = image.size.x;
-        dstRect[3] = image.size.y;
-
+        (image as any).destArr[0] = position.x;
+        (image as any).destArr[1] = position.y;
+        
         libsdl.symbols.SDL_RenderCopy(
-            Renderer.pointer,
+            Render.pointer,
             (image as any).pointer,
             null,
-            dstRect
+            ptr((image as any).destArr)
         );
     }
 
-    /*
-     * Method to draw to the screen with extended arguments
-     *
-     * @param image Image object to draw. Made using Slifer.Graphics.loadImage
-     * @param position Position to draw the image.
-     * @param rotation Optional argument angle of rotation
-     * @param scale Optional What to multiply the width and height of image by
-     */
-    public drawEx(
-        image: Image,
-        position: Vector2,
-        rotation?: number,
-        scale?: Vector2,
-        flipH?: boolean
-    ) {
-        // Define destination rect
-        const dstRect = new Uint32Array(4);
-        dstRect[0] = position.x;
-        dstRect[1] = position.y;
-        dstRect[2] = image.size.x * (scale ? scale.x : 1);
-        dstRect[3] = image.size.y * (scale ? scale.y : 1);
+    drawEx(image: Image, position: Vector2, rotation?: number, scale?: Vector2, flipH?: boolean) {
+        
+        const destArr = (image as any).destArr;
+        destArr[0] = position.x;
+        destArr[1] = position.y;
+        destArr[2] = image.width * (scale ? scale.x : 1);
+        destArr[3] = image.height * (scale ? scale.y : 1);
 
-        // Draw to screen
         libsdl.symbols.SDL_RenderCopyEx(
-            Renderer.pointer,
-            image.pointer,
+            Render.pointer,
+            (image as any).pointer,
             null,
-            ptr(dstRect),
+            ptr(destArr),
             rotation ? rotation : 0,
             null,
-            flipH ? Number(flipH) : 0
+            Number(flipH)
         );
+
+
+    }
+
+    setBackground(color: Color) : void {
+        libsdl.symbols.SDL_SetRenderDrawColor(Render.pointer,
+            color.r,
+            color.g,
+            color.b,
+            color.a
+        );
+        libsdl.symbols.SDL_RenderClear(Render.pointer);
     }
 
     public drawRect(rectangle: Rectangle, color: Color) {
         libsdl.symbols.SDL_SetRenderDrawColor(
-            Renderer.pointer,
+            Render.pointer,
             color.r,
             color.g,
             color.b,
             color.a
         );
-        libsdl.symbols.SDL_RenderFillRect(Renderer.pointer, rectangle.pointer);
-    }
-}
 
-/** @internal */
-export default Graphics;
+        const rect = new Uint32Array(4);
+        rect[0] = rectangle.position.x;
+        rect[1] = rectangle.position.y;
+        rect[2] = rectangle.size.x;
+        rect[3] = rectangle.size.y;
+
+        libsdl.symbols.SDL_RenderFillRect(Render.pointer, ptr(rect));
+    }
+}

package/src/modules/keyboard.ts

@@ -1,77 +1,50 @@
 import { libsdl } from "../ffi";
 import { toArrayBuffer } from "bun:ffi";
-
 /** @internal */
-class Keyboard {
-    static #instance: Keyboard;
-
-    static keyState: DataView;
-    static pressMap = new Map<string, number>();
-
-    private constructor() {}
-
-    public static get instance() {
-        if (!Keyboard.#instance) {
-            Keyboard.#instance = new Keyboard();
-        }
+export default class Keyboard {
 
-        return Keyboard.#instance;
-    }
+    public static keyMap = new Map<string, number>();
 
     private static convertScancodeToKey(scancode: number): string {
         const keyFromScancode = libsdl.symbols.SDL_GetKeyFromScancode(scancode);
         const keyName = libsdl.symbols
             .SDL_GetKeyName(keyFromScancode)
-            .toString();
+            .toString()
+            .toLocaleLowerCase();
 
         return keyName;
     }
 
-    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);
+    public static handleStates() {
+        const keyState = libsdl.symbols.SDL_GetKeyboardState(null);
+        if (keyState == null) throw `Keyboard state returned null.`;
+        const keyDV = new DataView(toArrayBuffer(keyState, 0, 512));
+        for (let kn = 0; kn < 512; kn++) {
+            if (keyDV.getUint8(kn) == 1) {
+                const keyName = this.convertScancodeToKey(kn);
+                const kmGet = this.keyMap.get(keyName);
+
                 if (kmGet == undefined || kmGet == 0) {
-                    this.pressMap.set(keyName, 1);
+                    this.keyMap.set(keyName, 1);
                 } else if (kmGet == 1) {
-                    this.pressMap.set(keyName, 2);
+                    this.keyMap.set(keyName, 2);
                 }
-            } else if (myArr.getUint8(i) == 0) {
-                const keyName = this.convertScancodeToKey(i).toLowerCase();
-                this.pressMap.set(keyName, 0);
+            } else if (keyDV.getUint8(kn) == 0) {
+                const keyName = this.convertScancodeToKey(kn);
+                this.keyMap.set(keyName, 0);
             }
         }
     }
 
-    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;
-        }
-
-
+    public isPressed(key: keys) : boolean {
+        const kmGet = Keyboard.keyMap.get(key);
+        if (kmGet == 1) return true;
         return false;
     }
 
-
-    public isDown(key: keys) {
-        const kmGet = Keyboard.pressMap.get(key);
-        if (kmGet == 1 || kmGet == 2) {
-            return true;
-        }
-
+    public isDown(key: keys) : boolean {
+        const kmGet = Keyboard.keyMap.get(key);
+        if (kmGet == 1 || kmGet == 2) return true;
         return false;
     }
 }
@@ -120,6 +93,3 @@ type keys =
     | "right shift"
     | "left ctrl"
     | "escape";
-
-/** @internal */
-export default Keyboard;

package/src/modules/mouse.ts

@@ -1,106 +1,62 @@
 import { libsdl } from "../ffi";
 import { ptr } from "bun:ffi";
-import {Vector2} from "../engine/vector";
+import Vector2 from "../engine/vector2";
 
 /** @internal */
 class Mouse {
-    static #instance: Mouse;
 
-    static downKeyMap = new Map<string, boolean>();
-    static pressedKeyMap = new Map<string, boolean>();
-    static releasedKeyMap = new Map<string, boolean>();
+    private static x : number;
+    private static y : number;
 
-    private constructor() {}
-
-    public static get instance() {
-        if (!Mouse.#instance) Mouse.#instance = new Mouse();
-
-        return Mouse.#instance;
+    private static buttonMap = new Map<number, number>();
+    
+    static onRelease(button: number) {
+        this.buttonMap.set(button, 0);
     }
 
-    static setButtonDown(button: number) {
-        let key: string = "";
-        if (button == 1) {
-            key = "left";
-        } else if (button == 2) {
-            key = "middle";
-        } else {
-            key = "right";
-        }
-
-        this.downKeyMap.set(key, true);
-        this.releasedKeyMap.set(key, false);
-    }
+    static handleState() {
+        const down = libsdl.symbols.SDL_GetMouseState();
+        const bmGet = this.buttonMap.get(down);
 
-    static setButtonUp(button: number) {
-        let key: string = "";
-        if (button == 1) {
-            key = "left";
-        } else if (button == 2) {
-            key = "middle";
-        } else {
-            key = "right";
+        if (bmGet == undefined || bmGet == 0) {
+            this.buttonMap.set(down, 1);
+        } else if (bmGet == 1) {
+            this.buttonMap.set(down, 2);
         }
-
-        this.downKeyMap.set(key, false);
-        this.pressedKeyMap.set(key, false);
     }
 
-    /**
-     *
-     * @param button string of button
-     * @returns if the button is being held down
-     */
-    isDown(button: buttons) {
-        const _state = Mouse.downKeyMap.get(button);
-        if (_state == undefined) return false;
-
-        return _state;
+    private static getPressMap(button: number) {
+        const bmGet = this.buttonMap.get(button);
+        if (bmGet == 1) return true;
+        return false;
     }
 
-    /**
-     *
-     * @param button string of button
-     * @returns if button is pressed. Returns only once
-     */
-    isPressed(button: buttons) {
-        const _pressedState = Mouse.pressedKeyMap.get(button);
-        const _downState = Mouse.downKeyMap.get(button);
-
-        if (_downState == true) {
-            if (_pressedState == false || _pressedState == undefined) {
-                Mouse.pressedKeyMap.set(button, true);
-                return true;
-            }
-        }
-
+    private static getDownMap(button: number) {
+        const bmGet = this.buttonMap.get(button);
+        if (bmGet == 1 || bmGet == 2) return true;
         return false;
     }
 
-    /**
-     *
-     * @param button string of button
-     * @returns if button is released. Returns only once
-     */
-    isReleased(button: buttons) {
-        const _releasedState = Mouse.releasedKeyMap.get(button);
-        const _downState = Mouse.downKeyMap.get(button);
-
-        if (_downState == false) {
-            if (_releasedState == false || undefined) {
-                Mouse.releasedKeyMap.set(button, true);
-                return true;
-            }
+    isPressed(button: buttons) : boolean {
+        switch (button) {
+            case 'left':
+                return Mouse.getPressMap(1);
+            case 'middle':
+                return Mouse.getPressMap(2);
+            case 'right':
+                return Mouse.getPressMap(3);
         }
-
-        return false;
     }
 
-    getPosition() {
-        const xArr = new Uint32Array(1);
-        const yArr = new Uint32Array(1);
-        libsdl.symbols.SDL_GetMouseState(ptr(xArr), ptr(yArr));
-        return new Vector2(xArr[0], yArr[0]);
+    isDown(button: buttons) : boolean {
+        switch (button) {
+            case 'left':
+                return Mouse.getDownMap(1);
+            case 'middle':
+                return Mouse.getDownMap(2);
+            case 'right':
+                return Mouse.getDownMap(3);
+        }
     }
 }
 

package/src/slifer.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "bun:test";
 import { initSDL, initSDLImage, initSDLTypeFont, initSDLMixer } from "./engine";
-import Vector2 from "./engine/vector";
+import Vector2 from "./engine/vector2";
+import Render from "./engine/render";
 import Window from "./engine/window";
-import Renderer from "./engine/renderer";
 
 describe("Initializing SDL ", () => {
     it("Should initialize without error ", () => {
@@ -38,6 +38,6 @@ describe("Window Creation ", () => {
 
 describe("Renderer Creation ", () => {
     it("Should create renderer without error", () => {
-        expect(() => Renderer.createRenderer()).not.toThrow(Error);
+        expect(() => Render.createRenderer()).not.toThrow(Error);
     });
 });

package/src/slifer.ts

@@ -1,109 +1,65 @@
 import { libsdl } from "./ffi";
-import Graphics from "./modules/graphics";
-import Keyboard from "./modules/keyboard";
-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 { Timer } from "./engine/time";
-import { ptr, toArrayBuffer } from "bun:ffi";
+import Renderer from "./engine/render";
+import { ptr } from "bun:ffi";
 import { initLibraries } from "./engine";
 import { version } from "../package.json";
+import type Vector2 from "./engine/vector2";
+import Graphics from "./modules/graphics";
+import Keyboard from "./modules/keyboard";
+import Mouse from "./modules/mouse";
+import Render from "./engine/render";
 
-/** @interal */
-export class SliferClass {
-    // Modules
-    Graphics = Graphics.instance;
-    Keyboard = Keyboard.instance;
-    Mouse = Mouse.instance;
-    Audio = Audio.instance;
-
-    // Public Variables
-    public dt: number = 0;
-    public isRunning: boolean = true;
+class Slifer {
+    
+    public isRunning: boolean;
 
-    private fps = 60;
-    private ticksPerFrame = 1000 / this.fps;
-    private capTimer: Timer;
+    // Modules
+    public Graphics = new Graphics();
+    public Keyboard = new Keyboard();
+    public Mouse = new Mouse();
 
     constructor() {
         initLibraries();
-        this.capTimer = new Timer();
+        this.isRunning = true;
     }
 
-    /**
-     * @param title Title of window
-     * @param width Width of window
-     * @param height Height of window
-     */
-    createWindow(title: string, size: Vector2): Window {
-        // Create the window
-        const window = Window.instance;
+    public createWindow(title: string, size: Vector2) : Window {
         Window.createWindow(title, size);
-
-        // Create the renderer
         Renderer.createRenderer();
 
-        // Return the window object
-        return window;
+        return new Window();
     }
 
-    /**
-     * @returns if the window should close
-     */
-    shouldClose(): boolean {
-        this.capTimer.start();
+    public shouldClose() : boolean {
 
-        // Clear the renderer
-        Renderer.clear();
+        libsdl.symbols.SDL_RenderClear(Render.pointer);
 
-        // Calculate delta time
-        // this.dt = Time.instance.calcDelta();
-
-        // Poll Events
         const eventArray = new Uint16Array(32);
-        const isEvent = libsdl.symbols.SDL_PollEvent(ptr(eventArray));
-
-        if (isEvent) {
+        const event = libsdl.symbols.SDL_PollEvent(ptr(eventArray));
+        if (event) {
             switch (eventArray[0]) {
-                // Quit event
                 case 256:
                     this.isRunning = false;
                     break;
-                // Mouse down event
-                case 1025:
-                    const _dbtn = eventArray[8] - 256;
-                    Mouse.setButtonDown(_dbtn);
-                    break;
-                // Mouse up event
                 case 1026:
-                    const _ubtn = eventArray[8];
-                    Mouse.setButtonUp(_ubtn);
+                    Mouse.onRelease(eventArray[8]);
                     break;
             }
         }
 
-        Keyboard.getStates();
-
-        const frameTicks = this.capTimer.getTicks();
-        if (frameTicks < this.ticksPerFrame) {
-            libsdl.symbols.SDL_Delay(this.ticksPerFrame - frameTicks);
-        }
+        Keyboard.handleStates();
 
+        Mouse.handleState();
+        
+        
         return !this.isRunning;
     }
 
-    /**
-     * Slifers quit method
-     */
-    quit() {
-        libsdl.symbols.SDL_DestroyRenderer(Renderer.pointer);
-        libsdl.symbols.SDL_DestroyWindow(Window.pointer);
-        libsdl.symbols.SDL_Quit();
-    }
-
-    getVersion() {
-        return version;
+    public getVersion() : string {
+        return 'v' + version;
     }
 }
+
+
+export default Slifer;