slifer 0.2.6 → 0.2.7

package/index.ts

@@ -3,6 +3,8 @@ import Image from "./src/engine/image";
 import Vector2 from "./src/engine/vector2";
 import Color from "./src/engine/color";
 import Audio from "./src/engine/audio";
+import Rectangle from "./src/engine/rectangle";
+import Font from "./src/engine/font";
 
 const slf = new Slifer();
-export { Vector2, Color, Image, Audio, slf as Slifer };
+export { Vector2, Color, Image, Audio, Rectangle, Font, slf as Slifer };

package/package.json

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

package/src/download.ts

@@ -1,5 +1,3 @@
-import * as https from 'https';
-import * as fs from 'fs';
 import * as path from 'path';
 
 const libDir = path.join(__dirname, '../libs/');
@@ -13,11 +11,17 @@ async function downloadLibrary(url: string, filename: string) {
 
 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");
+} else if (process.platform == "win32") {
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/SDL2.dll", "SDL2.dll");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/SDL2_image.dll", "SDL2_image.dll");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/SDL2_mixer.dll", "SDL2_mixer.dll");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/SDL2_ttf.dll", "SDL2_ttf.dll");
+} else if (process.platform == "linux") {
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2.so", "libSDL2.so");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_image.so", "libSDL2_image.so");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_mixer.so", "libSDL2_mixer.so");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_ttf.so", "libSDL2_ttf.so");
 }

package/src/engine/font.ts

@@ -0,0 +1,16 @@
+import { type Pointer } from 'bun:ffi';
+import { libttf } from '../ffi';
+
+export default class Font {
+	private pointer : Pointer;
+
+	constructor(path: string, size: number) {
+		const fp = libttf.symbols.TTF_OpenFont(Buffer.from(path+"\x00"), size);
+		if (fp == null) throw `Font failed to be opened`;
+		this.pointer = fp;
+	}
+
+	public destroy() {
+		libttf.symbols.TTF_CloseFont(this.pointer);
+	}
+}

package/src/engine/rectangle.ts

@@ -1,4 +1,4 @@
-import type Vector2 from "./vector2";
+import Vector2 from "./vector2";
 import { ptr, type Pointer } from 'bun:ffi';
 
 /** @internal */
@@ -12,6 +12,10 @@ export default class Rectangle {
         this.size = size;
     }
 
+	static empty() : Rectangle {
+		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 &&

package/src/engine/vector2.ts

@@ -7,4 +7,20 @@ export default class Vector2 {
         this.x = x;
         this.y = y;
     }
+
+    static one() : Vector2 {
+        return new Vector2(1, 1);
+    }
+
+    static unitX() : Vector2 {
+        return new Vector2(1, 0);
+    }
+
+    static unitY() : Vector2 {
+        return new Vector2(0, 1);
+    }
+
+    static zero() : Vector2 {
+        return new Vector2(0, 0);
+    }
 }   

package/src/ffi.ts

@@ -1,19 +1,22 @@
 import { dlopen, FFIType, suffix } from "bun:ffi";
+import * as path from "path";
 
 let libSDLImport;
 let libImageImport;
 let libTTFImport;
 let libMixerImport;
 
+const libDir = path.join(__dirname, "../libs/");
+
 if (process.platform == "win32") {
     //@ts-expect-error
-    libSDLImport = await import("../libs/libSDL2.dll");
+    libSDLImport = await import("../libs/SDL2.dll");
     //@ts-expect-error
-    libImageImport = await import("../libs/libSDL2_image.dll");
+    libImageImport = await import("../libs/SDL2_image.dll");
     //@ts-expect-error
-    libTTFImport = await import("../libs/libSDL2_ttf.dll");
+    libTTFImport = await import("../libs/SDL2_ttf.dll");
     //@ts-expect-error
-    libMixerImport = await import("../libs/libSDL2_mixer.dll");
+    libMixerImport = await import("../libs/SDL2_mixer.dll");
 } else if (process.platform == "darwin") {
     //@ts-expect-error
     libSDLImport = await import("../libs/libSDL2.dylib");
@@ -24,14 +27,10 @@ if (process.platform == "win32") {
     //@ts-expect-error
     libMixerImport = await import("../libs/libSDL2_mixer.dylib");
 } else if (process.platform == "linux") {
-    //@ts-expect-error
-    libSDLImport = await import("../libs/libSDL2.so");
-    //@ts-expect-error
-    libImageImport = await import("../libs/libSDL2_image.so");
-    //@ts-expect-error
-    libTTFImport = await import("../libs/libSDL2_ttf.so");
-    //@ts-expect-error
-    libMixerImport = await import("../libs/libSDL2_mixer.so");
+    libSDLImport = await import(`${libDir}libSDL2.so`);
+    libImageImport = await import(`${libDir}libSDL2_image.so`);
+    libTTFImport = await import(`${libDir}libSDL2_ttf.so`);
+    libMixerImport = await import(`${libDir}libSDL2_mixer.so`);
 }
 
 /** @internal */
@@ -220,6 +219,9 @@ export const libsdl = dlopen(libSDLImport.default, {
     SDL_GetScancodeFromName: {
         args: ["cstring"],
         returns: "int",
+    },
+    SDL_GetTicks64: {
+    	returns: 'u64'
     }
 });
 
@@ -234,9 +236,9 @@ export const libimage = dlopen(libImageImport.default, {
         returns: "pointer",
     },
     IMG_LoadTexture: {
-        args: ['pointer', 'cstring'],
-        returns: 'pointer'
-    }
+        args: ["pointer", "cstring"],
+        returns: "pointer",
+    },
 });
 
 /** @internal */

