slifer 0.2.4 → 0.2.6

package/.npmignore

@@ -135,3 +135,4 @@ test.ts
 char.png
 
 .wakatime-project
+libs/

package/index.ts

@@ -1,10 +1,8 @@
-import { SliferClass } from "./src/slifer";
+import Slifer from "./src/slifer";
+import Image from "./src/engine/image";
+import Vector2 from "./src/engine/vector2";
+import Color from "./src/engine/color";
+import Audio from "./src/engine/audio";
 
-export type { ImageType as Image } from "./src/modules/graphics";
-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;
+const slf = new Slifer();
+export { Vector2, Color, Image, Audio, slf as Slifer };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "slifer",
-    "version": "0.2.4",
+    "version": "0.2.6",
     "description": "A game framework made for bun and typescript",
     "module": "index.ts",
     "devDependencies": {
@@ -9,5 +9,9 @@
     "peerDependencies": {
         "typescript": "^5.0.0"
     },
-    "type": "module"
+    "type": "module",
+    "scripts": {
+        "postinstall": "bun run src/download.ts"
+    },
+    "exports": "./index.ts"
 }

package/src/download.ts

@@ -0,0 +1,23 @@
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const libDir = path.join(__dirname, '../libs/');
+
+async function downloadLibrary(url: string, filename: string) {
+    const response = await fetch(url);
+    await Bun.write(libDir + filename, response);
+    
+    
+}
+
+if (process.platform == "darwin") {
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2.dylib", "libSDL2.dylib");
+    
+    
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_image.dylib", "libSDL2_image.dylib");
+    
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_mixer.dylib", "libSDL2_mixer.dylib");
+    
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_ttf.dylib", "libSDL2_ttf.dylib");
+}

package/src/{modules → engine}/audio.ts

@@ -1,27 +1,12 @@
-import { ptr } from "bun:ffi";
 import { libmixer } from "../ffi";
 
