Estoy desarrollando un programa donde tengo muchas clases que necesitan almacenar tanto el valor actual como el valor anterior. Por ejemplo, una clase Player que necesitaría almacenar su x actual (y x anterior), su y actual (y anterior y ), etc. Además, también quiero poder obtener las versiones interpoladas de estos valores. Entonces, por ejemplo, podría obtener el punto medio entre la x anterior y la x actual.

De momento lo estoy haciendo así:

 class Player { private _x: number; private _prevX: number; constructor() { this._x = 0; this._prevX = 0; } get x() { return this._x; } set x(val: number) { this._prevX = this._x; this._x = val; } interX(t: number) { return (1 - t) * this._prevX + this._x * t; } }

Y esto es bueno porque solo puedo hacer player.x para obtener el valor actual de x , y player.x = 5 para establecer el valor actual de x (y también establecer automáticamente el valor anterior). Obtener el valor actual es una operación extremadamente común.

Sin embargo, no es tan agradable debido a todo el repetitivo. Cuando tengo 5 valores diferentes de los que quiero almacenar tanto los valores actuales como los anteriores, se vuelve muy detallado. Entonces, pensé en probar esto en su lugar:

 class Interpolate { prev: number; curr: number; constructor(prev: number, curr: number) { this.prev = prev; this.curr = curr; } set(val: number) { this.prev = this.curr; this.curr = val; } interpolate(t: number) { return (1 - t) * this.prev + this.curr * t; } } class Player { x: Interpolate; y: Interpolate; constructor() { this.x = new Interpolate(0, 0); this.y = new Interpolate(0, 0); } }

Y si bien esto es bueno, ahora tiene el problema de que para obtener el valor actual, tengo que hacer player.x.curr y player.y.curr . ¡No tan agradable!

¿Hay alguna manera de tener mi pastel y comérmelo también? Idealmente, me gustaría poder hacer algo como esto:

 let foo = player.x; // gets currentX value player.x = 55; // also sets prevX player.x.inter(0.5); // gets halfway point between previous and current

Pero la única forma en que sé cómo hacer esto es con la primera solución, que llena todas mis clases con una tonelada de repetición y lógica repetitiva propensa a errores.

Además, si es posible, la solución debe ser bastante eficaz (esto es para un juego, por lo que dudo que pueda usar algo como un proxy complejo para una propiedad como la posición del jugador)