package/src/modules/graphics.ts

@@ -1,7 +1,7 @@
 import Vector2 from "../engine/vector2";
-import { libsdl } from "../ffi";
+import { libsdl, libttf } from "../ffi";
 import { ptr } from 'bun:ffi';
-
+import Font from '../engine/font';
 import type Image from "../engine/image";
 import Render from "../engine/render";
 import type Color from "../engine/color";
@@ -10,14 +10,14 @@ import type Rectangle from "../engine/rectangle";
 /** @internal */
 export default class Graphics {
 
-    render() : void {
+    public render() : void {
         libsdl.symbols.SDL_RenderPresent(Render.pointer);
     }
     
-    draw(image: Image, position: Vector2) : void {
+    public draw(image: Image, x: number, y: number) : void {
 
-        (image as any).destArr[0] = position.x;
-        (image as any).destArr[1] = position.y;
+        (image as any).destArr[0] = x;
+        (image as any).destArr[1] = y;
         
         libsdl.symbols.SDL_RenderCopy(
             Render.pointer,
@@ -27,13 +27,13 @@ export default class Graphics {
         );
     }
 
-    drawEx(image: Image, position: Vector2, rotation?: number, scale?: Vector2, flipH?: boolean) {
+    public drawEx(image: Image, x: number, y: number, rotation?: number, scaleX?: number, scaleY?: number, 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);
+        destArr[0] = x;
+        destArr[1] = y;
+        destArr[2] = image.width * (scaleX ? scaleX : 1)
+        destArr[3] = image.height * (scaleY ? scaleY : 1);
 
         libsdl.symbols.SDL_RenderCopyEx(
             Render.pointer,
@@ -48,7 +48,7 @@ export default class Graphics {
 
     }
 
-    setBackground(color: Color) : void {
+    public setBackground(color: Color) : void {
         libsdl.symbols.SDL_SetRenderDrawColor(Render.pointer,
             color.r,
             color.g,
@@ -69,10 +69,53 @@ export default class Graphics {
 
         const rect = new Uint32Array(4);
         rect[0] = rectangle.position.x;
-        rect[1] = rectangle.position.y;
+    		rect[1] = rectangle.position.y;
         rect[2] = rectangle.size.x;
         rect[3] = rectangle.size.y;
 
         libsdl.symbols.SDL_RenderFillRect(Render.pointer, ptr(rect));
     }
-}
+
+    public print(text: string, x: number, y: number, font: Font, color: Color) {
+    	const wArr = new Uint32Array(1);
+    	const hArr = new Uint32Array(1);
+
+    	libttf.symbols.TTF_SizeText(
+	    	(font as any).pointer,
+	    	Buffer.from(text+"\x00"),
+	    	ptr(wArr),
+	    	ptr(hArr)
+    	);
+
+    	const _col = ((color.r << 0) + (color.g << 8) + (color.b << 16));
+
+    	const surface = libttf.symbols.TTF_RenderText_Solid(
+    		(font as any).pointer,
+    		Buffer.from(text+'\x00'),
+    		_col
+    	);
+    	if (surface == null) throw `Rendering text failed`;
+
+    	const texture = libsdl.symbols.SDL_CreateTextureFromSurface(
+    		Render.pointer,
+    		surface
+    	);
+			if (texture == null) throw `Texture Creation failed`;
+
+
+			const destRect = new Uint32Array(4);
+			destRect[0] = x;
+			destRect[1] = y;
+			destRect[2] = wArr[0];
+			destRect[3] = hArr[0];
+			libsdl.symbols.SDL_RenderCopy(
+				Render.pointer,
+				texture,
+				null,
+				ptr(destRect)
+			);
+    	
+
+    	
+    }
+}

package/src/modules/mouse.ts

@@ -4,18 +4,24 @@ import Vector2 from "../engine/vector2";
 
 /** @internal */
 class Mouse {
-
-    private static x : number;
-    private static y : number;
+    private static x: number;
+    private static y: number;
 
     private static buttonMap = new Map<number, number>();
-    
+
     static onRelease(button: number) {
         this.buttonMap.set(button, 0);
     }
 
+    static onMove(x: number, y: number) {
+        this.x = x;
+        this.y = y;
+    }
+
     static handleState() {
-        const down = libsdl.symbols.SDL_GetMouseState();
+        const xArr = new Uint32Array(1);
+        const yArr = new Uint32Array(1);
+        const down = libsdl.symbols.SDL_GetMouseState(ptr(xArr), ptr(yArr));
         const bmGet = this.buttonMap.get(down);
 
         if (bmGet == undefined || bmGet == 0) {
@@ -37,27 +43,31 @@ class Mouse {
         return false;
     }
 
-    isPressed(button: buttons) : boolean {
+    isPressed(button: buttons): boolean {
         switch (button) {
-            case 'left':
+            case "left":
                 return Mouse.getPressMap(1);
-            case 'middle':
+            case "middle":
                 return Mouse.getPressMap(2);
-            case 'right':
+            case "right":
                 return Mouse.getPressMap(3);
         }
     }
 
-    isDown(button: buttons) : boolean {
+    isDown(button: buttons): boolean {
         switch (button) {
-            case 'left':
+            case "left":
                 return Mouse.getDownMap(1);
-            case 'middle':
+            case "middle":
                 return Mouse.getDownMap(2);
-            case 'right':
+            case "right":
                 return Mouse.getDownMap(3);
         }
     }
+
+    getPosition(): Vector2 {
+        return new Vector2(Mouse.x, Mouse.y);
+    }
 }
 
 type buttons = "left" | "middle" | "right";

package/src/slifer.ts

@@ -11,28 +11,33 @@ import Mouse from "./modules/mouse";
 import Render from "./engine/render";
 
 class Slifer {
-    
     public isRunning: boolean;
+	public deltaTime: number;
 
     // Modules
     public Graphics = new Graphics();
     public Keyboard = new Keyboard();
     public Mouse = new Mouse();
 
+    private start = 0;
+    private end = 0;
+
     constructor() {
         initLibraries();
         this.isRunning = true;
+        this.deltaTime = 0;
     }
 
-    public createWindow(title: string, size: Vector2) : Window {
+    public createWindow(title: string, size: Vector2): Window {
         Window.createWindow(title, size);
         Renderer.createRenderer();
 
+        this.start = Number(libsdl.symbols.SDL_GetTicks64());
+
         return new Window();
     }
 
-    public shouldClose() : boolean {
-
+    public shouldClose(): boolean {
         libsdl.symbols.SDL_RenderClear(Render.pointer);
 
         const eventArray = new Uint16Array(32);
@@ -42,24 +47,39 @@ class Slifer {
                 case 256:
                     this.isRunning = false;
                     break;
+                case 1024:
+                    Mouse.onMove(eventArray[10], eventArray[12]);
+                    break;
                 case 1026:
                     Mouse.onRelease(eventArray[8]);
                     break;
             }
         }
 
+
         Keyboard.handleStates();
 
         Mouse.handleState();
+
+        this.end = Number(libsdl.symbols.SDL_GetTicks64());
+
+		this.deltaTime = (this.end - this.start) / 1000;
+
+        this.start = this.end;
         
-        
+
         return !this.isRunning;
     }
 
-    public getVersion() : string {
-        return 'v' + version;
+    public getVersion(): string {
+        return "v" + version;
     }
-}
 
+    public quit(): void {
+        libsdl.symbols.SDL_DestroyRenderer(Render.pointer);
+        libsdl.symbols.SDL_DestroyWindow(Window.pointer);
+        libsdl.symbols.SDL_Quit();
+    }
+}
 
 export default Slifer;