-class Audio {
-    static #instance: Audio;
-
-    private constructor() {}
-
-    public static get instance() {
-        if (!Audio.#instance) Audio.#instance = new Audio();
-
-        return Audio.#instance;
-    }
-
-    public loadAudio(path: string): AudioSource {
-        return new AudioSource(path);
-    }
-}
-
-export class AudioSource {
-    public readonly pointer;
+/** @internal */
+export default class Audio {
+    private readonly pointer;
 
     constructor(path: string) {
         const audiomix = libmixer.symbols.Mix_LoadWAV(
+            //@ts-expect-error Buffer error
             Buffer.from(path + "\x00")
         );
 
@@ -36,6 +21,4 @@ export class AudioSource {
     public destroy() {
         libmixer.symbols.Mix_FreeChunk(this.pointer);
     }
-}
-
-export default Audio;
+}

package/src/{color.ts → engine/color.ts}

@@ -1,4 +1,5 @@
-class Color {
+/** @internal */
+export default class Color {
     readonly r;
     readonly g;
     readonly b;
@@ -11,5 +12,3 @@ class Color {
         this.a = a;
     }
 }
-
-export default Color;

package/src/engine/image.ts

@@ -0,0 +1,34 @@
+import { libimage, libsdl } from "../ffi";
+import { type Pointer, ptr } from 'bun:ffi';
+import Render from "./render";
+
+/** @internal */
+export default class Image {
+
+    private pointer:  Pointer;
+    private destArr: Uint32Array;
+
+    public readonly width;
+    public readonly height;
+
+    constructor(path: string) {
+        const cs = Buffer.from(path+'\x00');
+        //@ts-expect-error Buffer error;
+        const texture = libimage.symbols.IMG_LoadTexture(Render.pointer, cs);
+        if (texture == null) throw `Texture creation failed.`;
+        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.width = wArr[0];
+        this.height = hArr[0];
+
+        this.destArr = new Uint32Array(4);
+        this.destArr[0] = 0;
+        this.destArr[1] = 0;
+        this.destArr[2] = this.width;
+        this.destArr[3] = this.height;
+    }
+}

package/src/engine/rectangle.ts

@@ -1,26 +1,17 @@
-import { ptr } from "bun:ffi";
-import { Vector2 } from "./vector";
+import type Vector2 from "./vector2";
+import { ptr, type Pointer } from 'bun:ffi';
 
-export class Rectangle {
-    public readonly pointer;
-    public position: Vector2;
-    public size: Vector2;
+/** @internal */
+export default class Rectangle {
+    
+    public readonly position;
+    public readonly size;
 
     constructor(position: Vector2, size: Vector2) {
-        const arr = new Uint32Array(4);
-        arr[0] = position.x;
-        arr[1] = position.y;
-        arr[2] = size.x;
-        arr[3] = size.y;
-        this.pointer = ptr(arr);
         this.position = position;
         this.size = size;
     }
 
-    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 &&
@@ -33,5 +24,4 @@ export class Rectangle {
 
     	return false;
     }
-}
-
+}

package/src/engine/render.ts

@@ -0,0 +1,15 @@
+import { type Pointer } from 'bun:ffi';
+import { libsdl } from "../ffi";
+import Window from "./window";
+
+/** @internal */
+export default class Render {
+
+    public static pointer : Pointer;
+
+    public static createRenderer() {
+        const renPointer = libsdl.symbols.SDL_CreateRenderer(Window.pointer, -1, 0);
+        if (renPointer == null) throw `Renderer creation failed.`;
+        this.pointer = renPointer;
+    }
+}

package/src/engine/vector2.ts

@@ -0,0 +1,10 @@
+/** @internal */
+export default class Vector2 {
+    public x;
+    public y;
+
+    constructor(x: number, y: number) {
+        this.x = x;
+        this.y = y;
+    }
+}   

package/src/engine/window.ts

@@ -1,60 +1,32 @@
-import { type Pointer } from "bun:ffi";
-import { Vector2 } from "./vector";
-import { libsdl } from "../ffi";
-
-class Window {
-    static #instance: Window;
-    static #pointer: Pointer;
-
-    private title!: string;
-    private size!: Vector2;
-
-    private static readonly centerPos = 0x2fff0000;
-
-    private constructor() {}
-
-    public static get instance() {
-        if (!Window.#instance) {
-            Window.#instance = new Window();
-        }
-
-        return Window.#instance;
-    }
-
-    public static get pointer() {
-        return Window.#pointer;
-    }
-
-    public static createWindow(title: string, size: Vector2): void {
-        Window.instance.title = title;
-        Window.instance.size = size;
-
-        // Create cstring by buffer from string
-        const _titleBuffer = new Buffer(Window.instance.title + "\x00");
-
-        // Create window pointer
-        const _winPointer = libsdl.symbols.SDL_CreateWindow(
-            _titleBuffer,
-            Window.centerPos,
-            Window.centerPos,
-            Window.instance.size.x,
-            Window.instance.size.y,
+import { type Pointer } from 'bun:ffi';
+import Vector2 from './vector2';
+import { libsdl } from '../ffi';
+
+/** @internal */
+export default class Window {
+    public static pointer: Pointer;
+
+    private static centerPos = 0x2fff0000;
+
+    public static createWindow(title: string, size: Vector2) : void {
+        const winPointer = libsdl.symbols.SDL_CreateWindow(
+            //@ts-expect-error Buffer error
+            Buffer.from(title + '\x00'),
+            this.centerPos,
+            this.centerPos,
+            size.x,
+            size.y,
             0
-        );
-
-        if (_winPointer == null) throw `Window Creation Failed`;
-        Window.#pointer = _winPointer;
-    }
+        )
 
-    public setSize(size: Vector2): void {
-        this.size = size;
-        libsdl.symbols.SDL_SetWindowSize(Window.pointer, size.x, size.y);
+        if (winPointer == null) throw `Window creation failed.`;
+        this.pointer = winPointer;
     }
 
     public setTitle(title: string): void {
-        this.title = title;
         libsdl.symbols.SDL_SetWindowTitle(
             Window.pointer,
+            //@ts-expect-error Buffer error
             Buffer.from(title + "\x00")
         );
     }
@@ -74,6 +46,4 @@ class Window {
     public centerWindow() {
         this.setPosition(new Vector2(Window.centerPos, Window.centerPos));
     }
-}
-
-export default Window;
+}

package/src/engine.ts

@@ -1,5 +1,4 @@
 import { libsdl, libimage, libttf, libmixer } from "./ffi";
-import Graphics from "./modules/graphics";
 
 export function initSDL() {
     const initVideo = 0x00000020;

package/src/ffi.ts

@@ -220,7 +220,7 @@ export const libsdl = dlopen(libSDLImport.default, {
     SDL_GetScancodeFromName: {
         args: ["cstring"],
         returns: "int",
-    },
+    }
 });
 
 /** @internal */
@@ -233,6 +233,10 @@ export const libimage = dlopen(libImageImport.default, {
         args: ["cstring"],
         returns: "pointer",
     },
+    IMG_LoadTexture: {
+        args: ['pointer', 'cstring'],
+        returns: 'pointer'
+    }
 });
 
 /** @internal */

package/src/modules/graphics.ts

@@ -1,173 +1,78 @@
-import { libimage, libsdl } from "../ffi";
-import { type Pointer, ptr } from "bun:ffi";
-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");
-        //@ts-expect-error
-        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)
         );
+
+
     }
 
-    public drawRect(rectangle: Rectangle, color: Color) {
-        libsdl.symbols.SDL_SetRenderDrawColor(
-            Renderer.pointer,
+    setBackground(color: Color) : void {
+        libsdl.symbols.SDL_SetRenderDrawColor(Render.pointer,
             color.r,
             color.g,
             color.b,
             color.a
         );
-        libsdl.symbols.SDL_RenderFillRect(Renderer.pointer, rectangle.pointer);
+        libsdl.symbols.SDL_RenderClear(Render.pointer);
     }
-}
-
-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)
+    public drawRect(rectangle: Rectangle, color: Color) {
+        libsdl.symbols.SDL_SetRenderDrawColor(
+            Render.pointer,
+            color.r,
+            color.g,
+            color.b,
+            color.a
         );
 
-        this.size = new Vector2(_wArr[0], _hArr[0]);
-    }
-}
-
-export type ImageType = Image;
+        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;
 
-/** @internal */
-export default Graphics;
+        libsdl.symbols.SDL_RenderFillRect(Render.pointer, ptr(rect));
+    }
+}

