Merge branch 'feat/reload_field' into 'main'

Feat/reload field

See merge request mycard/Neos!148

neos-protobuf @ 4f6cdd7c

-Subproject commit 96e06224838437a6cd0c985070f31ddedc08ad89
+Subproject commit 4f6cdd7ccc3b11b39ff8aa649e423bcf401f7ad5

src/api/ocgcore/idl/ocgcore.ts

@@ -5446,7 +5446,7 @@ export namespace ygopro {
     #one_of_decls: number[][] = [
       [
         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-        21, 22, 23,
+        21, 22, 23, 24,
       ],
     ];
     constructor(
@@ -5477,6 +5477,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5502,6 +5503,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5527,6 +5529,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5552,6 +5555,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5577,6 +5581,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5602,6 +5607,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5627,6 +5633,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5652,6 +5659,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5677,6 +5685,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5702,6 +5711,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5727,6 +5737,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5752,6 +5763,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5777,6 +5789,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5802,6 +5815,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5827,6 +5841,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5852,6 +5867,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5877,6 +5893,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5902,6 +5919,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5927,6 +5945,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5952,6 +5971,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -5977,6 +5997,7 @@ export namespace ygopro {
                 wait?: StocGameMessage.MsgWait;
                 unimplemented?: never;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -6002,6 +6023,7 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: StocGameMessage.MsgUnimplemented;
                 update_data?: never;
+                reload_field?: never;
               }
             | {
                 start?: never;
@@ -6027,6 +6049,33 @@ export namespace ygopro {
                 wait?: never;
                 unimplemented?: never;
                 update_data?: StocGameMessage.MsgUpdateData;
+                reload_field?: never;
+              }
+            | {
+                start?: never;
+                draw?: never;
+                new_turn?: never;
+                new_phase?: never;
+                hint?: never;
+                select_idle_cmd?: never;
+                select_place?: never;
+                move?: never;
+                select_card?: never;
+                select_chain?: never;
+                select_effect_yn?: never;
+                select_position?: never;
+                select_option?: never;
+                shuffle_hand?: never;
+                select_battle_cmd?: never;
+                pos_change?: never;
+                select_unselect_card?: never;
+                select_yes_no?: never;
+                update_hp?: never;
+                win?: never;
+                wait?: never;
+                unimplemented?: never;
+                update_data?: never;
+                reload_field?: StocGameMessage.MsgReloadField;
               }
           ))
     ) {
@@ -6115,6 +6164,9 @@ export namespace ygopro {
         if ("update_data" in data && data.update_data != undefined) {
           this.update_data = data.update_data;
         }
+        if ("reload_field" in data && data.reload_field != undefined) {
+          this.reload_field = data.reload_field;
+        }
       }
     }
     get start() {
@@ -6416,6 +6468,19 @@ export namespace ygopro {
     get has_update_data() {
       return pb_1.Message.getField(this, 23) != null;
     }
+    get reload_field() {
+      return pb_1.Message.getWrapperField(
+        this,
+        StocGameMessage.MsgReloadField,
+        24
+      ) as StocGameMessage.MsgReloadField;
+    }
+    set reload_field(value: StocGameMessage.MsgReloadField) {
+      pb_1.Message.setOneofWrapperField(this, 24, this.#one_of_decls[0], value);
+    }
+    get has_reload_field() {
+      return pb_1.Message.getField(this, 24) != null;
+    }
     get gameMsg() {
       const cases: {
         [index: number]:
@@ -6442,7 +6507,8 @@ export namespace ygopro {
           | "win"
           | "wait"
           | "unimplemented"
-          | "update_data";
+          | "update_data"
+          | "reload_field";
       } = {
         0: "none",
         1: "start",
@@ -6468,13 +6534,14 @@ export namespace ygopro {
         21: "wait",
         22: "unimplemented",
         23: "update_data",
+        24: "reload_field",
       };
       return cases[
         pb_1.Message.computeOneofCase(
           this,
           [
             1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
-            20, 21, 22, 23,
+            20, 21, 22, 23, 24,
           ]
         )
       ];
@@ -6537,6 +6604,9 @@ export namespace ygopro {
       update_data?: ReturnType<
         typeof StocGameMessage.MsgUpdateData.prototype.toObject
       >;
+      reload_field?: ReturnType<
+        typeof StocGameMessage.MsgReloadField.prototype.toObject
+      >;
     }): StocGameMessage {
       const message = new StocGameMessage({});
       if (data.start != null) {
@@ -6640,6 +6710,11 @@ export namespace ygopro {
           data.update_data
         );
       }
+      if (data.reload_field != null) {
+        message.reload_field = StocGameMessage.MsgReloadField.fromObject(
+          data.reload_field
+        );
+      }
       return message;
     }
     toObject() {
@@ -6701,6 +6776,9 @@ export namespace ygopro {
         update_data?: ReturnType<
           typeof StocGameMessage.MsgUpdateData.prototype.toObject
         >;
+        reload_field?: ReturnType<
+          typeof StocGameMessage.MsgReloadField.prototype.toObject
+        >;
       } = {};
       if (this.start != null) {
         data.start = this.start.toObject();
@@ -6771,6 +6849,9 @@ export namespace ygopro {
       if (this.update_data != null) {
         data.update_data = this.update_data.toObject();
       }
+      if (this.reload_field != null) {
+        data.reload_field = this.reload_field.toObject();
+      }
       return data;
     }
     serialize(): Uint8Array;
@@ -6857,6 +6938,10 @@ export namespace ygopro {
         writer.writeMessage(23, this.update_data, () =>
           this.update_data.serialize(writer)
         );
+      if (this.has_reload_field)
+        writer.writeMessage(24, this.reload_field, () =>
+          this.reload_field.serialize(writer)
+        );
       if (!w) return writer.getResultBuffer();
     }
     static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StocGameMessage {
@@ -7041,6 +7126,14 @@ export namespace ygopro {
                   StocGameMessage.MsgUpdateData.deserialize(reader))
             );
             break;
+          case 24:
+            reader.readMessage(
+              message.reload_field,
+              () =>
+                (message.reload_field =
+                  StocGameMessage.MsgReloadField.deserialize(reader))
+            );
+            break;
           default:
             reader.skipField();
         }
@@ -12519,5 +12612,707 @@ export namespace ygopro {
         }
       }
     }
+    export class MsgReloadField extends pb_1.Message {
+      #one_of_decls: number[][] = [];
+      constructor(
+        data?:
+          | any[]
+          | {
+              duel_rule?: number;
+              actions?: StocGameMessage.MsgReloadField.Action[];
+            }
+      ) {
+        super();
+        pb_1.Message.initialize(
+          this,
+          Array.isArray(data) ? data : [],
+          0,
+          -1,
+          [2],
+          this.#one_of_decls
+        );
+        if (!Array.isArray(data) && typeof data == "object") {
+          if ("duel_rule" in data && data.duel_rule != undefined) {
+            this.duel_rule = data.duel_rule;
+          }
+          if ("actions" in data && data.actions != undefined) {
+            this.actions = data.actions;
+          }
+        }
+      }
+      get duel_rule() {
+        return pb_1.Message.getFieldWithDefault(this, 1, 0) as number;
+      }
+      set duel_rule(value: number) {
+        pb_1.Message.setField(this, 1, value);
+      }
+      get actions() {
+        return pb_1.Message.getRepeatedWrapperField(
+          this,
+          StocGameMessage.MsgReloadField.Action,
+          2
+        ) as StocGameMessage.MsgReloadField.Action[];
+      }
+      set actions(value: StocGameMessage.MsgReloadField.Action[]) {
+        pb_1.Message.setRepeatedWrapperField(this, 2, value);
+      }
+      static fromObject(data: {
+        duel_rule?: number;
+        actions?: ReturnType<
+          typeof StocGameMessage.MsgReloadField.Action.prototype.toObject
+        >[];
+      }): MsgReloadField {
+        const message = new MsgReloadField({});
+        if (data.duel_rule != null) {
+          message.duel_rule = data.duel_rule;
+        }
+        if (data.actions != null) {
+          message.actions = data.actions.map((item) =>
+            StocGameMessage.MsgReloadField.Action.fromObject(item)
+          );
+        }
+        return message;
+      }
+      toObject() {
+        const data: {
+          duel_rule?: number;
+          actions?: ReturnType<
+            typeof StocGameMessage.MsgReloadField.Action.prototype.toObject
+          >[];
+        } = {};
+        if (this.duel_rule != null) {
+          data.duel_rule = this.duel_rule;
+        }
+        if (this.actions != null) {
+          data.actions = this.actions.map(
+            (item: StocGameMessage.MsgReloadField.Action) => item.toObject()
+          );
+        }
+        return data;
+      }
+      serialize(): Uint8Array;
+      serialize(w: pb_1.BinaryWriter): void;
+      serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
+        const writer = w || new pb_1.BinaryWriter();
+        if (this.duel_rule != 0) writer.writeInt32(1, this.duel_rule);
+        if (this.actions.length)
+          writer.writeRepeatedMessage(
+            2,
+            this.actions,
+            (item: StocGameMessage.MsgReloadField.Action) =>
+              item.serialize(writer)
+          );
+        if (!w) return writer.getResultBuffer();
+      }
+      static deserialize(
+        bytes: Uint8Array | pb_1.BinaryReader
+      ): MsgReloadField {
+        const reader =
+            bytes instanceof pb_1.BinaryReader
+              ? bytes
+              : new pb_1.BinaryReader(bytes),
+          message = new MsgReloadField();
+        while (reader.nextField()) {
+          if (reader.isEndGroup()) break;
+          switch (reader.getFieldNumber()) {
+            case 1:
+              message.duel_rule = reader.readInt32();
+              break;
+            case 2:
+              reader.readMessage(message.actions, () =>
+                pb_1.Message.addToRepeatedWrapperField(
+                  message,
+                  2,
+                  StocGameMessage.MsgReloadField.Action.deserialize(reader),
+                  StocGameMessage.MsgReloadField.Action
+                )
+              );
+              break;
+            default:
+              reader.skipField();
+          }
+        }
+        return message;
+      }
+      serializeBinary(): Uint8Array {
+        return this.serialize();
+      }
+      static deserializeBinary(bytes: Uint8Array): MsgReloadField {
+        return MsgReloadField.deserialize(bytes);
+      }
+    }
+    export namespace MsgReloadField {
+      export class ZoneAction extends pb_1.Message {
+        #one_of_decls: number[][] = [];
+        constructor(
+          data?:
+            | any[]
+            | {
+                zone?: CardZone;
+                sequence?: number;
+                position?: number;
+                overlay_count?: number;
+              }
+        ) {
+          super();
+          pb_1.Message.initialize(
+            this,
+            Array.isArray(data) ? data : [],
+            0,
+            -1,
+            [],
+            this.#one_of_decls
+          );
+          if (!Array.isArray(data) && typeof data == "object") {
+            if ("zone" in data && data.zone != undefined) {
+              this.zone = data.zone;
+            }
+            if ("sequence" in data && data.sequence != undefined) {
+              this.sequence = data.sequence;
+            }
+            if ("position" in data && data.position != undefined) {
+              this.position = data.position;
+            }
+            if ("overlay_count" in data && data.overlay_count != undefined) {
+              this.overlay_count = data.overlay_count;
+            }
+          }
+        }
+        get zone() {
+          return pb_1.Message.getFieldWithDefault(
+            this,
+            1,
+            CardZone.DECK
+          ) as CardZone;
+        }
+        set zone(value: CardZone) {
+          pb_1.Message.setField(this, 1, value);
+        }
+        get sequence() {
+          return pb_1.Message.getFieldWithDefault(this, 2, 0) as number;
+        }
+        set sequence(value: number) {
+          pb_1.Message.setField(this, 2, value);
+        }
+        get position() {
+          return pb_1.Message.getFieldWithDefault(this, 3, 0) as number;
+        }
+        set position(value: number) {
+          pb_1.Message.setField(this, 3, value);
+        }
+        get overlay_count() {
+          return pb_1.Message.getFieldWithDefault(this, 4, 0) as number;
+        }
+        set overlay_count(value: number) {
+          pb_1.Message.setField(this, 4, value);
+        }
+        static fromObject(data: {
+          zone?: CardZone;
+          sequence?: number;
+          position?: number;
+          overlay_count?: number;
+        }): ZoneAction {
+          const message = new ZoneAction({});
+          if (data.zone != null) {
+            message.zone = data.zone;
+          }
+          if (data.sequence != null) {
+            message.sequence = data.sequence;
+          }
+          if (data.position != null) {
+            message.position = data.position;
+          }
+          if (data.overlay_count != null) {
+            message.overlay_count = data.overlay_count;
+          }
+          return message;
+        }
+        toObject() {
+          const data: {
+            zone?: CardZone;
+            sequence?: number;
+            position?: number;
+            overlay_count?: number;
+          } = {};
+          if (this.zone != null) {
+            data.zone = this.zone;
+          }
+          if (this.sequence != null) {
+            data.sequence = this.sequence;
+          }
+          if (this.position != null) {
+            data.position = this.position;
+          }
+          if (this.overlay_count != null) {
+            data.overlay_count = this.overlay_count;
+          }
+          return data;
+        }
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
+          const writer = w || new pb_1.BinaryWriter();
+          if (this.zone != CardZone.DECK) writer.writeEnum(1, this.zone);
+          if (this.sequence != 0) writer.writeInt32(2, this.sequence);
+          if (this.position != 0) writer.writeInt32(3, this.position);
+          if (this.overlay_count != 0) writer.writeInt32(4, this.overlay_count);
+          if (!w) return writer.getResultBuffer();
+        }
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ZoneAction {
+          const reader =
+              bytes instanceof pb_1.BinaryReader
+                ? bytes
+                : new pb_1.BinaryReader(bytes),
+            message = new ZoneAction();
+          while (reader.nextField()) {
+            if (reader.isEndGroup()) break;
+            switch (reader.getFieldNumber()) {
+              case 1:
+                message.zone = reader.readEnum();
+                break;
+              case 2:
+                message.sequence = reader.readInt32();
+                break;
+              case 3:
+                message.position = reader.readInt32();
+                break;
+              case 4:
+                message.overlay_count = reader.readInt32();
+                break;
+              default:
+                reader.skipField();
+            }
+          }
+          return message;
+        }
+        serializeBinary(): Uint8Array {
+          return this.serialize();
+        }
+        static deserializeBinary(bytes: Uint8Array): ZoneAction {
+          return ZoneAction.deserialize(bytes);
+        }
+      }
+      export class ChainAction extends pb_1.Message {
+        #one_of_decls: number[][] = [];
+        constructor(
+          data?:
+            | any[]
+            | {
+                chain_code?: number;
+                location?: CardLocation;
+                triggering_controller?: number;
+                triggering_location?: number;
+                triggering_sequence?: number;
+                effect_description?: number;
+              }
+        ) {
+          super();
+          pb_1.Message.initialize(
+            this,
+            Array.isArray(data) ? data : [],
+            0,
+            -1,
+            [],
+            this.#one_of_decls
+          );
+          if (!Array.isArray(data) && typeof data == "object") {
+            if ("chain_code" in data && data.chain_code != undefined) {
+              this.chain_code = data.chain_code;
+            }
+            if ("location" in data && data.location != undefined) {
+              this.location = data.location;
+            }
+            if (
+              "triggering_controller" in data &&
+              data.triggering_controller != undefined
+            ) {
+              this.triggering_controller = data.triggering_controller;
+            }
+            if (
+              "triggering_location" in data &&
+              data.triggering_location != undefined
+            ) {
+              this.triggering_location = data.triggering_location;
+            }
+            if (
+              "triggering_sequence" in data &&
+              data.triggering_sequence != undefined
+            ) {
+              this.triggering_sequence = data.triggering_sequence;
+            }
+            if (
+              "effect_description" in data &&
+              data.effect_description != undefined
+            ) {
+              this.effect_description = data.effect_description;
+            }
+          }
+        }
+        get chain_code() {
+          return pb_1.Message.getFieldWithDefault(this, 1, 0) as number;
+        }
+        set chain_code(value: number) {
+          pb_1.Message.setField(this, 1, value);
+        }
+        get location() {
+          return pb_1.Message.getWrapperField(
+            this,
+            CardLocation,
+            2
+          ) as CardLocation;
+        }
+        set location(value: CardLocation) {
+          pb_1.Message.setWrapperField(this, 2, value);
+        }
+        get has_location() {
+          return pb_1.Message.getField(this, 2) != null;
+        }
+        get triggering_controller() {
+          return pb_1.Message.getFieldWithDefault(this, 3, 0) as number;
+        }
+        set triggering_controller(value: number) {
+          pb_1.Message.setField(this, 3, value);
+        }
+        get triggering_location() {
+          return pb_1.Message.getFieldWithDefault(this, 4, 0) as number;
+        }
+        set triggering_location(value: number) {
+          pb_1.Message.setField(this, 4, value);
+        }
+        get triggering_sequence() {
+          return pb_1.Message.getFieldWithDefault(this, 5, 0) as number;
+        }
+        set triggering_sequence(value: number) {
+          pb_1.Message.setField(this, 5, value);
+        }
+        get effect_description() {
+          return pb_1.Message.getFieldWithDefault(this, 6, 0) as number;
+        }
+        set effect_description(value: number) {
+          pb_1.Message.setField(this, 6, value);
+        }
+        static fromObject(data: {
+          chain_code?: number;
+          location?: ReturnType<typeof CardLocation.prototype.toObject>;
+          triggering_controller?: number;
+          triggering_location?: number;
+          triggering_sequence?: number;
+          effect_description?: number;
+        }): ChainAction {
+          const message = new ChainAction({});
+          if (data.chain_code != null) {
+            message.chain_code = data.chain_code;
+          }
+          if (data.location != null) {
+            message.location = CardLocation.fromObject(data.location);
+          }
+          if (data.triggering_controller != null) {
+            message.triggering_controller = data.triggering_controller;
+          }
+          if (data.triggering_location != null) {
+            message.triggering_location = data.triggering_location;
+          }
+          if (data.triggering_sequence != null) {
+            message.triggering_sequence = data.triggering_sequence;
+          }
+          if (data.effect_description != null) {
+            message.effect_description = data.effect_description;
+          }
+          return message;
+        }
+        toObject() {
+          const data: {
+            chain_code?: number;
+            location?: ReturnType<typeof CardLocation.prototype.toObject>;
+            triggering_controller?: number;
+            triggering_location?: number;
+            triggering_sequence?: number;
+            effect_description?: number;
+          } = {};
+          if (this.chain_code != null) {
+            data.chain_code = this.chain_code;
+          }
+          if (this.location != null) {
+            data.location = this.location.toObject();
+          }
+          if (this.triggering_controller != null) {
+            data.triggering_controller = this.triggering_controller;
+          }
+          if (this.triggering_location != null) {
+            data.triggering_location = this.triggering_location;
+          }
+          if (this.triggering_sequence != null) {
+            data.triggering_sequence = this.triggering_sequence;
+          }
+          if (this.effect_description != null) {
+            data.effect_description = this.effect_description;
+          }
+          return data;
+        }
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
+          const writer = w || new pb_1.BinaryWriter();
+          if (this.chain_code != 0) writer.writeInt32(1, this.chain_code);
+          if (this.has_location)
+            writer.writeMessage(2, this.location, () =>
+              this.location.serialize(writer)
+            );
+          if (this.triggering_controller != 0)
+            writer.writeInt32(3, this.triggering_controller);
+          if (this.triggering_location != 0)
+            writer.writeInt32(4, this.triggering_location);
+          if (this.triggering_sequence != 0)
+            writer.writeInt32(5, this.triggering_sequence);
+          if (this.effect_description != 0)
+            writer.writeInt32(6, this.effect_description);
+          if (!w) return writer.getResultBuffer();
+        }
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ChainAction {
+          const reader =
+              bytes instanceof pb_1.BinaryReader
+                ? bytes
+                : new pb_1.BinaryReader(bytes),
+            message = new ChainAction();
+          while (reader.nextField()) {
+            if (reader.isEndGroup()) break;
+            switch (reader.getFieldNumber()) {
+              case 1:
+                message.chain_code = reader.readInt32();
+                break;
+              case 2:
+                reader.readMessage(
+                  message.location,
+                  () => (message.location = CardLocation.deserialize(reader))
+                );
+                break;
+              case 3:
+                message.triggering_controller = reader.readInt32();
+                break;
+              case 4:
+                message.triggering_location = reader.readInt32();
+                break;
+              case 5:
+                message.triggering_sequence = reader.readInt32();
+                break;
+              case 6:
+                message.effect_description = reader.readInt32();
+                break;
+              default:
+                reader.skipField();
+            }
+          }
+          return message;
+        }
+        serializeBinary(): Uint8Array {
+          return this.serialize();
+        }
+        static deserializeBinary(bytes: Uint8Array): ChainAction {
+          return ChainAction.deserialize(bytes);
+        }
+      }
+      export class Action extends pb_1.Message {
+        #one_of_decls: number[][] = [];
+        constructor(
+          data?:
+            | any[]
+            | {
+                player?: number;
+                lp?: number;
+                zone_actions?: StocGameMessage.MsgReloadField.ZoneAction[];
+                chain_actions?: StocGameMessage.MsgReloadField.ChainAction[];
+              }
+        ) {
+          super();
+          pb_1.Message.initialize(
+            this,
+            Array.isArray(data) ? data : [],
+            0,
+            -1,
+            [3, 4],
+            this.#one_of_decls
+          );
+          if (!Array.isArray(data) && typeof data == "object") {
+            if ("player" in data && data.player != undefined) {
+              this.player = data.player;
+            }
+            if ("lp" in data && data.lp != undefined) {
+              this.lp = data.lp;
+            }
+            if ("zone_actions" in data && data.zone_actions != undefined) {
+              this.zone_actions = data.zone_actions;
+            }
+            if ("chain_actions" in data && data.chain_actions != undefined) {
+              this.chain_actions = data.chain_actions;
+            }
+          }
+        }
+        get player() {
+          return pb_1.Message.getFieldWithDefault(this, 1, 0) as number;
+        }
+        set player(value: number) {
+          pb_1.Message.setField(this, 1, value);
+        }
+        get lp() {
+          return pb_1.Message.getFieldWithDefault(this, 2, 0) as number;
+        }
+        set lp(value: number) {
+          pb_1.Message.setField(this, 2, value);
+        }
+        get zone_actions() {
+          return pb_1.Message.getRepeatedWrapperField(
+            this,
+            StocGameMessage.MsgReloadField.ZoneAction,
+            3
+          ) as StocGameMessage.MsgReloadField.ZoneAction[];
+        }
+        set zone_actions(value: StocGameMessage.MsgReloadField.ZoneAction[]) {
+          pb_1.Message.setRepeatedWrapperField(this, 3, value);
+        }
+        get chain_actions() {
+          return pb_1.Message.getRepeatedWrapperField(
+            this,
+            StocGameMessage.MsgReloadField.ChainAction,
+            4
+          ) as StocGameMessage.MsgReloadField.ChainAction[];
+        }
+        set chain_actions(value: StocGameMessage.MsgReloadField.ChainAction[]) {
+          pb_1.Message.setRepeatedWrapperField(this, 4, value);
+        }
+        static fromObject(data: {
+          player?: number;
+          lp?: number;
+          zone_actions?: ReturnType<
+            typeof StocGameMessage.MsgReloadField.ZoneAction.prototype.toObject
+          >[];
+          chain_actions?: ReturnType<
+            typeof StocGameMessage.MsgReloadField.ChainAction.prototype.toObject
+          >[];
+        }): Action {
+          const message = new Action({});
+          if (data.player != null) {
+            message.player = data.player;
+          }
+          if (data.lp != null) {
+            message.lp = data.lp;
+          }
+          if (data.zone_actions != null) {
+            message.zone_actions = data.zone_actions.map((item) =>
+              StocGameMessage.MsgReloadField.ZoneAction.fromObject(item)
+            );
+          }
+          if (data.chain_actions != null) {
+            message.chain_actions = data.chain_actions.map((item) =>
+              StocGameMessage.MsgReloadField.ChainAction.fromObject(item)
+            );
+          }
+          return message;
+        }
+        toObject() {
+          const data: {
+            player?: number;
+            lp?: number;
+            zone_actions?: ReturnType<
+              typeof StocGameMessage.MsgReloadField.ZoneAction.prototype.toObject
+            >[];
+            chain_actions?: ReturnType<
+              typeof StocGameMessage.MsgReloadField.ChainAction.prototype.toObject
+            >[];
+          } = {};
+          if (this.player != null) {
+            data.player = this.player;
+          }
+          if (this.lp != null) {
+            data.lp = this.lp;
+          }
+          if (this.zone_actions != null) {
+            data.zone_actions = this.zone_actions.map(
+              (item: StocGameMessage.MsgReloadField.ZoneAction) =>
+                item.toObject()
+            );
+          }
+          if (this.chain_actions != null) {
+            data.chain_actions = this.chain_actions.map(
+              (item: StocGameMessage.MsgReloadField.ChainAction) =>
+                item.toObject()
+            );
+          }
+          return data;
+        }
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
+          const writer = w || new pb_1.BinaryWriter();
+          if (this.player != 0) writer.writeInt32(1, this.player);
+          if (this.lp != 0) writer.writeInt32(2, this.lp);
+          if (this.zone_actions.length)
+            writer.writeRepeatedMessage(
+              3,
+              this.zone_actions,
+              (item: StocGameMessage.MsgReloadField.ZoneAction) =>
+                item.serialize(writer)
+            );
+          if (this.chain_actions.length)
+            writer.writeRepeatedMessage(
+              4,
+              this.chain_actions,
+              (item: StocGameMessage.MsgReloadField.ChainAction) =>
+                item.serialize(writer)
+            );
+          if (!w) return writer.getResultBuffer();
+        }
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Action {
+          const reader =
+              bytes instanceof pb_1.BinaryReader
+                ? bytes
+                : new pb_1.BinaryReader(bytes),
+            message = new Action();
+          while (reader.nextField()) {
+            if (reader.isEndGroup()) break;
+            switch (reader.getFieldNumber()) {
+              case 1:
+                message.player = reader.readInt32();
+                break;
+              case 2:
+                message.lp = reader.readInt32();
+                break;
+              case 3:
+                reader.readMessage(message.zone_actions, () =>
+                  pb_1.Message.addToRepeatedWrapperField(
+                    message,
+                    3,
+                    StocGameMessage.MsgReloadField.ZoneAction.deserialize(
+                      reader
+                    ),
+                    StocGameMessage.MsgReloadField.ZoneAction
+                  )
+                );
+                break;
+              case 4:
+                reader.readMessage(message.chain_actions, () =>
+                  pb_1.Message.addToRepeatedWrapperField(
+                    message,
+                    4,
+                    StocGameMessage.MsgReloadField.ChainAction.deserialize(
+                      reader
+                    ),
+                    StocGameMessage.MsgReloadField.ChainAction
+                  )
+                );
+                break;
+              default:
+                reader.skipField();
+            }
+          }
+          return message;
+        }
+        serializeBinary(): Uint8Array {
+          return this.serialize();
+        }
+        static deserializeBinary(bytes: Uint8Array): Action {
+          return Action.deserialize(bytes);
+        }
+      }
+    }
   }
 }

