slifer 0.2.8 → 0.3.0

package/src/modules/graphics.ts

@@ -1,100 +1,66 @@
-import Vector2 from "../engine/vector2";
-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 Window from '../engine/window';
-import type Color from "../engine/color";
-import Rectangle from "../engine/rectangle";
-import Canvas from '../engine/canvas';
-
-/** @internal */
-export default class Graphics {
-
-    public render() : void {
-    	const texture = libsdl.symbols.SDL_CreateTextureFromSurface(Render.pointer, Render.surface);
-    	if (texture == null) throw `Render texture creation failed`;
-    	libsdl.symbols.SDL_RenderCopy(
-    		Render.pointer,
-    		texture,
-    		null,
-    		null
-    	);
-        libsdl.symbols.SDL_RenderPresent(Render.pointer);
-        libsdl.symbols.SDL_DestroyTexture(texture);
-    }
-    
-    public draw(drawable: Image | Canvas, x: number, y: number, scaleX?: number, scaleY?: number) : void {
-
-		const destArray = new Uint32Array(4);
-		destArray[0] = x;
-		destArray[1] = y;
-		destArray[2] = drawable.width * (scaleX ? scaleX : 1);
-		destArray[3] = drawable.height * (scaleY ? scaleY : 1);
-		        
-        libsdl.symbols.SDL_UpperBlitScaled(
-        	(drawable as any).pointer,
-        	null,
-        	Render.surface,
-        	ptr(destArray)
-        );
-    }
-
-    public setBackground(color: Color) : void {
-		const rect = new Rectangle(
-			new Vector2(0, 0),
-			new Vector2(Window.size.x, Window.size.y)
-		);
-		this.drawRect(rect, color);
-   	}
-
-    public drawRect(rectangle: Rectangle, color: Color) {
-		const _col = ((color.r << 16) + (color.g << 8) + (color.b << 0));
-
-        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_FillRect(Render.surface, ptr(rect), _col);
-    }
-    
-    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,
-			//@ts-expect-error
-    		Buffer.from(text+"\x00"),
-    		ptr(wArr),
-    		ptr(hArr)
-    	);
-
-    	const _col = ((color.r << 16) + (color.g << 8) + (color.b << 0));
-
-    	const surface = libttf.symbols.TTF_RenderText_Solid(
-    		(font as any).pointer,
-    		//@ts-expect-error
-    	  	Buffer.from(text+'\x00'),
-    	   	_col
-    	);
-    	if (surface == null) throw `Rendering text failed`;
-
-    	const destRect = new Uint32Array(4);
-		destRect[0] = x;
-		destRect[1] = y;
-		destRect[2] = wArr[0];
-		destRect[3] = hArr[0];
-
-    	libsdl.symbols.SDL_UpperBlit(
-			surface,
-			null,
-			Render.surface,
-			ptr(destRect)
-    	);
-		
-    }
-}
+import Vector2 from "../engine/vector2";
+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 Window from '../engine/window';
+import type Color from "../engine/color";
+import Rectangle from "../engine/rectangle";
+import Cursor from '../engine/cursor';
+
+type Drawable = Image;
+
+/** @internal */
+export default class Graphics {
+	public render() {
+		libsdl.symbols.SDL_RenderPresent(Render.pointer);
+	}
+
+	public draw(drawable: Drawable, x: number, y: number) {
+		(drawable as any).destArray[0] = x;
+		(drawable as any).destArray[1] = y;
+		
+		libsdl.symbols.SDL_RenderCopy(
+			Render.pointer,
+			(drawable as any).pointer,
+			null,
+			ptr((drawable as any).destArray)
+		)
+	}
+
+	public drawScaled(drawable: Drawable, x: number, y: number, xscale: number, yscale: number) {
+		(drawable as any).destArray[0] = x;
+		(drawable as any).destArray[1] = y;
+		(drawable as any).destArray[2] = drawable.width * xscale;
+		(drawable as any).destArray[3] = drawable.height * yscale;
+		
+		libsdl.symbols.SDL_RenderCopy(
+			Render.pointer,
+			(drawable as any).pointer,
+			null,
+			ptr((drawable as any).destArray)
+		)
+	}
+
+	private setColor(color: Color) {
+		libsdl.symbols.SDL_SetRenderDrawColor(Render.pointer, color.r, color.g, color.b, color.a);
+	}
+
+	public setBackground(color: Color) {
+		this.setColor(color);
+		libsdl.symbols.SDL_RenderClear(Render.pointer);
+	}
+
+	public drawRect(rectangle: Rectangle, color: Color) {
+		this.setColor(color);
+
+		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,96 +1,100 @@
-import { libsdl } from "../ffi";
-import { toArrayBuffer } from "bun:ffi";
-
-/** @internal */
-export default class Keyboard {
-
-    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()
-            .toLocaleLowerCase();
-
-        return 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.keyMap.set(keyName, 1);
-                } else if (kmGet == 1) {
-                    this.keyMap.set(keyName, 2);
-                }
-            } else if (keyDV.getUint8(kn) == 0) {
-                const keyName = this.convertScancodeToKey(kn);
-                this.keyMap.set(keyName, 0);
-            }
-        }
-    }
-
-    public isPressed(key: keys) : boolean {
-        const kmGet = Keyboard.keyMap.get(key);
-        if (kmGet == 1) return true;
-        return false;
-    }
-
-    public isDown(key: keys) : boolean {
-        const kmGet = Keyboard.keyMap.get(key);
-        if (kmGet == 1 || kmGet == 2) return true;
-        return false;
-    }
-}
-
-type keys =
-    | "a"
-    | "b"
-    | "c"
-    | "d"
-    | "e"
-    | "f"
-    | "g"
-    | "h"
-    | "i"
-    | "j"
-    | "k"
-    | "l"
-    | "m"
-    | "n"
-    | "o"
-    | "p"
-    | "q"
-    | "r"
-    | "s"
-    | "t"
-    | "u"
-    | "v"
-    | "w"
-    | "x"
-    | "y"
-    | "z"
-    | "1"
-    | "2"
-    | "3"
-    | "4"
-    | "5"
-    | "6"
-    | "7"
-    | "8"
-    | "9"
-    | "0"
-    | "space"
-    | "caps lock"
-    | "tab"
-    | "left shift"
-    | "right shift"
-    | "left ctrl"
-    | "escape";
+import { libsdl } from "../ffi";
+import { toArrayBuffer } from "bun:ffi";
+
+/** @internal */
+export default class Keyboard {
+
+    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()
+            .toLocaleLowerCase();
+
+        return 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, 128));
+        for (let kn = 0; kn < 128; kn++) {
+            if (keyDV.getUint8(kn) == 1) {
+                const keyName = this.convertScancodeToKey(kn);
+                const kmGet = this.keyMap.get(keyName);
+
+							
+                if (kmGet == undefined || kmGet == 0) {
+                    this.keyMap.set(keyName, 1);
+                } else if (kmGet == 1) {
+                    this.keyMap.set(keyName, 2);
+                }
+            } else if (keyDV.getUint8(kn) == 0) {
+                const keyName = this.convertScancodeToKey(kn);
+                this.keyMap.set(keyName, 0);
+            }
+        }
+    }
+
+    public isPressed(key: keys) : boolean {
+        const kmGet = Keyboard.keyMap.get(key);
+        if (kmGet == 1) return true;
+        return false;
+    }
+
+    public isDown(key: keys) : boolean {
+        const kmGet = Keyboard.keyMap.get(key);
+        if (kmGet == 1 || kmGet == 2) return true;
+        return false;
+    }
+}
+
+export type keys =
+    | "a"
+    | "b"
+    | "c"
+    | "d"
+    | "e"
+    | "f"
+    | "g"
+    | "h"
+    | "i"
+    | "j"
+    | "k"
+    | "l"
+    | "m"
+    | "n"
+    | "o"
+    | "p"
+    | "q"
+    | "r"
+    | "s"
+    | "t"
+    | "u"
+    | "v"
+    | "w"
+    | "x"
+    | "y"
+    | "z"
+    | "1"
+    | "2"
+    | "3"
+    | "4"
+    | "5"
+    | "6"
+    | "7"
+    | "8"
+    | "9"
+    | "0"
+    | "space"
+    | "caps lock"
+    | "tab"
+    | "left shift"
+    | "right shift"
+    | "left ctrl"
+    | "escape"
+    | "backspace"
+    | "."
+    | "return";

