{
109 | let deltaTime = this.engine.getDeltaTime();
110 | let dt = deltaTime / 1000;
111 | this.update(dt);
112 | });
113 |
114 | scene.camera = camera;
115 | this._initPointerLock();
116 |
117 | return scene;
118 | }
119 |
120 | update(dt) {
121 | // HACK: this update can be called before the scene is fully ready,
122 | // so just check for dt == 0 and return early in that case
123 | // TODO: onBeforeRenderObservable is probably not the best way
124 | // of implementing the game loop?
125 | if (dt == 0) return;
126 |
127 | this.player.update(dt, this.inputMap);
128 |
129 | let player_mins = this.player.position.add(this.player.mins);
130 | let player_maxs = this.player.position.add(this.player.maxs);
131 | this.scene.triggers.forEach((trigger) => {
132 | let trigger_mins = trigger.getBoundingInfo().boundingBox.minimumWorld;
133 | let trigger_maxs = trigger.getBoundingInfo().boundingBox.maximumWorld;
134 | if (Collisions.AABBsIntersect(trigger_mins, trigger_maxs, player_mins, player_maxs)) {
135 | if (!this.scene.triggersBeingTouched.has(trigger.name)) {
136 | this.scene.triggersBeingTouched.add(trigger.name);
137 | if (this.scene.triggerCallbacks[trigger.name]) {
138 | this.scene.triggerCallbacks[trigger.name](this);
139 | }
140 | }
141 | } else {
142 | this.scene.triggersBeingTouched.delete(trigger.name);
143 | }
144 | });
145 |
146 | this.scene.camera.position = new BABYLON.Vector3(this.player.position.x, this.player.position.y + this.player.eyeHeight, this.player.position.z);
147 |
148 | if (performance.now() >= this.nextHUDUpdate) {
149 | this.updateHUD(dt);
150 | this.nextHUDUpdate = performance.now() + 100;
151 | }
152 | }
153 |
154 | updateHUD(dt) {
155 | this.speedometerElement.innerHTML = Math.round(this.player.getHorizSpeed());
156 | this.debugElement.innerHTML = `pos: ${this.player.position.x.toFixed(2)},${this.player.position.y.toFixed(2)},${this.player.position.z.toFixed(2)}
`;
157 | this.debugElement.innerHTML += `vel: ${this.player.velocity.x.toFixed(2)},${this.player.velocity.y.toFixed(2)},${this.player.velocity.z.toFixed(2)}
`;
158 | this.debugElement.innerHTML += `onGround: ${this.player.onGround}
`;
159 | if (this.scene.debugTrace) {
160 | this.debugElement.innerHTML += `trace: fraction: ${this.scene.debugTrace.fraction} startsolid: ${this.scene.debugTrace.startsolid} allsolid: ${this.scene.debugTrace.allsolid} plane: ${this.scene.debugTrace.plane}
`;
161 | }
162 | }
163 |
164 | _initPointerLock() {
165 | var _this = this;
166 | // Request pointer lock
167 | var canvas = this.canvas;
168 | canvas.addEventListener("click", function(evt) {
169 | canvas.requestPointerLock = canvas.requestPointerLock || canvas.msRequestPointerLock || canvas.mozRequestPointerLock || canvas.webkitRequestPointerLock;
170 | if (canvas.requestPointerLock) {
171 | canvas.requestPointerLock();
172 | }
173 | }, false);
174 |
175 | // Event listener when the pointerlock is updated.
176 | var pointerlockchange = function (event) {
177 | _this.controlEnabled = (document.mozPointerLockElement === canvas || document.webkitPointerLockElement === canvas || document.msPointerLockElement === canvas || document.pointerLockElement === canvas);
178 | if (!_this.controlEnabled) {
179 | _this.scene.camera.detachControl(canvas);
180 | } else {
181 | _this.scene.camera.attachControl(canvas);
182 | }
183 | };
184 | document.addEventListener("pointerlockchange", pointerlockchange, false);
185 | document.addEventListener("mspointerlockchange", pointerlockchange, false);
186 | document.addEventListener("mozpointerlockchange", pointerlockchange, false);
187 | document.addEventListener("webkitpointerlockchange", pointerlockchange, false);
188 | }
189 |
190 | }
191 |
--------------------------------------------------------------------------------
/src/Player.js:
--------------------------------------------------------------------------------
1 | import * as Collisions from './Collisions.js';
2 |
3 | export default class Player {
4 |
5 | constructor(scene, position) {
6 | this.scene = scene;
7 | this.position = position;
8 | this.velocity = BABYLON.Vector3.Zero();
9 | this.onGround = true;
10 | this.moveSpeed = 400;
11 | this.height = 72;
12 | this.eyeHeight = this.height - 8;
13 | this.duckHeight = 36;
14 | this.duckEyeHeight = this.duckHeight - 6;
15 | this.jumpVelocity = 295;
16 | this.mins = new BABYLON.Vector3(-16, 0, -16);
17 | this.maxs = new BABYLON.Vector3(16, this.height, 16);
18 | // TODO this seems like the wrong place for this
19 | this.useStayOnGround = true;
20 | }
21 |
22 | update(dt, inputMap) {
23 | this.playerMove(dt, inputMap);
24 | }
25 |
26 | playerMove(dt, inputMap) {
27 | if (this.checkStuck()) {
28 | // this is kind of an unrecoverable state as of now, so just throw
29 | throw new Error("stuck and unable to get unstuck");
30 | }
31 | this.categorizePosition();
32 | this.addHalfGravity(dt);
33 |
34 | if(this.onGround && inputMap[" "]) {
35 | this.jump();
36 | // this is done in jump normally, extracted out to here instead
37 | // from HL: "Decay it for simulation"
38 | this.addHalfGravity(dt);
39 | }
40 |
41 | if (this.onGround) {
42 | this.velocity.y = 0;
43 | this.applyFriction(dt, this.scene.friction);
44 | }
45 |
46 | var wishDir = this.getWishDirection(inputMap);
47 | if (this.onGround) {
48 | this.groundMove(dt, wishDir);
49 | } else {
50 | this.airMove(dt, wishDir);
51 | }
52 |
53 | this.categorizePosition();
54 | this.addHalfGravity(dt);
55 |
56 | if (this.onGround) {
57 | this.velocity.y = 0;
58 | }
59 | }
60 |
61 | // this is Quake 1's version of handling stuckness; it's very simple compared to HL1's
62 | // This function assumes that we are currently stuck,
63 | // Returns true if able to get unstuck, false otherwise.
64 | nudgePosition() {
65 | var testPosition = new BABYLON.Vector3();
66 | var nudge = [0, -1/8, 1/8];
67 | var x, y, z;
68 | // try nudging in every possible combination of directions
69 | for (z=0; z<3; z++) {
70 | for (x=0; x<3; x++) {
71 | for (y=0; y<3; y++) {
72 | testPosition.x = this.position.x + nudge[x];
73 | testPosition.y = this.position.y + nudge[y];
74 | testPosition.z = this.position.z + nudge[z];
75 | // if we are not stuck anymore, we're done
76 | if (Collisions.PlayerTestPosition(this.scene.meshes, testPosition, this.mins, this.maxs)) {
77 | this.position = testPosition;
78 | return true;
79 | }
80 | }
81 | }
82 | }
83 | return false;
84 | }
85 |
86 | // Returns true if we are stuck and we weren't able to get unstuck
87 | checkStuck() {
88 | var wasStuck = !Collisions.PlayerTestPosition(this.scene.meshes, this.position, this.mins, this.maxs);
89 | var didUnstuck = false;
90 | if (wasStuck) {
91 | // TODO: more robust stuckness handling if nudgePosition on its own isn't adequate
92 | didUnstuck = this.nudgePosition();
93 | }
94 | return wasStuck && !didUnstuck;
95 | }
96 |
97 | groundMove(dt, wishDir) {
98 | this.accelerate(dt, wishDir, this.moveSpeed, this.scene.accel);
99 | var wasOnGround = this.onGround;
100 | var dest = new BABYLON.Vector3(
101 | this.position.x + this.velocity.x * dt,
102 | this.position.y,
103 | this.position.z + this.velocity.z * dt
104 | );
105 | var trace = Collisions.PlayerTrace(this.scene.meshes, this.position, dest, this.mins, this.maxs);
106 | if (trace.fraction == 1) {
107 | this.position = dest;
108 | } else {
109 | this.stairMove(dt);
110 | }
111 | if (this.useStayOnGround) {
112 | this.stayOnGround();
113 | }
114 | }
115 |
116 | // This is a Source-engine-specific function that allows players to
117 | // walk down slopes and stairs without leaving the ground.
118 | stayOnGround() {
119 | var start = new BABYLON.Vector3(
120 | this.position.x,
121 | this.position.y + 2,
122 | this.position.z
123 | );
124 | var end = new BABYLON.Vector3(
125 | this.position.x,
126 | this.position.y - this.scene.stepsize,
127 | this.position.z
128 | );
129 |
130 | // See how far up we can go without getting stuck
131 | var trace = Collisions.PlayerTrace(this.scene.meshes, this.position, start, this.mins, this.maxs);
132 | start = trace.endpos;
133 |
134 | // Now trace down from a known safe position
135 | trace = Collisions.PlayerTrace(this.scene.meshes, start, end, this.mins, this.maxs);
136 | if (trace.fraction > 0 && // must go somewhere
137 | trace.fraction < 1 && // must hit something
138 | !trace.startsolid && // can't be embedded in a solid
139 | trace.plane.normal.y >= 0.7) // can't hit a too-steep slope
140 | {
141 | this.position = trace.endpos;
142 | }
143 | }
144 |
145 | stairMove(dt) {
146 | var stepsize = this.scene.stepsize;
147 | var originalPosition = this.position.clone();
148 | var originalVelocity = this.velocity.clone();
149 |
150 | var clip = this.slideMove(dt);
151 |
152 | var downPosition = this.position.clone();
153 | var downVelocity = this.velocity.clone();
154 |
155 | this.position = originalPosition.clone();
156 | this.velocity = originalVelocity.clone();
157 |
158 | var dest = this.position.clone();
159 | dest.y += stepsize;
160 |
161 | var trace = Collisions.PlayerTrace(this.scene.meshes, this.position, dest, this.mins, this.maxs);
162 | if (!trace.startsolid && !trace.allsolid) {
163 | this.position = trace.endpos.clone();
164 | }
165 |
166 | clip = this.slideMove(dt);
167 |
168 | dest = this.position.clone();
169 | dest.y -= stepsize;
170 |
171 | trace = Collisions.PlayerTrace(this.scene.meshes, this.position, dest, this.mins, this.maxs);
172 | if (!trace.plane || trace.plane.normal.y < 0.7) {
173 | this.position = downPosition;
174 | this.velocity = downVelocity;
175 | return;
176 | }
177 |
178 | if (!trace.startsolid && !trace.allsolid) {
179 | this.position = trace.endpos;
180 | }
181 |
182 | var upPosition = this.position.clone();
183 |
184 | var downdist = (downPosition.x-originalPosition.x)*(downPosition.x-originalPosition.x) +
185 | (downPosition.z-originalPosition.z)*(downPosition.z-originalPosition.z);
186 | var updist = (upPosition.x-originalPosition.x)*(upPosition.x-originalPosition.x) +
187 | (upPosition.z-originalPosition.z)*(upPosition.z-originalPosition.z);
188 |
189 | if (downdist > updist) {
190 | this.position = downPosition;
191 | this.velocity = downVelocity;
192 | } else {
193 | this.velocity.y = downVelocity.y;
194 | }
195 | }
196 |
197 | airMove(dt, wishDir) {
198 | this.airAccelerate(dt, wishDir, this.moveSpeed, this.scene.airAccel);
199 | this.slideMove(dt);
200 | }
201 |
202 | clipVelocity(velocity, normal, overbounce) {
203 | if (!normal) { normal = BABYLON.Vector3.Zero(); }
204 | const STOP_EPSILON = 0.1;
205 | var angle = normal.y;
206 | var blocked = 0;
207 | if (angle > 0)
208 | blocked |= 1;
209 | if (angle === 0)
210 | blocked |= 2;
211 |
212 | var backoff = BABYLON.Vector3.Dot(velocity, normal) * overbounce;
213 |
214 | var apply = function(compVel, compNorm) {
215 | var change = compNorm*backoff;
216 | var compOut = compVel - change;
217 | if (compOut > -STOP_EPSILON && compOut < STOP_EPSILON)
218 | compOut = 0;
219 | return compOut;
220 | };
221 | var newVelocity = new BABYLON.Vector3(
222 | apply(velocity.x, normal.x),
223 | apply(velocity.y, normal.y),
224 | apply(velocity.z, normal.z)
225 | );
226 |
227 | // this was a new addition in the source engine
228 | var adjust = BABYLON.Vector3.Dot(newVelocity, normal);
229 | if( adjust < 0.0 ) {
230 | newVelocity.x -= normal.x * adjust;
231 | newVelocity.y -= normal.y * adjust;
232 | newVelocity.z -= normal.z * adjust;
233 | }
234 |
235 | return {
236 | blocked: blocked,
237 | velocity: newVelocity
238 | };
239 | }
240 |
241 | // called PM_FlyMove in HL: applies velocity while sliding along touched planes
242 | slideMove(dt) {
243 | const MAX_CLIP_PLANES = 5;
244 | var numbumps = 4;
245 | var blocked = 0;
246 | var numplanes = 0;
247 | var originalVelocity = this.velocity.clone();
248 | var primalVelocity = this.velocity.clone();
249 | var planes = [];
250 |
251 | var allFraction = 0;
252 | var timeLeft = dt;
253 |
254 | for (var bumpcount=0; bumpcount 0) {
274 | this.position = trace.endpos.clone();
275 | originalVelocity = this.velocity.clone();
276 | numplanes = 0;
277 | }
278 |
279 | if (trace.fraction == 1) {
280 | break;
281 | }
282 |
283 | //PM_AddToTouched(trace, pmove->velocity);
284 |
285 | if (trace.plane.normal.y > 0.7) {
286 | blocked |= 1;
287 | }
288 |
289 | if (trace.plane.normal.y === 0) {
290 | blocked |= 2;
291 | }
292 |
293 | timeLeft -= timeLeft * trace.fraction;
294 |
295 | if (numplanes >= MAX_CLIP_PLANES) {
296 | // this shouldn't happen
297 | this.velocity = BABYLON.Vector3.Zero();
298 | break;
299 | }
300 |
301 | planes[numplanes] = trace.plane.normal;
302 | numplanes++;
303 |
304 | if (!this.onGround) {
305 | var newVelocity;
306 | for (let i=0; i 0.7) {
308 | let clipped = this.clipVelocity(originalVelocity, planes[i], 1);
309 | newVelocity = clipped.velocity;
310 | }
311 | else {
312 | let clipped = this.clipVelocity(originalVelocity, planes[i], 1.0 /*+ pmove->movevars->bounce * (1-pmove->friction)*/);
313 | newVelocity = clipped.velocity;
314 | }
315 | }
316 | this.velocity = newVelocity.clone();
317 | originalVelocity = newVelocity.clone();
318 | }
319 | else {
320 | var i;
321 | for (i=0; i 180) {
419 | this.onGround = false;
420 | }
421 | else {
422 | var tr = Collisions.PlayerTrace(this.scene.meshes, this.position, point, this.mins, this.maxs);
423 | if (!tr.plane || tr.plane.normal.y < 0.7) {
424 | this.onGround = false;
425 | }
426 | else {
427 | this.onGround = true;
428 | // move the player based on the trace so they don't float slightly above the ground
429 | if (!this.useStayOnGround && !tr.startsolid && !tr.allsolid) {
430 | this.position = tr.endpos;
431 | }
432 | }
433 | }
434 | }
435 |
436 | jump() {
437 | this.onGround = false;
438 | this.velocity.y += this.jumpVelocity;
439 | }
440 |
441 | accelerate(dt, wishDir, wishSpeed, accel) {
442 | var currentSpeed = BABYLON.Vector3.Dot(this.velocity, wishDir);
443 | var addSpeed = wishSpeed - currentSpeed;
444 | if (addSpeed <= 0)
445 | return;
446 |
447 | var accelSpeed = accel * wishSpeed * dt; // * friction (personal friction?)
448 |
449 | if (accelSpeed > addSpeed) {
450 | accelSpeed = addSpeed;
451 | }
452 |
453 | this.velocity.x += accelSpeed * wishDir.x;
454 | this.velocity.y += accelSpeed * wishDir.y;
455 | this.velocity.z += accelSpeed * wishDir.z;
456 | }
457 |
458 | airAccelerate(dt, wishDir, wishSpeed, accel) {
459 | var wishSpd = wishSpeed;
460 | if (wishSpd > 30) {
461 | wishSpd = 30;
462 | }
463 | var currentSpeed = BABYLON.Vector3.Dot(this.velocity, wishDir);
464 | var addSpeed = wishSpd - currentSpeed;
465 | if (addSpeed <= 0)
466 | return;
467 |
468 | var accelSpeed = accel * wishSpeed * dt;
469 | if (accelSpeed > addSpeed) {
470 | accelSpeed = addSpeed;
471 | }
472 |
473 | this.velocity.x += accelSpeed * wishDir.x;
474 | this.velocity.y += accelSpeed * wishDir.y;
475 | this.velocity.z += accelSpeed * wishDir.z;
476 | }
477 |
478 | addHalfGravity(dt) {
479 | var gravity = this.scene.gravity;
480 | this.velocity.y -= gravity * 0.5 * dt;
481 | }
482 |
483 | getHorizSpeed() {
484 | return Math.sqrt(this.velocity.x * this.velocity.x + this.velocity.z * this.velocity.z);
485 | }
486 |
487 | conc() {
488 | const LATERAL_POWER = 2.74;
489 | const VERTICAL_POWER = 4.10;
490 | const GROUND_UP_PUSH = 90;
491 |
492 | if (this.onGround) {
493 | this.velocity = new BABYLON.Vector3(
494 | this.velocity.x * LATERAL_POWER * 0.95,
495 | (this.velocity.y + GROUND_UP_PUSH) * VERTICAL_POWER,
496 | this.velocity.z * LATERAL_POWER * 0.95
497 | );
498 | }
499 | else {
500 | this.velocity.multiplyInPlace(new BABYLON.Vector3(LATERAL_POWER, VERTICAL_POWER, LATERAL_POWER));
501 | }
502 | }
503 | }
504 |
--------------------------------------------------------------------------------