src/api/ocgcore/ocgAdapter/protoDecl.ts

@@ -50,3 +50,4 @@ export const MSG_PAY_LP_COST = 100;
 export const MSG_WIN = 5;
 export const MSG_WAITING = 3;
 export const MSG_UPDATE_DATA = 6;
+export const MSG_RELOAD_FIELD = 162;

src/api/ocgcore/ocgAdapter/stoc/stocGameMsg/mod.ts

@@ -26,6 +26,7 @@ import MsgDamage from "./damage";
 import MsgRecover from "./recover";
 import MsgWin from "./win";
 import MsgUpdateDataAdapter from "./updateData";
+import MsgReloadFieldAdapter from "./reloadField";
 import PENETRATE from "./penetrate";
 
 /*
@@ -154,6 +155,11 @@ export default class GameMsgAdapter implements StocAdapter {
 
           break;
         }
+        case GAME_MSG.MSG_RELOAD_FIELD: {
+          gameMsg.reload_field = MsgReloadFieldAdapter(gameData);
+
+          break;
+        }
         default: {
           gameMsg.unimplemented = new ygopro.StocGameMessage.MsgUnimplemented({
             command: func,

src/api/ocgcore/ocgAdapter/stoc/stocGameMsg/reloadField.ts

+import { ygopro } from "../../../idl/ocgcore";
+// @ts-ignore
+import { BufferReaderExt } from "../../bufferIO";
+import MsgReloadField = ygopro.StocGameMessage.MsgReloadField;
+import { numberToCardPosition } from "../../util";
+
+export default (data: Uint8Array) => {
+  const reader = new BufferReaderExt(data);
+
+  const duel_rule = reader.inner.readUint8();
+  const actions = [];
+
+  for (let player = 0; player < 2; player++) {
+    const lp = reader.inner.readUint32();
+
+    const zone_actions = [];
+    // MZONE
+    for (let sequence = 0; sequence < 7; sequence++) {
+      const flag = reader.inner.readUint8();
+      if (flag) {
+        const position = reader.inner.readUint8();
+        const overlay_count = reader.inner.readUint8();
+
+        zone_actions.push(
+          new MsgReloadField.ZoneAction({
+            zone: ygopro.CardZone.MZONE,
+            sequence,
+            position: numberToCardPosition(position),
+            overlay_count,
+          })
+        );
+      } else {
+        zone_actions.push(
+          new MsgReloadField.ZoneAction({
+            zone: ygopro.CardZone.MZONE,
+            sequence,
+            position: ygopro.CardPosition.FACEDOWN,
+          })
+        );
+      }
+    }
+
+    // SZONE
+    for (let sequence = 0; sequence < 8; sequence++) {
+      const flag = reader.inner.readUint8();
+      if (flag) {
+        const position = reader.inner.readUint8();
+
+        zone_actions.push(
+          new MsgReloadField.ZoneAction({
+            zone: ygopro.CardZone.SZONE,
+            sequence,
+            position: numberToCardPosition(position),
+          })
+        );
+      } else {
+        zone_actions.push(
+          new MsgReloadField.ZoneAction({
+            zone: ygopro.CardZone.SZONE,
+            sequence,
+            position: ygopro.CardPosition.FACEDOWN,
+          })
+        );
+      }
+    }
+
+    const main_size = reader.inner.readUint8();
+    for (let sequence = 0; sequence < main_size; sequence++) {
+      zone_actions.push(
+        new MsgReloadField.ZoneAction({
+          zone: ygopro.CardZone.DECK,
+          sequence,
+          position: ygopro.CardPosition.FACEDOWN_ATTACK,
+        })
+      );
+    }
+
+    const hand_size = reader.inner.readUint8();
+    for (let sequence = 0; sequence < hand_size; sequence++) {
+      zone_actions.push(
+        new MsgReloadField.ZoneAction({
+          zone: ygopro.CardZone.HAND,
+          sequence,
+        })
+      );
+    }
+
+    const grave_size = reader.inner.readUint8();
+    for (let sequence = 0; sequence < grave_size; sequence++) {
+      zone_actions.push(
+        new MsgReloadField.ZoneAction({
+          zone: ygopro.CardZone.GRAVE,
+          sequence,
+        })
+      );
+    }
+
+    const removed_size = reader.inner.readUint8();
+    for (let sequence = 0; sequence < removed_size; sequence++) {
+      zone_actions.push(
+        new MsgReloadField.ZoneAction({
+          zone: ygopro.CardZone.REMOVED,
+          sequence,
+        })
+      );
+    }
+
+    const extra_size = reader.inner.readUint8();
+    for (let sequence = 0; sequence < extra_size; sequence++) {
+      zone_actions.push(
+        new MsgReloadField.ZoneAction({
+          zone: ygopro.CardZone.EXTRA,
+          sequence,
+          position: ygopro.CardPosition.FACEDOWN_ATTACK,
+        })
+      );
+    }
+
+    const _extra_p_size = reader.inner.readUint8();
+
+    // const chain_size = reader.inner.readUint8();
+    // const chain_actions = [];
+    // for (let i = 0; i < chain_size; i += 1) {
+    //   const chain_code = reader.inner.readUint32();
+    //   const location = reader.readCardLocation();
+    //   const triggering_controller = reader.inner.readUint8();
+    //   const triggering_location = reader.inner.readUint8();
+    //   const triggering_sequence = reader.inner.readUint8();
+    //   const effect_description = reader.inner.readUint32();
+    //
+    //   chain_actions.push(
+    //     new MsgReloadField.ChainAction({
+    //       chain_code,
+    //       location,
+    //       triggering_controller,
+    //       triggering_location,
+    //       triggering_sequence,
+    //       effect_description,
+    //     })
+    //   );
+    // }
+
+    actions.push(
+      new MsgReloadField.Action({
+        player,
+        lp,
+        zone_actions,
+        // chain_actions,
+      })
+    );
+  }
+
+  return new MsgReloadField({
+    duel_rule,
+    actions,
+  });
+};

src/reducers/duel/commonSlice.ts

@@ -3,9 +3,11 @@ import {
   clearIdleInteractivities,
   clearPlaceInteractivities,
   DuelReducer,
+  reloadFieldMeta,
   updateCardData,
 } from "./generic";
 import { judgeSelf } from "./util";
+import MsgReloadField = ygopro.StocGameMessage.MsgReloadField;
 type MsgUpdateData = ReturnType<
   typeof ygopro.StocGameMessage.MsgUpdateData.prototype.toObject
 >;
@@ -124,3 +126,87 @@ export const updateFieldDataImpl: DuelReducer<MsgUpdateData> = (
     }
   }
 };
+
+export const reloadFieldImpl: DuelReducer<MsgReloadField> = (state, action) => {
+  const _duel_rule = action.payload.duel_rule;
+
+  // 初始化`DuelState`
+  state.meDeck = { inner: [] };
+  state.opDeck = { inner: [] };
+  state.meExtraDeck = { inner: [] };
+  state.opExtraDeck = { inner: [] };
+  state.meMonsters = { inner: [] };
+  state.opMonsters = { inner: [] };
+  state.meMagics = { inner: [] };
+  state.opMagics = { inner: [] };
+  state.meCemetery = { inner: [] };
+  state.opCemetery = { inner: [] };
+  state.meExclusion = { inner: [] };
+  state.opExclusion = { inner: [] };
+  state.meHands = { inner: [] };
+  state.opHands = { inner: [] };
+
+  for (const reload of action.payload.actions) {
+    const player = reload.player;
+
+    // DECK
+    const deck = judgeSelf(player, state) ? state.meDeck : state.opDeck;
+    reloadFieldMeta(
+      deck,
+      reload.zone_actions.filter((item) => item.zone == ygopro.CardZone.DECK),
+      player
+    );
+    // EXTRA_DECK
+    const extraDeck = judgeSelf(player, state)
+      ? state.meExtraDeck
+      : state.opExtraDeck;
+    reloadFieldMeta(
+      extraDeck,
+      reload.zone_actions.filter((item) => item.zone == ygopro.CardZone.EXTRA),
+      player
+    );
+    // MZONE
+    const monster = judgeSelf(player, state)
+      ? state.meMonsters
+      : state.opMonsters;
+    reloadFieldMeta(
+      monster,
+      reload.zone_actions.filter((item) => item.zone == ygopro.CardZone.MZONE),
+      player
+    );
+    // SZONE
+    const magics = judgeSelf(player, state) ? state.meMagics : state.opMagics;
+    reloadFieldMeta(
+      magics,
+      reload.zone_actions.filter((item) => item.zone == ygopro.CardZone.SZONE),
+      player
+    );
+    // GRAVE
+    const cemetery = judgeSelf(player, state)
+      ? state.meCemetery
+      : state.opCemetery;
+    reloadFieldMeta(
+      cemetery,
+      reload.zone_actions.filter((item) => item.zone == ygopro.CardZone.GRAVE),
+      player
+    );
+    // REMOVED
+    const exclusion = judgeSelf(player, state)
+      ? state.meExclusion
+      : state.opExclusion;
+    reloadFieldMeta(
+      exclusion,
+      reload.zone_actions.filter(
+        (item) => item.zone == ygopro.CardZone.REMOVED
+      ),
+      player
+    );
+    // HANDS
+    const hands = judgeSelf(player, state) ? state.meHands : state.opHands;
+    reloadFieldMeta(
+      hands,
+      reload.zone_actions.filter((item) => item.zone == ygopro.CardZone.HAND),
+      player
+    );
+  }
+};

src/reducers/duel/generic.ts

@@ -8,6 +8,7 @@ import { CardMeta } from "../../api/cards";
 import { ygopro } from "../../api/ocgcore/idl/ocgcore";
 import { fetchCard } from "../../api/cards";
 import { DuelState } from "./mod";
+import ReloadFieldAction = ygopro.StocGameMessage.MsgReloadField.ZoneAction;
 type UpdateDataAction = ReturnType<
   typeof ygopro.StocGameMessage.MsgUpdateData.Action.prototype.toObject
 >;
@@ -33,6 +34,7 @@ export interface CardState {
     sequence: number;
   }>; // 选择位置状态下的互动信息
   overlay_materials?: CardMeta[]; // 超量素材
+  reload?: boolean; // 这个字段会在收到MSG_RELOAD_FIELD的时候设置成true，在收到MSG_UPDATE_DATE的时候设置成false
 }
 
 export enum InteractType {
@@ -294,9 +296,11 @@ export function updateCardData<T extends DuelFieldState>(
   for (const payload of actions) {
     const sequence = payload.location?.sequence;
     if (typeof sequence !== "undefined") {
-      console.log(payload.type_);
       const target = state?.inner.find((_, idx) => idx == sequence);
-      if (target && target.occupant) {
+      if (target && (target.occupant || target.reload)) {
+        if (target.occupant === undefined) {
+          target.occupant = { id: payload.code!, data: {}, text: {} };
+        }
         const occupant = target.occupant;
         // 目前只更新以下字段
         if (payload.code !== undefined && payload.code >= 0) {
@@ -325,6 +329,31 @@ export function updateCardData<T extends DuelFieldState>(
           occupant.data.def = payload.defense;
         }
       }
+      if (target?.reload) {
+        target.reload = false;
+      }
     }
   }
 }
+
+export function reloadFieldMeta<T extends DuelFieldState>(
+  state: T,
+  actions: ReloadFieldAction[],
+  controler: number
+) {
+  actions.sort((a, b) => a.sequence - b.sequence);
+  const cards = actions.map((action) => {
+    // FIXME: OVERLAY
+    return {
+      location: {
+        controler,
+        location: action.zone,
+        position: action.position,
+      },
+      idleInteractivities: [],
+      reload: true,
+    };
+  });
+
+  state.inner = cards;
+}

src/reducers/duel/mod.ts

@@ -96,6 +96,7 @@ import {
   clearAllIdleInteractivitiesImpl,
   clearAllPlaceInteractivitiesImpl,
   updateFieldDataImpl,
+  reloadFieldImpl,
 } from "./commonSlice";
 import {
   ExtraDeckState,
@@ -258,6 +259,7 @@ const duelSlice = createSlice({
     clearAllIdleInteractivities: clearAllIdleInteractivitiesImpl,
     clearAllPlaceInteractivities: clearAllPlaceInteractivitiesImpl,
     updateFieldData: updateFieldDataImpl,
+    reloadField: reloadFieldImpl,
 
     // 对局结果`Reducer`
     setResult: (state, action: PayloadAction<MsgWin.ActionType>) => {
@@ -355,6 +357,7 @@ export const {
   setWaiting,
   setUnimplemented,
   updateFieldData,
+  reloadField,
 } = duelSlice.actions;
 export const selectDuelHsStart = (state: RootState) => {
   return state.duel.meInitInfo != null;

src/service/duel/gameMsg.ts

@@ -23,6 +23,7 @@ import onMsgWin from "./win";
 import onMsgWait from "./wait";
 import onUnimplemented from "./unimplemented";
 import onMsgUpdateData from "./updateData";
+import onMsgReloadField from "./reloadField";
 import { setWaiting } from "../../reducers/duel/mod";
 
 const ActiveList = [
@@ -157,6 +158,11 @@ export default function handleGameMsg(pb: ygopro.YgoStocMsg) {
 
       break;
     }
+    case "reload_field": {
+      onMsgReloadField(msg.reload_field, dispatch);
+
+      break;
+    }
     case "unimplemented": {
       onUnimplemented(msg.unimplemented, dispatch);
 

src/service/duel/reloadField.ts

+import { ygopro } from "../../api/ocgcore/idl/ocgcore";
+import { reloadField } from "../../reducers/duel/mod";
+import { AppDispatch } from "../../store";
+import MsgReloadField = ygopro.StocGameMessage.MsgReloadField;
+
+export default (field: MsgReloadField, dispatch: AppDispatch) => {
+  dispatch(reloadField(field));
+};

src/store.ts

@@ -19,7 +19,7 @@ export const store = configureStore({
   middleware: (getDefaultMiddleware) =>
     getDefaultMiddleware({
       serializableCheck: {
-        ignoredActions: ["duel/updateHp"],
+        ignoredActions: ["duel/updateHp", "duel/reloadField"],
       },
     }),
 });