307 lines
10 KiB
JavaScript
307 lines
10 KiB
JavaScript
import Component from '@/ecs/component.js';
|
|
import {distance, intersects, transform} from '@/util/math.js';
|
|
|
|
import vector2d from './helpers/vector-2d';
|
|
|
|
export default class Collider extends Component {
|
|
instanceFromSchema() {
|
|
const {ecs} = this;
|
|
return class ColliderInstance extends super.instanceFromSchema() {
|
|
$$aabb = {x0: Infinity, x1: -Infinity, y0: Infinity, y1: -Infinity};
|
|
$$aabbs = [];
|
|
$$collisionStart;
|
|
$$collisionEnd;
|
|
$$intersections = new Map();
|
|
get aabb() {
|
|
const {Position: {x: px, y: py}} = ecs.get(this.entity);
|
|
return {
|
|
x0: this.$$aabb.x0 + px,
|
|
x1: this.$$aabb.x1 + px,
|
|
y0: this.$$aabb.y0 + py,
|
|
y1: this.$$aabb.y1 + py,
|
|
};
|
|
}
|
|
get aabbs() {
|
|
const {Position: {x: px, y: py}} = ecs.get(this.entity);
|
|
const aabbs = [];
|
|
for (const aabb of this.$$aabbs) {
|
|
aabbs.push({
|
|
x0: aabb.x0 + px,
|
|
x1: aabb.x1 + px,
|
|
y0: aabb.y0 + py,
|
|
y1: aabb.y1 + py,
|
|
})
|
|
}
|
|
return aabbs;
|
|
}
|
|
endIntersections(other, intersections) {
|
|
const otherEntity = ecs.get(other.entity);
|
|
const thisEntity = ecs.get(this.entity);
|
|
for (const intersection of intersections) {
|
|
const [body, otherBody] = [
|
|
intersection.entity.bodies[intersection.i],
|
|
intersection.other.bodies[intersection.j],
|
|
];
|
|
if (this.$$collisionEnd) {
|
|
const script = this.$$collisionEnd.clone();
|
|
script.context.other = otherEntity;
|
|
script.context.pair = [body, otherBody];
|
|
const ticker = script.ticker();
|
|
ecs.addDestructionDependency(thisEntity.id, ticker);
|
|
ecs.addDestructionDependency(otherEntity.id, ticker);
|
|
thisEntity.Ticking.add(ticker);
|
|
}
|
|
if (other.$$collisionEnd) {
|
|
const script = other.$$collisionEnd.clone();
|
|
script.context.other = thisEntity;
|
|
script.context.pair = [otherBody, body];
|
|
const ticker = script.ticker();
|
|
ecs.addDestructionDependency(thisEntity.id, ticker);
|
|
ecs.addDestructionDependency(otherEntity.id, ticker);
|
|
otherEntity.Ticking.add(ticker);
|
|
}
|
|
}
|
|
this.$$intersections.delete(other);
|
|
other.$$intersections.delete(this);
|
|
}
|
|
checkCollision(other) {
|
|
const otherEntity = ecs.get(other.entity);
|
|
const thisEntity = ecs.get(this.entity);
|
|
const intersections = this.intersectionsWith(other);
|
|
const activeIntersections = this.$$intersections.get(other) || new Set();
|
|
if (0 === intersections.length) {
|
|
// had none; have none
|
|
if (0 === activeIntersections.size) {
|
|
return;
|
|
}
|
|
this.endIntersections(other, intersections);
|
|
return;
|
|
}
|
|
for (const intersection of intersections) {
|
|
// new pair - start
|
|
const [body, otherBody] = [
|
|
intersection.entity.bodies[intersection.i],
|
|
intersection.other.bodies[intersection.j],
|
|
];
|
|
let hasMatchingIntersection = false;
|
|
for (const activeIntersection of activeIntersections) {
|
|
if (
|
|
(
|
|
activeIntersection.entity === intersection.entity
|
|
&& activeIntersection.other === intersection.other
|
|
&& activeIntersection.i === intersection.i
|
|
&& activeIntersection.j === intersection.j
|
|
)
|
|
|| (
|
|
activeIntersection.entity === intersection.other
|
|
&& activeIntersection.other === intersection.entity
|
|
&& activeIntersection.i === intersection.j
|
|
&& activeIntersection.j === intersection.i
|
|
)
|
|
) {
|
|
hasMatchingIntersection = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!hasMatchingIntersection) {
|
|
if (this.$$collisionStart) {
|
|
const script = this.$$collisionStart.clone();
|
|
script.context.entity = thisEntity;
|
|
script.context.other = otherEntity;
|
|
script.context.pair = [body, otherBody];
|
|
const ticker = script.ticker();
|
|
ecs.addDestructionDependency(otherEntity.id, ticker);
|
|
ecs.addDestructionDependency(thisEntity.id, ticker);
|
|
thisEntity.Ticking.add(ticker);
|
|
}
|
|
if (other.$$collisionStart) {
|
|
const script = other.$$collisionStart.clone();
|
|
script.context.entity = otherEntity;
|
|
script.context.other = thisEntity;
|
|
script.context.pair = [otherBody, body];
|
|
const ticker = script.ticker();
|
|
ecs.addDestructionDependency(otherEntity.id, ticker);
|
|
ecs.addDestructionDependency(thisEntity.id, ticker);
|
|
otherEntity.Ticking.add(ticker);
|
|
}
|
|
activeIntersections.add(intersection);
|
|
}
|
|
// undo restricted movement
|
|
if (!body.unstoppable && otherBody.impassable) {
|
|
const j = this.bodies.indexOf(body);
|
|
const oj = other.bodies.indexOf(otherBody);
|
|
const aabb = this.$$aabbs[j];
|
|
const otherAabb = other.aabbs[oj];
|
|
const {Position} = thisEntity;
|
|
if (!intersects(
|
|
{
|
|
x0: aabb.x0 + Position.lastX,
|
|
x1: aabb.x1 + Position.lastX,
|
|
y0: aabb.y0 + Position.y,
|
|
y1: aabb.y1 + Position.y,
|
|
},
|
|
otherAabb,
|
|
)) {
|
|
Position.x = Position.lastX
|
|
}
|
|
else if (!intersects(
|
|
{
|
|
x0: aabb.x0 + Position.x,
|
|
x1: aabb.x1 + Position.x,
|
|
y0: aabb.y0 + Position.lastY,
|
|
y1: aabb.y1 + Position.lastY,
|
|
},
|
|
otherAabb,
|
|
)) {
|
|
Position.y = Position.lastY
|
|
}
|
|
else {
|
|
Position.x = Position.lastX
|
|
Position.y = Position.lastY
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (activeIntersections.size > 0) {
|
|
this.$$intersections.set(other, activeIntersections);
|
|
other.$$intersections.set(this, activeIntersections);
|
|
}
|
|
}
|
|
closest(aabb) {
|
|
const entity = ecs.get(this.entity);
|
|
return Array.from(ecs.system('MaintainColliderHash').within(aabb))
|
|
.filter((other) => other !== entity)
|
|
.sort(({Position: l}, {Position: r}) => {
|
|
return distance(entity.Position, l) > distance(entity.Position, r) ? -1 : 1;
|
|
});
|
|
}
|
|
destroy() {
|
|
for (const [other] of this.$$intersections) {
|
|
other.$$intersections.delete(this);
|
|
}
|
|
this.$$intersections.clear();
|
|
}
|
|
intersectionsWith(other) {
|
|
const {aabb, aabbs} = this;
|
|
const {aabb: otherAabb, aabbs: otherAabbs} = other;
|
|
const intersections = [];
|
|
if (!intersects(aabb, otherAabb)) {
|
|
return intersections;
|
|
}
|
|
for (const i in aabbs) {
|
|
const aabb = aabbs[i];
|
|
const body = this.bodies[i];
|
|
for (const j in otherAabbs) {
|
|
const otherAabb = otherAabbs[j];
|
|
const otherBody = other.bodies[j];
|
|
if (body.group === otherBody.group && body.group < 0) {
|
|
continue;
|
|
}
|
|
if (body.group !== otherBody.group || 0 === body.group) {
|
|
if (0 === (otherBody.mask & body.bits) || 0 === (body.mask & otherBody.bits)) {
|
|
continue;
|
|
}
|
|
}
|
|
// todo accuracy
|
|
if (intersects(aabb, otherAabb)) {
|
|
intersections.push({
|
|
entity: this,
|
|
other,
|
|
i,
|
|
j,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return intersections;
|
|
}
|
|
isWithin(query) {
|
|
const {aabb, aabbs} = this;
|
|
if (!intersects(aabb, query)) {
|
|
return false;
|
|
}
|
|
for (const aabb of aabbs) {
|
|
if (intersects(aabb, query)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
updateAabbs() {
|
|
this.$$aabb = {x0: Infinity, x1: -Infinity, y0: Infinity, y1: -Infinity};
|
|
this.$$aabbs = [];
|
|
const {bodies} = this;
|
|
const {Direction: {direction = 0} = {}} = ecs.get(this.entity) || {};
|
|
for (const body of bodies) {
|
|
let x0 = Infinity, x1 = -Infinity, y0 = Infinity, y1 = -Infinity;
|
|
for (const point of transform(body.points, {rotation: direction})) {
|
|
const {x, y} = point;
|
|
if (x < x0) x0 = x;
|
|
if (x < this.$$aabb.x0) this.$$aabb.x0 = x;
|
|
if (x > x1) x1 = x;
|
|
if (x > this.$$aabb.x1) this.$$aabb.x1 = x;
|
|
if (y < y0) y0 = y;
|
|
if (y < this.$$aabb.y0) this.$$aabb.y0 = y;
|
|
if (y > y1) y1 = y;
|
|
if (y > this.$$aabb.y1) this.$$aabb.y1 = y;
|
|
}
|
|
this.$$aabbs.push({
|
|
x0: x0 > x1 ? x1 : x0,
|
|
x1: x0 > x1 ? x0 : x1,
|
|
y0: y0 > y1 ? y1 : y0,
|
|
y1: y0 > y1 ? y0 : y1,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
async load(instance) {
|
|
for (const i in instance.bodies) {
|
|
instance.bodies[i] = {
|
|
...this.constructor.schema.constructor.defaultValue(
|
|
this.constructor.schema.specification.concrete.properties.bodies.concrete.subtype,
|
|
),
|
|
...instance.bodies[i],
|
|
};
|
|
}
|
|
instance.updateAabbs();
|
|
// heavy handed...
|
|
if ('undefined' !== typeof window) {
|
|
return;
|
|
}
|
|
instance.$$collisionEnd = await this.ecs.readScript(
|
|
instance.collisionEndScript,
|
|
{
|
|
ecs: this.ecs,
|
|
},
|
|
);
|
|
instance.$$collisionStart = await this.ecs.readScript(
|
|
instance.collisionStartScript,
|
|
{
|
|
ecs: this.ecs,
|
|
},
|
|
);
|
|
}
|
|
static properties = {
|
|
bodies: {
|
|
type: 'array',
|
|
subtype: {
|
|
type: 'object',
|
|
properties: {
|
|
bits: {defaultValue: 0x00000001, type: 'uint32'},
|
|
impassable: {type: 'uint8'},
|
|
group: {type: 'int32'},
|
|
mask: {defaultValue: 0xFFFFFFFF, type: 'uint32'},
|
|
points: {
|
|
type: 'array',
|
|
subtype: vector2d('int16'),
|
|
},
|
|
unstoppable: {type: 'uint8'},
|
|
},
|
|
},
|
|
},
|
|
collisionEndScript: {type: 'string'},
|
|
collisionStartScript: {type: 'string'},
|
|
};
|
|
}
|