slifer 0.2.1 → 0.2.3

package/README.md

@@ -7,7 +7,7 @@
 > [!CAUTION]
 > Slifer is currently in alpha. Use at your own risk.
 
-> [!NOTE] 
+> [!NOTE]
 > Not all basic features have been implemented. Many are missing such as
 > window customization. As such, I recommend waiting for a beta release of
 > Slifer before using it for a long term project.
@@ -16,6 +16,8 @@ Slifer is a game framework made to allow users to code games in typescript. The
 framework uses bun and SDL2 under the hood to allow your game to render and
 build natively to desktop.
 
+If you'd like to learn more about Slifer, feel free to head to [Slifers Webpage](https://slifer.hazyvt.com).
+
 ## Contents
 
 - [Goals](#goals)
@@ -53,13 +55,13 @@ Slifer.createWindow("Example Window", 640, 480);
 const bg = Slifer.Graphics.makeColor(36, 36, 36, 255);
 
 while (!Slifer.shouldClose()) {
-  Slifer.Graphics.setBackground(bg);
+    Slifer.Graphics.setBackground(bg);
 
-  if (Slifer.Keyboard.isPressed("escape")) {
-    Slifer.isRunning = false;
-  }
+    if (Slifer.Keyboard.isPressed("escape")) {
+        Slifer.isRunning = false;
+    }
 
-  Slifer.Graphics.render();
+    Slifer.Graphics.render();
 }
 
 Slifer.quit();

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.01",
+    "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/renderer.ts

@@ -0,0 +1,40 @@
+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,
+            vsyncHint
+        );
+
+        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

@@ -0,0 +1,79 @@
+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,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

@@ -0,0 +1,79 @@
+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,
+            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);
+    }
+
+    public setTitle(title: string): void {
+        this.title = title;
+        libsdl.symbols.SDL_SetWindowTitle(
+            Window.pointer,
+            Buffer.from(title + "\x00")
+        );
+    }
+
+    public setFullscreen(flag: boolean) {
+        libsdl.symbols.SDL_SetWindowFullscreen(Window.pointer, Number(flag));
+    }
+
+    public setPosition(position: Vector2) {
+        libsdl.symbols.SDL_SetWindowPosition(
+            Window.pointer,
+            position.x,
+            position.y
+        );
+    }
+
+    public centerWindow() {
+        this.setPosition(new Vector2(Window.centerPos, Window.centerPos));
+    }
+}
+
+export default Window;

package/src/engine.ts

@@ -1,24 +1,31 @@
-import { libsdl, libimage, libttf } from "./ffi";
-import Global from "./global";
+import { libsdl, libimage, libttf, libmixer } from "./ffi";
+import Graphics from "./modules/graphics";
 
-//@ts-expect-error
-const fontFile = await import("./Jost-Bold.ttf");
-
-export function initLibraries(): void {
-    const baseInit = libsdl.symbols.SDL_Init(0x00000020);
+export function initSDL() {
+    const initVideo = 0x00000020;
+    const initAudio = 0x00000010;
+    const baseInit = libsdl.symbols.SDL_Init(initVideo + initAudio);
     if (baseInit != 0) throw `SDL failed to initialize`;
+}
 
+export function initSDLImage() {
     const imageInit = libimage.symbols.IMG_Init(3);
     if (imageInit != 3) throw `SDL Image failed to initialize`;
+}
 
+export function initSDLTypeFont() {
     const ttfInit = libttf.symbols.TTF_Init();
     if (ttfInit != 0) throw `SDL TTF failed to initialize`;
+}
 
-    const tempFont = libttf.symbols.TTF_OpenFont(
-        Buffer.from(fontFile.default),
-        24
-    );
+export function initSDLMixer() {
+    const mixInit = libmixer.symbols.Mix_OpenAudio(22050, null, 2, 4096);
+    if (mixInit != 0) throw `SDL Audio failed to initialize`;
+}
 
-    if (tempFont == null) throw `Default font loading failed`;
-    Global.ptrFont = tempFont;
+export function initLibraries(): void {
+    initSDL();
+	initSDLImage();
+	initSDLTypeFont();
+	initSDLMixer();
 }