package/src/modules/keyboard.ts

@@ -2,76 +2,50 @@ import { libsdl } from "../ffi";
 import { toArrayBuffer } from "bun:ffi";
 
 /** @internal */
-class Keyboard {
-    static #instance: Keyboard;
+export default class Keyboard {
 
-    static keyState: DataView;
-    static pressMap = new Map<string, number>();
-
-    private constructor() {}
-
-    public static get instance() {
-        if (!Keyboard.#instance) {
-            Keyboard.#instance = new 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 +94,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,116 +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 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();
-
-        // Clear the renderer
-        Renderer.clear();
+    public shouldClose() : boolean {
 
+        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();
+    public getVersion() : string {
+        return 'v' + version;
     }
+}
 
-    getVersion() {
-        return version;
-    }
 
-    setFps(fps: number) {
-        this.fps = fps;
-        this.ticksPerFrame = 1000 / fps;
-    }
-}
+export default Slifer;

package/src/engine/renderer.ts

@@ -1,40 +0,0 @@
-import { type Pointer } from "bun:ffi";
-import { libsdl } from "../ffi";
-import Window from "./window";
-
-class Renderer {
-    static #instance: Renderer;
-    static #pointer: Pointer;
-
-    private constructor() {}
-
-    public static get instance() {
-        if (!Renderer.#instance) {
-            Renderer.#instance = new Renderer();
-        }
-
-        return Renderer.#instance;
-    }
-
-    public static get pointer() {
-        return Renderer.#pointer;
-    }
-
-    static createRenderer() {
-        const vsyncHint = 0x00000004;
-        const _ren = libsdl.symbols.SDL_CreateRenderer(
-            Window.pointer,
-            -1,
-            0
-        );
-
-        if (_ren == null) throw `Renderer Creation Failed`;
-        Renderer.#pointer = _ren;
-    }
-
-    static clear() {
-        libsdl.symbols.SDL_RenderClear(Renderer.pointer);
-    }
-}
-
-export default Renderer;

package/src/engine/time.ts

@@ -1,79 +0,0 @@
-import { libsdl } from "../ffi";
-
-export class Timer {
-
-	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;
-
-   		this.mPaused = false;
-
-   		this.mStartTicks = libsdl.symbols.SDL_GetTicks();
-		this.mPausedTicks = 0;
-   	}
-
-   	public stop() {
-   		this.mStarted = false;
-   		this.mPaused = true;
-
-   		this.mStartTicks = 0;
-   		this.mPausedTicks = 0;
-   	}
-
-   	public pause() {
-		if (this.mStarted && !this.mPaused) {
-			this.mPaused = true;
-
-			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);
-   	}
-
-   	
-
-    
-}
-

package/src/engine/vector.ts

@@ -1,47 +0,0 @@
-export class Vector2 {
-    public x;
-    public y;
-
-    constructor(x: number, y: number) {
-        this.x = x;
-        this.y = y;
-    }
-
-    /**
-     * Creates a Vector2 with the components 1,1
-     */
-    static one() {
-        return new Vector2(1, 1);
-    }
-
-    /**
-     * Creates a Vector2 with the components 1,0
-     */
-    static unitX() {
-        return new Vector2(1, 0);
-    }
-
-    /**
-     * Creates a Vector2 with the components 0,1
-     */
-    static unitY() {
-        return new Vector2(0, 1);
-    }
-
-    /**
-     * Creates a vector2 with component 0,0
-     */
-    static zero() {
-        return new Vector2(0, 0);
-    }
-
-    /**
-     * Adds two vectors together
-     *
-     * @param vec1 Vector2 object
-     * @param vec2 Vector2 object
-     */
-    static add(vec1: Vector2, vec2: Vector2) {
-        return new Vector2(vec1.x + vec2.x, vec1.y + vec2.y);
-    }
-}