ArraySchema: fix .clear() operation usage with StateView.

Author: endel

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/schema",
-  "version": "3.0.32",
+  "version": "3.0.33",
   "description": "Binary state serializer with delta encoding for games",
   "bin": {
     "schema-codegen": "./bin/schema-codegen",

src/encoder/ChangeTree.ts

@@ -241,9 +241,14 @@ export class ChangeTree<T extends Ref=any> {
     operation(op: OPERATION) {
         // operations without index use negative values to represent them
         // this is checked during .encode() time.
-        this.changes.operations.push(-op);
+        if (this.filteredChanges !== undefined) {
+            this.filteredChanges.operations.push(-op);
+            enqueueChangeTree(this.root, this, 'filteredChanges');
 
-        enqueueChangeTree(this.root, this, 'changes');
+        } else {
+            this.changes.operations.push(-op);
+            enqueueChangeTree(this.root, this, 'changes');
+        }
     }
 
     change(index: number, operation: OPERATION = OPERATION.ADD) {

test/ArraySchema.test.ts

@@ -2383,6 +2383,60 @@ describe("ArraySchema Tests", () => {
 
             assertDeepStrictEqualEncodeAll(state);
         });
+
+        it("should allow clear + push", () => {
+            class Player extends Schema {
+                @type(["string"]) public hand = new ArraySchema<string>();
+                @type(["string"]) public deck = new ArraySchema<string>();
+            }
+            class State extends Schema {
+                @type({ map: Player }) players = new MapSchema<Player>();
+            }
+            const state = new State();
+            const decodedState = createInstanceFromReflection(state);
+
+            function createPlayer() {
+                const player = new Player();
+                for (let i = 0; i < 10; i++) {
+                    player.deck.push(`card${i}`);
+                }
+                player.hand.push(player.deck.pop());
+                player.hand.push(player.deck.pop());
+                player.hand.push(player.deck.pop());
+                return player;
+            }
+
+            const player1 = createPlayer();
+            const player2 = createPlayer();
+
+            state.players.set("one", player1);
+            state.players.set("two", player2);
+
+            decodedState.decode(state.encode());
+            assert.strictEqual(decodedState.players.size, 2);
+            assert.strictEqual(decodedState.players.get("one").hand.length, 3);
+            assert.strictEqual(decodedState.players.get("one").deck.length, 7);
+            assert.strictEqual(decodedState.players.get("two").hand.length, 3);
+            assert.strictEqual(decodedState.players.get("two").deck.length, 7);
+
+            player1.hand.clear();
+            player1.hand.push("card1");
+            player1.hand.push("card2");
+
+            player2.hand.clear();
+            player2.hand.push("card1");
+            player2.hand.push("card2");
+
+            decodedState.decode(state.encode());
+            assert.strictEqual(decodedState.players.size, 2);
+            assert.strictEqual(decodedState.players.get("one").hand.length, 2);
+            assert.strictEqual(decodedState.players.get("one").deck.length, 7);
+            assert.strictEqual(decodedState.players.get("two").hand.length, 2);
+            assert.strictEqual(decodedState.players.get("two").deck.length, 7);
+            assert.deepStrictEqual(state.toJSON(), decodedState.toJSON());
+
+            assertDeepStrictEqualEncodeAll(state);
+        });
     })
 
     describe("array methods", () => {

test/StateView.test.ts

@@ -1585,6 +1585,73 @@ describe("StateView", () => {
 
             assertEncodeAllMultiple(encoder, state, [client]);
         });
+
+        it("should allow clear and push on filtered array", () => {
+            class Player extends Schema {
+                @view() @type(["string"]) public hand = new ArraySchema<string>();
+                @view() @type(["string"]) public deck = new ArraySchema<string>();
+            }
+            class State extends Schema {
+                @type({ map: Player }) players = new MapSchema<Player>();
+            }
+            const state = new State();
+            const encoder = getEncoder(state);
+
+            const client1 = createClientWithView(state);
+            const client2 = createClientWithView(state);
+
+            function createPlayer() {
+                const player = new Player();
+                for (let i = 0; i < 10; i++) {
+                    player.deck.push(`card${i}`);
+                }
+                player.hand.push(player.deck.pop());
+                player.hand.push(player.deck.pop());
+                player.hand.push(player.deck.pop());
+                return player;
+            }
+
+            const player1 = createPlayer();
+            const player2 = createPlayer();
+
+            state.players.set("one", player1);
+            state.players.set("two", player2);
+
+            encodeMultiple(encoder, state, [client1, client2]);
+            assert.strictEqual(client1.state.players.size, 2);
+            assert.strictEqual(client1.state.players.get("one").hand, undefined);
+            assert.strictEqual(client2.state.players.size, 2);
+            assert.strictEqual(client2.state.players.get("two").hand, undefined);
+
+            client1.view.add(player1);
+            client2.view.add(player2);
+
+            encodeMultiple(encoder, state, [client1, client2]);
+            assert.strictEqual(client1.state.players.size, 2);
+            assert.strictEqual(client1.state.players.get("one").hand.length, 3);
+            assert.strictEqual(client1.state.players.get("one").deck.length, 7);
+            assert.strictEqual(client2.state.players.size, 2);
+            assert.strictEqual(client2.state.players.get("two").hand.length, 3);
+            assert.strictEqual(client2.state.players.get("two").deck.length, 7);
+
+            player1.hand.clear();
+            player1.hand.push("card1");
+            player1.hand.push("card2");
+
+            player2.hand.clear();
+            player2.hand.push("card1");
+            player2.hand.push("card2");
+
+            console.log(Schema.debugRefIds(state));
+
+            encodeMultiple(encoder, state, [client1, client2]);
+            assert.strictEqual(client1.state.players.get("one").hand.length, 2);
+            assert.strictEqual(client1.state.players.get("one").deck.length, 7);
+            assert.strictEqual(client2.state.players.get("two").hand.length, 2);
+            assert.strictEqual(client2.state.players.get("two").deck.length, 7);
+
+            assertEncodeAllMultiple(encoder, state, [client1, client2]);
+        });
     });
 
     describe("Deep and nested structures", () => {