Handling ceiling slopes & corner correction (I'm so close, looking for help)

import * as Util from "./util.js";

export class Player extends ISpriteInstance {
	
	#preTick = () => this.preTick();
	#postTick = () => this.postTick();
	
	constructor() {
		super();
		runtime.addEventListener("pretick", this.#preTick);
		runtime.addEventListener("tick2", this.#postTick);

		this.storedY = 0;
		this.didPushout = false;
	}

	preTick() {
		// this ticks BEFORE behaviors
		// TODO: Ideally I should have an input check here to see if a jump was executed because if the player is wedged under a sloped ceiling, the behavior will set vectorY to 0 and bonk the player before the slope handling kicks in
		this.handleCeilingSlopes();
	}

	postTick() {
		// this ticks AFTER behaviors
		// if a pushout happened this tick, set the players vectorY to the stored vectorY. This is needed because the behavior will set the vectorY to 0 because it detected a ceiling
		if(this.didPushout) this.behaviors.Platform.vectorY = this.storedY+this.behaviors.Platform.gravity*runtime.dt;
	}

	handleCeilingSlopes() {
		this.didPushout = false;

		// Player is not moving upwards, return
		if (this.behaviors.Platform.vectorY >= 0) return;
		
		// Store current position and expected next position based on velocity
		const old = {"x": this.x, "y": this.y};
		const next = {"x": this.x+this.behaviors.Platform.vectorX*runtime.dt, "y": this.y+this.behaviors.Platform.vectorY*runtime.dt};
		let maxPushoutDistance = 7; // maximum corner correction
		const maxPushoutSlope = 1000*runtime.dt; // max slope correction
		const minCeilingAngleTolerance = Math.PI*0.05; // maximum ceiling angle

		// set position to next frame
		this.setPosition(next.x, next.y);

		let overlap = this.testOverlapSolid();
		if(overlap) {
			// store the behaviors current vectorY
			this.storedY = this.behaviors.Platform.vectorY+this.behaviors.Platform.gravity*runtime.dt;
			let testRight = false;
			let testLeft = false;

			// test push right
			let i = 0;
			let pushoutAngle = 0;
			while(overlap && i < maxPushoutDistance) {
				i++;
				const bbox = this.getBoundingBox();
				const ray = this.behaviors.LineOfSight.castRay(bbox.left, bbox.top+16, bbox.left, bbox.top-2); // angle defaults to 0 if no slope hit
				let rAngle = Util.isWithinAngle(ray.normalAngle, Math.PI*0.5, minCeilingAngleTolerance) ? ray.normalAngle-Math.PI*0.5 : ray.normalAngle;
				if(Math.cos(rAngle) < 0) rAngle = Math.PI*2;
				if (ray.didCollide && !Util.isWithinAngle(ray.normalAngle, Math.PI*0.5, minCeilingAngleTolerance)) maxPushoutDistance = maxPushoutSlope;
				this.x += Math.cos(rAngle);
				this.y += Math.sin(rAngle);
				overlap = this.testOverlapSolid();
				pushoutAngle = rAngle;
			}
			testRight = {"success": false, "i": i, "x": this.x, "y": this.y, "angle": pushoutAngle};
			if(!overlap) testRight.success = true;

			// reset
			this.setPosition(next.x, next.y);
			overlap = true;
			maxPushoutDistance = 7;
			pushoutAngle = 0;

			// test push left
			i = 0;
			while(overlap && i < maxPushoutDistance) {
				i++;
				const bbox = this.getBoundingBox();
				const ray = this.behaviors.LineOfSight.castRay(bbox.right, bbox.top+16, bbox.right, bbox.top-2);
				let rAngle = ray.didCollide ? ray.normalAngle : Math.PI; // angle defaults to Math.PI if no slope hit
				rAngle = Util.isWithinAngle(rAngle, Math.PI*0.5, minCeilingAngleTolerance) ? rAngle+Math.PI*0.5 : rAngle;
				if(Math.cos(rAngle) > 0) rAngle = Math.PI;
				if (ray.didCollide && !Util.isWithinAngle(ray.normalAngle, Math.PI*0.5, minCeilingAngleTolerance)) maxPushoutDistance = maxPushoutSlope;
				this.x += Math.cos(rAngle);
				this.y += Math.sin(rAngle);
				overlap = this.testOverlapSolid();
				pushoutAngle = rAngle;
			}
			testLeft = {"success": false, "i": i, "x": this.x, "y": this.y, "angle": pushoutAngle};
			if(!overlap) testLeft.success = true;

			// result
			if(!testLeft.success && !testRight.success) {
				this.setPosition(old.x, old.y);
			} else if(testLeft.success && testRight.success) {
				// detect inner corner
				if(Math.sign(Math.cos(testLeft.angle)) != Math.sign(Math.cos(testRight.angle))) {
					this.didPushout = false;
				} else {
					this.didPushout = true;
				}
				if(testRight.i >= testLeft.i) {
					this.setPosition(testLeft.x, testLeft.y);
				} else {
					this.setPosition(testRight.x, testRight.y);
				}
			} else if (testRight.success && !testLeft.success) {
				this.setPosition(testRight.x, testRight.y);
				this.didPushout = true;
			} else if (!testRight.success && testLeft.success) {
				this.setPosition(testLeft.x, testLeft.y);
				this.didPushout = true;
			}

		} else {
			// no pushout needed, just revert
			this.setPosition(old.x, old.y);
		}
	}
}