Skip to content

N
Neos
Commit c7d17ef2 authored by Chunchi Che's avatar Chunchi Che
Browse files
Options

prettier fmt

parent 7652b0f9
Hide whitespace changes
Inline Side-by-side
Showing with 1308 additions and 1108 deletions
src/App.test.tsx
View file @ c7d17ef2
import React from 'react'; import React from "react";
import { render, screen } from '@testing-library/react'; import { render, screen } from "@testing-library/react";
import App from './App'; import App from "./App";
test('renders learn react link', () => { test("renders learn react link", () => {
render(<App />); render(<App />);
const linkElement = screen.getByText(/learn react/i); const linkElement = screen.getByText(/learn react/i);
expect(linkElement).toBeInTheDocument(); expect(linkElement).toBeInTheDocument();
......
src/App.tsx
View file @ c7d17ef2
import React from 'react'; import React from "react";
import './App.css'; import "./App.css";
import './api/ygopro.ts'; import "./api/ygopro.ts";
function App() { function App() {
return ( return (
<div className="App"> <div className="App">
<header className="App-header"> <header className="App-header">
<p> <p>Welcome to neos-ts!</p>
Welcome to neos-ts!
</p>
<a <a
className="App-link" className="App-link"
href="https://github.com/DarkNeos" href="https://github.com/DarkNeos"
......
src/api/ygopro.ts
View file @ c7d17ef2
...@@ -5,615 +5,781 @@ ...@@ -5,615 +5,781 @@
* git: https://github.com/thesayyn/protoc-gen-ts */ * git: https://github.com/thesayyn/protoc-gen-ts */
import * as pb_1 from "google-protobuf"; import * as pb_1 from "google-protobuf";
export namespace ygopro { export namespace ygopro {
export class YgoCtosMsg extends pb_1.Message { export class YgoCtosMsg extends pb_1.Message {
#one_of_decls: number[][] = [[2, 3, 4, 101, 102, 103, 104]]; #one_of_decls: number[][] = [[2, 3, 4, 101, 102, 103, 104]];
constructor(data?: any[] | ({ constructor(
data?:
| any[]
| ({
proto?: number; proto?: number;
} & (({ } & (
ctos_player_info?: CtosPlayerInfo; | {
ctos_join_game?: never; ctos_player_info?: CtosPlayerInfo;
ctos_update_deck?: never; ctos_join_game?: never;
stoc_join_game?: never; ctos_update_deck?: never;
stoc_chat?: never; stoc_join_game?: never;
stoc_hs_player_enter?: never; stoc_chat?: never;
stoc_type_change?: never; stoc_hs_player_enter?: never;
} | { stoc_type_change?: never;
ctos_player_info?: never; }
ctos_join_game?: CtosJoinGame; | {
ctos_update_deck?: never; ctos_player_info?: never;
stoc_join_game?: never; ctos_join_game?: CtosJoinGame;
stoc_chat?: never; ctos_update_deck?: never;
stoc_hs_player_enter?: never; stoc_join_game?: never;
stoc_type_change?: never; stoc_chat?: never;
} | { stoc_hs_player_enter?: never;
ctos_player_info?: never; stoc_type_change?: never;
ctos_join_game?: never; }
ctos_update_deck?: CtosUpdateDeck; | {
stoc_join_game?: never; ctos_player_info?: never;
stoc_chat?: never; ctos_join_game?: never;
stoc_hs_player_enter?: never; ctos_update_deck?: CtosUpdateDeck;
stoc_type_change?: never; stoc_join_game?: never;
} | { stoc_chat?: never;
ctos_player_info?: never; stoc_hs_player_enter?: never;
ctos_join_game?: never; stoc_type_change?: never;
ctos_update_deck?: never; }
stoc_join_game?: StocJoinGame; | {
stoc_chat?: never; ctos_player_info?: never;
stoc_hs_player_enter?: never; ctos_join_game?: never;
stoc_type_change?: never; ctos_update_deck?: never;
} | { stoc_join_game?: StocJoinGame;
ctos_player_info?: never; stoc_chat?: never;
ctos_join_game?: never; stoc_hs_player_enter?: never;
ctos_update_deck?: never; stoc_type_change?: never;
stoc_join_game?: never; }
stoc_chat?: StocChat; | {
stoc_hs_player_enter?: never; ctos_player_info?: never;
stoc_type_change?: never; ctos_join_game?: never;
} | { ctos_update_deck?: never;
ctos_player_info?: never; stoc_join_game?: never;
ctos_join_game?: never; stoc_chat?: StocChat;
ctos_update_deck?: never; stoc_hs_player_enter?: never;
stoc_join_game?: never; stoc_type_change?: never;
stoc_chat?: never; }
stoc_hs_player_enter?: StocHsPlayerEnter; | {
stoc_type_change?: never; ctos_player_info?: never;
} | { ctos_join_game?: never;
ctos_player_info?: never; ctos_update_deck?: never;
ctos_join_game?: never; stoc_join_game?: never;
ctos_update_deck?: never; stoc_chat?: never;
stoc_join_game?: never; stoc_hs_player_enter?: StocHsPlayerEnter;
stoc_chat?: never; stoc_type_change?: never;
stoc_hs_player_enter?: never; }
stoc_type_change?: StocTypeChange; | {
})))) { ctos_player_info?: never;
super(); ctos_join_game?: never;
pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls); ctos_update_deck?: never;
if (!Array.isArray(data) && typeof data == "object") { stoc_join_game?: never;
if ("proto" in data && data.proto != undefined) { stoc_chat?: never;
this.proto = data.proto; stoc_hs_player_enter?: never;
} stoc_type_change?: StocTypeChange;
if ("ctos_player_info" in data && data.ctos_player_info != undefined) { }
this.ctos_player_info = data.ctos_player_info; ))
} ) {
if ("ctos_join_game" in data && data.ctos_join_game != undefined) { super();
this.ctos_join_game = data.ctos_join_game; pb_1.Message.initialize(
} this,
if ("ctos_update_deck" in data && data.ctos_update_deck != undefined) { Array.isArray(data) ? data : [],
this.ctos_update_deck = data.ctos_update_deck; 0,
} -1,
if ("stoc_join_game" in data && data.stoc_join_game != undefined) { [],
this.stoc_join_game = data.stoc_join_game; this.#one_of_decls
} );
if ("stoc_chat" in data && data.stoc_chat != undefined) { if (!Array.isArray(data) && typeof data == "object") {
this.stoc_chat = data.stoc_chat; if ("proto" in data && data.proto != undefined) {
} this.proto = data.proto;
if ("stoc_hs_player_enter" in data && data.stoc_hs_player_enter != undefined) { }
this.stoc_hs_player_enter = data.stoc_hs_player_enter; if ("ctos_player_info" in data && data.ctos_player_info != undefined) {
} this.ctos_player_info = data.ctos_player_info;
if ("stoc_type_change" in data && data.stoc_type_change != undefined) { }
this.stoc_type_change = data.stoc_type_change; if ("ctos_join_game" in data && data.ctos_join_game != undefined) {
} this.ctos_join_game = data.ctos_join_game;
} }
} if ("ctos_update_deck" in data && data.ctos_update_deck != undefined) {
get proto() { this.ctos_update_deck = data.ctos_update_deck;
return pb_1.Message.getFieldWithDefault(this, 1, 0) as number; }
} if ("stoc_join_game" in data && data.stoc_join_game != undefined) {
set proto(value: number) { this.stoc_join_game = data.stoc_join_game;
pb_1.Message.setField(this, 1, value); }
} if ("stoc_chat" in data && data.stoc_chat != undefined) {
get ctos_player_info() { this.stoc_chat = data.stoc_chat;
return pb_1.Message.getWrapperField(this, CtosPlayerInfo, 2) as CtosPlayerInfo; }
} if (
set ctos_player_info(value: CtosPlayerInfo) { "stoc_hs_player_enter" in data &&
pb_1.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value); data.stoc_hs_player_enter != undefined
} ) {
get has_ctos_player_info() { this.stoc_hs_player_enter = data.stoc_hs_player_enter;
return pb_1.Message.getField(this, 2) != null; }
} if ("stoc_type_change" in data && data.stoc_type_change != undefined) {
get ctos_join_game() { this.stoc_type_change = data.stoc_type_change;
return pb_1.Message.getWrapperField(this, CtosJoinGame, 3) as CtosJoinGame; }
} }
set ctos_join_game(value: CtosJoinGame) {
pb_1.Message.setOneofWrapperField(this, 3, this.#one_of_decls[0], value);
}
get has_ctos_join_game() {
return pb_1.Message.getField(this, 3) != null;
}
get ctos_update_deck() {
return pb_1.Message.getWrapperField(this, CtosUpdateDeck, 4) as CtosUpdateDeck;
}
set ctos_update_deck(value: CtosUpdateDeck) {
pb_1.Message.setOneofWrapperField(this, 4, this.#one_of_decls[0], value);
}
get has_ctos_update_deck() {
return pb_1.Message.getField(this, 4) != null;
}
get stoc_join_game() {
return pb_1.Message.getWrapperField(this, StocJoinGame, 101) as StocJoinGame;
}
set stoc_join_game(value: StocJoinGame) {
pb_1.Message.setOneofWrapperField(this, 101, this.#one_of_decls[0], value);
}
get has_stoc_join_game() {
return pb_1.Message.getField(this, 101) != null;
}
get stoc_chat() {
return pb_1.Message.getWrapperField(this, StocChat, 102) as StocChat;
}
set stoc_chat(value: StocChat) {
pb_1.Message.setOneofWrapperField(this, 102, this.#one_of_decls[0], value);
}
get has_stoc_chat() {
return pb_1.Message.getField(this, 102) != null;
}
get stoc_hs_player_enter() {
return pb_1.Message.getWrapperField(this, StocHsPlayerEnter, 103) as StocHsPlayerEnter;
}
set stoc_hs_player_enter(value: StocHsPlayerEnter) {
pb_1.Message.setOneofWrapperField(this, 103, this.#one_of_decls[0], value);
}
get has_stoc_hs_player_enter() {
return pb_1.Message.getField(this, 103) != null;
}
get stoc_type_change() {
return pb_1.Message.getWrapperField(this, StocTypeChange, 104) as StocTypeChange;
}
set stoc_type_change(value: StocTypeChange) {
pb_1.Message.setOneofWrapperField(this, 104, this.#one_of_decls[0], value);
}
get has_stoc_type_change() {
return pb_1.Message.getField(this, 104) != null;
}
get msg() {
const cases: {
[index: number]: "none" | "ctos_player_info" | "ctos_join_game" | "ctos_update_deck" | "stoc_join_game" | "stoc_chat" | "stoc_hs_player_enter" | "stoc_type_change";
} = {
0: "none",
2: "ctos_player_info",
3: "ctos_join_game",
4: "ctos_update_deck",
101: "stoc_join_game",
102: "stoc_chat",
103: "stoc_hs_player_enter",
104: "stoc_type_change"
};
return cases[pb_1.Message.computeOneofCase(this, [2, 3, 4, 101, 102, 103, 104])];
}
static fromObject(data: {
proto?: number;
ctos_player_info?: ReturnType<typeof CtosPlayerInfo.prototype.toObject>;
ctos_join_game?: ReturnType<typeof CtosJoinGame.prototype.toObject>;
ctos_update_deck?: ReturnType<typeof CtosUpdateDeck.prototype.toObject>;
stoc_join_game?: ReturnType<typeof StocJoinGame.prototype.toObject>;
stoc_chat?: ReturnType<typeof StocChat.prototype.toObject>;
stoc_hs_player_enter?: ReturnType<typeof StocHsPlayerEnter.prototype.toObject>;
stoc_type_change?: ReturnType<typeof StocTypeChange.prototype.toObject>;
}): YgoCtosMsg {
const message = new YgoCtosMsg({});
if (data.proto != null) {
message.proto = data.proto;
}
if (data.ctos_player_info != null) {
message.ctos_player_info = CtosPlayerInfo.fromObject(data.ctos_player_info);
}
if (data.ctos_join_game != null) {
message.ctos_join_game = CtosJoinGame.fromObject(data.ctos_join_game);
}
if (data.ctos_update_deck != null) {
message.ctos_update_deck = CtosUpdateDeck.fromObject(data.ctos_update_deck);
}
if (data.stoc_join_game != null) {
message.stoc_join_game = StocJoinGame.fromObject(data.stoc_join_game);
}
if (data.stoc_chat != null) {
message.stoc_chat = StocChat.fromObject(data.stoc_chat);
}
if (data.stoc_hs_player_enter != null) {
message.stoc_hs_player_enter = StocHsPlayerEnter.fromObject(data.stoc_hs_player_enter);
}
if (data.stoc_type_change != null) {
message.stoc_type_change = StocTypeChange.fromObject(data.stoc_type_change);
}
return message;
}
toObject() {
const data: {
proto?: number;
ctos_player_info?: ReturnType<typeof CtosPlayerInfo.prototype.toObject>;
ctos_join_game?: ReturnType<typeof CtosJoinGame.prototype.toObject>;
ctos_update_deck?: ReturnType<typeof CtosUpdateDeck.prototype.toObject>;
stoc_join_game?: ReturnType<typeof StocJoinGame.prototype.toObject>;
stoc_chat?: ReturnType<typeof StocChat.prototype.toObject>;
stoc_hs_player_enter?: ReturnType<typeof StocHsPlayerEnter.prototype.toObject>;
stoc_type_change?: ReturnType<typeof StocTypeChange.prototype.toObject>;
} = {};
if (this.proto != null) {
data.proto = this.proto;
}
if (this.ctos_player_info != null) {
data.ctos_player_info = this.ctos_player_info.toObject();
}
if (this.ctos_join_game != null) {
data.ctos_join_game = this.ctos_join_game.toObject();
}
if (this.ctos_update_deck != null) {
data.ctos_update_deck = this.ctos_update_deck.toObject();
}
if (this.stoc_join_game != null) {
data.stoc_join_game = this.stoc_join_game.toObject();
}
if (this.stoc_chat != null) {
data.stoc_chat = this.stoc_chat.toObject();
}
if (this.stoc_hs_player_enter != null) {
data.stoc_hs_player_enter = this.stoc_hs_player_enter.toObject();
}
if (this.stoc_type_change != null) {
data.stoc_type_change = this.stoc_type_change.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.proto != 0)
writer.writeInt32(1, this.proto);
if (this.has_ctos_player_info)
writer.writeMessage(2, this.ctos_player_info, () => this.ctos_player_info.serialize(writer));
if (this.has_ctos_join_game)
writer.writeMessage(3, this.ctos_join_game, () => this.ctos_join_game.serialize(writer));
if (this.has_ctos_update_deck)
writer.writeMessage(4, this.ctos_update_deck, () => this.ctos_update_deck.serialize(writer));
if (this.has_stoc_join_game)
writer.writeMessage(101, this.stoc_join_game, () => this.stoc_join_game.serialize(writer));
if (this.has_stoc_chat)
writer.writeMessage(102, this.stoc_chat, () => this.stoc_chat.serialize(writer));
if (this.has_stoc_hs_player_enter)
writer.writeMessage(103, this.stoc_hs_player_enter, () => this.stoc_hs_player_enter.serialize(writer));
if (this.has_stoc_type_change)
writer.writeMessage(104, this.stoc_type_change, () => this.stoc_type_change.serialize(writer));
if (!w)
return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): YgoCtosMsg {
const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new YgoCtosMsg();
while (reader.nextField()) {
if (reader.isEndGroup())
break;
switch (reader.getFieldNumber()) {
case 1:
message.proto = reader.readInt32();
break;
case 2:
reader.readMessage(message.ctos_player_info, () => message.ctos_player_info = CtosPlayerInfo.deserialize(reader));
break;
case 3:
reader.readMessage(message.ctos_join_game, () => message.ctos_join_game = CtosJoinGame.deserialize(reader));
break;
case 4:
reader.readMessage(message.ctos_update_deck, () => message.ctos_update_deck = CtosUpdateDeck.deserialize(reader));
break;
case 101:
reader.readMessage(message.stoc_join_game, () => message.stoc_join_game = StocJoinGame.deserialize(reader));
break;
case 102:
reader.readMessage(message.stoc_chat, () => message.stoc_chat = StocChat.deserialize(reader));
break;
case 103:
reader.readMessage(message.stoc_hs_player_enter, () => message.stoc_hs_player_enter = StocHsPlayerEnter.deserialize(reader));
break;
case 104:
reader.readMessage(message.stoc_type_change, () => message.stoc_type_change = StocTypeChange.deserialize(reader));
break;
default: reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): YgoCtosMsg {
return YgoCtosMsg.deserialize(bytes);
}
} }
export class CtosPlayerInfo extends pb_1.Message { get proto() {
#one_of_decls: number[][] = []; return pb_1.Message.getFieldWithDefault(this, 1, 0) as number;
constructor(data?: any[] | { }
name?: string; set proto(value: number) {
}) { pb_1.Message.setField(this, 1, value);
super(); }
pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls); get ctos_player_info() {
if (!Array.isArray(data) && typeof data == "object") { return pb_1.Message.getWrapperField(
if ("name" in data && data.name != undefined) { this,
this.name = data.name; CtosPlayerInfo,
} 2
} ) as CtosPlayerInfo;
} }
get name() { set ctos_player_info(value: CtosPlayerInfo) {
return pb_1.Message.getFieldWithDefault(this, 1, "") as string; pb_1.Message.setOneofWrapperField(this, 2, this.#one_of_decls[0], value);
} }
set name(value: string) { get has_ctos_player_info() {
pb_1.Message.setField(this, 1, value); return pb_1.Message.getField(this, 2) != null;
} }
static fromObject(data: { get ctos_join_game() {
return pb_1.Message.getWrapperField(
this,
CtosJoinGame,
3
) as CtosJoinGame;
}
set ctos_join_game(value: CtosJoinGame) {
pb_1.Message.setOneofWrapperField(this, 3, this.#one_of_decls[0], value);
}
get has_ctos_join_game() {
return pb_1.Message.getField(this, 3) != null;
}
get ctos_update_deck() {
return pb_1.Message.getWrapperField(
this,
CtosUpdateDeck,
4
) as CtosUpdateDeck;
}
set ctos_update_deck(value: CtosUpdateDeck) {
pb_1.Message.setOneofWrapperField(this, 4, this.#one_of_decls[0], value);
}
get has_ctos_update_deck() {
return pb_1.Message.getField(this, 4) != null;
}
get stoc_join_game() {
return pb_1.Message.getWrapperField(
this,
StocJoinGame,
101
) as StocJoinGame;
}
set stoc_join_game(value: StocJoinGame) {
pb_1.Message.setOneofWrapperField(
this,
101,
this.#one_of_decls[0],
value
);
}
get has_stoc_join_game() {
return pb_1.Message.getField(this, 101) != null;
}
get stoc_chat() {
return pb_1.Message.getWrapperField(this, StocChat, 102) as StocChat;
}
set stoc_chat(value: StocChat) {
pb_1.Message.setOneofWrapperField(
this,
102,
this.#one_of_decls[0],
value
);
}
get has_stoc_chat() {
return pb_1.Message.getField(this, 102) != null;
}
get stoc_hs_player_enter() {
return pb_1.Message.getWrapperField(
this,
StocHsPlayerEnter,
103
) as StocHsPlayerEnter;
}
set stoc_hs_player_enter(value: StocHsPlayerEnter) {
pb_1.Message.setOneofWrapperField(
this,
103,
this.#one_of_decls[0],
value
);
}
get has_stoc_hs_player_enter() {
return pb_1.Message.getField(this, 103) != null;
}
get stoc_type_change() {
return pb_1.Message.getWrapperField(
this,
StocTypeChange,
104
) as StocTypeChange;
}
set stoc_type_change(value: StocTypeChange) {
pb_1.Message.setOneofWrapperField(
this,
104,
this.#one_of_decls[0],
value
);
}
get has_stoc_type_change() {
return pb_1.Message.getField(this, 104) != null;
}
get msg() {
const cases: {
[index: number]:
| "none"
| "ctos_player_info"
| "ctos_join_game"
| "ctos_update_deck"
| "stoc_join_game"
| "stoc_chat"
| "stoc_hs_player_enter"
| "stoc_type_change";
} = {
0: "none",
2: "ctos_player_info",
3: "ctos_join_game",
4: "ctos_update_deck",
101: "stoc_join_game",
102: "stoc_chat",
103: "stoc_hs_player_enter",
104: "stoc_type_change",
};
return cases[
pb_1.Message.computeOneofCase(this, [2, 3, 4, 101, 102, 103, 104])
];
}
static fromObject(data: {
proto?: number;
ctos_player_info?: ReturnType<typeof CtosPlayerInfo.prototype.toObject>;
ctos_join_game?: ReturnType<typeof CtosJoinGame.prototype.toObject>;
ctos_update_deck?: ReturnType<typeof CtosUpdateDeck.prototype.toObject>;
stoc_join_game?: ReturnType<typeof StocJoinGame.prototype.toObject>;
stoc_chat?: ReturnType<typeof StocChat.prototype.toObject>;
stoc_hs_player_enter?: ReturnType<
typeof StocHsPlayerEnter.prototype.toObject
>;
stoc_type_change?: ReturnType<typeof StocTypeChange.prototype.toObject>;
}): YgoCtosMsg {
const message = new YgoCtosMsg({});
if (data.proto != null) {
message.proto = data.proto;
}
if (data.ctos_player_info != null) {
message.ctos_player_info = CtosPlayerInfo.fromObject(
data.ctos_player_info
);
}
if (data.ctos_join_game != null) {
message.ctos_join_game = CtosJoinGame.fromObject(data.ctos_join_game);
}
if (data.ctos_update_deck != null) {
message.ctos_update_deck = CtosUpdateDeck.fromObject(
data.ctos_update_deck
);
}
if (data.stoc_join_game != null) {
message.stoc_join_game = StocJoinGame.fromObject(data.stoc_join_game);
}
if (data.stoc_chat != null) {
message.stoc_chat = StocChat.fromObject(data.stoc_chat);
}
if (data.stoc_hs_player_enter != null) {
message.stoc_hs_player_enter = StocHsPlayerEnter.fromObject(
data.stoc_hs_player_enter
);
}
if (data.stoc_type_change != null) {
message.stoc_type_change = StocTypeChange.fromObject(
data.stoc_type_change
);
}
return message;
}
toObject() {
const data: {
proto?: number;
ctos_player_info?: ReturnType<typeof CtosPlayerInfo.prototype.toObject>;
ctos_join_game?: ReturnType<typeof CtosJoinGame.prototype.toObject>;
ctos_update_deck?: ReturnType<typeof CtosUpdateDeck.prototype.toObject>;
stoc_join_game?: ReturnType<typeof StocJoinGame.prototype.toObject>;
stoc_chat?: ReturnType<typeof StocChat.prototype.toObject>;
stoc_hs_player_enter?: ReturnType<
typeof StocHsPlayerEnter.prototype.toObject
>;
stoc_type_change?: ReturnType<typeof StocTypeChange.prototype.toObject>;
} = {};
if (this.proto != null) {
data.proto = this.proto;
}
if (this.ctos_player_info != null) {
data.ctos_player_info = this.ctos_player_info.toObject();
}
if (this.ctos_join_game != null) {
data.ctos_join_game = this.ctos_join_game.toObject();
}
if (this.ctos_update_deck != null) {
data.ctos_update_deck = this.ctos_update_deck.toObject();
}
if (this.stoc_join_game != null) {
data.stoc_join_game = this.stoc_join_game.toObject();
}
if (this.stoc_chat != null) {
data.stoc_chat = this.stoc_chat.toObject();
}
if (this.stoc_hs_player_enter != null) {
data.stoc_hs_player_enter = this.stoc_hs_player_enter.toObject();
}
if (this.stoc_type_change != null) {
data.stoc_type_change = this.stoc_type_change.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.proto != 0) writer.writeInt32(1, this.proto);
if (this.has_ctos_player_info)
writer.writeMessage(2, this.ctos_player_info, () =>
this.ctos_player_info.serialize(writer)
);
if (this.has_ctos_join_game)
writer.writeMessage(3, this.ctos_join_game, () =>
this.ctos_join_game.serialize(writer)
);
if (this.has_ctos_update_deck)
writer.writeMessage(4, this.ctos_update_deck, () =>
this.ctos_update_deck.serialize(writer)
);
if (this.has_stoc_join_game)
writer.writeMessage(101, this.stoc_join_game, () =>
this.stoc_join_game.serialize(writer)
);
if (this.has_stoc_chat)
writer.writeMessage(102, this.stoc_chat, () =>
this.stoc_chat.serialize(writer)
);
if (this.has_stoc_hs_player_enter)
writer.writeMessage(103, this.stoc_hs_player_enter, () =>
this.stoc_hs_player_enter.serialize(writer)
);
if (this.has_stoc_type_change)
writer.writeMessage(104, this.stoc_type_change, () =>
this.stoc_type_change.serialize(writer)
);
if (!w) return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): YgoCtosMsg {
const reader =
bytes instanceof pb_1.BinaryReader
? bytes
: new pb_1.BinaryReader(bytes),
message = new YgoCtosMsg();
while (reader.nextField()) {
if (reader.isEndGroup()) break;
switch (reader.getFieldNumber()) {
case 1:
message.proto = reader.readInt32();
break;
case 2:
reader.readMessage(
message.ctos_player_info,
() =>
(message.ctos_player_info = CtosPlayerInfo.deserialize(reader))
);
break;
case 3:
reader.readMessage(
message.ctos_join_game,
() => (message.ctos_join_game = CtosJoinGame.deserialize(reader))
);
break;
case 4:
reader.readMessage(
message.ctos_update_deck,
() =>
(message.ctos_update_deck = CtosUpdateDeck.deserialize(reader))
);
break;
case 101:
reader.readMessage(
message.stoc_join_game,
() => (message.stoc_join_game = StocJoinGame.deserialize(reader))
);
break;
case 102:
reader.readMessage(
message.stoc_chat,
() => (message.stoc_chat = StocChat.deserialize(reader))
);
break;
case 103:
reader.readMessage(
message.stoc_hs_player_enter,
() =>
(message.stoc_hs_player_enter =
StocHsPlayerEnter.deserialize(reader))
);
break;
case 104:
reader.readMessage(
message.stoc_type_change,
() =>
(message.stoc_type_change = StocTypeChange.deserialize(reader))
);
break;
default:
reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): YgoCtosMsg {
return YgoCtosMsg.deserialize(bytes);
}
}
export class CtosPlayerInfo extends pb_1.Message {
#one_of_decls: number[][] = [];
constructor(
data?:
| any[]
| {
name?: string; name?: string;
}): CtosPlayerInfo { }
const message = new CtosPlayerInfo({}); ) {
if (data.name != null) { super();
message.name = data.name; pb_1.Message.initialize(
} this,
return message; Array.isArray(data) ? data : [],
} 0,
toObject() { -1,
const data: { [],
name?: string; this.#one_of_decls
} = {}; );
if (this.name != null) { if (!Array.isArray(data) && typeof data == "object") {
data.name = this.name; if ("name" in data && data.name != undefined) {
} this.name = data.name;
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.name.length)
writer.writeString(1, this.name);
if (!w)
return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): CtosPlayerInfo {
const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new CtosPlayerInfo();
while (reader.nextField()) {
if (reader.isEndGroup())
break;
switch (reader.getFieldNumber()) {
case 1:
message.name = reader.readString();
break;
default: reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): CtosPlayerInfo {
return CtosPlayerInfo.deserialize(bytes);
}
} }
export class CtosJoinGame extends pb_1.Message { get name() {
#one_of_decls: number[][] = []; return pb_1.Message.getFieldWithDefault(this, 1, "") as string;
constructor(data?: any[] | { }
version?: number; set name(value: string) {
gameid?: number; pb_1.Message.setField(this, 1, value);
passwd?: string; }
}) { static fromObject(data: { name?: string }): CtosPlayerInfo {
super(); const message = new CtosPlayerInfo({});
pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls); if (data.name != null) {
if (!Array.isArray(data) && typeof data == "object") { message.name = data.name;
if ("version" in data && data.version != undefined) { }
this.version = data.version; return message;
} }
if ("gameid" in data && data.gameid != undefined) { toObject() {
this.gameid = data.gameid; const data: {
} name?: string;
if ("passwd" in data && data.passwd != undefined) { } = {};
this.passwd = data.passwd; if (this.name != null) {
} data.name = this.name;
} }
} return data;
get version() { }
return pb_1.Message.getFieldWithDefault(this, 1, 0) as number; serialize(): Uint8Array;
} serialize(w: pb_1.BinaryWriter): void;
set version(value: number) { serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
pb_1.Message.setField(this, 1, value); const writer = w || new pb_1.BinaryWriter();
} if (this.name.length) writer.writeString(1, this.name);
get gameid() { if (!w) return writer.getResultBuffer();
return pb_1.Message.getFieldWithDefault(this, 2, 0) as number; }
} static deserialize(bytes: Uint8Array | pb_1.BinaryReader): CtosPlayerInfo {
set gameid(value: number) { const reader =
pb_1.Message.setField(this, 2, value); bytes instanceof pb_1.BinaryReader
} ? bytes
get passwd() { : new pb_1.BinaryReader(bytes),
return pb_1.Message.getFieldWithDefault(this, 3, "") as string; message = new CtosPlayerInfo();
} while (reader.nextField()) {
set passwd(value: string) { if (reader.isEndGroup()) break;
pb_1.Message.setField(this, 3, value); switch (reader.getFieldNumber()) {
} case 1:
static fromObject(data: { message.name = reader.readString();
break;
default:
reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): CtosPlayerInfo {
return CtosPlayerInfo.deserialize(bytes);
}
}
export class CtosJoinGame extends pb_1.Message {
#one_of_decls: number[][] = [];
constructor(
data?:
| any[]
| {
version?: number; version?: number;
gameid?: number; gameid?: number;
passwd?: string; passwd?: string;
}): CtosJoinGame { }
const message = new CtosJoinGame({}); ) {
if (data.version != null) { super();
message.version = data.version; pb_1.Message.initialize(
} this,
if (data.gameid != null) { Array.isArray(data) ? data : [],
message.gameid = data.gameid; 0,
} -1,
if (data.passwd != null) { [],
message.passwd = data.passwd; this.#one_of_decls
} );
return message; if (!Array.isArray(data) && typeof data == "object") {
} if ("version" in data && data.version != undefined) {
toObject() { this.version = data.version;
const data: { }
version?: number; if ("gameid" in data && data.gameid != undefined) {
gameid?: number; this.gameid = data.gameid;
passwd?: string; }
} = {}; if ("passwd" in data && data.passwd != undefined) {
if (this.version != null) { this.passwd = data.passwd;
data.version = this.version; }
} }
if (this.gameid != null) {
data.gameid = this.gameid;
}
if (this.passwd != null) {
data.passwd = this.passwd;
}
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.version != 0)
writer.writeInt32(1, this.version);
if (this.gameid != 0)
writer.writeInt32(2, this.gameid);
if (this.passwd.length)
writer.writeString(3, this.passwd);
if (!w)
return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): CtosJoinGame {
const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new CtosJoinGame();
while (reader.nextField()) {
if (reader.isEndGroup())
break;
switch (reader.getFieldNumber()) {
case 1:
message.version = reader.readInt32();
break;
case 2:
message.gameid = reader.readInt32();
break;
case 3:
message.passwd = reader.readString();
break;
default: reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): CtosJoinGame {
return CtosJoinGame.deserialize(bytes);
}
} }
export class CtosUpdateDeck extends pb_1.Message { get version() {
#one_of_decls: number[][] = []; return pb_1.Message.getFieldWithDefault(this, 1, 0) as number;
constructor(data?: any[] | { }
main?: number[]; set version(value: number) {
extra?: number[]; pb_1.Message.setField(this, 1, value);
side?: number[]; }
}) { get gameid() {
super(); return pb_1.Message.getFieldWithDefault(this, 2, 0) as number;
pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1, 2, 3], this.#one_of_decls); }
if (!Array.isArray(data) && typeof data == "object") { set gameid(value: number) {
if ("main" in data && data.main != undefined) { pb_1.Message.setField(this, 2, value);
this.main = data.main; }
} get passwd() {
if ("extra" in data && data.extra != undefined) { return pb_1.Message.getFieldWithDefault(this, 3, "") as string;
this.extra = data.extra; }
} set passwd(value: string) {
if ("side" in data && data.side != undefined) { pb_1.Message.setField(this, 3, value);
this.side = data.side; }
} static fromObject(data: {
} version?: number;
} gameid?: number;
get main() { passwd?: string;
return pb_1.Message.getFieldWithDefault(this, 1, []) as number[]; }): CtosJoinGame {
} const message = new CtosJoinGame({});
set main(value: number[]) { if (data.version != null) {
pb_1.Message.setField(this, 1, value); message.version = data.version;
} }
get extra() { if (data.gameid != null) {
return pb_1.Message.getFieldWithDefault(this, 2, []) as number[]; message.gameid = data.gameid;
} }
set extra(value: number[]) { if (data.passwd != null) {
pb_1.Message.setField(this, 2, value); message.passwd = data.passwd;
} }
get side() { return message;
return pb_1.Message.getFieldWithDefault(this, 3, []) as number[]; }
} toObject() {
set side(value: number[]) { const data: {
pb_1.Message.setField(this, 3, value); version?: number;
} gameid?: number;
static fromObject(data: { passwd?: string;
} = {};
if (this.version != null) {
data.version = this.version;
}
if (this.gameid != null) {
data.gameid = this.gameid;
}
if (this.passwd != null) {
data.passwd = this.passwd;
}
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.version != 0) writer.writeInt32(1, this.version);
if (this.gameid != 0) writer.writeInt32(2, this.gameid);
if (this.passwd.length) writer.writeString(3, this.passwd);
if (!w) return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): CtosJoinGame {
const reader =
bytes instanceof pb_1.BinaryReader
? bytes
: new pb_1.BinaryReader(bytes),
message = new CtosJoinGame();
while (reader.nextField()) {
if (reader.isEndGroup()) break;
switch (reader.getFieldNumber()) {
case 1:
message.version = reader.readInt32();
break;
case 2:
message.gameid = reader.readInt32();
break;
case 3:
message.passwd = reader.readString();
break;
default:
reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): CtosJoinGame {
return CtosJoinGame.deserialize(bytes);
}
}
export class CtosUpdateDeck extends pb_1.Message {
#one_of_decls: number[][] = [];
constructor(
data?:
| any[]
| {
main?: number[]; main?: number[];
extra?: number[]; extra?: number[];
side?: number[]; side?: number[];
}): CtosUpdateDeck { }
const message = new CtosUpdateDeck({}); ) {
if (data.main != null) { super();
message.main = data.main; pb_1.Message.initialize(
} this,
if (data.extra != null) { Array.isArray(data) ? data : [],
message.extra = data.extra; 0,
} -1,
if (data.side != null) { [1, 2, 3],
message.side = data.side; this.#one_of_decls
} );
return message; if (!Array.isArray(data) && typeof data == "object") {
} if ("main" in data && data.main != undefined) {
toObject() { this.main = data.main;
const data: { }
main?: number[]; if ("extra" in data && data.extra != undefined) {
extra?: number[]; this.extra = data.extra;
side?: number[]; }
} = {}; if ("side" in data && data.side != undefined) {
if (this.main != null) { this.side = data.side;
data.main = this.main; }
} }
if (this.extra != null) { }
data.extra = this.extra; get main() {
} return pb_1.Message.getFieldWithDefault(this, 1, []) as number[];
if (this.side != null) { }
data.side = this.side; set main(value: number[]) {
} pb_1.Message.setField(this, 1, value);
return data; }
} get extra() {
serialize(): Uint8Array; return pb_1.Message.getFieldWithDefault(this, 2, []) as number[];
serialize(w: pb_1.BinaryWriter): void;
serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
const writer = w || new pb_1.BinaryWriter();
if (this.main.length)
writer.writePackedInt32(1, this.main);
if (this.extra.length)
writer.writePackedInt32(2, this.extra);
if (this.side.length)
writer.writePackedInt32(3, this.side);
if (!w)
return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): CtosUpdateDeck {
const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new CtosUpdateDeck();
while (reader.nextField()) {
if (reader.isEndGroup())
break;
switch (reader.getFieldNumber()) {
case 1:
message.main = reader.readPackedInt32();
break;
case 2:
message.extra = reader.readPackedInt32();
break;
case 3:
message.side = reader.readPackedInt32();
break;
default: reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): CtosUpdateDeck {
return CtosUpdateDeck.deserialize(bytes);
}
} }
export class StocJoinGame extends pb_1.Message { set extra(value: number[]) {
#one_of_decls: number[][] = []; pb_1.Message.setField(this, 2, value);
constructor(data?: any[] | { }
get side() {
return pb_1.Message.getFieldWithDefault(this, 3, []) as number[];
}
set side(value: number[]) {
pb_1.Message.setField(this, 3, value);
}
static fromObject(data: {
main?: number[];
extra?: number[];
side?: number[];
}): CtosUpdateDeck {
const message = new CtosUpdateDeck({});
if (data.main != null) {
message.main = data.main;
}
if (data.extra != null) {
message.extra = data.extra;
}
if (data.side != null) {
message.side = data.side;
}
return message;
}
toObject() {
const data: {
main?: number[];
extra?: number[];
side?: number[];
} = {};
if (this.main != null) {
data.main = this.main;
}
if (this.extra != null) {
data.extra = this.extra;
}
if (this.side != null) {
data.side = this.side;
}
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.main.length) writer.writePackedInt32(1, this.main);
if (this.extra.length) writer.writePackedInt32(2, this.extra);
if (this.side.length) writer.writePackedInt32(3, this.side);
if (!w) return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): CtosUpdateDeck {
const reader =
bytes instanceof pb_1.BinaryReader
? bytes
: new pb_1.BinaryReader(bytes),
message = new CtosUpdateDeck();
while (reader.nextField()) {
if (reader.isEndGroup()) break;
switch (reader.getFieldNumber()) {
case 1:
message.main = reader.readPackedInt32();
break;
case 2:
message.extra = reader.readPackedInt32();
break;
case 3:
message.side = reader.readPackedInt32();
break;
default:
reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): CtosUpdateDeck {
return CtosUpdateDeck.deserialize(bytes);
}
}
export class StocJoinGame extends pb_1.Message {
#one_of_decls: number[][] = [];
constructor(
data?:
| any[]
| {
lflist?: number; lflist?: number;
rule?: number; rule?: number;
mode?: number; mode?: number;
...@@ -624,512 +790,548 @@ export namespace ygopro { ...@@ -624,512 +790,548 @@ export namespace ygopro {
start_hand?: number; start_hand?: number;
draw_count?: number; draw_count?: number;
time_limit?: number; time_limit?: number;
}) { }
super(); ) {
pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls); super();
if (!Array.isArray(data) && typeof data == "object") { pb_1.Message.initialize(
if ("lflist" in data && data.lflist != undefined) { this,
this.lflist = data.lflist; Array.isArray(data) ? data : [],
} 0,
if ("rule" in data && data.rule != undefined) { -1,
this.rule = data.rule; [],
} this.#one_of_decls
if ("mode" in data && data.mode != undefined) { );
this.mode = data.mode; if (!Array.isArray(data) && typeof data == "object") {
} if ("lflist" in data && data.lflist != undefined) {
if ("duel_rule" in data && data.duel_rule != undefined) { this.lflist = data.lflist;
this.duel_rule = data.duel_rule;
}
if ("no_check_deck" in data && data.no_check_deck != undefined) {
this.no_check_deck = data.no_check_deck;
}
if ("no_shuffle_deck" in data && data.no_shuffle_deck != undefined) {
this.no_shuffle_deck = data.no_shuffle_deck;
}
if ("start_lp" in data && data.start_lp != undefined) {
this.start_lp = data.start_lp;
}
if ("start_hand" in data && data.start_hand != undefined) {
this.start_hand = data.start_hand;
}
if ("draw_count" in data && data.draw_count != undefined) {
this.draw_count = data.draw_count;
}
if ("time_limit" in data && data.time_limit != undefined) {
this.time_limit = data.time_limit;
}
}
}
get lflist() {
return pb_1.Message.getFieldWithDefault(this, 1, 0) as number;
}
set lflist(value: number) {
pb_1.Message.setField(this, 1, value);
}
get rule() {
return pb_1.Message.getFieldWithDefault(this, 2, 0) as number;
}
set rule(value: number) {
pb_1.Message.setField(this, 2, value);
}
get mode() {
return pb_1.Message.getFieldWithDefault(this, 3, 0) as number;
}
set mode(value: number) {
pb_1.Message.setField(this, 3, value);
}
get duel_rule() {
return pb_1.Message.getFieldWithDefault(this, 4, 0) as number;
} }
set duel_rule(value: number) { if ("rule" in data && data.rule != undefined) {
pb_1.Message.setField(this, 4, value); this.rule = data.rule;
} }
get no_check_deck() { if ("mode" in data && data.mode != undefined) {
return pb_1.Message.getFieldWithDefault(this, 5, false) as boolean; this.mode = data.mode;
} }
set no_check_deck(value: boolean) { if ("duel_rule" in data && data.duel_rule != undefined) {
pb_1.Message.setField(this, 5, value); this.duel_rule = data.duel_rule;
} }
get no_shuffle_deck() { if ("no_check_deck" in data && data.no_check_deck != undefined) {
return pb_1.Message.getFieldWithDefault(this, 6, false) as boolean; this.no_check_deck = data.no_check_deck;
} }
set no_shuffle_deck(value: boolean) { if ("no_shuffle_deck" in data && data.no_shuffle_deck != undefined) {
pb_1.Message.setField(this, 6, value); this.no_shuffle_deck = data.no_shuffle_deck;
} }
get start_lp() { if ("start_lp" in data && data.start_lp != undefined) {
return pb_1.Message.getFieldWithDefault(this, 7, 0) as number; this.start_lp = data.start_lp;
} }
set start_lp(value: number) { if ("start_hand" in data && data.start_hand != undefined) {
pb_1.Message.setField(this, 7, value); this.start_hand = data.start_hand;
} }
get start_hand() { if ("draw_count" in data && data.draw_count != undefined) {
return pb_1.Message.getFieldWithDefault(this, 8, 0) as number; this.draw_count = data.draw_count;
}
set start_hand(value: number) {
pb_1.Message.setField(this, 8, value);
}
get draw_count() {
return pb_1.Message.getFieldWithDefault(this, 9, 0) as number;
}
set draw_count(value: number) {
pb_1.Message.setField(this, 9, value);
}
get time_limit() {
return pb_1.Message.getFieldWithDefault(this, 10, 0) as number;
}
set time_limit(value: number) {
pb_1.Message.setField(this, 10, value);
}
static fromObject(data: {
lflist?: number;
rule?: number;
mode?: number;
duel_rule?: number;
no_check_deck?: boolean;
no_shuffle_deck?: boolean;
start_lp?: number;
start_hand?: number;
draw_count?: number;
time_limit?: number;
}): StocJoinGame {
const message = new StocJoinGame({});
if (data.lflist != null) {
message.lflist = data.lflist;
}
if (data.rule != null) {
message.rule = data.rule;
}
if (data.mode != null) {
message.mode = data.mode;
}
if (data.duel_rule != null) {
message.duel_rule = data.duel_rule;
}
if (data.no_check_deck != null) {
message.no_check_deck = data.no_check_deck;
}
if (data.no_shuffle_deck != null) {
message.no_shuffle_deck = data.no_shuffle_deck;
}
if (data.start_lp != null) {
message.start_lp = data.start_lp;
}
if (data.start_hand != null) {
message.start_hand = data.start_hand;
}
if (data.draw_count != null) {
message.draw_count = data.draw_count;
}
if (data.time_limit != null) {
message.time_limit = data.time_limit;
}
return message;
} }
toObject() { if ("time_limit" in data && data.time_limit != undefined) {
const data: { this.time_limit = data.time_limit;
lflist?: number;
rule?: number;
mode?: number;
duel_rule?: number;
no_check_deck?: boolean;
no_shuffle_deck?: boolean;
start_lp?: number;
start_hand?: number;
draw_count?: number;
time_limit?: number;
} = {};
if (this.lflist != null) {
data.lflist = this.lflist;
}
if (this.rule != null) {
data.rule = this.rule;
}
if (this.mode != null) {
data.mode = this.mode;
}
if (this.duel_rule != null) {
data.duel_rule = this.duel_rule;
}
if (this.no_check_deck != null) {
data.no_check_deck = this.no_check_deck;
}
if (this.no_shuffle_deck != null) {
data.no_shuffle_deck = this.no_shuffle_deck;
}
if (this.start_lp != null) {
data.start_lp = this.start_lp;
}
if (this.start_hand != null) {
data.start_hand = this.start_hand;
}
if (this.draw_count != null) {
data.draw_count = this.draw_count;
}
if (this.time_limit != null) {
data.time_limit = this.time_limit;
}
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.lflist != 0)
writer.writeInt32(1, this.lflist);
if (this.rule != 0)
writer.writeInt32(2, this.rule);
if (this.mode != 0)
writer.writeInt32(3, this.mode);
if (this.duel_rule != 0)
writer.writeInt32(4, this.duel_rule);
if (this.no_check_deck != false)
writer.writeBool(5, this.no_check_deck);
if (this.no_shuffle_deck != false)
writer.writeBool(6, this.no_shuffle_deck);
if (this.start_lp != 0)
writer.writeInt32(7, this.start_lp);
if (this.start_hand != 0)
writer.writeInt32(8, this.start_hand);
if (this.draw_count != 0)
writer.writeInt32(9, this.draw_count);
if (this.time_limit != 0)
writer.writeInt32(10, this.time_limit);
if (!w)
return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StocJoinGame {
const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StocJoinGame();
while (reader.nextField()) {
if (reader.isEndGroup())
break;
switch (reader.getFieldNumber()) {
case 1:
message.lflist = reader.readInt32();
break;
case 2:
message.rule = reader.readInt32();
break;
case 3:
message.mode = reader.readInt32();
break;
case 4:
message.duel_rule = reader.readInt32();
break;
case 5:
message.no_check_deck = reader.readBool();
break;
case 6:
message.no_shuffle_deck = reader.readBool();
break;
case 7:
message.start_lp = reader.readInt32();
break;
case 8:
message.start_hand = reader.readInt32();
break;
case 9:
message.draw_count = reader.readInt32();
break;
case 10:
message.time_limit = reader.readInt32();
break;
default: reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): StocJoinGame {
return StocJoinGame.deserialize(bytes);
} }
}
} }
export class StocChat extends pb_1.Message { get lflist() {
#one_of_decls: number[][] = []; return pb_1.Message.getFieldWithDefault(this, 1, 0) as number;
constructor(data?: any[] | { }
player?: number; set lflist(value: number) {
msg?: string; pb_1.Message.setField(this, 1, value);
}) { }
super(); get rule() {
pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls); return pb_1.Message.getFieldWithDefault(this, 2, 0) as number;
if (!Array.isArray(data) && typeof data == "object") { }
if ("player" in data && data.player != undefined) { set rule(value: number) {
this.player = data.player; pb_1.Message.setField(this, 2, value);
} }
if ("msg" in data && data.msg != undefined) { get mode() {
this.msg = data.msg; return pb_1.Message.getFieldWithDefault(this, 3, 0) as number;
} }
} set mode(value: number) {
} pb_1.Message.setField(this, 3, value);
get player() { }
return pb_1.Message.getFieldWithDefault(this, 1, 0) as number; get duel_rule() {
} return pb_1.Message.getFieldWithDefault(this, 4, 0) as number;
set player(value: number) { }
pb_1.Message.setField(this, 1, value); set duel_rule(value: number) {
} pb_1.Message.setField(this, 4, value);
get msg() { }
return pb_1.Message.getFieldWithDefault(this, 2, "") as string; get no_check_deck() {
} return pb_1.Message.getFieldWithDefault(this, 5, false) as boolean;
set msg(value: string) { }
pb_1.Message.setField(this, 2, value); set no_check_deck(value: boolean) {
} pb_1.Message.setField(this, 5, value);
static fromObject(data: { }
get no_shuffle_deck() {
return pb_1.Message.getFieldWithDefault(this, 6, false) as boolean;
}
set no_shuffle_deck(value: boolean) {
pb_1.Message.setField(this, 6, value);
}
get start_lp() {
return pb_1.Message.getFieldWithDefault(this, 7, 0) as number;
}
set start_lp(value: number) {
pb_1.Message.setField(this, 7, value);
}
get start_hand() {
return pb_1.Message.getFieldWithDefault(this, 8, 0) as number;
}
set start_hand(value: number) {
pb_1.Message.setField(this, 8, value);
}
get draw_count() {
return pb_1.Message.getFieldWithDefault(this, 9, 0) as number;
}
set draw_count(value: number) {
pb_1.Message.setField(this, 9, value);
}
get time_limit() {
return pb_1.Message.getFieldWithDefault(this, 10, 0) as number;
}
set time_limit(value: number) {
pb_1.Message.setField(this, 10, value);
}
static fromObject(data: {
lflist?: number;
rule?: number;
mode?: number;
duel_rule?: number;
no_check_deck?: boolean;
no_shuffle_deck?: boolean;
start_lp?: number;
start_hand?: number;
draw_count?: number;
time_limit?: number;
}): StocJoinGame {
const message = new StocJoinGame({});
if (data.lflist != null) {
message.lflist = data.lflist;
}
if (data.rule != null) {
message.rule = data.rule;
}
if (data.mode != null) {
message.mode = data.mode;
}
if (data.duel_rule != null) {
message.duel_rule = data.duel_rule;
}
if (data.no_check_deck != null) {
message.no_check_deck = data.no_check_deck;
}
if (data.no_shuffle_deck != null) {
message.no_shuffle_deck = data.no_shuffle_deck;
}
if (data.start_lp != null) {
message.start_lp = data.start_lp;
}
if (data.start_hand != null) {
message.start_hand = data.start_hand;
}
if (data.draw_count != null) {
message.draw_count = data.draw_count;
}
if (data.time_limit != null) {
message.time_limit = data.time_limit;
}
return message;
}
toObject() {
const data: {
lflist?: number;
rule?: number;
mode?: number;
duel_rule?: number;
no_check_deck?: boolean;
no_shuffle_deck?: boolean;
start_lp?: number;
start_hand?: number;
draw_count?: number;
time_limit?: number;
} = {};
if (this.lflist != null) {
data.lflist = this.lflist;
}
if (this.rule != null) {
data.rule = this.rule;
}
if (this.mode != null) {
data.mode = this.mode;
}
if (this.duel_rule != null) {
data.duel_rule = this.duel_rule;
}
if (this.no_check_deck != null) {
data.no_check_deck = this.no_check_deck;
}
if (this.no_shuffle_deck != null) {
data.no_shuffle_deck = this.no_shuffle_deck;
}
if (this.start_lp != null) {
data.start_lp = this.start_lp;
}
if (this.start_hand != null) {
data.start_hand = this.start_hand;
}
if (this.draw_count != null) {
data.draw_count = this.draw_count;
}
if (this.time_limit != null) {
data.time_limit = this.time_limit;
}
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.lflist != 0) writer.writeInt32(1, this.lflist);
if (this.rule != 0) writer.writeInt32(2, this.rule);
if (this.mode != 0) writer.writeInt32(3, this.mode);
if (this.duel_rule != 0) writer.writeInt32(4, this.duel_rule);
if (this.no_check_deck != false) writer.writeBool(5, this.no_check_deck);
if (this.no_shuffle_deck != false)
writer.writeBool(6, this.no_shuffle_deck);
if (this.start_lp != 0) writer.writeInt32(7, this.start_lp);
if (this.start_hand != 0) writer.writeInt32(8, this.start_hand);
if (this.draw_count != 0) writer.writeInt32(9, this.draw_count);
if (this.time_limit != 0) writer.writeInt32(10, this.time_limit);
if (!w) return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StocJoinGame {
const reader =
bytes instanceof pb_1.BinaryReader
? bytes
: new pb_1.BinaryReader(bytes),
message = new StocJoinGame();
while (reader.nextField()) {
if (reader.isEndGroup()) break;
switch (reader.getFieldNumber()) {
case 1:
message.lflist = reader.readInt32();
break;
case 2:
message.rule = reader.readInt32();
break;
case 3:
message.mode = reader.readInt32();
break;
case 4:
message.duel_rule = reader.readInt32();
break;
case 5:
message.no_check_deck = reader.readBool();
break;
case 6:
message.no_shuffle_deck = reader.readBool();
break;
case 7:
message.start_lp = reader.readInt32();
break;
case 8:
message.start_hand = reader.readInt32();
break;
case 9:
message.draw_count = reader.readInt32();
break;
case 10:
message.time_limit = reader.readInt32();
break;
default:
reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): StocJoinGame {
return StocJoinGame.deserialize(bytes);
}
}
export class StocChat extends pb_1.Message {
#one_of_decls: number[][] = [];
constructor(
data?:
| any[]
| {
player?: number; player?: number;
msg?: string; msg?: string;
}): StocChat { }
const message = new StocChat({}); ) {
if (data.player != null) { super();
message.player = data.player; pb_1.Message.initialize(
} this,
if (data.msg != null) { Array.isArray(data) ? data : [],
message.msg = data.msg; 0,
} -1,
return message; [],
} this.#one_of_decls
toObject() { );
const data: { if (!Array.isArray(data) && typeof data == "object") {
player?: number; if ("player" in data && data.player != undefined) {
msg?: string; this.player = data.player;
} = {}; }
if (this.player != null) { if ("msg" in data && data.msg != undefined) {
data.player = this.player; this.msg = data.msg;
} }
if (this.msg != null) { }
data.msg = this.msg;
}
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.msg.length)
writer.writeString(2, this.msg);
if (!w)
return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StocChat {
const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StocChat();
while (reader.nextField()) {
if (reader.isEndGroup())
break;
switch (reader.getFieldNumber()) {
case 1:
message.player = reader.readInt32();
break;
case 2:
message.msg = reader.readString();
break;
default: reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): StocChat {
return StocChat.deserialize(bytes);
}
} }
export class StocHsPlayerEnter extends pb_1.Message { get player() {
#one_of_decls: number[][] = []; return pb_1.Message.getFieldWithDefault(this, 1, 0) as number;
constructor(data?: any[] | { }
name?: string; set player(value: number) {
pos?: number; pb_1.Message.setField(this, 1, value);
}) { }
super(); get msg() {
pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls); return pb_1.Message.getFieldWithDefault(this, 2, "") as string;
if (!Array.isArray(data) && typeof data == "object") { }
if ("name" in data && data.name != undefined) { set msg(value: string) {
this.name = data.name; pb_1.Message.setField(this, 2, value);
} }
if ("pos" in data && data.pos != undefined) { static fromObject(data: { player?: number; msg?: string }): StocChat {
this.pos = data.pos; const message = new StocChat({});
} if (data.player != null) {
} message.player = data.player;
} }
get name() { if (data.msg != null) {
return pb_1.Message.getFieldWithDefault(this, 1, "") as string; message.msg = data.msg;
} }
set name(value: string) { return message;
pb_1.Message.setField(this, 1, value); }
} toObject() {
get pos() { const data: {
return pb_1.Message.getFieldWithDefault(this, 2, 0) as number; player?: number;
} msg?: string;
set pos(value: number) { } = {};
pb_1.Message.setField(this, 2, value); if (this.player != null) {
} data.player = this.player;
static fromObject(data: { }
if (this.msg != null) {
data.msg = this.msg;
}
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.msg.length) writer.writeString(2, this.msg);
if (!w) return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StocChat {
const reader =
bytes instanceof pb_1.BinaryReader
? bytes
: new pb_1.BinaryReader(bytes),
message = new StocChat();
while (reader.nextField()) {
if (reader.isEndGroup()) break;
switch (reader.getFieldNumber()) {
case 1:
message.player = reader.readInt32();
break;
case 2:
message.msg = reader.readString();
break;
default:
reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): StocChat {
return StocChat.deserialize(bytes);
}
}
export class StocHsPlayerEnter extends pb_1.Message {
#one_of_decls: number[][] = [];
constructor(
data?:
| any[]
| {
name?: string; name?: string;
pos?: number; pos?: number;
}): StocHsPlayerEnter { }
const message = new StocHsPlayerEnter({}); ) {
if (data.name != null) { super();
message.name = data.name; pb_1.Message.initialize(
} this,
if (data.pos != null) { Array.isArray(data) ? data : [],
message.pos = data.pos; 0,
} -1,
return message; [],
} this.#one_of_decls
toObject() { );
const data: { if (!Array.isArray(data) && typeof data == "object") {
name?: string; if ("name" in data && data.name != undefined) {
pos?: number; this.name = data.name;
} = {}; }
if (this.name != null) { if ("pos" in data && data.pos != undefined) {
data.name = this.name; this.pos = data.pos;
} }
if (this.pos != null) { }
data.pos = this.pos;
}
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.name.length)
writer.writeString(1, this.name);
if (this.pos != 0)
writer.writeInt32(2, this.pos);
if (!w)
return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StocHsPlayerEnter {
const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StocHsPlayerEnter();
while (reader.nextField()) {
if (reader.isEndGroup())
break;
switch (reader.getFieldNumber()) {
case 1:
message.name = reader.readString();
break;
case 2:
message.pos = reader.readInt32();
break;
default: reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): StocHsPlayerEnter {
return StocHsPlayerEnter.deserialize(bytes);
}
} }
export class StocTypeChange extends pb_1.Message { get name() {
#one_of_decls: number[][] = []; return pb_1.Message.getFieldWithDefault(this, 1, "") as string;
constructor(data?: any[] | { }
type?: number; set name(value: string) {
}) { pb_1.Message.setField(this, 1, value);
super(); }
pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls); get pos() {
if (!Array.isArray(data) && typeof data == "object") { return pb_1.Message.getFieldWithDefault(this, 2, 0) as number;
if ("type" in data && data.type != undefined) { }
this.type = data.type; set pos(value: number) {
} pb_1.Message.setField(this, 2, value);
} }
} static fromObject(data: {
get type() { name?: string;
return pb_1.Message.getFieldWithDefault(this, 1, 0) as number; pos?: number;
} }): StocHsPlayerEnter {
set type(value: number) { const message = new StocHsPlayerEnter({});
pb_1.Message.setField(this, 1, value); if (data.name != null) {
} message.name = data.name;
static fromObject(data: { }
if (data.pos != null) {
message.pos = data.pos;
}
return message;
}
toObject() {
const data: {
name?: string;
pos?: number;
} = {};
if (this.name != null) {
data.name = this.name;
}
if (this.pos != null) {
data.pos = this.pos;
}
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.name.length) writer.writeString(1, this.name);
if (this.pos != 0) writer.writeInt32(2, this.pos);
if (!w) return writer.getResultBuffer();
}
static deserialize(
bytes: Uint8Array | pb_1.BinaryReader
): StocHsPlayerEnter {
const reader =
bytes instanceof pb_1.BinaryReader
? bytes
: new pb_1.BinaryReader(bytes),
message = new StocHsPlayerEnter();
while (reader.nextField()) {
if (reader.isEndGroup()) break;
switch (reader.getFieldNumber()) {
case 1:
message.name = reader.readString();
break;
case 2:
message.pos = reader.readInt32();
break;
default:
reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): StocHsPlayerEnter {
return StocHsPlayerEnter.deserialize(bytes);
}
}
export class StocTypeChange extends pb_1.Message {
#one_of_decls: number[][] = [];
constructor(
data?:
| any[]
| {
type?: number; type?: number;
}): StocTypeChange { }
const message = new StocTypeChange({}); ) {
if (data.type != null) { super();
message.type = data.type; pb_1.Message.initialize(
} this,
return message; Array.isArray(data) ? data : [],
} 0,
toObject() { -1,
const data: { [],
type?: number; this.#one_of_decls
} = {}; );
if (this.type != null) { if (!Array.isArray(data) && typeof data == "object") {
data.type = this.type; if ("type" in data && data.type != undefined) {
} this.type = data.type;
return data; }
} }
serialize(): Uint8Array; }
serialize(w: pb_1.BinaryWriter): void; get type() {
serialize(w?: pb_1.BinaryWriter): Uint8Array | void { return pb_1.Message.getFieldWithDefault(this, 1, 0) as number;
const writer = w || new pb_1.BinaryWriter(); }
if (this.type != 0) set type(value: number) {
writer.writeInt32(1, this.type); pb_1.Message.setField(this, 1, value);
if (!w) }
return writer.getResultBuffer(); static fromObject(data: { type?: number }): StocTypeChange {
} const message = new StocTypeChange({});
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StocTypeChange { if (data.type != null) {
const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new StocTypeChange(); message.type = data.type;
while (reader.nextField()) { }
if (reader.isEndGroup()) return message;
break; }
switch (reader.getFieldNumber()) { toObject() {
case 1: const data: {
message.type = reader.readInt32(); type?: number;
break; } = {};
default: reader.skipField(); if (this.type != null) {
} data.type = this.type;
} }
return message; return data;
} }
serializeBinary(): Uint8Array { serialize(): Uint8Array;
return this.serialize(); serialize(w: pb_1.BinaryWriter): void;
} serialize(w?: pb_1.BinaryWriter): Uint8Array | void {
static deserializeBinary(bytes: Uint8Array): StocTypeChange { const writer = w || new pb_1.BinaryWriter();
return StocTypeChange.deserialize(bytes); if (this.type != 0) writer.writeInt32(1, this.type);
} if (!w) return writer.getResultBuffer();
}
static deserialize(bytes: Uint8Array | pb_1.BinaryReader): StocTypeChange {
const reader =
bytes instanceof pb_1.BinaryReader
? bytes
: new pb_1.BinaryReader(bytes),
message = new StocTypeChange();
while (reader.nextField()) {
if (reader.isEndGroup()) break;
switch (reader.getFieldNumber()) {
case 1:
message.type = reader.readInt32();
break;
default:
reader.skipField();
}
}
return message;
}
serializeBinary(): Uint8Array {
return this.serialize();
}
static deserializeBinary(bytes: Uint8Array): StocTypeChange {
return StocTypeChange.deserialize(bytes);
} }
}
} }
src/index.css
View file @ c7d17ef2
body { body {
margin: 0; margin: 0;
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen",
'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue",
sans-serif; sans-serif;
-webkit-font-smoothing: antialiased; -webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale; -moz-osx-font-smoothing: grayscale;
} }
code { code {
font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New', font-family: source-code-pro, Menlo, Monaco, Consolas, "Courier New",
monospace; monospace;
} }
src/index.tsx
View file @ c7d17ef2
import React from 'react'; import React from "react";
import ReactDOM from 'react-dom/client'; import ReactDOM from "react-dom/client";
import './index.css'; import "./index.css";
import App from './App'; import App from "./App";
import reportWebVitals from './reportWebVitals'; import reportWebVitals from "./reportWebVitals";
const root = ReactDOM.createRoot( const root = ReactDOM.createRoot(
document.getElementById('root') as HTMLElement document.getElementById("root") as HTMLElement
); );
root.render( root.render(
<React.StrictMode> <React.StrictMode>
......
src/reportWebVitals.ts
View file @ c7d17ef2
import { ReportHandler } from 'web-vitals'; import { ReportHandler } from "web-vitals";
const reportWebVitals = (onPerfEntry?: ReportHandler) => { const reportWebVitals = (onPerfEntry?: ReportHandler) => {
if (onPerfEntry && onPerfEntry instanceof Function) { if (onPerfEntry && onPerfEntry instanceof Function) {
import('web-vitals').then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => { import("web-vitals").then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => {
getCLS(onPerfEntry); getCLS(onPerfEntry);
getFID(onPerfEntry); getFID(onPerfEntry);
getFCP(onPerfEntry); getFCP(onPerfEntry);
......
src/setupTests.ts
View file @ c7d17ef2
...@@ -2,4 +2,4 @@ ...@@ -2,4 +2,4 @@
// allows you to do things like: // allows you to do things like:
// expect(element).toHaveTextContent(/react/i) // expect(element).toHaveTextContent(/react/i)
// learn more: https://github.com/testing-library/jest-dom // learn more: https://github.com/testing-library/jest-dom
import '@testing-library/jest-dom'; import "@testing-library/jest-dom";
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment