neocturne/rpgedit
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

More generic collision handling

Browse source
This commit is contained in:
Matthias Schiffer 2018-11-05 19:59:39 +01:00
parent 9be9f8e739
commit fd59aaa55c
Signed by: neocturne
GPG key ID: 16EF3F64CB201D9C
4 changed files with 78 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
src/controller/gamecontext.ts
View file

@ -6,7 +6,9 @@ import { loadMap } from '../view/map';
import { Renderer } from '../view/renderer/renderer';
import { SpriteView } from '../view/sprite';
import { Collidable } from '../math/collision';
import { LineSegment, Movement } from '../math/line';
import { Point } from '../math/point';
import { getJSON } from '../util';
import { vec2 } from 'gl-matrix';
@ -24,8 +26,8 @@ export class GameContext {
);
}
private static mkCollision(collision: Collision[]): LineSegment[] {
const ret: LineSegment[] = [];
private static mkCollision(collision: Collision[]): Collidable[] {
const ret: Collidable[] = [];
for (const c of collision) {
switch (c.type) {
@ -39,13 +41,18 @@ export class GameContext {
ret.push(LineSegment.fromPoints(vec2.clone(prev), vec2.clone(v)));
prev = v;
}
for (const v of c.vertices) {
ret.push(new Point(vec2.clone(v)));
prev = v;
}
}
}
return ret;
}
private static async loadMap(renderer: Renderer): Promise<[SpriteView, LineSegment[]]> {
private static async loadMap(renderer: Renderer): Promise<[SpriteView, Collidable[]]> {
const map = new MapData(await getJSON('resources/map/test.json'));
return [await loadMap(renderer, map), this.mkCollision(map.collision)];
}
@ -53,7 +60,7 @@ export class GameContext {
private time: number|null = null;
private readonly tick = 10; // ms per tick
private readonly speed = 0.05; // movement per tick
private readonly speed = 0.04; // movement per tick
private readonly maxSkip = 20; // maximum ticks to process in a single render step
private readonly input: DirectionHandler;
@ -67,7 +74,7 @@ export class GameContext {
private readonly renderer: Renderer,
private readonly mapView: SpriteView,
private readonly entity: SpriteView,
private readonly collision: LineSegment[],
private readonly collision: Collidable[],
) {
this.input = new DirectionHandler();
this.input.addListener((v) => {
@ -102,7 +109,7 @@ export class GameContext {
const move = new Movement(this.entityPos, dest);
for (const c of this.collision) {
if (!c.collidesMoveCircle(dest2, move, this.collisionRadius))
if (!c.collide(dest2, move, this.collisionRadius))
continue;
if (!vec2.exactEquals(dest, dest2)) {

7
src/math/collision.ts Normal file
View file

@ -0,0 +1,7 @@
import { Movement } from './line';
import { vec2 } from 'gl-matrix';
export interface Collidable {
collide(out: vec2, move: Movement, r: number): boolean;
}

69
src/math/line.ts
View file

@ -1,4 +1,5 @@
import { mat2, vec2 } from 'gl-matrix';
import { Collidable } from './collision';
const rot90 = mat2.fromValues(
0, 1,
@ -80,7 +81,7 @@ export class Movement {
}
}
export class LineSegment extends Line {
export class LineSegment extends Line implements Collidable {
public static fromPoints(p1: vec2, p2: vec2): LineSegment {
const d = vec2.dist(p1, p2);
const v = vec2.sub(vec2.create(), p2, p1);
@ -101,12 +102,25 @@ export class LineSegment extends Line {
return vec2.scaleAndAdd(out, this.p, this.v, this.l);
}
public collidesPoint(p2: vec2): boolean {
public containsPoint(p2: vec2): boolean {
const d = this.projectPointDistance(p2);
return (d >= 0 && d <= this.l);
}
public collidesMove(out: vec2, move: Movement): boolean {
public collide(out: vec2, move: Movement, r: number): boolean {
const t = this.getNormal(vec2.create());
vec2.scale(t, t, -r);
const refMove = move.translate(t);
if (!this.collideRef(out, refMove))
return false;
vec2.sub(out, out, t);
return true;
}
private collideRef(out: vec2, move: Movement): boolean {
if (this.distancePoint(move.p1) < 0)
return false;
@ -114,58 +128,11 @@ export class LineSegment extends Line {
return false;
const x = move.intersectLine(vec2.create(), this);
if (!this.collidesPoint(x))
if (!this.containsPoint(x))
return false;
this.projectPoint(out, move.p2);
return true;
}
public collidesMoveCircle(out: vec2, move: Movement, r: number): boolean {
const t = this.getNormal(vec2.create());
vec2.scale(t, t, -r);
const refMove = move.translate(t);
const refOut = vec2.create();
if (this.collidesMove(refOut, refMove)) {
vec2.sub(out, refOut, t);
return true;
}
return this.collidesPointMoveCircle(out, move, r);
}
private collidesPointMoveCircle(out: vec2, move: Movement, r: number): boolean {
const moveLine = move.toLineSegment();
if (moveLine.projectPointDistance(this.p) < 0)
return false;
const d = moveLine.distancePoint(this.p) / r;
if (Math.abs(d) >= 1)
return false;
const e = Math.sqrt(1 - d * d);
const t = moveLine.getNormal(vec2.create());
vec2.scale(t, t, d);
vec2.scaleAndAdd(t, t, moveLine.v, e);
const tr = vec2.scale(vec2.create(), t, r);
const refMove = move.translate(tr);
if (vec2.sqrDist(this.p, move.p1) > r * r && !refMove.passes(this.p))
return false;
normal(t, t);
const tang = new Line(this.p, t);
tang.projectPoint(out, refMove.p2);
vec2.sub(out, out, tr);
return true;
}
}

40
src/math/point.ts Normal file
View file

@ -0,0 +1,40 @@
import { Collidable } from './collision';
import { Line, Movement, normal } from './line';
import { vec2 } from 'gl-matrix';
export class Point implements Collidable {
constructor(public readonly p: vec2) {}
public collide(out: vec2, move: Movement, r: number): boolean {
const moveLine = move.toLineSegment();
if (moveLine.projectPointDistance(this.p) < 0)
return false;
const d = moveLine.distancePoint(this.p) / r;
if (Math.abs(d) >= 1)
return false;
const e = Math.sqrt(1 - d * d);
const t = moveLine.getNormal(vec2.create());
vec2.scale(t, t, d);
vec2.scaleAndAdd(t, t, moveLine.v, e);
const tr = vec2.scale(vec2.create(), t, r);
const refMove = move.translate(tr);
if (vec2.sqrDist(this.p, move.p1) > r * r && !refMove.passes(this.p))
return false;
normal(t, t);
const tang = new Line(this.p, t);
tang.projectPoint(out, refMove.p2);
vec2.sub(out, out, tr);
return true;
}
}