classes.js

//#region types
/** The result of the operation.
 * @typedef {Object} Result
 * @property {boolean} success - Indicates whether the operation was successful.
 * @property {*} result
 */

/** 
 * @typedef {"%" | "px" | "rem" | "vw" | "vh"} numberExtention
 */

/** Represents a pair of coordinates in the game.
 * @typedef {Array<number, number>} GameCoords
 */

/** data of a Entity
 * @typedef {Object} EntityData
 * @property {Stat} speed - The movement speed of the entity, defining how far it can move with each step.
 * @property {GameCoords} position - The starting position of the entity.
 * @property {Stat} health - The health property of the entity.
 * @property {Stat} specialPoints - Points used for special abilities.
 * @property {{ health: Stat, specialPoints: Stat }} regen - The regeneration rate for health and special points per second.
 * @property {Stat} attackStrength - The natural damage dealt by the entity.
 * @property {Object} buffs - Any active buffs affecting the entity.
 * @property {Object<string, Upgrade[]} upgrades - Any upgrades applied to the entity.
 * @property {number} revives - The number of times the entity can be revived.
 * @property {Array<Ability | Stat>} tracked - the tracked Stats and Abilities
 */

/** Valid event names
 * @typedef {"health:0" | "health:25" | "health:50" | "damage" | "heal" | "collided" | "status"} EventName
 */

/**
 * @typedef {Object} DamageSource
 * @property {Entity | Projectile | undefined} attacker - The source of the damage, such as an entity or projectile.
 * @property {"explosion" | "blont" | "stabing" | undefined} type - The type of damage dealt.
 */

/**
 * @typedef {{type: string, number: number}} Upgrade
 */

/**
 * @callback eventFunction
 * @param {Entity} entity
 * @param {...any} args
 * @returns {Result}
 */

/** ability handler
 * @callback abilityHanbler
 * @param {Ability} ability
 * @param {...any} args
 * @returns {void} 
 */

/** ability initelizer
 * @callback abilityInitelizer
 * @param {Ability} ability
 * @returns {void}
 */

/**
 * @callback descriptor
 * @returns {String}
 */

/**@typedef {"none" | "random" | "aggressive" | "scared" | "chase" | "flee" | "wander" | "patrol" | "player"} AIType*/

/** Custom behavior data for the AI.
 * @typedef {object} AIBehavior
 * @property {number | Function} agro
 * @property {number | Function} fear
 * @property {number | Function} range
 * @property {Object<number, number>} priority
 * @property {Function | undefined} randomFunction
 * @property {[number, number][]} patrolPoints
 * @property {Entity} targeting
 */

/**@typedef {"common" | "uncommon" | "rare" | "epic" | "legendary" | "godly"} Rarity*/
//#region presets
/** JSON data
 * @typedef {{
* entityPresets: Object<string, EntityPreset>,
* htmlPresets: Object<string, HtmlPreset>,
* abilityPresets: Object<string, AbilityPreset>}} JSONData
*/

/** JSON entity preset
 * @typedef {Object} EntityPreset
 * @property {"Player" | "none" | "AI"} entityType - the type of entity
 * @property {Object} visual - Visual representation of the entity.
 * @property {HTMLData} visual.html
 * @property {HTMLData[]} visual.children
 * @property {JSONEntityData} data - Data representing the entity's stats and abilities.
*/

/** JSON HTML element preset
* @typedef {Object} HtmlPreset
* @property {HTMLData} visual - Visual representation of the HTML element.
* @property {HTMLData[]} children
*/
/** HTML data
 * @typedef {Object} HTMLData
 * @property {string | number} name
 * @property {string | number} id - ID of the HTML element.
 * @property {string} type - Type of the HTML element (e.g., "div").
 * @property {[number, number, numberExtention]} size - Size of the element [width, height, unit].
 * @property {{top: number, left: number, right: number, bottom: number, z: number types: numberExtention | Object<string, numberExtention>}} position
 * @property {Object} style - CSS styles for the element.
 * @property {Object} attributes
 * @property {string} text
 * @property {string} label - a input label
 * @property {HTMLData[]} content
 */

/**entity data 
 * @typedef {Object} JSONEntityData
 * @property {Object<string, {value: number, min:number, max:number}} stats - Statistics of the entity.
 * @property {string[]} abilities - Abilities assigned to the entity.
 * @property {object} ai - the logic controler of the entity
 * @property {AIType} ai.aiType - the type of ai
 * @property {AIBehavior | "empty"} ai.behavior
*/
/** JSON ability preset
* @typedef {Object} AbilityPreset
* @property {string} name - The name of the ability.
* @property {number} cooldownTime - The cooldown time in milliseconds.
* @property {Rarity} rarity - how rare the ability is
* @property {Object} data - Data representing the ability's properties.
* @property {string | descriptor} description - Description of the ability (instance)
* @property {Object} logic - Logic for the ability's behavior.
* @property {Object} logic.call - Function call logic for the ability.
* @property {string} logic.call.type - The type of the function.
* @property {Object} logic.call.params - Parameters for the function.
* @property {string} logic.call.params.ability - The ability parameter.
* @property {string} logic.call.params.user - The user parameter.
* @property {string} logic.call.code - The code to execute.
* @property {Object} logic.initialize - Initialization logic for the ability.
* @property {string} logic.initialize.type - The type of the function.
* @property {string} logic.initialize.description - Description of the function.
* @property {Object} logic.initialize.params - Parameters for the function.
* @property {string} logic.initialize.params.ability - The ability parameter.
* @property {string} logic.initialize.code - The code to execute.
*/

/** JSON callebal construction data 
* @typedef {Object} CallebolConstructionData
* @property {string} description - Description of the function.
* @property {Object} params - Parameters for the function.
* @property {string} code - The code to execute.
* 
*/
//#endregion

//#endregion
//#region classes
/** Represents an entity in the game.*/
class Entity {
	//#region propertys
	#isPlayer = false
	#active = true
	#position
	#size = [NaN, NaN]
	facing = "up"
	currentAngle = 0
	abilitys = {} //name: function
	/**@type {Object<string, Weapon>} */
	sides = {left: undefined, right: undefined, top: undefined, down: undefined}// aqipment
	/**@type {Object<string, eventFunction>}*/
	#events = {}
	/** @type {EntityData}*/
	data
	static nonEntity = new Entity("null") // domie instance
	//#endregion

