imshvc/noxious_server
1
0
Fork 0
forked from noxious/server
Code Pull Requests Activity

Worked on pathfinding, character animation & rotation, few enhancements

Browse Source
This commit is contained in:
Dennis Postma
2024-07-29 09:01:54 +02:00
parent dbe25071c7
commit bbeac95512
5 changed files with 188 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/utilities/Http.ts
View File

@ -49,31 +49,31 @@ async function addHttpRoutes(app: Application) {
})
app.get('/assets/:type/:spriteId?/:file', (req: Request, res: Response) => {
const assetType = req.params.type;
const spriteId = req.params.spriteId;
const fileName = req.params.file;
const assetType = req.params.type
const spriteId = req.params.spriteId
const fileName = req.params.file
let assetPath;
let assetPath
if (assetType === 'sprites' && spriteId) {
assetPath = path.join(process.cwd(), 'public', assetType, spriteId, fileName);
assetPath = path.join(process.cwd(), 'public', assetType, spriteId, fileName)
} else {
assetPath = path.join(process.cwd(), 'public', assetType, fileName);
assetPath = path.join(process.cwd(), 'public', assetType, fileName)
}
console.log(`Attempting to serve: ${assetPath}`);
console.log(`Attempting to serve: ${assetPath}`)
if (!fs.existsSync(assetPath)) {
console.error(`File not found: ${assetPath}`);
return res.status(404).send('Asset not found');
console.error(`File not found: ${assetPath}`)
return res.status(404).send('Asset not found')
}
res.sendFile(assetPath, (err) => {
if (err) {
console.error('Error sending file:', err);
res.status(500).send('Error downloading the asset');
console.error('Error sending file:', err)
res.status(500).send('Error downloading the asset')
}
});
});
})
})
app.post('/login', async (req: Request, res: Response) => {
const { username, password } = req.body

106
src/utilities/Player/AStar.ts
View File

@ -1,13 +1,13 @@
interface Position {
x: number;
y: number;
x: number
y: number
}
export interface Node extends Position {
parent?: Node;
g: number;
h: number;
f: number;
parent?: Node
g: number
h: number
f: number
}
/**
@ -16,17 +16,17 @@ export interface Node extends Position {
class AStar {
private static readonly ORTHOGONAL_DIRECTIONS: Position[] = [
{ x: 0, y: -1 }, // up
{ x: 0, y: 1 }, // down
{ x: 0, y: 1 }, // down
{ x: -1, y: 0 }, // left
{ x: 1, y: 0 } // right
];
{ x: 1, y: 0 } // right
]
private static readonly DIAGONAL_DIRECTIONS: Position[] = [
{ x: -1, y: -1 }, // up-left
{ x: -1, y: 1 }, // down-left
{ x: 1, y: -1 }, // up-right
{ x: 1, y: 1 } // down-right
];
{ x: -1, y: 1 }, // down-left
{ x: 1, y: -1 }, // up-right
{ x: 1, y: 1 } // down-right
]
/**
* Finds the shortest path from start to end on the given grid.
@ -37,79 +37,77 @@ class AStar {
* @returns Array of `Node` representing the path from start to end.
*/
static findPath(start: Position, end: Position, grid: number[][], allowDiagonal: boolean = false): Node[] {
const openList: Node[] = [];
const closedSet = new Set<string>();
const openList: Node[] = []
const closedSet = new Set<string>()
const startNode: Node = { ...start, g: 0, h: 0, f: 0 };
openList.push(startNode);
const startNode: Node = { ...start, g: 0, h: 0, f: 0 }
openList.push(startNode)
while (openList.length > 0) {
const currentNode = this.getLowestFScoreNode(openList);
const currentNode = this.getLowestFScoreNode(openList)
if (this.isEndNode(currentNode, end)) {
return this.reconstructPath(currentNode);
return this.reconstructPath(currentNode)
}
this.removeNodeFromOpenList(openList, currentNode);
closedSet.add(this.nodeToString(currentNode));
this.removeNodeFromOpenList(openList, currentNode)
closedSet.add(this.nodeToString(currentNode))
for (const neighbor of this.getValidNeighbors(currentNode, grid, end, allowDiagonal)) {
if (closedSet.has(this.nodeToString(neighbor))) continue;
if (closedSet.has(this.nodeToString(neighbor))) continue
const tentativeGScore = currentNode.g + this.getDistance(currentNode, neighbor);
const tentativeGScore = currentNode.g + this.getDistance(currentNode, neighbor)
if (!this.isInOpenList(openList, neighbor) || tentativeGScore < neighbor.g) {
neighbor.parent = currentNode;
neighbor.g = tentativeGScore;
neighbor.h = this.heuristic(neighbor, end);
neighbor.f = neighbor.g + neighbor.h;
neighbor.parent = currentNode
neighbor.g = tentativeGScore
neighbor.h = this.heuristic(neighbor, end)
neighbor.f = neighbor.g + neighbor.h
if (!this.isInOpenList(openList, neighbor)) {
openList.push(neighbor);
openList.push(neighbor)
}
}
}
}
return []; // No path found
return [] // No path found
}
/**
* Gets the node with the lowest F score from a list.
*/
private static getLowestFScoreNode(nodes: Node[]): Node {
return nodes.reduce((min, node) => (node.f < min.f ? node : min));
return nodes.reduce((min, node) => (node.f < min.f ? node : min))
}
/**
* Checks if the given node is the end node.
*/
private static isEndNode(node: Node, end: Position): boolean {
return node.x === end.x && node.y === end.y;
return node.x === end.x && node.y === end.y
}
/**
* Removes a node from the open list.
*/
private static removeNodeFromOpenList(openList: Node[], node: Node): void {
const index = openList.findIndex(n => n.x === node.x && n.y === node.y);
if (index !== -1) openList.splice(index, 1);
const index = openList.findIndex((n) => n.x === node.x && n.y === node.y)
if (index !== -1) openList.splice(index, 1)
}
/**
* Converts a node to a string representation.
*/
private static nodeToString(node: Position): string {
return `${node.x},${node.y}`;
return `${node.x},${node.y}`
}
/**
* Gets valid neighbors of the given node.
*/
private static getValidNeighbors(node: Node, grid: number[][], end: Position, allowDiagonal: boolean): Node[] {
const directions = allowDiagonal
? [...this.ORTHOGONAL_DIRECTIONS, ...this.DIAGONAL_DIRECTIONS]
: this.ORTHOGONAL_DIRECTIONS;
const directions = allowDiagonal ? [...this.ORTHOGONAL_DIRECTIONS, ...this.DIAGONAL_DIRECTIONS] : this.ORTHOGONAL_DIRECTIONS
return directions
.map((dir) => ({
@ -119,41 +117,37 @@ class AStar {
h: 0,
f: 0
}))
.filter((pos) => this.isValidPosition(pos, grid, end)) as Node[];
.filter((pos) => this.isValidPosition(pos, grid, end)) as Node[]
}
/**
* Checks if the given position is valid.
*/
private static isValidPosition(pos: Position, grid: number[][], end: Position): boolean {
const { x, y } = pos;
return (
x >= 0 && y >= 0 &&
x < grid.length && y < grid[0].length &&
(grid[y][x] === 0 || (x === end.x && y === end.y))
);
const { x, y } = pos
return x >= 0 && y >= 0 && x < grid.length && y < grid[0].length && (grid[y][x] === 0 || (x === end.x && y === end.y))
}
/**
* Checks if the given node is in the open list.
*/
private static isInOpenList(openList: Node[], node: Position): boolean {
return openList.some((n) => n.x === node.x && n.y === node.y);
return openList.some((n) => n.x === node.x && n.y === node.y)
}
/**
* Gets the distance between two positions.
*/
private static getDistance(a: Position, b: Position): number {
const dx = Math.abs(a.x - b.x);
const dy = Math.abs(a.y - b.y);
const dx = Math.abs(a.x - b.x)
const dy = Math.abs(a.y - b.y)
if (a.x === b.x || a.y === b.y) {
// Orthogonal movement (horizontal/vertical)
return Math.sqrt(dx * dx + dy * dy);
return Math.sqrt(dx * dx + dy * dy)
} else {
// Diagonal movement with cost sqrt(2)
return Math.sqrt(dx * dx + dy * dy);
return Math.sqrt(dx * dx + dy * dy)
}
}
@ -161,23 +155,23 @@ class AStar {
* Heuristic function estimating the distance from a node to the goal.
*/
private static heuristic(node: Position, goal: Position): number {
return this.getDistance(node, goal);
return this.getDistance(node, goal)
}
/**
* Reconstructs the path from the end node.
*/
private static reconstructPath(endNode: Node): Node[] {
const path: Node[] = [];
let currentNode: Node | undefined = endNode;
const path: Node[] = []
let currentNode: Node | undefined = endNode
while (currentNode) {
path.unshift(currentNode);
currentNode = currentNode.parent;
path.unshift(currentNode)
currentNode = currentNode.parent
}
return path;
return path
}
}
export default AStar;
export default AStar