138 lines
3.3 KiB
JavaScript
138 lines
3.3 KiB
JavaScript
import {compose} from '@avocado/core';
|
|
import {Vector} from '@avocado/math';
|
|
import {EventEmitter} from '@avocado/mixins';
|
|
|
|
import {Trait} from '../trait';
|
|
|
|
const decorate = compose(
|
|
EventEmitter,
|
|
Vector.Mixin('_position', 'x', 'y', {
|
|
track: true,
|
|
}),
|
|
Vector.Mixin('serverPosition', 'serverX', 'serverY', {
|
|
track: true,
|
|
}),
|
|
);
|
|
|
|
// < 16768 will pack into 1 short per axe and give +/- 0.25 precision.
|
|
class PositionedBase extends Trait {
|
|
|
|
static defaultState() {
|
|
return {
|
|
x: 0,
|
|
y: 0,
|
|
};
|
|
}
|
|
|
|
initialize() {
|
|
this.on('_positionChanged', (oldPosition, newPosition) => {
|
|
if (AVOCADO_SERVER) {
|
|
const x = Math.floor(newPosition[0]) * 4;
|
|
const y = Math.floor(newPosition[1]) * 4;
|
|
this.state = this.state.withMutations((state) => {
|
|
state.set('x', x).set('y', y);
|
|
});
|
|
this.isDirty = true;
|
|
}
|
|
if (oldPosition[0] !== newPosition[0]) {
|
|
this.entity.emit('xChanged', oldPosition[0], newPosition[0]);
|
|
}
|
|
if (oldPosition[1] !== newPosition[1]) {
|
|
this.entity.emit('yChanged', oldPosition[1], newPosition[1]);
|
|
}
|
|
this.entity.emit('positionChanged', oldPosition, newPosition);
|
|
});
|
|
const x = this.state.get('x') / 4;
|
|
const y = this.state.get('y') / 4;
|
|
this._position = [x, y];
|
|
if (AVOCADO_CLIENT) {
|
|
this._relaxServerPositionConstraintIfNearerThan = 0;
|
|
this.serverPosition = this._position;
|
|
this.serverPositionDirty = false;
|
|
this.on('serverPositionChanged', () => {
|
|
this.serverPositionDirty = true;
|
|
});
|
|
}
|
|
}
|
|
|
|
patchStateStep(key, step) {
|
|
if ('state' !== key) {
|
|
return;
|
|
}
|
|
const stateKey = step.path.substr(1);
|
|
const value = this.transformPatchValue(stateKey, step.value);
|
|
switch (stateKey) {
|
|
case 'x':
|
|
this.serverX = value;
|
|
break;
|
|
case 'y':
|
|
this.serverY = value;
|
|
break;
|
|
default:
|
|
super.patchStateStep(key, step);
|
|
break;
|
|
}
|
|
}
|
|
|
|
get position() {
|
|
return this._position;
|
|
}
|
|
|
|
set position(position) {
|
|
this._position = position;
|
|
}
|
|
|
|
set relaxServerPositionConstraintIfNearerThan(nearerThan) {
|
|
this._relaxServerPositionConstraintIfNearerThan = nearerThan;
|
|
}
|
|
|
|
transformPatchValue(key, value) {
|
|
if (-1 !== ['x', 'y'].indexOf(key)) {
|
|
return value / 4;
|
|
}
|
|
super.transformPatchValue(key, value);
|
|
}
|
|
|
|
listeners() {
|
|
return {
|
|
|
|
isTickingChanged: () => {
|
|
// Snap position on ticking change.
|
|
if (AVOCADO_CLIENT) {
|
|
this._position = this.serverPosition;
|
|
}
|
|
},
|
|
|
|
};
|
|
}
|
|
|
|
renderTick(elapsed) {
|
|
if (!this.serverPositionDirty) {
|
|
return;
|
|
}
|
|
if (Vector.equals(this._position, this.serverPosition)) {
|
|
return;
|
|
}
|
|
if (Vector.equalsClose(this._position, this.serverPosition, 0.1)) {
|
|
this._position = this.serverPosition;
|
|
return;
|
|
}
|
|
const diff = Vector.sub(this.serverPosition, this._position);
|
|
const nearerThan = this._relaxServerPositionConstraintIfNearerThan;
|
|
let lerp;
|
|
if (
|
|
nearerThan
|
|
&& Vector.equalsClose(this._position, this.serverPosition, nearerThan)
|
|
) {
|
|
lerp = .01;
|
|
}
|
|
else {
|
|
lerp = .5;
|
|
}
|
|
this._position = Vector.add(this._position, Vector.scale(diff, lerp));
|
|
}
|
|
|
|
}
|
|
|
|
export class Positioned extends decorate(PositionedBase) {}
|