Merge pull request #15 from DarkNeos/dev

Dev

neos-protobuf @ ed6ff3b1

-Subproject commit 7b87e8a035a016c44d551f85c1ce0a719b507b8f
+Subproject commit ed6ff3b15aaa74e35feb40d33aa518b52a275402

src/WaitRoom.tsx

@@ -6,9 +6,13 @@ import "./css/WaitRoom.css";
 
 type Player = {
   name?: string;
-  state?: string;
+  state?: string; // todo: use enum or boolean
+  isHost?: boolean;
 };
 
+const READY_STATE = "ready";
+const NO_READY_STATE = "not ready";
+
 export default function WaitRoom() {
   const params = useParams<{
     player?: string;
@@ -22,6 +26,7 @@ export default function WaitRoom() {
   const [observerCount, setObserverCount] = useState<number>(0);
   const [player0, setPlayer0] = useState<Player>({});
   const [player1, setPlayer1] = useState<Player>({});
+  const [isHost, setIsHost] = useState<boolean>(false);
   const [_, forceUpdate] = useReducer(x => x + 1, 0); // todo: use correct update design
 
   const ws = useRef<WebSocket | null>(null);
@@ -34,7 +39,7 @@ export default function WaitRoom() {
     }
 
     ws.current.onopen = () => {
-      console.log("websocket open");
+      console.log("Websocket open");
 
       if (
         player != null &&
@@ -53,7 +58,7 @@ export default function WaitRoom() {
     };
 
     ws.current.onclose = () => {
-      console.log("websocket closed");
+      console.log("Websocket closed");
     };
 
     ws.current.onmessage = e => {
@@ -103,26 +108,20 @@ export default function WaitRoom() {
                 break;
               }
               case ygopro.StocHsPlayerChange.State.READY: {
-                console.log("Player " + change.pos + " has ready");
-
                 const updateState = (player: Player) => {
-                  const state = "ready";
-                  player.state = state;
+                  player.state = READY_STATE;
                   return player;
                 };
 
                 change.pos == 0
                   ? setPlayer0(updateState)
                   : setPlayer1(updateState);
-                forceUpdate();
 
                 break;
               }
               case ygopro.StocHsPlayerChange.State.NO_READY: {
-                console.log("Player " + change.pos + " not ready");
-
                 const updateState = (player: Player) => {
-                  const state = "not ready";
+                  const state = NO_READY_STATE;
                   player.state = state;
                   return player;
                 };
@@ -130,20 +129,15 @@ export default function WaitRoom() {
                 change.pos == 0
                   ? setPlayer0(updateState)
                   : setPlayer1(updateState);
-                forceUpdate();
 
                 break;
               }
               case ygopro.StocHsPlayerChange.State.LEAVE: {
-                console.log("Player " + change.pos + " has leave");
-
                 change.pos == 0 ? setPlayer0({}) : setPlayer1({});
 
                 break;
               }
               case ygopro.StocHsPlayerChange.State.TO_OBSERVER: {
-                console.log("Player " + change.pos + " has moved to observer");
-
                 change.pos == 0 ? setPlayer0({}) : setPlayer1({});
                 setObserverCount(observerCount + 1);
 
@@ -153,6 +147,8 @@ export default function WaitRoom() {
                 break;
               }
             }
+
+            forceUpdate();
           }
 
           break;
@@ -170,19 +166,47 @@ export default function WaitRoom() {
           if (pos > 1) {
             console.log("Currently only supported 2v2 mode.");
           } else {
-            const player = {
-              name,
-              state: "not ready"
+            const updatePlayer = (player: Player) => {
+              player.name = name;
+              return player;
             };
-            pos == 0 ? setPlayer0(player) : setPlayer1(player);
+
+            pos == 0 ? setPlayer0(updatePlayer) : setPlayer1(updatePlayer);
+            forceUpdate();
           }
 
           break;
         }
         case "stoc_type_change": {
-          const t = pb.stoc_type_change.type;
+          const selfType = pb.stoc_type_change.self_type;
+          const assertHost = pb.stoc_type_change.is_host;
+
+          setIsHost(assertHost);
+
+          if (assertHost) {
+            const updatePlayer = (player: Player) => {
+              player.isHost = assertHost;
+              player.state = NO_READY_STATE;
+              return player;
+            };
 
-          console.log("STOC type changed: " + t);
+            switch (selfType) {
+              case ygopro.StocTypeChange.SelfType.PLAYER1: {
+                setPlayer0(updatePlayer);
+
+                break;
+              }
+              case ygopro.StocTypeChange.SelfType.PLAYER2: {
+                setPlayer1(updatePlayer);
+
+                break;
+              }
+              default: {
+                break;
+              }
+            }
+            forceUpdate();
+          }
 
           break;
         }
@@ -217,6 +241,12 @@ export default function WaitRoom() {
     }
   };
 
+  const handleChoseStart = () => {
+    if (ws.current) {
+      sendHsStart(ws.current);
+    }
+  };
+
   return (
     <div className="container">
       <div className="playerRegion">
@@ -231,14 +261,32 @@ export default function WaitRoom() {
             ready
           </button>
         </p>
+        <p>
+          <button
+            disabled={
+              !(
+                isHost &&
+                player0.state != undefined &&
+                player0.state === READY_STATE &&
+                player1.state != undefined &&
+                player1.state === READY_STATE
+              )
+            }
+            onClick={handleChoseStart}
+          >
+            start
+          </button>
+        </p>
       </div>
       <div className="roomRegion">
         <h2>Room Passwd: {passWd}</h2>
         <p>
-          player0: {player0.name} {player0.state}
+          player0: {player0.isHost == true ? "[Host]" : ""} {player0.name}{" "}
+          {player0.state}
         </p>
         <p>
-          player1: {player1.name} {player1.state}
+          player1: {player1.isHost == true ? "[Host]" : ""} {player1.name}{" "}
+          {player1.state}
         </p>
         <p>observer: {observerCount}</p>
         <p>chat: {chat}</p>
@@ -288,3 +336,11 @@ function sendHsReady(ws: WebSocket) {
 
   ws.send(hasReady.serialize());
 }
+
+function sendHsStart(ws: WebSocket) {
+  const hasStart = new ygopro.YgoCtosMsg({
+    ctos_hs_start: new ygopro.CtosHsStart({})
+  });
+
+  ws.send(hasStart.serialize());
+}

src/api/idl/ocgcore.ts

@@ -6,27 +6,37 @@
 import * as pb_1 from "google-protobuf";
 export namespace ygopro {
     export class YgoCtosMsg extends pb_1.Message {
-        #one_of_decls: number[][] = [[1, 2, 3, 4]];
+        #one_of_decls: number[][] = [[1, 2, 3, 4, 5]];
         constructor(data?: any[] | ({} & (({
             ctos_player_info?: CtosPlayerInfo;
             ctos_join_game?: never;
             ctos_update_deck?: never;
             ctos_hs_ready?: never;
+            ctos_hs_start?: never;
         } | {
             ctos_player_info?: never;
             ctos_join_game?: CtosJoinGame;
             ctos_update_deck?: never;
             ctos_hs_ready?: never;
+            ctos_hs_start?: never;
         } | {
             ctos_player_info?: never;
             ctos_join_game?: never;
             ctos_update_deck?: CtosUpdateDeck;
             ctos_hs_ready?: never;
+            ctos_hs_start?: never;
         } | {
             ctos_player_info?: never;
             ctos_join_game?: never;
             ctos_update_deck?: never;
             ctos_hs_ready?: CtosHsReady;
+            ctos_hs_start?: never;
+        } | {
+            ctos_player_info?: never;
+            ctos_join_game?: never;
+            ctos_update_deck?: never;
+            ctos_hs_ready?: never;
+            ctos_hs_start?: CtosHsStart;
         })))) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
@@ -43,6 +53,9 @@ export namespace ygopro {
                 if ("ctos_hs_ready" in data && data.ctos_hs_ready != undefined) {
                     this.ctos_hs_ready = data.ctos_hs_ready;
                 }
+                if ("ctos_hs_start" in data && data.ctos_hs_start != undefined) {
+                    this.ctos_hs_start = data.ctos_hs_start;
+                }
             }
         }
         get ctos_player_info() {
@@ -81,23 +94,34 @@ export namespace ygopro {
         get has_ctos_hs_ready() {
             return pb_1.Message.getField(this, 4) != null;
         }
+        get ctos_hs_start() {
+            return pb_1.Message.getWrapperField(this, CtosHsStart, 5) as CtosHsStart;
+        }
+        set ctos_hs_start(value: CtosHsStart) {
+            pb_1.Message.setOneofWrapperField(this, 5, this.#one_of_decls[0], value);
+        }
+        get has_ctos_hs_start() {
+            return pb_1.Message.getField(this, 5) != null;
+        }
         get msg() {
             const cases: {
-                [index: number]: "none" | "ctos_player_info" | "ctos_join_game" | "ctos_update_deck" | "ctos_hs_ready";
+                [index: number]: "none" | "ctos_player_info" | "ctos_join_game" | "ctos_update_deck" | "ctos_hs_ready" | "ctos_hs_start";
             } = {
                 0: "none",
                 1: "ctos_player_info",
                 2: "ctos_join_game",
                 3: "ctos_update_deck",
-                4: "ctos_hs_ready"
+                4: "ctos_hs_ready",
+                5: "ctos_hs_start"
             };
-            return cases[pb_1.Message.computeOneofCase(this, [1, 2, 3, 4])];
+            return cases[pb_1.Message.computeOneofCase(this, [1, 2, 3, 4, 5])];
         }
         static fromObject(data: {
             ctos_player_info?: ReturnType<typeof CtosPlayerInfo.prototype.toObject>;
             ctos_join_game?: ReturnType<typeof CtosJoinGame.prototype.toObject>;
             ctos_update_deck?: ReturnType<typeof CtosUpdateDeck.prototype.toObject>;
             ctos_hs_ready?: ReturnType<typeof CtosHsReady.prototype.toObject>;
+            ctos_hs_start?: ReturnType<typeof CtosHsStart.prototype.toObject>;
         }): YgoCtosMsg {
             const message = new YgoCtosMsg({});
             if (data.ctos_player_info != null) {
@@ -112,6 +136,9 @@ export namespace ygopro {
             if (data.ctos_hs_ready != null) {
                 message.ctos_hs_ready = CtosHsReady.fromObject(data.ctos_hs_ready);
             }
+            if (data.ctos_hs_start != null) {
+                message.ctos_hs_start = CtosHsStart.fromObject(data.ctos_hs_start);
+            }
             return message;
         }
         toObject() {
@@ -120,6 +147,7 @@ export namespace ygopro {
                 ctos_join_game?: ReturnType<typeof CtosJoinGame.prototype.toObject>;
                 ctos_update_deck?: ReturnType<typeof CtosUpdateDeck.prototype.toObject>;
                 ctos_hs_ready?: ReturnType<typeof CtosHsReady.prototype.toObject>;
+                ctos_hs_start?: ReturnType<typeof CtosHsStart.prototype.toObject>;
             } = {};
             if (this.ctos_player_info != null) {
                 data.ctos_player_info = this.ctos_player_info.toObject();
@@ -133,6 +161,9 @@ export namespace ygopro {
             if (this.ctos_hs_ready != null) {
                 data.ctos_hs_ready = this.ctos_hs_ready.toObject();
             }
+            if (this.ctos_hs_start != null) {
+                data.ctos_hs_start = this.ctos_hs_start.toObject();
+            }
             return data;
         }
         serialize(): Uint8Array;
@@ -147,6 +178,8 @@ export namespace ygopro {
                 writer.writeMessage(3, this.ctos_update_deck, () => this.ctos_update_deck.serialize(writer));
             if (this.has_ctos_hs_ready)
                 writer.writeMessage(4, this.ctos_hs_ready, () => this.ctos_hs_ready.serialize(writer));
+            if (this.has_ctos_hs_start)
+                writer.writeMessage(5, this.ctos_hs_start, () => this.ctos_hs_start.serialize(writer));
             if (!w)
                 return writer.getResultBuffer();
         }
@@ -168,6 +201,9 @@ export namespace ygopro {
                     case 4:
                         reader.readMessage(message.ctos_hs_ready, () => message.ctos_hs_ready = CtosHsReady.deserialize(reader));
                         break;
+                    case 5:
+                        reader.readMessage(message.ctos_hs_start, () => message.ctos_hs_start = CtosHsStart.deserialize(reader));
+                        break;
                     default: reader.skipField();
                 }
             }
@@ -762,6 +798,46 @@ export namespace ygopro {
             return CtosHsReady.deserialize(bytes);
         }
     }
+    export class CtosHsStart extends pb_1.Message {
+        #one_of_decls: number[][] = [];
+        constructor(data?: any[] | {}) {
+            super();
+            pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
+            if (!Array.isArray(data) && typeof data == "object") { }
+        }
+        static fromObject(data: {}): CtosHsStart {
+            const message = new CtosHsStart({});
+            return message;
+        }
+        toObject() {
+            const data: {} = {};
+            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 (!w)
+                return writer.getResultBuffer();
+        }
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): CtosHsStart {
+            const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new CtosHsStart();
+            while (reader.nextField()) {
+                if (reader.isEndGroup())
+                    break;
+                switch (reader.getFieldNumber()) {
+                    default: reader.skipField();
+                }
+            }
+            return message;
+        }
+        serializeBinary(): Uint8Array {
+            return this.serialize();
+        }
+        static deserializeBinary(bytes: Uint8Array): CtosHsStart {
+            return CtosHsStart.deserialize(bytes);
+        }
+    }
     export class StocJoinGame extends pb_1.Message {
         #one_of_decls: number[][] = [];
         constructor(data?: any[] | {
@@ -1219,37 +1295,55 @@ export namespace ygopro {
     export class StocTypeChange extends pb_1.Message {
         #one_of_decls: number[][] = [];
         constructor(data?: any[] | {
-            type?: number;
+            self_type?: StocTypeChange.SelfType;
+            is_host?: boolean;
         }) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
             if (!Array.isArray(data) && typeof data == "object") {
-                if ("type" in data && data.type != undefined) {
-                    this.type = data.type;
+                if ("self_type" in data && data.self_type != undefined) {
+                    this.self_type = data.self_type;
                 }
+                if ("is_host" in data && data.is_host != undefined) {
+                    this.is_host = data.is_host;
                 }
             }
-        get type() {
-            return pb_1.Message.getFieldWithDefault(this, 1, 0) as number;
         }
-        set type(value: number) {
+        get self_type() {
+            return pb_1.Message.getFieldWithDefault(this, 1, StocTypeChange.SelfType.UNKNOWN) as StocTypeChange.SelfType;
+        }
+        set self_type(value: StocTypeChange.SelfType) {
             pb_1.Message.setField(this, 1, value);
         }
+        get is_host() {
+            return pb_1.Message.getFieldWithDefault(this, 2, false) as boolean;
+        }
+        set is_host(value: boolean) {
+            pb_1.Message.setField(this, 2, value);
+        }
         static fromObject(data: {
-            type?: number;
+            self_type?: StocTypeChange.SelfType;
+            is_host?: boolean;
         }): StocTypeChange {
             const message = new StocTypeChange({});
-            if (data.type != null) {
-                message.type = data.type;
+            if (data.self_type != null) {
+                message.self_type = data.self_type;
+            }
+            if (data.is_host != null) {
+                message.is_host = data.is_host;
             }
             return message;
         }
         toObject() {
             const data: {
-                type?: number;
+                self_type?: StocTypeChange.SelfType;
+                is_host?: boolean;
             } = {};
-            if (this.type != null) {
-                data.type = this.type;
+            if (this.self_type != null) {
+                data.self_type = this.self_type;
+            }
+            if (this.is_host != null) {
+                data.is_host = this.is_host;
             }
             return data;
         }
@@ -1257,8 +1351,10 @@ export namespace ygopro {
         serialize(w: pb_1.BinaryWriter): void;
         serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
             const writer = w || new pb_1.BinaryWriter();
-            if (this.type != 0)
-                writer.writeInt32(1, this.type);
+            if (this.self_type != StocTypeChange.SelfType.UNKNOWN)
+                writer.writeEnum(1, this.self_type);
+            if (this.is_host != false)
+                writer.writeBool(2, this.is_host);
             if (!w)
                 return writer.getResultBuffer();
         }
@@ -1269,7 +1365,10 @@ export namespace ygopro {
                     break;
                 switch (reader.getFieldNumber()) {
                     case 1:
-                        message.type = reader.readInt32();
+                        message.self_type = reader.readEnum();
+                        break;
+                    case 2:
+                        message.is_host = reader.readBool();
                         break;
                     default: reader.skipField();
                 }
@@ -1283,6 +1382,18 @@ export namespace ygopro {
             return StocTypeChange.deserialize(bytes);
         }
     }
+    export namespace StocTypeChange {
+        export enum SelfType {
+            UNKNOWN = 0,
+            PLAYER1 = 1,
+            PLAYER2 = 2,
+            PLAYER3 = 3,
+            PLAYER4 = 4,
+            PLAYER5 = 5,
+            PLAYER6 = 6,
+            OBSERVER = 100
+        }
+    }
     export class StocHsPlayerChange extends pb_1.Message {
         #one_of_decls: number[][] = [];
         constructor(data?: any[] | {