	/**
	 * @param {string|number} html_element_id - The ID of the HTML element representing the entity.
	 * @param {EntityData} [data={}] - Additional data for the entity.
	 * @param {boolean} [isPlayer=false] - Indicates if the entity is controlled by a player.
	 */
	constructor(html_element_id, data = {}, isPlayer = false) {
		if (html_element_id === "null") {// dummie instance
			this.id = "null";
			this.element = null;
			this.#position = [0, 0];
			this.#size = [0, 0];
			this.data = {};
			this.#isPlayer = false;
			this.style = {}
			return;
		}
		const GAME = Game.instance
		if (!Game.Active) throw new Error("game is not active");
		if (typeof html_element_id !== "string" && typeof html_element_id !== "number") 
			{throw new Error("Invalid ID");}
		const entity = this
		this.element = document.getElementById(html_element_id);
		const element = this.element
		if (!element) throw new Error(`Element with ID "${html_element_id}" not found.`);
		//#region propertys
		this.id = html_element_id;
		this.#position = [element.offsetLeft, element.offsetTop];
		this.#size = [element.offsetWidth, element.offsetHeight];
		this.#isPlayer = isPlayer;
		this.style = element.style;
		this.data = { speed: new Stat("speed", 10, [NaN, 0]), ...data };
		this.style.position = "absolute";
		//#endregion
		// Logic
		const {minSize, maxSize} = GAME;
		this.#size = this.#size.map((dim) => {
			if (dim > maxSize) return maxSize;
			if (dim < minSize) return minSize;
			return Math.round(dim);
		});

		this.width = this.#size[0]
		this.height = this.#size[1]
		//#region data prosesing
		//#region position preset
		if (data.position){
			this.goTo(...data.position)
			delete data.position
		}
		//#endregion
		//#region style
		if (data.style){ 
			for (const style in data.style) this.style[style] = data.style[style];
			delete data.style

		}
		//#endregion
		//#region health
		if (data.health){
			let {health, maxHealth} = data
			if(!(health instanceof Stat) && (typeof health != "number" || health <= 0 || isNaN(health))) 
				throw new TypeError("invalid healt value")
			if(typeof health == "number") health = new Stat(
				"hp", //name
				health, //value
				[
				Math.max(maxHealth ?? health, health), //max
				0,// min
				]
			)
			health.onChange = () => entity.checkHealt()
			this.data.health = health
		}
		//#endregion
		//#region move speed
		if(data.speed){
			let {moveSpeed} = data.speed
			if(!(moveSpeed instanceof Stat) && typeof moveSpeed != "number" || isNaN(moveSpeed)) 
				throw new TypeError("invalid moveSpeed value")
			if(typeof moveSpeed === "number") moveSpeed = new Stat("speed", moveSpeed)
			console.debug(`moveSpeed of ${this.id} = ${moveSpeed}`);
			
			this.data.speed = moveSpeed
		}
		else console.debug(`${this.id}'s speed has not been set as its given movespeed is: ${data.speed}`);
		
		//#endregion
		//#endregion
		GAME.addEntity(this)

	}
	//#region getters & setters
	get isPlayer() {return this.#isPlayer;}

	get position() {return this.#position;}

	get borderCords() {// returns the cords of the border
		const offset = this.size.map((size => size/2))
		return{
			"left": this.position[0] - offset[0],
			"right": this.position[0] + offset[0],
			"top": this.position[1] - offset[1],
			"bottom": this.position[1] + offset[1],
		}
	}
	get hitbox(){
		return Math.min(...this.size) * 0.75
	}

	get width() {return parseFloat(this.style.width) || 0;}
	set width(width) {
		if (typeof width !== "number") throw new Error("Width must be a number");
		this.style.width = `${width}px`;
	}
	
	get height() {return parseFloat(this.style.height) || 0;}
	set height(height) {
		if (typeof height !== "number") throw new Error("Height must be a number");
		this.style.height = `${height}px`;
	}
	
	get size() {return this.#size;}
	set size(size) {
		if (!Array.isArray(size)) {
			if (typeof size === "number") {
				if(Math.min(size) < Math.max(size)/2) return
				size = [size, size];
			} else {
				console.warn("Size must be a number or an array of two numbers.");
				return;
			}
		}

		if (size.length !== 2 || size.some(dim => typeof dim !== "number")) {
			console.warn("Array must contain exactly two numbers.");
			return;
		}

		this.#size = size;
		this.style.width = `${size[0]}px`;
		this.style.height = `${size[1]}px`;
	}

	get closestEntity() {
		let otherEntity = Entity.nonEntity; // To store the closest entity
	
		// Loop through all entities
		Game.instance.entities.forEach((entity) => {
			if(!(entity instanceof Entity)) throw new Error("a Object has been found that is not a instance of the Entity class")
			if (entity === this || entity === Entity.nonEntity || !entity) return; // Skip itself
			if (!Entity.isEntity(otherEntity)) {
				otherEntity = entity
				return
			}
	
			let distance = this.getDistanceToEntity(entity);
			if (!otherEntity || distance < this.getDistanceToEntity(otherEntity)) otherEntity = entity;
		});
		if(otherEntity == Entity.nonEntity) throw new Error("no valid entity was returned");
		
		return otherEntity;
	}
	//#endregion
	//#region events
	get events(){
		const entity = this
		return new Proxy(this.#events, {
			get: (target, prop) => target[prop],
			set: (_, eventType, handler) => {entity.addEvent(eventType, handler)},
			deleteProperty: (_, prop) => {entity.removeEvent(prop)}
		})
	}
	/**Adds an event handler to the entity.
	 * @param {EventName} eventName - The name of the event to add.
	 * @param {eventFunction} handler - The function to execute when the event is triggered.
	 * @throws {TypeError} - If the event type is not a string, or if the handler is not a function.
	*/
	addEvent(eventName, handler) {
		if (typeof eventName !== "string") throw new TypeError("Invalid event type: must be a string.");

		if (typeof handler !== "function") throw new TypeError("Invalid handler: must be a function.");

		// Add the event handler to the internal #events object.
		this.#events[eventName] = handler;
	}

	/** Removes an event handler from the entity.
	 * @param {EventName} eventName - The name of the event to remove.
	 * @throws `TypeError` - If the event type is not a string.
	 * @warns if the event dusent exist
	 */
	removeEvent(eventName) {
		if (typeof eventName !== "string") throw new TypeError("Invalid event type: must be a string.");

		// Check if the event exists before attempting to delete.
		if (!this.#events[eventName]) {
			console.warn(`Event "${eventName}" does not exist.`);
			return;
		}

		// Remove the event handler from the internal #events object.
		delete this.#events[eventName];
	}
	
	/**
	 * @param {EventName} eventName 
	 * @param  {...any} args 
	 * @returns {result}
	 */
	triggerEvent(eventName, ...args) {
		if (!this.#events[eventName]) return {success: false, result: undefined};
		const result = this.#events[eventName](this, ...args);
		return {success: true, result: result};
	}
	//#endregion
	//#region movement
	move(x = 0, y = 0) {
		if (!this.#active) return;
		if(typeof x != "number" || typeof y != "number" || ![x,y].map((cord) => isNaN(cord)))
			throw new TypeError(`invalid values:x: ${x}, y: ${y}`)
		// Update position
		this.#position[0] += Math.round(x);
		this.#position[1] += Math.round(y);

		// Update facing direction based on movement
		if (x !== 0 || y !== 0) this.updateFacingDirection(x, y);

		// Ensure entity stays within bounds
		this.checkBounds();
	}

	goTo(x = 0, y = 0, bounded=false) {
		// Update position
		this.#position = [x, y];

		// Since goTo does not involve incremental movement, keep the current facing direction
		if(bounded) this.checkBounds()
	}
	
	updateFacingDirection(x, y) {
		const directions = Game.directions.object;
		const directionVector = [x, y].map((value) => (value > 0 ? 1 : value < 0 ? -1 : 0));
		let newFacing = "none"; // Default facing
	
		for (const dir in directions) {
			if (JSON.stringify(directions[dir]) === JSON.stringify(directionVector)) {
				newFacing = dir;
				break;
			}
		}
	
		if (this.facing !== newFacing) {
			this.facing = newFacing;
			this.updateRotation(); // Update rotation smoothly
		}
	}
	
	updateRotation() {
		const angles = {
			up: 0,
			right: 90,
			down: 180,
			left: 270,
			upRight: 45,
			downRight: 135,
			downLeft: 225,
			upLeft: 315,
		};
		this.currentAngle >=0 ? this.currentAngle = -1000 : void 0
		const targetAngle = angles[this.facing] ?? 0; // Get target angle for the new facing
		const angleDiff = ((targetAngle - this.currentAngle + 540) % 360) - 180; // Shortest rotation path
		this.currentAngle += angleDiff; // Update current angle
		//console.log(targetAngle, angleDiff, this.currentAngle);

		// Apply rotation
		this.style.rotate = `${this.currentAngle}deg`;
	}
	
	updatePosition() {
		const zero =  Game.instance.zero; // The center of the game window
		this.style.left = `${zero[0] + this.#position[0]}px`; // Convert gameCords to DOM position
		this.style.top = `${zero[1] + this.#position[1]}px`;
	}
	checkBounds() {
		const gameBorder = Game.instance.borderCords; // New object each time
		const entityBorder = this.borderCords;
		const offset = [this.width / 2, this.height / 2];

		// Adjust the border for offsets
		let i = 0;
		for (const cord in gameBorder) {
			i++;
			if (i % 2 === 1) gameBorder[cord] -= i > 2 ? offset[0] : offset[1]; // Adjust left and top
			else gameBorder[cord] += i > 2 ? offset[0] : offset[1]; // Adjust right and bottom
		}

		// Update entity position if it exceeds game bounds
		if (entityBorder.left < gameBorder.left)
			this.#position[0] = gameBorder.left + offset[0];
		if (entityBorder.right > gameBorder.right)
			this.#position[0] = gameBorder.right - offset[0];
		if (entityBorder.top < gameBorder.top)
			this.#position[1] = gameBorder.top + offset[1];
		if (entityBorder.bottom > gameBorder.bottom)
			this.#position[1] = gameBorder.bottom - offset[1];
	
		// Check collisions
		Game.instance.checkColision();
	}
	
	//#endregion
	//#region health
	/**@returns {boolean}*/
	checkHealt(recheck=0){
		const {health} = this.data
		const healthLevel = this.healthLevel
		/**@type {Number} */
		this.oldHealtLevel = this.oldHealtLevel ?? 100
		if(!health) return void 0// checks if the entity has a healt stat
		if(healthLevel <=50 && this.oldHealtLevel > 50){
			console.log(`${this.id}'s health has droped to 50%`);
			this.triggerEvent("health:50")
		}
		if(healthLevel <= 25 && this.oldHealtLevel > 25){
			console.log(`${this.id}'s health has droped to 25%`);
			this.triggerEvent("health:25")
		}
		if(healthLevel <= 10 && this.oldHealtLevel > 10){
			console.log(`${this.id}'s health has droped to 10%`);
			this.triggerEvent("health:1")
		}
		if(healthLevel === 0 || health.value === 0){
			console.log(`entity(${this.id})'s healt has reachd 0%`)
			this.triggerEvent("health:0")
			return false
		}
		this.oldHealtLevel = health.value
		if(recheck) this.checkHealt(recheck--)
		return true
	}
	get healthLevel(){
		const health = this.data.health
		if(!(health instanceof Stat)) {
			console.warn(`${this.id}'s health stat is a ${typeof health} instead of a Stat instance`);
			return NaN
		}
		return health.level
	}
	/**
	 * @param {number} damage
	 * @param {DamageSource} sourch
	 */
	damage(damage, sourch=undefined) {
		if (typeof damage !== "number" || isNaN(damage)) 
			throw new Error("Invalid damage: must be a number.", typeof damage);

		// Trigger the "damage" event and allow handlers to modify the damage.
		const { success, result } = this.triggerEvent("damage", damage, sourch);
		//console.log(damage);

		if (success) {
			if (typeof result?.damage === "number" && result.damage >= 0) damage = result.damage;
			else console.warn("Damage event handler did not return a valid damage value.");
		}
		//console.log(damage);

		if (!this.data.health) return; // Skip if the entity has no health property.

		// Ensure damage does not exceed current health or go negative.
		damage = Math.min(Math.max(damage, 0), this.data.health);
		// Apply the damage.
		const health = this.data.health
		if(!(health instanceof Stat)) return
		health.value -= damage;

		//console.log(`${this.id} took ${damage} damage, remaining health: ${health.value}`);
	}
	//#endregion
	//#region helper functions
	/**
	 * @param {Entity} otherEntity 
	 * @returns {number} the distance in pixels
	 */
	getDistanceToEntity(otherEntity) {
		if (!(otherEntity instanceof Entity))
			throw new Error("The argument must be an instance of Entity.");

		const distance = this.getDistanceToPoint(otherEntity.position)
		return distance;
	}
	getDistanceToPoint(point){
	if (!Array.isArray(point) || point.length !== 2 || typeof point[0] !== "number" || typeof point[1] !== "number")
		throw new TypeError("Invalid position");

	const [x1, y1] = this.position;
	const [x2, y2] = point;
	return Math.hypot(x2 - x1, y2 - y1);
}
	getDirection(x, y, debug = false) {
	const differences = [x, y].map((coord, index) => {
		const diff = coord - this.position[index];
		return diff > 0 ? 1 : diff < 0 ? -1 : 0;
	});
	if (debug) console.log(differences);
	return differences;
}

	/** delets the entity*/
	destroy(gameEnd=false){
		if(this instanceof NPC) this.ai.stop()
		if(!gameEnd)console.log(`${this.id} has been defetet`);
		
		this.#active = false
		Game.instance.romoveEntity(this.id)
		if(this instanceof NPC) delete this.ai

		try {
			this.element.remove()
		} catch (error) {
			if(!document.getElementById(this.id)) return
			else throw new Error(error);
			
		}
		

	}
	//#endregion
	//#region defalt events
	/**
	 * @param {EventName} eventName 
	 * @returns {eventFunction}
	 */
	static defaultEvent(eventName){
		switch (eventName) {
			case "health:0":return (entity) => entity.destroy()
			default:throw new TypeError("invalid eventName");
		}
	}
	//#endregion
	//#region static
	/** returns weater the entity is a entity
	 * @param {Entity} entity 
	 * @returns {Boolean}
	 */
	static isEntity(entity){return (entity && entity !== Entity.nonEntity)}
	//#endregion
}

/** Represents a Non-Player Character (NPC) with AI-driven behavior. */
class NPC extends Entity {
	/**
	 * @param {string} id - The unique identifier for the NPC.
	 * @param {AI} ai - The AI instance controlling the NPC.
	 * @param {Object} [data={ moveSpeed: 10 }] - Additional configuration for the NPC.
	 * @throws {Error} Throws if `ai` is not an instance of AI.
	 */
	constructor(id, ai, data = { moveSpeed: 10 }) {
		if (!(ai instanceof AI)) throw new Error("An NPC requires a valid AI instance.");

		super(id, data);
		this.ai = ai;
		ai.entity = this;
	}

	/**
	 * Executes the AI-driven movement logic for the NPC.
	 * Ensures the NPC's position is updated visually and logically.
	 */
	ComputerMove() {
		if (this === window) {
			console.error("Entity cannot be the window object.");
			return;
		}

		// Check if AI is defined
		if (!this.ai) {
			console.error("AI is not defined for this NPC.");
			return;
		}

		// Get movement direction from AI
		const direction = this.ai.direction();
		if (!Array.isArray(direction) || direction.length !== 2) {
			console.error("AI provided an invalid direction. Expected [x, y].");
			return;
		}

		// Apply movement, scaling by moveSpeed
		this.move(...direction.map((cord) => cord * (this.data.speed || 1)));

		// Update the visual position
		this.updatePosition();

		// Trigger any external updates, if required
		if (typeof updateOutput === "function") updateOutput();
	}
}

/** Represents the Player.
 * Extending the `Entity` class.
 * Enforces a singleton pattern to ensure only one player instance exists.
 */
class Player extends Entity {
	/** the loded player instance
	 * @type {Player}
	 */
	static instance;
	static userData = {
		name: "player",
		score: 0,
		abilities: {move: undefined},// abilities: keybord key, function
		 entity: undefined, //new Player
		 settings: {
			movement: {
			left: "a",
			right: "d",
			up: "w",
			down: "s"
			},
			playerColor: "blue",
		},
		/**@type {key} */
		keyPresses: {},
		rewards: {upgrades: [], abilities: [], healhs: 0, length:0}
	}
	cords = [0,0]
	#active = false;
	/**
	 * @param {} data
	 * @param {EntityData} mods 
	 * @returns 
	 */
	constructor(mods = {}, ...{data = {}}) {
		if (Player.instance instanceof Player) return Player.instance;

		super("player", {
			health: 200,
		}, true);

		Player.instance = this;
		if(data.ai) this.controler = data.ai
		else
		this.controler = new AI("player", {
			movement: { c: Ability.getAbility("dash"), 
			" ": Ability.getAbility("shoot") },
		});
		this.controler.entity = this;

		// Initialization
		this.#active = true;
		this.data.onCooldown = {};
		this.addEvent("damage", (entity, damage, source) => {
			if (typeof damage !== "number") throw new TypeError("Damage must be a number.");
			this.data.health.value -= damage
		});
		this.addEvent("health:0", (player) => {
			if (!(player instanceof Player)) throw new Error("Invalid player instance.");
			player.active = false;
			if(player){}

		});
		this.sides.top = Weapon.defaultWeapon(this)
		// Apply styles
		this.style.backgroundColor = Player.userData.settings.backgroundColor;

	}
	//#region static functions
	/** Updates the player's state based on user inputs or AI controls. */
	static updatePlayer() {
		if (!(Player.instance instanceof Player)) {
			console.log("Waiting for player to load...");
			setTimeout(Player.updatePlayer, 500);
			return;
		}
		const user = Player.instance;
		const directions = Game.directions.object;
		const controls = Player.userData.settings.movement;

		// Map keys to actions
		const keyList = Object.entries(controls).reduce((acc, [action, key]) => {
			acc[key] = action;
			return acc;
		}, {});

		const moves = { ...user.controler.behavior.moves, ...keyList };
		const player = Player.userData
		const {keyPresses} = player
		let directionToMoveIn = { left: 0, right: 0, up: 0, down: 0 };
		let hasMoved = false;


		// Handle pressed keys
		Object.keys(keyPresses).forEach((key) => {
			if (!moves[key]) return; // Skip undefined actions

			const action = moves[key];
			if (Object.values(controls).includes(key) && !player.moveOnCooldown) {
				// Handle movement
				hasMoved = Player.handleMovement(action, directionToMoveIn) || hasMoved;
			} else if (!Object.values(controls).includes(key)) {
				// Handle abilities
				Player.handleAbility(action, user);
			}
		});

		if (hasMoved) {
			let toMove = [0, 0];
			toMove[0] -= (directionToMoveIn.left ?? 0) - (directionToMoveIn.right ?? 0);
			toMove[1] -= (directionToMoveIn.up ?? 0) - (directionToMoveIn.down ?? 0);
			if (toMove[0] && toMove[1]) toMove = toMove.map((cord) => cord / 2);
			user.move(toMove);
			player.moveOnCooldown = true;
			setTimeout(() => (player.moveOnCooldown = false), 50);
		}
	}

	/** Handles directional movement.
	 * @param {string} action - The action (e.g., "left", "right", "up", "down").
	 * @param {Object} directionToMoveIn - Tracks the active directions.
	 * @returns {boolean} Whether movement was handled.
	 */
	static handleMovement(action, directionToMoveIn) {
		switch (action) {
			case "left":
				directionToMoveIn.left = 1;
				return true;
			case "right":
				directionToMoveIn.right = 1;
				return true;
			case "up":
				directionToMoveIn.up = 1;
				return true;
			case "down":
				directionToMoveIn.down = 1;
				return true;
			default:
				console.warn(`Unknown movement action: ${action}`);
				return false;
		}
	}

	/** Handles ability usage.
	 * @param {object|string} action - The ability or invalid action.
	 * @param {Player} user - The player using the ability.
	 */
	static handleAbility(action, user) {
		if (typeof action === "object" && typeof action.use === "function") action.use(user);
		else console.warn(`Invalid or undefined ability action: ${action}`);
	}
	//#endregion
	/** Moves the player in a given direction, applying speed.
	 * @param {number[]} direction - The [x, y] movement vector.
	 */
	move(direction) {super.move(...direction.map((cord) => cord * this.data.speed));}

	/** Applies player-specific settings (e.g., color). */
	applySettings() {this.style.backgroundColor = Player.settings.playerColor;}
	/**
	 * @param {Stat | Ability} toAd 
	 */
	addToHub(toAd){

	}
	//#region getters and setters

	/** Whether the player is active.
	 * @returns {boolean}
	 */
	get active() {return this.#active;}
	set active(bool) {
		if(!(typeof bool == "boolean")) throw new TypeError("active has to be a bool");
		this.#active = bool
	}
	//#endregion
	static setupKeyListeners() {
		const keyPresses = Player.userData.keyPresses
		window.addEventListener("keydown", (e) => {
			const key = e.key.toLowerCase();
			if (!key.includes("f") || key === "f") keyPresses[key] = true;
		});
	
		window.addEventListener("keyup", (e) => {
			delete keyPresses[e.key.toLowerCase()];
		});
		Player.instance.updateIntervale = setInterval(Player.updatePlayer, 26)
	}

}

/** Represents a projectile in the game. */
class Projectile {
	/**A list of all active projectiles in the game.
	 * @type {Projectile[]}
	 */static activeProjectiles = [];

	/**Default stats for projectiles.*/
	static get defaultStats() {return {
			speed: new Stat("speed", 20, [200, 0]),
			atk: new Stat("ATK", 10),
			hp: new Stat("health", 1, [1, 1]),
			drag: new Stat("drag", 0), // Reduces speed over time by this amount
			range: new Stat("range", 10)
		};
	}

	#stats = Projectile.defaultStats
	#onHit = Ability.getAbility("explode", {damage: 10, range: 10})
	target = { type: "direction", data: "up" }; // Type: [entity, direction, point]
	position = [0, 0];

	/**
	 * @param {Entity} owner - The entity that owns this projectile.
	 * @param {Object<string, Stat>} stats - Custom stats for the projectile.
	 * @param {number[]} position - Initial position of the projectile as [x, y].
	 * @param {Object} target - The target of the projectile (type and data). `valid types` - [direction, point, entity]
	 * @param {Object} data - Additional metadata.
	 * @throws {TypeError} If the owner is not a valid `Entity` or stats are invalid.
	 */
	constructor(owner = Entity.nonEntity, stats = Projectile.defaultStats, position = [NaN], target, data = {}) {
		if (!(owner instanceof Entity) && owner !== Entity.nonEntity) {
			throw new TypeError("Owner has to be an Entity or Entity.nonEntity");
		}
		for (const statKey in stats) {
			if (!(stats[statKey] instanceof Stat)) {
				throw new TypeError(`Invalid stat: ${statKey}`);
			}
		}

		this.owner = owner;
		this.#stats = { ...Projectile.defaultStats, ...stats };
		this.target = target;

		// Create visual representation
		this.element = document.createElement("div");
		this.style = this.element.style;
		this.style.width = "2.5px";
		this.style.height = "2.5px";
		this.style.backgroundColor = "red";
		this.style.position = "absolute";

		if (!isNaN(position[0] && !isNaN(position[1])) && Array.isArray(position)) {
			this.position = position;
			//console.debug("Projectile has valid coordinates");
		} else {
			this.position = this.elementPosition;
			//console.debug("Projectile has invalid coordinates");
		}
		Game.instance.window.appendChild(this.element);

		Projectile.activeProjectiles.push(this);

		// Start movement
		this.moveInterval = setInterval(() => this.updatePosition(), 64);
	}
	//#region getters and setters
	/**The stats of the projectile.*/
	get stats() {return this.#stats;}

	/**The ability triggered upon collision or destruction.*/
	get onHit() {
		//console.debug(this.#onHit);
		return this.#onHit;
	}

	/**Sets the on-hit ability.*/
	set onHit(ability) {
		if (!(ability instanceof Ability)) {
			throw new TypeError("onHit must be an instance of Ability");
		}
		this.#onHit = ability;
	}

	/**The current position of the `Projectile` element in game coordinates as [`x`, `y`].*/
	get elementPosition() {return Game.instance.gamePosition(this.element);}

	set elementPosition(newCords) {
		if (!Array.isArray(newCords) || newCords.length !== 2 ||
			typeof newCords[0] !== "number" || typeof newCords[1] !== "number") {
			throw new TypeError("newCords must be an array of two numbers [x, y]");
		}
		this.position = newCords;
		newCords = newCords.map(cord => Game.instance.size / 2 + cord);
		this.style.left = `${newCords[0]}px`;
		this.style.top = `${newCords[1]}px`;
	}
	/**
	 * @returns True if the projectile is out of game bounds.
	 */
	get isOutOfBounds() {
		return (
			this.position[0] < Game.instance.borderCords.left ||
			this.position[0] > Game.instance.borderCords.right ||
			this.position[1] < Game.instance.borderCords.top ||
			this.position[1] > Game.instance.borderCords.bottom
		);
	}
	//#endregion
	/**Updates the projectile's position based on its target and speed.*/
	updatePosition() {
		const { speed, drag } = this.#stats;
		let directionVector = [0, 0];

		switch (this.target.type) {
			case "direction":
				directionVector = Game.directions.object[this.target.data];
				break;
			case "point":
			case "entity":
				const targetPos = this.target.type === "point" ? this.target.data : this.target.data.position;
				const dx = targetPos[0] - this.position[0];
				const dy = targetPos[1] - this.position[1];
				const magnitude = Math.sqrt(dx ** 2 + dy ** 2) || 1;
				directionVector = [dx / magnitude, dy / magnitude];
				break;
			default:
				console.warn("Invalid target type");
		}

		speed.value -= drag / 60;

		this.position = this.position.map((cord, index) => {
			return cord + (directionVector[index] * speed);
		});
		this.elementPosition = this.position;

		if (this.checkCollision() || this.isOutOfBounds || this.#stats.hp.value === 0) {
			this.destroy();
		}
	}
	/** Checks for collisions with other entities.
	 * @returns {boolean} True if a collision occurs, otherwise false.
	 */
	checkCollision(entity = Entity.nonEntity) {
		const position = this.elementPosition;

		// Check collision with a single entity
		const hasCollided = (target) => {
			const distance = target.getDistanceToPoint(position);
			const collisionThreshold =
				(this.element.offsetWidth + this.element.offsetHeight) / 4 +
				(target.size ? Math.min(...target.size) / 2 : 0);
			return distance <= collisionThreshold;
		};

		if (Entity.isEntity(entity)) {
			if (hasCollided(entity)) {
				console.debug(`Projectile hit ${entity.id}`);
				return true;
			}
		}

		else if (entity === Entity.nonEntity) {
			for (const target of Game.instance.entities) {
				if (target === Entity.nonEntity || target === this.owner) continue;
				if (hasCollided(target)) {
					console.debug(`Projectile hit ${target.id}`);
					return true;
				}
			}
		}
		else throw new TypeError("invalid entity");
		
		return false;
	}
	

	/**Destroys the projectile, removing it from the game and triggering its on-hit ability.*/
	destroy() {
		clearInterval(this.moveInterval);
		delete Projectile.activeProjectiles[Projectile.activeProjectiles.indexOf(this)]
		if (this.onHit) {
			this.onHit.use(this, this.position);
		}
		Game.instance.window.removeChild(this.element);
	}
}

/** Handles the spawning of projectiles. */
class Weapon {
	#name;
	#handler;
	/** The entity that uses this weapon.
	 * @type {Entity}
	 */
	#owner;

	/** Handles the spawning of projectiles.
	 * @param {string} name - The name of the weapon.
	 * @param {Function} projectileConstructor - The function that will construct a projectile.
	 */
	constructor(name, projectileConstructor) {
		this.#name = name;
		this.#handler = projectileConstructor;
	}

	//#region Getters and Setters
	/** Gets the name of the weapon.
	 * @returns {string} The name of the weapon.
	 */
	get name() {return this.#name;}

	/** Gets the owner of the weapon.
	 * @returns {Entity} The entity that owns the weapon.
	 */
	get owner() {return this.#owner;}

	/** Sets the owner of the weapon.
	 * @param {Entity} newOwner - The new owner of the `weapon`.
	 * @throws `TypeError`: If the new owner is not an instance of `Entity` or is `Entity.nonEntity`.
	 */
	set owner(newOwner) {
		if (!(newOwner instanceof Entity) || newOwner === Entity.nonEntity)
			throw new TypeError("A weapon can only be owned by an entity.");

		this.#owner = newOwner;
	}
	//#endregion

	/**Uses the `weapon` by calling its `Projectile` handler.*/
	use() {this.#handler(this)}

	//#region static functions
	/** the default `weapon`
	 * @param {Entity} owner - the owner of the `weapon`
	 * @returns a basic `weapon`
	 */
	static defaultWeapon(owner){
		const weapon = new Weapon("gun", 
			/**
			 * @param {Weapon} weapon 
			 * @return {Projectile}
			 */
			(weapon) => new Projectile(
				weapon.owner, 
				Projectile.defaultStats, 
				weapon.owner.position,
				{type:"direction", data: weapon.owner.facing}))
		weapon.owner = owner
		return weapon
	}
}

/** the controler of a NPC */
class AI {
	/** List of available AI types.
	 * @type {AIType[]}
	 * @static
	 */
	static types = ["none", "random", "aggressive", "scared", "chase", "flee", "wander", "patrol", "player"];

	/** A placeholder AI instance representing "no AI."
	 * @type {AI}
	 * @static
	 */
	static noAI = new AI("none");

	#entity = Entity.nonEntity;
	#type;
	#behavior = AI.getDefaultBehavior();

	/** Returns the default behavior settings for AI.
	 * @returns {AIBehavior} The default behavior object.
	 * @static
	 */
	static getDefaultBehavior() {
		return {
			agro: 50,
			fear: 0,
			priority: { 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 0 },
			randomFunction: undefined,
			patrolPoints: [[0, 0], [0, 0]],
			targeting: Player.instance,
		};
	}

	/**
	 * @param {AIType} type - The type of AI (must be in `AI.types`).
	 * @param {AIBehavior} [behaviorData] - Custom behavior data for the AI.
	 * @throws {Error} If the type is invalid.
	 */
	constructor(type, behaviorData) {
		const ai = this
		if (!AI.types.includes(type)) throw new Error("Invalid AI type");
		this.behaviorData = behaviorData || AI.getDefaultBehavior();
		if (type !== "player") {
			setTimeout(() => ai.type = type, 100);
		} else {
			this.setupPlayer(behaviorData?.movement);
		}
	}

	//#region Behavior Setups

	/** Sets up random behavior logic. Placeholder for now. */
	setupRandom() {

	}

	/** Sets up aggressive behavior, calculating agro level based on behavior data. */
	setupAggressive() {
		if (!this.behaviorData) {
			console.warn(`${this.#entity?.id || "Unknown Entity"}'s AI has no behavior data`);
			return;
		}
		const { range, agro } = this.behaviorData;
		this.#behavior.agro = this.calculateValue(range) + this.calculateValue(agro);
	}

	/** Sets up fleeing behavior, calculating fear level based on behavior data. */
	setupFlee() {
		const { range, fear } = this.behaviorData;
		this.#behavior.fear = this.calculateValue(range) + this.calculateValue(fear);
	}

	/** Sets up wandering behavior logic. Placeholder for now. */
	setupWander() {

	}

	/** Sets up player behavior using provided movement data.
	 * @param {Object} movementData - Movement-related behavior data for the player.
	 */
	setupPlayer(movementData) {this.#behavior.moves = movementData;}

	/** Calculates the value of a behavior property, handling functions and defaults.
	 * @param {any} value - The property value (could be a function or literal).
	 * @returns {number} The computed value.
	 */
	calculateValue(value) {return typeof value === "function" ? value(this.#entity) : value || 0;}

	//#endregion

	//#region Properties

	/** Gets the entity associated with this AI.
	 * @returns {Entity} The associated entity.
	 */
	get entity() {return this.#entity;}

	/** Sets the entity associated with this AI.
	 * @param {Entity} entity - The entity to associate with this AI.
	 * @throws {TypeError} If the entity is not an instance of `Entity`.
	 */
	set entity(entity) {
		if (!(entity instanceof Entity)) throw new TypeError("Entity must be of type Entity");
		if (entity === Entity.nonEntity) return;

		this.#entity = entity;
		this.initializeBehavior();
	}

	/** Gets the type of AI.
	 * @returns {AIType} The AI type.
	 */
	get type() {return this.#type;}
	
	/** Sets the type of AI and initializes behavior.
	 * @param {AIType} newType - The new AI type (must be in `AI.types`).
	 * @throws {Error} If the type is invalid.
	 */
	set type(newType) {
		if (!AI.types.includes(newType)) throw new Error("Invalid AI type");
		this.#type = newType;

		if (this.#entity && this.#entity !== Entity.nonEntity) {
			this.initializeBehavior();
		}
	}

	/** Gets the behavior data, wrapped in a Proxy to prevent modification.
	 * @returns {Object} The AI's behavior data.
	 */
	get behavior() {
		return new Proxy(this.#behavior, {
			get: (target, prop) => target[prop],
			set: () => {
				throw new Error("Behavior data cannot be modified after AI creation");
			},
		});
	}
	//#endregion

	//#region Helper Methods

	/** Initializes the behavior setup for the current AI type. */
	initializeBehavior() {
		try{
		switch (this.#type) {
			case "none": break;
			case "random": this.setupRandom(); break;
			case "aggressive": this.setupAggressive(); break;
			case "chase": this.setupChase(); break;
			case "flee": this.setupFlee(); break;
			case "wander": this.setupWander(); break;
			case "patrol": this.setupPatrol(); break;
		}
		}
		catch(e){
		}
	}

	/** Calculates the direction to move toward a target position.
	 * @param {[number, number]} targetPosition - The target position as [x, y].
	 * @returns {[number, number]} Direction vector as [dx, dy].
	 */
	calculateDirection(targetPosition) {
		const [x1, y1] = this.#entity.position;
		const [x2, y2] = targetPosition;
		return [x2 - x1, y2 - y1].map((diff) => (diff > 0 ? 1 : diff < 0 ? -1 : 0));
	}

	/** Generates a random movement direction based on priorities.
	 * @returns {number[]} A random direction vector as [dx, dy].
	 */
	randomDirection() {
		const directions = Game.directions.list;
		const priority = this.#behavior.priority;
		const totalPriority = Object.values(priority).reduce((sum, val) => sum + val, 0);
		const rand = Math.random() * totalPriority;

		let cumulative = 0;
		for (const [key, value] of Object.entries(priority)) {
			cumulative += value;
			if (rand <= cumulative) {
				return Game.directions.list[parseInt(key) - 1];
			}
		}

		return [0, 0];
	}

	//#endregion

	//#region Control Toggles

	/** Starts the AI's active process, making it perform actions periodically. */
	start() {
		if (this.active) return;
		this.active = true;
		this.process = setInterval(() => this.#entity?.ComputerMove(), 200);
	}

	/** Stops the AI's active process. */
	stop() {
		if (!this.active) return;
		this.active = false;
		clearInterval(this.process);
	}

	//#endregion

	//#region movement
	direction(){
		const {entity, behaviorData} = this
		const {agro, fear, range, patrolPoints, targeting} = behaviorData
		const other = entity.closestEntity
		if (debug) {
		console.debug(
			`
			---------------taget---------------\n
			${other}
			`)
		}
		if(!Entity.isEntity(other)) throw new Error("invalid target");
		
		let direction = [0,0]
		switch (this.type) {
			case "aggressive":
				if(entity.getDistanceToEntity(other) <= agro + range)
					direction = this.calculateDirection(other.position)
				else direction = this.randomDirection()
				break;
			case "random": direction = this.randomDirection(); break
			case "scared":
				if(entity.getDistanceToEntity(other) <= fear + range)
					direction = this.calculateDirection(other.position).map(cord => -cord)
				else direction = this.randomDirection()
				break;
			case "chase":
				direction = this.calculateDirection(Entity.isEntity(targeting) ? targeting.position : other.position); break
			case "flee":
				direction = this.calculateDirection(Entity.isEntity(targeting) ? targeting.position : other.position).map(cord => -cord); break
			case "patrol":
			case "none":
			case "player":
			default:break;
		}
		return direction
	}
	//#endregion
}

class Game {
	static placeholder = new Game("placeholder") // domie instance
	/**@type {Game} */
	static instance = false
	static Active = false
	static get directions() {return {
		list:[
		[0, -1], [1, 0], [0, 1], [-1, 0], // Cardinal directions
		[1, 1], [-1, -1], [-1, 1], [1, -1], // Diagonal directions
		[0, 0], // No movement
		],
		object:{
			// Cardinal
			left:     [-1, 0],     right: [ 1, 0], // horizontal
			  up:     [ 0,-1],      down: [ 0, 1], // vertical
			// Diaganal
			  upLeft: [-1,-1],   upRight: [ 1,-1], // top diaganal
			downLeft: [-1, 1], downRight: [ 1, 1], // buttum diaganal
			// None
			none:[0,0]
		},}
	}
	static storage = {}
	SCORE_PER_KILL = 10
	get scoreMulty(){return Math.round(waveMulti(1, 0, -10))}
	#id_timeouts = 0
	#size = 0
	#entities
	#wave = 0
	usedNames = []
	constructor(status = 0, finisEvent = () => {}) {
		if(Game.instance) return Game.instance
		if(status != 0) return console.log("Game: placeholder");
		console.log("starting game");
		Game.instance = this
		const window = document.getElementById("main");
		let rewardElement = document.getElementById("rewards")
		if (!window) throw new Error("there is no main element")
		if (!(rewardElement instanceof HTMLDivElement)) {
			const game = this
			rewardElement = Game.addElementFromPreset("rewardElement").then((
				value => {return value}), 
				(reason) => {throw new Error(reason)},
			)
		}
		this.window = window
		this.rewardElement = rewardElement
		this.style = this.window.style;
		this.#entities = [Entity.nonEntity];
		this.resize(true)

		// Style the game area
		// geting zero
		Game.Active = true
		if(typeof finisEvent == "function") finisEvent("ok")
	}
	//#region game stats
	get size() {return this.#size;}
	get zero() {
		if (!this.window) {
			console.log(this);
			
			throw new Error("window is not set")
		}
		return [this.#size/2-25, this.size/2-25];}
	get borderCords() {
		const cords = this.zero[0]
		return {
			left: -cords,
			right: cords,
			top: -cords,
			bottom: cords,
		};
	}
	get minSize(){return this.#size / 100}
	get maxSize(){return this.#size / 4}
	get wave(){return this.#wave}
	getNamedEntity(id){return this.#entities.find(entity => entity.id === id)}
	getUnusedId(){
		const TIME_OUT = 100
		const POOL_RANGE = 255
		let id = 0
		let i = 0
		while(this.usedNames.includes(id)){
			i++
			if(i >= TIME_OUT) this.#id_timeouts++
			id = Math.round(Math.random() * POOL_RANGE * (this.#id_timeouts + 1))
		}
		this.usedNames.push(id)
		return id
	}
	gamePosition(html_element) {
		let element = HTMLElement.prototype
		if(typeof html_element === "string" || typeof html_element === "number")
			element = document.getElementById(html_element);
		else element = html_element
		if(element === HTMLElement.prototype || !element) {
			throw new TypeError(`element ${html_element} is NULL`)
		}
		const htmlCords = [element.offsetLeft, element.offsetTop];
	
		// Adjust for the game window position relative to the document
		const gameCords = this.gamePositionFromCords(htmlCords)
		
		return gameCords;
	}
	/**
	 * @param {[Number, Number]} cords 
	 * @param {Boolean} fromSpawn 
	 * @returns {[Number, Number]}
	 */
	gamePositionFromCords(cords, fromSpawn = false){
		cords = this.zero.map((cord, index)=>cords[index] - cord)
		if(fromSpawn)console.log(cords);
		return cords
	}
	resize(initial = false) {
		const parent = this.window.parentElement
		this.#size = Math.round(Math.min(parent.offsetWidth, parent.offsetHeight) * 0.8);
		if(this.#size%2) this.#size++
		this.style.width = `${this.#size}px`;
		this.style.height = `${this.#size}px`;
		if(!initial)
		this.#entities.forEach(entity => {
			entity.checkBounds()
		});
	}
	//#endregion

	//#region game entities
	get entities() {return [...this.#entities.values()]}
	addEntity(entity) {
		if (!(entity instanceof Entity)) throw new Error("Only Entity instances can be added.");
		this.#entities.push(entity);
	}
	romoveEntity(id){
		if(typeof id != "string" && typeof id != "number"){throw new TypeError("invalid id")}
		if(![...this.#entities.map(entity => entity.id)].includes(id)) throw new Error(`no entity that has the id ${id}`);
		this.#entities = [...this.#entities.filter(entity => entity.id != id)]
	}
	/**
	 * @param {string} presetName 
	 * @param {string} jsonFile 
	 * @param {JSONEntityData} modifications
	 */
	async spawnEntityFromPreset(presetName, modifications = {}, jsonFile = "extraData.json"){
		if(validatePath(jsonFile, ".json")[0]) throw new TypeError("invalid jsonFile");
		const response = await fetch(jsonFile)
		if(!response.ok) throw new Error(`Failed to load abilities: ${response.statusText}`)
		/**@type {JSONData} */
		const JSONData = await response.json()
		const preset = JSONData.entityPresets[presetName]
		const {html:HTMLData, children} = preset.visual
		let {stats: statsData, abilities: abilityNames, ai: aiData} = preset.data
		const stats = {...statsData, ...modifications.stats}
		const abilities = []
		for (const name of new Set(...abilityNames, ...modifications.abilities)) {
			if(Ability.abilityNames.includes(name))
			abilities.push(Ability.getAbility(name))
		}
		//#region element creation
		const element = document.createElement(HTMLData.type)
		styleElement(element, HTMLData)
		for (const child of children) {
			const childElement = document.createElement(child.type)
			styleElement(childElement, child)
			element.appendChild(childElement)
		}
		this.window.appendChild(element)
		//#endregion
		//#region entity creation
		const ai = new AI(aiData.aiType, {...AI.getDefaultBehavior(), ...(aiData.behavior | {})})
		let entity
		switch (preset.entityType) {
			case "Player":entity = new Player({stats, });break
			case "none":entity = new Entity(element.id, {stats});break;
			case "AI":entity = new NPC(element.id, ai, {stats})
		}
		this.addEntity
		//#endregion
	}
	spawnEntity(location = [0, 0], data = { ai: new AI("none", {range:50}), health: 100 }) {
		if(this.gameState != "actife") return
		// Convert the given location to game coordinates

		const position = this.gamePositionFromCords(location, true).map(cord => -cord)
		
		const name = this.getUnusedId()

		// Create a new HTML element for the entity
		const element = document.createElement("div")
		element.id = name;
		element.classList.add("entity");
	
		// Append the entity to the game window
		this.window.appendChild(element);
	
		// Set the entity's initial position using CSS
		element.style.left = `${position[0]}px`;
		element.style.top = `${position[1]}px`;
	
		// Create the corresponding NPC object
		const entity = new NPC(name, data.ai, data);
		entity.addEvent(
			"health:0",
			entity => {
				if(entity instanceof NPC){
				const GAME = Game.instance
				Player.userData.score += GAME.SCORE_PER_KILL * GAME.scoreMulty
				entity.ai.stop()
				entity.destroy()}
			}
		)
		entity.addEvent("collided", (entity, other) => {
			if(!(other instanceof Player)) return
			other.damage(entity.healthLevel*0.25, {})
			entity.destroy()
		})
		entity.ai.start()
		return entity
	}
	
	checkColision() {
	const processed = new Set();

	for (const entity of this.#entities) {
		if (!entity || entity === Entity.nonEntity) continue;
		
		const thisBorder = entity.borderCords;
		processed.add(entity);

		for (const other of this.#entities) {
			if (
				processed.has(other) ||
				!other ||
				entity === other ||
				other === Entity.nonEntity
			) continue;

			const otherBorder = other.borderCords;

			const isColliding =
				thisBorder.right >= otherBorder.left &&
				thisBorder.left <= otherBorder.right &&
				thisBorder.bottom >= otherBorder.top &&
				thisBorder.top <= otherBorder.bottom;

			if (isColliding) {
				entity.triggerEvent("collided", other);
				other.triggerEvent("collided", entity); // optioneel als je bidirectioneel wilt
			}
		}
	}
}

	//#endregion

	//#region window
	addElement(element = {tag: "div", id: undefined, class: undefined, style: undefined}){
		if(typeof element != "object") throw new TypeError("element needs to be a object")
		const newElement = document.createElement(element.tag)
		for(const key in element){
			if(["tag", "class", "style"].includes(key)) continue
			newElement[key] = element[key]
		}
		if(element.class) newElement.className = element.class
		if(element.style) {
			if(typeof element.style != "object") {throw new TypeError("")}
			for(const styleProperty in element.style){
				newElement.style[styleProperty] = element.style[styleProperty]
			}
		}
		this.window.appendChild(newElement)
	}
	/**
	 * @param {string} jsonFile 
	 * @param {string} presetName 
	 * @returns 
	 */
	static async addElementFromPreset(presetName, jsonFile = "extraData.json"){
		if(typeof jsonFile != "string" | !jsonFile.includes(".json")) throw new TypeError("json file needs to be a json file")
		const response = await fetch(jsonFile)
		if(!response.ok) throw new Error(`a error acourd wile fecing the file: ${response.statusText}`)
		/** @type {JSONData} */
		const jsonData = await response.json()
		let preset
		let visual
		try {
			preset = jsonData.htmlPresets[presetName]
			visual = preset.visual
			
		} catch (error) {
			console.log(jsonData);
			
			throw new Error(`preset ${presetName} dusent exist...`)
		}
		/** @type {HTMLElement} */
		const element = document.createElement(visual.type)
		styleElement(element, visual)
		if(preset.children){
			for (const child of preset.children){
				const childElement = document.createElement(child.type)
				styleElement(childElement, child)
				element.appendChild(childElement)
			}
		}
		return element
	}
	
	//#endregion
	//#region game state
	async loadGameHome(){
		const TIME_OUT = 5
		const element = this.window
		let success = false
		let retryCount = 1
		while (!success){
			if(retryCount > TIME_OUT) {
			console.error("Loading the game failed due to too many exceptions");
			element.innerHTML = `
				<h1 style="color:red">Het was niet gelukt om het spel te laden</h1><br>
				<button onclick="history.back()">ga terug</button>
			`
			return
			}
			
			try {
				const [playerElement, titelElement, controleSetings, startButton] = await Promise.all([
					Game.addElementFromPreset("player"), 
					Game.addElementFromPreset("titel"),
					Game.addElementFromPreset("setings"),
					Game.addElementFromPreset("startButton")
				])
				this.window.appendChild(playerElement)
				this.window.appendChild(titelElement)
				this.window.appendChild(controleSetings)
				this.window.appendChild(startButton)
				const playerStyle = playerElement.style
				playerStyle.top = playerStyle.left = "50%"
				const controles = {all: controleSetings.querySelectorAll("input")}
				controles.all.forEach(element=>{
					labelInput(element)
					controles[element.id] = element
				})
				delete controles.all
				startButton.addEventListener("click", () => Game.instance.start())
				success = true
			} catch (error) {
				console.error(error, `this was atempt ${retryCount}`);
				retryCount++
		}}


	}
	async start(){
		this.gameState = "actife"
		this.window.innerHTML = ""

		this.window.appendChild(await Game.addElementFromPreset("player"))
		new Player()
		this.#entities = this.#entities.filter(entity => Entity.isEntity(entity))
		this.startTime = Date.now()
		this.waveTimers = []
		this.nextWave()
		Player.setupKeyListeners()
	}
	async nextWave(){
		Player.instance.cords = [0,0]
		this.#wave++
		this.waveTimers.push(Date.now())
		if(this.wave === 1) this.spawnEntity([100,100], {ai: new AI("none", {}), health:1})
		else{
			for (let spawnNum = 0; spawnNum < this.wave; spawnNum++) {
				this.spawnEntity(
					this.getValidSpawn(), 
					{
					ai: new AI(AI.types[random(5,1)], {...AI.getDefaultBehavior(), range: 50}),
					health: 10 + waveMulti(1.5, 0, 2)
				})
			}
		}
		this.waveInterval = setInterval(Game.waveLogic)
	}
	static waveLogic(){
		const GAME = Game.instance
		const player = Player.instance

		if(GAME.entities.length <= 1 && player.healthLevel) {
			clearInterval(GAME.waveInterval)
			player.data.health.value += player.data.health *0.2
			GAME.nextWave()
		}
		else if(!player.healthLevel) {
			clearInterval(GAME.waveInterval)
			GAME.handleGameOver()
		}
	}
	reward(){
		const element = this.rewardElement
		const posAbilities = Ability.abilityNames.filter(value => !Player.userData.rewards.ability.includes(value))
		const statUpgrades = 0
	}
	handleGameOver() {
	function shrinkAndDelete(element) {
		const timeout = setTimeout(() => element.remove(), 1000);
		element.addEventListener("transitionend", e => {
			clearTimeout(timeout);
			e.target.remove();
		}, { once: true });

		element.style.transition = "width 0.5s, height 0.5s, opacity 0.5s";
		element.style.width = "0px";
		element.style.height = "0px";
		element.style.opacity = "0";
	}

	Array.from(this.window.children).forEach(shrinkAndDelete);

	this.entities.forEach(entity => {
		if (typeof entity.destroy === "function") entity.destroy(true);
	});

	// Toon alleen de titel
	this.window.innerHTML = `
	<h1 class="gameOver">Game Over</h1>
	<p class="score">Score: <span>${-Player.userData.score}P</span></p>
	`;

	const output = document.getElementById("output");
	if (output) output.style.display = "none";
}

	getValidSpawn(minDistance = 150) {
		// Generate random spawn coordinates
		function genSpawn() {
			return [
				Math.round(Math.random() * gameSize),
				Math.round(Math.random() * gameSize),
			];
		}
	
		// Check if the generated spawn is valid based on distance
		function isValidSpawn() {
			const difX = Math.abs(playerCords[0] - cords[0]);
			const difY = Math.abs(playerCords[1] - cords[1]);
			return difX + difY >= minDistance;
		}
	
		// Player and game details
		const playerCords = Player.instance.cords;
		const gameSize = this.#size;
		let cords = genSpawn();
	
		// Keep generating new coordinates until valid
		while (!isValidSpawn()) {
			cords = genSpawn();
		}
	
		return cords;
	}
	
	//#endregion
}
/**the hub namespace warmee je hub elementen kunt beheren*/
class Hub {
	/** @type {HTMLElement|null} */
	static #self = null;

	/**
	 * Geeft het centrale DOM-element waarin HUD-elementen geplaatst worden.
	 * Cachet het resultaat na eerste toegang.
	 * 
	 * @returns {HTMLElement} Het `#hub` DOM-element.
	 * @throws {ReferenceError} Als het element niet bestaat.
	 */
	static get section() {
		if (Hub.#self) return Hub.#self;

		const element = document.getElementById("hub");
		if (!(element instanceof HTMLElement) || !isSet(element)) {
			throw new ReferenceError('Element with ID "hub" not found in the DOM.');
		}

		Hub.#self = element;
		return element;
	}

	/**
	 * Retourneert alle kinderen van het `#hub`-element.
	 * @returns {HTMLCollection}
	 */
	static get children() {
		return Hub.section.children;
	}

	/**
	 * Voegt een DOM-element toe aan de `#hub`-container.
	 * @param {HTMLElement} element - Het element om toe te voegen.
	 * @throws {TypeError} Als het argument geen HTMLElement is.
	 */
	static addElement(element) {
		if (!(element instanceof HTMLElement)) {
			throw new TypeError("addElement: argument is not a valid HTMLElement.");
		}
		Hub.section.appendChild(element);
	}
}


/** Represents an ability with cooldown mechanics and dynamic registration. */
class Ability {
	/**Registry of all abilities for reconstruction.
	 * @type {Object<string, { action: abilityHanbler, constructor: abilityInitelizer, data: Object<string, any>}>}
	 */
	static #abilities = {}; 
	/** Time since the ability was last used (in ms) */#lastUse = 0; 
	 /** Time between uses (in ms)*/#cooldownTime = 100;
	/** Cooldown reductions 
	 * @type {{type: "min" | "div" | "per", value: number}[]}
	 * */
	#cooldownReductions = [];
	#minTime = 100; // Minimum cooldown time (in ms)
	#set = false; // If true, disables changes to the private properties
	#action; // The ability action handler
	/** Extra data like level or stats
	* @type {Object<string, any>}
	*/
	data;
	/** descrijves the ability
	 * @type {string | descriptor}
	 */
	#description

	/**
	 * @param {string} name - The unique name of the ability.
	 * @param {abilityHanbler} actionHandler - The function executed when the ability is used.
	 * @param {abilityInitelizer} [initializer=() => {}] - A function to initialize ability properties.
	 * @param {Object} [data={}] - Additional data such as level, stats, or metadata.
	 * @throws {TypeError} If `name` is not a string, or `actionHandler` or `initializer` are not functions.
	 */
	constructor(name, actionHandler, initializer = () => {}, ...{...data}) {
		if (typeof name !== "string") throw new TypeError("Ability name must be a string");
		if (typeof actionHandler !== "function") throw new TypeError("Action handler must be a function");
		if (typeof initializer !== "function") throw new TypeError("Initializer must be a function");

		this.name = name;
		this.#action = actionHandler;
		this.initializer = initializer;
		this.data = data
		this.initializer(this);
		//#region setup logic
		if(data.description){
			const {description} = data
			if(typeof description !== "string" && typeof description != "function") throw new TypeError("invalid description");
			this.#description = description
			delete data.description
		}
		//#endregion

		if (!data.loodedAbility) {
			Ability.addAbility(name, actionHandler, initializer, data);
		}
		this.#set = true;
	}

	//#region Cooldown handlers
	/** Gets the calculated cooldown time considering reductions.
	 * @returns {number} The effective cooldown time in milliseconds.
	 */
	get cooldownTime() {
		let cooldown = this.#cooldownTime;
		const cooldownReductions = [...this.#cooldownReductions, ...(this.owner?.data?.cooldownReductions || [])]
			.sort((a, b) => {
				const priority = { min: 1, div: 2, per: 3 };
				let result = priority[b.type] - priority[a.type];
				if (result !== 0) return result;
				return a.value - b.value;
			});
		for (const reduction of cooldownReductions) {
			const { type, value } = reduction;
			if (!type) continue;
			if (!["min", "div", "per"].includes(type)) throw new Error(`Invalid reduction type: ${type}`);
			if (!value && value !== 0) throw new Error(`Invalid reduction value: ${value}`);
			switch (type) {
				case "min": cooldown -= value; break;
				case "div": cooldown /= value; break;
				case "per": cooldown *= (1 - value / 100); break;
			}
		}
		return Math.max(Math.round(cooldown), this.#minTime);
	}

	/** Sets a new cooldown time.
	 * @param {number} newTime - The new cooldown time in milliseconds.
	 * @throws {Error} If the cooldown time is being modified after initialization.
	 */
	set cooldownTime(newTime) {
		if (this.#set) throw new Error("cooldownTime cannot be changed after the ability is initialized.");
		if (typeof newTime !== "number") throw new TypeError("cooldownTime must be a number");
		if (newTime <= 0) throw new Error("Cooldown time must be greater than 0");
		this.#cooldownTime = newTime;
	}

	get rawCooldownTime() {return this.#cooldownTime}

	/** Checks if the ability is currently on cooldown.
	 * @returns {boolean} True if the ability is on cooldown, otherwise false.
	 */
	get onCooldown() {
		return (this.#lastUse + this.cooldownTime) > Date.now();
	}
	//#endregion

	//#region description
	get description(){
		if(typeof this.#description != "function") return this.#description
		return this.#description()
	}
	//#endregion
	/** Uses the ability if it's not on cooldown.
	 * @param {...any} args - Arguments passed to the action handler.
	 */
	use(...args) {
		if (!this.onCooldown) {
			this.#action(this, ...args);
			this.#lastUse = Date.now();
		}
	}
	/** Converts the ability object to a JSON-compatible AbilityPreset format.
	 * 
	 * @returns {AbilityPreset} The serialized ability preset.
	 */
	toJson() {
		return {
			// The name of the ability
			name: this.name,
			
			// The cooldown time of the ability
			cooldownTime: this.#cooldownTime,
			
			// Shallow copy of the ability data
			data: { ...this.data },

			// Description, converted to string or object based on type
			description: typeof this.#description === "string" 
				? this.#description 
				: { 
					code: this.#description.toString(), 
					params: this.#description.arguments 
				},
			
			// Logic block containing the call and initialize functions
			logic: {
				// Call function details
				call: {
					type: "function",
					params: this.#action?.arguments || [], // Safeguard against undefined
					code: this.#action?.toString() || ""   // Safeguard against undefined
				},
				// Initialize function details
				initialize: {
					type: "function",
					params: this.initializer?.arguments || [], // Safeguard against undefined
					code: this.initializer?.toString() || ""   // Safeguard against undefined
				}
			}
		};
	}


	//#region Static functions
	/** Registers a new ability in the registry.
	 * @param {string} name - The unique name of the ability.
	 * @param {abilityHanbler} actionHandler - The function executed when the ability is used.
	 * @param {abilityInitelizer} initializer - A function to initialize the ability.
	 * @param {Object} data - Additional data for the ability.
	 */
	static addAbility(name, actionHandler, initializer, data) {
		if(data.loodedAbility) return
		if (Ability.#abilities[name]) {
			console.warn(`Ability "${name}" is already registered. NOT Overwriting.`);
			return
		}
		Ability.#abilities[name] = { action: actionHandler, constructor: initializer, data: data};
	}

	/** Retrieves an ability from the registry and creates a new instance.
	 * @param {string} name - The name of the ability to retrieve.
	 * @param {Object} [data={}] - Additional data for the ability instance.
	 * @returns {Ability} A new ability instance.
	 * @throws {Error} If the ability is not found in the registry.
	 */
	static getAbility(name, data = {}) {
		if (!Ability.#abilities[name]) throw new Error(`Ability "${name}" not found. Available abilities: ${Object.keys(Ability.#abilities).join(", ")}`);
		if (!Ability.#abilities[name]) throw new Error(`Ability "${name}" not found. Available abilities: ${Object.keys(Ability.#abilities).join(", ")}`);
		const { action, constructor, data: abilityData } = Ability.#abilities[name];
		return new Ability(name, action, constructor, {...abilityData, ...data, loodedAbility: true});
	}

	static get abilityNames(){return Object.keys(this.#abilities)}
	/** Loads abilities from a JSON file.
	 * @param {string} source - The URL or path to the JSON file.
	 * @returns {Promise<void>} Resolves once the abilities are loaded and registered.
	 * @throws {TypeError} If the source is not a string or does not end with `.json`.
	 * @throws {Error} If the fetch request fails or the JSON is malformed.
	 */
	static async loadAbilities(source = "extraData.json") {
		if (typeof source !== "string") throw new TypeError("Source should be a string");
		if (!source.endsWith(".json")) throw new TypeError("Source should be a JSON file");
	
		const response = await fetch(source);
		if (!response.ok) throw new Error(`Failed to load abilities: ${response.statusText}`);
	
		/** @type {JSONData} */
		const jsonData = await response.json();
	
		for (const name in jsonData.abilityPresets) {
			/** @type {AbilityPreset} */
			const abilityPreset = jsonData.abilityPresets[name];
	
			const { data, logic } = abilityPreset;
			const { call: use, initialize } = logic;
			const { description } = use
			if (!containsAll(use, "code", "params")) {
				console.warn(`Failed to load the ability "${name}": Invalid call function`);
				continue;
			}
	
			try {
				// Dynamically evaluate the `code` string as a function
				const call = new Function(...Object.keys(use.params), use.code);
				const init = initialize ? new Function(...Object.keys(initialize.params), initialize.code) : undefined;
	
				Ability.addAbility(name, call, init, {...data, description: description || ""});
			} catch (err) {
				console.error(`Failed to load the ability "${name}": ${err.message}`);
			}
		}
	}
	
	static async saveAbilities(filename = "abilities_backup.json") {
		if (typeof filename !== "string") {
			throw new TypeError("Filename should be a string");
		}
		if (!filename.endsWith(".json")) {
			throw new TypeError("Filename should be a JSON file");
		}
	
		/** @type {Object<string, AbilityPreset>} */
		const data = {};
	
		// Iterate through all abilities and collect data
		for (const abilityName in Ability.#abilities) {
			/** @type {Ability} */
			const ability = Ability.getAbility[abilityName].toJson();
			if (!ability) continue;
			// Ensure the ability matches the AbilityPreset structure
			data[abilityName] = {
				name: ability.name,
				cooldownTime: ability.rawCooldownTime,
				data: ability.data,
				logic: logic
				// {
				//     call: {
				//         type: "function",
				//         description: ability.logic.call.description,
				//         params: ability.logic.call.params,
				//         code: ability.logic.call.code
				//     },
				//     initialize: {
				//         type: "function",
				//         description: ability.logic.initialize.description,
				//         params: ability.logic.initialize.params,
				//         code: ability.logic.initialize.code
				//     }
				// }
			};
			console.log(data[abilityName]);
			
		}
		if(!data) throw new Error("");
		console.log(data);
		
		try {
			// Create a JSON object with the collected data
			const JSONData = {
				abilityPresets: data
			};
	
			// Convert the JSON object to a string
			const jsonString = JSON.stringify(JSONData, null, 4); // Pretty-print JSON for readability
	
			// Create a Blob from the JSON string
			const blob = new Blob([jsonString], { type: "application/json" });
	
			// Create a temporary link element
			const link = document.createElement("a");
			link.href = URL.createObjectURL(blob);
			link.download = filename; // Set the filename for the download
	
			// Append the link to the document, click it, and then remove it
			document.body.appendChild(link);
			link.click();
			document.body.removeChild(link);
	
			console.log(`Abilities saved successfully to ${filename}.`);
		} catch (error) {
			console.error(`Error in saveAbilitiesToPC: ${error.message}`);
			throw error;
		}
	}
	
	
	//#endregion
}

class Stat {
	static get upgrades(){
		
		/**@typedef {{value: (rarity: Rarity) => number, minRarity: Rarity}} TypeData*/

		/**
		 * @type {Object<string, TypeData>}
		 */
		const types = {
			damagePlus: {value: (rarity) => random(5, 1) * rarityMulti(rarity)},
			healthPlus: {value: random(20, 10) * rarityMulti()},
			specialPointsPlus: {value: random(10, 5) * rarityMulti()},
			speedPlus: {value: random(10,5)},
			healthRegen: {value: random(3, 1), minRarity: "rare"},
			specialPointsRegen: {value: (rarity) => random(5, 1) * waveMulti(10, 1, getRarityValue(rarity) >= 3 ? -1 : -0.5)}
		}
		return {
			types: types,
		}
	}
	#name; #value; #min; #max; 
	/** A event function thats run when the value changes
	 * @type {Function}
	 */
	#onChange

	/**
	 * @param {string} name - The name of the stat.
	 * @param {number} [value=0] - The initial value of the stat.
	 * @param {number[]} [bounds=[NaN, NaN]] - An array containing max and min values.
	 * @param {{tracker: boolean, onChange: Function}} [data={}] - Additional configuration, including optional tracker setup.
	 * @throws `TypeError` If name is not a non-empty string.
	 * @throws `RangeError` If min is greater than max.
	 */
	constructor(name, value = 0, [max = NaN, min = NaN] = [], data = {}) {
		if (typeof name !== "string" || !name) {
			throw new TypeError("Stat name must be a non-empty string.");
		}
		if (typeof max === "number" && typeof min === "number" && min > max) {
			throw new RangeError("Minimum value cannot exceed the maximum value.");
		}
		this.#name = name;
		// value vars
		this.#value = value;

		this.#max = max;
		this.#min = min;

		this.data = data ;

		// Setup tracker if defined in the data
		if (data.tracker) {
			data.colors = { text: "white", background: ["#4DF527", "#000000"], ...data.colors };
			this.tracker = new Tracker(name, this, { colors: data.colors });
		}
		if (typeof data.onChange == "function"){this.#onChange = data.onChange}
	}
	//#region getters and setters
	/** Gets the name of the stat.
	 * @returns {string} The name of the stat.
	 */
	get name() {
		return this.#name;
	}
	//#region value
	/** Gets the current value of the stat.
	 * @returns {number} The stat value.
	 */
	get value() {return this.#value}

	/** Sets the value of the stat, ensuring it adheres to the defined min and max bounds.
	 * @param {number} newValue - The new value to set.
	 * @throws {TypeError} If the value is not a number.
	 */
	set value(newValue) {
		if (typeof newValue !== "number") {
			throw new TypeError("Value must be a number.");
		}
		if (!isNaN(this.#min) && newValue < this.#min) {
			newValue = this.#min;
		}
		if (!isNaN(this.#max) && newValue > this.#max) {
			newValue = this.#max;
		}
		this.#value = newValue;
		if (this.tracker instanceof Tracker) this.updateElement();
		if (this.#onChange) this.#onChange()
	}

	/** The minimum value for the stat.
	 * @returns {number} The minimum value.
	 */
	get min() {return this.#min}

	/**
	 * @param {number} newMin - The new minimum value.
	 * @throws {TypeError} If the minimum value is not a number.
	 * @throws {RangeError} If the new minimum exceeds the maximum value.
	 */
	set min(newMin) {
		if (typeof newMin !== "number") {
			throw new TypeError("Minimum value must be a number.");
		}
		if (!isNaN(this.#max) && newMin > this.#max) {
			throw new RangeError("Minimum value cannot exceed the maximum value.");
		}
		this.#min = newMin;
		if (this.#value < this.#min) {
			this.value = this.#min; // Revalidate value
		}
	}
	/** The maximum value for the stat.
	 * @returns {number} The maximum value.
	 */
	get max() { return this.#max;}

	/**
	 * @param {number} newMax - The new maximum value.
	 * @throws {TypeError} If the maximum value is not a number.
	 * @throws {RangeError} If the new maximum is less than the minimum value.
	 */
	set max(newMax) {
		if (typeof newMax !== "number") {
			throw new TypeError("Maximum value must be a number.");
		}
		if (!isNaN(this.#min) && newMax < this.#min) {
			throw new RangeError("Maximum value cannot be less than the minimum value.");
		}
		this.#max = newMax;
		if (this.#value > this.#max) {
			this.value = this.#max; // Revalidate value
		}
	}
	//#endregion
	/** The stat's level as a percentage of the range from min to max.
	 * @returns {number} The level percentage, or NaN if min or max is not set.
	 */
	get level() {
		if (isNaN(this.#min) || isNaN(this.#max)) return NaN;
		const range = this.#max - this.#min;
		return Math.round(((this.#value - this.#min) / range) * 100);
	}
	/** A event function thats run when the value changes */
	get onChange(){return this.#onChange}

	set onChange(handler){
		if(typeof handler != "function") throw new TypeError("invalid event function")
		this.#onChange = handler
	}
	//#endregion
	/** Gets the numeric value of the stat (used in arithmetic operations).
	 * @returns {number} The stat value.
	 */
	valueOf() {return this.value;}

}
class statStorage {
	#stats
	constructor(){}
}

class Tracker {
	static trackers = [];
	#element = document.createElement("div");
	#style = this.#element.style;
	// Modes: "cover" or "trans"
	#colors = { text: "white", background: ["#daa520", "#000000"], mode: "trans" };
	#tracking;

	/**
	 * @param {string|number} id - The unique identifier for the tracker element.
	 * @param {Stat|Ability} toTrack - The stat or ability object to track.
	 * @param {Object} data - Additional settings for the tracker.
	 * @param {Object} [data.colors] - Style configuration for the tracker.
	 * @param {string} [data.colors.text="white"] - Text color.
	 * @param {Array<string>} [data.colors.background=["#daa520", "#000000"]] - Background colors.
	 * @param {string} [data.colors.mode="trans"] - Display mode ("cover" or "trans").
	 * @throws {TypeError} If the `id` is not a string/number or `toTrack` is not an instance of Stat or Ability.
	 */
	constructor(id, toTrack, { ...data }) {
		// Validate id and target
		if (typeof id !== "string" && typeof id !== "number") {
			throw new TypeError("Invalid id");
		}
		if (!(toTrack instanceof Stat || toTrack instanceof Ability)) {
			throw new TypeError("Invalid target");
		}

		// Set up the element and add it to the Hub
		this.#element.id = id;
		this.#element.classList.add("tracker");
		Hub.addElement(this.#element);

		// Set the tracker target
		this.#tracking = toTrack;

		// Apply styles from data.colors if available
		if (data.colors) {
			const { text, background, mode } = data.colors;

			// Apply text color if specified
			if (text) {
				this.#element.style.color = text;
			}

			// Apply background color based on mode
			let updateFunction;
			let tracker = this;
			if (mode) {
				switch (mode) {
					case "trans": // Transparent mode
						this.#element.style.backgroundColor = background[0];
						const child = document.createElement("div");
						this.#element.appendChild(child);
						child.style.backgroundColor = background[1] + transparantsie(0);
						updateFunction = () => {
							tracker.trans();
						};
						break;
				}
			}
		}

		// Set up the inner HTML for the tracker
		this.#element.innerHTML = `
			<p id="${this.#tracking.name.toString() + "status"}" class="status">${this.#tracking.status}</p>
			<p>${this.#tracking.name}</p>
		`;
	}

	/**
	 * Updates the tracker element visually based on the current state of the tracked object.
	 */
	updateElement() {
		// Implementation for updating the tracker's display
	}
	static transparantsie(percentage = 100) {
		if (percentage < 0 || percentage > 100) {
			throw new RangeError("Percentage must be between 0 and 100");
		}
		let value = Math.round(255 * (1 - percentage / 100));
		return value.toString(16).padStart(2, "0").toUpperCase();
	}
}
//#endregion
//#endregion
//#region helper functions
/**
 * @param {string} filePath 
 * @param {string} fileExtention 
 * @returns {[Boolean, string]}
 */
function validatePath(filePath, fileExtention = ""){
	if(typeof filePath != "string") return [false, "file path is not a string"];
	if(!filePath.endsWith(fileExtention) && fileExtention) return [false, `invalide ${fileExtention} file`]
	return [true, "ok"]
}
function containsAll(object, ...args){
	if(typeof object != "object") return false
	const objectPropertys = Object.keys(object)
	for(const arg of args){
		if (!objectPropertys.includes(arg)) return false
	}
	return true
}
/** Generates a random integer between the specified range [min, max].
 * @param {number} [max=100] - The maximum value (inclusive).
 * @param {number} [min=0] - The minimum value (inclusive).
 * @returns {number} A random integer within the range [min, max].
 * @throws {TypeError} If min or max are not numbers.
 * @throws {RangeError} If min is greater than max.
 */
function random(max = 100, min = 0) {
	if (typeof min !== "number" || typeof max !== "number") {
		throw new TypeError("Both min and max should be numbers.");
	}
	if (min > max) {
		throw new RangeError("Min cannot be greater than max.");
	}
	
	const range = max - min + 1; // Include max in the range
	return Math.floor(Math.random() * range) + min;
}
/**
 * @param {number} luck 
 * @returns {Rarity}
 */
function getRarity(luck) {
	/**@type {Array<{name: Rarity, weight: number}>} */
	const rarities = [
		{ name: "common", weight: 500 - luck * 0.5 },
		{ name: "uncommon", weight: 300 + luck * 0.3 },
		{ name: "rare", weight: 150 + luck * 0.15 },
		{ name: "epic", weight: 40 + luck * 0.05 },
		{ name: "legendary", weight: 9 + luck * 0.02 },
		{ name: "godly", weight: Game.instance.wave >= 20 ? 1 + luck * 0.01 : 0}
	];
	const totalWeight = rarities.reduce((sum, rarity) => sum + rarity.weight, 0);
	const roll = random(totalWeight);

	let cumulative = 0;
	for (const rarity of rarities) {
		cumulative += rarity.weight;
		if (roll < cumulative) return rarity.name;
	}
	return "common";
}
function rarityGenerator(runs = 1, luck = 0){
	const result = {}
	for (let index = 0; index < runs; index++) {
		const loot = getRarity(luck)
		if(result[loot]) result[loot]++
		else result[loot] = 1
	}
	if(!result) throw new Error("");
	
	return result
}
/** Gets the numeric value of the rarity.
 * @param {Rarity} rarity 
 * @returns {number}
 */
function getRarityValue(rarity) {
	/** @type {Rarity[]} */
	const values = ["common", "uncommon", "rare", "epic", "legendary", "godly"];
	
	// Normalize the input to lowercase
	if (typeof rarity !== "string") {
		throw new TypeError(`Rarity must be a string, got ${typeof rarity}`);
	}
	rarity = rarity.toLowerCase();

	// Get the index or throw an error if not found
	const index = values.indexOf(rarity);
	if (index === -1) {
		throw new Error(`Invalid rarity: ${rarity}`);
	}

	return index;
}
/**
 * @param {Rarity} rarity 
 */
function rarityMulti(rarity = "common"){
	let number
	switch (rarity) {
		case "common":number = 1;break;
		case "uncommon":number = 2.5; break;
		case "rare":number = 5; break;
		case "epic":number = 7.5; break
		case "legendary":number = 10; break
		case "godly": number = 20; break
		default: throw new TypeError("invalid rarity")
	}
	return number * waveMulti()
}
/**
 * @param {number} waveInterval - how many waves have to pas to give one point
 * @param {number} start - the starting point
 * @param {number} clip - clips the growth of the number
 * @returns {number}
 */
function waveMulti(waveInterval = 5, start = 1, clip = 1) {
	const increments = Math.floor(Game.instance.wave / waveInterval); // Total intervals
	const cappedIncrements = Math.min(increments, 100 / clip); // Account for erosion cap
	const effectiveGrowth = cappedIncrements * (100 - ((cappedIncrements - 1) * clip / 2)) / 100;
	console.debug(`
		div:${waveInterval}, 
		start:${start}, 
		clip:${clip},
		wave:${Game.instance.wave}
		increments:${increments}, 
		cappedIncrements:${cappedIncrements}, 
		effectiveGrowth${effectiveGrowth}`)
	return start + effectiveGrowth;
}

/**
 * @param {HTMLElement} element 
 * @param {HTMLData} data 
 */
function styleElement(element, data){
	const {style: styles, id, size, position, text, label, attributes, content} = data
	const elementStyle = element.style
	let extra = []
	if(isSet(id)) element.id = id
	if(isSet(styles)) Object.assign(elementStyle, styles);
	if (isSet(attributes) && typeof attributes === "object") {
		for (const [attr, value] of Object.entries(attributes)) {
			if (isSet(value)) {
				element.setAttribute(attr, value);
			}
		}
	}
	if(size){
		const [width, height, unit] = size
		elementStyle.width = `${width}${unit}`
		elementStyle.height = `${height}${unit}`
	}
	if(position){
		const dirs = ["top", "bottom", "left", "right"]
		console.debug(`${data.name ?? data.id ?? data.type}'s position: ${Object.entries(position)}`);
		
		const {top, left, bottom, right: right, z, types} = position
		if(typeof types === "string"){
			
			if(isSet(top))    elementStyle.top    = `${top}${types}`
			if(isSet(bottom)) elementStyle.bottom = `${bottom}${types}`
			if(isSet(left))   elementStyle.left   = `${left}${types}`
			if(isSet(right))  elementStyle.right  = `${right}${types}`
		}
		else if(typeof types === "object"){
			if(!types["default"]) throw new Error("the default unit is not defined");
			for (let index = 0; index < dirs.length; index++) {
				const dir = dirs[index];
				if(position[dir]) elementStyle[dir] = `${position[dir]}${types[dir] | types["default"]}`
			}
		}
		else throw new Error("recived a invalid position element");
		if(z) elementStyle.zIndex = z
		console.debug(dirs.map(key => {
			const value = position[key]
			return `${key}: ${isSet(value)}`
		}))
	}
	if(isSet(text)) element.innerText = text;

	if (Array.isArray(content)) {
		if (debug) console.debug(`---------------children of ${data.name}---------------`)
		for (const childData of content) {
			console.debug(`-----${childData.name || childData.id}----------`)
			const childElement = document.createElement(childData.type || "div");
			styleElement(childElement, childData);
			element.appendChild(childElement);
		}
	}
}
/**
 * @param {HTMLInputElement} element 
 */
function labelInput(element) {
	if (!(element instanceof HTMLElement)) {
		throw new TypeError("Expected an HTMLElement as input.");
	}

	const parent = element.parentElement;
	if (!parent) {
		console.warn("The element has no parent. It will be wrapped but not inserted into the document.");
	}

	// Ensure the input has a valid name or id for the label
	if (!element.name && !element.id) {
		element.id = `input-${Game.instance.getUnusedId()}`;
	}

	// Create label and wrapper
	const div = document.createElement("div");
	const label = document.createElement("label");

	label.setAttribute("for", element.name ?? element.id);
	label.innerText = element.name ?? element.id;

	// Insert elements properly
	div.appendChild(label);
	div.appendChild(element);

	if (parent) {
		parent.appendChild(div)
	}

	return div;
}

function isSet(toCeck){return Boolean(toCeck || toCeck === 0)}
//#endregion
const debug = true
export {Entity, NPC, Player, Projectile, Weapon, AI, Game, Hub, Ability, Stat, Tracker, waveMulti}