From 4f49d996b14681f2acd2a8340b04e0b8ba5285f7 Mon Sep 17 00:00:00 2001 From: Somebody Date: Sat, 3 Feb 2024 21:50:03 +0800 Subject: [PATCH] fix some events (most events are available) --- .../proto/ChessRogueAvatarInfoOuterClass.java | 400 +++++ .../proto/ChessRogueAvatarOuterClass.java | 340 ++++ .../proto/ChessRogueBuffDataOuterClass.java | 295 ++++ .../proto/ChessRogueBuffInfoOuterClass.java | 282 ++++ .../proto/ChessRogueCellInfoOuterClass.java | 393 +++++ .../proto/ChessRogueCellOuterClass.java | 1183 ++++++++++++++ .../ChessRogueCellUpdateNotifyOuterClass.java | 425 +++++ .../ChessRogueConfirmRollScRspOuterClass.java | 362 +++++ .../ChessRogueCurrentInfoOuterClass.java | 1204 +++++++++++++++ .../proto/ChessRogueInfoOuterClass.java | 381 +++++ .../proto/ChessRogueItemInfoOuterClass.java | 617 ++++++++ .../ChessRogueMiracleDataOuterClass.java | 295 ++++ .../ChessRogueMiracleInfoOuterClass.java | 282 ++++ .../proto/ChessRogueMoneyInfoOuterClass.java | 259 ++++ .../ChessRogueNousDiceInfoOuterClass.java | 541 +++++++ .../proto/ChessRogueNousDiceOuterClass.java | 1367 +++++++++++++++++ ...essRogueNousDiceSurfaceInfoOuterClass.java | 342 +++++ ...ChessRogueNousEditDiceCsReqOuterClass.java | 283 ++++ ...ChessRogueNousEditDiceScRspOuterClass.java | 363 +++++ ...ChessRogueNousMainStoryInfoOuterClass.java | 361 +++++ .../ChessRogueNousQueryInfoOuterClass.java | 559 +++++++ .../ChessRogueNousStoryInfoOuterClass.java | 942 ++++++++++++ .../ChessRogueNousSubStoryInfoOuterClass.java | 260 ++++ .../proto/ChessRogueNousValueOuterClass.java | 259 ++++ .../proto/ChessRogueQueryOuterClass.java | 937 +++++++++++ .../proto/ChessRogueQueryScRspOuterClass.java | 501 ++++++ .../ChessRogueReRollDiceCsReqOuterClass.java | 260 ++++ .../ChessRogueRollDiceCsReqOuterClass.java | 260 ++++ .../ChessRogueRollDiceScRspOuterClass.java | 442 ++++++ .../ChessRogueSelectCellCsReqOuterClass.java | 260 ++++ .../ChessRogueSelectCellScRspOuterClass.java | 521 +++++++ .../proto/ChessRogueStartCsReqOuterClass.java | 924 +++++++++++ .../proto/ChessRogueStartScRspOuterClass.java | 794 ++++++++++ ...ueUpdateActionPointScNotifyOuterClass.java | 266 ++++ ...teAllowedSelectCellScNotifyOuterClass.java | 388 +++++ ...RogueUpdateDiceInfoScNotifyOuterClass.java | 285 ++++ ...siveAccumulateValueScNotifyOuterClass.java | 265 ++++ ...ogueUpdateMoneyInfoScNotifyOuterClass.java | 286 ++++ .../ChessRogueVirtualItemInfoOuterClass.java | 518 +++++++ ...hessRogueNousStoryInfoScRspOuterClass.java | 498 ++++++ .../proto/LANBPBBAJLMOuterClass.java | 280 ++++ .../proto/LLJFPKKLGAKOuterClass.java | 381 +++++ .../RogueAvatarReviveCostOuterClass.java | 281 ++++ .../RogueSyncContextBoardEventOuterClass.java | 341 ++++ ...ChessRogueNousValueScNotifyOuterClass.java | 283 ++++ .../java/emu/lunarcore/data/GameData.java | 4 + .../data/excel/RogueNousDiceBranchExcel.java | 26 + .../data/excel/RogueNousMainStoryExcel.java | 23 + .../data/excel/RogueNousSubStoryExcel.java | 23 + .../lunarcore/game/battle/BattleService.java | 1 + .../emu/lunarcore/game/player/Player.java | 3 + .../game/rogue/RogueEntityLoader.java | 2 + .../game/rogue/RogueEventManager.java | 87 +- .../lunarcore/game/rogue/RogueInstance.java | 7 +- .../game/rogue/chess/ChessRogueManager.java | 27 + .../recv/HandlerChessRogueQueryCsReq.java | 16 + ...andlerGetChessRogueNousStoryInfoCsReq.java | 15 + .../HandlerSelectRogueDialogueEventCsReq.java | 2 +- .../send/PacketChessRogueQueryScRsp.java | 39 + ...PacketGetChessRogueNousStoryInfoScRsp.java | 29 + 60 files changed, 21255 insertions(+), 15 deletions(-) create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueAvatarInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueAvatarOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueBuffDataOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueBuffInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueCellInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueCellOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueCellUpdateNotifyOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueConfirmRollScRspOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueCurrentInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueItemInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueMiracleDataOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueMiracleInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueMoneyInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceSurfaceInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueNousEditDiceCsReqOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueNousEditDiceScRspOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueNousMainStoryInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueNousQueryInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueNousStoryInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueNousSubStoryInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueNousValueOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueQueryOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueQueryScRspOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueReRollDiceCsReqOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueRollDiceCsReqOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueRollDiceScRspOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueSelectCellCsReqOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueSelectCellScRspOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueStartCsReqOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueStartScRspOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueUpdateActionPointScNotifyOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueUpdateAllowedSelectCellScNotifyOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueUpdateDiceInfoScNotifyOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueUpdateDicePassiveAccumulateValueScNotifyOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueUpdateMoneyInfoScNotifyOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ChessRogueVirtualItemInfoOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/GetChessRogueNousStoryInfoScRspOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/LANBPBBAJLMOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/LLJFPKKLGAKOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/RogueAvatarReviveCostOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/RogueSyncContextBoardEventOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/SyncChessRogueNousValueScNotifyOuterClass.java create mode 100644 src/main/java/emu/lunarcore/data/excel/RogueNousDiceBranchExcel.java create mode 100644 src/main/java/emu/lunarcore/data/excel/RogueNousMainStoryExcel.java create mode 100644 src/main/java/emu/lunarcore/data/excel/RogueNousSubStoryExcel.java create mode 100644 src/main/java/emu/lunarcore/game/rogue/chess/ChessRogueManager.java create mode 100644 src/main/java/emu/lunarcore/server/packet/recv/HandlerChessRogueQueryCsReq.java create mode 100644 src/main/java/emu/lunarcore/server/packet/recv/HandlerGetChessRogueNousStoryInfoCsReq.java create mode 100644 src/main/java/emu/lunarcore/server/packet/send/PacketChessRogueQueryScRsp.java create mode 100644 src/main/java/emu/lunarcore/server/packet/send/PacketGetChessRogueNousStoryInfoScRsp.java diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueAvatarInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueAvatarInfoOuterClass.java new file mode 100644 index 0000000..63f4bb9 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueAvatarInfoOuterClass.java @@ -0,0 +1,400 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedMessage; + +public final class ChessRogueAvatarInfoOuterClass { + /** + * Protobuf type {@code ChessRogueAvatarInfo} + */ + public static final class ChessRogueAvatarInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .RogueAvatarReviveCost revive_cost = 15; + */ + private final RogueAvatarReviveCostOuterClass.RogueAvatarReviveCost reviveCost = RogueAvatarReviveCostOuterClass.RogueAvatarReviveCost.newInstance(); + + /** + * repeated .ChessRogueAvatar chess_rogue_avatar = 3; + */ + private final RepeatedMessage chessRogueAvatar = RepeatedMessage.newEmptyInstance(ChessRogueAvatarOuterClass.ChessRogueAvatar.getFactory()); + + private ChessRogueAvatarInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueAvatarInfo} + */ + public static ChessRogueAvatarInfo newInstance() { + return new ChessRogueAvatarInfo(); + } + + /** + * optional .RogueAvatarReviveCost revive_cost = 15; + * @return whether the reviveCost field is set + */ + public boolean hasReviveCost() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .RogueAvatarReviveCost revive_cost = 15; + * @return this + */ + public ChessRogueAvatarInfo clearReviveCost() { + bitField0_ &= ~0x00000001; + reviveCost.clear(); + return this; + } + + /** + * optional .RogueAvatarReviveCost revive_cost = 15; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableReviveCost()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RogueAvatarReviveCostOuterClass.RogueAvatarReviveCost getReviveCost() { + return reviveCost; + } + + /** + * optional .RogueAvatarReviveCost revive_cost = 15; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RogueAvatarReviveCostOuterClass.RogueAvatarReviveCost getMutableReviveCost() { + bitField0_ |= 0x00000001; + return reviveCost; + } + + /** + * optional .RogueAvatarReviveCost revive_cost = 15; + * @param value the reviveCost to set + * @return this + */ + public ChessRogueAvatarInfo setReviveCost( + final RogueAvatarReviveCostOuterClass.RogueAvatarReviveCost value) { + bitField0_ |= 0x00000001; + reviveCost.copyFrom(value); + return this; + } + + /** + * repeated .ChessRogueAvatar chess_rogue_avatar = 3; + * @return whether the chessRogueAvatar field is set + */ + public boolean hasChessRogueAvatar() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated .ChessRogueAvatar chess_rogue_avatar = 3; + * @return this + */ + public ChessRogueAvatarInfo clearChessRogueAvatar() { + bitField0_ &= ~0x00000002; + chessRogueAvatar.clear(); + return this; + } + + /** + * repeated .ChessRogueAvatar chess_rogue_avatar = 3; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableChessRogueAvatar()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getChessRogueAvatar() { + return chessRogueAvatar; + } + + /** + * repeated .ChessRogueAvatar chess_rogue_avatar = 3; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableChessRogueAvatar( + ) { + bitField0_ |= 0x00000002; + return chessRogueAvatar; + } + + /** + * repeated .ChessRogueAvatar chess_rogue_avatar = 3; + * @param value the chessRogueAvatar to add + * @return this + */ + public ChessRogueAvatarInfo addChessRogueAvatar( + final ChessRogueAvatarOuterClass.ChessRogueAvatar value) { + bitField0_ |= 0x00000002; + chessRogueAvatar.add(value); + return this; + } + + /** + * repeated .ChessRogueAvatar chess_rogue_avatar = 3; + * @param values the chessRogueAvatar to add + * @return this + */ + public ChessRogueAvatarInfo addAllChessRogueAvatar( + final ChessRogueAvatarOuterClass.ChessRogueAvatar... values) { + bitField0_ |= 0x00000002; + chessRogueAvatar.addAll(values); + return this; + } + + @Override + public ChessRogueAvatarInfo copyFrom(final ChessRogueAvatarInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + reviveCost.copyFrom(other.reviveCost); + chessRogueAvatar.copyFrom(other.chessRogueAvatar); + } + return this; + } + + @Override + public ChessRogueAvatarInfo mergeFrom(final ChessRogueAvatarInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasReviveCost()) { + getMutableReviveCost().mergeFrom(other.reviveCost); + } + if (other.hasChessRogueAvatar()) { + getMutableChessRogueAvatar().addAll(other.chessRogueAvatar); + } + return this; + } + + @Override + public ChessRogueAvatarInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + reviveCost.clear(); + chessRogueAvatar.clear(); + return this; + } + + @Override + public ChessRogueAvatarInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + reviveCost.clearQuick(); + chessRogueAvatar.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueAvatarInfo)) { + return false; + } + ChessRogueAvatarInfo other = (ChessRogueAvatarInfo) o; + return bitField0_ == other.bitField0_ + && (!hasReviveCost() || reviveCost.equals(other.reviveCost)) + && (!hasChessRogueAvatar() || chessRogueAvatar.equals(other.chessRogueAvatar)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 122); + output.writeMessageNoTag(reviveCost); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < chessRogueAvatar.length(); i++) { + output.writeRawByte((byte) 26); + output.writeMessageNoTag(chessRogueAvatar.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(reviveCost); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * chessRogueAvatar.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(chessRogueAvatar); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueAvatarInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 122: { + // reviveCost + input.readMessage(reviveCost); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 26) { + break; + } + } + case 26: { + // chessRogueAvatar + tag = input.readRepeatedMessage(chessRogueAvatar, tag); + bitField0_ |= 0x00000002; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.reviveCost, reviveCost); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedMessage(FieldNames.chessRogueAvatar, chessRogueAvatar); + } + output.endObject(); + } + + @Override + public ChessRogueAvatarInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1426560318: + case -1248199561: { + if (input.isAtField(FieldNames.reviveCost)) { + if (!input.trySkipNullValue()) { + input.readMessage(reviveCost); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2052177741: + case 1901902397: { + if (input.isAtField(FieldNames.chessRogueAvatar)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(chessRogueAvatar); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueAvatarInfo clone() { + return new ChessRogueAvatarInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueAvatarInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueAvatarInfo(), data).checkInitialized(); + } + + public static ChessRogueAvatarInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueAvatarInfo(), input).checkInitialized(); + } + + public static ChessRogueAvatarInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueAvatarInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueAvatarInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueAvatarInfoFactory.INSTANCE; + } + + private enum ChessRogueAvatarInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueAvatarInfo create() { + return ChessRogueAvatarInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName reviveCost = FieldName.forField("reviveCost", "revive_cost"); + + static final FieldName chessRogueAvatar = FieldName.forField("chessRogueAvatar", "chess_rogue_avatar"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueAvatarOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueAvatarOuterClass.java new file mode 100644 index 0000000..bf7f569 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueAvatarOuterClass.java @@ -0,0 +1,340 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueAvatarOuterClass { + /** + * Protobuf type {@code ChessRogueAvatar} + */ + public static final class ChessRogueAvatar extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 PGPLJENDONA = 9; + */ + private int pGPLJENDONA; + + /** + * optional uint32 avatar_id = 14; + */ + private int avatarId; + + private ChessRogueAvatar() { + } + + /** + * @return a new empty instance of {@code ChessRogueAvatar} + */ + public static ChessRogueAvatar newInstance() { + return new ChessRogueAvatar(); + } + + /** + * optional uint32 PGPLJENDONA = 9; + * @return whether the pGPLJENDONA field is set + */ + public boolean hasPGPLJENDONA() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 PGPLJENDONA = 9; + * @return this + */ + public ChessRogueAvatar clearPGPLJENDONA() { + bitField0_ &= ~0x00000001; + pGPLJENDONA = 0; + return this; + } + + /** + * optional uint32 PGPLJENDONA = 9; + * @return the pGPLJENDONA + */ + public int getPGPLJENDONA() { + return pGPLJENDONA; + } + + /** + * optional uint32 PGPLJENDONA = 9; + * @param value the pGPLJENDONA to set + * @return this + */ + public ChessRogueAvatar setPGPLJENDONA(final int value) { + bitField0_ |= 0x00000001; + pGPLJENDONA = value; + return this; + } + + /** + * optional uint32 avatar_id = 14; + * @return whether the avatarId field is set + */ + public boolean hasAvatarId() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 avatar_id = 14; + * @return this + */ + public ChessRogueAvatar clearAvatarId() { + bitField0_ &= ~0x00000002; + avatarId = 0; + return this; + } + + /** + * optional uint32 avatar_id = 14; + * @return the avatarId + */ + public int getAvatarId() { + return avatarId; + } + + /** + * optional uint32 avatar_id = 14; + * @param value the avatarId to set + * @return this + */ + public ChessRogueAvatar setAvatarId(final int value) { + bitField0_ |= 0x00000002; + avatarId = value; + return this; + } + + @Override + public ChessRogueAvatar copyFrom(final ChessRogueAvatar other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + pGPLJENDONA = other.pGPLJENDONA; + avatarId = other.avatarId; + } + return this; + } + + @Override + public ChessRogueAvatar mergeFrom(final ChessRogueAvatar other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasPGPLJENDONA()) { + setPGPLJENDONA(other.pGPLJENDONA); + } + if (other.hasAvatarId()) { + setAvatarId(other.avatarId); + } + return this; + } + + @Override + public ChessRogueAvatar clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + pGPLJENDONA = 0; + avatarId = 0; + return this; + } + + @Override + public ChessRogueAvatar clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueAvatar)) { + return false; + } + ChessRogueAvatar other = (ChessRogueAvatar) o; + return bitField0_ == other.bitField0_ + && (!hasPGPLJENDONA() || pGPLJENDONA == other.pGPLJENDONA) + && (!hasAvatarId() || avatarId == other.avatarId); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 72); + output.writeUInt32NoTag(pGPLJENDONA); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 112); + output.writeUInt32NoTag(avatarId); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(pGPLJENDONA); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(avatarId); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueAvatar mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 72: { + // pGPLJENDONA + pGPLJENDONA = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 112) { + break; + } + } + case 112: { + // avatarId + avatarId = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.pGPLJENDONA, pGPLJENDONA); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.avatarId, avatarId); + } + output.endObject(); + } + + @Override + public ChessRogueAvatar mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 952698590: { + if (input.isAtField(FieldNames.pGPLJENDONA)) { + if (!input.trySkipNullValue()) { + pGPLJENDONA = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1787287636: + case -428636735: { + if (input.isAtField(FieldNames.avatarId)) { + if (!input.trySkipNullValue()) { + avatarId = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueAvatar clone() { + return new ChessRogueAvatar().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueAvatar parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueAvatar(), data).checkInitialized(); + } + + public static ChessRogueAvatar parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueAvatar(), input).checkInitialized(); + } + + public static ChessRogueAvatar parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueAvatar(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueAvatar messages + */ + public static MessageFactory getFactory() { + return ChessRogueAvatarFactory.INSTANCE; + } + + private enum ChessRogueAvatarFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueAvatar create() { + return ChessRogueAvatar.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName pGPLJENDONA = FieldName.forField("PGPLJENDONA"); + + static final FieldName avatarId = FieldName.forField("avatarId", "avatar_id"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueBuffDataOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueBuffDataOuterClass.java new file mode 100644 index 0000000..6bc62be --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueBuffDataOuterClass.java @@ -0,0 +1,295 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedMessage; + +public final class ChessRogueBuffDataOuterClass { + /** + * Protobuf type {@code ChessRogueBuffData} + */ + public static final class ChessRogueBuffData extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * repeated .RogueBuffData buff_list = 13; + */ + private final RepeatedMessage buffList = RepeatedMessage.newEmptyInstance(RogueBuffDataOuterClass.RogueBuffData.getFactory()); + + private ChessRogueBuffData() { + } + + /** + * @return a new empty instance of {@code ChessRogueBuffData} + */ + public static ChessRogueBuffData newInstance() { + return new ChessRogueBuffData(); + } + + /** + * repeated .RogueBuffData buff_list = 13; + * @return whether the buffList field is set + */ + public boolean hasBuffList() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * repeated .RogueBuffData buff_list = 13; + * @return this + */ + public ChessRogueBuffData clearBuffList() { + bitField0_ &= ~0x00000001; + buffList.clear(); + return this; + } + + /** + * repeated .RogueBuffData buff_list = 13; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableBuffList()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getBuffList() { + return buffList; + } + + /** + * repeated .RogueBuffData buff_list = 13; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableBuffList() { + bitField0_ |= 0x00000001; + return buffList; + } + + /** + * repeated .RogueBuffData buff_list = 13; + * @param value the buffList to add + * @return this + */ + public ChessRogueBuffData addBuffList(final RogueBuffDataOuterClass.RogueBuffData value) { + bitField0_ |= 0x00000001; + buffList.add(value); + return this; + } + + /** + * repeated .RogueBuffData buff_list = 13; + * @param values the buffList to add + * @return this + */ + public ChessRogueBuffData addAllBuffList( + final RogueBuffDataOuterClass.RogueBuffData... values) { + bitField0_ |= 0x00000001; + buffList.addAll(values); + return this; + } + + @Override + public ChessRogueBuffData copyFrom(final ChessRogueBuffData other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + buffList.copyFrom(other.buffList); + } + return this; + } + + @Override + public ChessRogueBuffData mergeFrom(final ChessRogueBuffData other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasBuffList()) { + getMutableBuffList().addAll(other.buffList); + } + return this; + } + + @Override + public ChessRogueBuffData clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + buffList.clear(); + return this; + } + + @Override + public ChessRogueBuffData clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + buffList.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueBuffData)) { + return false; + } + ChessRogueBuffData other = (ChessRogueBuffData) o; + return bitField0_ == other.bitField0_ + && (!hasBuffList() || buffList.equals(other.buffList)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + for (int i = 0; i < buffList.length(); i++) { + output.writeRawByte((byte) 106); + output.writeMessageNoTag(buffList.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += (1 * buffList.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(buffList); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueBuffData mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 106: { + // buffList + tag = input.readRepeatedMessage(buffList, tag); + bitField0_ |= 0x00000001; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeRepeatedMessage(FieldNames.buffList, buffList); + } + output.endObject(); + } + + @Override + public ChessRogueBuffData mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1522789487: + case 55792906: { + if (input.isAtField(FieldNames.buffList)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(buffList); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueBuffData clone() { + return new ChessRogueBuffData().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueBuffData parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueBuffData(), data).checkInitialized(); + } + + public static ChessRogueBuffData parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueBuffData(), input).checkInitialized(); + } + + public static ChessRogueBuffData parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueBuffData(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueBuffData messages + */ + public static MessageFactory getFactory() { + return ChessRogueBuffDataFactory.INSTANCE; + } + + private enum ChessRogueBuffDataFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueBuffData create() { + return ChessRogueBuffData.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName buffList = FieldName.forField("buffList", "buff_list"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueBuffInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueBuffInfoOuterClass.java new file mode 100644 index 0000000..05f78ea --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueBuffInfoOuterClass.java @@ -0,0 +1,282 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueBuffInfoOuterClass { + /** + * Protobuf type {@code ChessRogueBuffInfo} + */ + public static final class ChessRogueBuffInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .ChessRogueBuffData buff_data = 1; + */ + private final ChessRogueBuffDataOuterClass.ChessRogueBuffData buffData = ChessRogueBuffDataOuterClass.ChessRogueBuffData.newInstance(); + + private ChessRogueBuffInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueBuffInfo} + */ + public static ChessRogueBuffInfo newInstance() { + return new ChessRogueBuffInfo(); + } + + /** + * optional .ChessRogueBuffData buff_data = 1; + * @return whether the buffData field is set + */ + public boolean hasBuffData() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .ChessRogueBuffData buff_data = 1; + * @return this + */ + public ChessRogueBuffInfo clearBuffData() { + bitField0_ &= ~0x00000001; + buffData.clear(); + return this; + } + + /** + * optional .ChessRogueBuffData buff_data = 1; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableBuffData()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueBuffDataOuterClass.ChessRogueBuffData getBuffData() { + return buffData; + } + + /** + * optional .ChessRogueBuffData buff_data = 1; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueBuffDataOuterClass.ChessRogueBuffData getMutableBuffData() { + bitField0_ |= 0x00000001; + return buffData; + } + + /** + * optional .ChessRogueBuffData buff_data = 1; + * @param value the buffData to set + * @return this + */ + public ChessRogueBuffInfo setBuffData( + final ChessRogueBuffDataOuterClass.ChessRogueBuffData value) { + bitField0_ |= 0x00000001; + buffData.copyFrom(value); + return this; + } + + @Override + public ChessRogueBuffInfo copyFrom(final ChessRogueBuffInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + buffData.copyFrom(other.buffData); + } + return this; + } + + @Override + public ChessRogueBuffInfo mergeFrom(final ChessRogueBuffInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasBuffData()) { + getMutableBuffData().mergeFrom(other.buffData); + } + return this; + } + + @Override + public ChessRogueBuffInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + buffData.clear(); + return this; + } + + @Override + public ChessRogueBuffInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + buffData.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueBuffInfo)) { + return false; + } + ChessRogueBuffInfo other = (ChessRogueBuffInfo) o; + return bitField0_ == other.bitField0_ + && (!hasBuffData() || buffData.equals(other.buffData)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 10); + output.writeMessageNoTag(buffData); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(buffData); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueBuffInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 10: { + // buffData + input.readMessage(buffData); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.buffData, buffData); + } + output.endObject(); + } + + @Override + public ChessRogueBuffInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1523035491: + case 55546902: { + if (input.isAtField(FieldNames.buffData)) { + if (!input.trySkipNullValue()) { + input.readMessage(buffData); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueBuffInfo clone() { + return new ChessRogueBuffInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueBuffInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueBuffInfo(), data).checkInitialized(); + } + + public static ChessRogueBuffInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueBuffInfo(), input).checkInitialized(); + } + + public static ChessRogueBuffInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueBuffInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueBuffInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueBuffInfoFactory.INSTANCE; + } + + private enum ChessRogueBuffInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueBuffInfo create() { + return ChessRogueBuffInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName buffData = FieldName.forField("buffData", "buff_data"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueCellInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueCellInfoOuterClass.java new file mode 100644 index 0000000..7086562 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueCellInfoOuterClass.java @@ -0,0 +1,393 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedMessage; + +public final class ChessRogueCellInfoOuterClass { + /** + * Protobuf type {@code ChessRogueCellInfo} + */ + public static final class ChessRogueCellInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * 
+     *  61
+     *
+ * + * optional uint32 BIEJGDGAOBL = 1; + */ + private int bIEJGDGAOBL; + + /** + * repeated .ChessRogueCell query = 7; + */ + private final RepeatedMessage query = RepeatedMessage.newEmptyInstance(ChessRogueCellOuterClass.ChessRogueCell.getFactory()); + + private ChessRogueCellInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueCellInfo} + */ + public static ChessRogueCellInfo newInstance() { + return new ChessRogueCellInfo(); + } + + /** + * 
+     *  61
+     *
+ * + * optional uint32 BIEJGDGAOBL = 1; + * @return whether the bIEJGDGAOBL field is set + */ + public boolean hasBIEJGDGAOBL() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * 
+     *  61
+     *
+ * + * optional uint32 BIEJGDGAOBL = 1; + * @return this + */ + public ChessRogueCellInfo clearBIEJGDGAOBL() { + bitField0_ &= ~0x00000001; + bIEJGDGAOBL = 0; + return this; + } + + /** + * 
+     *  61
+     *
+ * + * optional uint32 BIEJGDGAOBL = 1; + * @return the bIEJGDGAOBL + */ + public int getBIEJGDGAOBL() { + return bIEJGDGAOBL; + } + + /** + * 
+     *  61
+     *
+ * + * optional uint32 BIEJGDGAOBL = 1; + * @param value the bIEJGDGAOBL to set + * @return this + */ + public ChessRogueCellInfo setBIEJGDGAOBL(final int value) { + bitField0_ |= 0x00000001; + bIEJGDGAOBL = value; + return this; + } + + /** + * repeated .ChessRogueCell query = 7; + * @return whether the query field is set + */ + public boolean hasQuery() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated .ChessRogueCell query = 7; + * @return this + */ + public ChessRogueCellInfo clearQuery() { + bitField0_ &= ~0x00000002; + query.clear(); + return this; + } + + /** + * repeated .ChessRogueCell query = 7; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableQuery()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getQuery() { + return query; + } + + /** + * repeated .ChessRogueCell query = 7; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableQuery() { + bitField0_ |= 0x00000002; + return query; + } + + /** + * repeated .ChessRogueCell query = 7; + * @param value the query to add + * @return this + */ + public ChessRogueCellInfo addQuery(final ChessRogueCellOuterClass.ChessRogueCell value) { + bitField0_ |= 0x00000002; + query.add(value); + return this; + } + + /** + * repeated .ChessRogueCell query = 7; + * @param values the query to add + * @return this + */ + public ChessRogueCellInfo addAllQuery(final ChessRogueCellOuterClass.ChessRogueCell... values) { + bitField0_ |= 0x00000002; + query.addAll(values); + return this; + } + + @Override + public ChessRogueCellInfo copyFrom(final ChessRogueCellInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + bIEJGDGAOBL = other.bIEJGDGAOBL; + query.copyFrom(other.query); + } + return this; + } + + @Override + public ChessRogueCellInfo mergeFrom(final ChessRogueCellInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasBIEJGDGAOBL()) { + setBIEJGDGAOBL(other.bIEJGDGAOBL); + } + if (other.hasQuery()) { + getMutableQuery().addAll(other.query); + } + return this; + } + + @Override + public ChessRogueCellInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + bIEJGDGAOBL = 0; + query.clear(); + return this; + } + + @Override + public ChessRogueCellInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + query.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueCellInfo)) { + return false; + } + ChessRogueCellInfo other = (ChessRogueCellInfo) o; + return bitField0_ == other.bitField0_ + && (!hasBIEJGDGAOBL() || bIEJGDGAOBL == other.bIEJGDGAOBL) + && (!hasQuery() || query.equals(other.query)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(bIEJGDGAOBL); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < query.length(); i++) { + output.writeRawByte((byte) 58); + output.writeMessageNoTag(query.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(bIEJGDGAOBL); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * query.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(query); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueCellInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // bIEJGDGAOBL + bIEJGDGAOBL = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 58) { + break; + } + } + case 58: { + // query + tag = input.readRepeatedMessage(query, tag); + bitField0_ |= 0x00000002; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.bIEJGDGAOBL, bIEJGDGAOBL); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedMessage(FieldNames.query, query); + } + output.endObject(); + } + + @Override + public ChessRogueCellInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 760968790: { + if (input.isAtField(FieldNames.bIEJGDGAOBL)) { + if (!input.trySkipNullValue()) { + bIEJGDGAOBL = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 107944136: { + if (input.isAtField(FieldNames.query)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(query); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueCellInfo clone() { + return new ChessRogueCellInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueCellInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueCellInfo(), data).checkInitialized(); + } + + public static ChessRogueCellInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueCellInfo(), input).checkInitialized(); + } + + public static ChessRogueCellInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueCellInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueCellInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueCellInfoFactory.INSTANCE; + } + + private enum ChessRogueCellInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueCellInfo create() { + return ChessRogueCellInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName bIEJGDGAOBL = FieldName.forField("BIEJGDGAOBL"); + + static final FieldName query = FieldName.forField("query"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueCellOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueCellOuterClass.java new file mode 100644 index 0000000..25dd37e --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueCellOuterClass.java @@ -0,0 +1,1183 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedInt; + +public final class ChessRogueCellOuterClass { + /** + * Protobuf type {@code ChessRogueCell} + */ + public static final class ChessRogueCell extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 entrance_id = 1; + */ + private int entranceId; + + /** + * optional uint32 NNMNHHPJBDB = 2; + */ + private int nNMNHHPJBDB; + + /** + * optional uint32 NLBGDNLIONI = 3; + */ + private int nLBGDNLIONI; + + /** + * optional uint32 FOKKJJADPEA = 5; + */ + private int fOKKJJADPEA; + + /** + * 
+     *  5, 3
+     *
+ * + * optional uint32 PNKFAINKKCE = 7; + */ + private int pNKFAINKKCE; + + /** + * optional uint32 rogue_version_id = 9; + */ + private int rogueVersionId; + + /** + * 
+     *  7, 4
+     *
+ * + * optional uint32 JLOBGDKNJLN = 10; + */ + private int jLOBGDKNJLN; + + /** + * optional uint32 AAODCDKAINI = 11; + */ + private int aAODCDKAINI; + + /** + * 
+     * AKNBDONHPPM chess_rogue_info = 14;
+     *
+ * + * optional bool PMBLMGDFGAN = 6; + */ + private boolean pMBLMGDFGAN; + + /** + * 
+     *  true
+     *
+ * + * optional bool is_unlocked = 8; + */ + private boolean isUnlocked; + + /** + * repeated uint32 IIJOCONHKND = 4; + */ + private final RepeatedInt iIJOCONHKND = RepeatedInt.newEmptyInstance(); + + private ChessRogueCell() { + } + + /** + * @return a new empty instance of {@code ChessRogueCell} + */ + public static ChessRogueCell newInstance() { + return new ChessRogueCell(); + } + + /** + * optional uint32 entrance_id = 1; + * @return whether the entranceId field is set + */ + public boolean hasEntranceId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 entrance_id = 1; + * @return this + */ + public ChessRogueCell clearEntranceId() { + bitField0_ &= ~0x00000001; + entranceId = 0; + return this; + } + + /** + * optional uint32 entrance_id = 1; + * @return the entranceId + */ + public int getEntranceId() { + return entranceId; + } + + /** + * optional uint32 entrance_id = 1; + * @param value the entranceId to set + * @return this + */ + public ChessRogueCell setEntranceId(final int value) { + bitField0_ |= 0x00000001; + entranceId = value; + return this; + } + + /** + * optional uint32 NNMNHHPJBDB = 2; + * @return whether the nNMNHHPJBDB field is set + */ + public boolean hasNNMNHHPJBDB() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 NNMNHHPJBDB = 2; + * @return this + */ + public ChessRogueCell clearNNMNHHPJBDB() { + bitField0_ &= ~0x00000002; + nNMNHHPJBDB = 0; + return this; + } + + /** + * optional uint32 NNMNHHPJBDB = 2; + * @return the nNMNHHPJBDB + */ + public int getNNMNHHPJBDB() { + return nNMNHHPJBDB; + } + + /** + * optional uint32 NNMNHHPJBDB = 2; + * @param value the nNMNHHPJBDB to set + * @return this + */ + public ChessRogueCell setNNMNHHPJBDB(final int value) { + bitField0_ |= 0x00000002; + nNMNHHPJBDB = value; + return this; + } + + /** + * optional uint32 NLBGDNLIONI = 3; + * @return whether the nLBGDNLIONI field is set + */ + public boolean hasNLBGDNLIONI() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 NLBGDNLIONI = 3; + * @return this + */ + public ChessRogueCell clearNLBGDNLIONI() { + bitField0_ &= ~0x00000004; + nLBGDNLIONI = 0; + return this; + } + + /** + * optional uint32 NLBGDNLIONI = 3; + * @return the nLBGDNLIONI + */ + public int getNLBGDNLIONI() { + return nLBGDNLIONI; + } + + /** + * optional uint32 NLBGDNLIONI = 3; + * @param value the nLBGDNLIONI to set + * @return this + */ + public ChessRogueCell setNLBGDNLIONI(final int value) { + bitField0_ |= 0x00000004; + nLBGDNLIONI = value; + return this; + } + + /** + * optional uint32 FOKKJJADPEA = 5; + * @return whether the fOKKJJADPEA field is set + */ + public boolean hasFOKKJJADPEA() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional uint32 FOKKJJADPEA = 5; + * @return this + */ + public ChessRogueCell clearFOKKJJADPEA() { + bitField0_ &= ~0x00000008; + fOKKJJADPEA = 0; + return this; + } + + /** + * optional uint32 FOKKJJADPEA = 5; + * @return the fOKKJJADPEA + */ + public int getFOKKJJADPEA() { + return fOKKJJADPEA; + } + + /** + * optional uint32 FOKKJJADPEA = 5; + * @param value the fOKKJJADPEA to set + * @return this + */ + public ChessRogueCell setFOKKJJADPEA(final int value) { + bitField0_ |= 0x00000008; + fOKKJJADPEA = value; + return this; + } + + /** + * 
+     *  5, 3
+     *
+ * + * optional uint32 PNKFAINKKCE = 7; + * @return whether the pNKFAINKKCE field is set + */ + public boolean hasPNKFAINKKCE() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * 
+     *  5, 3
+     *
+ * + * optional uint32 PNKFAINKKCE = 7; + * @return this + */ + public ChessRogueCell clearPNKFAINKKCE() { + bitField0_ &= ~0x00000010; + pNKFAINKKCE = 0; + return this; + } + + /** + * 
+     *  5, 3
+     *
+ * + * optional uint32 PNKFAINKKCE = 7; + * @return the pNKFAINKKCE + */ + public int getPNKFAINKKCE() { + return pNKFAINKKCE; + } + + /** + * 
+     *  5, 3
+     *
+ * + * optional uint32 PNKFAINKKCE = 7; + * @param value the pNKFAINKKCE to set + * @return this + */ + public ChessRogueCell setPNKFAINKKCE(final int value) { + bitField0_ |= 0x00000010; + pNKFAINKKCE = value; + return this; + } + + /** + * optional uint32 rogue_version_id = 9; + * @return whether the rogueVersionId field is set + */ + public boolean hasRogueVersionId() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * optional uint32 rogue_version_id = 9; + * @return this + */ + public ChessRogueCell clearRogueVersionId() { + bitField0_ &= ~0x00000020; + rogueVersionId = 0; + return this; + } + + /** + * optional uint32 rogue_version_id = 9; + * @return the rogueVersionId + */ + public int getRogueVersionId() { + return rogueVersionId; + } + + /** + * optional uint32 rogue_version_id = 9; + * @param value the rogueVersionId to set + * @return this + */ + public ChessRogueCell setRogueVersionId(final int value) { + bitField0_ |= 0x00000020; + rogueVersionId = value; + return this; + } + + /** + * 
+     *  7, 4
+     *
+ * + * optional uint32 JLOBGDKNJLN = 10; + * @return whether the jLOBGDKNJLN field is set + */ + public boolean hasJLOBGDKNJLN() { + return (bitField0_ & 0x00000040) != 0; + } + + /** + * 
+     *  7, 4
+     *
+ * + * optional uint32 JLOBGDKNJLN = 10; + * @return this + */ + public ChessRogueCell clearJLOBGDKNJLN() { + bitField0_ &= ~0x00000040; + jLOBGDKNJLN = 0; + return this; + } + + /** + * 
+     *  7, 4
+     *
+ * + * optional uint32 JLOBGDKNJLN = 10; + * @return the jLOBGDKNJLN + */ + public int getJLOBGDKNJLN() { + return jLOBGDKNJLN; + } + + /** + * 
+     *  7, 4
+     *
+ * + * optional uint32 JLOBGDKNJLN = 10; + * @param value the jLOBGDKNJLN to set + * @return this + */ + public ChessRogueCell setJLOBGDKNJLN(final int value) { + bitField0_ |= 0x00000040; + jLOBGDKNJLN = value; + return this; + } + + /** + * optional uint32 AAODCDKAINI = 11; + * @return whether the aAODCDKAINI field is set + */ + public boolean hasAAODCDKAINI() { + return (bitField0_ & 0x00000080) != 0; + } + + /** + * optional uint32 AAODCDKAINI = 11; + * @return this + */ + public ChessRogueCell clearAAODCDKAINI() { + bitField0_ &= ~0x00000080; + aAODCDKAINI = 0; + return this; + } + + /** + * optional uint32 AAODCDKAINI = 11; + * @return the aAODCDKAINI + */ + public int getAAODCDKAINI() { + return aAODCDKAINI; + } + + /** + * optional uint32 AAODCDKAINI = 11; + * @param value the aAODCDKAINI to set + * @return this + */ + public ChessRogueCell setAAODCDKAINI(final int value) { + bitField0_ |= 0x00000080; + aAODCDKAINI = value; + return this; + } + + /** + * 
+     * AKNBDONHPPM chess_rogue_info = 14;
+     *
+ * + * optional bool PMBLMGDFGAN = 6; + * @return whether the pMBLMGDFGAN field is set + */ + public boolean hasPMBLMGDFGAN() { + return (bitField0_ & 0x00000100) != 0; + } + + /** + * 
+     * AKNBDONHPPM chess_rogue_info = 14;
+     *
+ * + * optional bool PMBLMGDFGAN = 6; + * @return this + */ + public ChessRogueCell clearPMBLMGDFGAN() { + bitField0_ &= ~0x00000100; + pMBLMGDFGAN = false; + return this; + } + + /** + * 
+     * AKNBDONHPPM chess_rogue_info = 14;
+     *
+ * + * optional bool PMBLMGDFGAN = 6; + * @return the pMBLMGDFGAN + */ + public boolean getPMBLMGDFGAN() { + return pMBLMGDFGAN; + } + + /** + * 
+     * AKNBDONHPPM chess_rogue_info = 14;
+     *
+ * + * optional bool PMBLMGDFGAN = 6; + * @param value the pMBLMGDFGAN to set + * @return this + */ + public ChessRogueCell setPMBLMGDFGAN(final boolean value) { + bitField0_ |= 0x00000100; + pMBLMGDFGAN = value; + return this; + } + + /** + * 
+     *  true
+     *
+ * + * optional bool is_unlocked = 8; + * @return whether the isUnlocked field is set + */ + public boolean hasIsUnlocked() { + return (bitField0_ & 0x00000200) != 0; + } + + /** + * 
+     *  true
+     *
+ * + * optional bool is_unlocked = 8; + * @return this + */ + public ChessRogueCell clearIsUnlocked() { + bitField0_ &= ~0x00000200; + isUnlocked = false; + return this; + } + + /** + * 
+     *  true
+     *
+ * + * optional bool is_unlocked = 8; + * @return the isUnlocked + */ + public boolean getIsUnlocked() { + return isUnlocked; + } + + /** + * 
+     *  true
+     *
+ * + * optional bool is_unlocked = 8; + * @param value the isUnlocked to set + * @return this + */ + public ChessRogueCell setIsUnlocked(final boolean value) { + bitField0_ |= 0x00000200; + isUnlocked = value; + return this; + } + + /** + * repeated uint32 IIJOCONHKND = 4; + * @return whether the iIJOCONHKND field is set + */ + public boolean hasIIJOCONHKND() { + return (bitField0_ & 0x00000400) != 0; + } + + /** + * repeated uint32 IIJOCONHKND = 4; + * @return this + */ + public ChessRogueCell clearIIJOCONHKND() { + bitField0_ &= ~0x00000400; + iIJOCONHKND.clear(); + return this; + } + + /** + * repeated uint32 IIJOCONHKND = 4; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableIIJOCONHKND()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getIIJOCONHKND() { + return iIJOCONHKND; + } + + /** + * repeated uint32 IIJOCONHKND = 4; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableIIJOCONHKND() { + bitField0_ |= 0x00000400; + return iIJOCONHKND; + } + + /** + * repeated uint32 IIJOCONHKND = 4; + * @param value the iIJOCONHKND to add + * @return this + */ + public ChessRogueCell addIIJOCONHKND(final int value) { + bitField0_ |= 0x00000400; + iIJOCONHKND.add(value); + return this; + } + + /** + * repeated uint32 IIJOCONHKND = 4; + * @param values the iIJOCONHKND to add + * @return this + */ + public ChessRogueCell addAllIIJOCONHKND(final int... values) { + bitField0_ |= 0x00000400; + iIJOCONHKND.addAll(values); + return this; + } + + @Override + public ChessRogueCell copyFrom(final ChessRogueCell other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + entranceId = other.entranceId; + nNMNHHPJBDB = other.nNMNHHPJBDB; + nLBGDNLIONI = other.nLBGDNLIONI; + fOKKJJADPEA = other.fOKKJJADPEA; + pNKFAINKKCE = other.pNKFAINKKCE; + rogueVersionId = other.rogueVersionId; + jLOBGDKNJLN = other.jLOBGDKNJLN; + aAODCDKAINI = other.aAODCDKAINI; + pMBLMGDFGAN = other.pMBLMGDFGAN; + isUnlocked = other.isUnlocked; + iIJOCONHKND.copyFrom(other.iIJOCONHKND); + } + return this; + } + + @Override + public ChessRogueCell mergeFrom(final ChessRogueCell other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasEntranceId()) { + setEntranceId(other.entranceId); + } + if (other.hasNNMNHHPJBDB()) { + setNNMNHHPJBDB(other.nNMNHHPJBDB); + } + if (other.hasNLBGDNLIONI()) { + setNLBGDNLIONI(other.nLBGDNLIONI); + } + if (other.hasFOKKJJADPEA()) { + setFOKKJJADPEA(other.fOKKJJADPEA); + } + if (other.hasPNKFAINKKCE()) { + setPNKFAINKKCE(other.pNKFAINKKCE); + } + if (other.hasRogueVersionId()) { + setRogueVersionId(other.rogueVersionId); + } + if (other.hasJLOBGDKNJLN()) { + setJLOBGDKNJLN(other.jLOBGDKNJLN); + } + if (other.hasAAODCDKAINI()) { + setAAODCDKAINI(other.aAODCDKAINI); + } + if (other.hasPMBLMGDFGAN()) { + setPMBLMGDFGAN(other.pMBLMGDFGAN); + } + if (other.hasIsUnlocked()) { + setIsUnlocked(other.isUnlocked); + } + if (other.hasIIJOCONHKND()) { + getMutableIIJOCONHKND().addAll(other.iIJOCONHKND); + } + return this; + } + + @Override + public ChessRogueCell clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + entranceId = 0; + nNMNHHPJBDB = 0; + nLBGDNLIONI = 0; + fOKKJJADPEA = 0; + pNKFAINKKCE = 0; + rogueVersionId = 0; + jLOBGDKNJLN = 0; + aAODCDKAINI = 0; + pMBLMGDFGAN = false; + isUnlocked = false; + iIJOCONHKND.clear(); + return this; + } + + @Override + public ChessRogueCell clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + iIJOCONHKND.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueCell)) { + return false; + } + ChessRogueCell other = (ChessRogueCell) o; + return bitField0_ == other.bitField0_ + && (!hasEntranceId() || entranceId == other.entranceId) + && (!hasNNMNHHPJBDB() || nNMNHHPJBDB == other.nNMNHHPJBDB) + && (!hasNLBGDNLIONI() || nLBGDNLIONI == other.nLBGDNLIONI) + && (!hasFOKKJJADPEA() || fOKKJJADPEA == other.fOKKJJADPEA) + && (!hasPNKFAINKKCE() || pNKFAINKKCE == other.pNKFAINKKCE) + && (!hasRogueVersionId() || rogueVersionId == other.rogueVersionId) + && (!hasJLOBGDKNJLN() || jLOBGDKNJLN == other.jLOBGDKNJLN) + && (!hasAAODCDKAINI() || aAODCDKAINI == other.aAODCDKAINI) + && (!hasPMBLMGDFGAN() || pMBLMGDFGAN == other.pMBLMGDFGAN) + && (!hasIsUnlocked() || isUnlocked == other.isUnlocked) + && (!hasIIJOCONHKND() || iIJOCONHKND.equals(other.iIJOCONHKND)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(entranceId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(nNMNHHPJBDB); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(nLBGDNLIONI); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 40); + output.writeUInt32NoTag(fOKKJJADPEA); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawByte((byte) 56); + output.writeUInt32NoTag(pNKFAINKKCE); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRawByte((byte) 72); + output.writeUInt32NoTag(rogueVersionId); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeRawByte((byte) 80); + output.writeUInt32NoTag(jLOBGDKNJLN); + } + if ((bitField0_ & 0x00000080) != 0) { + output.writeRawByte((byte) 88); + output.writeUInt32NoTag(aAODCDKAINI); + } + if ((bitField0_ & 0x00000100) != 0) { + output.writeRawByte((byte) 48); + output.writeBoolNoTag(pMBLMGDFGAN); + } + if ((bitField0_ & 0x00000200) != 0) { + output.writeRawByte((byte) 64); + output.writeBoolNoTag(isUnlocked); + } + if ((bitField0_ & 0x00000400) != 0) { + for (int i = 0; i < iIJOCONHKND.length(); i++) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(iIJOCONHKND.array()[i]); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(entranceId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(nNMNHHPJBDB); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(nLBGDNLIONI); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(fOKKJJADPEA); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(pNKFAINKKCE); + } + if ((bitField0_ & 0x00000020) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(rogueVersionId); + } + if ((bitField0_ & 0x00000040) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(jLOBGDKNJLN); + } + if ((bitField0_ & 0x00000080) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(aAODCDKAINI); + } + if ((bitField0_ & 0x00000100) != 0) { + size += 2; + } + if ((bitField0_ & 0x00000200) != 0) { + size += 2; + } + if ((bitField0_ & 0x00000400) != 0) { + size += (1 * iIJOCONHKND.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(iIJOCONHKND); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueCell mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // entranceId + entranceId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // nNMNHHPJBDB + nNMNHHPJBDB = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 24) { + break; + } + } + case 24: { + // nLBGDNLIONI + nLBGDNLIONI = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 40) { + break; + } + } + case 40: { + // fOKKJJADPEA + fOKKJJADPEA = input.readUInt32(); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 56) { + break; + } + } + case 56: { + // pNKFAINKKCE + pNKFAINKKCE = input.readUInt32(); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 72) { + break; + } + } + case 72: { + // rogueVersionId + rogueVersionId = input.readUInt32(); + bitField0_ |= 0x00000020; + tag = input.readTag(); + if (tag != 80) { + break; + } + } + case 80: { + // jLOBGDKNJLN + jLOBGDKNJLN = input.readUInt32(); + bitField0_ |= 0x00000040; + tag = input.readTag(); + if (tag != 88) { + break; + } + } + case 88: { + // aAODCDKAINI + aAODCDKAINI = input.readUInt32(); + bitField0_ |= 0x00000080; + tag = input.readTag(); + if (tag != 48) { + break; + } + } + case 48: { + // pMBLMGDFGAN + pMBLMGDFGAN = input.readBool(); + bitField0_ |= 0x00000100; + tag = input.readTag(); + if (tag != 64) { + break; + } + } + case 64: { + // isUnlocked + isUnlocked = input.readBool(); + bitField0_ |= 0x00000200; + tag = input.readTag(); + if (tag != 34) { + break; + } + } + case 34: { + // iIJOCONHKND [packed=true] + input.readPackedUInt32(iIJOCONHKND, tag); + bitField0_ |= 0x00000400; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + case 32: { + // iIJOCONHKND [packed=false] + tag = input.readRepeatedUInt32(iIJOCONHKND, tag); + bitField0_ |= 0x00000400; + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.entranceId, entranceId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.nNMNHHPJBDB, nNMNHHPJBDB); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.nLBGDNLIONI, nLBGDNLIONI); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeUInt32(FieldNames.fOKKJJADPEA, fOKKJJADPEA); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeUInt32(FieldNames.pNKFAINKKCE, pNKFAINKKCE); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeUInt32(FieldNames.rogueVersionId, rogueVersionId); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeUInt32(FieldNames.jLOBGDKNJLN, jLOBGDKNJLN); + } + if ((bitField0_ & 0x00000080) != 0) { + output.writeUInt32(FieldNames.aAODCDKAINI, aAODCDKAINI); + } + if ((bitField0_ & 0x00000100) != 0) { + output.writeBool(FieldNames.pMBLMGDFGAN, pMBLMGDFGAN); + } + if ((bitField0_ & 0x00000200) != 0) { + output.writeBool(FieldNames.isUnlocked, isUnlocked); + } + if ((bitField0_ & 0x00000400) != 0) { + output.writeRepeatedUInt32(FieldNames.iIJOCONHKND, iIJOCONHKND); + } + output.endObject(); + } + + @Override + public ChessRogueCell mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1655881329: + case -207264956: { + if (input.isAtField(FieldNames.entranceId)) { + if (!input.trySkipNullValue()) { + entranceId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1801949317: { + if (input.isAtField(FieldNames.nNMNHHPJBDB)) { + if (!input.trySkipNullValue()) { + nNMNHHPJBDB = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2094582400: { + if (input.isAtField(FieldNames.nLBGDNLIONI)) { + if (!input.trySkipNullValue()) { + nLBGDNLIONI = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -994096992: { + if (input.isAtField(FieldNames.fOKKJJADPEA)) { + if (!input.trySkipNullValue()) { + fOKKJJADPEA = input.readUInt32(); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1125363217: { + if (input.isAtField(FieldNames.pNKFAINKKCE)) { + if (!input.trySkipNullValue()) { + pNKFAINKKCE = input.readUInt32(); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1457526951: + case 1832096103: { + if (input.isAtField(FieldNames.rogueVersionId)) { + if (!input.trySkipNullValue()) { + rogueVersionId = input.readUInt32(); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1027507223: { + if (input.isAtField(FieldNames.jLOBGDKNJLN)) { + if (!input.trySkipNullValue()) { + jLOBGDKNJLN = input.readUInt32(); + bitField0_ |= 0x00000040; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2117066584: { + if (input.isAtField(FieldNames.aAODCDKAINI)) { + if (!input.trySkipNullValue()) { + aAODCDKAINI = input.readUInt32(); + bitField0_ |= 0x00000080; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2018761905: { + if (input.isAtField(FieldNames.pMBLMGDFGAN)) { + if (!input.trySkipNullValue()) { + pMBLMGDFGAN = input.readBool(); + bitField0_ |= 0x00000100; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1004219859: + case -945979816: { + if (input.isAtField(FieldNames.isUnlocked)) { + if (!input.trySkipNullValue()) { + isUnlocked = input.readBool(); + bitField0_ |= 0x00000200; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1810533462: { + if (input.isAtField(FieldNames.iIJOCONHKND)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(iIJOCONHKND); + bitField0_ |= 0x00000400; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueCell clone() { + return new ChessRogueCell().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueCell parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueCell(), data).checkInitialized(); + } + + public static ChessRogueCell parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueCell(), input).checkInitialized(); + } + + public static ChessRogueCell parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueCell(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueCell messages + */ + public static MessageFactory getFactory() { + return ChessRogueCellFactory.INSTANCE; + } + + private enum ChessRogueCellFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueCell create() { + return ChessRogueCell.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName entranceId = FieldName.forField("entranceId", "entrance_id"); + + static final FieldName nNMNHHPJBDB = FieldName.forField("NNMNHHPJBDB"); + + static final FieldName nLBGDNLIONI = FieldName.forField("NLBGDNLIONI"); + + static final FieldName fOKKJJADPEA = FieldName.forField("FOKKJJADPEA"); + + static final FieldName pNKFAINKKCE = FieldName.forField("PNKFAINKKCE"); + + static final FieldName rogueVersionId = FieldName.forField("rogueVersionId", "rogue_version_id"); + + static final FieldName jLOBGDKNJLN = FieldName.forField("JLOBGDKNJLN"); + + static final FieldName aAODCDKAINI = FieldName.forField("AAODCDKAINI"); + + static final FieldName pMBLMGDFGAN = FieldName.forField("PMBLMGDFGAN"); + + static final FieldName isUnlocked = FieldName.forField("isUnlocked", "is_unlocked"); + + static final FieldName iIJOCONHKND = FieldName.forField("IIJOCONHKND"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueCellUpdateNotifyOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueCellUpdateNotifyOuterClass.java new file mode 100644 index 0000000..528fb6b --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueCellUpdateNotifyOuterClass.java @@ -0,0 +1,425 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedMessage; + +public final class ChessRogueCellUpdateNotifyOuterClass { + /** + * Protobuf type {@code ChessRogueCellUpdateNotify} + */ + public static final class ChessRogueCellUpdateNotify extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * 
+     * EOKIACEIBBD IFMNJMMMJCM = 8;
+     *
+ * + * optional uint32 cell_room_id = 4; + */ + private int cellRoomId; + + /** + * 
+     * MMKEKJCAHGP reason = 1;
+     *
+ * + * repeated .ChessRogueCell cell_info = 6; + */ + private final RepeatedMessage cellInfo = RepeatedMessage.newEmptyInstance(ChessRogueCellOuterClass.ChessRogueCell.getFactory()); + + private ChessRogueCellUpdateNotify() { + } + + /** + * @return a new empty instance of {@code ChessRogueCellUpdateNotify} + */ + public static ChessRogueCellUpdateNotify newInstance() { + return new ChessRogueCellUpdateNotify(); + } + + /** + * 
+     * EOKIACEIBBD IFMNJMMMJCM = 8;
+     *
+ * + * optional uint32 cell_room_id = 4; + * @return whether the cellRoomId field is set + */ + public boolean hasCellRoomId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * 
+     * EOKIACEIBBD IFMNJMMMJCM = 8;
+     *
+ * + * optional uint32 cell_room_id = 4; + * @return this + */ + public ChessRogueCellUpdateNotify clearCellRoomId() { + bitField0_ &= ~0x00000001; + cellRoomId = 0; + return this; + } + + /** + * 
+     * EOKIACEIBBD IFMNJMMMJCM = 8;
+     *
+ * + * optional uint32 cell_room_id = 4; + * @return the cellRoomId + */ + public int getCellRoomId() { + return cellRoomId; + } + + /** + * 
+     * EOKIACEIBBD IFMNJMMMJCM = 8;
+     *
+ * + * optional uint32 cell_room_id = 4; + * @param value the cellRoomId to set + * @return this + */ + public ChessRogueCellUpdateNotify setCellRoomId(final int value) { + bitField0_ |= 0x00000001; + cellRoomId = value; + return this; + } + + /** + * 
+     * MMKEKJCAHGP reason = 1;
+     *
+ * + * repeated .ChessRogueCell cell_info = 6; + * @return whether the cellInfo field is set + */ + public boolean hasCellInfo() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * 
+     * MMKEKJCAHGP reason = 1;
+     *
+ * + * repeated .ChessRogueCell cell_info = 6; + * @return this + */ + public ChessRogueCellUpdateNotify clearCellInfo() { + bitField0_ &= ~0x00000002; + cellInfo.clear(); + return this; + } + + /** + * 
+     * MMKEKJCAHGP reason = 1;
+     *
+ * + * repeated .ChessRogueCell cell_info = 6; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableCellInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getCellInfo() { + return cellInfo; + } + + /** + * 
+     * MMKEKJCAHGP reason = 1;
+     *
+ * + * repeated .ChessRogueCell cell_info = 6; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableCellInfo() { + bitField0_ |= 0x00000002; + return cellInfo; + } + + /** + * 
+     * MMKEKJCAHGP reason = 1;
+     *
+ * + * repeated .ChessRogueCell cell_info = 6; + * @param value the cellInfo to add + * @return this + */ + public ChessRogueCellUpdateNotify addCellInfo( + final ChessRogueCellOuterClass.ChessRogueCell value) { + bitField0_ |= 0x00000002; + cellInfo.add(value); + return this; + } + + /** + * 
+     * MMKEKJCAHGP reason = 1;
+     *
+ * + * repeated .ChessRogueCell cell_info = 6; + * @param values the cellInfo to add + * @return this + */ + public ChessRogueCellUpdateNotify addAllCellInfo( + final ChessRogueCellOuterClass.ChessRogueCell... values) { + bitField0_ |= 0x00000002; + cellInfo.addAll(values); + return this; + } + + @Override + public ChessRogueCellUpdateNotify copyFrom(final ChessRogueCellUpdateNotify other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + cellRoomId = other.cellRoomId; + cellInfo.copyFrom(other.cellInfo); + } + return this; + } + + @Override + public ChessRogueCellUpdateNotify mergeFrom(final ChessRogueCellUpdateNotify other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasCellRoomId()) { + setCellRoomId(other.cellRoomId); + } + if (other.hasCellInfo()) { + getMutableCellInfo().addAll(other.cellInfo); + } + return this; + } + + @Override + public ChessRogueCellUpdateNotify clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + cellRoomId = 0; + cellInfo.clear(); + return this; + } + + @Override + public ChessRogueCellUpdateNotify clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + cellInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueCellUpdateNotify)) { + return false; + } + ChessRogueCellUpdateNotify other = (ChessRogueCellUpdateNotify) o; + return bitField0_ == other.bitField0_ + && (!hasCellRoomId() || cellRoomId == other.cellRoomId) + && (!hasCellInfo() || cellInfo.equals(other.cellInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(cellRoomId); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < cellInfo.length(); i++) { + output.writeRawByte((byte) 50); + output.writeMessageNoTag(cellInfo.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(cellRoomId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * cellInfo.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(cellInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueCellUpdateNotify mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 32: { + // cellRoomId + cellRoomId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 50) { + break; + } + } + case 50: { + // cellInfo + tag = input.readRepeatedMessage(cellInfo, tag); + bitField0_ |= 0x00000002; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.cellRoomId, cellRoomId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedMessage(FieldNames.cellInfo, cellInfo); + } + output.endObject(); + } + + @Override + public ChessRogueCellUpdateNotify mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1379654824: + case 848768290: { + if (input.isAtField(FieldNames.cellRoomId)) { + if (!input.trySkipNullValue()) { + cellRoomId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -917905104: + case 1629888875: { + if (input.isAtField(FieldNames.cellInfo)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(cellInfo); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueCellUpdateNotify clone() { + return new ChessRogueCellUpdateNotify().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueCellUpdateNotify parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueCellUpdateNotify(), data).checkInitialized(); + } + + public static ChessRogueCellUpdateNotify parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueCellUpdateNotify(), input).checkInitialized(); + } + + public static ChessRogueCellUpdateNotify parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueCellUpdateNotify(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueCellUpdateNotify messages + */ + public static MessageFactory getFactory() { + return ChessRogueCellUpdateNotifyFactory.INSTANCE; + } + + private enum ChessRogueCellUpdateNotifyFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueCellUpdateNotify create() { + return ChessRogueCellUpdateNotify.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName cellRoomId = FieldName.forField("cellRoomId", "cell_room_id"); + + static final FieldName cellInfo = FieldName.forField("cellInfo", "cell_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueConfirmRollScRspOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueConfirmRollScRspOuterClass.java new file mode 100644 index 0000000..429a026 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueConfirmRollScRspOuterClass.java @@ -0,0 +1,362 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueConfirmRollScRspOuterClass { + /** + * Protobuf type {@code ChessRogueConfirmRollScRsp} + */ + public static final class ChessRogueConfirmRollScRsp extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 retcode = 13; + */ + private int retcode; + + /** + * optional .ChessRogueNousDice nous_dice = 5; + */ + private final ChessRogueNousDiceOuterClass.ChessRogueNousDice nousDice = ChessRogueNousDiceOuterClass.ChessRogueNousDice.newInstance(); + + private ChessRogueConfirmRollScRsp() { + } + + /** + * @return a new empty instance of {@code ChessRogueConfirmRollScRsp} + */ + public static ChessRogueConfirmRollScRsp newInstance() { + return new ChessRogueConfirmRollScRsp(); + } + + /** + * optional uint32 retcode = 13; + * @return whether the retcode field is set + */ + public boolean hasRetcode() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 retcode = 13; + * @return this + */ + public ChessRogueConfirmRollScRsp clearRetcode() { + bitField0_ &= ~0x00000001; + retcode = 0; + return this; + } + + /** + * optional uint32 retcode = 13; + * @return the retcode + */ + public int getRetcode() { + return retcode; + } + + /** + * optional uint32 retcode = 13; + * @param value the retcode to set + * @return this + */ + public ChessRogueConfirmRollScRsp setRetcode(final int value) { + bitField0_ |= 0x00000001; + retcode = value; + return this; + } + + /** + * optional .ChessRogueNousDice nous_dice = 5; + * @return whether the nousDice field is set + */ + public boolean hasNousDice() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional .ChessRogueNousDice nous_dice = 5; + * @return this + */ + public ChessRogueConfirmRollScRsp clearNousDice() { + bitField0_ &= ~0x00000002; + nousDice.clear(); + return this; + } + + /** + * optional .ChessRogueNousDice nous_dice = 5; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableNousDice()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueNousDiceOuterClass.ChessRogueNousDice getNousDice() { + return nousDice; + } + + /** + * optional .ChessRogueNousDice nous_dice = 5; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueNousDiceOuterClass.ChessRogueNousDice getMutableNousDice() { + bitField0_ |= 0x00000002; + return nousDice; + } + + /** + * optional .ChessRogueNousDice nous_dice = 5; + * @param value the nousDice to set + * @return this + */ + public ChessRogueConfirmRollScRsp setNousDice( + final ChessRogueNousDiceOuterClass.ChessRogueNousDice value) { + bitField0_ |= 0x00000002; + nousDice.copyFrom(value); + return this; + } + + @Override + public ChessRogueConfirmRollScRsp copyFrom(final ChessRogueConfirmRollScRsp other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + retcode = other.retcode; + nousDice.copyFrom(other.nousDice); + } + return this; + } + + @Override + public ChessRogueConfirmRollScRsp mergeFrom(final ChessRogueConfirmRollScRsp other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRetcode()) { + setRetcode(other.retcode); + } + if (other.hasNousDice()) { + getMutableNousDice().mergeFrom(other.nousDice); + } + return this; + } + + @Override + public ChessRogueConfirmRollScRsp clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + retcode = 0; + nousDice.clear(); + return this; + } + + @Override + public ChessRogueConfirmRollScRsp clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nousDice.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueConfirmRollScRsp)) { + return false; + } + ChessRogueConfirmRollScRsp other = (ChessRogueConfirmRollScRsp) o; + return bitField0_ == other.bitField0_ + && (!hasRetcode() || retcode == other.retcode) + && (!hasNousDice() || nousDice.equals(other.nousDice)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 104); + output.writeUInt32NoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 42); + output.writeMessageNoTag(nousDice); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(nousDice); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueConfirmRollScRsp mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 104: { + // retcode + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 42) { + break; + } + } + case 42: { + // nousDice + input.readMessage(nousDice); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.retcode, retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeMessage(FieldNames.nousDice, nousDice); + } + output.endObject(); + } + + @Override + public ChessRogueConfirmRollScRsp mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1097936398: { + if (input.isAtField(FieldNames.retcode)) { + if (!input.trySkipNullValue()) { + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1622214758: + case -1226158137: { + if (input.isAtField(FieldNames.nousDice)) { + if (!input.trySkipNullValue()) { + input.readMessage(nousDice); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueConfirmRollScRsp clone() { + return new ChessRogueConfirmRollScRsp().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueConfirmRollScRsp parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueConfirmRollScRsp(), data).checkInitialized(); + } + + public static ChessRogueConfirmRollScRsp parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueConfirmRollScRsp(), input).checkInitialized(); + } + + public static ChessRogueConfirmRollScRsp parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueConfirmRollScRsp(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueConfirmRollScRsp messages + */ + public static MessageFactory getFactory() { + return ChessRogueConfirmRollScRspFactory.INSTANCE; + } + + private enum ChessRogueConfirmRollScRspFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueConfirmRollScRsp create() { + return ChessRogueConfirmRollScRsp.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName retcode = FieldName.forField("retcode"); + + static final FieldName nousDice = FieldName.forField("nousDice", "nous_dice"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueCurrentInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueCurrentInfoOuterClass.java new file mode 100644 index 0000000..4765115 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueCurrentInfoOuterClass.java @@ -0,0 +1,1204 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedMessage; + +public final class ChessRogueCurrentInfoOuterClass { + /** + * Protobuf type {@code ChessRogueCurrentInfo} + */ + public static final class ChessRogueCurrentInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * 
+     * DKMCDMJGOIB CKJPPDKJIOH = 2;
+     *
+ * + * optional uint32 rogue_version_id = 12; + */ + private int rogueVersionId; + + /** + * 
+     * NGKOOLFOHEM JNAGMIALOII = 522;
+     * LNJJGEAFJPH NMJAHFBMGDO = 7;
+     *
+ * + * optional .ChessRogueBuffInfo buff_info = 1; + */ + private final ChessRogueBuffInfoOuterClass.ChessRogueBuffInfo buffInfo = ChessRogueBuffInfoOuterClass.ChessRogueBuffInfo.newInstance(); + + /** + * 
+     * JFGFEBLFGMG KJHGNMBOGHA = 9;
+     * CGAPFPHEJIA EEFGNNFCDNJ = 8;
+     *
+ * + * optional .ChessRogueMiracleInfo miracle_info = 3; + */ + private final ChessRogueMiracleInfoOuterClass.ChessRogueMiracleInfo miracleInfo = ChessRogueMiracleInfoOuterClass.ChessRogueMiracleInfo.newInstance(); + + /** + * optional .RogueCommonPendingAction pending_action = 4; + */ + private final RogueCommonPendingActionOuterClass.RogueCommonPendingAction pendingAction = RogueCommonPendingActionOuterClass.RogueCommonPendingAction.newInstance(); + + /** + * optional .ChessRogueNousStoryInfo story_info = 5; + */ + private final ChessRogueNousStoryInfoOuterClass.ChessRogueNousStoryInfo storyInfo = ChessRogueNousStoryInfoOuterClass.ChessRogueNousStoryInfo.newInstance(); + + /** + * 
+     * BELMNIPGEDN LIJCHOCOPEK = 15;
+     *
+ * + * optional .ChessRogueAvatarInfo rogue_avatar_info = 10; + */ + private final ChessRogueAvatarInfoOuterClass.ChessRogueAvatarInfo rogueAvatarInfo = ChessRogueAvatarInfoOuterClass.ChessRogueAvatarInfo.newInstance(); + + /** + * optional .ChessRogueNousDice dice_info = 11; + */ + private final ChessRogueNousDiceOuterClass.ChessRogueNousDice diceInfo = ChessRogueNousDiceOuterClass.ChessRogueNousDice.newInstance(); + + /** + * optional .ChessRogueNousValue nous_value = 14; + */ + private final ChessRogueNousValueOuterClass.ChessRogueNousValue nousValue = ChessRogueNousValueOuterClass.ChessRogueNousValue.newInstance(); + + /** + * repeated .ChessRogueVirtualItemInfo virtual_item_info = 13; + */ + private final RepeatedMessage virtualItemInfo = RepeatedMessage.newEmptyInstance(ChessRogueVirtualItemInfoOuterClass.ChessRogueVirtualItemInfo.getFactory()); + + private ChessRogueCurrentInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueCurrentInfo} + */ + public static ChessRogueCurrentInfo newInstance() { + return new ChessRogueCurrentInfo(); + } + + /** + * 
+     * DKMCDMJGOIB CKJPPDKJIOH = 2;
+     *
+ * + * optional uint32 rogue_version_id = 12; + * @return whether the rogueVersionId field is set + */ + public boolean hasRogueVersionId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * 
+     * DKMCDMJGOIB CKJPPDKJIOH = 2;
+     *
+ * + * optional uint32 rogue_version_id = 12; + * @return this + */ + public ChessRogueCurrentInfo clearRogueVersionId() { + bitField0_ &= ~0x00000001; + rogueVersionId = 0; + return this; + } + + /** + * 
+     * DKMCDMJGOIB CKJPPDKJIOH = 2;
+     *
+ * + * optional uint32 rogue_version_id = 12; + * @return the rogueVersionId + */ + public int getRogueVersionId() { + return rogueVersionId; + } + + /** + * 
+     * DKMCDMJGOIB CKJPPDKJIOH = 2;
+     *
+ * + * optional uint32 rogue_version_id = 12; + * @param value the rogueVersionId to set + * @return this + */ + public ChessRogueCurrentInfo setRogueVersionId(final int value) { + bitField0_ |= 0x00000001; + rogueVersionId = value; + return this; + } + + /** + * 
+     * NGKOOLFOHEM JNAGMIALOII = 522;
+     * LNJJGEAFJPH NMJAHFBMGDO = 7;
+     *
+ * + * optional .ChessRogueBuffInfo buff_info = 1; + * @return whether the buffInfo field is set + */ + public boolean hasBuffInfo() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * 
+     * NGKOOLFOHEM JNAGMIALOII = 522;
+     * LNJJGEAFJPH NMJAHFBMGDO = 7;
+     *
+ * + * optional .ChessRogueBuffInfo buff_info = 1; + * @return this + */ + public ChessRogueCurrentInfo clearBuffInfo() { + bitField0_ &= ~0x00000002; + buffInfo.clear(); + return this; + } + + /** + * 
+     * NGKOOLFOHEM JNAGMIALOII = 522;
+     * LNJJGEAFJPH NMJAHFBMGDO = 7;
+     *
+ * + * optional .ChessRogueBuffInfo buff_info = 1; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableBuffInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueBuffInfoOuterClass.ChessRogueBuffInfo getBuffInfo() { + return buffInfo; + } + + /** + * 
+     * NGKOOLFOHEM JNAGMIALOII = 522;
+     * LNJJGEAFJPH NMJAHFBMGDO = 7;
+     *
+ * + * optional .ChessRogueBuffInfo buff_info = 1; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueBuffInfoOuterClass.ChessRogueBuffInfo getMutableBuffInfo() { + bitField0_ |= 0x00000002; + return buffInfo; + } + + /** + * 
+     * NGKOOLFOHEM JNAGMIALOII = 522;
+     * LNJJGEAFJPH NMJAHFBMGDO = 7;
+     *
+ * + * optional .ChessRogueBuffInfo buff_info = 1; + * @param value the buffInfo to set + * @return this + */ + public ChessRogueCurrentInfo setBuffInfo( + final ChessRogueBuffInfoOuterClass.ChessRogueBuffInfo value) { + bitField0_ |= 0x00000002; + buffInfo.copyFrom(value); + return this; + } + + /** + * 
+     * JFGFEBLFGMG KJHGNMBOGHA = 9;
+     * CGAPFPHEJIA EEFGNNFCDNJ = 8;
+     *
+ * + * optional .ChessRogueMiracleInfo miracle_info = 3; + * @return whether the miracleInfo field is set + */ + public boolean hasMiracleInfo() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * 
+     * JFGFEBLFGMG KJHGNMBOGHA = 9;
+     * CGAPFPHEJIA EEFGNNFCDNJ = 8;
+     *
+ * + * optional .ChessRogueMiracleInfo miracle_info = 3; + * @return this + */ + public ChessRogueCurrentInfo clearMiracleInfo() { + bitField0_ &= ~0x00000004; + miracleInfo.clear(); + return this; + } + + /** + * 
+     * JFGFEBLFGMG KJHGNMBOGHA = 9;
+     * CGAPFPHEJIA EEFGNNFCDNJ = 8;
+     *
+ * + * optional .ChessRogueMiracleInfo miracle_info = 3; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableMiracleInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueMiracleInfoOuterClass.ChessRogueMiracleInfo getMiracleInfo() { + return miracleInfo; + } + + /** + * 
+     * JFGFEBLFGMG KJHGNMBOGHA = 9;
+     * CGAPFPHEJIA EEFGNNFCDNJ = 8;
+     *
+ * + * optional .ChessRogueMiracleInfo miracle_info = 3; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueMiracleInfoOuterClass.ChessRogueMiracleInfo getMutableMiracleInfo() { + bitField0_ |= 0x00000004; + return miracleInfo; + } + + /** + * 
+     * JFGFEBLFGMG KJHGNMBOGHA = 9;
+     * CGAPFPHEJIA EEFGNNFCDNJ = 8;
+     *
+ * + * optional .ChessRogueMiracleInfo miracle_info = 3; + * @param value the miracleInfo to set + * @return this + */ + public ChessRogueCurrentInfo setMiracleInfo( + final ChessRogueMiracleInfoOuterClass.ChessRogueMiracleInfo value) { + bitField0_ |= 0x00000004; + miracleInfo.copyFrom(value); + return this; + } + + /** + * optional .RogueCommonPendingAction pending_action = 4; + * @return whether the pendingAction field is set + */ + public boolean hasPendingAction() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional .RogueCommonPendingAction pending_action = 4; + * @return this + */ + public ChessRogueCurrentInfo clearPendingAction() { + bitField0_ &= ~0x00000008; + pendingAction.clear(); + return this; + } + + /** + * optional .RogueCommonPendingAction pending_action = 4; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutablePendingAction()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RogueCommonPendingActionOuterClass.RogueCommonPendingAction getPendingAction() { + return pendingAction; + } + + /** + * optional .RogueCommonPendingAction pending_action = 4; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RogueCommonPendingActionOuterClass.RogueCommonPendingAction getMutablePendingAction() { + bitField0_ |= 0x00000008; + return pendingAction; + } + + /** + * optional .RogueCommonPendingAction pending_action = 4; + * @param value the pendingAction to set + * @return this + */ + public ChessRogueCurrentInfo setPendingAction( + final RogueCommonPendingActionOuterClass.RogueCommonPendingAction value) { + bitField0_ |= 0x00000008; + pendingAction.copyFrom(value); + return this; + } + + /** + * optional .ChessRogueNousStoryInfo story_info = 5; + * @return whether the storyInfo field is set + */ + public boolean hasStoryInfo() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * optional .ChessRogueNousStoryInfo story_info = 5; + * @return this + */ + public ChessRogueCurrentInfo clearStoryInfo() { + bitField0_ &= ~0x00000010; + storyInfo.clear(); + return this; + } + + /** + * optional .ChessRogueNousStoryInfo story_info = 5; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableStoryInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueNousStoryInfoOuterClass.ChessRogueNousStoryInfo getStoryInfo() { + return storyInfo; + } + + /** + * optional .ChessRogueNousStoryInfo story_info = 5; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueNousStoryInfoOuterClass.ChessRogueNousStoryInfo getMutableStoryInfo() { + bitField0_ |= 0x00000010; + return storyInfo; + } + + /** + * optional .ChessRogueNousStoryInfo story_info = 5; + * @param value the storyInfo to set + * @return this + */ + public ChessRogueCurrentInfo setStoryInfo( + final ChessRogueNousStoryInfoOuterClass.ChessRogueNousStoryInfo value) { + bitField0_ |= 0x00000010; + storyInfo.copyFrom(value); + return this; + } + + /** + * 
+     * BELMNIPGEDN LIJCHOCOPEK = 15;
+     *
+ * + * optional .ChessRogueAvatarInfo rogue_avatar_info = 10; + * @return whether the rogueAvatarInfo field is set + */ + public boolean hasRogueAvatarInfo() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * 
+     * BELMNIPGEDN LIJCHOCOPEK = 15;
+     *
+ * + * optional .ChessRogueAvatarInfo rogue_avatar_info = 10; + * @return this + */ + public ChessRogueCurrentInfo clearRogueAvatarInfo() { + bitField0_ &= ~0x00000020; + rogueAvatarInfo.clear(); + return this; + } + + /** + * 
+     * BELMNIPGEDN LIJCHOCOPEK = 15;
+     *
+ * + * optional .ChessRogueAvatarInfo rogue_avatar_info = 10; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableRogueAvatarInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueAvatarInfoOuterClass.ChessRogueAvatarInfo getRogueAvatarInfo() { + return rogueAvatarInfo; + } + + /** + * 
+     * BELMNIPGEDN LIJCHOCOPEK = 15;
+     *
+ * + * optional .ChessRogueAvatarInfo rogue_avatar_info = 10; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueAvatarInfoOuterClass.ChessRogueAvatarInfo getMutableRogueAvatarInfo() { + bitField0_ |= 0x00000020; + return rogueAvatarInfo; + } + + /** + * 
+     * BELMNIPGEDN LIJCHOCOPEK = 15;
+     *
+ * + * optional .ChessRogueAvatarInfo rogue_avatar_info = 10; + * @param value the rogueAvatarInfo to set + * @return this + */ + public ChessRogueCurrentInfo setRogueAvatarInfo( + final ChessRogueAvatarInfoOuterClass.ChessRogueAvatarInfo value) { + bitField0_ |= 0x00000020; + rogueAvatarInfo.copyFrom(value); + return this; + } + + /** + * optional .ChessRogueNousDice dice_info = 11; + * @return whether the diceInfo field is set + */ + public boolean hasDiceInfo() { + return (bitField0_ & 0x00000040) != 0; + } + + /** + * optional .ChessRogueNousDice dice_info = 11; + * @return this + */ + public ChessRogueCurrentInfo clearDiceInfo() { + bitField0_ &= ~0x00000040; + diceInfo.clear(); + return this; + } + + /** + * optional .ChessRogueNousDice dice_info = 11; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableDiceInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueNousDiceOuterClass.ChessRogueNousDice getDiceInfo() { + return diceInfo; + } + + /** + * optional .ChessRogueNousDice dice_info = 11; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueNousDiceOuterClass.ChessRogueNousDice getMutableDiceInfo() { + bitField0_ |= 0x00000040; + return diceInfo; + } + + /** + * optional .ChessRogueNousDice dice_info = 11; + * @param value the diceInfo to set + * @return this + */ + public ChessRogueCurrentInfo setDiceInfo( + final ChessRogueNousDiceOuterClass.ChessRogueNousDice value) { + bitField0_ |= 0x00000040; + diceInfo.copyFrom(value); + return this; + } + + /** + * optional .ChessRogueNousValue nous_value = 14; + * @return whether the nousValue field is set + */ + public boolean hasNousValue() { + return (bitField0_ & 0x00000080) != 0; + } + + /** + * optional .ChessRogueNousValue nous_value = 14; + * @return this + */ + public ChessRogueCurrentInfo clearNousValue() { + bitField0_ &= ~0x00000080; + nousValue.clear(); + return this; + } + + /** + * optional .ChessRogueNousValue nous_value = 14; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableNousValue()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueNousValueOuterClass.ChessRogueNousValue getNousValue() { + return nousValue; + } + + /** + * optional .ChessRogueNousValue nous_value = 14; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueNousValueOuterClass.ChessRogueNousValue getMutableNousValue() { + bitField0_ |= 0x00000080; + return nousValue; + } + + /** + * optional .ChessRogueNousValue nous_value = 14; + * @param value the nousValue to set + * @return this + */ + public ChessRogueCurrentInfo setNousValue( + final ChessRogueNousValueOuterClass.ChessRogueNousValue value) { + bitField0_ |= 0x00000080; + nousValue.copyFrom(value); + return this; + } + + /** + * repeated .ChessRogueVirtualItemInfo virtual_item_info = 13; + * @return whether the virtualItemInfo field is set + */ + public boolean hasVirtualItemInfo() { + return (bitField0_ & 0x00000100) != 0; + } + + /** + * repeated .ChessRogueVirtualItemInfo virtual_item_info = 13; + * @return this + */ + public ChessRogueCurrentInfo clearVirtualItemInfo() { + bitField0_ &= ~0x00000100; + virtualItemInfo.clear(); + return this; + } + + /** + * repeated .ChessRogueVirtualItemInfo virtual_item_info = 13; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableVirtualItemInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getVirtualItemInfo( + ) { + return virtualItemInfo; + } + + /** + * repeated .ChessRogueVirtualItemInfo virtual_item_info = 13; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableVirtualItemInfo( + ) { + bitField0_ |= 0x00000100; + return virtualItemInfo; + } + + /** + * repeated .ChessRogueVirtualItemInfo virtual_item_info = 13; + * @param value the virtualItemInfo to add + * @return this + */ + public ChessRogueCurrentInfo addVirtualItemInfo( + final ChessRogueVirtualItemInfoOuterClass.ChessRogueVirtualItemInfo value) { + bitField0_ |= 0x00000100; + virtualItemInfo.add(value); + return this; + } + + /** + * repeated .ChessRogueVirtualItemInfo virtual_item_info = 13; + * @param values the virtualItemInfo to add + * @return this + */ + public ChessRogueCurrentInfo addAllVirtualItemInfo( + final ChessRogueVirtualItemInfoOuterClass.ChessRogueVirtualItemInfo... values) { + bitField0_ |= 0x00000100; + virtualItemInfo.addAll(values); + return this; + } + + @Override + public ChessRogueCurrentInfo copyFrom(final ChessRogueCurrentInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + rogueVersionId = other.rogueVersionId; + buffInfo.copyFrom(other.buffInfo); + miracleInfo.copyFrom(other.miracleInfo); + pendingAction.copyFrom(other.pendingAction); + storyInfo.copyFrom(other.storyInfo); + rogueAvatarInfo.copyFrom(other.rogueAvatarInfo); + diceInfo.copyFrom(other.diceInfo); + nousValue.copyFrom(other.nousValue); + virtualItemInfo.copyFrom(other.virtualItemInfo); + } + return this; + } + + @Override + public ChessRogueCurrentInfo mergeFrom(final ChessRogueCurrentInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRogueVersionId()) { + setRogueVersionId(other.rogueVersionId); + } + if (other.hasBuffInfo()) { + getMutableBuffInfo().mergeFrom(other.buffInfo); + } + if (other.hasMiracleInfo()) { + getMutableMiracleInfo().mergeFrom(other.miracleInfo); + } + if (other.hasPendingAction()) { + getMutablePendingAction().mergeFrom(other.pendingAction); + } + if (other.hasStoryInfo()) { + getMutableStoryInfo().mergeFrom(other.storyInfo); + } + if (other.hasRogueAvatarInfo()) { + getMutableRogueAvatarInfo().mergeFrom(other.rogueAvatarInfo); + } + if (other.hasDiceInfo()) { + getMutableDiceInfo().mergeFrom(other.diceInfo); + } + if (other.hasNousValue()) { + getMutableNousValue().mergeFrom(other.nousValue); + } + if (other.hasVirtualItemInfo()) { + getMutableVirtualItemInfo().addAll(other.virtualItemInfo); + } + return this; + } + + @Override + public ChessRogueCurrentInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + rogueVersionId = 0; + buffInfo.clear(); + miracleInfo.clear(); + pendingAction.clear(); + storyInfo.clear(); + rogueAvatarInfo.clear(); + diceInfo.clear(); + nousValue.clear(); + virtualItemInfo.clear(); + return this; + } + + @Override + public ChessRogueCurrentInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + buffInfo.clearQuick(); + miracleInfo.clearQuick(); + pendingAction.clearQuick(); + storyInfo.clearQuick(); + rogueAvatarInfo.clearQuick(); + diceInfo.clearQuick(); + nousValue.clearQuick(); + virtualItemInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueCurrentInfo)) { + return false; + } + ChessRogueCurrentInfo other = (ChessRogueCurrentInfo) o; + return bitField0_ == other.bitField0_ + && (!hasRogueVersionId() || rogueVersionId == other.rogueVersionId) + && (!hasBuffInfo() || buffInfo.equals(other.buffInfo)) + && (!hasMiracleInfo() || miracleInfo.equals(other.miracleInfo)) + && (!hasPendingAction() || pendingAction.equals(other.pendingAction)) + && (!hasStoryInfo() || storyInfo.equals(other.storyInfo)) + && (!hasRogueAvatarInfo() || rogueAvatarInfo.equals(other.rogueAvatarInfo)) + && (!hasDiceInfo() || diceInfo.equals(other.diceInfo)) + && (!hasNousValue() || nousValue.equals(other.nousValue)) + && (!hasVirtualItemInfo() || virtualItemInfo.equals(other.virtualItemInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 96); + output.writeUInt32NoTag(rogueVersionId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 10); + output.writeMessageNoTag(buffInfo); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 26); + output.writeMessageNoTag(miracleInfo); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 34); + output.writeMessageNoTag(pendingAction); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawByte((byte) 42); + output.writeMessageNoTag(storyInfo); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRawByte((byte) 82); + output.writeMessageNoTag(rogueAvatarInfo); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeRawByte((byte) 90); + output.writeMessageNoTag(diceInfo); + } + if ((bitField0_ & 0x00000080) != 0) { + output.writeRawByte((byte) 114); + output.writeMessageNoTag(nousValue); + } + if ((bitField0_ & 0x00000100) != 0) { + for (int i = 0; i < virtualItemInfo.length(); i++) { + output.writeRawByte((byte) 106); + output.writeMessageNoTag(virtualItemInfo.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(rogueVersionId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(buffInfo); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(miracleInfo); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(pendingAction); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(storyInfo); + } + if ((bitField0_ & 0x00000020) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(rogueAvatarInfo); + } + if ((bitField0_ & 0x00000040) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(diceInfo); + } + if ((bitField0_ & 0x00000080) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(nousValue); + } + if ((bitField0_ & 0x00000100) != 0) { + size += (1 * virtualItemInfo.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(virtualItemInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueCurrentInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 96: { + // rogueVersionId + rogueVersionId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 10) { + break; + } + } + case 10: { + // buffInfo + input.readMessage(buffInfo); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 26) { + break; + } + } + case 26: { + // miracleInfo + input.readMessage(miracleInfo); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 34) { + break; + } + } + case 34: { + // pendingAction + input.readMessage(pendingAction); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 42) { + break; + } + } + case 42: { + // storyInfo + input.readMessage(storyInfo); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 82) { + break; + } + } + case 82: { + // rogueAvatarInfo + input.readMessage(rogueAvatarInfo); + bitField0_ |= 0x00000020; + tag = input.readTag(); + if (tag != 90) { + break; + } + } + case 90: { + // diceInfo + input.readMessage(diceInfo); + bitField0_ |= 0x00000040; + tag = input.readTag(); + if (tag != 114) { + break; + } + } + case 114: { + // nousValue + input.readMessage(nousValue); + bitField0_ |= 0x00000080; + tag = input.readTag(); + if (tag != 106) { + break; + } + } + case 106: { + // virtualItemInfo + tag = input.readRepeatedMessage(virtualItemInfo, tag); + bitField0_ |= 0x00000100; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.rogueVersionId, rogueVersionId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeMessage(FieldNames.buffInfo, buffInfo); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeMessage(FieldNames.miracleInfo, miracleInfo); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeMessage(FieldNames.pendingAction, pendingAction); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeMessage(FieldNames.storyInfo, storyInfo); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeMessage(FieldNames.rogueAvatarInfo, rogueAvatarInfo); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeMessage(FieldNames.diceInfo, diceInfo); + } + if ((bitField0_ & 0x00000080) != 0) { + output.writeMessage(FieldNames.nousValue, nousValue); + } + if ((bitField0_ & 0x00000100) != 0) { + output.writeRepeatedMessage(FieldNames.virtualItemInfo, virtualItemInfo); + } + output.endObject(); + } + + @Override + public ChessRogueCurrentInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1457526951: + case 1832096103: { + if (input.isAtField(FieldNames.rogueVersionId)) { + if (!input.trySkipNullValue()) { + rogueVersionId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1522874463: + case 55707930: { + if (input.isAtField(FieldNames.buffInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(buffInfo); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 760306879: + case 2114852796: { + if (input.isAtField(FieldNames.miracleInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(miracleInfo); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -110680403: + case 1646545374: { + if (input.isAtField(FieldNames.pendingAction)) { + if (!input.trySkipNullValue()) { + input.readMessage(pendingAction); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1710116675: + case 1494185400: { + if (input.isAtField(FieldNames.storyInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(storyInfo); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1966631135: + case 667955439: { + if (input.isAtField(FieldNames.rogueAvatarInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(rogueAvatarInfo); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } + case -184174347: + case -1394261434: { + if (input.isAtField(FieldNames.diceInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(diceInfo); + bitField0_ |= 0x00000040; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1234555758: + case 660197713: { + if (input.isAtField(FieldNames.nousValue)) { + if (!input.trySkipNullValue()) { + input.readMessage(nousValue); + bitField0_ |= 0x00000080; + } + } else { + input.skipUnknownField(); + } + break; + } + case 892328588: + case -207708634: { + if (input.isAtField(FieldNames.virtualItemInfo)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(virtualItemInfo); + bitField0_ |= 0x00000100; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueCurrentInfo clone() { + return new ChessRogueCurrentInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueCurrentInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueCurrentInfo(), data).checkInitialized(); + } + + public static ChessRogueCurrentInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueCurrentInfo(), input).checkInitialized(); + } + + public static ChessRogueCurrentInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueCurrentInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueCurrentInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueCurrentInfoFactory.INSTANCE; + } + + private enum ChessRogueCurrentInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueCurrentInfo create() { + return ChessRogueCurrentInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName rogueVersionId = FieldName.forField("rogueVersionId", "rogue_version_id"); + + static final FieldName buffInfo = FieldName.forField("buffInfo", "buff_info"); + + static final FieldName miracleInfo = FieldName.forField("miracleInfo", "miracle_info"); + + static final FieldName pendingAction = FieldName.forField("pendingAction", "pending_action"); + + static final FieldName storyInfo = FieldName.forField("storyInfo", "story_info"); + + static final FieldName rogueAvatarInfo = FieldName.forField("rogueAvatarInfo", "rogue_avatar_info"); + + static final FieldName diceInfo = FieldName.forField("diceInfo", "dice_info"); + + static final FieldName nousValue = FieldName.forField("nousValue", "nous_value"); + + static final FieldName virtualItemInfo = FieldName.forField("virtualItemInfo", "virtual_item_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueInfoOuterClass.java new file mode 100644 index 0000000..dcb8db3 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueInfoOuterClass.java @@ -0,0 +1,381 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueInfoOuterClass { + /** + * Protobuf type {@code ChessRogueInfo} + */ + public static final class ChessRogueInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .LineupInfo lineup = 4; + */ + private final LineupInfoOuterClass.LineupInfo lineup = LineupInfoOuterClass.LineupInfo.newInstance(); + + /** + * optional .SceneInfo scene = 6; + */ + private final SceneInfoOuterClass.SceneInfo scene = SceneInfoOuterClass.SceneInfo.newInstance(); + + private ChessRogueInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueInfo} + */ + public static ChessRogueInfo newInstance() { + return new ChessRogueInfo(); + } + + /** + * optional .LineupInfo lineup = 4; + * @return whether the lineup field is set + */ + public boolean hasLineup() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .LineupInfo lineup = 4; + * @return this + */ + public ChessRogueInfo clearLineup() { + bitField0_ &= ~0x00000001; + lineup.clear(); + return this; + } + + /** + * optional .LineupInfo lineup = 4; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableLineup()} if you want to modify it. + * + * @return internal storage object for reading + */ + public LineupInfoOuterClass.LineupInfo getLineup() { + return lineup; + } + + /** + * optional .LineupInfo lineup = 4; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public LineupInfoOuterClass.LineupInfo getMutableLineup() { + bitField0_ |= 0x00000001; + return lineup; + } + + /** + * optional .LineupInfo lineup = 4; + * @param value the lineup to set + * @return this + */ + public ChessRogueInfo setLineup(final LineupInfoOuterClass.LineupInfo value) { + bitField0_ |= 0x00000001; + lineup.copyFrom(value); + return this; + } + + /** + * optional .SceneInfo scene = 6; + * @return whether the scene field is set + */ + public boolean hasScene() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional .SceneInfo scene = 6; + * @return this + */ + public ChessRogueInfo clearScene() { + bitField0_ &= ~0x00000002; + scene.clear(); + return this; + } + + /** + * optional .SceneInfo scene = 6; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableScene()} if you want to modify it. + * + * @return internal storage object for reading + */ + public SceneInfoOuterClass.SceneInfo getScene() { + return scene; + } + + /** + * optional .SceneInfo scene = 6; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public SceneInfoOuterClass.SceneInfo getMutableScene() { + bitField0_ |= 0x00000002; + return scene; + } + + /** + * optional .SceneInfo scene = 6; + * @param value the scene to set + * @return this + */ + public ChessRogueInfo setScene(final SceneInfoOuterClass.SceneInfo value) { + bitField0_ |= 0x00000002; + scene.copyFrom(value); + return this; + } + + @Override + public ChessRogueInfo copyFrom(final ChessRogueInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + lineup.copyFrom(other.lineup); + scene.copyFrom(other.scene); + } + return this; + } + + @Override + public ChessRogueInfo mergeFrom(final ChessRogueInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasLineup()) { + getMutableLineup().mergeFrom(other.lineup); + } + if (other.hasScene()) { + getMutableScene().mergeFrom(other.scene); + } + return this; + } + + @Override + public ChessRogueInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + lineup.clear(); + scene.clear(); + return this; + } + + @Override + public ChessRogueInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + lineup.clearQuick(); + scene.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueInfo)) { + return false; + } + ChessRogueInfo other = (ChessRogueInfo) o; + return bitField0_ == other.bitField0_ + && (!hasLineup() || lineup.equals(other.lineup)) + && (!hasScene() || scene.equals(other.scene)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 34); + output.writeMessageNoTag(lineup); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 50); + output.writeMessageNoTag(scene); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(lineup); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(scene); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 34: { + // lineup + input.readMessage(lineup); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 50) { + break; + } + } + case 50: { + // scene + input.readMessage(scene); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.lineup, lineup); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeMessage(FieldNames.scene, scene); + } + output.endObject(); + } + + @Override + public ChessRogueInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1102671473: { + if (input.isAtField(FieldNames.lineup)) { + if (!input.trySkipNullValue()) { + input.readMessage(lineup); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 109254796: { + if (input.isAtField(FieldNames.scene)) { + if (!input.trySkipNullValue()) { + input.readMessage(scene); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueInfo clone() { + return new ChessRogueInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueInfo(), data).checkInitialized(); + } + + public static ChessRogueInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueInfo(), input).checkInitialized(); + } + + public static ChessRogueInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueInfoFactory.INSTANCE; + } + + private enum ChessRogueInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueInfo create() { + return ChessRogueInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName lineup = FieldName.forField("lineup"); + + static final FieldName scene = FieldName.forField("scene"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueItemInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueItemInfoOuterClass.java new file mode 100644 index 0000000..2bb143b --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueItemInfoOuterClass.java @@ -0,0 +1,617 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedMessage; + +public final class ChessRogueItemInfoOuterClass { + /** + * Protobuf type {@code ChessRogueItemInfo} + */ + public static final class ChessRogueItemInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * repeated .ChessRogueItemInfo.ItemsEntry items = 4; + */ + private final RepeatedMessage items = RepeatedMessage.newEmptyInstance(ItemsEntry.getFactory()); + + private ChessRogueItemInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueItemInfo} + */ + public static ChessRogueItemInfo newInstance() { + return new ChessRogueItemInfo(); + } + + /** + * repeated .ChessRogueItemInfo.ItemsEntry items = 4; + * @return whether the items field is set + */ + public boolean hasItems() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * repeated .ChessRogueItemInfo.ItemsEntry items = 4; + * @return this + */ + public ChessRogueItemInfo clearItems() { + bitField0_ &= ~0x00000001; + items.clear(); + return this; + } + + /** + * repeated .ChessRogueItemInfo.ItemsEntry items = 4; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableItems()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getItems() { + return items; + } + + /** + * repeated .ChessRogueItemInfo.ItemsEntry items = 4; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableItems() { + bitField0_ |= 0x00000001; + return items; + } + + /** + * repeated .ChessRogueItemInfo.ItemsEntry items = 4; + * @param value the items to add + * @return this + */ + public ChessRogueItemInfo addItems(final ItemsEntry value) { + bitField0_ |= 0x00000001; + items.add(value); + return this; + } + + /** + * repeated .ChessRogueItemInfo.ItemsEntry items = 4; + * @param values the items to add + * @return this + */ + public ChessRogueItemInfo addAllItems(final ItemsEntry... values) { + bitField0_ |= 0x00000001; + items.addAll(values); + return this; + } + + @Override + public ChessRogueItemInfo copyFrom(final ChessRogueItemInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + items.copyFrom(other.items); + } + return this; + } + + @Override + public ChessRogueItemInfo mergeFrom(final ChessRogueItemInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasItems()) { + getMutableItems().addAll(other.items); + } + return this; + } + + @Override + public ChessRogueItemInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + items.clear(); + return this; + } + + @Override + public ChessRogueItemInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + items.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueItemInfo)) { + return false; + } + ChessRogueItemInfo other = (ChessRogueItemInfo) o; + return bitField0_ == other.bitField0_ + && (!hasItems() || items.equals(other.items)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + for (int i = 0; i < items.length(); i++) { + output.writeRawByte((byte) 34); + output.writeMessageNoTag(items.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += (1 * items.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(items); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueItemInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 34: { + // items + tag = input.readRepeatedMessage(items, tag); + bitField0_ |= 0x00000001; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeRepeatedMessage(FieldNames.items, items); + } + output.endObject(); + } + + @Override + public ChessRogueItemInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 100526016: { + if (input.isAtField(FieldNames.items)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(items); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueItemInfo clone() { + return new ChessRogueItemInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueItemInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueItemInfo(), data).checkInitialized(); + } + + public static ChessRogueItemInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueItemInfo(), input).checkInitialized(); + } + + public static ChessRogueItemInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueItemInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueItemInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueItemInfoFactory.INSTANCE; + } + + /** + * Protobuf type {@code ItemsEntry} + */ + public static final class ItemsEntry extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 key = 1; + */ + private int key; + + /** + * optional uint32 value = 2; + */ + private int value_; + + private ItemsEntry() { + } + + /** + * @return a new empty instance of {@code ItemsEntry} + */ + public static ItemsEntry newInstance() { + return new ItemsEntry(); + } + + /** + * optional uint32 key = 1; + * @return whether the key field is set + */ + public boolean hasKey() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 key = 1; + * @return this + */ + public ItemsEntry clearKey() { + bitField0_ &= ~0x00000001; + key = 0; + return this; + } + + /** + * optional uint32 key = 1; + * @return the key + */ + public int getKey() { + return key; + } + + /** + * optional uint32 key = 1; + * @param value the key to set + * @return this + */ + public ItemsEntry setKey(final int value) { + bitField0_ |= 0x00000001; + key = value; + return this; + } + + /** + * optional uint32 value = 2; + * @return whether the value_ field is set + */ + public boolean hasValue() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 value = 2; + * @return this + */ + public ItemsEntry clearValue() { + bitField0_ &= ~0x00000002; + value_ = 0; + return this; + } + + /** + * optional uint32 value = 2; + * @return the value_ + */ + public int getValue() { + return value_; + } + + /** + * optional uint32 value = 2; + * @param value the value_ to set + * @return this + */ + public ItemsEntry setValue(final int value) { + bitField0_ |= 0x00000002; + value_ = value; + return this; + } + + @Override + public ItemsEntry copyFrom(final ItemsEntry other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + key = other.key; + value_ = other.value_; + } + return this; + } + + @Override + public ItemsEntry mergeFrom(final ItemsEntry other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasKey()) { + setKey(other.key); + } + if (other.hasValue()) { + setValue(other.value_); + } + return this; + } + + @Override + public ItemsEntry clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + key = 0; + value_ = 0; + return this; + } + + @Override + public ItemsEntry clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ItemsEntry)) { + return false; + } + ItemsEntry other = (ItemsEntry) o; + return bitField0_ == other.bitField0_ + && (!hasKey() || key == other.key) + && (!hasValue() || value_ == other.value_); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(key); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(value_); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(key); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(value_); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ItemsEntry mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // key + key = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // value_ + value_ = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.key, key); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.value_, value_); + } + output.endObject(); + } + + @Override + public ItemsEntry mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 106079: { + if (input.isAtField(FieldNames.key)) { + if (!input.trySkipNullValue()) { + key = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 111972721: { + if (input.isAtField(FieldNames.value_)) { + if (!input.trySkipNullValue()) { + value_ = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ItemsEntry clone() { + return new ItemsEntry().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ItemsEntry parseFrom(final byte[] data) throws InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ItemsEntry(), data).checkInitialized(); + } + + public static ItemsEntry parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ItemsEntry(), input).checkInitialized(); + } + + public static ItemsEntry parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ItemsEntry(), input).checkInitialized(); + } + + /** + * @return factory for creating ItemsEntry messages + */ + public static MessageFactory getFactory() { + return ItemsEntryFactory.INSTANCE; + } + + private enum ItemsEntryFactory implements MessageFactory { + INSTANCE; + + @Override + public ItemsEntry create() { + return ItemsEntry.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName key = FieldName.forField("key"); + + static final FieldName value_ = FieldName.forField("value"); + } + } + + private enum ChessRogueItemInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueItemInfo create() { + return ChessRogueItemInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName items = FieldName.forField("items"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueMiracleDataOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueMiracleDataOuterClass.java new file mode 100644 index 0000000..1c11865 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueMiracleDataOuterClass.java @@ -0,0 +1,295 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedMessage; + +public final class ChessRogueMiracleDataOuterClass { + /** + * Protobuf type {@code ChessRogueMiracleData} + */ + public static final class ChessRogueMiracleData extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * repeated .RogueMiracle miracle_list = 15; + */ + private final RepeatedMessage miracleList = RepeatedMessage.newEmptyInstance(RogueMiracleOuterClass.RogueMiracle.getFactory()); + + private ChessRogueMiracleData() { + } + + /** + * @return a new empty instance of {@code ChessRogueMiracleData} + */ + public static ChessRogueMiracleData newInstance() { + return new ChessRogueMiracleData(); + } + + /** + * repeated .RogueMiracle miracle_list = 15; + * @return whether the miracleList field is set + */ + public boolean hasMiracleList() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * repeated .RogueMiracle miracle_list = 15; + * @return this + */ + public ChessRogueMiracleData clearMiracleList() { + bitField0_ &= ~0x00000001; + miracleList.clear(); + return this; + } + + /** + * repeated .RogueMiracle miracle_list = 15; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableMiracleList()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getMiracleList() { + return miracleList; + } + + /** + * repeated .RogueMiracle miracle_list = 15; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableMiracleList() { + bitField0_ |= 0x00000001; + return miracleList; + } + + /** + * repeated .RogueMiracle miracle_list = 15; + * @param value the miracleList to add + * @return this + */ + public ChessRogueMiracleData addMiracleList(final RogueMiracleOuterClass.RogueMiracle value) { + bitField0_ |= 0x00000001; + miracleList.add(value); + return this; + } + + /** + * repeated .RogueMiracle miracle_list = 15; + * @param values the miracleList to add + * @return this + */ + public ChessRogueMiracleData addAllMiracleList( + final RogueMiracleOuterClass.RogueMiracle... values) { + bitField0_ |= 0x00000001; + miracleList.addAll(values); + return this; + } + + @Override + public ChessRogueMiracleData copyFrom(final ChessRogueMiracleData other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + miracleList.copyFrom(other.miracleList); + } + return this; + } + + @Override + public ChessRogueMiracleData mergeFrom(final ChessRogueMiracleData other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasMiracleList()) { + getMutableMiracleList().addAll(other.miracleList); + } + return this; + } + + @Override + public ChessRogueMiracleData clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + miracleList.clear(); + return this; + } + + @Override + public ChessRogueMiracleData clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + miracleList.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueMiracleData)) { + return false; + } + ChessRogueMiracleData other = (ChessRogueMiracleData) o; + return bitField0_ == other.bitField0_ + && (!hasMiracleList() || miracleList.equals(other.miracleList)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + for (int i = 0; i < miracleList.length(); i++) { + output.writeRawByte((byte) 122); + output.writeMessageNoTag(miracleList.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += (1 * miracleList.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(miracleList); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueMiracleData mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 122: { + // miracleList + tag = input.readRepeatedMessage(miracleList, tag); + bitField0_ |= 0x00000001; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeRepeatedMessage(FieldNames.miracleList, miracleList); + } + output.endObject(); + } + + @Override + public ChessRogueMiracleData mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 760391855: + case 2114937772: { + if (input.isAtField(FieldNames.miracleList)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(miracleList); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueMiracleData clone() { + return new ChessRogueMiracleData().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueMiracleData parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueMiracleData(), data).checkInitialized(); + } + + public static ChessRogueMiracleData parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueMiracleData(), input).checkInitialized(); + } + + public static ChessRogueMiracleData parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueMiracleData(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueMiracleData messages + */ + public static MessageFactory getFactory() { + return ChessRogueMiracleDataFactory.INSTANCE; + } + + private enum ChessRogueMiracleDataFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueMiracleData create() { + return ChessRogueMiracleData.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName miracleList = FieldName.forField("miracleList", "miracle_list"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueMiracleInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueMiracleInfoOuterClass.java new file mode 100644 index 0000000..4c6c9a0 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueMiracleInfoOuterClass.java @@ -0,0 +1,282 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueMiracleInfoOuterClass { + /** + * Protobuf type {@code ChessRogueMiracleInfo} + */ + public static final class ChessRogueMiracleInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .ChessRogueMiracleData miracle_data = 11; + */ + private final ChessRogueMiracleDataOuterClass.ChessRogueMiracleData miracleData = ChessRogueMiracleDataOuterClass.ChessRogueMiracleData.newInstance(); + + private ChessRogueMiracleInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueMiracleInfo} + */ + public static ChessRogueMiracleInfo newInstance() { + return new ChessRogueMiracleInfo(); + } + + /** + * optional .ChessRogueMiracleData miracle_data = 11; + * @return whether the miracleData field is set + */ + public boolean hasMiracleData() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .ChessRogueMiracleData miracle_data = 11; + * @return this + */ + public ChessRogueMiracleInfo clearMiracleData() { + bitField0_ &= ~0x00000001; + miracleData.clear(); + return this; + } + + /** + * optional .ChessRogueMiracleData miracle_data = 11; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableMiracleData()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueMiracleDataOuterClass.ChessRogueMiracleData getMiracleData() { + return miracleData; + } + + /** + * optional .ChessRogueMiracleData miracle_data = 11; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueMiracleDataOuterClass.ChessRogueMiracleData getMutableMiracleData() { + bitField0_ |= 0x00000001; + return miracleData; + } + + /** + * optional .ChessRogueMiracleData miracle_data = 11; + * @param value the miracleData to set + * @return this + */ + public ChessRogueMiracleInfo setMiracleData( + final ChessRogueMiracleDataOuterClass.ChessRogueMiracleData value) { + bitField0_ |= 0x00000001; + miracleData.copyFrom(value); + return this; + } + + @Override + public ChessRogueMiracleInfo copyFrom(final ChessRogueMiracleInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + miracleData.copyFrom(other.miracleData); + } + return this; + } + + @Override + public ChessRogueMiracleInfo mergeFrom(final ChessRogueMiracleInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasMiracleData()) { + getMutableMiracleData().mergeFrom(other.miracleData); + } + return this; + } + + @Override + public ChessRogueMiracleInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + miracleData.clear(); + return this; + } + + @Override + public ChessRogueMiracleInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + miracleData.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueMiracleInfo)) { + return false; + } + ChessRogueMiracleInfo other = (ChessRogueMiracleInfo) o; + return bitField0_ == other.bitField0_ + && (!hasMiracleData() || miracleData.equals(other.miracleData)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 90); + output.writeMessageNoTag(miracleData); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(miracleData); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueMiracleInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 90: { + // miracleData + input.readMessage(miracleData); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.miracleData, miracleData); + } + output.endObject(); + } + + @Override + public ChessRogueMiracleInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 760145851: + case 2114691768: { + if (input.isAtField(FieldNames.miracleData)) { + if (!input.trySkipNullValue()) { + input.readMessage(miracleData); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueMiracleInfo clone() { + return new ChessRogueMiracleInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueMiracleInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueMiracleInfo(), data).checkInitialized(); + } + + public static ChessRogueMiracleInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueMiracleInfo(), input).checkInitialized(); + } + + public static ChessRogueMiracleInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueMiracleInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueMiracleInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueMiracleInfoFactory.INSTANCE; + } + + private enum ChessRogueMiracleInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueMiracleInfo create() { + return ChessRogueMiracleInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName miracleData = FieldName.forField("miracleData", "miracle_data"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueMoneyInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueMoneyInfoOuterClass.java new file mode 100644 index 0000000..28b5788 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueMoneyInfoOuterClass.java @@ -0,0 +1,259 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueMoneyInfoOuterClass { + /** + * Protobuf type {@code ChessRogueMoneyInfo} + */ + public static final class ChessRogueMoneyInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 money = 15; + */ + private int money; + + private ChessRogueMoneyInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueMoneyInfo} + */ + public static ChessRogueMoneyInfo newInstance() { + return new ChessRogueMoneyInfo(); + } + + /** + * optional uint32 money = 15; + * @return whether the money field is set + */ + public boolean hasMoney() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 money = 15; + * @return this + */ + public ChessRogueMoneyInfo clearMoney() { + bitField0_ &= ~0x00000001; + money = 0; + return this; + } + + /** + * optional uint32 money = 15; + * @return the money + */ + public int getMoney() { + return money; + } + + /** + * optional uint32 money = 15; + * @param value the money to set + * @return this + */ + public ChessRogueMoneyInfo setMoney(final int value) { + bitField0_ |= 0x00000001; + money = value; + return this; + } + + @Override + public ChessRogueMoneyInfo copyFrom(final ChessRogueMoneyInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + money = other.money; + } + return this; + } + + @Override + public ChessRogueMoneyInfo mergeFrom(final ChessRogueMoneyInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasMoney()) { + setMoney(other.money); + } + return this; + } + + @Override + public ChessRogueMoneyInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + money = 0; + return this; + } + + @Override + public ChessRogueMoneyInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueMoneyInfo)) { + return false; + } + ChessRogueMoneyInfo other = (ChessRogueMoneyInfo) o; + return bitField0_ == other.bitField0_ + && (!hasMoney() || money == other.money); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 120); + output.writeUInt32NoTag(money); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(money); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueMoneyInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 120: { + // money + money = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.money, money); + } + output.endObject(); + } + + @Override + public ChessRogueMoneyInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 104079552: { + if (input.isAtField(FieldNames.money)) { + if (!input.trySkipNullValue()) { + money = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueMoneyInfo clone() { + return new ChessRogueMoneyInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueMoneyInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueMoneyInfo(), data).checkInitialized(); + } + + public static ChessRogueMoneyInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueMoneyInfo(), input).checkInitialized(); + } + + public static ChessRogueMoneyInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueMoneyInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueMoneyInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueMoneyInfoFactory.INSTANCE; + } + + private enum ChessRogueMoneyInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueMoneyInfo create() { + return ChessRogueMoneyInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName money = FieldName.forField("money"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceInfoOuterClass.java new file mode 100644 index 0000000..295ee56 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceInfoOuterClass.java @@ -0,0 +1,541 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedMessage; + +public final class ChessRogueNousDiceInfoOuterClass { + /** + * Protobuf type {@code ChessRogueNousDiceInfo} + */ + public static final class ChessRogueNousDiceInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 dice_branch_id = 5; + */ + private int diceBranchId; + + /** + * optional uint32 question_difficulty = 10; + */ + private int questionDifficulty; + + /** + * optional uint32 max_difficulty = 14; + */ + private int maxDifficulty; + + /** + * repeated .ChessRogueNousDiceSurfaceInfo dice_surface = 2; + */ + private final RepeatedMessage diceSurface = RepeatedMessage.newEmptyInstance(ChessRogueNousDiceSurfaceInfoOuterClass.ChessRogueNousDiceSurfaceInfo.getFactory()); + + private ChessRogueNousDiceInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueNousDiceInfo} + */ + public static ChessRogueNousDiceInfo newInstance() { + return new ChessRogueNousDiceInfo(); + } + + /** + * optional uint32 dice_branch_id = 5; + * @return whether the diceBranchId field is set + */ + public boolean hasDiceBranchId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 dice_branch_id = 5; + * @return this + */ + public ChessRogueNousDiceInfo clearDiceBranchId() { + bitField0_ &= ~0x00000001; + diceBranchId = 0; + return this; + } + + /** + * optional uint32 dice_branch_id = 5; + * @return the diceBranchId + */ + public int getDiceBranchId() { + return diceBranchId; + } + + /** + * optional uint32 dice_branch_id = 5; + * @param value the diceBranchId to set + * @return this + */ + public ChessRogueNousDiceInfo setDiceBranchId(final int value) { + bitField0_ |= 0x00000001; + diceBranchId = value; + return this; + } + + /** + * optional uint32 question_difficulty = 10; + * @return whether the questionDifficulty field is set + */ + public boolean hasQuestionDifficulty() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 question_difficulty = 10; + * @return this + */ + public ChessRogueNousDiceInfo clearQuestionDifficulty() { + bitField0_ &= ~0x00000002; + questionDifficulty = 0; + return this; + } + + /** + * optional uint32 question_difficulty = 10; + * @return the questionDifficulty + */ + public int getQuestionDifficulty() { + return questionDifficulty; + } + + /** + * optional uint32 question_difficulty = 10; + * @param value the questionDifficulty to set + * @return this + */ + public ChessRogueNousDiceInfo setQuestionDifficulty(final int value) { + bitField0_ |= 0x00000002; + questionDifficulty = value; + return this; + } + + /** + * optional uint32 max_difficulty = 14; + * @return whether the maxDifficulty field is set + */ + public boolean hasMaxDifficulty() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 max_difficulty = 14; + * @return this + */ + public ChessRogueNousDiceInfo clearMaxDifficulty() { + bitField0_ &= ~0x00000004; + maxDifficulty = 0; + return this; + } + + /** + * optional uint32 max_difficulty = 14; + * @return the maxDifficulty + */ + public int getMaxDifficulty() { + return maxDifficulty; + } + + /** + * optional uint32 max_difficulty = 14; + * @param value the maxDifficulty to set + * @return this + */ + public ChessRogueNousDiceInfo setMaxDifficulty(final int value) { + bitField0_ |= 0x00000004; + maxDifficulty = value; + return this; + } + + /** + * repeated .ChessRogueNousDiceSurfaceInfo dice_surface = 2; + * @return whether the diceSurface field is set + */ + public boolean hasDiceSurface() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * repeated .ChessRogueNousDiceSurfaceInfo dice_surface = 2; + * @return this + */ + public ChessRogueNousDiceInfo clearDiceSurface() { + bitField0_ &= ~0x00000008; + diceSurface.clear(); + return this; + } + + /** + * repeated .ChessRogueNousDiceSurfaceInfo dice_surface = 2; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableDiceSurface()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getDiceSurface( + ) { + return diceSurface; + } + + /** + * repeated .ChessRogueNousDiceSurfaceInfo dice_surface = 2; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableDiceSurface( + ) { + bitField0_ |= 0x00000008; + return diceSurface; + } + + /** + * repeated .ChessRogueNousDiceSurfaceInfo dice_surface = 2; + * @param value the diceSurface to add + * @return this + */ + public ChessRogueNousDiceInfo addDiceSurface( + final ChessRogueNousDiceSurfaceInfoOuterClass.ChessRogueNousDiceSurfaceInfo value) { + bitField0_ |= 0x00000008; + diceSurface.add(value); + return this; + } + + /** + * repeated .ChessRogueNousDiceSurfaceInfo dice_surface = 2; + * @param values the diceSurface to add + * @return this + */ + public ChessRogueNousDiceInfo addAllDiceSurface( + final ChessRogueNousDiceSurfaceInfoOuterClass.ChessRogueNousDiceSurfaceInfo... values) { + bitField0_ |= 0x00000008; + diceSurface.addAll(values); + return this; + } + + @Override + public ChessRogueNousDiceInfo copyFrom(final ChessRogueNousDiceInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + diceBranchId = other.diceBranchId; + questionDifficulty = other.questionDifficulty; + maxDifficulty = other.maxDifficulty; + diceSurface.copyFrom(other.diceSurface); + } + return this; + } + + @Override + public ChessRogueNousDiceInfo mergeFrom(final ChessRogueNousDiceInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasDiceBranchId()) { + setDiceBranchId(other.diceBranchId); + } + if (other.hasQuestionDifficulty()) { + setQuestionDifficulty(other.questionDifficulty); + } + if (other.hasMaxDifficulty()) { + setMaxDifficulty(other.maxDifficulty); + } + if (other.hasDiceSurface()) { + getMutableDiceSurface().addAll(other.diceSurface); + } + return this; + } + + @Override + public ChessRogueNousDiceInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + diceBranchId = 0; + questionDifficulty = 0; + maxDifficulty = 0; + diceSurface.clear(); + return this; + } + + @Override + public ChessRogueNousDiceInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + diceSurface.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueNousDiceInfo)) { + return false; + } + ChessRogueNousDiceInfo other = (ChessRogueNousDiceInfo) o; + return bitField0_ == other.bitField0_ + && (!hasDiceBranchId() || diceBranchId == other.diceBranchId) + && (!hasQuestionDifficulty() || questionDifficulty == other.questionDifficulty) + && (!hasMaxDifficulty() || maxDifficulty == other.maxDifficulty) + && (!hasDiceSurface() || diceSurface.equals(other.diceSurface)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 40); + output.writeUInt32NoTag(diceBranchId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 80); + output.writeUInt32NoTag(questionDifficulty); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 112); + output.writeUInt32NoTag(maxDifficulty); + } + if ((bitField0_ & 0x00000008) != 0) { + for (int i = 0; i < diceSurface.length(); i++) { + output.writeRawByte((byte) 18); + output.writeMessageNoTag(diceSurface.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(diceBranchId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(questionDifficulty); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(maxDifficulty); + } + if ((bitField0_ & 0x00000008) != 0) { + size += (1 * diceSurface.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(diceSurface); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueNousDiceInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 40: { + // diceBranchId + diceBranchId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 80) { + break; + } + } + case 80: { + // questionDifficulty + questionDifficulty = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 112) { + break; + } + } + case 112: { + // maxDifficulty + maxDifficulty = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 18) { + break; + } + } + case 18: { + // diceSurface + tag = input.readRepeatedMessage(diceSurface, tag); + bitField0_ |= 0x00000008; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.diceBranchId, diceBranchId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.questionDifficulty, questionDifficulty); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.maxDifficulty, maxDifficulty); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRepeatedMessage(FieldNames.diceSurface, diceSurface); + } + output.endObject(); + } + + @Override + public ChessRogueNousDiceInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 216999716: + case 1050456640: { + if (input.isAtField(FieldNames.diceBranchId)) { + if (!input.trySkipNullValue()) { + diceBranchId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1586161729: + case -1998600780: { + if (input.isAtField(FieldNames.questionDifficulty)) { + if (!input.trySkipNullValue()) { + questionDifficulty = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 657132607: + case -733732490: { + if (input.isAtField(FieldNames.maxDifficulty)) { + if (!input.trySkipNullValue()) { + maxDifficulty = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1568317690: + case 682756117: { + if (input.isAtField(FieldNames.diceSurface)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(diceSurface); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueNousDiceInfo clone() { + return new ChessRogueNousDiceInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueNousDiceInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueNousDiceInfo(), data).checkInitialized(); + } + + public static ChessRogueNousDiceInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousDiceInfo(), input).checkInitialized(); + } + + public static ChessRogueNousDiceInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousDiceInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueNousDiceInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueNousDiceInfoFactory.INSTANCE; + } + + private enum ChessRogueNousDiceInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueNousDiceInfo create() { + return ChessRogueNousDiceInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName diceBranchId = FieldName.forField("diceBranchId", "dice_branch_id"); + + static final FieldName questionDifficulty = FieldName.forField("questionDifficulty", "question_difficulty"); + + static final FieldName maxDifficulty = FieldName.forField("maxDifficulty", "max_difficulty"); + + static final FieldName diceSurface = FieldName.forField("diceSurface", "dice_surface"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceOuterClass.java new file mode 100644 index 0000000..5145695 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceOuterClass.java @@ -0,0 +1,1367 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedInt; + +public final class ChessRogueNousDiceOuterClass { + /** + * Protobuf type {@code ChessRogueNousDice} + */ + public static final class ChessRogueNousDice extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 dice_branch_id = 1; + */ + private int diceBranchId; + + /** + * 
+     * FEDEMDEEJML JLCEDGIHAFF = 12;
+     *
+ * + * optional uint32 NDJBBOEJOEH = 2; + */ + private int nDJBBOEJOEH; + + /** + * 
+     * NMNBNLMAJGC cur_surface_effect = 6;
+     *
+ * + * optional uint32 cur_surface_id = 3; + */ + private int curSurfaceId; + + /** + * 
+     *  1
+     *
+ * + * optional uint32 KCFGDMFGIAN = 4; + */ + private int kCFGDMFGIAN; + + /** + * 
+     *  10
+     *
+ * + * optional uint32 HIJBOPMGBAP = 5; + */ + private int hIJBOPMGBAP; + + /** + * 
+     *  1
+     *
+ * + * optional uint32 GFGCPJOHMEL = 9; + */ + private int gFGCPJOHMEL; + + /** + * optional uint32 cur_surface_index = 13; + */ + private int curSurfaceIndex; + + /** + * 
+     *  idk
+     *
+ * + * optional uint32 dice_branch_id_remote = 14; + */ + private int diceBranchIdRemote; + + /** + * 
+     * sint32 PAOHKKNCNCD = 625;
+     *
+ * + * optional bool BDENADDOCAC = 10; + */ + private boolean bDENADDOCAC; + + /** + * 
+     * NMNBNLMAJGC POHKHEGDOHO = 343;  // guess its about modifier
+     *
+ * + * optional bool CHGLMLDAMJH = 1185; + */ + private boolean cHGLMLDAMJH; + + /** + * optional .ChessRogueNousDiceInfo dice_info = 208; + */ + private final ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo diceInfo = ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo.newInstance(); + + /** + * repeated uint32 NOGJMMEDGLL = 833; + */ + private final RepeatedInt nOGJMMEDGLL = RepeatedInt.newEmptyInstance(); + + private ChessRogueNousDice() { + } + + /** + * @return a new empty instance of {@code ChessRogueNousDice} + */ + public static ChessRogueNousDice newInstance() { + return new ChessRogueNousDice(); + } + + /** + * optional uint32 dice_branch_id = 1; + * @return whether the diceBranchId field is set + */ + public boolean hasDiceBranchId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 dice_branch_id = 1; + * @return this + */ + public ChessRogueNousDice clearDiceBranchId() { + bitField0_ &= ~0x00000001; + diceBranchId = 0; + return this; + } + + /** + * optional uint32 dice_branch_id = 1; + * @return the diceBranchId + */ + public int getDiceBranchId() { + return diceBranchId; + } + + /** + * optional uint32 dice_branch_id = 1; + * @param value the diceBranchId to set + * @return this + */ + public ChessRogueNousDice setDiceBranchId(final int value) { + bitField0_ |= 0x00000001; + diceBranchId = value; + return this; + } + + /** + * 
+     * FEDEMDEEJML JLCEDGIHAFF = 12;
+     *
+ * + * optional uint32 NDJBBOEJOEH = 2; + * @return whether the nDJBBOEJOEH field is set + */ + public boolean hasNDJBBOEJOEH() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * 
+     * FEDEMDEEJML JLCEDGIHAFF = 12;
+     *
+ * + * optional uint32 NDJBBOEJOEH = 2; + * @return this + */ + public ChessRogueNousDice clearNDJBBOEJOEH() { + bitField0_ &= ~0x00000002; + nDJBBOEJOEH = 0; + return this; + } + + /** + * 
+     * FEDEMDEEJML JLCEDGIHAFF = 12;
+     *
+ * + * optional uint32 NDJBBOEJOEH = 2; + * @return the nDJBBOEJOEH + */ + public int getNDJBBOEJOEH() { + return nDJBBOEJOEH; + } + + /** + * 
+     * FEDEMDEEJML JLCEDGIHAFF = 12;
+     *
+ * + * optional uint32 NDJBBOEJOEH = 2; + * @param value the nDJBBOEJOEH to set + * @return this + */ + public ChessRogueNousDice setNDJBBOEJOEH(final int value) { + bitField0_ |= 0x00000002; + nDJBBOEJOEH = value; + return this; + } + + /** + * 
+     * NMNBNLMAJGC cur_surface_effect = 6;
+     *
+ * + * optional uint32 cur_surface_id = 3; + * @return whether the curSurfaceId field is set + */ + public boolean hasCurSurfaceId() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * 
+     * NMNBNLMAJGC cur_surface_effect = 6;
+     *
+ * + * optional uint32 cur_surface_id = 3; + * @return this + */ + public ChessRogueNousDice clearCurSurfaceId() { + bitField0_ &= ~0x00000004; + curSurfaceId = 0; + return this; + } + + /** + * 
+     * NMNBNLMAJGC cur_surface_effect = 6;
+     *
+ * + * optional uint32 cur_surface_id = 3; + * @return the curSurfaceId + */ + public int getCurSurfaceId() { + return curSurfaceId; + } + + /** + * 
+     * NMNBNLMAJGC cur_surface_effect = 6;
+     *
+ * + * optional uint32 cur_surface_id = 3; + * @param value the curSurfaceId to set + * @return this + */ + public ChessRogueNousDice setCurSurfaceId(final int value) { + bitField0_ |= 0x00000004; + curSurfaceId = value; + return this; + } + + /** + * 
+     *  1
+     *
+ * + * optional uint32 KCFGDMFGIAN = 4; + * @return whether the kCFGDMFGIAN field is set + */ + public boolean hasKCFGDMFGIAN() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * 
+     *  1
+     *
+ * + * optional uint32 KCFGDMFGIAN = 4; + * @return this + */ + public ChessRogueNousDice clearKCFGDMFGIAN() { + bitField0_ &= ~0x00000008; + kCFGDMFGIAN = 0; + return this; + } + + /** + * 
+     *  1
+     *
+ * + * optional uint32 KCFGDMFGIAN = 4; + * @return the kCFGDMFGIAN + */ + public int getKCFGDMFGIAN() { + return kCFGDMFGIAN; + } + + /** + * 
+     *  1
+     *
+ * + * optional uint32 KCFGDMFGIAN = 4; + * @param value the kCFGDMFGIAN to set + * @return this + */ + public ChessRogueNousDice setKCFGDMFGIAN(final int value) { + bitField0_ |= 0x00000008; + kCFGDMFGIAN = value; + return this; + } + + /** + * 
+     *  10
+     *
+ * + * optional uint32 HIJBOPMGBAP = 5; + * @return whether the hIJBOPMGBAP field is set + */ + public boolean hasHIJBOPMGBAP() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * 
+     *  10
+     *
+ * + * optional uint32 HIJBOPMGBAP = 5; + * @return this + */ + public ChessRogueNousDice clearHIJBOPMGBAP() { + bitField0_ &= ~0x00000010; + hIJBOPMGBAP = 0; + return this; + } + + /** + * 
+     *  10
+     *
+ * + * optional uint32 HIJBOPMGBAP = 5; + * @return the hIJBOPMGBAP + */ + public int getHIJBOPMGBAP() { + return hIJBOPMGBAP; + } + + /** + * 
+     *  10
+     *
+ * + * optional uint32 HIJBOPMGBAP = 5; + * @param value the hIJBOPMGBAP to set + * @return this + */ + public ChessRogueNousDice setHIJBOPMGBAP(final int value) { + bitField0_ |= 0x00000010; + hIJBOPMGBAP = value; + return this; + } + + /** + * 
+     *  1
+     *
+ * + * optional uint32 GFGCPJOHMEL = 9; + * @return whether the gFGCPJOHMEL field is set + */ + public boolean hasGFGCPJOHMEL() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * 
+     *  1
+     *
+ * + * optional uint32 GFGCPJOHMEL = 9; + * @return this + */ + public ChessRogueNousDice clearGFGCPJOHMEL() { + bitField0_ &= ~0x00000020; + gFGCPJOHMEL = 0; + return this; + } + + /** + * 
+     *  1
+     *
+ * + * optional uint32 GFGCPJOHMEL = 9; + * @return the gFGCPJOHMEL + */ + public int getGFGCPJOHMEL() { + return gFGCPJOHMEL; + } + + /** + * 
+     *  1
+     *
+ * + * optional uint32 GFGCPJOHMEL = 9; + * @param value the gFGCPJOHMEL to set + * @return this + */ + public ChessRogueNousDice setGFGCPJOHMEL(final int value) { + bitField0_ |= 0x00000020; + gFGCPJOHMEL = value; + return this; + } + + /** + * optional uint32 cur_surface_index = 13; + * @return whether the curSurfaceIndex field is set + */ + public boolean hasCurSurfaceIndex() { + return (bitField0_ & 0x00000040) != 0; + } + + /** + * optional uint32 cur_surface_index = 13; + * @return this + */ + public ChessRogueNousDice clearCurSurfaceIndex() { + bitField0_ &= ~0x00000040; + curSurfaceIndex = 0; + return this; + } + + /** + * optional uint32 cur_surface_index = 13; + * @return the curSurfaceIndex + */ + public int getCurSurfaceIndex() { + return curSurfaceIndex; + } + + /** + * optional uint32 cur_surface_index = 13; + * @param value the curSurfaceIndex to set + * @return this + */ + public ChessRogueNousDice setCurSurfaceIndex(final int value) { + bitField0_ |= 0x00000040; + curSurfaceIndex = value; + return this; + } + + /** + * 
+     *  idk
+     *
+ * + * optional uint32 dice_branch_id_remote = 14; + * @return whether the diceBranchIdRemote field is set + */ + public boolean hasDiceBranchIdRemote() { + return (bitField0_ & 0x00000080) != 0; + } + + /** + * 
+     *  idk
+     *
+ * + * optional uint32 dice_branch_id_remote = 14; + * @return this + */ + public ChessRogueNousDice clearDiceBranchIdRemote() { + bitField0_ &= ~0x00000080; + diceBranchIdRemote = 0; + return this; + } + + /** + * 
+     *  idk
+     *
+ * + * optional uint32 dice_branch_id_remote = 14; + * @return the diceBranchIdRemote + */ + public int getDiceBranchIdRemote() { + return diceBranchIdRemote; + } + + /** + * 
+     *  idk
+     *
+ * + * optional uint32 dice_branch_id_remote = 14; + * @param value the diceBranchIdRemote to set + * @return this + */ + public ChessRogueNousDice setDiceBranchIdRemote(final int value) { + bitField0_ |= 0x00000080; + diceBranchIdRemote = value; + return this; + } + + /** + * 
+     * sint32 PAOHKKNCNCD = 625;
+     *
+ * + * optional bool BDENADDOCAC = 10; + * @return whether the bDENADDOCAC field is set + */ + public boolean hasBDENADDOCAC() { + return (bitField0_ & 0x00000100) != 0; + } + + /** + * 
+     * sint32 PAOHKKNCNCD = 625;
+     *
+ * + * optional bool BDENADDOCAC = 10; + * @return this + */ + public ChessRogueNousDice clearBDENADDOCAC() { + bitField0_ &= ~0x00000100; + bDENADDOCAC = false; + return this; + } + + /** + * 
+     * sint32 PAOHKKNCNCD = 625;
+     *
+ * + * optional bool BDENADDOCAC = 10; + * @return the bDENADDOCAC + */ + public boolean getBDENADDOCAC() { + return bDENADDOCAC; + } + + /** + * 
+     * sint32 PAOHKKNCNCD = 625;
+     *
+ * + * optional bool BDENADDOCAC = 10; + * @param value the bDENADDOCAC to set + * @return this + */ + public ChessRogueNousDice setBDENADDOCAC(final boolean value) { + bitField0_ |= 0x00000100; + bDENADDOCAC = value; + return this; + } + + /** + * 
+     * NMNBNLMAJGC POHKHEGDOHO = 343;  // guess its about modifier
+     *
+ * + * optional bool CHGLMLDAMJH = 1185; + * @return whether the cHGLMLDAMJH field is set + */ + public boolean hasCHGLMLDAMJH() { + return (bitField0_ & 0x00000200) != 0; + } + + /** + * 
+     * NMNBNLMAJGC POHKHEGDOHO = 343;  // guess its about modifier
+     *
+ * + * optional bool CHGLMLDAMJH = 1185; + * @return this + */ + public ChessRogueNousDice clearCHGLMLDAMJH() { + bitField0_ &= ~0x00000200; + cHGLMLDAMJH = false; + return this; + } + + /** + * 
+     * NMNBNLMAJGC POHKHEGDOHO = 343;  // guess its about modifier
+     *
+ * + * optional bool CHGLMLDAMJH = 1185; + * @return the cHGLMLDAMJH + */ + public boolean getCHGLMLDAMJH() { + return cHGLMLDAMJH; + } + + /** + * 
+     * NMNBNLMAJGC POHKHEGDOHO = 343;  // guess its about modifier
+     *
+ * + * optional bool CHGLMLDAMJH = 1185; + * @param value the cHGLMLDAMJH to set + * @return this + */ + public ChessRogueNousDice setCHGLMLDAMJH(final boolean value) { + bitField0_ |= 0x00000200; + cHGLMLDAMJH = value; + return this; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 208; + * @return whether the diceInfo field is set + */ + public boolean hasDiceInfo() { + return (bitField0_ & 0x00000400) != 0; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 208; + * @return this + */ + public ChessRogueNousDice clearDiceInfo() { + bitField0_ &= ~0x00000400; + diceInfo.clear(); + return this; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 208; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableDiceInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo getDiceInfo() { + return diceInfo; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 208; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo getMutableDiceInfo() { + bitField0_ |= 0x00000400; + return diceInfo; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 208; + * @param value the diceInfo to set + * @return this + */ + public ChessRogueNousDice setDiceInfo( + final ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo value) { + bitField0_ |= 0x00000400; + diceInfo.copyFrom(value); + return this; + } + + /** + * repeated uint32 NOGJMMEDGLL = 833; + * @return whether the nOGJMMEDGLL field is set + */ + public boolean hasNOGJMMEDGLL() { + return (bitField0_ & 0x00000800) != 0; + } + + /** + * repeated uint32 NOGJMMEDGLL = 833; + * @return this + */ + public ChessRogueNousDice clearNOGJMMEDGLL() { + bitField0_ &= ~0x00000800; + nOGJMMEDGLL.clear(); + return this; + } + + /** + * repeated uint32 NOGJMMEDGLL = 833; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableNOGJMMEDGLL()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getNOGJMMEDGLL() { + return nOGJMMEDGLL; + } + + /** + * repeated uint32 NOGJMMEDGLL = 833; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableNOGJMMEDGLL() { + bitField0_ |= 0x00000800; + return nOGJMMEDGLL; + } + + /** + * repeated uint32 NOGJMMEDGLL = 833; + * @param value the nOGJMMEDGLL to add + * @return this + */ + public ChessRogueNousDice addNOGJMMEDGLL(final int value) { + bitField0_ |= 0x00000800; + nOGJMMEDGLL.add(value); + return this; + } + + /** + * repeated uint32 NOGJMMEDGLL = 833; + * @param values the nOGJMMEDGLL to add + * @return this + */ + public ChessRogueNousDice addAllNOGJMMEDGLL(final int... values) { + bitField0_ |= 0x00000800; + nOGJMMEDGLL.addAll(values); + return this; + } + + @Override + public ChessRogueNousDice copyFrom(final ChessRogueNousDice other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + diceBranchId = other.diceBranchId; + nDJBBOEJOEH = other.nDJBBOEJOEH; + curSurfaceId = other.curSurfaceId; + kCFGDMFGIAN = other.kCFGDMFGIAN; + hIJBOPMGBAP = other.hIJBOPMGBAP; + gFGCPJOHMEL = other.gFGCPJOHMEL; + curSurfaceIndex = other.curSurfaceIndex; + diceBranchIdRemote = other.diceBranchIdRemote; + bDENADDOCAC = other.bDENADDOCAC; + cHGLMLDAMJH = other.cHGLMLDAMJH; + diceInfo.copyFrom(other.diceInfo); + nOGJMMEDGLL.copyFrom(other.nOGJMMEDGLL); + } + return this; + } + + @Override + public ChessRogueNousDice mergeFrom(final ChessRogueNousDice other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasDiceBranchId()) { + setDiceBranchId(other.diceBranchId); + } + if (other.hasNDJBBOEJOEH()) { + setNDJBBOEJOEH(other.nDJBBOEJOEH); + } + if (other.hasCurSurfaceId()) { + setCurSurfaceId(other.curSurfaceId); + } + if (other.hasKCFGDMFGIAN()) { + setKCFGDMFGIAN(other.kCFGDMFGIAN); + } + if (other.hasHIJBOPMGBAP()) { + setHIJBOPMGBAP(other.hIJBOPMGBAP); + } + if (other.hasGFGCPJOHMEL()) { + setGFGCPJOHMEL(other.gFGCPJOHMEL); + } + if (other.hasCurSurfaceIndex()) { + setCurSurfaceIndex(other.curSurfaceIndex); + } + if (other.hasDiceBranchIdRemote()) { + setDiceBranchIdRemote(other.diceBranchIdRemote); + } + if (other.hasBDENADDOCAC()) { + setBDENADDOCAC(other.bDENADDOCAC); + } + if (other.hasCHGLMLDAMJH()) { + setCHGLMLDAMJH(other.cHGLMLDAMJH); + } + if (other.hasDiceInfo()) { + getMutableDiceInfo().mergeFrom(other.diceInfo); + } + if (other.hasNOGJMMEDGLL()) { + getMutableNOGJMMEDGLL().addAll(other.nOGJMMEDGLL); + } + return this; + } + + @Override + public ChessRogueNousDice clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + diceBranchId = 0; + nDJBBOEJOEH = 0; + curSurfaceId = 0; + kCFGDMFGIAN = 0; + hIJBOPMGBAP = 0; + gFGCPJOHMEL = 0; + curSurfaceIndex = 0; + diceBranchIdRemote = 0; + bDENADDOCAC = false; + cHGLMLDAMJH = false; + diceInfo.clear(); + nOGJMMEDGLL.clear(); + return this; + } + + @Override + public ChessRogueNousDice clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + diceInfo.clearQuick(); + nOGJMMEDGLL.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueNousDice)) { + return false; + } + ChessRogueNousDice other = (ChessRogueNousDice) o; + return bitField0_ == other.bitField0_ + && (!hasDiceBranchId() || diceBranchId == other.diceBranchId) + && (!hasNDJBBOEJOEH() || nDJBBOEJOEH == other.nDJBBOEJOEH) + && (!hasCurSurfaceId() || curSurfaceId == other.curSurfaceId) + && (!hasKCFGDMFGIAN() || kCFGDMFGIAN == other.kCFGDMFGIAN) + && (!hasHIJBOPMGBAP() || hIJBOPMGBAP == other.hIJBOPMGBAP) + && (!hasGFGCPJOHMEL() || gFGCPJOHMEL == other.gFGCPJOHMEL) + && (!hasCurSurfaceIndex() || curSurfaceIndex == other.curSurfaceIndex) + && (!hasDiceBranchIdRemote() || diceBranchIdRemote == other.diceBranchIdRemote) + && (!hasBDENADDOCAC() || bDENADDOCAC == other.bDENADDOCAC) + && (!hasCHGLMLDAMJH() || cHGLMLDAMJH == other.cHGLMLDAMJH) + && (!hasDiceInfo() || diceInfo.equals(other.diceInfo)) + && (!hasNOGJMMEDGLL() || nOGJMMEDGLL.equals(other.nOGJMMEDGLL)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(diceBranchId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(nDJBBOEJOEH); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(curSurfaceId); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(kCFGDMFGIAN); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawByte((byte) 40); + output.writeUInt32NoTag(hIJBOPMGBAP); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRawByte((byte) 72); + output.writeUInt32NoTag(gFGCPJOHMEL); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeRawByte((byte) 104); + output.writeUInt32NoTag(curSurfaceIndex); + } + if ((bitField0_ & 0x00000080) != 0) { + output.writeRawByte((byte) 112); + output.writeUInt32NoTag(diceBranchIdRemote); + } + if ((bitField0_ & 0x00000100) != 0) { + output.writeRawByte((byte) 80); + output.writeBoolNoTag(bDENADDOCAC); + } + if ((bitField0_ & 0x00000200) != 0) { + output.writeRawLittleEndian16((short) 19080); + output.writeBoolNoTag(cHGLMLDAMJH); + } + if ((bitField0_ & 0x00000400) != 0) { + output.writeRawLittleEndian16((short) 3458); + output.writeMessageNoTag(diceInfo); + } + if ((bitField0_ & 0x00000800) != 0) { + for (int i = 0; i < nOGJMMEDGLL.length(); i++) { + output.writeRawLittleEndian16((short) 13448); + output.writeUInt32NoTag(nOGJMMEDGLL.array()[i]); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(diceBranchId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(nDJBBOEJOEH); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(curSurfaceId); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(kCFGDMFGIAN); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(hIJBOPMGBAP); + } + if ((bitField0_ & 0x00000020) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(gFGCPJOHMEL); + } + if ((bitField0_ & 0x00000040) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(curSurfaceIndex); + } + if ((bitField0_ & 0x00000080) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(diceBranchIdRemote); + } + if ((bitField0_ & 0x00000100) != 0) { + size += 2; + } + if ((bitField0_ & 0x00000200) != 0) { + size += 3; + } + if ((bitField0_ & 0x00000400) != 0) { + size += 2 + ProtoSink.computeMessageSizeNoTag(diceInfo); + } + if ((bitField0_ & 0x00000800) != 0) { + size += (2 * nOGJMMEDGLL.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(nOGJMMEDGLL); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueNousDice mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // diceBranchId + diceBranchId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // nDJBBOEJOEH + nDJBBOEJOEH = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 24) { + break; + } + } + case 24: { + // curSurfaceId + curSurfaceId = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 32) { + break; + } + } + case 32: { + // kCFGDMFGIAN + kCFGDMFGIAN = input.readUInt32(); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 40) { + break; + } + } + case 40: { + // hIJBOPMGBAP + hIJBOPMGBAP = input.readUInt32(); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 72) { + break; + } + } + case 72: { + // gFGCPJOHMEL + gFGCPJOHMEL = input.readUInt32(); + bitField0_ |= 0x00000020; + tag = input.readTag(); + if (tag != 104) { + break; + } + } + case 104: { + // curSurfaceIndex + curSurfaceIndex = input.readUInt32(); + bitField0_ |= 0x00000040; + tag = input.readTag(); + if (tag != 112) { + break; + } + } + case 112: { + // diceBranchIdRemote + diceBranchIdRemote = input.readUInt32(); + bitField0_ |= 0x00000080; + tag = input.readTag(); + if (tag != 80) { + break; + } + } + case 80: { + // bDENADDOCAC + bDENADDOCAC = input.readBool(); + bitField0_ |= 0x00000100; + tag = input.readTag(); + if (tag != 9480) { + break; + } + } + case 9480: { + // cHGLMLDAMJH + cHGLMLDAMJH = input.readBool(); + bitField0_ |= 0x00000200; + tag = input.readTag(); + if (tag != 1666) { + break; + } + } + case 1666: { + // diceInfo + input.readMessage(diceInfo); + bitField0_ |= 0x00000400; + tag = input.readTag(); + if (tag != 6666) { + break; + } + } + case 6666: { + // nOGJMMEDGLL [packed=true] + input.readPackedUInt32(nOGJMMEDGLL, tag); + bitField0_ |= 0x00000800; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + case 6664: { + // nOGJMMEDGLL [packed=false] + tag = input.readRepeatedUInt32(nOGJMMEDGLL, tag); + bitField0_ |= 0x00000800; + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.diceBranchId, diceBranchId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.nDJBBOEJOEH, nDJBBOEJOEH); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.curSurfaceId, curSurfaceId); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeUInt32(FieldNames.kCFGDMFGIAN, kCFGDMFGIAN); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeUInt32(FieldNames.hIJBOPMGBAP, hIJBOPMGBAP); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeUInt32(FieldNames.gFGCPJOHMEL, gFGCPJOHMEL); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeUInt32(FieldNames.curSurfaceIndex, curSurfaceIndex); + } + if ((bitField0_ & 0x00000080) != 0) { + output.writeUInt32(FieldNames.diceBranchIdRemote, diceBranchIdRemote); + } + if ((bitField0_ & 0x00000100) != 0) { + output.writeBool(FieldNames.bDENADDOCAC, bDENADDOCAC); + } + if ((bitField0_ & 0x00000200) != 0) { + output.writeBool(FieldNames.cHGLMLDAMJH, cHGLMLDAMJH); + } + if ((bitField0_ & 0x00000400) != 0) { + output.writeMessage(FieldNames.diceInfo, diceInfo); + } + if ((bitField0_ & 0x00000800) != 0) { + output.writeRepeatedUInt32(FieldNames.nOGJMMEDGLL, nOGJMMEDGLL); + } + output.endObject(); + } + + @Override + public ChessRogueNousDice mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 216999716: + case 1050456640: { + if (input.isAtField(FieldNames.diceBranchId)) { + if (!input.trySkipNullValue()) { + diceBranchId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 320828690: { + if (input.isAtField(FieldNames.nDJBBOEJOEH)) { + if (!input.trySkipNullValue()) { + nDJBBOEJOEH = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1658805176: + case -1978690228: { + if (input.isAtField(FieldNames.curSurfaceId)) { + if (!input.trySkipNullValue()) { + curSurfaceId = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2095806643: { + if (input.isAtField(FieldNames.kCFGDMFGIAN)) { + if (!input.trySkipNullValue()) { + kCFGDMFGIAN = input.readUInt32(); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case 218596029: { + if (input.isAtField(FieldNames.hIJBOPMGBAP)) { + if (!input.trySkipNullValue()) { + hIJBOPMGBAP = input.readUInt32(); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1897943334: { + if (input.isAtField(FieldNames.gFGCPJOHMEL)) { + if (!input.trySkipNullValue()) { + gFGCPJOHMEL = input.readUInt32(); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } + case 429106821: + case 1265952513: { + if (input.isAtField(FieldNames.curSurfaceIndex)) { + if (!input.trySkipNullValue()) { + curSurfaceIndex = input.readUInt32(); + bitField0_ |= 0x00000040; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1925587082: + case 1293761317: { + if (input.isAtField(FieldNames.diceBranchIdRemote)) { + if (!input.trySkipNullValue()) { + diceBranchIdRemote = input.readUInt32(); + bitField0_ |= 0x00000080; + } + } else { + input.skipUnknownField(); + } + break; + } + case -907576788: { + if (input.isAtField(FieldNames.bDENADDOCAC)) { + if (!input.trySkipNullValue()) { + bDENADDOCAC = input.readBool(); + bitField0_ |= 0x00000100; + } + } else { + input.skipUnknownField(); + } + break; + } + case 287558437: { + if (input.isAtField(FieldNames.cHGLMLDAMJH)) { + if (!input.trySkipNullValue()) { + cHGLMLDAMJH = input.readBool(); + bitField0_ |= 0x00000200; + } + } else { + input.skipUnknownField(); + } + break; + } + case -184174347: + case -1394261434: { + if (input.isAtField(FieldNames.diceInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(diceInfo); + bitField0_ |= 0x00000400; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1459318404: { + if (input.isAtField(FieldNames.nOGJMMEDGLL)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(nOGJMMEDGLL); + bitField0_ |= 0x00000800; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueNousDice clone() { + return new ChessRogueNousDice().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueNousDice parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueNousDice(), data).checkInitialized(); + } + + public static ChessRogueNousDice parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousDice(), input).checkInitialized(); + } + + public static ChessRogueNousDice parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousDice(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueNousDice messages + */ + public static MessageFactory getFactory() { + return ChessRogueNousDiceFactory.INSTANCE; + } + + private enum ChessRogueNousDiceFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueNousDice create() { + return ChessRogueNousDice.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName diceBranchId = FieldName.forField("diceBranchId", "dice_branch_id"); + + static final FieldName nDJBBOEJOEH = FieldName.forField("NDJBBOEJOEH"); + + static final FieldName curSurfaceId = FieldName.forField("curSurfaceId", "cur_surface_id"); + + static final FieldName kCFGDMFGIAN = FieldName.forField("KCFGDMFGIAN"); + + static final FieldName hIJBOPMGBAP = FieldName.forField("HIJBOPMGBAP"); + + static final FieldName gFGCPJOHMEL = FieldName.forField("GFGCPJOHMEL"); + + static final FieldName curSurfaceIndex = FieldName.forField("curSurfaceIndex", "cur_surface_index"); + + static final FieldName diceBranchIdRemote = FieldName.forField("diceBranchIdRemote", "dice_branch_id_remote"); + + static final FieldName bDENADDOCAC = FieldName.forField("BDENADDOCAC"); + + static final FieldName cHGLMLDAMJH = FieldName.forField("CHGLMLDAMJH"); + + static final FieldName diceInfo = FieldName.forField("diceInfo", "dice_info"); + + static final FieldName nOGJMMEDGLL = FieldName.forField("NOGJMMEDGLL"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceSurfaceInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceSurfaceInfoOuterClass.java new file mode 100644 index 0000000..b51e5d2 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueNousDiceSurfaceInfoOuterClass.java @@ -0,0 +1,342 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueNousDiceSurfaceInfoOuterClass { + /** + * Protobuf type {@code ChessRogueNousDiceSurfaceInfo} + */ + public static final class ChessRogueNousDiceSurfaceInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 index = 5; + */ + private int index; + + /** + * optional uint32 dice_id = 9; + */ + private int diceId; + + private ChessRogueNousDiceSurfaceInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueNousDiceSurfaceInfo} + */ + public static ChessRogueNousDiceSurfaceInfo newInstance() { + return new ChessRogueNousDiceSurfaceInfo(); + } + + /** + * optional uint32 index = 5; + * @return whether the index field is set + */ + public boolean hasIndex() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 index = 5; + * @return this + */ + public ChessRogueNousDiceSurfaceInfo clearIndex() { + bitField0_ &= ~0x00000001; + index = 0; + return this; + } + + /** + * optional uint32 index = 5; + * @return the index + */ + public int getIndex() { + return index; + } + + /** + * optional uint32 index = 5; + * @param value the index to set + * @return this + */ + public ChessRogueNousDiceSurfaceInfo setIndex(final int value) { + bitField0_ |= 0x00000001; + index = value; + return this; + } + + /** + * optional uint32 dice_id = 9; + * @return whether the diceId field is set + */ + public boolean hasDiceId() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 dice_id = 9; + * @return this + */ + public ChessRogueNousDiceSurfaceInfo clearDiceId() { + bitField0_ &= ~0x00000002; + diceId = 0; + return this; + } + + /** + * optional uint32 dice_id = 9; + * @return the diceId + */ + public int getDiceId() { + return diceId; + } + + /** + * optional uint32 dice_id = 9; + * @param value the diceId to set + * @return this + */ + public ChessRogueNousDiceSurfaceInfo setDiceId(final int value) { + bitField0_ |= 0x00000002; + diceId = value; + return this; + } + + @Override + public ChessRogueNousDiceSurfaceInfo copyFrom(final ChessRogueNousDiceSurfaceInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + index = other.index; + diceId = other.diceId; + } + return this; + } + + @Override + public ChessRogueNousDiceSurfaceInfo mergeFrom(final ChessRogueNousDiceSurfaceInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasIndex()) { + setIndex(other.index); + } + if (other.hasDiceId()) { + setDiceId(other.diceId); + } + return this; + } + + @Override + public ChessRogueNousDiceSurfaceInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + index = 0; + diceId = 0; + return this; + } + + @Override + public ChessRogueNousDiceSurfaceInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueNousDiceSurfaceInfo)) { + return false; + } + ChessRogueNousDiceSurfaceInfo other = (ChessRogueNousDiceSurfaceInfo) o; + return bitField0_ == other.bitField0_ + && (!hasIndex() || index == other.index) + && (!hasDiceId() || diceId == other.diceId); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 40); + output.writeUInt32NoTag(index); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 72); + output.writeUInt32NoTag(diceId); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(index); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(diceId); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueNousDiceSurfaceInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 40: { + // index + index = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 72) { + break; + } + } + case 72: { + // diceId + diceId = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.index, index); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.diceId, diceId); + } + output.endObject(); + } + + @Override + public ChessRogueNousDiceSurfaceInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 100346066: { + if (input.isAtField(FieldNames.index)) { + if (!input.trySkipNullValue()) { + index = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1332033758: + case 1656647859: { + if (input.isAtField(FieldNames.diceId)) { + if (!input.trySkipNullValue()) { + diceId = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueNousDiceSurfaceInfo clone() { + return new ChessRogueNousDiceSurfaceInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueNousDiceSurfaceInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueNousDiceSurfaceInfo(), data).checkInitialized(); + } + + public static ChessRogueNousDiceSurfaceInfo parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousDiceSurfaceInfo(), input).checkInitialized(); + } + + public static ChessRogueNousDiceSurfaceInfo parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousDiceSurfaceInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueNousDiceSurfaceInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueNousDiceSurfaceInfoFactory.INSTANCE; + } + + private enum ChessRogueNousDiceSurfaceInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueNousDiceSurfaceInfo create() { + return ChessRogueNousDiceSurfaceInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName index = FieldName.forField("index"); + + static final FieldName diceId = FieldName.forField("diceId", "dice_id"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueNousEditDiceCsReqOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueNousEditDiceCsReqOuterClass.java new file mode 100644 index 0000000..bbbec87 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueNousEditDiceCsReqOuterClass.java @@ -0,0 +1,283 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueNousEditDiceCsReqOuterClass { + /** + * Protobuf type {@code ChessRogueNousEditDiceCsReq} + */ + public static final class ChessRogueNousEditDiceCsReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .ChessRogueNousDiceInfo dice_info = 12; + */ + private final ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo diceInfo = ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo.newInstance(); + + private ChessRogueNousEditDiceCsReq() { + } + + /** + * @return a new empty instance of {@code ChessRogueNousEditDiceCsReq} + */ + public static ChessRogueNousEditDiceCsReq newInstance() { + return new ChessRogueNousEditDiceCsReq(); + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 12; + * @return whether the diceInfo field is set + */ + public boolean hasDiceInfo() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 12; + * @return this + */ + public ChessRogueNousEditDiceCsReq clearDiceInfo() { + bitField0_ &= ~0x00000001; + diceInfo.clear(); + return this; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 12; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableDiceInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo getDiceInfo() { + return diceInfo; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 12; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo getMutableDiceInfo() { + bitField0_ |= 0x00000001; + return diceInfo; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 12; + * @param value the diceInfo to set + * @return this + */ + public ChessRogueNousEditDiceCsReq setDiceInfo( + final ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo value) { + bitField0_ |= 0x00000001; + diceInfo.copyFrom(value); + return this; + } + + @Override + public ChessRogueNousEditDiceCsReq copyFrom(final ChessRogueNousEditDiceCsReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + diceInfo.copyFrom(other.diceInfo); + } + return this; + } + + @Override + public ChessRogueNousEditDiceCsReq mergeFrom(final ChessRogueNousEditDiceCsReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasDiceInfo()) { + getMutableDiceInfo().mergeFrom(other.diceInfo); + } + return this; + } + + @Override + public ChessRogueNousEditDiceCsReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + diceInfo.clear(); + return this; + } + + @Override + public ChessRogueNousEditDiceCsReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + diceInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueNousEditDiceCsReq)) { + return false; + } + ChessRogueNousEditDiceCsReq other = (ChessRogueNousEditDiceCsReq) o; + return bitField0_ == other.bitField0_ + && (!hasDiceInfo() || diceInfo.equals(other.diceInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 98); + output.writeMessageNoTag(diceInfo); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(diceInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueNousEditDiceCsReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 98: { + // diceInfo + input.readMessage(diceInfo); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.diceInfo, diceInfo); + } + output.endObject(); + } + + @Override + public ChessRogueNousEditDiceCsReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -184174347: + case -1394261434: { + if (input.isAtField(FieldNames.diceInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(diceInfo); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueNousEditDiceCsReq clone() { + return new ChessRogueNousEditDiceCsReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueNousEditDiceCsReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueNousEditDiceCsReq(), data).checkInitialized(); + } + + public static ChessRogueNousEditDiceCsReq parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousEditDiceCsReq(), input).checkInitialized(); + } + + public static ChessRogueNousEditDiceCsReq parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousEditDiceCsReq(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueNousEditDiceCsReq messages + */ + public static MessageFactory getFactory() { + return ChessRogueNousEditDiceCsReqFactory.INSTANCE; + } + + private enum ChessRogueNousEditDiceCsReqFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueNousEditDiceCsReq create() { + return ChessRogueNousEditDiceCsReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName diceInfo = FieldName.forField("diceInfo", "dice_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueNousEditDiceScRspOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueNousEditDiceScRspOuterClass.java new file mode 100644 index 0000000..3e82e9d --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueNousEditDiceScRspOuterClass.java @@ -0,0 +1,363 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueNousEditDiceScRspOuterClass { + /** + * Protobuf type {@code ChessRogueNousEditDiceScRsp} + */ + public static final class ChessRogueNousEditDiceScRsp extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 retcode = 11; + */ + private int retcode; + + /** + * optional .ChessRogueNousDiceInfo dice_info = 13; + */ + private final ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo diceInfo = ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo.newInstance(); + + private ChessRogueNousEditDiceScRsp() { + } + + /** + * @return a new empty instance of {@code ChessRogueNousEditDiceScRsp} + */ + public static ChessRogueNousEditDiceScRsp newInstance() { + return new ChessRogueNousEditDiceScRsp(); + } + + /** + * optional uint32 retcode = 11; + * @return whether the retcode field is set + */ + public boolean hasRetcode() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 retcode = 11; + * @return this + */ + public ChessRogueNousEditDiceScRsp clearRetcode() { + bitField0_ &= ~0x00000001; + retcode = 0; + return this; + } + + /** + * optional uint32 retcode = 11; + * @return the retcode + */ + public int getRetcode() { + return retcode; + } + + /** + * optional uint32 retcode = 11; + * @param value the retcode to set + * @return this + */ + public ChessRogueNousEditDiceScRsp setRetcode(final int value) { + bitField0_ |= 0x00000001; + retcode = value; + return this; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 13; + * @return whether the diceInfo field is set + */ + public boolean hasDiceInfo() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 13; + * @return this + */ + public ChessRogueNousEditDiceScRsp clearDiceInfo() { + bitField0_ &= ~0x00000002; + diceInfo.clear(); + return this; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 13; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableDiceInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo getDiceInfo() { + return diceInfo; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 13; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo getMutableDiceInfo() { + bitField0_ |= 0x00000002; + return diceInfo; + } + + /** + * optional .ChessRogueNousDiceInfo dice_info = 13; + * @param value the diceInfo to set + * @return this + */ + public ChessRogueNousEditDiceScRsp setDiceInfo( + final ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo value) { + bitField0_ |= 0x00000002; + diceInfo.copyFrom(value); + return this; + } + + @Override + public ChessRogueNousEditDiceScRsp copyFrom(final ChessRogueNousEditDiceScRsp other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + retcode = other.retcode; + diceInfo.copyFrom(other.diceInfo); + } + return this; + } + + @Override + public ChessRogueNousEditDiceScRsp mergeFrom(final ChessRogueNousEditDiceScRsp other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRetcode()) { + setRetcode(other.retcode); + } + if (other.hasDiceInfo()) { + getMutableDiceInfo().mergeFrom(other.diceInfo); + } + return this; + } + + @Override + public ChessRogueNousEditDiceScRsp clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + retcode = 0; + diceInfo.clear(); + return this; + } + + @Override + public ChessRogueNousEditDiceScRsp clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + diceInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueNousEditDiceScRsp)) { + return false; + } + ChessRogueNousEditDiceScRsp other = (ChessRogueNousEditDiceScRsp) o; + return bitField0_ == other.bitField0_ + && (!hasRetcode() || retcode == other.retcode) + && (!hasDiceInfo() || diceInfo.equals(other.diceInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 88); + output.writeUInt32NoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 106); + output.writeMessageNoTag(diceInfo); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(diceInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueNousEditDiceScRsp mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 88: { + // retcode + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 106) { + break; + } + } + case 106: { + // diceInfo + input.readMessage(diceInfo); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.retcode, retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeMessage(FieldNames.diceInfo, diceInfo); + } + output.endObject(); + } + + @Override + public ChessRogueNousEditDiceScRsp mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1097936398: { + if (input.isAtField(FieldNames.retcode)) { + if (!input.trySkipNullValue()) { + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -184174347: + case -1394261434: { + if (input.isAtField(FieldNames.diceInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(diceInfo); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueNousEditDiceScRsp clone() { + return new ChessRogueNousEditDiceScRsp().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueNousEditDiceScRsp parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueNousEditDiceScRsp(), data).checkInitialized(); + } + + public static ChessRogueNousEditDiceScRsp parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousEditDiceScRsp(), input).checkInitialized(); + } + + public static ChessRogueNousEditDiceScRsp parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousEditDiceScRsp(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueNousEditDiceScRsp messages + */ + public static MessageFactory getFactory() { + return ChessRogueNousEditDiceScRspFactory.INSTANCE; + } + + private enum ChessRogueNousEditDiceScRspFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueNousEditDiceScRsp create() { + return ChessRogueNousEditDiceScRsp.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName retcode = FieldName.forField("retcode"); + + static final FieldName diceInfo = FieldName.forField("diceInfo", "dice_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueNousMainStoryInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueNousMainStoryInfoOuterClass.java new file mode 100644 index 0000000..064402a --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueNousMainStoryInfoOuterClass.java @@ -0,0 +1,361 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueNousMainStoryInfoOuterClass { + /** + * Protobuf type {@code ChessRogueNousMainStoryInfo} + */ + public static final class ChessRogueNousMainStoryInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 story_id = 10; + */ + private int storyId; + + /** + * 
+     *  2 finished
+     *
+ * + * optional uint32 status = 11; + */ + private int status; + + private ChessRogueNousMainStoryInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueNousMainStoryInfo} + */ + public static ChessRogueNousMainStoryInfo newInstance() { + return new ChessRogueNousMainStoryInfo(); + } + + /** + * optional uint32 story_id = 10; + * @return whether the storyId field is set + */ + public boolean hasStoryId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 story_id = 10; + * @return this + */ + public ChessRogueNousMainStoryInfo clearStoryId() { + bitField0_ &= ~0x00000001; + storyId = 0; + return this; + } + + /** + * optional uint32 story_id = 10; + * @return the storyId + */ + public int getStoryId() { + return storyId; + } + + /** + * optional uint32 story_id = 10; + * @param value the storyId to set + * @return this + */ + public ChessRogueNousMainStoryInfo setStoryId(final int value) { + bitField0_ |= 0x00000001; + storyId = value; + return this; + } + + /** + * 
+     *  2 finished
+     *
+ * + * optional uint32 status = 11; + * @return whether the status field is set + */ + public boolean hasStatus() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * 
+     *  2 finished
+     *
+ * + * optional uint32 status = 11; + * @return this + */ + public ChessRogueNousMainStoryInfo clearStatus() { + bitField0_ &= ~0x00000002; + status = 0; + return this; + } + + /** + * 
+     *  2 finished
+     *
+ * + * optional uint32 status = 11; + * @return the status + */ + public int getStatus() { + return status; + } + + /** + * 
+     *  2 finished
+     *
+ * + * optional uint32 status = 11; + * @param value the status to set + * @return this + */ + public ChessRogueNousMainStoryInfo setStatus(final int value) { + bitField0_ |= 0x00000002; + status = value; + return this; + } + + @Override + public ChessRogueNousMainStoryInfo copyFrom(final ChessRogueNousMainStoryInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + storyId = other.storyId; + status = other.status; + } + return this; + } + + @Override + public ChessRogueNousMainStoryInfo mergeFrom(final ChessRogueNousMainStoryInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasStoryId()) { + setStoryId(other.storyId); + } + if (other.hasStatus()) { + setStatus(other.status); + } + return this; + } + + @Override + public ChessRogueNousMainStoryInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + storyId = 0; + status = 0; + return this; + } + + @Override + public ChessRogueNousMainStoryInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueNousMainStoryInfo)) { + return false; + } + ChessRogueNousMainStoryInfo other = (ChessRogueNousMainStoryInfo) o; + return bitField0_ == other.bitField0_ + && (!hasStoryId() || storyId == other.storyId) + && (!hasStatus() || status == other.status); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 80); + output.writeUInt32NoTag(storyId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 88); + output.writeUInt32NoTag(status); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(storyId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(status); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueNousMainStoryInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 80: { + // storyId + storyId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 88) { + break; + } + } + case 88: { + // status + status = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.storyId, storyId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.status, status); + } + output.endObject(); + } + + @Override + public ChessRogueNousMainStoryInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1884251920: + case 1717754021: { + if (input.isAtField(FieldNames.storyId)) { + if (!input.trySkipNullValue()) { + storyId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -892481550: { + if (input.isAtField(FieldNames.status)) { + if (!input.trySkipNullValue()) { + status = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueNousMainStoryInfo clone() { + return new ChessRogueNousMainStoryInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueNousMainStoryInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueNousMainStoryInfo(), data).checkInitialized(); + } + + public static ChessRogueNousMainStoryInfo parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousMainStoryInfo(), input).checkInitialized(); + } + + public static ChessRogueNousMainStoryInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousMainStoryInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueNousMainStoryInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueNousMainStoryInfoFactory.INSTANCE; + } + + private enum ChessRogueNousMainStoryInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueNousMainStoryInfo create() { + return ChessRogueNousMainStoryInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName storyId = FieldName.forField("storyId", "story_id"); + + static final FieldName status = FieldName.forField("status"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueNousQueryInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueNousQueryInfoOuterClass.java new file mode 100644 index 0000000..ce722fa --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueNousQueryInfoOuterClass.java @@ -0,0 +1,559 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedInt; + +public final class ChessRogueNousQueryInfoOuterClass { + /** + * Protobuf type {@code ChessRogueNousQueryInfo} + */ + public static final class ChessRogueNousQueryInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * 
+     * MAKPHMAOCHI talent_info = 1;
+     * OFHBFINPHAG JNAGMIALOII = 6;
+     * CLIDPGPDFGK IKGPADCBBPN = 4;
+     *
+ * + * optional .ChessRogueQuery query_info = 13; + */ + private final ChessRogueQueryOuterClass.ChessRogueQuery queryInfo = ChessRogueQueryOuterClass.ChessRogueQuery.newInstance(); + + /** + * repeated uint32 PHJAFGJHOCO = 7; + */ + private final RepeatedInt pHJAFGJHOCO = RepeatedInt.newEmptyInstance(); + + /** + * repeated uint32 CMNHLKGFKOP = 8; + */ + private final RepeatedInt cMNHLKGFKOP = RepeatedInt.newEmptyInstance(); + + private ChessRogueNousQueryInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueNousQueryInfo} + */ + public static ChessRogueNousQueryInfo newInstance() { + return new ChessRogueNousQueryInfo(); + } + + /** + * 
+     * MAKPHMAOCHI talent_info = 1;
+     * OFHBFINPHAG JNAGMIALOII = 6;
+     * CLIDPGPDFGK IKGPADCBBPN = 4;
+     *
+ * + * optional .ChessRogueQuery query_info = 13; + * @return whether the queryInfo field is set + */ + public boolean hasQueryInfo() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * 
+     * MAKPHMAOCHI talent_info = 1;
+     * OFHBFINPHAG JNAGMIALOII = 6;
+     * CLIDPGPDFGK IKGPADCBBPN = 4;
+     *
+ * + * optional .ChessRogueQuery query_info = 13; + * @return this + */ + public ChessRogueNousQueryInfo clearQueryInfo() { + bitField0_ &= ~0x00000001; + queryInfo.clear(); + return this; + } + + /** + * 
+     * MAKPHMAOCHI talent_info = 1;
+     * OFHBFINPHAG JNAGMIALOII = 6;
+     * CLIDPGPDFGK IKGPADCBBPN = 4;
+     *
+ * + * optional .ChessRogueQuery query_info = 13; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableQueryInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueQueryOuterClass.ChessRogueQuery getQueryInfo() { + return queryInfo; + } + + /** + * 
+     * MAKPHMAOCHI talent_info = 1;
+     * OFHBFINPHAG JNAGMIALOII = 6;
+     * CLIDPGPDFGK IKGPADCBBPN = 4;
+     *
+ * + * optional .ChessRogueQuery query_info = 13; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueQueryOuterClass.ChessRogueQuery getMutableQueryInfo() { + bitField0_ |= 0x00000001; + return queryInfo; + } + + /** + * 
+     * MAKPHMAOCHI talent_info = 1;
+     * OFHBFINPHAG JNAGMIALOII = 6;
+     * CLIDPGPDFGK IKGPADCBBPN = 4;
+     *
+ * + * optional .ChessRogueQuery query_info = 13; + * @param value the queryInfo to set + * @return this + */ + public ChessRogueNousQueryInfo setQueryInfo( + final ChessRogueQueryOuterClass.ChessRogueQuery value) { + bitField0_ |= 0x00000001; + queryInfo.copyFrom(value); + return this; + } + + /** + * repeated uint32 PHJAFGJHOCO = 7; + * @return whether the pHJAFGJHOCO field is set + */ + public boolean hasPHJAFGJHOCO() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated uint32 PHJAFGJHOCO = 7; + * @return this + */ + public ChessRogueNousQueryInfo clearPHJAFGJHOCO() { + bitField0_ &= ~0x00000002; + pHJAFGJHOCO.clear(); + return this; + } + + /** + * repeated uint32 PHJAFGJHOCO = 7; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutablePHJAFGJHOCO()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getPHJAFGJHOCO() { + return pHJAFGJHOCO; + } + + /** + * repeated uint32 PHJAFGJHOCO = 7; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutablePHJAFGJHOCO() { + bitField0_ |= 0x00000002; + return pHJAFGJHOCO; + } + + /** + * repeated uint32 PHJAFGJHOCO = 7; + * @param value the pHJAFGJHOCO to add + * @return this + */ + public ChessRogueNousQueryInfo addPHJAFGJHOCO(final int value) { + bitField0_ |= 0x00000002; + pHJAFGJHOCO.add(value); + return this; + } + + /** + * repeated uint32 PHJAFGJHOCO = 7; + * @param values the pHJAFGJHOCO to add + * @return this + */ + public ChessRogueNousQueryInfo addAllPHJAFGJHOCO(final int... values) { + bitField0_ |= 0x00000002; + pHJAFGJHOCO.addAll(values); + return this; + } + + /** + * repeated uint32 CMNHLKGFKOP = 8; + * @return whether the cMNHLKGFKOP field is set + */ + public boolean hasCMNHLKGFKOP() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * repeated uint32 CMNHLKGFKOP = 8; + * @return this + */ + public ChessRogueNousQueryInfo clearCMNHLKGFKOP() { + bitField0_ &= ~0x00000004; + cMNHLKGFKOP.clear(); + return this; + } + + /** + * repeated uint32 CMNHLKGFKOP = 8; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableCMNHLKGFKOP()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getCMNHLKGFKOP() { + return cMNHLKGFKOP; + } + + /** + * repeated uint32 CMNHLKGFKOP = 8; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableCMNHLKGFKOP() { + bitField0_ |= 0x00000004; + return cMNHLKGFKOP; + } + + /** + * repeated uint32 CMNHLKGFKOP = 8; + * @param value the cMNHLKGFKOP to add + * @return this + */ + public ChessRogueNousQueryInfo addCMNHLKGFKOP(final int value) { + bitField0_ |= 0x00000004; + cMNHLKGFKOP.add(value); + return this; + } + + /** + * repeated uint32 CMNHLKGFKOP = 8; + * @param values the cMNHLKGFKOP to add + * @return this + */ + public ChessRogueNousQueryInfo addAllCMNHLKGFKOP(final int... values) { + bitField0_ |= 0x00000004; + cMNHLKGFKOP.addAll(values); + return this; + } + + @Override + public ChessRogueNousQueryInfo copyFrom(final ChessRogueNousQueryInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + queryInfo.copyFrom(other.queryInfo); + pHJAFGJHOCO.copyFrom(other.pHJAFGJHOCO); + cMNHLKGFKOP.copyFrom(other.cMNHLKGFKOP); + } + return this; + } + + @Override + public ChessRogueNousQueryInfo mergeFrom(final ChessRogueNousQueryInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasQueryInfo()) { + getMutableQueryInfo().mergeFrom(other.queryInfo); + } + if (other.hasPHJAFGJHOCO()) { + getMutablePHJAFGJHOCO().addAll(other.pHJAFGJHOCO); + } + if (other.hasCMNHLKGFKOP()) { + getMutableCMNHLKGFKOP().addAll(other.cMNHLKGFKOP); + } + return this; + } + + @Override + public ChessRogueNousQueryInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + queryInfo.clear(); + pHJAFGJHOCO.clear(); + cMNHLKGFKOP.clear(); + return this; + } + + @Override + public ChessRogueNousQueryInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + queryInfo.clearQuick(); + pHJAFGJHOCO.clear(); + cMNHLKGFKOP.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueNousQueryInfo)) { + return false; + } + ChessRogueNousQueryInfo other = (ChessRogueNousQueryInfo) o; + return bitField0_ == other.bitField0_ + && (!hasQueryInfo() || queryInfo.equals(other.queryInfo)) + && (!hasPHJAFGJHOCO() || pHJAFGJHOCO.equals(other.pHJAFGJHOCO)) + && (!hasCMNHLKGFKOP() || cMNHLKGFKOP.equals(other.cMNHLKGFKOP)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 106); + output.writeMessageNoTag(queryInfo); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < pHJAFGJHOCO.length(); i++) { + output.writeRawByte((byte) 56); + output.writeUInt32NoTag(pHJAFGJHOCO.array()[i]); + } + } + if ((bitField0_ & 0x00000004) != 0) { + for (int i = 0; i < cMNHLKGFKOP.length(); i++) { + output.writeRawByte((byte) 64); + output.writeUInt32NoTag(cMNHLKGFKOP.array()[i]); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(queryInfo); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * pHJAFGJHOCO.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(pHJAFGJHOCO); + } + if ((bitField0_ & 0x00000004) != 0) { + size += (1 * cMNHLKGFKOP.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(cMNHLKGFKOP); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueNousQueryInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 106: { + // queryInfo + input.readMessage(queryInfo); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 58) { + break; + } + } + case 58: { + // pHJAFGJHOCO [packed=true] + input.readPackedUInt32(pHJAFGJHOCO, tag); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 66) { + break; + } + } + case 66: { + // cMNHLKGFKOP [packed=true] + input.readPackedUInt32(cMNHLKGFKOP, tag); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + case 56: { + // pHJAFGJHOCO [packed=false] + tag = input.readRepeatedUInt32(pHJAFGJHOCO, tag); + bitField0_ |= 0x00000002; + break; + } + case 64: { + // cMNHLKGFKOP [packed=false] + tag = input.readRepeatedUInt32(cMNHLKGFKOP, tag); + bitField0_ |= 0x00000004; + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.queryInfo, queryInfo); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedUInt32(FieldNames.pHJAFGJHOCO, pHJAFGJHOCO); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRepeatedUInt32(FieldNames.cMNHLKGFKOP, cMNHLKGFKOP); + } + output.endObject(); + } + + @Override + public ChessRogueNousQueryInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1807200874: + case -168476219: { + if (input.isAtField(FieldNames.queryInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(queryInfo); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1818568397: { + if (input.isAtField(FieldNames.pHJAFGJHOCO)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(pHJAFGJHOCO); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 243189738: { + if (input.isAtField(FieldNames.cMNHLKGFKOP)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(cMNHLKGFKOP); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueNousQueryInfo clone() { + return new ChessRogueNousQueryInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueNousQueryInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueNousQueryInfo(), data).checkInitialized(); + } + + public static ChessRogueNousQueryInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousQueryInfo(), input).checkInitialized(); + } + + public static ChessRogueNousQueryInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousQueryInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueNousQueryInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueNousQueryInfoFactory.INSTANCE; + } + + private enum ChessRogueNousQueryInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueNousQueryInfo create() { + return ChessRogueNousQueryInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName queryInfo = FieldName.forField("queryInfo", "query_info"); + + static final FieldName pHJAFGJHOCO = FieldName.forField("PHJAFGJHOCO"); + + static final FieldName cMNHLKGFKOP = FieldName.forField("CMNHLKGFKOP"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueNousStoryInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueNousStoryInfoOuterClass.java new file mode 100644 index 0000000..9ad26f3 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueNousStoryInfoOuterClass.java @@ -0,0 +1,942 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedInt; + +public final class ChessRogueNousStoryInfoOuterClass { + /** + * Protobuf type {@code ChessRogueNousStoryInfo} + */ + public static final class ChessRogueNousStoryInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 story_id = 3; + */ + private int storyId; + + /** + * optional uint32 sub_story_id = 7; + */ + private int subStoryId; + + /** + * optional uint32 ACLGLHEFFON = 14; + */ + private int aCLGLHEFFON; + + /** + * optional bool CKEKKMGIHKJ = 8; + */ + private boolean cKEKKMGIHKJ; + + /** + * optional bool AHOJIDMLFPE = 12; + */ + private boolean aHOJIDMLFPE; + + /** + * repeated uint32 HCPCJBDBBGC = 1; + */ + private final RepeatedInt hCPCJBDBBGC = RepeatedInt.newEmptyInstance(); + + /** + * repeated uint32 CMHLEEKNFKH = 4; + */ + private final RepeatedInt cMHLEEKNFKH = RepeatedInt.newEmptyInstance(); + + /** + * repeated uint32 INPDLILFOCO = 9; + */ + private final RepeatedInt iNPDLILFOCO = RepeatedInt.newEmptyInstance(); + + private ChessRogueNousStoryInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueNousStoryInfo} + */ + public static ChessRogueNousStoryInfo newInstance() { + return new ChessRogueNousStoryInfo(); + } + + /** + * optional uint32 story_id = 3; + * @return whether the storyId field is set + */ + public boolean hasStoryId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 story_id = 3; + * @return this + */ + public ChessRogueNousStoryInfo clearStoryId() { + bitField0_ &= ~0x00000001; + storyId = 0; + return this; + } + + /** + * optional uint32 story_id = 3; + * @return the storyId + */ + public int getStoryId() { + return storyId; + } + + /** + * optional uint32 story_id = 3; + * @param value the storyId to set + * @return this + */ + public ChessRogueNousStoryInfo setStoryId(final int value) { + bitField0_ |= 0x00000001; + storyId = value; + return this; + } + + /** + * optional uint32 sub_story_id = 7; + * @return whether the subStoryId field is set + */ + public boolean hasSubStoryId() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 sub_story_id = 7; + * @return this + */ + public ChessRogueNousStoryInfo clearSubStoryId() { + bitField0_ &= ~0x00000002; + subStoryId = 0; + return this; + } + + /** + * optional uint32 sub_story_id = 7; + * @return the subStoryId + */ + public int getSubStoryId() { + return subStoryId; + } + + /** + * optional uint32 sub_story_id = 7; + * @param value the subStoryId to set + * @return this + */ + public ChessRogueNousStoryInfo setSubStoryId(final int value) { + bitField0_ |= 0x00000002; + subStoryId = value; + return this; + } + + /** + * optional uint32 ACLGLHEFFON = 14; + * @return whether the aCLGLHEFFON field is set + */ + public boolean hasACLGLHEFFON() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 ACLGLHEFFON = 14; + * @return this + */ + public ChessRogueNousStoryInfo clearACLGLHEFFON() { + bitField0_ &= ~0x00000004; + aCLGLHEFFON = 0; + return this; + } + + /** + * optional uint32 ACLGLHEFFON = 14; + * @return the aCLGLHEFFON + */ + public int getACLGLHEFFON() { + return aCLGLHEFFON; + } + + /** + * optional uint32 ACLGLHEFFON = 14; + * @param value the aCLGLHEFFON to set + * @return this + */ + public ChessRogueNousStoryInfo setACLGLHEFFON(final int value) { + bitField0_ |= 0x00000004; + aCLGLHEFFON = value; + return this; + } + + /** + * optional bool CKEKKMGIHKJ = 8; + * @return whether the cKEKKMGIHKJ field is set + */ + public boolean hasCKEKKMGIHKJ() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional bool CKEKKMGIHKJ = 8; + * @return this + */ + public ChessRogueNousStoryInfo clearCKEKKMGIHKJ() { + bitField0_ &= ~0x00000008; + cKEKKMGIHKJ = false; + return this; + } + + /** + * optional bool CKEKKMGIHKJ = 8; + * @return the cKEKKMGIHKJ + */ + public boolean getCKEKKMGIHKJ() { + return cKEKKMGIHKJ; + } + + /** + * optional bool CKEKKMGIHKJ = 8; + * @param value the cKEKKMGIHKJ to set + * @return this + */ + public ChessRogueNousStoryInfo setCKEKKMGIHKJ(final boolean value) { + bitField0_ |= 0x00000008; + cKEKKMGIHKJ = value; + return this; + } + + /** + * optional bool AHOJIDMLFPE = 12; + * @return whether the aHOJIDMLFPE field is set + */ + public boolean hasAHOJIDMLFPE() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * optional bool AHOJIDMLFPE = 12; + * @return this + */ + public ChessRogueNousStoryInfo clearAHOJIDMLFPE() { + bitField0_ &= ~0x00000010; + aHOJIDMLFPE = false; + return this; + } + + /** + * optional bool AHOJIDMLFPE = 12; + * @return the aHOJIDMLFPE + */ + public boolean getAHOJIDMLFPE() { + return aHOJIDMLFPE; + } + + /** + * optional bool AHOJIDMLFPE = 12; + * @param value the aHOJIDMLFPE to set + * @return this + */ + public ChessRogueNousStoryInfo setAHOJIDMLFPE(final boolean value) { + bitField0_ |= 0x00000010; + aHOJIDMLFPE = value; + return this; + } + + /** + * repeated uint32 HCPCJBDBBGC = 1; + * @return whether the hCPCJBDBBGC field is set + */ + public boolean hasHCPCJBDBBGC() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * repeated uint32 HCPCJBDBBGC = 1; + * @return this + */ + public ChessRogueNousStoryInfo clearHCPCJBDBBGC() { + bitField0_ &= ~0x00000020; + hCPCJBDBBGC.clear(); + return this; + } + + /** + * repeated uint32 HCPCJBDBBGC = 1; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableHCPCJBDBBGC()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getHCPCJBDBBGC() { + return hCPCJBDBBGC; + } + + /** + * repeated uint32 HCPCJBDBBGC = 1; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableHCPCJBDBBGC() { + bitField0_ |= 0x00000020; + return hCPCJBDBBGC; + } + + /** + * repeated uint32 HCPCJBDBBGC = 1; + * @param value the hCPCJBDBBGC to add + * @return this + */ + public ChessRogueNousStoryInfo addHCPCJBDBBGC(final int value) { + bitField0_ |= 0x00000020; + hCPCJBDBBGC.add(value); + return this; + } + + /** + * repeated uint32 HCPCJBDBBGC = 1; + * @param values the hCPCJBDBBGC to add + * @return this + */ + public ChessRogueNousStoryInfo addAllHCPCJBDBBGC(final int... values) { + bitField0_ |= 0x00000020; + hCPCJBDBBGC.addAll(values); + return this; + } + + /** + * repeated uint32 CMHLEEKNFKH = 4; + * @return whether the cMHLEEKNFKH field is set + */ + public boolean hasCMHLEEKNFKH() { + return (bitField0_ & 0x00000040) != 0; + } + + /** + * repeated uint32 CMHLEEKNFKH = 4; + * @return this + */ + public ChessRogueNousStoryInfo clearCMHLEEKNFKH() { + bitField0_ &= ~0x00000040; + cMHLEEKNFKH.clear(); + return this; + } + + /** + * repeated uint32 CMHLEEKNFKH = 4; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableCMHLEEKNFKH()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getCMHLEEKNFKH() { + return cMHLEEKNFKH; + } + + /** + * repeated uint32 CMHLEEKNFKH = 4; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableCMHLEEKNFKH() { + bitField0_ |= 0x00000040; + return cMHLEEKNFKH; + } + + /** + * repeated uint32 CMHLEEKNFKH = 4; + * @param value the cMHLEEKNFKH to add + * @return this + */ + public ChessRogueNousStoryInfo addCMHLEEKNFKH(final int value) { + bitField0_ |= 0x00000040; + cMHLEEKNFKH.add(value); + return this; + } + + /** + * repeated uint32 CMHLEEKNFKH = 4; + * @param values the cMHLEEKNFKH to add + * @return this + */ + public ChessRogueNousStoryInfo addAllCMHLEEKNFKH(final int... values) { + bitField0_ |= 0x00000040; + cMHLEEKNFKH.addAll(values); + return this; + } + + /** + * repeated uint32 INPDLILFOCO = 9; + * @return whether the iNPDLILFOCO field is set + */ + public boolean hasINPDLILFOCO() { + return (bitField0_ & 0x00000080) != 0; + } + + /** + * repeated uint32 INPDLILFOCO = 9; + * @return this + */ + public ChessRogueNousStoryInfo clearINPDLILFOCO() { + bitField0_ &= ~0x00000080; + iNPDLILFOCO.clear(); + return this; + } + + /** + * repeated uint32 INPDLILFOCO = 9; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableINPDLILFOCO()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getINPDLILFOCO() { + return iNPDLILFOCO; + } + + /** + * repeated uint32 INPDLILFOCO = 9; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableINPDLILFOCO() { + bitField0_ |= 0x00000080; + return iNPDLILFOCO; + } + + /** + * repeated uint32 INPDLILFOCO = 9; + * @param value the iNPDLILFOCO to add + * @return this + */ + public ChessRogueNousStoryInfo addINPDLILFOCO(final int value) { + bitField0_ |= 0x00000080; + iNPDLILFOCO.add(value); + return this; + } + + /** + * repeated uint32 INPDLILFOCO = 9; + * @param values the iNPDLILFOCO to add + * @return this + */ + public ChessRogueNousStoryInfo addAllINPDLILFOCO(final int... values) { + bitField0_ |= 0x00000080; + iNPDLILFOCO.addAll(values); + return this; + } + + @Override + public ChessRogueNousStoryInfo copyFrom(final ChessRogueNousStoryInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + storyId = other.storyId; + subStoryId = other.subStoryId; + aCLGLHEFFON = other.aCLGLHEFFON; + cKEKKMGIHKJ = other.cKEKKMGIHKJ; + aHOJIDMLFPE = other.aHOJIDMLFPE; + hCPCJBDBBGC.copyFrom(other.hCPCJBDBBGC); + cMHLEEKNFKH.copyFrom(other.cMHLEEKNFKH); + iNPDLILFOCO.copyFrom(other.iNPDLILFOCO); + } + return this; + } + + @Override + public ChessRogueNousStoryInfo mergeFrom(final ChessRogueNousStoryInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasStoryId()) { + setStoryId(other.storyId); + } + if (other.hasSubStoryId()) { + setSubStoryId(other.subStoryId); + } + if (other.hasACLGLHEFFON()) { + setACLGLHEFFON(other.aCLGLHEFFON); + } + if (other.hasCKEKKMGIHKJ()) { + setCKEKKMGIHKJ(other.cKEKKMGIHKJ); + } + if (other.hasAHOJIDMLFPE()) { + setAHOJIDMLFPE(other.aHOJIDMLFPE); + } + if (other.hasHCPCJBDBBGC()) { + getMutableHCPCJBDBBGC().addAll(other.hCPCJBDBBGC); + } + if (other.hasCMHLEEKNFKH()) { + getMutableCMHLEEKNFKH().addAll(other.cMHLEEKNFKH); + } + if (other.hasINPDLILFOCO()) { + getMutableINPDLILFOCO().addAll(other.iNPDLILFOCO); + } + return this; + } + + @Override + public ChessRogueNousStoryInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + storyId = 0; + subStoryId = 0; + aCLGLHEFFON = 0; + cKEKKMGIHKJ = false; + aHOJIDMLFPE = false; + hCPCJBDBBGC.clear(); + cMHLEEKNFKH.clear(); + iNPDLILFOCO.clear(); + return this; + } + + @Override + public ChessRogueNousStoryInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + hCPCJBDBBGC.clear(); + cMHLEEKNFKH.clear(); + iNPDLILFOCO.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueNousStoryInfo)) { + return false; + } + ChessRogueNousStoryInfo other = (ChessRogueNousStoryInfo) o; + return bitField0_ == other.bitField0_ + && (!hasStoryId() || storyId == other.storyId) + && (!hasSubStoryId() || subStoryId == other.subStoryId) + && (!hasACLGLHEFFON() || aCLGLHEFFON == other.aCLGLHEFFON) + && (!hasCKEKKMGIHKJ() || cKEKKMGIHKJ == other.cKEKKMGIHKJ) + && (!hasAHOJIDMLFPE() || aHOJIDMLFPE == other.aHOJIDMLFPE) + && (!hasHCPCJBDBBGC() || hCPCJBDBBGC.equals(other.hCPCJBDBBGC)) + && (!hasCMHLEEKNFKH() || cMHLEEKNFKH.equals(other.cMHLEEKNFKH)) + && (!hasINPDLILFOCO() || iNPDLILFOCO.equals(other.iNPDLILFOCO)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(storyId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 56); + output.writeUInt32NoTag(subStoryId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 112); + output.writeUInt32NoTag(aCLGLHEFFON); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 64); + output.writeBoolNoTag(cKEKKMGIHKJ); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawByte((byte) 96); + output.writeBoolNoTag(aHOJIDMLFPE); + } + if ((bitField0_ & 0x00000020) != 0) { + for (int i = 0; i < hCPCJBDBBGC.length(); i++) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(hCPCJBDBBGC.array()[i]); + } + } + if ((bitField0_ & 0x00000040) != 0) { + for (int i = 0; i < cMHLEEKNFKH.length(); i++) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(cMHLEEKNFKH.array()[i]); + } + } + if ((bitField0_ & 0x00000080) != 0) { + for (int i = 0; i < iNPDLILFOCO.length(); i++) { + output.writeRawByte((byte) 72); + output.writeUInt32NoTag(iNPDLILFOCO.array()[i]); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(storyId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(subStoryId); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(aCLGLHEFFON); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 2; + } + if ((bitField0_ & 0x00000010) != 0) { + size += 2; + } + if ((bitField0_ & 0x00000020) != 0) { + size += (1 * hCPCJBDBBGC.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(hCPCJBDBBGC); + } + if ((bitField0_ & 0x00000040) != 0) { + size += (1 * cMHLEEKNFKH.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(cMHLEEKNFKH); + } + if ((bitField0_ & 0x00000080) != 0) { + size += (1 * iNPDLILFOCO.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(iNPDLILFOCO); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueNousStoryInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 24: { + // storyId + storyId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 56) { + break; + } + } + case 56: { + // subStoryId + subStoryId = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 112) { + break; + } + } + case 112: { + // aCLGLHEFFON + aCLGLHEFFON = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 64) { + break; + } + } + case 64: { + // cKEKKMGIHKJ + cKEKKMGIHKJ = input.readBool(); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 96) { + break; + } + } + case 96: { + // aHOJIDMLFPE + aHOJIDMLFPE = input.readBool(); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 10) { + break; + } + } + case 10: { + // hCPCJBDBBGC [packed=true] + input.readPackedUInt32(hCPCJBDBBGC, tag); + bitField0_ |= 0x00000020; + tag = input.readTag(); + if (tag != 34) { + break; + } + } + case 34: { + // cMHLEEKNFKH [packed=true] + input.readPackedUInt32(cMHLEEKNFKH, tag); + bitField0_ |= 0x00000040; + tag = input.readTag(); + if (tag != 74) { + break; + } + } + case 74: { + // iNPDLILFOCO [packed=true] + input.readPackedUInt32(iNPDLILFOCO, tag); + bitField0_ |= 0x00000080; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + case 8: { + // hCPCJBDBBGC [packed=false] + tag = input.readRepeatedUInt32(hCPCJBDBBGC, tag); + bitField0_ |= 0x00000020; + break; + } + case 32: { + // cMHLEEKNFKH [packed=false] + tag = input.readRepeatedUInt32(cMHLEEKNFKH, tag); + bitField0_ |= 0x00000040; + break; + } + case 72: { + // iNPDLILFOCO [packed=false] + tag = input.readRepeatedUInt32(iNPDLILFOCO, tag); + bitField0_ |= 0x00000080; + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.storyId, storyId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.subStoryId, subStoryId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.aCLGLHEFFON, aCLGLHEFFON); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeBool(FieldNames.cKEKKMGIHKJ, cKEKKMGIHKJ); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeBool(FieldNames.aHOJIDMLFPE, aHOJIDMLFPE); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRepeatedUInt32(FieldNames.hCPCJBDBBGC, hCPCJBDBBGC); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeRepeatedUInt32(FieldNames.cMHLEEKNFKH, cMHLEEKNFKH); + } + if ((bitField0_ & 0x00000080) != 0) { + output.writeRepeatedUInt32(FieldNames.iNPDLILFOCO, iNPDLILFOCO); + } + output.endObject(); + } + + @Override + public ChessRogueNousStoryInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1884251920: + case 1717754021: { + if (input.isAtField(FieldNames.storyId)) { + if (!input.trySkipNullValue()) { + storyId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 929098384: + case 1899516868: { + if (input.isAtField(FieldNames.subStoryId)) { + if (!input.trySkipNullValue()) { + subStoryId = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1003347797: { + if (input.isAtField(FieldNames.aCLGLHEFFON)) { + if (!input.trySkipNullValue()) { + aCLGLHEFFON = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -173257579: { + if (input.isAtField(FieldNames.cKEKKMGIHKJ)) { + if (!input.trySkipNullValue()) { + cKEKKMGIHKJ = input.readBool(); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case -654341121: { + if (input.isAtField(FieldNames.aHOJIDMLFPE)) { + if (!input.trySkipNullValue()) { + aHOJIDMLFPE = input.readBool(); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case 333875514: { + if (input.isAtField(FieldNames.hCPCJBDBBGC)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(hCPCJBDBBGC); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1206117230: { + if (input.isAtField(FieldNames.cMHLEEKNFKH)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(cMHLEEKNFKH); + bitField0_ |= 0x00000040; + } + } else { + input.skipUnknownField(); + } + break; + } + case 101017067: { + if (input.isAtField(FieldNames.iNPDLILFOCO)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(iNPDLILFOCO); + bitField0_ |= 0x00000080; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueNousStoryInfo clone() { + return new ChessRogueNousStoryInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueNousStoryInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueNousStoryInfo(), data).checkInitialized(); + } + + public static ChessRogueNousStoryInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousStoryInfo(), input).checkInitialized(); + } + + public static ChessRogueNousStoryInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousStoryInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueNousStoryInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueNousStoryInfoFactory.INSTANCE; + } + + private enum ChessRogueNousStoryInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueNousStoryInfo create() { + return ChessRogueNousStoryInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName storyId = FieldName.forField("storyId", "story_id"); + + static final FieldName subStoryId = FieldName.forField("subStoryId", "sub_story_id"); + + static final FieldName aCLGLHEFFON = FieldName.forField("ACLGLHEFFON"); + + static final FieldName cKEKKMGIHKJ = FieldName.forField("CKEKKMGIHKJ"); + + static final FieldName aHOJIDMLFPE = FieldName.forField("AHOJIDMLFPE"); + + static final FieldName hCPCJBDBBGC = FieldName.forField("HCPCJBDBBGC"); + + static final FieldName cMHLEEKNFKH = FieldName.forField("CMHLEEKNFKH"); + + static final FieldName iNPDLILFOCO = FieldName.forField("INPDLILFOCO"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueNousSubStoryInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueNousSubStoryInfoOuterClass.java new file mode 100644 index 0000000..4a351d0 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueNousSubStoryInfoOuterClass.java @@ -0,0 +1,260 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueNousSubStoryInfoOuterClass { + /** + * Protobuf type {@code ChessRogueNousSubStoryInfo} + */ + public static final class ChessRogueNousSubStoryInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 sub_story_id = 4; + */ + private int subStoryId; + + private ChessRogueNousSubStoryInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueNousSubStoryInfo} + */ + public static ChessRogueNousSubStoryInfo newInstance() { + return new ChessRogueNousSubStoryInfo(); + } + + /** + * optional uint32 sub_story_id = 4; + * @return whether the subStoryId field is set + */ + public boolean hasSubStoryId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 sub_story_id = 4; + * @return this + */ + public ChessRogueNousSubStoryInfo clearSubStoryId() { + bitField0_ &= ~0x00000001; + subStoryId = 0; + return this; + } + + /** + * optional uint32 sub_story_id = 4; + * @return the subStoryId + */ + public int getSubStoryId() { + return subStoryId; + } + + /** + * optional uint32 sub_story_id = 4; + * @param value the subStoryId to set + * @return this + */ + public ChessRogueNousSubStoryInfo setSubStoryId(final int value) { + bitField0_ |= 0x00000001; + subStoryId = value; + return this; + } + + @Override + public ChessRogueNousSubStoryInfo copyFrom(final ChessRogueNousSubStoryInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + subStoryId = other.subStoryId; + } + return this; + } + + @Override + public ChessRogueNousSubStoryInfo mergeFrom(final ChessRogueNousSubStoryInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasSubStoryId()) { + setSubStoryId(other.subStoryId); + } + return this; + } + + @Override + public ChessRogueNousSubStoryInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + subStoryId = 0; + return this; + } + + @Override + public ChessRogueNousSubStoryInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueNousSubStoryInfo)) { + return false; + } + ChessRogueNousSubStoryInfo other = (ChessRogueNousSubStoryInfo) o; + return bitField0_ == other.bitField0_ + && (!hasSubStoryId() || subStoryId == other.subStoryId); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(subStoryId); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(subStoryId); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueNousSubStoryInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 32: { + // subStoryId + subStoryId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.subStoryId, subStoryId); + } + output.endObject(); + } + + @Override + public ChessRogueNousSubStoryInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 929098384: + case 1899516868: { + if (input.isAtField(FieldNames.subStoryId)) { + if (!input.trySkipNullValue()) { + subStoryId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueNousSubStoryInfo clone() { + return new ChessRogueNousSubStoryInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueNousSubStoryInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueNousSubStoryInfo(), data).checkInitialized(); + } + + public static ChessRogueNousSubStoryInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousSubStoryInfo(), input).checkInitialized(); + } + + public static ChessRogueNousSubStoryInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousSubStoryInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueNousSubStoryInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueNousSubStoryInfoFactory.INSTANCE; + } + + private enum ChessRogueNousSubStoryInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueNousSubStoryInfo create() { + return ChessRogueNousSubStoryInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName subStoryId = FieldName.forField("subStoryId", "sub_story_id"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueNousValueOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueNousValueOuterClass.java new file mode 100644 index 0000000..f887c9b --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueNousValueOuterClass.java @@ -0,0 +1,259 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueNousValueOuterClass { + /** + * Protobuf type {@code ChessRogueNousValue} + */ + public static final class ChessRogueNousValue extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional sint32 value = 13; + */ + private int value_; + + private ChessRogueNousValue() { + } + + /** + * @return a new empty instance of {@code ChessRogueNousValue} + */ + public static ChessRogueNousValue newInstance() { + return new ChessRogueNousValue(); + } + + /** + * optional sint32 value = 13; + * @return whether the value_ field is set + */ + public boolean hasValue() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional sint32 value = 13; + * @return this + */ + public ChessRogueNousValue clearValue() { + bitField0_ &= ~0x00000001; + value_ = 0; + return this; + } + + /** + * optional sint32 value = 13; + * @return the value_ + */ + public int getValue() { + return value_; + } + + /** + * optional sint32 value = 13; + * @param value the value_ to set + * @return this + */ + public ChessRogueNousValue setValue(final int value) { + bitField0_ |= 0x00000001; + value_ = value; + return this; + } + + @Override + public ChessRogueNousValue copyFrom(final ChessRogueNousValue other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + value_ = other.value_; + } + return this; + } + + @Override + public ChessRogueNousValue mergeFrom(final ChessRogueNousValue other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasValue()) { + setValue(other.value_); + } + return this; + } + + @Override + public ChessRogueNousValue clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + value_ = 0; + return this; + } + + @Override + public ChessRogueNousValue clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueNousValue)) { + return false; + } + ChessRogueNousValue other = (ChessRogueNousValue) o; + return bitField0_ == other.bitField0_ + && (!hasValue() || value_ == other.value_); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 104); + output.writeSInt32NoTag(value_); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeSInt32SizeNoTag(value_); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueNousValue mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 104: { + // value_ + value_ = input.readSInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeSInt32(FieldNames.value_, value_); + } + output.endObject(); + } + + @Override + public ChessRogueNousValue mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 111972721: { + if (input.isAtField(FieldNames.value_)) { + if (!input.trySkipNullValue()) { + value_ = input.readSInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueNousValue clone() { + return new ChessRogueNousValue().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueNousValue parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueNousValue(), data).checkInitialized(); + } + + public static ChessRogueNousValue parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousValue(), input).checkInitialized(); + } + + public static ChessRogueNousValue parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueNousValue(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueNousValue messages + */ + public static MessageFactory getFactory() { + return ChessRogueNousValueFactory.INSTANCE; + } + + private enum ChessRogueNousValueFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueNousValue create() { + return ChessRogueNousValue.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName value_ = FieldName.forField("value"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueQueryOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueQueryOuterClass.java new file mode 100644 index 0000000..f179aa7 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueQueryOuterClass.java @@ -0,0 +1,937 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedInt; +import us.hebi.quickbuf.RepeatedMessage; + +public final class ChessRogueQueryOuterClass { + /** + * Protobuf type {@code ChessRogueQuery} + */ + public static final class ChessRogueQuery extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 KDHBPKCKEAL = 10; + */ + private int kDHBPKCKEAL; + + /** + * repeated uint32 main_story_id = 8; + */ + private final RepeatedInt mainStoryId = RepeatedInt.newEmptyInstance(); + + /** + * repeated .ChessRogueQuery.EKLAFMBHNIPEntry EKLAFMBHNIP = 6; + */ + private final RepeatedMessage eKLAFMBHNIP = RepeatedMessage.newEmptyInstance(EKLAFMBHNIPEntry.getFactory()); + + /** + * repeated .ChessRogueNousDiceInfo dice_info = 12; + */ + private final RepeatedMessage diceInfo = RepeatedMessage.newEmptyInstance(ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo.getFactory()); + + private ChessRogueQuery() { + } + + /** + * @return a new empty instance of {@code ChessRogueQuery} + */ + public static ChessRogueQuery newInstance() { + return new ChessRogueQuery(); + } + + /** + * optional uint32 KDHBPKCKEAL = 10; + * @return whether the kDHBPKCKEAL field is set + */ + public boolean hasKDHBPKCKEAL() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 KDHBPKCKEAL = 10; + * @return this + */ + public ChessRogueQuery clearKDHBPKCKEAL() { + bitField0_ &= ~0x00000001; + kDHBPKCKEAL = 0; + return this; + } + + /** + * optional uint32 KDHBPKCKEAL = 10; + * @return the kDHBPKCKEAL + */ + public int getKDHBPKCKEAL() { + return kDHBPKCKEAL; + } + + /** + * optional uint32 KDHBPKCKEAL = 10; + * @param value the kDHBPKCKEAL to set + * @return this + */ + public ChessRogueQuery setKDHBPKCKEAL(final int value) { + bitField0_ |= 0x00000001; + kDHBPKCKEAL = value; + return this; + } + + /** + * repeated uint32 main_story_id = 8; + * @return whether the mainStoryId field is set + */ + public boolean hasMainStoryId() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated uint32 main_story_id = 8; + * @return this + */ + public ChessRogueQuery clearMainStoryId() { + bitField0_ &= ~0x00000002; + mainStoryId.clear(); + return this; + } + + /** + * repeated uint32 main_story_id = 8; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableMainStoryId()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getMainStoryId() { + return mainStoryId; + } + + /** + * repeated uint32 main_story_id = 8; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableMainStoryId() { + bitField0_ |= 0x00000002; + return mainStoryId; + } + + /** + * repeated uint32 main_story_id = 8; + * @param value the mainStoryId to add + * @return this + */ + public ChessRogueQuery addMainStoryId(final int value) { + bitField0_ |= 0x00000002; + mainStoryId.add(value); + return this; + } + + /** + * repeated uint32 main_story_id = 8; + * @param values the mainStoryId to add + * @return this + */ + public ChessRogueQuery addAllMainStoryId(final int... values) { + bitField0_ |= 0x00000002; + mainStoryId.addAll(values); + return this; + } + + /** + * repeated .ChessRogueQuery.EKLAFMBHNIPEntry EKLAFMBHNIP = 6; + * @return whether the eKLAFMBHNIP field is set + */ + public boolean hasEKLAFMBHNIP() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * repeated .ChessRogueQuery.EKLAFMBHNIPEntry EKLAFMBHNIP = 6; + * @return this + */ + public ChessRogueQuery clearEKLAFMBHNIP() { + bitField0_ &= ~0x00000004; + eKLAFMBHNIP.clear(); + return this; + } + + /** + * repeated .ChessRogueQuery.EKLAFMBHNIPEntry EKLAFMBHNIP = 6; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableEKLAFMBHNIP()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getEKLAFMBHNIP() { + return eKLAFMBHNIP; + } + + /** + * repeated .ChessRogueQuery.EKLAFMBHNIPEntry EKLAFMBHNIP = 6; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableEKLAFMBHNIP() { + bitField0_ |= 0x00000004; + return eKLAFMBHNIP; + } + + /** + * repeated .ChessRogueQuery.EKLAFMBHNIPEntry EKLAFMBHNIP = 6; + * @param value the eKLAFMBHNIP to add + * @return this + */ + public ChessRogueQuery addEKLAFMBHNIP(final EKLAFMBHNIPEntry value) { + bitField0_ |= 0x00000004; + eKLAFMBHNIP.add(value); + return this; + } + + /** + * repeated .ChessRogueQuery.EKLAFMBHNIPEntry EKLAFMBHNIP = 6; + * @param values the eKLAFMBHNIP to add + * @return this + */ + public ChessRogueQuery addAllEKLAFMBHNIP(final EKLAFMBHNIPEntry... values) { + bitField0_ |= 0x00000004; + eKLAFMBHNIP.addAll(values); + return this; + } + + /** + * repeated .ChessRogueNousDiceInfo dice_info = 12; + * @return whether the diceInfo field is set + */ + public boolean hasDiceInfo() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * repeated .ChessRogueNousDiceInfo dice_info = 12; + * @return this + */ + public ChessRogueQuery clearDiceInfo() { + bitField0_ &= ~0x00000008; + diceInfo.clear(); + return this; + } + + /** + * repeated .ChessRogueNousDiceInfo dice_info = 12; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableDiceInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getDiceInfo() { + return diceInfo; + } + + /** + * repeated .ChessRogueNousDiceInfo dice_info = 12; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableDiceInfo( + ) { + bitField0_ |= 0x00000008; + return diceInfo; + } + + /** + * repeated .ChessRogueNousDiceInfo dice_info = 12; + * @param value the diceInfo to add + * @return this + */ + public ChessRogueQuery addDiceInfo( + final ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo value) { + bitField0_ |= 0x00000008; + diceInfo.add(value); + return this; + } + + /** + * repeated .ChessRogueNousDiceInfo dice_info = 12; + * @param values the diceInfo to add + * @return this + */ + public ChessRogueQuery addAllDiceInfo( + final ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo... values) { + bitField0_ |= 0x00000008; + diceInfo.addAll(values); + return this; + } + + @Override + public ChessRogueQuery copyFrom(final ChessRogueQuery other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + kDHBPKCKEAL = other.kDHBPKCKEAL; + mainStoryId.copyFrom(other.mainStoryId); + eKLAFMBHNIP.copyFrom(other.eKLAFMBHNIP); + diceInfo.copyFrom(other.diceInfo); + } + return this; + } + + @Override + public ChessRogueQuery mergeFrom(final ChessRogueQuery other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasKDHBPKCKEAL()) { + setKDHBPKCKEAL(other.kDHBPKCKEAL); + } + if (other.hasMainStoryId()) { + getMutableMainStoryId().addAll(other.mainStoryId); + } + if (other.hasEKLAFMBHNIP()) { + getMutableEKLAFMBHNIP().addAll(other.eKLAFMBHNIP); + } + if (other.hasDiceInfo()) { + getMutableDiceInfo().addAll(other.diceInfo); + } + return this; + } + + @Override + public ChessRogueQuery clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + kDHBPKCKEAL = 0; + mainStoryId.clear(); + eKLAFMBHNIP.clear(); + diceInfo.clear(); + return this; + } + + @Override + public ChessRogueQuery clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + mainStoryId.clear(); + eKLAFMBHNIP.clearQuick(); + diceInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueQuery)) { + return false; + } + ChessRogueQuery other = (ChessRogueQuery) o; + return bitField0_ == other.bitField0_ + && (!hasKDHBPKCKEAL() || kDHBPKCKEAL == other.kDHBPKCKEAL) + && (!hasMainStoryId() || mainStoryId.equals(other.mainStoryId)) + && (!hasEKLAFMBHNIP() || eKLAFMBHNIP.equals(other.eKLAFMBHNIP)) + && (!hasDiceInfo() || diceInfo.equals(other.diceInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 80); + output.writeUInt32NoTag(kDHBPKCKEAL); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < mainStoryId.length(); i++) { + output.writeRawByte((byte) 64); + output.writeUInt32NoTag(mainStoryId.array()[i]); + } + } + if ((bitField0_ & 0x00000004) != 0) { + for (int i = 0; i < eKLAFMBHNIP.length(); i++) { + output.writeRawByte((byte) 50); + output.writeMessageNoTag(eKLAFMBHNIP.get(i)); + } + } + if ((bitField0_ & 0x00000008) != 0) { + for (int i = 0; i < diceInfo.length(); i++) { + output.writeRawByte((byte) 98); + output.writeMessageNoTag(diceInfo.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(kDHBPKCKEAL); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * mainStoryId.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(mainStoryId); + } + if ((bitField0_ & 0x00000004) != 0) { + size += (1 * eKLAFMBHNIP.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(eKLAFMBHNIP); + } + if ((bitField0_ & 0x00000008) != 0) { + size += (1 * diceInfo.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(diceInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueQuery mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 80: { + // kDHBPKCKEAL + kDHBPKCKEAL = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 66) { + break; + } + } + case 66: { + // mainStoryId [packed=true] + input.readPackedUInt32(mainStoryId, tag); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 50) { + break; + } + } + case 50: { + // eKLAFMBHNIP + tag = input.readRepeatedMessage(eKLAFMBHNIP, tag); + bitField0_ |= 0x00000004; + if (tag != 98) { + break; + } + } + case 98: { + // diceInfo + tag = input.readRepeatedMessage(diceInfo, tag); + bitField0_ |= 0x00000008; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + case 64: { + // mainStoryId [packed=false] + tag = input.readRepeatedUInt32(mainStoryId, tag); + bitField0_ |= 0x00000002; + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.kDHBPKCKEAL, kDHBPKCKEAL); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedUInt32(FieldNames.mainStoryId, mainStoryId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRepeatedMessage(FieldNames.eKLAFMBHNIP, eKLAFMBHNIP); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRepeatedMessage(FieldNames.diceInfo, diceInfo); + } + output.endObject(); + } + + @Override + public ChessRogueQuery mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 160463162: { + if (input.isAtField(FieldNames.kDHBPKCKEAL)) { + if (!input.trySkipNullValue()) { + kDHBPKCKEAL = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1525676279: + case -314743701: { + if (input.isAtField(FieldNames.mainStoryId)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(mainStoryId); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 365100685: { + if (input.isAtField(FieldNames.eKLAFMBHNIP)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(eKLAFMBHNIP); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -184174347: + case -1394261434: { + if (input.isAtField(FieldNames.diceInfo)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(diceInfo); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueQuery clone() { + return new ChessRogueQuery().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueQuery parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueQuery(), data).checkInitialized(); + } + + public static ChessRogueQuery parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueQuery(), input).checkInitialized(); + } + + public static ChessRogueQuery parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueQuery(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueQuery messages + */ + public static MessageFactory getFactory() { + return ChessRogueQueryFactory.INSTANCE; + } + + /** + * Protobuf type {@code EKLAFMBHNIPEntry} + */ + public static final class EKLAFMBHNIPEntry extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 key = 1; + */ + private int key; + + /** + * optional bool value = 2; + */ + private boolean value_; + + private EKLAFMBHNIPEntry() { + } + + /** + * @return a new empty instance of {@code EKLAFMBHNIPEntry} + */ + public static EKLAFMBHNIPEntry newInstance() { + return new EKLAFMBHNIPEntry(); + } + + /** + * optional uint32 key = 1; + * @return whether the key field is set + */ + public boolean hasKey() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 key = 1; + * @return this + */ + public EKLAFMBHNIPEntry clearKey() { + bitField0_ &= ~0x00000001; + key = 0; + return this; + } + + /** + * optional uint32 key = 1; + * @return the key + */ + public int getKey() { + return key; + } + + /** + * optional uint32 key = 1; + * @param value the key to set + * @return this + */ + public EKLAFMBHNIPEntry setKey(final int value) { + bitField0_ |= 0x00000001; + key = value; + return this; + } + + /** + * optional bool value = 2; + * @return whether the value_ field is set + */ + public boolean hasValue() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional bool value = 2; + * @return this + */ + public EKLAFMBHNIPEntry clearValue() { + bitField0_ &= ~0x00000002; + value_ = false; + return this; + } + + /** + * optional bool value = 2; + * @return the value_ + */ + public boolean getValue() { + return value_; + } + + /** + * optional bool value = 2; + * @param value the value_ to set + * @return this + */ + public EKLAFMBHNIPEntry setValue(final boolean value) { + bitField0_ |= 0x00000002; + value_ = value; + return this; + } + + @Override + public EKLAFMBHNIPEntry copyFrom(final EKLAFMBHNIPEntry other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + key = other.key; + value_ = other.value_; + } + return this; + } + + @Override + public EKLAFMBHNIPEntry mergeFrom(final EKLAFMBHNIPEntry other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasKey()) { + setKey(other.key); + } + if (other.hasValue()) { + setValue(other.value_); + } + return this; + } + + @Override + public EKLAFMBHNIPEntry clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + key = 0; + value_ = false; + return this; + } + + @Override + public EKLAFMBHNIPEntry clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof EKLAFMBHNIPEntry)) { + return false; + } + EKLAFMBHNIPEntry other = (EKLAFMBHNIPEntry) o; + return bitField0_ == other.bitField0_ + && (!hasKey() || key == other.key) + && (!hasValue() || value_ == other.value_); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(key); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeBoolNoTag(value_); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(key); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 2; + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public EKLAFMBHNIPEntry mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // key + key = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // value_ + value_ = input.readBool(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.key, key); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeBool(FieldNames.value_, value_); + } + output.endObject(); + } + + @Override + public EKLAFMBHNIPEntry mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 106079: { + if (input.isAtField(FieldNames.key)) { + if (!input.trySkipNullValue()) { + key = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 111972721: { + if (input.isAtField(FieldNames.value_)) { + if (!input.trySkipNullValue()) { + value_ = input.readBool(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public EKLAFMBHNIPEntry clone() { + return new EKLAFMBHNIPEntry().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static EKLAFMBHNIPEntry parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new EKLAFMBHNIPEntry(), data).checkInitialized(); + } + + public static EKLAFMBHNIPEntry parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new EKLAFMBHNIPEntry(), input).checkInitialized(); + } + + public static EKLAFMBHNIPEntry parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new EKLAFMBHNIPEntry(), input).checkInitialized(); + } + + /** + * @return factory for creating EKLAFMBHNIPEntry messages + */ + public static MessageFactory getFactory() { + return EKLAFMBHNIPEntryFactory.INSTANCE; + } + + private enum EKLAFMBHNIPEntryFactory implements MessageFactory { + INSTANCE; + + @Override + public EKLAFMBHNIPEntry create() { + return EKLAFMBHNIPEntry.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName key = FieldName.forField("key"); + + static final FieldName value_ = FieldName.forField("value"); + } + } + + private enum ChessRogueQueryFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueQuery create() { + return ChessRogueQuery.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName kDHBPKCKEAL = FieldName.forField("KDHBPKCKEAL"); + + static final FieldName mainStoryId = FieldName.forField("mainStoryId", "main_story_id"); + + static final FieldName eKLAFMBHNIP = FieldName.forField("EKLAFMBHNIP"); + + static final FieldName diceInfo = FieldName.forField("diceInfo", "dice_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueQueryScRspOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueQueryScRspOuterClass.java new file mode 100644 index 0000000..4190f0e --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueQueryScRspOuterClass.java @@ -0,0 +1,501 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueQueryScRspOuterClass { + /** + * Protobuf type {@code ChessRogueQueryScRsp} + */ + public static final class ChessRogueQueryScRsp extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 retcode = 3; + */ + private int retcode; + + /** + * optional .ChessRogueNousQueryInfo rogue_nous = 10; + */ + private final ChessRogueNousQueryInfoOuterClass.ChessRogueNousQueryInfo rogueNous = ChessRogueNousQueryInfoOuterClass.ChessRogueNousQueryInfo.newInstance(); + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 15;
+     * HFKELKECMJE MKCLHOMEICF = 4;
+     * JDFLHMLFFIL NOGDNLNLMJH = 9;
+     *
+ * + * optional .ChessRogueCurrentInfo current_info = 12; + */ + private final ChessRogueCurrentInfoOuterClass.ChessRogueCurrentInfo currentInfo = ChessRogueCurrentInfoOuterClass.ChessRogueCurrentInfo.newInstance(); + + private ChessRogueQueryScRsp() { + } + + /** + * @return a new empty instance of {@code ChessRogueQueryScRsp} + */ + public static ChessRogueQueryScRsp newInstance() { + return new ChessRogueQueryScRsp(); + } + + /** + * optional uint32 retcode = 3; + * @return whether the retcode field is set + */ + public boolean hasRetcode() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 retcode = 3; + * @return this + */ + public ChessRogueQueryScRsp clearRetcode() { + bitField0_ &= ~0x00000001; + retcode = 0; + return this; + } + + /** + * optional uint32 retcode = 3; + * @return the retcode + */ + public int getRetcode() { + return retcode; + } + + /** + * optional uint32 retcode = 3; + * @param value the retcode to set + * @return this + */ + public ChessRogueQueryScRsp setRetcode(final int value) { + bitField0_ |= 0x00000001; + retcode = value; + return this; + } + + /** + * optional .ChessRogueNousQueryInfo rogue_nous = 10; + * @return whether the rogueNous field is set + */ + public boolean hasRogueNous() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional .ChessRogueNousQueryInfo rogue_nous = 10; + * @return this + */ + public ChessRogueQueryScRsp clearRogueNous() { + bitField0_ &= ~0x00000002; + rogueNous.clear(); + return this; + } + + /** + * optional .ChessRogueNousQueryInfo rogue_nous = 10; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableRogueNous()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueNousQueryInfoOuterClass.ChessRogueNousQueryInfo getRogueNous() { + return rogueNous; + } + + /** + * optional .ChessRogueNousQueryInfo rogue_nous = 10; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueNousQueryInfoOuterClass.ChessRogueNousQueryInfo getMutableRogueNous() { + bitField0_ |= 0x00000002; + return rogueNous; + } + + /** + * optional .ChessRogueNousQueryInfo rogue_nous = 10; + * @param value the rogueNous to set + * @return this + */ + public ChessRogueQueryScRsp setRogueNous( + final ChessRogueNousQueryInfoOuterClass.ChessRogueNousQueryInfo value) { + bitField0_ |= 0x00000002; + rogueNous.copyFrom(value); + return this; + } + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 15;
+     * HFKELKECMJE MKCLHOMEICF = 4;
+     * JDFLHMLFFIL NOGDNLNLMJH = 9;
+     *
+ * + * optional .ChessRogueCurrentInfo current_info = 12; + * @return whether the currentInfo field is set + */ + public boolean hasCurrentInfo() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 15;
+     * HFKELKECMJE MKCLHOMEICF = 4;
+     * JDFLHMLFFIL NOGDNLNLMJH = 9;
+     *
+ * + * optional .ChessRogueCurrentInfo current_info = 12; + * @return this + */ + public ChessRogueQueryScRsp clearCurrentInfo() { + bitField0_ &= ~0x00000004; + currentInfo.clear(); + return this; + } + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 15;
+     * HFKELKECMJE MKCLHOMEICF = 4;
+     * JDFLHMLFFIL NOGDNLNLMJH = 9;
+     *
+ * + * optional .ChessRogueCurrentInfo current_info = 12; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableCurrentInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueCurrentInfoOuterClass.ChessRogueCurrentInfo getCurrentInfo() { + return currentInfo; + } + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 15;
+     * HFKELKECMJE MKCLHOMEICF = 4;
+     * JDFLHMLFFIL NOGDNLNLMJH = 9;
+     *
+ * + * optional .ChessRogueCurrentInfo current_info = 12; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueCurrentInfoOuterClass.ChessRogueCurrentInfo getMutableCurrentInfo() { + bitField0_ |= 0x00000004; + return currentInfo; + } + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 15;
+     * HFKELKECMJE MKCLHOMEICF = 4;
+     * JDFLHMLFFIL NOGDNLNLMJH = 9;
+     *
+ * + * optional .ChessRogueCurrentInfo current_info = 12; + * @param value the currentInfo to set + * @return this + */ + public ChessRogueQueryScRsp setCurrentInfo( + final ChessRogueCurrentInfoOuterClass.ChessRogueCurrentInfo value) { + bitField0_ |= 0x00000004; + currentInfo.copyFrom(value); + return this; + } + + @Override + public ChessRogueQueryScRsp copyFrom(final ChessRogueQueryScRsp other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + retcode = other.retcode; + rogueNous.copyFrom(other.rogueNous); + currentInfo.copyFrom(other.currentInfo); + } + return this; + } + + @Override + public ChessRogueQueryScRsp mergeFrom(final ChessRogueQueryScRsp other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRetcode()) { + setRetcode(other.retcode); + } + if (other.hasRogueNous()) { + getMutableRogueNous().mergeFrom(other.rogueNous); + } + if (other.hasCurrentInfo()) { + getMutableCurrentInfo().mergeFrom(other.currentInfo); + } + return this; + } + + @Override + public ChessRogueQueryScRsp clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + retcode = 0; + rogueNous.clear(); + currentInfo.clear(); + return this; + } + + @Override + public ChessRogueQueryScRsp clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + rogueNous.clearQuick(); + currentInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueQueryScRsp)) { + return false; + } + ChessRogueQueryScRsp other = (ChessRogueQueryScRsp) o; + return bitField0_ == other.bitField0_ + && (!hasRetcode() || retcode == other.retcode) + && (!hasRogueNous() || rogueNous.equals(other.rogueNous)) + && (!hasCurrentInfo() || currentInfo.equals(other.currentInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 82); + output.writeMessageNoTag(rogueNous); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 98); + output.writeMessageNoTag(currentInfo); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(rogueNous); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(currentInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueQueryScRsp mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 24: { + // retcode + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 82) { + break; + } + } + case 82: { + // rogueNous + input.readMessage(rogueNous); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 98) { + break; + } + } + case 98: { + // currentInfo + input.readMessage(currentInfo); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.retcode, retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeMessage(FieldNames.rogueNous, rogueNous); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeMessage(FieldNames.currentInfo, currentInfo); + } + output.endObject(); + } + + @Override + public ChessRogueQueryScRsp mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1097936398: { + if (input.isAtField(FieldNames.retcode)) { + if (!input.trySkipNullValue()) { + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 655959321: + case -1124433052: { + if (input.isAtField(FieldNames.rogueNous)) { + if (!input.trySkipNullValue()) { + input.readMessage(rogueNous); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 600912327: + case 1468588980: { + if (input.isAtField(FieldNames.currentInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(currentInfo); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueQueryScRsp clone() { + return new ChessRogueQueryScRsp().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueQueryScRsp parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueQueryScRsp(), data).checkInitialized(); + } + + public static ChessRogueQueryScRsp parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueQueryScRsp(), input).checkInitialized(); + } + + public static ChessRogueQueryScRsp parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueQueryScRsp(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueQueryScRsp messages + */ + public static MessageFactory getFactory() { + return ChessRogueQueryScRspFactory.INSTANCE; + } + + private enum ChessRogueQueryScRspFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueQueryScRsp create() { + return ChessRogueQueryScRsp.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName retcode = FieldName.forField("retcode"); + + static final FieldName rogueNous = FieldName.forField("rogueNous", "rogue_nous"); + + static final FieldName currentInfo = FieldName.forField("currentInfo", "current_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueReRollDiceCsReqOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueReRollDiceCsReqOuterClass.java new file mode 100644 index 0000000..36e290c --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueReRollDiceCsReqOuterClass.java @@ -0,0 +1,260 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueReRollDiceCsReqOuterClass { + /** + * Protobuf type {@code ChessRogueReRollDiceCsReq} + */ + public static final class ChessRogueReRollDiceCsReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 entity_id = 14; + */ + private int entityId; + + private ChessRogueReRollDiceCsReq() { + } + + /** + * @return a new empty instance of {@code ChessRogueReRollDiceCsReq} + */ + public static ChessRogueReRollDiceCsReq newInstance() { + return new ChessRogueReRollDiceCsReq(); + } + + /** + * optional uint32 entity_id = 14; + * @return whether the entityId field is set + */ + public boolean hasEntityId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 entity_id = 14; + * @return this + */ + public ChessRogueReRollDiceCsReq clearEntityId() { + bitField0_ &= ~0x00000001; + entityId = 0; + return this; + } + + /** + * optional uint32 entity_id = 14; + * @return the entityId + */ + public int getEntityId() { + return entityId; + } + + /** + * optional uint32 entity_id = 14; + * @param value the entityId to set + * @return this + */ + public ChessRogueReRollDiceCsReq setEntityId(final int value) { + bitField0_ |= 0x00000001; + entityId = value; + return this; + } + + @Override + public ChessRogueReRollDiceCsReq copyFrom(final ChessRogueReRollDiceCsReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + entityId = other.entityId; + } + return this; + } + + @Override + public ChessRogueReRollDiceCsReq mergeFrom(final ChessRogueReRollDiceCsReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasEntityId()) { + setEntityId(other.entityId); + } + return this; + } + + @Override + public ChessRogueReRollDiceCsReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + entityId = 0; + return this; + } + + @Override + public ChessRogueReRollDiceCsReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueReRollDiceCsReq)) { + return false; + } + ChessRogueReRollDiceCsReq other = (ChessRogueReRollDiceCsReq) o; + return bitField0_ == other.bitField0_ + && (!hasEntityId() || entityId == other.entityId); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 112); + output.writeUInt32NoTag(entityId); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(entityId); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueReRollDiceCsReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 112: { + // entityId + entityId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.entityId, entityId); + } + output.endObject(); + } + + @Override + public ChessRogueReRollDiceCsReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -2102099874: + case -740565257: { + if (input.isAtField(FieldNames.entityId)) { + if (!input.trySkipNullValue()) { + entityId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueReRollDiceCsReq clone() { + return new ChessRogueReRollDiceCsReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueReRollDiceCsReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueReRollDiceCsReq(), data).checkInitialized(); + } + + public static ChessRogueReRollDiceCsReq parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueReRollDiceCsReq(), input).checkInitialized(); + } + + public static ChessRogueReRollDiceCsReq parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueReRollDiceCsReq(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueReRollDiceCsReq messages + */ + public static MessageFactory getFactory() { + return ChessRogueReRollDiceCsReqFactory.INSTANCE; + } + + private enum ChessRogueReRollDiceCsReqFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueReRollDiceCsReq create() { + return ChessRogueReRollDiceCsReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName entityId = FieldName.forField("entityId", "entity_id"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueRollDiceCsReqOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueRollDiceCsReqOuterClass.java new file mode 100644 index 0000000..d40d637 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueRollDiceCsReqOuterClass.java @@ -0,0 +1,260 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueRollDiceCsReqOuterClass { + /** + * Protobuf type {@code ChessRogueRollDiceCsReq} + */ + public static final class ChessRogueRollDiceCsReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 entity_id = 4; + */ + private int entityId; + + private ChessRogueRollDiceCsReq() { + } + + /** + * @return a new empty instance of {@code ChessRogueRollDiceCsReq} + */ + public static ChessRogueRollDiceCsReq newInstance() { + return new ChessRogueRollDiceCsReq(); + } + + /** + * optional uint32 entity_id = 4; + * @return whether the entityId field is set + */ + public boolean hasEntityId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 entity_id = 4; + * @return this + */ + public ChessRogueRollDiceCsReq clearEntityId() { + bitField0_ &= ~0x00000001; + entityId = 0; + return this; + } + + /** + * optional uint32 entity_id = 4; + * @return the entityId + */ + public int getEntityId() { + return entityId; + } + + /** + * optional uint32 entity_id = 4; + * @param value the entityId to set + * @return this + */ + public ChessRogueRollDiceCsReq setEntityId(final int value) { + bitField0_ |= 0x00000001; + entityId = value; + return this; + } + + @Override + public ChessRogueRollDiceCsReq copyFrom(final ChessRogueRollDiceCsReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + entityId = other.entityId; + } + return this; + } + + @Override + public ChessRogueRollDiceCsReq mergeFrom(final ChessRogueRollDiceCsReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasEntityId()) { + setEntityId(other.entityId); + } + return this; + } + + @Override + public ChessRogueRollDiceCsReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + entityId = 0; + return this; + } + + @Override + public ChessRogueRollDiceCsReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueRollDiceCsReq)) { + return false; + } + ChessRogueRollDiceCsReq other = (ChessRogueRollDiceCsReq) o; + return bitField0_ == other.bitField0_ + && (!hasEntityId() || entityId == other.entityId); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(entityId); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(entityId); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueRollDiceCsReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 32: { + // entityId + entityId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.entityId, entityId); + } + output.endObject(); + } + + @Override + public ChessRogueRollDiceCsReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -2102099874: + case -740565257: { + if (input.isAtField(FieldNames.entityId)) { + if (!input.trySkipNullValue()) { + entityId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueRollDiceCsReq clone() { + return new ChessRogueRollDiceCsReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueRollDiceCsReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueRollDiceCsReq(), data).checkInitialized(); + } + + public static ChessRogueRollDiceCsReq parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueRollDiceCsReq(), input).checkInitialized(); + } + + public static ChessRogueRollDiceCsReq parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueRollDiceCsReq(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueRollDiceCsReq messages + */ + public static MessageFactory getFactory() { + return ChessRogueRollDiceCsReqFactory.INSTANCE; + } + + private enum ChessRogueRollDiceCsReqFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueRollDiceCsReq create() { + return ChessRogueRollDiceCsReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName entityId = FieldName.forField("entityId", "entity_id"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueRollDiceScRspOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueRollDiceScRspOuterClass.java new file mode 100644 index 0000000..ab02ad8 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueRollDiceScRspOuterClass.java @@ -0,0 +1,442 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueRollDiceScRspOuterClass { + /** + * Protobuf type {@code ChessRogueRollDiceScRsp} + */ + public static final class ChessRogueRollDiceScRsp extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 retcode = 10; + */ + private int retcode; + + /** + * optional uint32 OHNDNDDKAEG = 11; + */ + private int oHNDNDDKAEG; + + /** + * optional .ChessRogueNousDice nous_dice = 6; + */ + private final ChessRogueNousDiceOuterClass.ChessRogueNousDice nousDice = ChessRogueNousDiceOuterClass.ChessRogueNousDice.newInstance(); + + private ChessRogueRollDiceScRsp() { + } + + /** + * @return a new empty instance of {@code ChessRogueRollDiceScRsp} + */ + public static ChessRogueRollDiceScRsp newInstance() { + return new ChessRogueRollDiceScRsp(); + } + + /** + * optional uint32 retcode = 10; + * @return whether the retcode field is set + */ + public boolean hasRetcode() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 retcode = 10; + * @return this + */ + public ChessRogueRollDiceScRsp clearRetcode() { + bitField0_ &= ~0x00000001; + retcode = 0; + return this; + } + + /** + * optional uint32 retcode = 10; + * @return the retcode + */ + public int getRetcode() { + return retcode; + } + + /** + * optional uint32 retcode = 10; + * @param value the retcode to set + * @return this + */ + public ChessRogueRollDiceScRsp setRetcode(final int value) { + bitField0_ |= 0x00000001; + retcode = value; + return this; + } + + /** + * optional uint32 OHNDNDDKAEG = 11; + * @return whether the oHNDNDDKAEG field is set + */ + public boolean hasOHNDNDDKAEG() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 OHNDNDDKAEG = 11; + * @return this + */ + public ChessRogueRollDiceScRsp clearOHNDNDDKAEG() { + bitField0_ &= ~0x00000002; + oHNDNDDKAEG = 0; + return this; + } + + /** + * optional uint32 OHNDNDDKAEG = 11; + * @return the oHNDNDDKAEG + */ + public int getOHNDNDDKAEG() { + return oHNDNDDKAEG; + } + + /** + * optional uint32 OHNDNDDKAEG = 11; + * @param value the oHNDNDDKAEG to set + * @return this + */ + public ChessRogueRollDiceScRsp setOHNDNDDKAEG(final int value) { + bitField0_ |= 0x00000002; + oHNDNDDKAEG = value; + return this; + } + + /** + * optional .ChessRogueNousDice nous_dice = 6; + * @return whether the nousDice field is set + */ + public boolean hasNousDice() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional .ChessRogueNousDice nous_dice = 6; + * @return this + */ + public ChessRogueRollDiceScRsp clearNousDice() { + bitField0_ &= ~0x00000004; + nousDice.clear(); + return this; + } + + /** + * optional .ChessRogueNousDice nous_dice = 6; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableNousDice()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueNousDiceOuterClass.ChessRogueNousDice getNousDice() { + return nousDice; + } + + /** + * optional .ChessRogueNousDice nous_dice = 6; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueNousDiceOuterClass.ChessRogueNousDice getMutableNousDice() { + bitField0_ |= 0x00000004; + return nousDice; + } + + /** + * optional .ChessRogueNousDice nous_dice = 6; + * @param value the nousDice to set + * @return this + */ + public ChessRogueRollDiceScRsp setNousDice( + final ChessRogueNousDiceOuterClass.ChessRogueNousDice value) { + bitField0_ |= 0x00000004; + nousDice.copyFrom(value); + return this; + } + + @Override + public ChessRogueRollDiceScRsp copyFrom(final ChessRogueRollDiceScRsp other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + retcode = other.retcode; + oHNDNDDKAEG = other.oHNDNDDKAEG; + nousDice.copyFrom(other.nousDice); + } + return this; + } + + @Override + public ChessRogueRollDiceScRsp mergeFrom(final ChessRogueRollDiceScRsp other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRetcode()) { + setRetcode(other.retcode); + } + if (other.hasOHNDNDDKAEG()) { + setOHNDNDDKAEG(other.oHNDNDDKAEG); + } + if (other.hasNousDice()) { + getMutableNousDice().mergeFrom(other.nousDice); + } + return this; + } + + @Override + public ChessRogueRollDiceScRsp clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + retcode = 0; + oHNDNDDKAEG = 0; + nousDice.clear(); + return this; + } + + @Override + public ChessRogueRollDiceScRsp clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nousDice.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueRollDiceScRsp)) { + return false; + } + ChessRogueRollDiceScRsp other = (ChessRogueRollDiceScRsp) o; + return bitField0_ == other.bitField0_ + && (!hasRetcode() || retcode == other.retcode) + && (!hasOHNDNDDKAEG() || oHNDNDDKAEG == other.oHNDNDDKAEG) + && (!hasNousDice() || nousDice.equals(other.nousDice)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 80); + output.writeUInt32NoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 88); + output.writeUInt32NoTag(oHNDNDDKAEG); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 50); + output.writeMessageNoTag(nousDice); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(oHNDNDDKAEG); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(nousDice); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueRollDiceScRsp mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 80: { + // retcode + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 88) { + break; + } + } + case 88: { + // oHNDNDDKAEG + oHNDNDDKAEG = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 50) { + break; + } + } + case 50: { + // nousDice + input.readMessage(nousDice); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.retcode, retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.oHNDNDDKAEG, oHNDNDDKAEG); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeMessage(FieldNames.nousDice, nousDice); + } + output.endObject(); + } + + @Override + public ChessRogueRollDiceScRsp mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1097936398: { + if (input.isAtField(FieldNames.retcode)) { + if (!input.trySkipNullValue()) { + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 32875159: { + if (input.isAtField(FieldNames.oHNDNDDKAEG)) { + if (!input.trySkipNullValue()) { + oHNDNDDKAEG = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1622214758: + case -1226158137: { + if (input.isAtField(FieldNames.nousDice)) { + if (!input.trySkipNullValue()) { + input.readMessage(nousDice); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueRollDiceScRsp clone() { + return new ChessRogueRollDiceScRsp().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueRollDiceScRsp parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueRollDiceScRsp(), data).checkInitialized(); + } + + public static ChessRogueRollDiceScRsp parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueRollDiceScRsp(), input).checkInitialized(); + } + + public static ChessRogueRollDiceScRsp parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueRollDiceScRsp(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueRollDiceScRsp messages + */ + public static MessageFactory getFactory() { + return ChessRogueRollDiceScRspFactory.INSTANCE; + } + + private enum ChessRogueRollDiceScRspFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueRollDiceScRsp create() { + return ChessRogueRollDiceScRsp.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName retcode = FieldName.forField("retcode"); + + static final FieldName oHNDNDDKAEG = FieldName.forField("OHNDNDDKAEG"); + + static final FieldName nousDice = FieldName.forField("nousDice", "nous_dice"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueSelectCellCsReqOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueSelectCellCsReqOuterClass.java new file mode 100644 index 0000000..d42caae --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueSelectCellCsReqOuterClass.java @@ -0,0 +1,260 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueSelectCellCsReqOuterClass { + /** + * Protobuf type {@code ChessRogueSelectCellCsReq} + */ + public static final class ChessRogueSelectCellCsReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 cell_id = 11; + */ + private int cellId; + + private ChessRogueSelectCellCsReq() { + } + + /** + * @return a new empty instance of {@code ChessRogueSelectCellCsReq} + */ + public static ChessRogueSelectCellCsReq newInstance() { + return new ChessRogueSelectCellCsReq(); + } + + /** + * optional uint32 cell_id = 11; + * @return whether the cellId field is set + */ + public boolean hasCellId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 cell_id = 11; + * @return this + */ + public ChessRogueSelectCellCsReq clearCellId() { + bitField0_ &= ~0x00000001; + cellId = 0; + return this; + } + + /** + * optional uint32 cell_id = 11; + * @return the cellId + */ + public int getCellId() { + return cellId; + } + + /** + * optional uint32 cell_id = 11; + * @param value the cellId to set + * @return this + */ + public ChessRogueSelectCellCsReq setCellId(final int value) { + bitField0_ |= 0x00000001; + cellId = value; + return this; + } + + @Override + public ChessRogueSelectCellCsReq copyFrom(final ChessRogueSelectCellCsReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + cellId = other.cellId; + } + return this; + } + + @Override + public ChessRogueSelectCellCsReq mergeFrom(final ChessRogueSelectCellCsReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasCellId()) { + setCellId(other.cellId); + } + return this; + } + + @Override + public ChessRogueSelectCellCsReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + cellId = 0; + return this; + } + + @Override + public ChessRogueSelectCellCsReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueSelectCellCsReq)) { + return false; + } + ChessRogueSelectCellCsReq other = (ChessRogueSelectCellCsReq) o; + return bitField0_ == other.bitField0_ + && (!hasCellId() || cellId == other.cellId); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 88); + output.writeUInt32NoTag(cellId); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(cellId); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueSelectCellCsReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 88: { + // cellId + cellId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.cellId, cellId); + } + output.endObject(); + } + + @Override + public ChessRogueSelectCellCsReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1364082147: + case 663147800: { + if (input.isAtField(FieldNames.cellId)) { + if (!input.trySkipNullValue()) { + cellId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueSelectCellCsReq clone() { + return new ChessRogueSelectCellCsReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueSelectCellCsReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueSelectCellCsReq(), data).checkInitialized(); + } + + public static ChessRogueSelectCellCsReq parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueSelectCellCsReq(), input).checkInitialized(); + } + + public static ChessRogueSelectCellCsReq parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueSelectCellCsReq(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueSelectCellCsReq messages + */ + public static MessageFactory getFactory() { + return ChessRogueSelectCellCsReqFactory.INSTANCE; + } + + private enum ChessRogueSelectCellCsReqFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueSelectCellCsReq create() { + return ChessRogueSelectCellCsReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName cellId = FieldName.forField("cellId", "cell_id"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueSelectCellScRspOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueSelectCellScRspOuterClass.java new file mode 100644 index 0000000..a3fb409 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueSelectCellScRspOuterClass.java @@ -0,0 +1,521 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueSelectCellScRspOuterClass { + /** + * Protobuf type {@code ChessRogueSelectCellScRsp} + */ + public static final class ChessRogueSelectCellScRsp extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 JNBHLHFBBBJ = 5; + */ + private int jNBHLHFBBBJ; + + /** + * optional uint32 retcode = 7; + */ + private int retcode; + + /** + * optional uint32 cell_id = 13; + */ + private int cellId; + + /** + * optional .LLJFPKKLGAK NDGOHDPDKAD = 10; + */ + private final LLJFPKKLGAKOuterClass.LLJFPKKLGAK nDGOHDPDKAD = LLJFPKKLGAKOuterClass.LLJFPKKLGAK.newInstance(); + + private ChessRogueSelectCellScRsp() { + } + + /** + * @return a new empty instance of {@code ChessRogueSelectCellScRsp} + */ + public static ChessRogueSelectCellScRsp newInstance() { + return new ChessRogueSelectCellScRsp(); + } + + /** + * optional uint32 JNBHLHFBBBJ = 5; + * @return whether the jNBHLHFBBBJ field is set + */ + public boolean hasJNBHLHFBBBJ() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 JNBHLHFBBBJ = 5; + * @return this + */ + public ChessRogueSelectCellScRsp clearJNBHLHFBBBJ() { + bitField0_ &= ~0x00000001; + jNBHLHFBBBJ = 0; + return this; + } + + /** + * optional uint32 JNBHLHFBBBJ = 5; + * @return the jNBHLHFBBBJ + */ + public int getJNBHLHFBBBJ() { + return jNBHLHFBBBJ; + } + + /** + * optional uint32 JNBHLHFBBBJ = 5; + * @param value the jNBHLHFBBBJ to set + * @return this + */ + public ChessRogueSelectCellScRsp setJNBHLHFBBBJ(final int value) { + bitField0_ |= 0x00000001; + jNBHLHFBBBJ = value; + return this; + } + + /** + * optional uint32 retcode = 7; + * @return whether the retcode field is set + */ + public boolean hasRetcode() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 retcode = 7; + * @return this + */ + public ChessRogueSelectCellScRsp clearRetcode() { + bitField0_ &= ~0x00000002; + retcode = 0; + return this; + } + + /** + * optional uint32 retcode = 7; + * @return the retcode + */ + public int getRetcode() { + return retcode; + } + + /** + * optional uint32 retcode = 7; + * @param value the retcode to set + * @return this + */ + public ChessRogueSelectCellScRsp setRetcode(final int value) { + bitField0_ |= 0x00000002; + retcode = value; + return this; + } + + /** + * optional uint32 cell_id = 13; + * @return whether the cellId field is set + */ + public boolean hasCellId() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 cell_id = 13; + * @return this + */ + public ChessRogueSelectCellScRsp clearCellId() { + bitField0_ &= ~0x00000004; + cellId = 0; + return this; + } + + /** + * optional uint32 cell_id = 13; + * @return the cellId + */ + public int getCellId() { + return cellId; + } + + /** + * optional uint32 cell_id = 13; + * @param value the cellId to set + * @return this + */ + public ChessRogueSelectCellScRsp setCellId(final int value) { + bitField0_ |= 0x00000004; + cellId = value; + return this; + } + + /** + * optional .LLJFPKKLGAK NDGOHDPDKAD = 10; + * @return whether the nDGOHDPDKAD field is set + */ + public boolean hasNDGOHDPDKAD() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional .LLJFPKKLGAK NDGOHDPDKAD = 10; + * @return this + */ + public ChessRogueSelectCellScRsp clearNDGOHDPDKAD() { + bitField0_ &= ~0x00000008; + nDGOHDPDKAD.clear(); + return this; + } + + /** + * optional .LLJFPKKLGAK NDGOHDPDKAD = 10; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableNDGOHDPDKAD()} if you want to modify it. + * + * @return internal storage object for reading + */ + public LLJFPKKLGAKOuterClass.LLJFPKKLGAK getNDGOHDPDKAD() { + return nDGOHDPDKAD; + } + + /** + * optional .LLJFPKKLGAK NDGOHDPDKAD = 10; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public LLJFPKKLGAKOuterClass.LLJFPKKLGAK getMutableNDGOHDPDKAD() { + bitField0_ |= 0x00000008; + return nDGOHDPDKAD; + } + + /** + * optional .LLJFPKKLGAK NDGOHDPDKAD = 10; + * @param value the nDGOHDPDKAD to set + * @return this + */ + public ChessRogueSelectCellScRsp setNDGOHDPDKAD(final LLJFPKKLGAKOuterClass.LLJFPKKLGAK value) { + bitField0_ |= 0x00000008; + nDGOHDPDKAD.copyFrom(value); + return this; + } + + @Override + public ChessRogueSelectCellScRsp copyFrom(final ChessRogueSelectCellScRsp other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + jNBHLHFBBBJ = other.jNBHLHFBBBJ; + retcode = other.retcode; + cellId = other.cellId; + nDGOHDPDKAD.copyFrom(other.nDGOHDPDKAD); + } + return this; + } + + @Override + public ChessRogueSelectCellScRsp mergeFrom(final ChessRogueSelectCellScRsp other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasJNBHLHFBBBJ()) { + setJNBHLHFBBBJ(other.jNBHLHFBBBJ); + } + if (other.hasRetcode()) { + setRetcode(other.retcode); + } + if (other.hasCellId()) { + setCellId(other.cellId); + } + if (other.hasNDGOHDPDKAD()) { + getMutableNDGOHDPDKAD().mergeFrom(other.nDGOHDPDKAD); + } + return this; + } + + @Override + public ChessRogueSelectCellScRsp clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + jNBHLHFBBBJ = 0; + retcode = 0; + cellId = 0; + nDGOHDPDKAD.clear(); + return this; + } + + @Override + public ChessRogueSelectCellScRsp clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nDGOHDPDKAD.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueSelectCellScRsp)) { + return false; + } + ChessRogueSelectCellScRsp other = (ChessRogueSelectCellScRsp) o; + return bitField0_ == other.bitField0_ + && (!hasJNBHLHFBBBJ() || jNBHLHFBBBJ == other.jNBHLHFBBBJ) + && (!hasRetcode() || retcode == other.retcode) + && (!hasCellId() || cellId == other.cellId) + && (!hasNDGOHDPDKAD() || nDGOHDPDKAD.equals(other.nDGOHDPDKAD)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 40); + output.writeUInt32NoTag(jNBHLHFBBBJ); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 56); + output.writeUInt32NoTag(retcode); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 104); + output.writeUInt32NoTag(cellId); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 82); + output.writeMessageNoTag(nDGOHDPDKAD); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(jNBHLHFBBBJ); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(retcode); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(cellId); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(nDGOHDPDKAD); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueSelectCellScRsp mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 40: { + // jNBHLHFBBBJ + jNBHLHFBBBJ = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 56) { + break; + } + } + case 56: { + // retcode + retcode = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 104) { + break; + } + } + case 104: { + // cellId + cellId = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 82) { + break; + } + } + case 82: { + // nDGOHDPDKAD + input.readMessage(nDGOHDPDKAD); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.jNBHLHFBBBJ, jNBHLHFBBBJ); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.retcode, retcode); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.cellId, cellId); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeMessage(FieldNames.nDGOHDPDKAD, nDGOHDPDKAD); + } + output.endObject(); + } + + @Override + public ChessRogueSelectCellScRsp mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 480596488: { + if (input.isAtField(FieldNames.jNBHLHFBBBJ)) { + if (!input.trySkipNullValue()) { + jNBHLHFBBBJ = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1097936398: { + if (input.isAtField(FieldNames.retcode)) { + if (!input.trySkipNullValue()) { + retcode = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1364082147: + case 663147800: { + if (input.isAtField(FieldNames.cellId)) { + if (!input.trySkipNullValue()) { + cellId = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -939934496: { + if (input.isAtField(FieldNames.nDGOHDPDKAD)) { + if (!input.trySkipNullValue()) { + input.readMessage(nDGOHDPDKAD); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueSelectCellScRsp clone() { + return new ChessRogueSelectCellScRsp().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueSelectCellScRsp parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueSelectCellScRsp(), data).checkInitialized(); + } + + public static ChessRogueSelectCellScRsp parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueSelectCellScRsp(), input).checkInitialized(); + } + + public static ChessRogueSelectCellScRsp parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueSelectCellScRsp(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueSelectCellScRsp messages + */ + public static MessageFactory getFactory() { + return ChessRogueSelectCellScRspFactory.INSTANCE; + } + + private enum ChessRogueSelectCellScRspFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueSelectCellScRsp create() { + return ChessRogueSelectCellScRsp.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName jNBHLHFBBBJ = FieldName.forField("JNBHLHFBBBJ"); + + static final FieldName retcode = FieldName.forField("retcode"); + + static final FieldName cellId = FieldName.forField("cellId", "cell_id"); + + static final FieldName nDGOHDPDKAD = FieldName.forField("NDGOHDPDKAD"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueStartCsReqOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueStartCsReqOuterClass.java new file mode 100644 index 0000000..9d0129c --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueStartCsReqOuterClass.java @@ -0,0 +1,924 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedInt; + +public final class ChessRogueStartCsReqOuterClass { + /** + * Protobuf type {@code ChessRogueStartCsReq} + */ + public static final class ChessRogueStartCsReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * 
+     *  guess this is the difficulty level
+     *
+ * + * optional uint32 KOLEFJKMFLF = 1; + */ + private int kOLEFJKMFLF; + + /** + * optional uint32 area_id = 5; + */ + private int areaId; + + /** + * optional uint32 dice_branch_id = 9; + */ + private int diceBranchId; + + /** + * repeated uint32 DDDICOEFHPM = 6; + */ + private final RepeatedInt dDDICOEFHPM = RepeatedInt.newEmptyInstance(); + + /** + * repeated uint32 JDCMGPJHGLG = 8; + */ + private final RepeatedInt jDCMGPJHGLG = RepeatedInt.newEmptyInstance(); + + /** + * repeated uint32 disable_aeon_id = 13; + */ + private final RepeatedInt disableAeonId = RepeatedInt.newEmptyInstance(); + + /** + * repeated uint32 base_avatar_id_list = 15; + */ + private final RepeatedInt baseAvatarIdList = RepeatedInt.newEmptyInstance(); + + private ChessRogueStartCsReq() { + } + + /** + * @return a new empty instance of {@code ChessRogueStartCsReq} + */ + public static ChessRogueStartCsReq newInstance() { + return new ChessRogueStartCsReq(); + } + + /** + * 
+     *  guess this is the difficulty level
+     *
+ * + * optional uint32 KOLEFJKMFLF = 1; + * @return whether the kOLEFJKMFLF field is set + */ + public boolean hasKOLEFJKMFLF() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * 
+     *  guess this is the difficulty level
+     *
+ * + * optional uint32 KOLEFJKMFLF = 1; + * @return this + */ + public ChessRogueStartCsReq clearKOLEFJKMFLF() { + bitField0_ &= ~0x00000001; + kOLEFJKMFLF = 0; + return this; + } + + /** + * 
+     *  guess this is the difficulty level
+     *
+ * + * optional uint32 KOLEFJKMFLF = 1; + * @return the kOLEFJKMFLF + */ + public int getKOLEFJKMFLF() { + return kOLEFJKMFLF; + } + + /** + * 
+     *  guess this is the difficulty level
+     *
+ * + * optional uint32 KOLEFJKMFLF = 1; + * @param value the kOLEFJKMFLF to set + * @return this + */ + public ChessRogueStartCsReq setKOLEFJKMFLF(final int value) { + bitField0_ |= 0x00000001; + kOLEFJKMFLF = value; + return this; + } + + /** + * optional uint32 area_id = 5; + * @return whether the areaId field is set + */ + public boolean hasAreaId() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 area_id = 5; + * @return this + */ + public ChessRogueStartCsReq clearAreaId() { + bitField0_ &= ~0x00000002; + areaId = 0; + return this; + } + + /** + * optional uint32 area_id = 5; + * @return the areaId + */ + public int getAreaId() { + return areaId; + } + + /** + * optional uint32 area_id = 5; + * @param value the areaId to set + * @return this + */ + public ChessRogueStartCsReq setAreaId(final int value) { + bitField0_ |= 0x00000002; + areaId = value; + return this; + } + + /** + * optional uint32 dice_branch_id = 9; + * @return whether the diceBranchId field is set + */ + public boolean hasDiceBranchId() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 dice_branch_id = 9; + * @return this + */ + public ChessRogueStartCsReq clearDiceBranchId() { + bitField0_ &= ~0x00000004; + diceBranchId = 0; + return this; + } + + /** + * optional uint32 dice_branch_id = 9; + * @return the diceBranchId + */ + public int getDiceBranchId() { + return diceBranchId; + } + + /** + * optional uint32 dice_branch_id = 9; + * @param value the diceBranchId to set + * @return this + */ + public ChessRogueStartCsReq setDiceBranchId(final int value) { + bitField0_ |= 0x00000004; + diceBranchId = value; + return this; + } + + /** + * repeated uint32 DDDICOEFHPM = 6; + * @return whether the dDDICOEFHPM field is set + */ + public boolean hasDDDICOEFHPM() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * repeated uint32 DDDICOEFHPM = 6; + * @return this + */ + public ChessRogueStartCsReq clearDDDICOEFHPM() { + bitField0_ &= ~0x00000008; + dDDICOEFHPM.clear(); + return this; + } + + /** + * repeated uint32 DDDICOEFHPM = 6; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableDDDICOEFHPM()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getDDDICOEFHPM() { + return dDDICOEFHPM; + } + + /** + * repeated uint32 DDDICOEFHPM = 6; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableDDDICOEFHPM() { + bitField0_ |= 0x00000008; + return dDDICOEFHPM; + } + + /** + * repeated uint32 DDDICOEFHPM = 6; + * @param value the dDDICOEFHPM to add + * @return this + */ + public ChessRogueStartCsReq addDDDICOEFHPM(final int value) { + bitField0_ |= 0x00000008; + dDDICOEFHPM.add(value); + return this; + } + + /** + * repeated uint32 DDDICOEFHPM = 6; + * @param values the dDDICOEFHPM to add + * @return this + */ + public ChessRogueStartCsReq addAllDDDICOEFHPM(final int... values) { + bitField0_ |= 0x00000008; + dDDICOEFHPM.addAll(values); + return this; + } + + /** + * repeated uint32 JDCMGPJHGLG = 8; + * @return whether the jDCMGPJHGLG field is set + */ + public boolean hasJDCMGPJHGLG() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * repeated uint32 JDCMGPJHGLG = 8; + * @return this + */ + public ChessRogueStartCsReq clearJDCMGPJHGLG() { + bitField0_ &= ~0x00000010; + jDCMGPJHGLG.clear(); + return this; + } + + /** + * repeated uint32 JDCMGPJHGLG = 8; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableJDCMGPJHGLG()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getJDCMGPJHGLG() { + return jDCMGPJHGLG; + } + + /** + * repeated uint32 JDCMGPJHGLG = 8; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableJDCMGPJHGLG() { + bitField0_ |= 0x00000010; + return jDCMGPJHGLG; + } + + /** + * repeated uint32 JDCMGPJHGLG = 8; + * @param value the jDCMGPJHGLG to add + * @return this + */ + public ChessRogueStartCsReq addJDCMGPJHGLG(final int value) { + bitField0_ |= 0x00000010; + jDCMGPJHGLG.add(value); + return this; + } + + /** + * repeated uint32 JDCMGPJHGLG = 8; + * @param values the jDCMGPJHGLG to add + * @return this + */ + public ChessRogueStartCsReq addAllJDCMGPJHGLG(final int... values) { + bitField0_ |= 0x00000010; + jDCMGPJHGLG.addAll(values); + return this; + } + + /** + * repeated uint32 disable_aeon_id = 13; + * @return whether the disableAeonId field is set + */ + public boolean hasDisableAeonId() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * repeated uint32 disable_aeon_id = 13; + * @return this + */ + public ChessRogueStartCsReq clearDisableAeonId() { + bitField0_ &= ~0x00000020; + disableAeonId.clear(); + return this; + } + + /** + * repeated uint32 disable_aeon_id = 13; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableDisableAeonId()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getDisableAeonId() { + return disableAeonId; + } + + /** + * repeated uint32 disable_aeon_id = 13; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableDisableAeonId() { + bitField0_ |= 0x00000020; + return disableAeonId; + } + + /** + * repeated uint32 disable_aeon_id = 13; + * @param value the disableAeonId to add + * @return this + */ + public ChessRogueStartCsReq addDisableAeonId(final int value) { + bitField0_ |= 0x00000020; + disableAeonId.add(value); + return this; + } + + /** + * repeated uint32 disable_aeon_id = 13; + * @param values the disableAeonId to add + * @return this + */ + public ChessRogueStartCsReq addAllDisableAeonId(final int... values) { + bitField0_ |= 0x00000020; + disableAeonId.addAll(values); + return this; + } + + /** + * repeated uint32 base_avatar_id_list = 15; + * @return whether the baseAvatarIdList field is set + */ + public boolean hasBaseAvatarIdList() { + return (bitField0_ & 0x00000040) != 0; + } + + /** + * repeated uint32 base_avatar_id_list = 15; + * @return this + */ + public ChessRogueStartCsReq clearBaseAvatarIdList() { + bitField0_ &= ~0x00000040; + baseAvatarIdList.clear(); + return this; + } + + /** + * repeated uint32 base_avatar_id_list = 15; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableBaseAvatarIdList()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getBaseAvatarIdList() { + return baseAvatarIdList; + } + + /** + * repeated uint32 base_avatar_id_list = 15; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableBaseAvatarIdList() { + bitField0_ |= 0x00000040; + return baseAvatarIdList; + } + + /** + * repeated uint32 base_avatar_id_list = 15; + * @param value the baseAvatarIdList to add + * @return this + */ + public ChessRogueStartCsReq addBaseAvatarIdList(final int value) { + bitField0_ |= 0x00000040; + baseAvatarIdList.add(value); + return this; + } + + /** + * repeated uint32 base_avatar_id_list = 15; + * @param values the baseAvatarIdList to add + * @return this + */ + public ChessRogueStartCsReq addAllBaseAvatarIdList(final int... values) { + bitField0_ |= 0x00000040; + baseAvatarIdList.addAll(values); + return this; + } + + @Override + public ChessRogueStartCsReq copyFrom(final ChessRogueStartCsReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + kOLEFJKMFLF = other.kOLEFJKMFLF; + areaId = other.areaId; + diceBranchId = other.diceBranchId; + dDDICOEFHPM.copyFrom(other.dDDICOEFHPM); + jDCMGPJHGLG.copyFrom(other.jDCMGPJHGLG); + disableAeonId.copyFrom(other.disableAeonId); + baseAvatarIdList.copyFrom(other.baseAvatarIdList); + } + return this; + } + + @Override + public ChessRogueStartCsReq mergeFrom(final ChessRogueStartCsReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasKOLEFJKMFLF()) { + setKOLEFJKMFLF(other.kOLEFJKMFLF); + } + if (other.hasAreaId()) { + setAreaId(other.areaId); + } + if (other.hasDiceBranchId()) { + setDiceBranchId(other.diceBranchId); + } + if (other.hasDDDICOEFHPM()) { + getMutableDDDICOEFHPM().addAll(other.dDDICOEFHPM); + } + if (other.hasJDCMGPJHGLG()) { + getMutableJDCMGPJHGLG().addAll(other.jDCMGPJHGLG); + } + if (other.hasDisableAeonId()) { + getMutableDisableAeonId().addAll(other.disableAeonId); + } + if (other.hasBaseAvatarIdList()) { + getMutableBaseAvatarIdList().addAll(other.baseAvatarIdList); + } + return this; + } + + @Override + public ChessRogueStartCsReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + kOLEFJKMFLF = 0; + areaId = 0; + diceBranchId = 0; + dDDICOEFHPM.clear(); + jDCMGPJHGLG.clear(); + disableAeonId.clear(); + baseAvatarIdList.clear(); + return this; + } + + @Override + public ChessRogueStartCsReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + dDDICOEFHPM.clear(); + jDCMGPJHGLG.clear(); + disableAeonId.clear(); + baseAvatarIdList.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueStartCsReq)) { + return false; + } + ChessRogueStartCsReq other = (ChessRogueStartCsReq) o; + return bitField0_ == other.bitField0_ + && (!hasKOLEFJKMFLF() || kOLEFJKMFLF == other.kOLEFJKMFLF) + && (!hasAreaId() || areaId == other.areaId) + && (!hasDiceBranchId() || diceBranchId == other.diceBranchId) + && (!hasDDDICOEFHPM() || dDDICOEFHPM.equals(other.dDDICOEFHPM)) + && (!hasJDCMGPJHGLG() || jDCMGPJHGLG.equals(other.jDCMGPJHGLG)) + && (!hasDisableAeonId() || disableAeonId.equals(other.disableAeonId)) + && (!hasBaseAvatarIdList() || baseAvatarIdList.equals(other.baseAvatarIdList)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(kOLEFJKMFLF); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 40); + output.writeUInt32NoTag(areaId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 72); + output.writeUInt32NoTag(diceBranchId); + } + if ((bitField0_ & 0x00000008) != 0) { + for (int i = 0; i < dDDICOEFHPM.length(); i++) { + output.writeRawByte((byte) 48); + output.writeUInt32NoTag(dDDICOEFHPM.array()[i]); + } + } + if ((bitField0_ & 0x00000010) != 0) { + for (int i = 0; i < jDCMGPJHGLG.length(); i++) { + output.writeRawByte((byte) 64); + output.writeUInt32NoTag(jDCMGPJHGLG.array()[i]); + } + } + if ((bitField0_ & 0x00000020) != 0) { + for (int i = 0; i < disableAeonId.length(); i++) { + output.writeRawByte((byte) 104); + output.writeUInt32NoTag(disableAeonId.array()[i]); + } + } + if ((bitField0_ & 0x00000040) != 0) { + for (int i = 0; i < baseAvatarIdList.length(); i++) { + output.writeRawByte((byte) 120); + output.writeUInt32NoTag(baseAvatarIdList.array()[i]); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(kOLEFJKMFLF); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(areaId); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(diceBranchId); + } + if ((bitField0_ & 0x00000008) != 0) { + size += (1 * dDDICOEFHPM.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(dDDICOEFHPM); + } + if ((bitField0_ & 0x00000010) != 0) { + size += (1 * jDCMGPJHGLG.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(jDCMGPJHGLG); + } + if ((bitField0_ & 0x00000020) != 0) { + size += (1 * disableAeonId.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(disableAeonId); + } + if ((bitField0_ & 0x00000040) != 0) { + size += (1 * baseAvatarIdList.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(baseAvatarIdList); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueStartCsReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // kOLEFJKMFLF + kOLEFJKMFLF = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 40) { + break; + } + } + case 40: { + // areaId + areaId = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 72) { + break; + } + } + case 72: { + // diceBranchId + diceBranchId = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 50) { + break; + } + } + case 50: { + // dDDICOEFHPM [packed=true] + input.readPackedUInt32(dDDICOEFHPM, tag); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 66) { + break; + } + } + case 66: { + // jDCMGPJHGLG [packed=true] + input.readPackedUInt32(jDCMGPJHGLG, tag); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 106) { + break; + } + } + case 106: { + // disableAeonId [packed=true] + input.readPackedUInt32(disableAeonId, tag); + bitField0_ |= 0x00000020; + tag = input.readTag(); + if (tag != 122) { + break; + } + } + case 122: { + // baseAvatarIdList [packed=true] + input.readPackedUInt32(baseAvatarIdList, tag); + bitField0_ |= 0x00000040; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + case 48: { + // dDDICOEFHPM [packed=false] + tag = input.readRepeatedUInt32(dDDICOEFHPM, tag); + bitField0_ |= 0x00000008; + break; + } + case 64: { + // jDCMGPJHGLG [packed=false] + tag = input.readRepeatedUInt32(jDCMGPJHGLG, tag); + bitField0_ |= 0x00000010; + break; + } + case 104: { + // disableAeonId [packed=false] + tag = input.readRepeatedUInt32(disableAeonId, tag); + bitField0_ |= 0x00000020; + break; + } + case 120: { + // baseAvatarIdList [packed=false] + tag = input.readRepeatedUInt32(baseAvatarIdList, tag); + bitField0_ |= 0x00000040; + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.kOLEFJKMFLF, kOLEFJKMFLF); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.areaId, areaId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.diceBranchId, diceBranchId); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRepeatedUInt32(FieldNames.dDDICOEFHPM, dDDICOEFHPM); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRepeatedUInt32(FieldNames.jDCMGPJHGLG, jDCMGPJHGLG); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRepeatedUInt32(FieldNames.disableAeonId, disableAeonId); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeRepeatedUInt32(FieldNames.baseAvatarIdList, baseAvatarIdList); + } + output.endObject(); + } + + @Override + public ChessRogueStartCsReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -13887267: { + if (input.isAtField(FieldNames.kOLEFJKMFLF)) { + if (!input.trySkipNullValue()) { + kOLEFJKMFLF = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1409553784: + case -746472947: { + if (input.isAtField(FieldNames.areaId)) { + if (!input.trySkipNullValue()) { + areaId = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 216999716: + case 1050456640: { + if (input.isAtField(FieldNames.diceBranchId)) { + if (!input.trySkipNullValue()) { + diceBranchId = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -727553421: { + if (input.isAtField(FieldNames.dDDICOEFHPM)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(dDDICOEFHPM); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case 852754199: { + if (input.isAtField(FieldNames.jDCMGPJHGLG)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(jDCMGPJHGLG); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1370442106: + case -1529483392: { + if (input.isAtField(FieldNames.disableAeonId)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(disableAeonId); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1212654461: + case 914628490: { + if (input.isAtField(FieldNames.baseAvatarIdList)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(baseAvatarIdList); + bitField0_ |= 0x00000040; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueStartCsReq clone() { + return new ChessRogueStartCsReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueStartCsReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueStartCsReq(), data).checkInitialized(); + } + + public static ChessRogueStartCsReq parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueStartCsReq(), input).checkInitialized(); + } + + public static ChessRogueStartCsReq parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueStartCsReq(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueStartCsReq messages + */ + public static MessageFactory getFactory() { + return ChessRogueStartCsReqFactory.INSTANCE; + } + + private enum ChessRogueStartCsReqFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueStartCsReq create() { + return ChessRogueStartCsReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName kOLEFJKMFLF = FieldName.forField("KOLEFJKMFLF"); + + static final FieldName areaId = FieldName.forField("areaId", "area_id"); + + static final FieldName diceBranchId = FieldName.forField("diceBranchId", "dice_branch_id"); + + static final FieldName dDDICOEFHPM = FieldName.forField("DDDICOEFHPM"); + + static final FieldName jDCMGPJHGLG = FieldName.forField("JDCMGPJHGLG"); + + static final FieldName disableAeonId = FieldName.forField("disableAeonId", "disable_aeon_id"); + + static final FieldName baseAvatarIdList = FieldName.forField("baseAvatarIdList", "base_avatar_id_list"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueStartScRspOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueStartScRspOuterClass.java new file mode 100644 index 0000000..76c1264 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueStartScRspOuterClass.java @@ -0,0 +1,794 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueStartScRspOuterClass { + /** + * Protobuf type {@code ChessRogueStartScRsp} + */ + public static final class ChessRogueStartScRsp extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 retcode = 2; + */ + private int retcode; + + /** + * optional .LineupInfo lineup = 1; + */ + private final LineupInfoOuterClass.LineupInfo lineup = LineupInfoOuterClass.LineupInfo.newInstance(); + + /** + * optional .SceneInfo scene = 4; + */ + private final SceneInfoOuterClass.SceneInfo scene = SceneInfoOuterClass.SceneInfo.newInstance(); + + /** + * optional .ChessRogueCellInfo cell_info = 7; + */ + private final ChessRogueCellInfoOuterClass.ChessRogueCellInfo cellInfo = ChessRogueCellInfoOuterClass.ChessRogueCellInfo.newInstance(); + + /** + * optional .ChessRogueCurrentInfo current_info = 10; + */ + private final ChessRogueCurrentInfoOuterClass.ChessRogueCurrentInfo currentInfo = ChessRogueCurrentInfoOuterClass.ChessRogueCurrentInfo.newInstance(); + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 13;
+     *
+ * + * optional .ChessRogueInfo chess_rogue_info = 11; + */ + private final ChessRogueInfoOuterClass.ChessRogueInfo chessRogueInfo = ChessRogueInfoOuterClass.ChessRogueInfo.newInstance(); + + private ChessRogueStartScRsp() { + } + + /** + * @return a new empty instance of {@code ChessRogueStartScRsp} + */ + public static ChessRogueStartScRsp newInstance() { + return new ChessRogueStartScRsp(); + } + + /** + * optional uint32 retcode = 2; + * @return whether the retcode field is set + */ + public boolean hasRetcode() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 retcode = 2; + * @return this + */ + public ChessRogueStartScRsp clearRetcode() { + bitField0_ &= ~0x00000001; + retcode = 0; + return this; + } + + /** + * optional uint32 retcode = 2; + * @return the retcode + */ + public int getRetcode() { + return retcode; + } + + /** + * optional uint32 retcode = 2; + * @param value the retcode to set + * @return this + */ + public ChessRogueStartScRsp setRetcode(final int value) { + bitField0_ |= 0x00000001; + retcode = value; + return this; + } + + /** + * optional .LineupInfo lineup = 1; + * @return whether the lineup field is set + */ + public boolean hasLineup() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional .LineupInfo lineup = 1; + * @return this + */ + public ChessRogueStartScRsp clearLineup() { + bitField0_ &= ~0x00000002; + lineup.clear(); + return this; + } + + /** + * optional .LineupInfo lineup = 1; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableLineup()} if you want to modify it. + * + * @return internal storage object for reading + */ + public LineupInfoOuterClass.LineupInfo getLineup() { + return lineup; + } + + /** + * optional .LineupInfo lineup = 1; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public LineupInfoOuterClass.LineupInfo getMutableLineup() { + bitField0_ |= 0x00000002; + return lineup; + } + + /** + * optional .LineupInfo lineup = 1; + * @param value the lineup to set + * @return this + */ + public ChessRogueStartScRsp setLineup(final LineupInfoOuterClass.LineupInfo value) { + bitField0_ |= 0x00000002; + lineup.copyFrom(value); + return this; + } + + /** + * optional .SceneInfo scene = 4; + * @return whether the scene field is set + */ + public boolean hasScene() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional .SceneInfo scene = 4; + * @return this + */ + public ChessRogueStartScRsp clearScene() { + bitField0_ &= ~0x00000004; + scene.clear(); + return this; + } + + /** + * optional .SceneInfo scene = 4; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableScene()} if you want to modify it. + * + * @return internal storage object for reading + */ + public SceneInfoOuterClass.SceneInfo getScene() { + return scene; + } + + /** + * optional .SceneInfo scene = 4; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public SceneInfoOuterClass.SceneInfo getMutableScene() { + bitField0_ |= 0x00000004; + return scene; + } + + /** + * optional .SceneInfo scene = 4; + * @param value the scene to set + * @return this + */ + public ChessRogueStartScRsp setScene(final SceneInfoOuterClass.SceneInfo value) { + bitField0_ |= 0x00000004; + scene.copyFrom(value); + return this; + } + + /** + * optional .ChessRogueCellInfo cell_info = 7; + * @return whether the cellInfo field is set + */ + public boolean hasCellInfo() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional .ChessRogueCellInfo cell_info = 7; + * @return this + */ + public ChessRogueStartScRsp clearCellInfo() { + bitField0_ &= ~0x00000008; + cellInfo.clear(); + return this; + } + + /** + * optional .ChessRogueCellInfo cell_info = 7; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableCellInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueCellInfoOuterClass.ChessRogueCellInfo getCellInfo() { + return cellInfo; + } + + /** + * optional .ChessRogueCellInfo cell_info = 7; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueCellInfoOuterClass.ChessRogueCellInfo getMutableCellInfo() { + bitField0_ |= 0x00000008; + return cellInfo; + } + + /** + * optional .ChessRogueCellInfo cell_info = 7; + * @param value the cellInfo to set + * @return this + */ + public ChessRogueStartScRsp setCellInfo( + final ChessRogueCellInfoOuterClass.ChessRogueCellInfo value) { + bitField0_ |= 0x00000008; + cellInfo.copyFrom(value); + return this; + } + + /** + * optional .ChessRogueCurrentInfo current_info = 10; + * @return whether the currentInfo field is set + */ + public boolean hasCurrentInfo() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * optional .ChessRogueCurrentInfo current_info = 10; + * @return this + */ + public ChessRogueStartScRsp clearCurrentInfo() { + bitField0_ &= ~0x00000010; + currentInfo.clear(); + return this; + } + + /** + * optional .ChessRogueCurrentInfo current_info = 10; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableCurrentInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueCurrentInfoOuterClass.ChessRogueCurrentInfo getCurrentInfo() { + return currentInfo; + } + + /** + * optional .ChessRogueCurrentInfo current_info = 10; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueCurrentInfoOuterClass.ChessRogueCurrentInfo getMutableCurrentInfo() { + bitField0_ |= 0x00000010; + return currentInfo; + } + + /** + * optional .ChessRogueCurrentInfo current_info = 10; + * @param value the currentInfo to set + * @return this + */ + public ChessRogueStartScRsp setCurrentInfo( + final ChessRogueCurrentInfoOuterClass.ChessRogueCurrentInfo value) { + bitField0_ |= 0x00000010; + currentInfo.copyFrom(value); + return this; + } + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 13;
+     *
+ * + * optional .ChessRogueInfo chess_rogue_info = 11; + * @return whether the chessRogueInfo field is set + */ + public boolean hasChessRogueInfo() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 13;
+     *
+ * + * optional .ChessRogueInfo chess_rogue_info = 11; + * @return this + */ + public ChessRogueStartScRsp clearChessRogueInfo() { + bitField0_ &= ~0x00000020; + chessRogueInfo.clear(); + return this; + } + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 13;
+     *
+ * + * optional .ChessRogueInfo chess_rogue_info = 11; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableChessRogueInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueInfoOuterClass.ChessRogueInfo getChessRogueInfo() { + return chessRogueInfo; + } + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 13;
+     *
+ * + * optional .ChessRogueInfo chess_rogue_info = 11; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueInfoOuterClass.ChessRogueInfo getMutableChessRogueInfo() { + bitField0_ |= 0x00000020; + return chessRogueInfo; + } + + /** + * 
+     * HLODEEONDBF OBGFEMEOJCE = 13;
+     *
+ * + * optional .ChessRogueInfo chess_rogue_info = 11; + * @param value the chessRogueInfo to set + * @return this + */ + public ChessRogueStartScRsp setChessRogueInfo( + final ChessRogueInfoOuterClass.ChessRogueInfo value) { + bitField0_ |= 0x00000020; + chessRogueInfo.copyFrom(value); + return this; + } + + @Override + public ChessRogueStartScRsp copyFrom(final ChessRogueStartScRsp other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + retcode = other.retcode; + lineup.copyFrom(other.lineup); + scene.copyFrom(other.scene); + cellInfo.copyFrom(other.cellInfo); + currentInfo.copyFrom(other.currentInfo); + chessRogueInfo.copyFrom(other.chessRogueInfo); + } + return this; + } + + @Override + public ChessRogueStartScRsp mergeFrom(final ChessRogueStartScRsp other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRetcode()) { + setRetcode(other.retcode); + } + if (other.hasLineup()) { + getMutableLineup().mergeFrom(other.lineup); + } + if (other.hasScene()) { + getMutableScene().mergeFrom(other.scene); + } + if (other.hasCellInfo()) { + getMutableCellInfo().mergeFrom(other.cellInfo); + } + if (other.hasCurrentInfo()) { + getMutableCurrentInfo().mergeFrom(other.currentInfo); + } + if (other.hasChessRogueInfo()) { + getMutableChessRogueInfo().mergeFrom(other.chessRogueInfo); + } + return this; + } + + @Override + public ChessRogueStartScRsp clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + retcode = 0; + lineup.clear(); + scene.clear(); + cellInfo.clear(); + currentInfo.clear(); + chessRogueInfo.clear(); + return this; + } + + @Override + public ChessRogueStartScRsp clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + lineup.clearQuick(); + scene.clearQuick(); + cellInfo.clearQuick(); + currentInfo.clearQuick(); + chessRogueInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueStartScRsp)) { + return false; + } + ChessRogueStartScRsp other = (ChessRogueStartScRsp) o; + return bitField0_ == other.bitField0_ + && (!hasRetcode() || retcode == other.retcode) + && (!hasLineup() || lineup.equals(other.lineup)) + && (!hasScene() || scene.equals(other.scene)) + && (!hasCellInfo() || cellInfo.equals(other.cellInfo)) + && (!hasCurrentInfo() || currentInfo.equals(other.currentInfo)) + && (!hasChessRogueInfo() || chessRogueInfo.equals(other.chessRogueInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 10); + output.writeMessageNoTag(lineup); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 34); + output.writeMessageNoTag(scene); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 58); + output.writeMessageNoTag(cellInfo); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawByte((byte) 82); + output.writeMessageNoTag(currentInfo); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRawByte((byte) 90); + output.writeMessageNoTag(chessRogueInfo); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(lineup); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(scene); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(cellInfo); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(currentInfo); + } + if ((bitField0_ & 0x00000020) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(chessRogueInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueStartScRsp mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 16: { + // retcode + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 10) { + break; + } + } + case 10: { + // lineup + input.readMessage(lineup); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 34) { + break; + } + } + case 34: { + // scene + input.readMessage(scene); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 58) { + break; + } + } + case 58: { + // cellInfo + input.readMessage(cellInfo); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 82) { + break; + } + } + case 82: { + // currentInfo + input.readMessage(currentInfo); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 90) { + break; + } + } + case 90: { + // chessRogueInfo + input.readMessage(chessRogueInfo); + bitField0_ |= 0x00000020; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.retcode, retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeMessage(FieldNames.lineup, lineup); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeMessage(FieldNames.scene, scene); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeMessage(FieldNames.cellInfo, cellInfo); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeMessage(FieldNames.currentInfo, currentInfo); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeMessage(FieldNames.chessRogueInfo, chessRogueInfo); + } + output.endObject(); + } + + @Override + public ChessRogueStartScRsp mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1097936398: { + if (input.isAtField(FieldNames.retcode)) { + if (!input.trySkipNullValue()) { + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1102671473: { + if (input.isAtField(FieldNames.lineup)) { + if (!input.trySkipNullValue()) { + input.readMessage(lineup); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 109254796: { + if (input.isAtField(FieldNames.scene)) { + if (!input.trySkipNullValue()) { + input.readMessage(scene); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -917905104: + case 1629888875: { + if (input.isAtField(FieldNames.cellInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(cellInfo); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case 600912327: + case 1468588980: { + if (input.isAtField(FieldNames.currentInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(currentInfo); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2057768312: + case 1888241298: { + if (input.isAtField(FieldNames.chessRogueInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(chessRogueInfo); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueStartScRsp clone() { + return new ChessRogueStartScRsp().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueStartScRsp parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueStartScRsp(), data).checkInitialized(); + } + + public static ChessRogueStartScRsp parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueStartScRsp(), input).checkInitialized(); + } + + public static ChessRogueStartScRsp parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueStartScRsp(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueStartScRsp messages + */ + public static MessageFactory getFactory() { + return ChessRogueStartScRspFactory.INSTANCE; + } + + private enum ChessRogueStartScRspFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueStartScRsp create() { + return ChessRogueStartScRsp.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName retcode = FieldName.forField("retcode"); + + static final FieldName lineup = FieldName.forField("lineup"); + + static final FieldName scene = FieldName.forField("scene"); + + static final FieldName cellInfo = FieldName.forField("cellInfo", "cell_info"); + + static final FieldName currentInfo = FieldName.forField("currentInfo", "current_info"); + + static final FieldName chessRogueInfo = FieldName.forField("chessRogueInfo", "chess_rogue_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateActionPointScNotifyOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateActionPointScNotifyOuterClass.java new file mode 100644 index 0000000..47f5dac --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateActionPointScNotifyOuterClass.java @@ -0,0 +1,266 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueUpdateActionPointScNotifyOuterClass { + /** + * Protobuf type {@code ChessRogueUpdateActionPointScNotify} + */ + public static final class ChessRogueUpdateActionPointScNotify extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 action_point = 9; + */ + private int actionPoint; + + private ChessRogueUpdateActionPointScNotify() { + } + + /** + * @return a new empty instance of {@code ChessRogueUpdateActionPointScNotify} + */ + public static ChessRogueUpdateActionPointScNotify newInstance() { + return new ChessRogueUpdateActionPointScNotify(); + } + + /** + * optional uint32 action_point = 9; + * @return whether the actionPoint field is set + */ + public boolean hasActionPoint() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 action_point = 9; + * @return this + */ + public ChessRogueUpdateActionPointScNotify clearActionPoint() { + bitField0_ &= ~0x00000001; + actionPoint = 0; + return this; + } + + /** + * optional uint32 action_point = 9; + * @return the actionPoint + */ + public int getActionPoint() { + return actionPoint; + } + + /** + * optional uint32 action_point = 9; + * @param value the actionPoint to set + * @return this + */ + public ChessRogueUpdateActionPointScNotify setActionPoint(final int value) { + bitField0_ |= 0x00000001; + actionPoint = value; + return this; + } + + @Override + public ChessRogueUpdateActionPointScNotify copyFrom( + final ChessRogueUpdateActionPointScNotify other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + actionPoint = other.actionPoint; + } + return this; + } + + @Override + public ChessRogueUpdateActionPointScNotify mergeFrom( + final ChessRogueUpdateActionPointScNotify other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasActionPoint()) { + setActionPoint(other.actionPoint); + } + return this; + } + + @Override + public ChessRogueUpdateActionPointScNotify clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + actionPoint = 0; + return this; + } + + @Override + public ChessRogueUpdateActionPointScNotify clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueUpdateActionPointScNotify)) { + return false; + } + ChessRogueUpdateActionPointScNotify other = (ChessRogueUpdateActionPointScNotify) o; + return bitField0_ == other.bitField0_ + && (!hasActionPoint() || actionPoint == other.actionPoint); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 72); + output.writeUInt32NoTag(actionPoint); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(actionPoint); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueUpdateActionPointScNotify mergeFrom(final ProtoSource input) throws + IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 72: { + // actionPoint + actionPoint = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.actionPoint, actionPoint); + } + output.endObject(); + } + + @Override + public ChessRogueUpdateActionPointScNotify mergeFrom(final JsonSource input) throws + IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1569741050: + case 1847866951: { + if (input.isAtField(FieldNames.actionPoint)) { + if (!input.trySkipNullValue()) { + actionPoint = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueUpdateActionPointScNotify clone() { + return new ChessRogueUpdateActionPointScNotify().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueUpdateActionPointScNotify parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateActionPointScNotify(), data).checkInitialized(); + } + + public static ChessRogueUpdateActionPointScNotify parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateActionPointScNotify(), input).checkInitialized(); + } + + public static ChessRogueUpdateActionPointScNotify parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateActionPointScNotify(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueUpdateActionPointScNotify messages + */ + public static MessageFactory getFactory() { + return ChessRogueUpdateActionPointScNotifyFactory.INSTANCE; + } + + private enum ChessRogueUpdateActionPointScNotifyFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueUpdateActionPointScNotify create() { + return ChessRogueUpdateActionPointScNotify.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName actionPoint = FieldName.forField("actionPoint", "action_point"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateAllowedSelectCellScNotifyOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateAllowedSelectCellScNotifyOuterClass.java new file mode 100644 index 0000000..a67876a --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateAllowedSelectCellScNotifyOuterClass.java @@ -0,0 +1,388 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedInt; + +public final class ChessRogueUpdateAllowedSelectCellScNotifyOuterClass { + /** + * Protobuf type {@code ChessRogueUpdateAllowedSelectCellScNotify} + */ + public static final class ChessRogueUpdateAllowedSelectCellScNotify extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 room_id = 12; + */ + private int roomId; + + /** + * repeated uint32 cell_id_list = 11; + */ + private final RepeatedInt cellIdList = RepeatedInt.newEmptyInstance(); + + private ChessRogueUpdateAllowedSelectCellScNotify() { + } + + /** + * @return a new empty instance of {@code ChessRogueUpdateAllowedSelectCellScNotify} + */ + public static ChessRogueUpdateAllowedSelectCellScNotify newInstance() { + return new ChessRogueUpdateAllowedSelectCellScNotify(); + } + + /** + * optional uint32 room_id = 12; + * @return whether the roomId field is set + */ + public boolean hasRoomId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 room_id = 12; + * @return this + */ + public ChessRogueUpdateAllowedSelectCellScNotify clearRoomId() { + bitField0_ &= ~0x00000001; + roomId = 0; + return this; + } + + /** + * optional uint32 room_id = 12; + * @return the roomId + */ + public int getRoomId() { + return roomId; + } + + /** + * optional uint32 room_id = 12; + * @param value the roomId to set + * @return this + */ + public ChessRogueUpdateAllowedSelectCellScNotify setRoomId(final int value) { + bitField0_ |= 0x00000001; + roomId = value; + return this; + } + + /** + * repeated uint32 cell_id_list = 11; + * @return whether the cellIdList field is set + */ + public boolean hasCellIdList() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated uint32 cell_id_list = 11; + * @return this + */ + public ChessRogueUpdateAllowedSelectCellScNotify clearCellIdList() { + bitField0_ &= ~0x00000002; + cellIdList.clear(); + return this; + } + + /** + * repeated uint32 cell_id_list = 11; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableCellIdList()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getCellIdList() { + return cellIdList; + } + + /** + * repeated uint32 cell_id_list = 11; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableCellIdList() { + bitField0_ |= 0x00000002; + return cellIdList; + } + + /** + * repeated uint32 cell_id_list = 11; + * @param value the cellIdList to add + * @return this + */ + public ChessRogueUpdateAllowedSelectCellScNotify addCellIdList(final int value) { + bitField0_ |= 0x00000002; + cellIdList.add(value); + return this; + } + + /** + * repeated uint32 cell_id_list = 11; + * @param values the cellIdList to add + * @return this + */ + public ChessRogueUpdateAllowedSelectCellScNotify addAllCellIdList(final int... values) { + bitField0_ |= 0x00000002; + cellIdList.addAll(values); + return this; + } + + @Override + public ChessRogueUpdateAllowedSelectCellScNotify copyFrom( + final ChessRogueUpdateAllowedSelectCellScNotify other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + roomId = other.roomId; + cellIdList.copyFrom(other.cellIdList); + } + return this; + } + + @Override + public ChessRogueUpdateAllowedSelectCellScNotify mergeFrom( + final ChessRogueUpdateAllowedSelectCellScNotify other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRoomId()) { + setRoomId(other.roomId); + } + if (other.hasCellIdList()) { + getMutableCellIdList().addAll(other.cellIdList); + } + return this; + } + + @Override + public ChessRogueUpdateAllowedSelectCellScNotify clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + roomId = 0; + cellIdList.clear(); + return this; + } + + @Override + public ChessRogueUpdateAllowedSelectCellScNotify clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + cellIdList.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueUpdateAllowedSelectCellScNotify)) { + return false; + } + ChessRogueUpdateAllowedSelectCellScNotify other = (ChessRogueUpdateAllowedSelectCellScNotify) o; + return bitField0_ == other.bitField0_ + && (!hasRoomId() || roomId == other.roomId) + && (!hasCellIdList() || cellIdList.equals(other.cellIdList)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 96); + output.writeUInt32NoTag(roomId); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < cellIdList.length(); i++) { + output.writeRawByte((byte) 88); + output.writeUInt32NoTag(cellIdList.array()[i]); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(roomId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * cellIdList.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(cellIdList); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueUpdateAllowedSelectCellScNotify mergeFrom(final ProtoSource input) throws + IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 96: { + // roomId + roomId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 90) { + break; + } + } + case 90: { + // cellIdList [packed=true] + input.readPackedUInt32(cellIdList, tag); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + case 88: { + // cellIdList [packed=false] + tag = input.readRepeatedUInt32(cellIdList, tag); + bitField0_ |= 0x00000002; + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.roomId, roomId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedUInt32(FieldNames.cellIdList, cellIdList); + } + output.endObject(); + } + + @Override + public ChessRogueUpdateAllowedSelectCellScNotify mergeFrom(final JsonSource input) throws + IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -925319338: + case 1379892991: { + if (input.isAtField(FieldNames.roomId)) { + if (!input.trySkipNullValue()) { + roomId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1648521125: + case 1121452901: { + if (input.isAtField(FieldNames.cellIdList)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(cellIdList); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueUpdateAllowedSelectCellScNotify clone() { + return new ChessRogueUpdateAllowedSelectCellScNotify().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueUpdateAllowedSelectCellScNotify parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateAllowedSelectCellScNotify(), data).checkInitialized(); + } + + public static ChessRogueUpdateAllowedSelectCellScNotify parseFrom(final ProtoSource input) + throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateAllowedSelectCellScNotify(), input).checkInitialized(); + } + + public static ChessRogueUpdateAllowedSelectCellScNotify parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateAllowedSelectCellScNotify(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueUpdateAllowedSelectCellScNotify messages + */ + public static MessageFactory getFactory() { + return ChessRogueUpdateAllowedSelectCellScNotifyFactory.INSTANCE; + } + + private enum ChessRogueUpdateAllowedSelectCellScNotifyFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueUpdateAllowedSelectCellScNotify create() { + return ChessRogueUpdateAllowedSelectCellScNotify.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName roomId = FieldName.forField("roomId", "room_id"); + + static final FieldName cellIdList = FieldName.forField("cellIdList", "cell_id_list"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateDiceInfoScNotifyOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateDiceInfoScNotifyOuterClass.java new file mode 100644 index 0000000..11ed134 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateDiceInfoScNotifyOuterClass.java @@ -0,0 +1,285 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueUpdateDiceInfoScNotifyOuterClass { + /** + * Protobuf type {@code ChessRogueUpdateDiceInfoScNotify} + */ + public static final class ChessRogueUpdateDiceInfoScNotify extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .ChessRogueNousDice nous_dice = 5; + */ + private final ChessRogueNousDiceOuterClass.ChessRogueNousDice nousDice = ChessRogueNousDiceOuterClass.ChessRogueNousDice.newInstance(); + + private ChessRogueUpdateDiceInfoScNotify() { + } + + /** + * @return a new empty instance of {@code ChessRogueUpdateDiceInfoScNotify} + */ + public static ChessRogueUpdateDiceInfoScNotify newInstance() { + return new ChessRogueUpdateDiceInfoScNotify(); + } + + /** + * optional .ChessRogueNousDice nous_dice = 5; + * @return whether the nousDice field is set + */ + public boolean hasNousDice() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .ChessRogueNousDice nous_dice = 5; + * @return this + */ + public ChessRogueUpdateDiceInfoScNotify clearNousDice() { + bitField0_ &= ~0x00000001; + nousDice.clear(); + return this; + } + + /** + * optional .ChessRogueNousDice nous_dice = 5; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableNousDice()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueNousDiceOuterClass.ChessRogueNousDice getNousDice() { + return nousDice; + } + + /** + * optional .ChessRogueNousDice nous_dice = 5; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueNousDiceOuterClass.ChessRogueNousDice getMutableNousDice() { + bitField0_ |= 0x00000001; + return nousDice; + } + + /** + * optional .ChessRogueNousDice nous_dice = 5; + * @param value the nousDice to set + * @return this + */ + public ChessRogueUpdateDiceInfoScNotify setNousDice( + final ChessRogueNousDiceOuterClass.ChessRogueNousDice value) { + bitField0_ |= 0x00000001; + nousDice.copyFrom(value); + return this; + } + + @Override + public ChessRogueUpdateDiceInfoScNotify copyFrom(final ChessRogueUpdateDiceInfoScNotify other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + nousDice.copyFrom(other.nousDice); + } + return this; + } + + @Override + public ChessRogueUpdateDiceInfoScNotify mergeFrom( + final ChessRogueUpdateDiceInfoScNotify other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasNousDice()) { + getMutableNousDice().mergeFrom(other.nousDice); + } + return this; + } + + @Override + public ChessRogueUpdateDiceInfoScNotify clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nousDice.clear(); + return this; + } + + @Override + public ChessRogueUpdateDiceInfoScNotify clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nousDice.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueUpdateDiceInfoScNotify)) { + return false; + } + ChessRogueUpdateDiceInfoScNotify other = (ChessRogueUpdateDiceInfoScNotify) o; + return bitField0_ == other.bitField0_ + && (!hasNousDice() || nousDice.equals(other.nousDice)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 42); + output.writeMessageNoTag(nousDice); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(nousDice); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueUpdateDiceInfoScNotify mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 42: { + // nousDice + input.readMessage(nousDice); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.nousDice, nousDice); + } + output.endObject(); + } + + @Override + public ChessRogueUpdateDiceInfoScNotify mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1622214758: + case -1226158137: { + if (input.isAtField(FieldNames.nousDice)) { + if (!input.trySkipNullValue()) { + input.readMessage(nousDice); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueUpdateDiceInfoScNotify clone() { + return new ChessRogueUpdateDiceInfoScNotify().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueUpdateDiceInfoScNotify parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateDiceInfoScNotify(), data).checkInitialized(); + } + + public static ChessRogueUpdateDiceInfoScNotify parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateDiceInfoScNotify(), input).checkInitialized(); + } + + public static ChessRogueUpdateDiceInfoScNotify parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateDiceInfoScNotify(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueUpdateDiceInfoScNotify messages + */ + public static MessageFactory getFactory() { + return ChessRogueUpdateDiceInfoScNotifyFactory.INSTANCE; + } + + private enum ChessRogueUpdateDiceInfoScNotifyFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueUpdateDiceInfoScNotify create() { + return ChessRogueUpdateDiceInfoScNotify.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName nousDice = FieldName.forField("nousDice", "nous_dice"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateDicePassiveAccumulateValueScNotifyOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateDicePassiveAccumulateValueScNotifyOuterClass.java new file mode 100644 index 0000000..5eff001 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateDicePassiveAccumulateValueScNotifyOuterClass.java @@ -0,0 +1,265 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueUpdateDicePassiveAccumulateValueScNotifyOuterClass { + /** + * Protobuf type {@code ChessRogueUpdateDicePassiveAccumulateValueScNotify} + */ + public static final class ChessRogueUpdateDicePassiveAccumulateValueScNotify extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 value = 13; + */ + private int value_; + + private ChessRogueUpdateDicePassiveAccumulateValueScNotify() { + } + + /** + * @return a new empty instance of {@code ChessRogueUpdateDicePassiveAccumulateValueScNotify} + */ + public static ChessRogueUpdateDicePassiveAccumulateValueScNotify newInstance() { + return new ChessRogueUpdateDicePassiveAccumulateValueScNotify(); + } + + /** + * optional uint32 value = 13; + * @return whether the value_ field is set + */ + public boolean hasValue() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 value = 13; + * @return this + */ + public ChessRogueUpdateDicePassiveAccumulateValueScNotify clearValue() { + bitField0_ &= ~0x00000001; + value_ = 0; + return this; + } + + /** + * optional uint32 value = 13; + * @return the value_ + */ + public int getValue() { + return value_; + } + + /** + * optional uint32 value = 13; + * @param value the value_ to set + * @return this + */ + public ChessRogueUpdateDicePassiveAccumulateValueScNotify setValue(final int value) { + bitField0_ |= 0x00000001; + value_ = value; + return this; + } + + @Override + public ChessRogueUpdateDicePassiveAccumulateValueScNotify copyFrom( + final ChessRogueUpdateDicePassiveAccumulateValueScNotify other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + value_ = other.value_; + } + return this; + } + + @Override + public ChessRogueUpdateDicePassiveAccumulateValueScNotify mergeFrom( + final ChessRogueUpdateDicePassiveAccumulateValueScNotify other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasValue()) { + setValue(other.value_); + } + return this; + } + + @Override + public ChessRogueUpdateDicePassiveAccumulateValueScNotify clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + value_ = 0; + return this; + } + + @Override + public ChessRogueUpdateDicePassiveAccumulateValueScNotify clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueUpdateDicePassiveAccumulateValueScNotify)) { + return false; + } + ChessRogueUpdateDicePassiveAccumulateValueScNotify other = (ChessRogueUpdateDicePassiveAccumulateValueScNotify) o; + return bitField0_ == other.bitField0_ + && (!hasValue() || value_ == other.value_); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 104); + output.writeUInt32NoTag(value_); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(value_); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueUpdateDicePassiveAccumulateValueScNotify mergeFrom(final ProtoSource input) + throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 104: { + // value_ + value_ = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.value_, value_); + } + output.endObject(); + } + + @Override + public ChessRogueUpdateDicePassiveAccumulateValueScNotify mergeFrom(final JsonSource input) + throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 111972721: { + if (input.isAtField(FieldNames.value_)) { + if (!input.trySkipNullValue()) { + value_ = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueUpdateDicePassiveAccumulateValueScNotify clone() { + return new ChessRogueUpdateDicePassiveAccumulateValueScNotify().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueUpdateDicePassiveAccumulateValueScNotify parseFrom(final byte[] data) + throws InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateDicePassiveAccumulateValueScNotify(), data).checkInitialized(); + } + + public static ChessRogueUpdateDicePassiveAccumulateValueScNotify parseFrom( + final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateDicePassiveAccumulateValueScNotify(), input).checkInitialized(); + } + + public static ChessRogueUpdateDicePassiveAccumulateValueScNotify parseFrom( + final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateDicePassiveAccumulateValueScNotify(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueUpdateDicePassiveAccumulateValueScNotify messages + */ + public static MessageFactory getFactory() { + return ChessRogueUpdateDicePassiveAccumulateValueScNotifyFactory.INSTANCE; + } + + private enum ChessRogueUpdateDicePassiveAccumulateValueScNotifyFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueUpdateDicePassiveAccumulateValueScNotify create() { + return ChessRogueUpdateDicePassiveAccumulateValueScNotify.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName value_ = FieldName.forField("value"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateMoneyInfoScNotifyOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateMoneyInfoScNotifyOuterClass.java new file mode 100644 index 0000000..81f94a3 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueUpdateMoneyInfoScNotifyOuterClass.java @@ -0,0 +1,286 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueUpdateMoneyInfoScNotifyOuterClass { + /** + * Protobuf type {@code ChessRogueUpdateMoneyInfoScNotify} + */ + public static final class ChessRogueUpdateMoneyInfoScNotify extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .ChessRogueMoneyInfo money_info = 12; + */ + private final ChessRogueMoneyInfoOuterClass.ChessRogueMoneyInfo moneyInfo = ChessRogueMoneyInfoOuterClass.ChessRogueMoneyInfo.newInstance(); + + private ChessRogueUpdateMoneyInfoScNotify() { + } + + /** + * @return a new empty instance of {@code ChessRogueUpdateMoneyInfoScNotify} + */ + public static ChessRogueUpdateMoneyInfoScNotify newInstance() { + return new ChessRogueUpdateMoneyInfoScNotify(); + } + + /** + * optional .ChessRogueMoneyInfo money_info = 12; + * @return whether the moneyInfo field is set + */ + public boolean hasMoneyInfo() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .ChessRogueMoneyInfo money_info = 12; + * @return this + */ + public ChessRogueUpdateMoneyInfoScNotify clearMoneyInfo() { + bitField0_ &= ~0x00000001; + moneyInfo.clear(); + return this; + } + + /** + * optional .ChessRogueMoneyInfo money_info = 12; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableMoneyInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueMoneyInfoOuterClass.ChessRogueMoneyInfo getMoneyInfo() { + return moneyInfo; + } + + /** + * optional .ChessRogueMoneyInfo money_info = 12; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueMoneyInfoOuterClass.ChessRogueMoneyInfo getMutableMoneyInfo() { + bitField0_ |= 0x00000001; + return moneyInfo; + } + + /** + * optional .ChessRogueMoneyInfo money_info = 12; + * @param value the moneyInfo to set + * @return this + */ + public ChessRogueUpdateMoneyInfoScNotify setMoneyInfo( + final ChessRogueMoneyInfoOuterClass.ChessRogueMoneyInfo value) { + bitField0_ |= 0x00000001; + moneyInfo.copyFrom(value); + return this; + } + + @Override + public ChessRogueUpdateMoneyInfoScNotify copyFrom( + final ChessRogueUpdateMoneyInfoScNotify other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + moneyInfo.copyFrom(other.moneyInfo); + } + return this; + } + + @Override + public ChessRogueUpdateMoneyInfoScNotify mergeFrom( + final ChessRogueUpdateMoneyInfoScNotify other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasMoneyInfo()) { + getMutableMoneyInfo().mergeFrom(other.moneyInfo); + } + return this; + } + + @Override + public ChessRogueUpdateMoneyInfoScNotify clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + moneyInfo.clear(); + return this; + } + + @Override + public ChessRogueUpdateMoneyInfoScNotify clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + moneyInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueUpdateMoneyInfoScNotify)) { + return false; + } + ChessRogueUpdateMoneyInfoScNotify other = (ChessRogueUpdateMoneyInfoScNotify) o; + return bitField0_ == other.bitField0_ + && (!hasMoneyInfo() || moneyInfo.equals(other.moneyInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 98); + output.writeMessageNoTag(moneyInfo); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(moneyInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueUpdateMoneyInfoScNotify mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 98: { + // moneyInfo + input.readMessage(moneyInfo); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.moneyInfo, moneyInfo); + } + output.endObject(); + } + + @Override + public ChessRogueUpdateMoneyInfoScNotify mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1713858162: + case -1569819443: { + if (input.isAtField(FieldNames.moneyInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(moneyInfo); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueUpdateMoneyInfoScNotify clone() { + return new ChessRogueUpdateMoneyInfoScNotify().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueUpdateMoneyInfoScNotify parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateMoneyInfoScNotify(), data).checkInitialized(); + } + + public static ChessRogueUpdateMoneyInfoScNotify parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateMoneyInfoScNotify(), input).checkInitialized(); + } + + public static ChessRogueUpdateMoneyInfoScNotify parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new ChessRogueUpdateMoneyInfoScNotify(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueUpdateMoneyInfoScNotify messages + */ + public static MessageFactory getFactory() { + return ChessRogueUpdateMoneyInfoScNotifyFactory.INSTANCE; + } + + private enum ChessRogueUpdateMoneyInfoScNotifyFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueUpdateMoneyInfoScNotify create() { + return ChessRogueUpdateMoneyInfoScNotify.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName moneyInfo = FieldName.forField("moneyInfo", "money_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ChessRogueVirtualItemInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/ChessRogueVirtualItemInfoOuterClass.java new file mode 100644 index 0000000..35bc282 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ChessRogueVirtualItemInfoOuterClass.java @@ -0,0 +1,518 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ChessRogueVirtualItemInfoOuterClass { + /** + * Protobuf type {@code ChessRogueVirtualItemInfo} + */ + public static final class ChessRogueVirtualItemInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * 
+     * LNGAAJMILOC CKJPPDKJIOH = 8;
+     * NNGLIKCIBCA JNAGMIALOII = 14;
+     *
+ * + * optional .ChessRogueItemInfo item_info = 6; + */ + private final ChessRogueItemInfoOuterClass.ChessRogueItemInfo itemInfo = ChessRogueItemInfoOuterClass.ChessRogueItemInfo.newInstance(); + + /** + * optional .ChessRogueBuffInfo buff_info = 9; + */ + private final ChessRogueBuffInfoOuterClass.ChessRogueBuffInfo buffInfo = ChessRogueBuffInfoOuterClass.ChessRogueBuffInfo.newInstance(); + + /** + * optional .ChessRogueMiracleInfo miracle_info = 13; + */ + private final ChessRogueMiracleInfoOuterClass.ChessRogueMiracleInfo miracleInfo = ChessRogueMiracleInfoOuterClass.ChessRogueMiracleInfo.newInstance(); + + private ChessRogueVirtualItemInfo() { + } + + /** + * @return a new empty instance of {@code ChessRogueVirtualItemInfo} + */ + public static ChessRogueVirtualItemInfo newInstance() { + return new ChessRogueVirtualItemInfo(); + } + + /** + * 
+     * LNGAAJMILOC CKJPPDKJIOH = 8;
+     * NNGLIKCIBCA JNAGMIALOII = 14;
+     *
+ * + * optional .ChessRogueItemInfo item_info = 6; + * @return whether the itemInfo field is set + */ + public boolean hasItemInfo() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * 
+     * LNGAAJMILOC CKJPPDKJIOH = 8;
+     * NNGLIKCIBCA JNAGMIALOII = 14;
+     *
+ * + * optional .ChessRogueItemInfo item_info = 6; + * @return this + */ + public ChessRogueVirtualItemInfo clearItemInfo() { + bitField0_ &= ~0x00000001; + itemInfo.clear(); + return this; + } + + /** + * 
+     * LNGAAJMILOC CKJPPDKJIOH = 8;
+     * NNGLIKCIBCA JNAGMIALOII = 14;
+     *
+ * + * optional .ChessRogueItemInfo item_info = 6; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableItemInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueItemInfoOuterClass.ChessRogueItemInfo getItemInfo() { + return itemInfo; + } + + /** + * 
+     * LNGAAJMILOC CKJPPDKJIOH = 8;
+     * NNGLIKCIBCA JNAGMIALOII = 14;
+     *
+ * + * optional .ChessRogueItemInfo item_info = 6; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueItemInfoOuterClass.ChessRogueItemInfo getMutableItemInfo() { + bitField0_ |= 0x00000001; + return itemInfo; + } + + /** + * 
+     * LNGAAJMILOC CKJPPDKJIOH = 8;
+     * NNGLIKCIBCA JNAGMIALOII = 14;
+     *
+ * + * optional .ChessRogueItemInfo item_info = 6; + * @param value the itemInfo to set + * @return this + */ + public ChessRogueVirtualItemInfo setItemInfo( + final ChessRogueItemInfoOuterClass.ChessRogueItemInfo value) { + bitField0_ |= 0x00000001; + itemInfo.copyFrom(value); + return this; + } + + /** + * optional .ChessRogueBuffInfo buff_info = 9; + * @return whether the buffInfo field is set + */ + public boolean hasBuffInfo() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional .ChessRogueBuffInfo buff_info = 9; + * @return this + */ + public ChessRogueVirtualItemInfo clearBuffInfo() { + bitField0_ &= ~0x00000002; + buffInfo.clear(); + return this; + } + + /** + * optional .ChessRogueBuffInfo buff_info = 9; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableBuffInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueBuffInfoOuterClass.ChessRogueBuffInfo getBuffInfo() { + return buffInfo; + } + + /** + * optional .ChessRogueBuffInfo buff_info = 9; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueBuffInfoOuterClass.ChessRogueBuffInfo getMutableBuffInfo() { + bitField0_ |= 0x00000002; + return buffInfo; + } + + /** + * optional .ChessRogueBuffInfo buff_info = 9; + * @param value the buffInfo to set + * @return this + */ + public ChessRogueVirtualItemInfo setBuffInfo( + final ChessRogueBuffInfoOuterClass.ChessRogueBuffInfo value) { + bitField0_ |= 0x00000002; + buffInfo.copyFrom(value); + return this; + } + + /** + * optional .ChessRogueMiracleInfo miracle_info = 13; + * @return whether the miracleInfo field is set + */ + public boolean hasMiracleInfo() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional .ChessRogueMiracleInfo miracle_info = 13; + * @return this + */ + public ChessRogueVirtualItemInfo clearMiracleInfo() { + bitField0_ &= ~0x00000004; + miracleInfo.clear(); + return this; + } + + /** + * optional .ChessRogueMiracleInfo miracle_info = 13; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableMiracleInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueMiracleInfoOuterClass.ChessRogueMiracleInfo getMiracleInfo() { + return miracleInfo; + } + + /** + * optional .ChessRogueMiracleInfo miracle_info = 13; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueMiracleInfoOuterClass.ChessRogueMiracleInfo getMutableMiracleInfo() { + bitField0_ |= 0x00000004; + return miracleInfo; + } + + /** + * optional .ChessRogueMiracleInfo miracle_info = 13; + * @param value the miracleInfo to set + * @return this + */ + public ChessRogueVirtualItemInfo setMiracleInfo( + final ChessRogueMiracleInfoOuterClass.ChessRogueMiracleInfo value) { + bitField0_ |= 0x00000004; + miracleInfo.copyFrom(value); + return this; + } + + @Override + public ChessRogueVirtualItemInfo copyFrom(final ChessRogueVirtualItemInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + itemInfo.copyFrom(other.itemInfo); + buffInfo.copyFrom(other.buffInfo); + miracleInfo.copyFrom(other.miracleInfo); + } + return this; + } + + @Override + public ChessRogueVirtualItemInfo mergeFrom(final ChessRogueVirtualItemInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasItemInfo()) { + getMutableItemInfo().mergeFrom(other.itemInfo); + } + if (other.hasBuffInfo()) { + getMutableBuffInfo().mergeFrom(other.buffInfo); + } + if (other.hasMiracleInfo()) { + getMutableMiracleInfo().mergeFrom(other.miracleInfo); + } + return this; + } + + @Override + public ChessRogueVirtualItemInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + itemInfo.clear(); + buffInfo.clear(); + miracleInfo.clear(); + return this; + } + + @Override + public ChessRogueVirtualItemInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + itemInfo.clearQuick(); + buffInfo.clearQuick(); + miracleInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ChessRogueVirtualItemInfo)) { + return false; + } + ChessRogueVirtualItemInfo other = (ChessRogueVirtualItemInfo) o; + return bitField0_ == other.bitField0_ + && (!hasItemInfo() || itemInfo.equals(other.itemInfo)) + && (!hasBuffInfo() || buffInfo.equals(other.buffInfo)) + && (!hasMiracleInfo() || miracleInfo.equals(other.miracleInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 50); + output.writeMessageNoTag(itemInfo); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 74); + output.writeMessageNoTag(buffInfo); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 106); + output.writeMessageNoTag(miracleInfo); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(itemInfo); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(buffInfo); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(miracleInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ChessRogueVirtualItemInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 50: { + // itemInfo + input.readMessage(itemInfo); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 74) { + break; + } + } + case 74: { + // buffInfo + input.readMessage(buffInfo); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 106) { + break; + } + } + case 106: { + // miracleInfo + input.readMessage(miracleInfo); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.itemInfo, itemInfo); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeMessage(FieldNames.buffInfo, buffInfo); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeMessage(FieldNames.miracleInfo, miracleInfo); + } + output.endObject(); + } + + @Override + public ChessRogueVirtualItemInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1177195105: + case -2141481382: { + if (input.isAtField(FieldNames.itemInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(itemInfo); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1522874463: + case 55707930: { + if (input.isAtField(FieldNames.buffInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(buffInfo); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 760306879: + case 2114852796: { + if (input.isAtField(FieldNames.miracleInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(miracleInfo); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ChessRogueVirtualItemInfo clone() { + return new ChessRogueVirtualItemInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ChessRogueVirtualItemInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ChessRogueVirtualItemInfo(), data).checkInitialized(); + } + + public static ChessRogueVirtualItemInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueVirtualItemInfo(), input).checkInitialized(); + } + + public static ChessRogueVirtualItemInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ChessRogueVirtualItemInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating ChessRogueVirtualItemInfo messages + */ + public static MessageFactory getFactory() { + return ChessRogueVirtualItemInfoFactory.INSTANCE; + } + + private enum ChessRogueVirtualItemInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public ChessRogueVirtualItemInfo create() { + return ChessRogueVirtualItemInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName itemInfo = FieldName.forField("itemInfo", "item_info"); + + static final FieldName buffInfo = FieldName.forField("buffInfo", "buff_info"); + + static final FieldName miracleInfo = FieldName.forField("miracleInfo", "miracle_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/GetChessRogueNousStoryInfoScRspOuterClass.java b/src/generated/main/emu/lunarcore/proto/GetChessRogueNousStoryInfoScRspOuterClass.java new file mode 100644 index 0000000..2344128 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/GetChessRogueNousStoryInfoScRspOuterClass.java @@ -0,0 +1,498 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedMessage; + +public final class GetChessRogueNousStoryInfoScRspOuterClass { + /** + * Protobuf type {@code GetChessRogueNousStoryInfoScRsp} + */ + public static final class GetChessRogueNousStoryInfoScRsp extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 retcode = 12; + */ + private int retcode; + + /** + * repeated .ChessRogueNousSubStoryInfo sub_story_info = 6; + */ + private final RepeatedMessage subStoryInfo = RepeatedMessage.newEmptyInstance(ChessRogueNousSubStoryInfoOuterClass.ChessRogueNousSubStoryInfo.getFactory()); + + /** + * repeated .ChessRogueNousMainStoryInfo main_story_info = 10; + */ + private final RepeatedMessage mainStoryInfo = RepeatedMessage.newEmptyInstance(ChessRogueNousMainStoryInfoOuterClass.ChessRogueNousMainStoryInfo.getFactory()); + + private GetChessRogueNousStoryInfoScRsp() { + } + + /** + * @return a new empty instance of {@code GetChessRogueNousStoryInfoScRsp} + */ + public static GetChessRogueNousStoryInfoScRsp newInstance() { + return new GetChessRogueNousStoryInfoScRsp(); + } + + /** + * optional uint32 retcode = 12; + * @return whether the retcode field is set + */ + public boolean hasRetcode() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 retcode = 12; + * @return this + */ + public GetChessRogueNousStoryInfoScRsp clearRetcode() { + bitField0_ &= ~0x00000001; + retcode = 0; + return this; + } + + /** + * optional uint32 retcode = 12; + * @return the retcode + */ + public int getRetcode() { + return retcode; + } + + /** + * optional uint32 retcode = 12; + * @param value the retcode to set + * @return this + */ + public GetChessRogueNousStoryInfoScRsp setRetcode(final int value) { + bitField0_ |= 0x00000001; + retcode = value; + return this; + } + + /** + * repeated .ChessRogueNousSubStoryInfo sub_story_info = 6; + * @return whether the subStoryInfo field is set + */ + public boolean hasSubStoryInfo() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated .ChessRogueNousSubStoryInfo sub_story_info = 6; + * @return this + */ + public GetChessRogueNousStoryInfoScRsp clearSubStoryInfo() { + bitField0_ &= ~0x00000002; + subStoryInfo.clear(); + return this; + } + + /** + * repeated .ChessRogueNousSubStoryInfo sub_story_info = 6; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableSubStoryInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getSubStoryInfo( + ) { + return subStoryInfo; + } + + /** + * repeated .ChessRogueNousSubStoryInfo sub_story_info = 6; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableSubStoryInfo( + ) { + bitField0_ |= 0x00000002; + return subStoryInfo; + } + + /** + * repeated .ChessRogueNousSubStoryInfo sub_story_info = 6; + * @param value the subStoryInfo to add + * @return this + */ + public GetChessRogueNousStoryInfoScRsp addSubStoryInfo( + final ChessRogueNousSubStoryInfoOuterClass.ChessRogueNousSubStoryInfo value) { + bitField0_ |= 0x00000002; + subStoryInfo.add(value); + return this; + } + + /** + * repeated .ChessRogueNousSubStoryInfo sub_story_info = 6; + * @param values the subStoryInfo to add + * @return this + */ + public GetChessRogueNousStoryInfoScRsp addAllSubStoryInfo( + final ChessRogueNousSubStoryInfoOuterClass.ChessRogueNousSubStoryInfo... values) { + bitField0_ |= 0x00000002; + subStoryInfo.addAll(values); + return this; + } + + /** + * repeated .ChessRogueNousMainStoryInfo main_story_info = 10; + * @return whether the mainStoryInfo field is set + */ + public boolean hasMainStoryInfo() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * repeated .ChessRogueNousMainStoryInfo main_story_info = 10; + * @return this + */ + public GetChessRogueNousStoryInfoScRsp clearMainStoryInfo() { + bitField0_ &= ~0x00000004; + mainStoryInfo.clear(); + return this; + } + + /** + * repeated .ChessRogueNousMainStoryInfo main_story_info = 10; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableMainStoryInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getMainStoryInfo( + ) { + return mainStoryInfo; + } + + /** + * repeated .ChessRogueNousMainStoryInfo main_story_info = 10; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableMainStoryInfo( + ) { + bitField0_ |= 0x00000004; + return mainStoryInfo; + } + + /** + * repeated .ChessRogueNousMainStoryInfo main_story_info = 10; + * @param value the mainStoryInfo to add + * @return this + */ + public GetChessRogueNousStoryInfoScRsp addMainStoryInfo( + final ChessRogueNousMainStoryInfoOuterClass.ChessRogueNousMainStoryInfo value) { + bitField0_ |= 0x00000004; + mainStoryInfo.add(value); + return this; + } + + /** + * repeated .ChessRogueNousMainStoryInfo main_story_info = 10; + * @param values the mainStoryInfo to add + * @return this + */ + public GetChessRogueNousStoryInfoScRsp addAllMainStoryInfo( + final ChessRogueNousMainStoryInfoOuterClass.ChessRogueNousMainStoryInfo... values) { + bitField0_ |= 0x00000004; + mainStoryInfo.addAll(values); + return this; + } + + @Override + public GetChessRogueNousStoryInfoScRsp copyFrom(final GetChessRogueNousStoryInfoScRsp other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + retcode = other.retcode; + subStoryInfo.copyFrom(other.subStoryInfo); + mainStoryInfo.copyFrom(other.mainStoryInfo); + } + return this; + } + + @Override + public GetChessRogueNousStoryInfoScRsp mergeFrom(final GetChessRogueNousStoryInfoScRsp other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRetcode()) { + setRetcode(other.retcode); + } + if (other.hasSubStoryInfo()) { + getMutableSubStoryInfo().addAll(other.subStoryInfo); + } + if (other.hasMainStoryInfo()) { + getMutableMainStoryInfo().addAll(other.mainStoryInfo); + } + return this; + } + + @Override + public GetChessRogueNousStoryInfoScRsp clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + retcode = 0; + subStoryInfo.clear(); + mainStoryInfo.clear(); + return this; + } + + @Override + public GetChessRogueNousStoryInfoScRsp clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + subStoryInfo.clearQuick(); + mainStoryInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof GetChessRogueNousStoryInfoScRsp)) { + return false; + } + GetChessRogueNousStoryInfoScRsp other = (GetChessRogueNousStoryInfoScRsp) o; + return bitField0_ == other.bitField0_ + && (!hasRetcode() || retcode == other.retcode) + && (!hasSubStoryInfo() || subStoryInfo.equals(other.subStoryInfo)) + && (!hasMainStoryInfo() || mainStoryInfo.equals(other.mainStoryInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 96); + output.writeUInt32NoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < subStoryInfo.length(); i++) { + output.writeRawByte((byte) 50); + output.writeMessageNoTag(subStoryInfo.get(i)); + } + } + if ((bitField0_ & 0x00000004) != 0) { + for (int i = 0; i < mainStoryInfo.length(); i++) { + output.writeRawByte((byte) 82); + output.writeMessageNoTag(mainStoryInfo.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * subStoryInfo.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(subStoryInfo); + } + if ((bitField0_ & 0x00000004) != 0) { + size += (1 * mainStoryInfo.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(mainStoryInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public GetChessRogueNousStoryInfoScRsp mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 96: { + // retcode + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 50) { + break; + } + } + case 50: { + // subStoryInfo + tag = input.readRepeatedMessage(subStoryInfo, tag); + bitField0_ |= 0x00000002; + if (tag != 82) { + break; + } + } + case 82: { + // mainStoryInfo + tag = input.readRepeatedMessage(mainStoryInfo, tag); + bitField0_ |= 0x00000004; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.retcode, retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedMessage(FieldNames.subStoryInfo, subStoryInfo); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRepeatedMessage(FieldNames.mainStoryInfo, mainStoryInfo); + } + output.endObject(); + } + + @Override + public GetChessRogueNousStoryInfoScRsp mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1097936398: { + if (input.isAtField(FieldNames.retcode)) { + if (!input.trySkipNullValue()) { + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -489637661: + case 74622231: { + if (input.isAtField(FieldNames.subStoryInfo)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(subStoryInfo); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1591069066: + case -1820973058: { + if (input.isAtField(FieldNames.mainStoryInfo)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(mainStoryInfo); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public GetChessRogueNousStoryInfoScRsp clone() { + return new GetChessRogueNousStoryInfoScRsp().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static GetChessRogueNousStoryInfoScRsp parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new GetChessRogueNousStoryInfoScRsp(), data).checkInitialized(); + } + + public static GetChessRogueNousStoryInfoScRsp parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new GetChessRogueNousStoryInfoScRsp(), input).checkInitialized(); + } + + public static GetChessRogueNousStoryInfoScRsp parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new GetChessRogueNousStoryInfoScRsp(), input).checkInitialized(); + } + + /** + * @return factory for creating GetChessRogueNousStoryInfoScRsp messages + */ + public static MessageFactory getFactory() { + return GetChessRogueNousStoryInfoScRspFactory.INSTANCE; + } + + private enum GetChessRogueNousStoryInfoScRspFactory implements MessageFactory { + INSTANCE; + + @Override + public GetChessRogueNousStoryInfoScRsp create() { + return GetChessRogueNousStoryInfoScRsp.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName retcode = FieldName.forField("retcode"); + + static final FieldName subStoryInfo = FieldName.forField("subStoryInfo", "sub_story_info"); + + static final FieldName mainStoryInfo = FieldName.forField("mainStoryInfo", "main_story_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/LANBPBBAJLMOuterClass.java b/src/generated/main/emu/lunarcore/proto/LANBPBBAJLMOuterClass.java new file mode 100644 index 0000000..cb12d85 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/LANBPBBAJLMOuterClass.java @@ -0,0 +1,280 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class LANBPBBAJLMOuterClass { + /** + * Protobuf type {@code LANBPBBAJLM} + */ + public static final class LANBPBBAJLM extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .ItemList item_list = 8; + */ + private final ItemListOuterClass.ItemList itemList = ItemListOuterClass.ItemList.newInstance(); + + private LANBPBBAJLM() { + } + + /** + * @return a new empty instance of {@code LANBPBBAJLM} + */ + public static LANBPBBAJLM newInstance() { + return new LANBPBBAJLM(); + } + + /** + * optional .ItemList item_list = 8; + * @return whether the itemList field is set + */ + public boolean hasItemList() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .ItemList item_list = 8; + * @return this + */ + public LANBPBBAJLM clearItemList() { + bitField0_ &= ~0x00000001; + itemList.clear(); + return this; + } + + /** + * optional .ItemList item_list = 8; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableItemList()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ItemListOuterClass.ItemList getItemList() { + return itemList; + } + + /** + * optional .ItemList item_list = 8; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ItemListOuterClass.ItemList getMutableItemList() { + bitField0_ |= 0x00000001; + return itemList; + } + + /** + * optional .ItemList item_list = 8; + * @param value the itemList to set + * @return this + */ + public LANBPBBAJLM setItemList(final ItemListOuterClass.ItemList value) { + bitField0_ |= 0x00000001; + itemList.copyFrom(value); + return this; + } + + @Override + public LANBPBBAJLM copyFrom(final LANBPBBAJLM other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + itemList.copyFrom(other.itemList); + } + return this; + } + + @Override + public LANBPBBAJLM mergeFrom(final LANBPBBAJLM other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasItemList()) { + getMutableItemList().mergeFrom(other.itemList); + } + return this; + } + + @Override + public LANBPBBAJLM clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + itemList.clear(); + return this; + } + + @Override + public LANBPBBAJLM clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + itemList.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof LANBPBBAJLM)) { + return false; + } + LANBPBBAJLM other = (LANBPBBAJLM) o; + return bitField0_ == other.bitField0_ + && (!hasItemList() || itemList.equals(other.itemList)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 66); + output.writeMessageNoTag(itemList); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(itemList); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public LANBPBBAJLM mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 66: { + // itemList + input.readMessage(itemList); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.itemList, itemList); + } + output.endObject(); + } + + @Override + public LANBPBBAJLM mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1177280081: + case -2141396406: { + if (input.isAtField(FieldNames.itemList)) { + if (!input.trySkipNullValue()) { + input.readMessage(itemList); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public LANBPBBAJLM clone() { + return new LANBPBBAJLM().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static LANBPBBAJLM parseFrom(final byte[] data) throws InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new LANBPBBAJLM(), data).checkInitialized(); + } + + public static LANBPBBAJLM parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new LANBPBBAJLM(), input).checkInitialized(); + } + + public static LANBPBBAJLM parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new LANBPBBAJLM(), input).checkInitialized(); + } + + /** + * @return factory for creating LANBPBBAJLM messages + */ + public static MessageFactory getFactory() { + return LANBPBBAJLMFactory.INSTANCE; + } + + private enum LANBPBBAJLMFactory implements MessageFactory { + INSTANCE; + + @Override + public LANBPBBAJLM create() { + return LANBPBBAJLM.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName itemList = FieldName.forField("itemList", "item_list"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/LLJFPKKLGAKOuterClass.java b/src/generated/main/emu/lunarcore/proto/LLJFPKKLGAKOuterClass.java new file mode 100644 index 0000000..1c3fab4 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/LLJFPKKLGAKOuterClass.java @@ -0,0 +1,381 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class LLJFPKKLGAKOuterClass { + /** + * Protobuf type {@code LLJFPKKLGAK} + */ + public static final class LLJFPKKLGAK extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .LANBPBBAJLM OLMCGHBDKIE = 1; + */ + private final LANBPBBAJLMOuterClass.LANBPBBAJLM oLMCGHBDKIE = LANBPBBAJLMOuterClass.LANBPBBAJLM.newInstance(); + + /** + * optional .RogueSyncContextBoardEvent PJALJFEJGDD = 9; + */ + private final RogueSyncContextBoardEventOuterClass.RogueSyncContextBoardEvent pJALJFEJGDD = RogueSyncContextBoardEventOuterClass.RogueSyncContextBoardEvent.newInstance(); + + private LLJFPKKLGAK() { + } + + /** + * @return a new empty instance of {@code LLJFPKKLGAK} + */ + public static LLJFPKKLGAK newInstance() { + return new LLJFPKKLGAK(); + } + + /** + * optional .LANBPBBAJLM OLMCGHBDKIE = 1; + * @return whether the oLMCGHBDKIE field is set + */ + public boolean hasOLMCGHBDKIE() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .LANBPBBAJLM OLMCGHBDKIE = 1; + * @return this + */ + public LLJFPKKLGAK clearOLMCGHBDKIE() { + bitField0_ &= ~0x00000001; + oLMCGHBDKIE.clear(); + return this; + } + + /** + * optional .LANBPBBAJLM OLMCGHBDKIE = 1; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableOLMCGHBDKIE()} if you want to modify it. + * + * @return internal storage object for reading + */ + public LANBPBBAJLMOuterClass.LANBPBBAJLM getOLMCGHBDKIE() { + return oLMCGHBDKIE; + } + + /** + * optional .LANBPBBAJLM OLMCGHBDKIE = 1; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public LANBPBBAJLMOuterClass.LANBPBBAJLM getMutableOLMCGHBDKIE() { + bitField0_ |= 0x00000001; + return oLMCGHBDKIE; + } + + /** + * optional .LANBPBBAJLM OLMCGHBDKIE = 1; + * @param value the oLMCGHBDKIE to set + * @return this + */ + public LLJFPKKLGAK setOLMCGHBDKIE(final LANBPBBAJLMOuterClass.LANBPBBAJLM value) { + bitField0_ |= 0x00000001; + oLMCGHBDKIE.copyFrom(value); + return this; + } + + /** + * optional .RogueSyncContextBoardEvent PJALJFEJGDD = 9; + * @return whether the pJALJFEJGDD field is set + */ + public boolean hasPJALJFEJGDD() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional .RogueSyncContextBoardEvent PJALJFEJGDD = 9; + * @return this + */ + public LLJFPKKLGAK clearPJALJFEJGDD() { + bitField0_ &= ~0x00000002; + pJALJFEJGDD.clear(); + return this; + } + + /** + * optional .RogueSyncContextBoardEvent PJALJFEJGDD = 9; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutablePJALJFEJGDD()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RogueSyncContextBoardEventOuterClass.RogueSyncContextBoardEvent getPJALJFEJGDD() { + return pJALJFEJGDD; + } + + /** + * optional .RogueSyncContextBoardEvent PJALJFEJGDD = 9; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RogueSyncContextBoardEventOuterClass.RogueSyncContextBoardEvent getMutablePJALJFEJGDD() { + bitField0_ |= 0x00000002; + return pJALJFEJGDD; + } + + /** + * optional .RogueSyncContextBoardEvent PJALJFEJGDD = 9; + * @param value the pJALJFEJGDD to set + * @return this + */ + public LLJFPKKLGAK setPJALJFEJGDD( + final RogueSyncContextBoardEventOuterClass.RogueSyncContextBoardEvent value) { + bitField0_ |= 0x00000002; + pJALJFEJGDD.copyFrom(value); + return this; + } + + @Override + public LLJFPKKLGAK copyFrom(final LLJFPKKLGAK other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + oLMCGHBDKIE.copyFrom(other.oLMCGHBDKIE); + pJALJFEJGDD.copyFrom(other.pJALJFEJGDD); + } + return this; + } + + @Override + public LLJFPKKLGAK mergeFrom(final LLJFPKKLGAK other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasOLMCGHBDKIE()) { + getMutableOLMCGHBDKIE().mergeFrom(other.oLMCGHBDKIE); + } + if (other.hasPJALJFEJGDD()) { + getMutablePJALJFEJGDD().mergeFrom(other.pJALJFEJGDD); + } + return this; + } + + @Override + public LLJFPKKLGAK clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + oLMCGHBDKIE.clear(); + pJALJFEJGDD.clear(); + return this; + } + + @Override + public LLJFPKKLGAK clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + oLMCGHBDKIE.clearQuick(); + pJALJFEJGDD.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof LLJFPKKLGAK)) { + return false; + } + LLJFPKKLGAK other = (LLJFPKKLGAK) o; + return bitField0_ == other.bitField0_ + && (!hasOLMCGHBDKIE() || oLMCGHBDKIE.equals(other.oLMCGHBDKIE)) + && (!hasPJALJFEJGDD() || pJALJFEJGDD.equals(other.pJALJFEJGDD)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 10); + output.writeMessageNoTag(oLMCGHBDKIE); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 74); + output.writeMessageNoTag(pJALJFEJGDD); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(oLMCGHBDKIE); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(pJALJFEJGDD); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public LLJFPKKLGAK mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 10: { + // oLMCGHBDKIE + input.readMessage(oLMCGHBDKIE); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 74) { + break; + } + } + case 74: { + // pJALJFEJGDD + input.readMessage(pJALJFEJGDD); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.oLMCGHBDKIE, oLMCGHBDKIE); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeMessage(FieldNames.pJALJFEJGDD, pJALJFEJGDD); + } + output.endObject(); + } + + @Override + public LLJFPKKLGAK mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1801344849: { + if (input.isAtField(FieldNames.oLMCGHBDKIE)) { + if (!input.trySkipNullValue()) { + input.readMessage(oLMCGHBDKIE); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1725659457: { + if (input.isAtField(FieldNames.pJALJFEJGDD)) { + if (!input.trySkipNullValue()) { + input.readMessage(pJALJFEJGDD); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public LLJFPKKLGAK clone() { + return new LLJFPKKLGAK().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static LLJFPKKLGAK parseFrom(final byte[] data) throws InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new LLJFPKKLGAK(), data).checkInitialized(); + } + + public static LLJFPKKLGAK parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new LLJFPKKLGAK(), input).checkInitialized(); + } + + public static LLJFPKKLGAK parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new LLJFPKKLGAK(), input).checkInitialized(); + } + + /** + * @return factory for creating LLJFPKKLGAK messages + */ + public static MessageFactory getFactory() { + return LLJFPKKLGAKFactory.INSTANCE; + } + + private enum LLJFPKKLGAKFactory implements MessageFactory { + INSTANCE; + + @Override + public LLJFPKKLGAK create() { + return LLJFPKKLGAK.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName oLMCGHBDKIE = FieldName.forField("OLMCGHBDKIE"); + + static final FieldName pJALJFEJGDD = FieldName.forField("PJALJFEJGDD"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/RogueAvatarReviveCostOuterClass.java b/src/generated/main/emu/lunarcore/proto/RogueAvatarReviveCostOuterClass.java new file mode 100644 index 0000000..152c314 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/RogueAvatarReviveCostOuterClass.java @@ -0,0 +1,281 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class RogueAvatarReviveCostOuterClass { + /** + * Protobuf type {@code RogueAvatarReviveCost} + */ + public static final class RogueAvatarReviveCost extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .ItemCostList revive_cost = 6; + */ + private final ItemCostListOuterClass.ItemCostList reviveCost = ItemCostListOuterClass.ItemCostList.newInstance(); + + private RogueAvatarReviveCost() { + } + + /** + * @return a new empty instance of {@code RogueAvatarReviveCost} + */ + public static RogueAvatarReviveCost newInstance() { + return new RogueAvatarReviveCost(); + } + + /** + * optional .ItemCostList revive_cost = 6; + * @return whether the reviveCost field is set + */ + public boolean hasReviveCost() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .ItemCostList revive_cost = 6; + * @return this + */ + public RogueAvatarReviveCost clearReviveCost() { + bitField0_ &= ~0x00000001; + reviveCost.clear(); + return this; + } + + /** + * optional .ItemCostList revive_cost = 6; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableReviveCost()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ItemCostListOuterClass.ItemCostList getReviveCost() { + return reviveCost; + } + + /** + * optional .ItemCostList revive_cost = 6; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ItemCostListOuterClass.ItemCostList getMutableReviveCost() { + bitField0_ |= 0x00000001; + return reviveCost; + } + + /** + * optional .ItemCostList revive_cost = 6; + * @param value the reviveCost to set + * @return this + */ + public RogueAvatarReviveCost setReviveCost(final ItemCostListOuterClass.ItemCostList value) { + bitField0_ |= 0x00000001; + reviveCost.copyFrom(value); + return this; + } + + @Override + public RogueAvatarReviveCost copyFrom(final RogueAvatarReviveCost other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + reviveCost.copyFrom(other.reviveCost); + } + return this; + } + + @Override + public RogueAvatarReviveCost mergeFrom(final RogueAvatarReviveCost other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasReviveCost()) { + getMutableReviveCost().mergeFrom(other.reviveCost); + } + return this; + } + + @Override + public RogueAvatarReviveCost clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + reviveCost.clear(); + return this; + } + + @Override + public RogueAvatarReviveCost clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + reviveCost.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof RogueAvatarReviveCost)) { + return false; + } + RogueAvatarReviveCost other = (RogueAvatarReviveCost) o; + return bitField0_ == other.bitField0_ + && (!hasReviveCost() || reviveCost.equals(other.reviveCost)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 50); + output.writeMessageNoTag(reviveCost); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(reviveCost); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public RogueAvatarReviveCost mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 50: { + // reviveCost + input.readMessage(reviveCost); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.reviveCost, reviveCost); + } + output.endObject(); + } + + @Override + public RogueAvatarReviveCost mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1426560318: + case -1248199561: { + if (input.isAtField(FieldNames.reviveCost)) { + if (!input.trySkipNullValue()) { + input.readMessage(reviveCost); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public RogueAvatarReviveCost clone() { + return new RogueAvatarReviveCost().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static RogueAvatarReviveCost parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new RogueAvatarReviveCost(), data).checkInitialized(); + } + + public static RogueAvatarReviveCost parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueAvatarReviveCost(), input).checkInitialized(); + } + + public static RogueAvatarReviveCost parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueAvatarReviveCost(), input).checkInitialized(); + } + + /** + * @return factory for creating RogueAvatarReviveCost messages + */ + public static MessageFactory getFactory() { + return RogueAvatarReviveCostFactory.INSTANCE; + } + + private enum RogueAvatarReviveCostFactory implements MessageFactory { + INSTANCE; + + @Override + public RogueAvatarReviveCost create() { + return RogueAvatarReviveCost.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName reviveCost = FieldName.forField("reviveCost", "revive_cost"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/RogueSyncContextBoardEventOuterClass.java b/src/generated/main/emu/lunarcore/proto/RogueSyncContextBoardEventOuterClass.java new file mode 100644 index 0000000..273c8fd --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/RogueSyncContextBoardEventOuterClass.java @@ -0,0 +1,341 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class RogueSyncContextBoardEventOuterClass { + /** + * Protobuf type {@code RogueSyncContextBoardEvent} + */ + public static final class RogueSyncContextBoardEvent extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 board_event_id = 1; + */ + private int boardEventId; + + /** + * optional uint32 modifier_effect_type = 6; + */ + private int modifierEffectType; + + private RogueSyncContextBoardEvent() { + } + + /** + * @return a new empty instance of {@code RogueSyncContextBoardEvent} + */ + public static RogueSyncContextBoardEvent newInstance() { + return new RogueSyncContextBoardEvent(); + } + + /** + * optional uint32 board_event_id = 1; + * @return whether the boardEventId field is set + */ + public boolean hasBoardEventId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 board_event_id = 1; + * @return this + */ + public RogueSyncContextBoardEvent clearBoardEventId() { + bitField0_ &= ~0x00000001; + boardEventId = 0; + return this; + } + + /** + * optional uint32 board_event_id = 1; + * @return the boardEventId + */ + public int getBoardEventId() { + return boardEventId; + } + + /** + * optional uint32 board_event_id = 1; + * @param value the boardEventId to set + * @return this + */ + public RogueSyncContextBoardEvent setBoardEventId(final int value) { + bitField0_ |= 0x00000001; + boardEventId = value; + return this; + } + + /** + * optional uint32 modifier_effect_type = 6; + * @return whether the modifierEffectType field is set + */ + public boolean hasModifierEffectType() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 modifier_effect_type = 6; + * @return this + */ + public RogueSyncContextBoardEvent clearModifierEffectType() { + bitField0_ &= ~0x00000002; + modifierEffectType = 0; + return this; + } + + /** + * optional uint32 modifier_effect_type = 6; + * @return the modifierEffectType + */ + public int getModifierEffectType() { + return modifierEffectType; + } + + /** + * optional uint32 modifier_effect_type = 6; + * @param value the modifierEffectType to set + * @return this + */ + public RogueSyncContextBoardEvent setModifierEffectType(final int value) { + bitField0_ |= 0x00000002; + modifierEffectType = value; + return this; + } + + @Override + public RogueSyncContextBoardEvent copyFrom(final RogueSyncContextBoardEvent other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + boardEventId = other.boardEventId; + modifierEffectType = other.modifierEffectType; + } + return this; + } + + @Override + public RogueSyncContextBoardEvent mergeFrom(final RogueSyncContextBoardEvent other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasBoardEventId()) { + setBoardEventId(other.boardEventId); + } + if (other.hasModifierEffectType()) { + setModifierEffectType(other.modifierEffectType); + } + return this; + } + + @Override + public RogueSyncContextBoardEvent clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + boardEventId = 0; + modifierEffectType = 0; + return this; + } + + @Override + public RogueSyncContextBoardEvent clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof RogueSyncContextBoardEvent)) { + return false; + } + RogueSyncContextBoardEvent other = (RogueSyncContextBoardEvent) o; + return bitField0_ == other.bitField0_ + && (!hasBoardEventId() || boardEventId == other.boardEventId) + && (!hasModifierEffectType() || modifierEffectType == other.modifierEffectType); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(boardEventId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 48); + output.writeUInt32NoTag(modifierEffectType); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(boardEventId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(modifierEffectType); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public RogueSyncContextBoardEvent mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // boardEventId + boardEventId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 48) { + break; + } + } + case 48: { + // modifierEffectType + modifierEffectType = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.boardEventId, boardEventId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.modifierEffectType, modifierEffectType); + } + output.endObject(); + } + + @Override + public RogueSyncContextBoardEvent mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1130727537: + case -1668848103: { + if (input.isAtField(FieldNames.boardEventId)) { + if (!input.trySkipNullValue()) { + boardEventId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1445000542: + case -145180736: { + if (input.isAtField(FieldNames.modifierEffectType)) { + if (!input.trySkipNullValue()) { + modifierEffectType = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public RogueSyncContextBoardEvent clone() { + return new RogueSyncContextBoardEvent().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static RogueSyncContextBoardEvent parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new RogueSyncContextBoardEvent(), data).checkInitialized(); + } + + public static RogueSyncContextBoardEvent parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueSyncContextBoardEvent(), input).checkInitialized(); + } + + public static RogueSyncContextBoardEvent parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueSyncContextBoardEvent(), input).checkInitialized(); + } + + /** + * @return factory for creating RogueSyncContextBoardEvent messages + */ + public static MessageFactory getFactory() { + return RogueSyncContextBoardEventFactory.INSTANCE; + } + + private enum RogueSyncContextBoardEventFactory implements MessageFactory { + INSTANCE; + + @Override + public RogueSyncContextBoardEvent create() { + return RogueSyncContextBoardEvent.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName boardEventId = FieldName.forField("boardEventId", "board_event_id"); + + static final FieldName modifierEffectType = FieldName.forField("modifierEffectType", "modifier_effect_type"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/SyncChessRogueNousValueScNotifyOuterClass.java b/src/generated/main/emu/lunarcore/proto/SyncChessRogueNousValueScNotifyOuterClass.java new file mode 100644 index 0000000..c2aa1d1 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/SyncChessRogueNousValueScNotifyOuterClass.java @@ -0,0 +1,283 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class SyncChessRogueNousValueScNotifyOuterClass { + /** + * Protobuf type {@code SyncChessRogueNousValueScNotify} + */ + public static final class SyncChessRogueNousValueScNotify extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .ChessRogueNousValue value = 12; + */ + private final ChessRogueNousValueOuterClass.ChessRogueNousValue value_ = ChessRogueNousValueOuterClass.ChessRogueNousValue.newInstance(); + + private SyncChessRogueNousValueScNotify() { + } + + /** + * @return a new empty instance of {@code SyncChessRogueNousValueScNotify} + */ + public static SyncChessRogueNousValueScNotify newInstance() { + return new SyncChessRogueNousValueScNotify(); + } + + /** + * optional .ChessRogueNousValue value = 12; + * @return whether the value_ field is set + */ + public boolean hasValue() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .ChessRogueNousValue value = 12; + * @return this + */ + public SyncChessRogueNousValueScNotify clearValue() { + bitField0_ &= ~0x00000001; + value_.clear(); + return this; + } + + /** + * optional .ChessRogueNousValue value = 12; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableValue()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ChessRogueNousValueOuterClass.ChessRogueNousValue getValue() { + return value_; + } + + /** + * optional .ChessRogueNousValue value = 12; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ChessRogueNousValueOuterClass.ChessRogueNousValue getMutableValue() { + bitField0_ |= 0x00000001; + return value_; + } + + /** + * optional .ChessRogueNousValue value = 12; + * @param value the value_ to set + * @return this + */ + public SyncChessRogueNousValueScNotify setValue( + final ChessRogueNousValueOuterClass.ChessRogueNousValue value) { + bitField0_ |= 0x00000001; + value_.copyFrom(value); + return this; + } + + @Override + public SyncChessRogueNousValueScNotify copyFrom(final SyncChessRogueNousValueScNotify other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + value_.copyFrom(other.value_); + } + return this; + } + + @Override + public SyncChessRogueNousValueScNotify mergeFrom(final SyncChessRogueNousValueScNotify other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasValue()) { + getMutableValue().mergeFrom(other.value_); + } + return this; + } + + @Override + public SyncChessRogueNousValueScNotify clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + value_.clear(); + return this; + } + + @Override + public SyncChessRogueNousValueScNotify clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + value_.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof SyncChessRogueNousValueScNotify)) { + return false; + } + SyncChessRogueNousValueScNotify other = (SyncChessRogueNousValueScNotify) o; + return bitField0_ == other.bitField0_ + && (!hasValue() || value_.equals(other.value_)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 98); + output.writeMessageNoTag(value_); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(value_); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public SyncChessRogueNousValueScNotify mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 98: { + // value_ + input.readMessage(value_); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeMessage(FieldNames.value_, value_); + } + output.endObject(); + } + + @Override + public SyncChessRogueNousValueScNotify mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 111972721: { + if (input.isAtField(FieldNames.value_)) { + if (!input.trySkipNullValue()) { + input.readMessage(value_); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public SyncChessRogueNousValueScNotify clone() { + return new SyncChessRogueNousValueScNotify().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static SyncChessRogueNousValueScNotify parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new SyncChessRogueNousValueScNotify(), data).checkInitialized(); + } + + public static SyncChessRogueNousValueScNotify parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new SyncChessRogueNousValueScNotify(), input).checkInitialized(); + } + + public static SyncChessRogueNousValueScNotify parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new SyncChessRogueNousValueScNotify(), input).checkInitialized(); + } + + /** + * @return factory for creating SyncChessRogueNousValueScNotify messages + */ + public static MessageFactory getFactory() { + return SyncChessRogueNousValueScNotifyFactory.INSTANCE; + } + + private enum SyncChessRogueNousValueScNotifyFactory implements MessageFactory { + INSTANCE; + + @Override + public SyncChessRogueNousValueScNotify create() { + return SyncChessRogueNousValueScNotify.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName value_ = FieldName.forField("value"); + } + } +} diff --git a/src/main/java/emu/lunarcore/data/GameData.java b/src/main/java/emu/lunarcore/data/GameData.java index 6989d6f..cd289d5 100644 --- a/src/main/java/emu/lunarcore/data/GameData.java +++ b/src/main/java/emu/lunarcore/data/GameData.java @@ -58,6 +58,10 @@ public class GameData { @Getter private static Int2ObjectMap rogueDialogueEventList = new Int2ObjectOpenHashMap<>(); @Getter private static Int2ObjectMap rogueBuffTagExcelMap = new Int2ObjectOpenHashMap<>(); @Getter private static Int2ObjectMap rogueBuffGroupExcelMap = new Int2ObjectOpenHashMap<>(); + + @Getter private static Int2ObjectMap rogueNousMainStoryExcelMap = new Int2ObjectOpenHashMap<>(); + @Getter private static Int2ObjectMap rogueNousSubStoryExcelMap = new Int2ObjectOpenHashMap<>(); + @Getter private static Int2ObjectMap rogueNousDiceBranchExcelMap = new Int2ObjectOpenHashMap<>(); private static Int2ObjectMap rogueBuffExcelMap = new Int2ObjectOpenHashMap<>(); private static Int2ObjectMap avatarPromotionExcelMap = new Int2ObjectOpenHashMap<>(); diff --git a/src/main/java/emu/lunarcore/data/excel/RogueNousDiceBranchExcel.java b/src/main/java/emu/lunarcore/data/excel/RogueNousDiceBranchExcel.java new file mode 100644 index 0000000..b1dbc75 --- /dev/null +++ b/src/main/java/emu/lunarcore/data/excel/RogueNousDiceBranchExcel.java @@ -0,0 +1,26 @@ +package emu.lunarcore.data.excel; + +import emu.lunarcore.data.GameData; +import emu.lunarcore.data.GameResource; +import emu.lunarcore.data.ResourceType; +import lombok.Getter; + +import java.util.Set; + +@Getter +@ResourceType(name = {"RogueNousDiceBranch.json"}) +public class RogueNousDiceBranchExcel extends GameResource { + private int BranchId; + private int DefaultUltraSurface; + private Set DefaultCommonSurfaceList; + + @Override + public int getId() { + return BranchId; + } + + @Override + public void onLoad() { + GameData.getRogueNousDiceBranchExcelMap().put(BranchId, this); + } +} diff --git a/src/main/java/emu/lunarcore/data/excel/RogueNousMainStoryExcel.java b/src/main/java/emu/lunarcore/data/excel/RogueNousMainStoryExcel.java new file mode 100644 index 0000000..57d836a --- /dev/null +++ b/src/main/java/emu/lunarcore/data/excel/RogueNousMainStoryExcel.java @@ -0,0 +1,23 @@ +package emu.lunarcore.data.excel; + +import emu.lunarcore.data.GameData; +import emu.lunarcore.data.GameResource; +import emu.lunarcore.data.ResourceType; +import lombok.Getter; + +@Getter +@ResourceType(name = {"RogueNousMainStory.json"}) +public class RogueNousMainStoryExcel extends GameResource { + private int StoryID; + private int Layer; + + @Override + public int getId() { + return this.StoryID; + } + + @Override + public void onLoad() { + GameData.getRogueNousMainStoryExcelMap().put(this.StoryID, this); + } +} diff --git a/src/main/java/emu/lunarcore/data/excel/RogueNousSubStoryExcel.java b/src/main/java/emu/lunarcore/data/excel/RogueNousSubStoryExcel.java new file mode 100644 index 0000000..eb1af42 --- /dev/null +++ b/src/main/java/emu/lunarcore/data/excel/RogueNousSubStoryExcel.java @@ -0,0 +1,23 @@ +package emu.lunarcore.data.excel; + +import emu.lunarcore.data.GameData; +import emu.lunarcore.data.GameResource; +import emu.lunarcore.data.ResourceType; +import lombok.Getter; + +@Getter +@ResourceType(name = {"RogueNousSubStory.json"}) +public class RogueNousSubStoryExcel extends GameResource { + private int StoryID; + private int Layer; + + @Override + public int getId() { + return this.StoryID; + } + + @Override + public void onLoad() { + GameData.getRogueNousSubStoryExcelMap().put(this.StoryID, this); + } +} diff --git a/src/main/java/emu/lunarcore/game/battle/BattleService.java b/src/main/java/emu/lunarcore/game/battle/BattleService.java index 759d393..dbb8883 100644 --- a/src/main/java/emu/lunarcore/game/battle/BattleService.java +++ b/src/main/java/emu/lunarcore/game/battle/BattleService.java @@ -166,6 +166,7 @@ public class BattleService extends BaseGameService { public void startBattle(Player player, int stageId) { // Sanity check to make sure player isnt in a battle if (player.isInBattle()) { + player.sendPacket(new PacketSceneEnterStageScRsp(player.getBattle())); return; } diff --git a/src/main/java/emu/lunarcore/game/player/Player.java b/src/main/java/emu/lunarcore/game/player/Player.java index 16eaec2..0e8d528 100644 --- a/src/main/java/emu/lunarcore/game/player/Player.java +++ b/src/main/java/emu/lunarcore/game/player/Player.java @@ -43,6 +43,7 @@ import emu.lunarcore.game.player.lineup.PlayerLineup; import emu.lunarcore.game.rogue.RogueInstance; import emu.lunarcore.game.rogue.RogueManager; import emu.lunarcore.game.rogue.RogueTalentData; +import emu.lunarcore.game.rogue.chess.ChessRogueManager; import emu.lunarcore.game.scene.Scene; import emu.lunarcore.game.scene.SceneBuff; import emu.lunarcore.game.scene.entity.EntityProp; @@ -115,6 +116,7 @@ public class Player implements Tickable { private transient final Mailbox mailbox; private transient final ChallengeManager challengeManager; private transient final RogueManager rogueManager; + private transient final ChessRogueManager chessRogueManager; // Database persistent data private LineupManager lineupManager; @@ -147,6 +149,7 @@ public class Player implements Tickable { this.mailbox = new Mailbox(this); this.challengeManager = new ChallengeManager(this); this.rogueManager = new RogueManager(this); + this.chessRogueManager = new ChessRogueManager(this); } // Called when player is created diff --git a/src/main/java/emu/lunarcore/game/rogue/RogueEntityLoader.java b/src/main/java/emu/lunarcore/game/rogue/RogueEntityLoader.java index 9c7fb32..298e61a 100644 --- a/src/main/java/emu/lunarcore/game/rogue/RogueEntityLoader.java +++ b/src/main/java/emu/lunarcore/game/rogue/RogueEntityLoader.java @@ -141,6 +141,8 @@ public class RogueEntityLoader extends SceneEntityLoader { instance = scene.getPlayer().getRogueInstance(); } while (instance.setDialogueParams(npcId) == null); + instance.getEventManager().setNowPercentage(0); + instance.getEventManager().setBuffType(0); npc.setRogueNpcId(npcId); npc.setEventId(++instance.eventId); scene.getPlayer().sendPacket(new PacketSyncRogueDialogueEventDataScNotify(npcId, instance.curDialogueParams.get(npcId), diff --git a/src/main/java/emu/lunarcore/game/rogue/RogueEventManager.java b/src/main/java/emu/lunarcore/game/rogue/RogueEventManager.java index b9df5c4..f1010a3 100644 --- a/src/main/java/emu/lunarcore/game/rogue/RogueEventManager.java +++ b/src/main/java/emu/lunarcore/game/rogue/RogueEventManager.java @@ -3,14 +3,11 @@ package emu.lunarcore.game.rogue; import emu.lunarcore.LunarCore; import emu.lunarcore.data.GameData; import emu.lunarcore.game.player.Player; -import emu.lunarcore.game.scene.entity.EntityNpc; -import emu.lunarcore.proto.FinishRogueDialogueGroupCsReqOuterClass; -import emu.lunarcore.server.packet.BasePacket; -import emu.lunarcore.server.packet.CmdId; -import emu.lunarcore.server.packet.recv.HandlerFinishRogueDialogueGroupCsReq; -import emu.lunarcore.server.packet.send.PacketSyncRogueCommonPendingActionScNotify; +import emu.lunarcore.proto.RogueDialogueEventParamOuterClass.RogueDialogueEventParam; +import emu.lunarcore.util.Utils; import emu.lunarcore.util.WeightedList; import lombok.Getter; +import lombok.Setter; import java.util.List; @@ -18,20 +15,22 @@ import java.util.List; public class RogueEventManager { private RogueInstance rogueInstance; private Player player; + @Setter private int nowPercentage = 0; + @Setter private int buffType = 0; public RogueEventManager(RogueInstance rogueInstance) { this.rogueInstance = rogueInstance; this.player = rogueInstance.getPlayer(); } - public int handleEvent(int eventId) { + public int handleEvent(int eventId, int npcId) { var event = GameData.getRogueDialogueEventList().get(eventId); if (event == null || event.getRogueEffectType() == null) return 0; List param = event.getRogueEffectParamList(); switch (event.getRogueEffectType()) { case GetItem -> rogueInstance.addDialogueMoney(param.get(1)); case TriggerBattle -> { - //this.getPlayer().getServer().getBattleService().startBattle(player, param.get(0)); + this.getPlayer().getServer().getBattleService().startBattle(player, param.get(0)); // handle in SceneEnterStageCsReq } case TriggerRogueMiracleSelect -> this.getRogueInstance().createMiracleSelect(1); case TriggerRogueBuffSelect -> { @@ -61,19 +60,85 @@ public class RogueEventManager { } case TriggerDialogueEventList -> { for (var id : param) { - this.handleEvent(id); + this.handleEvent(id, npcId); + this.getRogueInstance().getCurDialogueParams().get(npcId).add(RogueDialogueEventParam.newInstance() + .setDialogueEventId(id) + .setIsValid(true)); } } case TriggerRandomEventList -> { - this.handleEvent(11604); // temp + var weightList = new WeightedList(); + var nextEventId = 0; + for (var id : param) { + if (nextEventId == 0) { + nextEventId = id; + continue; + } + weightList.add(id, nextEventId); + nextEventId = 0; + } + int randomEventId = weightList.next(); handleCost(eventId); - return 0; + this.handleEvent(randomEventId, npcId); + return randomEventId; } case GetAllRogueBuffInGroupAndGetItem -> { var rogueBuff = GameData.getRogueBuffGroupExcelMap().get(param.get(0)); this.getRogueInstance().addBuff(rogueBuff.getRogueBuffList()); this.getRogueInstance().addDialogueMoney(param.get(2)); } + case RepeatableGamble -> { + var failEventId = param.get(0); + var initialPercent = param.get(1); + var increasePercent = param.get(2); + if (this.nowPercentage != 0) + this.nowPercentage = initialPercent; + else + this.nowPercentage += increasePercent; + var weightList = new WeightedList(); + for (int i = 4; i < param.size(); i += 2) { + weightList.add(param.get(i + 1), param.get(i)); + } + int randomNum = Utils.randomRange(0, 100); + if (randomNum <= this.nowPercentage) { + handleCost(eventId); + this.handleEvent(failEventId, npcId); + this.getRogueInstance().getCurDialogueParams().get(npcId).add(RogueDialogueEventParam.newInstance() + .setDialogueEventId(failEventId) + .setIsValid(true)); + return 0; + } else { + handleCost(eventId); + int nextEventId = weightList.next(); + this.handleEvent(nextEventId, npcId); + this.getRogueInstance().getCurDialogueParams().get(npcId).add(RogueDialogueEventParam.newInstance() + .setDialogueEventId(nextEventId) + .setIsValid(true) + .setRatio(this.nowPercentage / 100f)); + return 0; + } + } + case EnhanceRogueBuff -> { + var rogueBuff = GameData.getRogueBuffGroupExcelMap().get(param.get(0)); + if (rogueBuff != null) { + var weightList = new WeightedList(); + for (var buff : rogueBuff.getRogueBuffList()) { + weightList.add(1.0f, buff); + } + // random param.get(1) times + while (true) { + var buff = weightList.next(); + if (buff == null || buff.getExcel() == null) break; + if (!this.getRogueInstance().getBuffs().containsValue(buff)) continue; + if (this.getRogueInstance().getBuffs().get(buff.getId()).getLevel() >= 2) continue; + this.getRogueInstance().addBuff(new RogueBuffData(buff.getId(), buff.getLevel() + 1)); + param.set(1, param.get(1) - 1); + if (param.get(1) <= 0) break; + } + } + } + + case NONE -> {} // do nothing default -> { LunarCore.getLogger().info("RogueEventManager: unhandled event type: " + event.getRogueEffectType()); // DEBUG } diff --git a/src/main/java/emu/lunarcore/game/rogue/RogueInstance.java b/src/main/java/emu/lunarcore/game/rogue/RogueInstance.java index 4388a7e..c7532a7 100644 --- a/src/main/java/emu/lunarcore/game/rogue/RogueInstance.java +++ b/src/main/java/emu/lunarcore/game/rogue/RogueInstance.java @@ -416,7 +416,7 @@ public class RogueInstance { data.setTimes(this.id - 2); this.getPlayer().sendPacket(new PacketHandleRogueCommonPendingActionScRsp(data)); try { - this.onSelectDialogue(bonus.getEventId()); + this.onSelectDialogue(bonus.getEventId(), 0); } catch (Exception ignored) { } return bonus; @@ -489,6 +489,7 @@ public class RogueInstance { if (argMap.containsKey(v) && argMap.get(v).equals("RelateToBuff")) { param.setArgId(this.getAeonId()); + this.getEventManager().setBuffType(this.getAeonBuffType()); } params.add(param); @@ -560,8 +561,8 @@ public class RogueInstance { // Dialogue stuff - public int onSelectDialogue(int dialogueEventId) { - return this.eventManager.handleEvent(dialogueEventId); + public int onSelectDialogue(int dialogueEventId, int npcId) { + return this.eventManager.handleEvent(dialogueEventId, npcId); } // Battle diff --git a/src/main/java/emu/lunarcore/game/rogue/chess/ChessRogueManager.java b/src/main/java/emu/lunarcore/game/rogue/chess/ChessRogueManager.java new file mode 100644 index 0000000..7778b76 --- /dev/null +++ b/src/main/java/emu/lunarcore/game/rogue/chess/ChessRogueManager.java @@ -0,0 +1,27 @@ +package emu.lunarcore.game.rogue.chess; + +import emu.lunarcore.data.GameData; +import emu.lunarcore.game.player.BasePlayerManager; +import emu.lunarcore.game.player.Player; +import it.unimi.dsi.fastutil.ints.Int2ObjectMap; +import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap; + +import java.util.HashSet; +import java.util.Set; + +public class ChessRogueManager extends BasePlayerManager { + public ChessRogueManager(Player player) { + super(player); + } + + public Int2ObjectMap> getRogueDefaultDice() { + var map = new Int2ObjectOpenHashMap>(); + for (var entry: GameData.getRogueNousDiceBranchExcelMap().values()) { + var set = new HashSet(); + set.add(entry.getDefaultUltraSurface()); + set.addAll(entry.getDefaultCommonSurfaceList()); + map.put(entry.getBranchId(), set); + } + return map; + } +} diff --git a/src/main/java/emu/lunarcore/server/packet/recv/HandlerChessRogueQueryCsReq.java b/src/main/java/emu/lunarcore/server/packet/recv/HandlerChessRogueQueryCsReq.java new file mode 100644 index 0000000..8b64e01 --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/recv/HandlerChessRogueQueryCsReq.java @@ -0,0 +1,16 @@ +package emu.lunarcore.server.packet.recv; + +import emu.lunarcore.server.game.GameSession; +import emu.lunarcore.server.packet.CmdId; +import emu.lunarcore.server.packet.Opcodes; +import emu.lunarcore.server.packet.PacketHandler; +import emu.lunarcore.server.packet.send.PacketChessRogueQueryScRsp; + +@Opcodes(CmdId.ChessRogueQueryCsReq) +public class HandlerChessRogueQueryCsReq extends PacketHandler { + + @Override + public void handle(GameSession session, byte[] data) throws Exception { + session.send(new PacketChessRogueQueryScRsp(session.getPlayer())); + } +} diff --git a/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetChessRogueNousStoryInfoCsReq.java b/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetChessRogueNousStoryInfoCsReq.java new file mode 100644 index 0000000..027f17a --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetChessRogueNousStoryInfoCsReq.java @@ -0,0 +1,15 @@ +package emu.lunarcore.server.packet.recv; + +import emu.lunarcore.server.game.GameSession; +import emu.lunarcore.server.packet.CmdId; +import emu.lunarcore.server.packet.Opcodes; +import emu.lunarcore.server.packet.PacketHandler; +import emu.lunarcore.server.packet.send.PacketGetChessRogueNousStoryInfoScRsp; + +@Opcodes(CmdId.GetChessRogueNousStoryInfoCsReq) +public class HandlerGetChessRogueNousStoryInfoCsReq extends PacketHandler { + @Override + public void handle(GameSession session, byte[] data) throws Exception { + session.send(new PacketGetChessRogueNousStoryInfoScRsp()); + } +} diff --git a/src/main/java/emu/lunarcore/server/packet/recv/HandlerSelectRogueDialogueEventCsReq.java b/src/main/java/emu/lunarcore/server/packet/recv/HandlerSelectRogueDialogueEventCsReq.java index 8d2475b..3fd45c0 100644 --- a/src/main/java/emu/lunarcore/server/packet/recv/HandlerSelectRogueDialogueEventCsReq.java +++ b/src/main/java/emu/lunarcore/server/packet/recv/HandlerSelectRogueDialogueEventCsReq.java @@ -21,7 +21,7 @@ public class HandlerSelectRogueDialogueEventCsReq extends PacketHandler { int callback = 0; if (session.getPlayer().getRogueInstance() != null) { - callback = session.getPlayer().getRogueInstance().onSelectDialogue(req.getDialogueEventId()); + callback = session.getPlayer().getRogueInstance().onSelectDialogue(req.getDialogueEventId(), npc.getRogueNpcId()); } session.send(new PacketSelectRogueDialogueEventScRsp(req.getDialogueEventId(), npc, callback)); diff --git a/src/main/java/emu/lunarcore/server/packet/send/PacketChessRogueQueryScRsp.java b/src/main/java/emu/lunarcore/server/packet/send/PacketChessRogueQueryScRsp.java new file mode 100644 index 0000000..7a1fa5d --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/send/PacketChessRogueQueryScRsp.java @@ -0,0 +1,39 @@ +package emu.lunarcore.server.packet.send; + +import emu.lunarcore.data.GameData; +import emu.lunarcore.game.player.Player; +import emu.lunarcore.proto.ChessRogueNousDiceInfoOuterClass.ChessRogueNousDiceInfo; +import emu.lunarcore.proto.ChessRogueNousDiceSurfaceInfoOuterClass.ChessRogueNousDiceSurfaceInfo; +import emu.lunarcore.proto.ChessRogueNousQueryInfoOuterClass.ChessRogueNousQueryInfo; +import emu.lunarcore.proto.ChessRogueQueryOuterClass.ChessRogueQuery; +import emu.lunarcore.proto.ChessRogueQueryScRspOuterClass.ChessRogueQueryScRsp; +import emu.lunarcore.server.packet.BasePacket; +import emu.lunarcore.server.packet.CmdId; + +public class PacketChessRogueQueryScRsp extends BasePacket { + public PacketChessRogueQueryScRsp(Player player) { + super(CmdId.ChessRogueQueryScRsp); + + var data = ChessRogueQuery.newInstance(); + + for (var entry: GameData.getRogueNousMainStoryExcelMap().keySet()) { + data.addMainStoryId(entry); + } + player.getChessRogueManager().getRogueDefaultDice().forEach((k, v) -> { + var dice = ChessRogueNousDiceInfo.newInstance() + .setDiceBranchId(k); + var index = 0; + for (Integer d : v) { + dice.addDiceSurface(ChessRogueNousDiceSurfaceInfo.newInstance() + .setIndex(++index) + .setDiceId(d)); + } + data.addDiceInfo(dice); + }); + var proto = ChessRogueQueryScRsp.newInstance() + .setRogueNous(ChessRogueNousQueryInfo.newInstance() + .setQueryInfo(data)); + + this.setData(proto); + } +} diff --git a/src/main/java/emu/lunarcore/server/packet/send/PacketGetChessRogueNousStoryInfoScRsp.java b/src/main/java/emu/lunarcore/server/packet/send/PacketGetChessRogueNousStoryInfoScRsp.java new file mode 100644 index 0000000..11473f5 --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/send/PacketGetChessRogueNousStoryInfoScRsp.java @@ -0,0 +1,29 @@ +package emu.lunarcore.server.packet.send; + +import emu.lunarcore.data.GameData; +import emu.lunarcore.proto.ChessRogueNousMainStoryInfoOuterClass.ChessRogueNousMainStoryInfo; +import emu.lunarcore.proto.ChessRogueNousSubStoryInfoOuterClass.ChessRogueNousSubStoryInfo; +import emu.lunarcore.proto.GetChessRogueNousStoryInfoScRspOuterClass.GetChessRogueNousStoryInfoScRsp; +import emu.lunarcore.server.packet.BasePacket; +import emu.lunarcore.server.packet.CmdId; + +public class PacketGetChessRogueNousStoryInfoScRsp extends BasePacket { + public PacketGetChessRogueNousStoryInfoScRsp() { + super(CmdId.GetChessRogueNousStoryInfoScRsp); + + var proto = GetChessRogueNousStoryInfoScRsp.newInstance(); + + for (var entry : GameData.getRogueNousMainStoryExcelMap().keySet()) { + proto.addMainStoryInfo(ChessRogueNousMainStoryInfo.newInstance() + .setStoryId(entry) + .setStatus(2)); + } + + for (var entry : GameData.getRogueNousSubStoryExcelMap().keySet()) { + proto.addSubStoryInfo(ChessRogueNousSubStoryInfo.newInstance() + .setSubStoryId(entry)); + } + + this.setData(proto); + } +}