skycraft: now with landing!
Once landed, position is locked to the body it landed on. Not enough fuel to launch again.
This commit is contained in:
parent
29f5e84312
commit
4a9bca98ef
@ -4,7 +4,7 @@ import {memoize} from 'wmc-common/memoize';
|
||||
|
||||
type direction = ('-x' | '+x' | '-y' | '+y' | '-z' | '+z');
|
||||
|
||||
const BlockType = {
|
||||
export const BlockType = {
|
||||
UNDEFINED: 0,
|
||||
AIR: 1,
|
||||
DIRT: 2,
|
||||
@ -18,7 +18,6 @@ const BlockType = {
|
||||
|
||||
const CHUNKSIZE = 32;
|
||||
|
||||
|
||||
/** seed: some kind of number uniquely defining the body
|
||||
* x, y, z: space coordinates in the body's frame
|
||||
*
|
||||
@ -304,10 +303,115 @@ function getBodyChunks(seed: number) {
|
||||
return chunks;
|
||||
}
|
||||
|
||||
/** fake chunk map re-using the memoize */
|
||||
class ChunkMap {
|
||||
constructor(seed) {
|
||||
this.seed = seed;
|
||||
}
|
||||
|
||||
get(i, j, k) {
|
||||
return getChunk(this.seed, i, j, k);
|
||||
}
|
||||
|
||||
has(i, j, k) {
|
||||
return getChunk(this.seed, i, j, k) !== undefined;
|
||||
}
|
||||
}
|
||||
|
||||
export function getBodyGeometry(seed: number) {
|
||||
const faces = getBodyChunks(seed)
|
||||
.filter(chunk => !chunk.underground)
|
||||
.map(chunk => [...makeChunkFaces(chunk)]);
|
||||
|
||||
return faces.reduce((a, b) => a.concat(b));
|
||||
return {
|
||||
faces: faces.reduce((a, b) => a.concat(b)),
|
||||
chunkMap: new ChunkMap(seed),
|
||||
};
|
||||
}
|
||||
|
||||
function blockLookup(chunkMap, x, y, z) {
|
||||
const chunki = Math.floor((x + CHUNKSIZE / 2) / CHUNKSIZE);
|
||||
const chunkj = Math.floor((y + CHUNKSIZE / 2) / CHUNKSIZE);
|
||||
const chunkk = Math.floor((z + CHUNKSIZE / 2) / CHUNKSIZE);
|
||||
|
||||
const chunk = chunkMap.get(chunki, chunkj, chunkk);
|
||||
if (chunk === undefined) {
|
||||
return {
|
||||
type: BlockType.UNDEFINED,
|
||||
};
|
||||
}
|
||||
|
||||
const i = Math.floor(x - chunk.position[0] + 0.5);
|
||||
const j = Math.floor(y - chunk.position[1] + 0.5);
|
||||
const k = Math.floor(z - chunk.position[2] + 0.5);
|
||||
|
||||
const blockIndex = CHUNKSIZE * (CHUNKSIZE * i + j) + k;
|
||||
|
||||
return {
|
||||
type: chunk.blocks[blockIndex],
|
||||
centerPosition: [
|
||||
chunk.position[0] + i,
|
||||
chunk.position[1] + j,
|
||||
chunk.position[2] + k,
|
||||
],
|
||||
chunk,
|
||||
blockIndex,
|
||||
};
|
||||
}
|
||||
|
||||
function movePoint(p, s, u) {
|
||||
return linalg.add(p, linalg.scale(u, s));
|
||||
}
|
||||
|
||||
function minIndex(arr) {
|
||||
return arr.reduce((min, val, i) => val >= arr[min] ? min : i, -1);
|
||||
}
|
||||
|
||||
/** Imported from wmc, looks like it calculates the distance to the next grid block */
|
||||
function rayThroughGrid(origin, direction, maxDistance) {
|
||||
const range = i => [...Array(i).keys()];
|
||||
|
||||
const nextGrid = range(3).map(i => direction[i] > 0 ?
|
||||
Math.floor(origin[i] + 0.5) + 0.5 :
|
||||
Math.floor(origin[i] + 0.5) - 0.5);
|
||||
const distanceToGrid = range(3).map(i => (nextGrid[i] - origin[i]) / direction[i])
|
||||
.map(v => v === 0.0 ? Number.POSITIVE_INFINITY : v);
|
||||
const axis = minIndex(distanceToGrid);
|
||||
const rayLength = distanceToGrid[axis];
|
||||
|
||||
if (rayLength > maxDistance) {
|
||||
return {};
|
||||
}
|
||||
|
||||
const position = movePoint(origin, distanceToGrid[axis], direction);
|
||||
const normal = range(3).map(i => i === axis ? -Math.sign(direction[i]) : 0);
|
||||
|
||||
return {position, normal, distance: rayLength};
|
||||
}
|
||||
|
||||
/** needs a blockLookup function, finds the first non-air block along a ray */
|
||||
export function castRay(chunkMap, origin, direction, maxDistance=CHUNKSIZE) {
|
||||
let currentPoint = origin;
|
||||
|
||||
while (maxDistance > 0) {
|
||||
const {position, normal, distance} = rayThroughGrid(currentPoint, direction, maxDistance);
|
||||
|
||||
if (position === undefined) {
|
||||
return;
|
||||
}
|
||||
|
||||
maxDistance -= distance;
|
||||
currentPoint = movePoint(position, 0.01, direction);
|
||||
const blockCenter = movePoint(position, -0.5, normal);
|
||||
const block = blockLookup(chunkMap, ...blockCenter);
|
||||
|
||||
if (block.type === BlockType.AIR) {
|
||||
continue;
|
||||
}
|
||||
|
||||
return {
|
||||
block,
|
||||
normal,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@ -250,7 +250,7 @@ function getObjects(context, body, parentPosition = undefined) {
|
||||
const {position, orientation, glowColor, specularColor} = body;
|
||||
|
||||
if (body.glBuffer === undefined) {
|
||||
body.glBuffer = makeBufferFromFaces(gl, body.geometry);
|
||||
body.glBuffer = makeBufferFromFaces(gl, body.geometry.faces);
|
||||
}
|
||||
|
||||
objects.push({
|
||||
@ -263,14 +263,21 @@ function getObjects(context, body, parentPosition = undefined) {
|
||||
});
|
||||
if (parentPosition !== undefined) {
|
||||
const orbitObject = makeOrbitObject(gl, context.orbitGlContext, body.orbit, parentPosition);
|
||||
objects.push(orbitObject);
|
||||
//objects.push(orbitObject);
|
||||
} else {
|
||||
const tfs = [player.tf];
|
||||
if (context.landed) {
|
||||
const body = context.landedBody;
|
||||
const bodyTf = se3.product(se3.translation(...body.position), body.orientation);
|
||||
tfs.splice(0, 0, bodyTf);
|
||||
}
|
||||
const tf = tfs.reduce(se3.product);
|
||||
const shipOrientation = [
|
||||
se3.rotationOnly(player.tf),
|
||||
se3.rotationOnly(tf),
|
||||
//se3.rotationOnly(context.camera.tf),
|
||||
se3.rotxyz(-Math.PI / 2, Math.PI / 2, Math.PI / 2),
|
||||
].reduce(se3.product);
|
||||
const shipPos = player.position;
|
||||
const shipPos = se3.apply(tf, [0, 0, 0, 1]);
|
||||
objects.push({
|
||||
geometry: makeBufferFromFaces(gl, context.spaceship),
|
||||
orientation: shipOrientation,
|
||||
@ -297,7 +304,7 @@ export function draw(context) {
|
||||
const {gl, camera, player, universe, orbit, orbitGlContext, orbitBody} = context;
|
||||
const {skyColor, ambiantLight, projMatrix} = context;
|
||||
const objects = getObjects(context, universe);
|
||||
if (orbit !== undefined && orbit.excentricity < 1) {
|
||||
if (orbit !== undefined && orbit.excentricity < 1 && !context.landing) {
|
||||
objects.push(makeOrbitObject(gl, orbitGlContext, orbit, orbitBody.position));
|
||||
}
|
||||
|
||||
@ -313,11 +320,18 @@ export function draw(context) {
|
||||
|
||||
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
|
||||
|
||||
const viewMatrix = se3.inverse([
|
||||
const playerView = [
|
||||
player.tf, // player position & orientation
|
||||
camera.tf, // camera orientation relative to player
|
||||
se3.translation(0, 1, 4), // step back from the player
|
||||
].reduce(se3.product));
|
||||
];
|
||||
if (context.landed) {
|
||||
const body = context.landedBody;
|
||||
const bodyTf = se3.product(se3.translation(...body.position), body.orientation);
|
||||
playerView.splice(0, 0, bodyTf);
|
||||
}
|
||||
|
||||
const viewMatrix = se3.inverse(playerView.reduce(se3.product));
|
||||
let lastGlContext;
|
||||
|
||||
for (const {position, orientation, geometry, glContext, glowColor, specularColor} of objects) {
|
||||
|
||||
@ -3,8 +3,8 @@ import { makeFace } from 'wmc-common/geometry';
|
||||
import * as linalg from './linalg';
|
||||
import { loadObjModel } from './obj';
|
||||
import * as se3 from 'wmc-common/se3';
|
||||
import { computeOrbit, findSoi, getCartesianState, updateBodyPhysics } from './orbit';
|
||||
import { getBodyGeometry } from './chunk';
|
||||
import { computeOrbit, findSoi, getCartesianState, updateBodyPhysics, isInSoi } from './orbit';
|
||||
import { getBodyGeometry, castRay, BlockType } from './chunk';
|
||||
import { draw, getOrbitDrawContext, initWorldGl } from './draw';
|
||||
import * as quat from './quat';
|
||||
|
||||
@ -157,18 +157,10 @@ function initUiListeners(canvas: HTMLCanvasElement, context) {
|
||||
delete context.orbit;
|
||||
return false;
|
||||
case 'KeyL':
|
||||
if (closeToPlanet(context)) {
|
||||
context.landing = True;
|
||||
}
|
||||
context.landing = !context.landing;
|
||||
return false;
|
||||
case 'Space':
|
||||
if (!context.flying) {
|
||||
if (context.jumpAmount > 0) {
|
||||
const amount = context.jumpForce;
|
||||
context.player.velocity[1] = amount;
|
||||
context.jumpAmount -= 1;
|
||||
}
|
||||
}
|
||||
context.pause = !context.pause;
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
@ -236,6 +228,16 @@ function handleInput(context) {
|
||||
}
|
||||
};
|
||||
|
||||
const roll = (amount: number) => {
|
||||
if (context.keys.has('ShiftLeft')) {
|
||||
amount *= 10;
|
||||
}
|
||||
context.camera.tf =[
|
||||
context.camera.tf,
|
||||
se3.rotz(amount),
|
||||
].reduce(se3.product);
|
||||
};
|
||||
|
||||
context.keys.forEach(key => {
|
||||
switch (key) {
|
||||
case 'KeyW':
|
||||
@ -250,6 +252,12 @@ function handleInput(context) {
|
||||
case 'KeyD':
|
||||
move(0.0, 0.5);
|
||||
return;
|
||||
case 'KeyQ':
|
||||
roll(0.02);
|
||||
return;
|
||||
case 'KeyE':
|
||||
roll(-0.02);
|
||||
return;
|
||||
case 'KeyR':
|
||||
context.timeOffset += 1;
|
||||
return;
|
||||
@ -259,15 +267,120 @@ function handleInput(context) {
|
||||
|
||||
function slerp(current: linalg.Mat4, target: linalg.Mat4, maxVelocity: number) : linalg.Mat4 {
|
||||
const q0 = quat.mat2Quat(current);
|
||||
const q1 = quat.mat2Quat(target);
|
||||
let q1 = quat.mat2Quat(target);
|
||||
|
||||
const dq = quat.diff(q1, q0);
|
||||
const maxt = maxVelocity / quat.norm(dq);
|
||||
|
||||
const q = quat.normalize(quat.add(q0, quat.scale(dq, Math.min(1, maxt))));
|
||||
//const q = quat.normalize(quat.add(q0, quat.scale(dq, Math.min(1, maxt))));
|
||||
const t = maxVelocity;
|
||||
if (quat.dot(q0, q1) < 0) {
|
||||
q1 = quat.scale(q1, -1);
|
||||
}
|
||||
const q = quat.normalize(quat.add(quat.scale(q0, 1 - t), quat.scale(q1, t)));
|
||||
return quat.quat2Mat(q);
|
||||
}
|
||||
|
||||
function distanceToGround(body: Body, position: number[], direction: number[]) : number {
|
||||
const inChunkOrientation = se3.inverse(body.orientation);
|
||||
const toChunk = vec => se3.apply(inChunkOrientation, vec.concat([0]));
|
||||
const directionInChunk = toChunk(direction);
|
||||
const positionInChunk = toChunk(linalg.diff(position, body.position));
|
||||
|
||||
const hit = castRay(body.geometry.chunkMap, positionInChunk, directionInChunk);
|
||||
|
||||
if (hit === undefined || hit.block.type === BlockType.UNDEFINED || hit.block.type === undefined) {
|
||||
const ray = linalg.diff(position, body.position);
|
||||
return {
|
||||
distance: linalg.norm(ray),
|
||||
normal: linalg.normalize(ray),
|
||||
};
|
||||
}
|
||||
|
||||
const distance = linalg.norm(linalg.diff(positionInChunk, hit.block.centerPosition));
|
||||
const normal = se3.apply(body.orientation, hit.normal.concat([0]));
|
||||
return {distance, normal};
|
||||
}
|
||||
|
||||
function autoLand(context) {
|
||||
const p = context.player;
|
||||
// 0. check prereqs:
|
||||
// - none
|
||||
// 1. adjust tangential speed to match body rotational
|
||||
// 2. cast ray towards center
|
||||
// 3. while high, go towards center
|
||||
// 4. when low, go towards ground
|
||||
// 5. stop when on ground
|
||||
const kShipRotateSpeed = 0.1;
|
||||
|
||||
const body = findSoi(context.universe, p.position);
|
||||
const toBodyCenter = linalg.diff(body.position, p.position);
|
||||
const {distance: altitude, normal: surfaceNormal} = distanceToGround(body, p.position, linalg.normalize(toBodyCenter));
|
||||
|
||||
// figure out tangential speed
|
||||
const spinSpeed = linalg.add(body.velocity, linalg.cross(body.spin, linalg.scale(toBodyCenter, -1)));
|
||||
const dv = linalg.diff(spinSpeed, p.velocity);
|
||||
// remove vertical component
|
||||
const vertical = linalg.scale(surfaceNormal, -linalg.dot(dv, surfaceNormal));
|
||||
const smallDv = linalg.scale(linalg.add(dv, vertical), 0.01);
|
||||
// const smallDv = linalg.scale(dv, 0.05);
|
||||
p.velocity = linalg.add(p.velocity, smallDv);
|
||||
|
||||
// up is up
|
||||
const shipZ = se3.apply(p.tf, [0, 0, 1, 0]);
|
||||
const ny = surfaceNormal;
|
||||
const nx = linalg.normalize(linalg.cross(ny, shipZ));
|
||||
const nz = linalg.normalize(linalg.cross(nx, ny));
|
||||
|
||||
const targetOrientation = se3.fromBases(nx, ny, nz);
|
||||
const currentOrientation = slerp(p.tf, targetOrientation, kShipRotateSpeed);
|
||||
p.tf = se3.setOrientation(p.tf, currentOrientation);
|
||||
|
||||
if (altitude < 1.5) {
|
||||
const upward = linalg.dot(linalg.diff(p.velocity, body.velocity), surfaceNormal);
|
||||
if (upward < -2) {
|
||||
p.velocity = linalg.add(p.velocity, linalg.scale(surfaceNormal, -2*upward));
|
||||
context.landing = false;
|
||||
} else if (upward < 0) {
|
||||
context.landed = true;
|
||||
context.landedBody = body;
|
||||
|
||||
p.tf = [
|
||||
se3.inverse(body.orientation),
|
||||
se3.inverse(se3.translation(...body.position)),
|
||||
p.tf,
|
||||
].reduce(se3.product);
|
||||
p.velocity = [0, 0, 0];
|
||||
p.position = se3.apply(p.tf, [0, 0, 0, 1]);
|
||||
}
|
||||
}
|
||||
// p.velocity = linalg.add(p.velocity, linalg.scale(surfaceNormal, dvup));
|
||||
}
|
||||
|
||||
function effectiveGravity(position: number[], rootBody: Body) : number[] {
|
||||
let body = rootBody;
|
||||
let acceleration = [0, 0, 0];
|
||||
while (body !== undefined) {
|
||||
const toBodyCenter = linalg.diff(body.position, position);
|
||||
const d = linalg.norm(toBodyCenter);
|
||||
const gravity = body.mass / d**3;
|
||||
acceleration = linalg.add(acceleration, linalg.scale(toBodyCenter, gravity));
|
||||
|
||||
const parentMass = body.mass;
|
||||
const children = body.children || [];
|
||||
body = undefined;
|
||||
for (const child of children) {
|
||||
if (!isInSoi(child, parentMass, position)) {
|
||||
continue;
|
||||
}
|
||||
body = child;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return acceleration;
|
||||
}
|
||||
|
||||
function updatePhysics(time: number, context) {
|
||||
const {player} = context;
|
||||
const dt = time - (context.lastTime || 0);
|
||||
@ -275,37 +388,41 @@ function updatePhysics(time: number, context) {
|
||||
|
||||
player.position = se3.apply(player.tf, [0, 0, 0, 1]);
|
||||
|
||||
updateBodyPhysics(time, context.universe);
|
||||
if (!context.pause) {
|
||||
updateBodyPhysics(time, context.universe);
|
||||
}
|
||||
|
||||
const dr = slerp(se3.identity(), context.camera.tf, 0.007);
|
||||
player.tf = se3.product(player.tf, dr);
|
||||
context.camera.tf = se3.product(context.camera.tf, se3.inverse(dr));
|
||||
const kShipRotateSpeed = 0.1;
|
||||
|
||||
if (!context.flying) {
|
||||
if (context.orbit === undefined) {
|
||||
const newPos = linalg.add(player.position, linalg.scale(player.velocity, dt));
|
||||
const dx = linalg.diff(newPos, player.position);
|
||||
player.tf = se3.product(se3.translation(...dx), player.tf);
|
||||
if (context.landed) {
|
||||
return; // TODO: implement
|
||||
}
|
||||
|
||||
const body = findSoi(context.universe, context.player.position);
|
||||
context.orbit = computeOrbit(player, body, time);
|
||||
console.log(`orbiting ${body.name}, excentricity: ${context.orbit.excentricity}`);
|
||||
context.orbitBody = body;
|
||||
} else {
|
||||
const {position: orbitPos, velocity: orbitVel} = getCartesianState(
|
||||
context.orbit, context.orbitBody.mass, time);
|
||||
if (orbitPos === undefined) {
|
||||
const newPos = linalg.add(player.position, linalg.scale(player.velocity, dt));
|
||||
const dx = linalg.diff(newPos, player.position);
|
||||
player.tf = se3.product(se3.translation(...dx), player.tf);
|
||||
} else {
|
||||
const position = linalg.add(orbitPos, context.orbitBody.position);
|
||||
const velocity = linalg.add(orbitVel, context.orbitBody.velocity);
|
||||
player.velocity = velocity;
|
||||
const dx = linalg.diff(position, player.position);
|
||||
player.tf = se3.product(se3.translation(...dx), player.tf);
|
||||
}
|
||||
}
|
||||
if (context.landing) {
|
||||
autoLand(context);
|
||||
} else {
|
||||
// allow acdjusting camera
|
||||
const dr = slerp(se3.identity(), context.camera.tf, kShipRotateSpeed);
|
||||
player.tf = se3.product(player.tf, dr);
|
||||
context.camera.tf = se3.product(context.camera.tf, se3.inverse(dr));
|
||||
}
|
||||
|
||||
if (context.flying) {
|
||||
// no physics, just magically moving around
|
||||
return;
|
||||
}
|
||||
|
||||
const gravity = effectiveGravity(player.position, context.universe);
|
||||
player.velocity = linalg.add(player.velocity, linalg.scale(gravity, dt));
|
||||
|
||||
const newPos = linalg.add(player.position, linalg.scale(player.velocity, dt));
|
||||
player.tf = se3.setPosition(player.tf, newPos);
|
||||
|
||||
if (context.orbit === undefined) {
|
||||
const body = findSoi(context.universe, context.player.position);
|
||||
context.orbit = computeOrbit(player, body, time);
|
||||
console.log(`orbiting ${body.name}, excentricity: ${context.orbit.excentricity}`);
|
||||
context.orbitBody = body;
|
||||
}
|
||||
}
|
||||
|
||||
@ -336,14 +453,16 @@ function tick(time: number, context) {
|
||||
}
|
||||
|
||||
function makeCube(texture) {
|
||||
return [
|
||||
makeFace('-x', texture, [-0.5, 0, 0]),
|
||||
makeFace('+x', texture, [+0.5, 0, 0]),
|
||||
makeFace('-y', texture, [0, -0.5, 0]),
|
||||
makeFace('+y', texture, [0, +0.5, 0]),
|
||||
makeFace('-z', texture, [0, 0, -0.5]),
|
||||
makeFace('+z', texture, [0, 0, +0.5]),
|
||||
];
|
||||
return {
|
||||
faces: [
|
||||
makeFace('-x', texture, [-0.5, 0, 0]),
|
||||
makeFace('+x', texture, [+0.5, 0, 0]),
|
||||
makeFace('-y', texture, [0, -0.5, 0]),
|
||||
makeFace('+y', texture, [0, +0.5, 0]),
|
||||
makeFace('-z', texture, [0, 0, -0.5]),
|
||||
makeFace('+z', texture, [0, 0, +0.5]),
|
||||
]
|
||||
};
|
||||
}
|
||||
|
||||
async function main() {
|
||||
@ -399,7 +518,6 @@ async function main() {
|
||||
initUiListeners(canvas, context);
|
||||
|
||||
const starshipGeom = await modelPromise;
|
||||
console.log(`loaded ${starshipGeom.length} triangles`);
|
||||
|
||||
context.spaceship = starshipGeom;
|
||||
|
||||
|
||||
@ -52,6 +52,14 @@ export function updateBodyPhysics(time: number, body: Body, parentBody : Body |
|
||||
}
|
||||
}
|
||||
|
||||
export function isInSoi(body: Body, parentMass: number, position: number[]) : boolean {
|
||||
const soi = body.orbit.semimajorAxis * Math.pow(body.mass / parentMass, 2/5);
|
||||
const pos = position;
|
||||
const bod = body.position;
|
||||
const dr = [pos[0] - bod[0], pos[1] - bod[1], pos[2] - bod[2]];
|
||||
return (dr[0]**2 + dr[1]**2 + dr[2]**2 < soi**2);
|
||||
}
|
||||
|
||||
export function findSoi(rootBody: Body, position: number[]) : Body {
|
||||
const bodies = [rootBody];
|
||||
let body : Body;
|
||||
@ -63,11 +71,7 @@ export function findSoi(rootBody: Body, position: number[]) : Body {
|
||||
}
|
||||
|
||||
for (const child of body.children) {
|
||||
const soi = child.orbit.semimajorAxis * Math.pow(child.mass / body.mass, 2/5);
|
||||
const pos = position;
|
||||
const bod = child.position;
|
||||
const dr = [pos[0] - bod[0], pos[1] - bod[1], pos[2] - bod[2]];
|
||||
if (dr[0]**2 + dr[1]**2 + dr[2]**2 < soi**2) {
|
||||
if (isInSoi(child, body.mass, position)) {
|
||||
bodies.push(child);
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user