package/src/modules/mouse.ts

@@ -1,76 +1,76 @@
-import { libsdl } from "../ffi";
-import { ptr } from "bun:ffi";
-import Vector2 from "../engine/vector2";
-
-/** @internal */
-class Mouse {
-    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 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) {
-            this.buttonMap.set(down, 1);
-        } else if (bmGet == 1) {
-            this.buttonMap.set(down, 2);
-        }
-    }
-
-    private static getPressMap(button: number) {
-        const bmGet = this.buttonMap.get(button);
-        if (bmGet == 1) return true;
-        return false;
-    }
-
-    private static getDownMap(button: number) {
-        const bmGet = this.buttonMap.get(button);
-        if (bmGet == 1 || bmGet == 2) return true;
-        return false;
-    }
-
-    isPressed(button: buttons): boolean {
-        switch (button) {
-            case "left":
-                return Mouse.getPressMap(1);
-            case "middle":
-                return Mouse.getPressMap(2);
-            case "right":
-                return Mouse.getPressMap(3);
-        }
-    }
-
-    isDown(button: buttons): boolean {
-        switch (button) {
-            case "left":
-                return Mouse.getDownMap(1);
-            case "middle":
-                return Mouse.getDownMap(2);
-            case "right":
-                return Mouse.getDownMap(3);
-        }
-    }
-
-    getPosition(): Vector2 {
-        return new Vector2(Mouse.x, Mouse.y);
-    }
-}
-
-type buttons = "left" | "middle" | "right";
-
-/** @internal */
-export default Mouse;
+import { libsdl } from "../ffi";
+import { ptr } from "bun:ffi";
+import Vector2 from "../engine/vector2";
+
+/** @internal */
+class Mouse {
+    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 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) {
+            this.buttonMap.set(down, 1);
+        } else if (bmGet == 1) {
+            this.buttonMap.set(down, 2);
+        }
+    }
+
+    private static getPressMap(button: number) {
+        const bmGet = this.buttonMap.get(button);
+        if (bmGet == 1) return true;
+        return false;
+    }
+
+    private static getDownMap(button: number) {
+        const bmGet = this.buttonMap.get(button);
+        if (bmGet == 1 || bmGet == 2) return true;
+        return false;
+    }
+
+    isPressed(button: buttons): boolean {
+        switch (button) {
+            case "left":
+                return Mouse.getPressMap(1);
+            case "middle":
+                return Mouse.getPressMap(2);
+            case "right":
+                return Mouse.getPressMap(3);
+        }
+    }
+
+    isDown(button: buttons): boolean {
+        switch (button) {
+            case "left":
+                return Mouse.getDownMap(1);
+            case "middle":
+                return Mouse.getDownMap(2);
+            case "right":
+                return Mouse.getDownMap(3);
+        }
+    }
+
+    getPosition(): Vector2 {
+        return new Vector2(Mouse.x, Mouse.y);
+    }
+}
+
+type buttons = "left" | "middle" | "right";
+
+/** @internal */
+export default Mouse;

package/src/slifer.test.ts

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