diff --git a/src/generated/main/emu/lunarcore/proto/GetRogueHandbookDataScRspOuterClass.java b/src/generated/main/emu/lunarcore/proto/GetRogueHandbookDataScRspOuterClass.java new file mode 100644 index 0000000..5164792 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/GetRogueHandbookDataScRspOuterClass.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 GetRogueHandbookDataScRspOuterClass { + /** + * Protobuf type {@code GetRogueHandbookDataScRsp} + */ + public static final class GetRogueHandbookDataScRsp extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 retcode = 6; + */ + private int retcode; + + /** + * optional .RogueHandbookData handbook_info = 11; + */ + private final RogueHandbookDataOuterClass.RogueHandbookData handbookInfo = RogueHandbookDataOuterClass.RogueHandbookData.newInstance(); + + private GetRogueHandbookDataScRsp() { + } + + /** + * @return a new empty instance of {@code GetRogueHandbookDataScRsp} + */ + public static GetRogueHandbookDataScRsp newInstance() { + return new GetRogueHandbookDataScRsp(); + } + + /** + * optional uint32 retcode = 6; + * @return whether the retcode field is set + */ + public boolean hasRetcode() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 retcode = 6; + * @return this + */ + public GetRogueHandbookDataScRsp clearRetcode() { + bitField0_ &= ~0x00000001; + retcode = 0; + return this; + } + + /** + * optional uint32 retcode = 6; + * @return the retcode + */ + public int getRetcode() { + return retcode; + } + + /** + * optional uint32 retcode = 6; + * @param value the retcode to set + * @return this + */ + public GetRogueHandbookDataScRsp setRetcode(final int value) { + bitField0_ |= 0x00000001; + retcode = value; + return this; + } + + /** + * optional .RogueHandbookData handbook_info = 11; + * @return whether the handbookInfo field is set + */ + public boolean hasHandbookInfo() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional .RogueHandbookData handbook_info = 11; + * @return this + */ + public GetRogueHandbookDataScRsp clearHandbookInfo() { + bitField0_ &= ~0x00000002; + handbookInfo.clear(); + return this; + } + + /** + * optional .RogueHandbookData handbook_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 #getMutableHandbookInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RogueHandbookDataOuterClass.RogueHandbookData getHandbookInfo() { + return handbookInfo; + } + + /** + * optional .RogueHandbookData handbook_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 RogueHandbookDataOuterClass.RogueHandbookData getMutableHandbookInfo() { + bitField0_ |= 0x00000002; + return handbookInfo; + } + + /** + * optional .RogueHandbookData handbook_info = 11; + * @param value the handbookInfo to set + * @return this + */ + public GetRogueHandbookDataScRsp setHandbookInfo( + final RogueHandbookDataOuterClass.RogueHandbookData value) { + bitField0_ |= 0x00000002; + handbookInfo.copyFrom(value); + return this; + } + + @Override + public GetRogueHandbookDataScRsp copyFrom(final GetRogueHandbookDataScRsp other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + retcode = other.retcode; + handbookInfo.copyFrom(other.handbookInfo); + } + return this; + } + + @Override + public GetRogueHandbookDataScRsp mergeFrom(final GetRogueHandbookDataScRsp other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRetcode()) { + setRetcode(other.retcode); + } + if (other.hasHandbookInfo()) { + getMutableHandbookInfo().mergeFrom(other.handbookInfo); + } + return this; + } + + @Override + public GetRogueHandbookDataScRsp clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + retcode = 0; + handbookInfo.clear(); + return this; + } + + @Override + public GetRogueHandbookDataScRsp clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + handbookInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof GetRogueHandbookDataScRsp)) { + return false; + } + GetRogueHandbookDataScRsp other = (GetRogueHandbookDataScRsp) o; + return bitField0_ == other.bitField0_ + && (!hasRetcode() || retcode == other.retcode) + && (!hasHandbookInfo() || handbookInfo.equals(other.handbookInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 48); + output.writeUInt32NoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 90); + output.writeMessageNoTag(handbookInfo); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(handbookInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public GetRogueHandbookDataScRsp mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 48: { + // retcode + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 90) { + break; + } + } + case 90: { + // handbookInfo + input.readMessage(handbookInfo); + 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.handbookInfo, handbookInfo); + } + output.endObject(); + } + + @Override + public GetRogueHandbookDataScRsp 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 -460040026: + case -1356162891: { + if (input.isAtField(FieldNames.handbookInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(handbookInfo); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public GetRogueHandbookDataScRsp clone() { + return new GetRogueHandbookDataScRsp().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static GetRogueHandbookDataScRsp parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new GetRogueHandbookDataScRsp(), data).checkInitialized(); + } + + public static GetRogueHandbookDataScRsp parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new GetRogueHandbookDataScRsp(), input).checkInitialized(); + } + + public static GetRogueHandbookDataScRsp parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new GetRogueHandbookDataScRsp(), input).checkInitialized(); + } + + /** + * @return factory for creating GetRogueHandbookDataScRsp messages + */ + public static MessageFactory getFactory() { + return GetRogueHandbookDataScRspFactory.INSTANCE; + } + + private enum GetRogueHandbookDataScRspFactory implements MessageFactory { + INSTANCE; + + @Override + public GetRogueHandbookDataScRsp create() { + return GetRogueHandbookDataScRsp.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName retcode = FieldName.forField("retcode"); + + static final FieldName handbookInfo = FieldName.forField("handbookInfo", "handbook_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/GetRogueInfoScRspOuterClass.java b/src/generated/main/emu/lunarcore/proto/GetRogueInfoScRspOuterClass.java new file mode 100644 index 0000000..f6a1c33 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/GetRogueInfoScRspOuterClass.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 GetRogueInfoScRspOuterClass { + /** + * Protobuf type {@code GetRogueInfoScRsp} + */ + public static final class GetRogueInfoScRsp extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 retcode = 11; + */ + private int retcode; + + /** + * optional .RogueInfo rogue_info = 3; + */ + private final RogueInfoOuterClass.RogueInfo rogueInfo = RogueInfoOuterClass.RogueInfo.newInstance(); + + private GetRogueInfoScRsp() { + } + + /** + * @return a new empty instance of {@code GetRogueInfoScRsp} + */ + public static GetRogueInfoScRsp newInstance() { + return new GetRogueInfoScRsp(); + } + + /** + * 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 GetRogueInfoScRsp 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 GetRogueInfoScRsp setRetcode(final int value) { + bitField0_ |= 0x00000001; + retcode = value; + return this; + } + + /** + * optional .RogueInfo rogue_info = 3; + * @return whether the rogueInfo field is set + */ + public boolean hasRogueInfo() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional .RogueInfo rogue_info = 3; + * @return this + */ + public GetRogueInfoScRsp clearRogueInfo() { + bitField0_ &= ~0x00000002; + rogueInfo.clear(); + return this; + } + + /** + * optional .RogueInfo rogue_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 #getMutableRogueInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RogueInfoOuterClass.RogueInfo getRogueInfo() { + return rogueInfo; + } + + /** + * optional .RogueInfo rogue_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 RogueInfoOuterClass.RogueInfo getMutableRogueInfo() { + bitField0_ |= 0x00000002; + return rogueInfo; + } + + /** + * optional .RogueInfo rogue_info = 3; + * @param value the rogueInfo to set + * @return this + */ + public GetRogueInfoScRsp setRogueInfo(final RogueInfoOuterClass.RogueInfo value) { + bitField0_ |= 0x00000002; + rogueInfo.copyFrom(value); + return this; + } + + @Override + public GetRogueInfoScRsp copyFrom(final GetRogueInfoScRsp other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + retcode = other.retcode; + rogueInfo.copyFrom(other.rogueInfo); + } + return this; + } + + @Override + public GetRogueInfoScRsp mergeFrom(final GetRogueInfoScRsp other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRetcode()) { + setRetcode(other.retcode); + } + if (other.hasRogueInfo()) { + getMutableRogueInfo().mergeFrom(other.rogueInfo); + } + return this; + } + + @Override + public GetRogueInfoScRsp clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + retcode = 0; + rogueInfo.clear(); + return this; + } + + @Override + public GetRogueInfoScRsp clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + rogueInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof GetRogueInfoScRsp)) { + return false; + } + GetRogueInfoScRsp other = (GetRogueInfoScRsp) o; + return bitField0_ == other.bitField0_ + && (!hasRetcode() || retcode == other.retcode) + && (!hasRogueInfo() || rogueInfo.equals(other.rogueInfo)); + } + + @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) 26); + output.writeMessageNoTag(rogueInfo); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(rogueInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public GetRogueInfoScRsp 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 != 26) { + break; + } + } + case 26: { + // rogueInfo + input.readMessage(rogueInfo); + 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.rogueInfo, rogueInfo); + } + output.endObject(); + } + + @Override + public GetRogueInfoScRsp 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 655808936: + case -1124583437: { + if (input.isAtField(FieldNames.rogueInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(rogueInfo); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public GetRogueInfoScRsp clone() { + return new GetRogueInfoScRsp().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static GetRogueInfoScRsp parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new GetRogueInfoScRsp(), data).checkInitialized(); + } + + public static GetRogueInfoScRsp parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new GetRogueInfoScRsp(), input).checkInitialized(); + } + + public static GetRogueInfoScRsp parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new GetRogueInfoScRsp(), input).checkInitialized(); + } + + /** + * @return factory for creating GetRogueInfoScRsp messages + */ + public static MessageFactory getFactory() { + return GetRogueInfoScRspFactory.INSTANCE; + } + + private enum GetRogueInfoScRspFactory implements MessageFactory { + INSTANCE; + + @Override + public GetRogueInfoScRsp create() { + return GetRogueInfoScRsp.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName retcode = FieldName.forField("retcode"); + + static final FieldName rogueInfo = FieldName.forField("rogueInfo", "rogue_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/GetRogueScoreRewardInfoScRspOuterClass.java b/src/generated/main/emu/lunarcore/proto/GetRogueScoreRewardInfoScRspOuterClass.java new file mode 100644 index 0000000..e07a1bc --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/GetRogueScoreRewardInfoScRspOuterClass.java @@ -0,0 +1,364 @@ +// 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 GetRogueScoreRewardInfoScRspOuterClass { + /** + * Protobuf type {@code GetRogueScoreRewardInfoScRsp} + */ + public static final class GetRogueScoreRewardInfoScRsp extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 retcode = 2; + */ + private int retcode; + + /** + * optional .RogueScoreRewardInfo score_reward_info = 13; + */ + private final RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo scoreRewardInfo = RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo.newInstance(); + + private GetRogueScoreRewardInfoScRsp() { + } + + /** + * @return a new empty instance of {@code GetRogueScoreRewardInfoScRsp} + */ + public static GetRogueScoreRewardInfoScRsp newInstance() { + return new GetRogueScoreRewardInfoScRsp(); + } + + /** + * 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 GetRogueScoreRewardInfoScRsp 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 GetRogueScoreRewardInfoScRsp setRetcode(final int value) { + bitField0_ |= 0x00000001; + retcode = value; + return this; + } + + /** + * optional .RogueScoreRewardInfo score_reward_info = 13; + * @return whether the scoreRewardInfo field is set + */ + public boolean hasScoreRewardInfo() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional .RogueScoreRewardInfo score_reward_info = 13; + * @return this + */ + public GetRogueScoreRewardInfoScRsp clearScoreRewardInfo() { + bitField0_ &= ~0x00000002; + scoreRewardInfo.clear(); + return this; + } + + /** + * optional .RogueScoreRewardInfo score_reward_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 #getMutableScoreRewardInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo getScoreRewardInfo() { + return scoreRewardInfo; + } + + /** + * optional .RogueScoreRewardInfo score_reward_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 RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo getMutableScoreRewardInfo() { + bitField0_ |= 0x00000002; + return scoreRewardInfo; + } + + /** + * optional .RogueScoreRewardInfo score_reward_info = 13; + * @param value the scoreRewardInfo to set + * @return this + */ + public GetRogueScoreRewardInfoScRsp setScoreRewardInfo( + final RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo value) { + bitField0_ |= 0x00000002; + scoreRewardInfo.copyFrom(value); + return this; + } + + @Override + public GetRogueScoreRewardInfoScRsp copyFrom(final GetRogueScoreRewardInfoScRsp other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + retcode = other.retcode; + scoreRewardInfo.copyFrom(other.scoreRewardInfo); + } + return this; + } + + @Override + public GetRogueScoreRewardInfoScRsp mergeFrom(final GetRogueScoreRewardInfoScRsp other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRetcode()) { + setRetcode(other.retcode); + } + if (other.hasScoreRewardInfo()) { + getMutableScoreRewardInfo().mergeFrom(other.scoreRewardInfo); + } + return this; + } + + @Override + public GetRogueScoreRewardInfoScRsp clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + retcode = 0; + scoreRewardInfo.clear(); + return this; + } + + @Override + public GetRogueScoreRewardInfoScRsp clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + scoreRewardInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof GetRogueScoreRewardInfoScRsp)) { + return false; + } + GetRogueScoreRewardInfoScRsp other = (GetRogueScoreRewardInfoScRsp) o; + return bitField0_ == other.bitField0_ + && (!hasRetcode() || retcode == other.retcode) + && (!hasScoreRewardInfo() || scoreRewardInfo.equals(other.scoreRewardInfo)); + } + + @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) 106); + output.writeMessageNoTag(scoreRewardInfo); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(scoreRewardInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public GetRogueScoreRewardInfoScRsp 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 != 106) { + break; + } + } + case 106: { + // scoreRewardInfo + input.readMessage(scoreRewardInfo); + 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.scoreRewardInfo, scoreRewardInfo); + } + output.endObject(); + } + + @Override + public GetRogueScoreRewardInfoScRsp 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 672564399: + case 751191441: { + if (input.isAtField(FieldNames.scoreRewardInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(scoreRewardInfo); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public GetRogueScoreRewardInfoScRsp clone() { + return new GetRogueScoreRewardInfoScRsp().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static GetRogueScoreRewardInfoScRsp parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new GetRogueScoreRewardInfoScRsp(), data).checkInitialized(); + } + + public static GetRogueScoreRewardInfoScRsp parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new GetRogueScoreRewardInfoScRsp(), input).checkInitialized(); + } + + public static GetRogueScoreRewardInfoScRsp parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new GetRogueScoreRewardInfoScRsp(), input).checkInitialized(); + } + + /** + * @return factory for creating GetRogueScoreRewardInfoScRsp messages + */ + public static MessageFactory getFactory() { + return GetRogueScoreRewardInfoScRspFactory.INSTANCE; + } + + private enum GetRogueScoreRewardInfoScRspFactory implements MessageFactory { + INSTANCE; + + @Override + public GetRogueScoreRewardInfoScRsp create() { + return GetRogueScoreRewardInfoScRsp.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName retcode = FieldName.forField("retcode"); + + static final FieldName scoreRewardInfo = FieldName.forField("scoreRewardInfo", "score_reward_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/RogueAreaOuterClass.java b/src/generated/main/emu/lunarcore/proto/RogueAreaOuterClass.java new file mode 100644 index 0000000..edb1cce --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/RogueAreaOuterClass.java @@ -0,0 +1,730 @@ +// 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 RogueAreaOuterClass { + /** + * Protobuf type {@code RogueArea} + */ + public static final class RogueArea extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 area_id = 4; + */ + private int areaId; + + /** + * optional uint32 cur_reach_room_num = 10; + */ + private int curReachRoomNum; + + /** + * optional uint32 map_id = 13; + */ + private int mapId; + + /** + * optional .RogueAreaStatus rogue_area_status = 6; + */ + private int rogueAreaStatus; + + /** + * optional .RogueStatus rogue_status = 9; + */ + private int rogueStatus; + + /** + * optional bool is_reward_taken = 7; + */ + private boolean isRewardTaken; + + private RogueArea() { + } + + /** + * @return a new empty instance of {@code RogueArea} + */ + public static RogueArea newInstance() { + return new RogueArea(); + } + + /** + * optional uint32 area_id = 4; + * @return whether the areaId field is set + */ + public boolean hasAreaId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 area_id = 4; + * @return this + */ + public RogueArea clearAreaId() { + bitField0_ &= ~0x00000001; + areaId = 0; + return this; + } + + /** + * optional uint32 area_id = 4; + * @return the areaId + */ + public int getAreaId() { + return areaId; + } + + /** + * optional uint32 area_id = 4; + * @param value the areaId to set + * @return this + */ + public RogueArea setAreaId(final int value) { + bitField0_ |= 0x00000001; + areaId = value; + return this; + } + + /** + * optional uint32 cur_reach_room_num = 10; + * @return whether the curReachRoomNum field is set + */ + public boolean hasCurReachRoomNum() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 cur_reach_room_num = 10; + * @return this + */ + public RogueArea clearCurReachRoomNum() { + bitField0_ &= ~0x00000002; + curReachRoomNum = 0; + return this; + } + + /** + * optional uint32 cur_reach_room_num = 10; + * @return the curReachRoomNum + */ + public int getCurReachRoomNum() { + return curReachRoomNum; + } + + /** + * optional uint32 cur_reach_room_num = 10; + * @param value the curReachRoomNum to set + * @return this + */ + public RogueArea setCurReachRoomNum(final int value) { + bitField0_ |= 0x00000002; + curReachRoomNum = value; + return this; + } + + /** + * optional uint32 map_id = 13; + * @return whether the mapId field is set + */ + public boolean hasMapId() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 map_id = 13; + * @return this + */ + public RogueArea clearMapId() { + bitField0_ &= ~0x00000004; + mapId = 0; + return this; + } + + /** + * optional uint32 map_id = 13; + * @return the mapId + */ + public int getMapId() { + return mapId; + } + + /** + * optional uint32 map_id = 13; + * @param value the mapId to set + * @return this + */ + public RogueArea setMapId(final int value) { + bitField0_ |= 0x00000004; + mapId = value; + return this; + } + + /** + * optional .RogueAreaStatus rogue_area_status = 6; + * @return whether the rogueAreaStatus field is set + */ + public boolean hasRogueAreaStatus() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional .RogueAreaStatus rogue_area_status = 6; + * @return this + */ + public RogueArea clearRogueAreaStatus() { + bitField0_ &= ~0x00000008; + rogueAreaStatus = 0; + return this; + } + + /** + * optional .RogueAreaStatus rogue_area_status = 6; + * @return the rogueAreaStatus + */ + public RogueAreaStatusOuterClass.RogueAreaStatus getRogueAreaStatus() { + return RogueAreaStatusOuterClass.RogueAreaStatus.forNumber(rogueAreaStatus); + } + + /** + * Gets the value of the internal enum store. The result is + * equivalent to {@link RogueArea#getRogueAreaStatus()}.getNumber(). + * + * @return numeric wire representation + */ + public int getRogueAreaStatusValue() { + return rogueAreaStatus; + } + + /** + * Sets the value of the internal enum store. This does not + * do any validity checks, so be sure to use appropriate value + * constants from {@link RogueAreaStatusOuterClass.RogueAreaStatus}. Setting an invalid value + * can cause {@link RogueArea#getRogueAreaStatus()} to return null + * + * @param value the numeric wire value to set + * @return this + */ + public RogueArea setRogueAreaStatusValue(final int value) { + bitField0_ |= 0x00000008; + rogueAreaStatus = value; + return this; + } + + /** + * optional .RogueAreaStatus rogue_area_status = 6; + * @param value the rogueAreaStatus to set + * @return this + */ + public RogueArea setRogueAreaStatus(final RogueAreaStatusOuterClass.RogueAreaStatus value) { + bitField0_ |= 0x00000008; + rogueAreaStatus = value.getNumber(); + return this; + } + + /** + * optional .RogueStatus rogue_status = 9; + * @return whether the rogueStatus field is set + */ + public boolean hasRogueStatus() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * optional .RogueStatus rogue_status = 9; + * @return this + */ + public RogueArea clearRogueStatus() { + bitField0_ &= ~0x00000010; + rogueStatus = 0; + return this; + } + + /** + * optional .RogueStatus rogue_status = 9; + * @return the rogueStatus + */ + public RogueStatusOuterClass.RogueStatus getRogueStatus() { + return RogueStatusOuterClass.RogueStatus.forNumber(rogueStatus); + } + + /** + * Gets the value of the internal enum store. The result is + * equivalent to {@link RogueArea#getRogueStatus()}.getNumber(). + * + * @return numeric wire representation + */ + public int getRogueStatusValue() { + return rogueStatus; + } + + /** + * Sets the value of the internal enum store. This does not + * do any validity checks, so be sure to use appropriate value + * constants from {@link RogueStatusOuterClass.RogueStatus}. Setting an invalid value + * can cause {@link RogueArea#getRogueStatus()} to return null + * + * @param value the numeric wire value to set + * @return this + */ + public RogueArea setRogueStatusValue(final int value) { + bitField0_ |= 0x00000010; + rogueStatus = value; + return this; + } + + /** + * optional .RogueStatus rogue_status = 9; + * @param value the rogueStatus to set + * @return this + */ + public RogueArea setRogueStatus(final RogueStatusOuterClass.RogueStatus value) { + bitField0_ |= 0x00000010; + rogueStatus = value.getNumber(); + return this; + } + + /** + * optional bool is_reward_taken = 7; + * @return whether the isRewardTaken field is set + */ + public boolean hasIsRewardTaken() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * optional bool is_reward_taken = 7; + * @return this + */ + public RogueArea clearIsRewardTaken() { + bitField0_ &= ~0x00000020; + isRewardTaken = false; + return this; + } + + /** + * optional bool is_reward_taken = 7; + * @return the isRewardTaken + */ + public boolean getIsRewardTaken() { + return isRewardTaken; + } + + /** + * optional bool is_reward_taken = 7; + * @param value the isRewardTaken to set + * @return this + */ + public RogueArea setIsRewardTaken(final boolean value) { + bitField0_ |= 0x00000020; + isRewardTaken = value; + return this; + } + + @Override + public RogueArea copyFrom(final RogueArea other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + areaId = other.areaId; + curReachRoomNum = other.curReachRoomNum; + mapId = other.mapId; + rogueAreaStatus = other.rogueAreaStatus; + rogueStatus = other.rogueStatus; + isRewardTaken = other.isRewardTaken; + } + return this; + } + + @Override + public RogueArea mergeFrom(final RogueArea other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasAreaId()) { + setAreaId(other.areaId); + } + if (other.hasCurReachRoomNum()) { + setCurReachRoomNum(other.curReachRoomNum); + } + if (other.hasMapId()) { + setMapId(other.mapId); + } + if (other.hasRogueAreaStatus()) { + setRogueAreaStatusValue(other.rogueAreaStatus); + } + if (other.hasRogueStatus()) { + setRogueStatusValue(other.rogueStatus); + } + if (other.hasIsRewardTaken()) { + setIsRewardTaken(other.isRewardTaken); + } + return this; + } + + @Override + public RogueArea clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + areaId = 0; + curReachRoomNum = 0; + mapId = 0; + rogueAreaStatus = 0; + rogueStatus = 0; + isRewardTaken = false; + return this; + } + + @Override + public RogueArea 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 RogueArea)) { + return false; + } + RogueArea other = (RogueArea) o; + return bitField0_ == other.bitField0_ + && (!hasAreaId() || areaId == other.areaId) + && (!hasCurReachRoomNum() || curReachRoomNum == other.curReachRoomNum) + && (!hasMapId() || mapId == other.mapId) + && (!hasRogueAreaStatus() || rogueAreaStatus == other.rogueAreaStatus) + && (!hasRogueStatus() || rogueStatus == other.rogueStatus) + && (!hasIsRewardTaken() || isRewardTaken == other.isRewardTaken); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(areaId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 80); + output.writeUInt32NoTag(curReachRoomNum); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 104); + output.writeUInt32NoTag(mapId); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 48); + output.writeEnumNoTag(rogueAreaStatus); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawByte((byte) 72); + output.writeEnumNoTag(rogueStatus); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRawByte((byte) 56); + output.writeBoolNoTag(isRewardTaken); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(areaId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(curReachRoomNum); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(mapId); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeEnumSizeNoTag(rogueAreaStatus); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 1 + ProtoSink.computeEnumSizeNoTag(rogueStatus); + } + if ((bitField0_ & 0x00000020) != 0) { + size += 2; + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public RogueArea mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 32: { + // areaId + areaId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 80) { + break; + } + } + case 80: { + // curReachRoomNum + curReachRoomNum = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 104) { + break; + } + } + case 104: { + // mapId + mapId = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 48) { + break; + } + } + case 48: { + // rogueAreaStatus + final int value = input.readInt32(); + if (RogueAreaStatusOuterClass.RogueAreaStatus.forNumber(value) != null) { + rogueAreaStatus = value; + bitField0_ |= 0x00000008; + } + tag = input.readTag(); + if (tag != 72) { + break; + } + } + case 72: { + // rogueStatus + final int value = input.readInt32(); + if (RogueStatusOuterClass.RogueStatus.forNumber(value) != null) { + rogueStatus = value; + bitField0_ |= 0x00000010; + } + tag = input.readTag(); + if (tag != 56) { + break; + } + } + case 56: { + // isRewardTaken + isRewardTaken = input.readBool(); + 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.areaId, areaId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.curReachRoomNum, curReachRoomNum); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.mapId, mapId); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeEnum(FieldNames.rogueAreaStatus, rogueAreaStatus, RogueAreaStatusOuterClass.RogueAreaStatus.converter()); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeEnum(FieldNames.rogueStatus, rogueStatus, RogueStatusOuterClass.RogueStatus.converter()); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeBool(FieldNames.isRewardTaken, isRewardTaken); + } + output.endObject(); + } + + @Override + public RogueArea mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1409553784: + case -746472947: { + if (input.isAtField(FieldNames.areaId)) { + if (!input.trySkipNullValue()) { + areaId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 888045080: + case 328196941: { + if (input.isAtField(FieldNames.curReachRoomNum)) { + if (!input.trySkipNullValue()) { + curReachRoomNum = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 103663511: + case -1081377058: { + if (input.isAtField(FieldNames.mapId)) { + if (!input.trySkipNullValue()) { + mapId = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -731414439: + case -1961715457: { + if (input.isAtField(FieldNames.rogueAreaStatus)) { + if (!input.trySkipNullValue()) { + final RogueAreaStatusOuterClass.RogueAreaStatus value = input.readEnum(RogueAreaStatusOuterClass.RogueAreaStatus.converter()); + if (value != null) { + rogueAreaStatus = value.getNumber(); + bitField0_ |= 0x00000008; + } else { + input.skipUnknownEnumValue(); + } + } + } else { + input.skipUnknownField(); + } + break; + } + case -836112788: + case 1898767863: { + if (input.isAtField(FieldNames.rogueStatus)) { + if (!input.trySkipNullValue()) { + final RogueStatusOuterClass.RogueStatus value = input.readEnum(RogueStatusOuterClass.RogueStatus.converter()); + if (value != null) { + rogueStatus = value.getNumber(); + bitField0_ |= 0x00000010; + } else { + input.skipUnknownEnumValue(); + } + } + } else { + input.skipUnknownField(); + } + break; + } + case -522199218: + case 1351172268: { + if (input.isAtField(FieldNames.isRewardTaken)) { + if (!input.trySkipNullValue()) { + isRewardTaken = input.readBool(); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public RogueArea clone() { + return new RogueArea().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static RogueArea parseFrom(final byte[] data) throws InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new RogueArea(), data).checkInitialized(); + } + + public static RogueArea parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueArea(), input).checkInitialized(); + } + + public static RogueArea parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueArea(), input).checkInitialized(); + } + + /** + * @return factory for creating RogueArea messages + */ + public static MessageFactory getFactory() { + return RogueAreaFactory.INSTANCE; + } + + private enum RogueAreaFactory implements MessageFactory { + INSTANCE; + + @Override + public RogueArea create() { + return RogueArea.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName areaId = FieldName.forField("areaId", "area_id"); + + static final FieldName curReachRoomNum = FieldName.forField("curReachRoomNum", "cur_reach_room_num"); + + static final FieldName mapId = FieldName.forField("mapId", "map_id"); + + static final FieldName rogueAreaStatus = FieldName.forField("rogueAreaStatus", "rogue_area_status"); + + static final FieldName rogueStatus = FieldName.forField("rogueStatus", "rogue_status"); + + static final FieldName isRewardTaken = FieldName.forField("isRewardTaken", "is_reward_taken"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/RogueAreaStatusOuterClass.java b/src/generated/main/emu/lunarcore/proto/RogueAreaStatusOuterClass.java new file mode 100644 index 0000000..58bf4aa --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/RogueAreaStatusOuterClass.java @@ -0,0 +1,154 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import us.hebi.quickbuf.ProtoEnum; +import us.hebi.quickbuf.ProtoUtil; + +public final class RogueAreaStatusOuterClass { + /** + * Protobuf enum {@code RogueAreaStatus} + */ + public enum RogueAreaStatus implements ProtoEnum { + /** + * ROGUE_AREA_STATUS_LOCK = 0; + */ + ROGUE_AREA_STATUS_LOCK("ROGUE_AREA_STATUS_LOCK", 0), + + /** + * ROGUE_AREA_STATUS_UNLOCK = 1; + */ + ROGUE_AREA_STATUS_UNLOCK("ROGUE_AREA_STATUS_UNLOCK", 1), + + /** + * ROGUE_AREA_STATUS_FIRST_PASS = 2; + */ + ROGUE_AREA_STATUS_FIRST_PASS("ROGUE_AREA_STATUS_FIRST_PASS", 2), + + /** + * ROGUE_AREA_STATUS_CLOSE = 3; + */ + ROGUE_AREA_STATUS_CLOSE("ROGUE_AREA_STATUS_CLOSE", 3); + + /** + * ROGUE_AREA_STATUS_LOCK = 0; + */ + public static final int ROGUE_AREA_STATUS_LOCK_VALUE = 0; + + /** + * ROGUE_AREA_STATUS_UNLOCK = 1; + */ + public static final int ROGUE_AREA_STATUS_UNLOCK_VALUE = 1; + + /** + * ROGUE_AREA_STATUS_FIRST_PASS = 2; + */ + public static final int ROGUE_AREA_STATUS_FIRST_PASS_VALUE = 2; + + /** + * ROGUE_AREA_STATUS_CLOSE = 3; + */ + public static final int ROGUE_AREA_STATUS_CLOSE_VALUE = 3; + + private final String name; + + private final int number; + + private RogueAreaStatus(String name, int number) { + this.name = name; + this.number = number; + } + + /** + * @return the string representation of enum entry + */ + @Override + public String getName() { + return name; + } + + /** + * @return the numeric wire value of this enum entry + */ + @Override + public int getNumber() { + return number; + } + + /** + * @return a converter that maps between this enum's numeric and text representations + */ + public static ProtoEnum.EnumConverter converter() { + return RogueAreaStatusConverter.INSTANCE; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value, or null if unknown. + */ + public static RogueAreaStatus forNumber(int value) { + return RogueAreaStatusConverter.INSTANCE.forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @param other Fallback value in case the value is not known. + * @return The enum associated with the given numeric wire value, or the fallback value if unknown. + */ + public static RogueAreaStatus forNumberOr(int number, RogueAreaStatus other) { + RogueAreaStatus value = forNumber(number); + return value == null ? other : value; + } + + enum RogueAreaStatusConverter implements ProtoEnum.EnumConverter { + INSTANCE; + + private static final RogueAreaStatus[] lookup = new RogueAreaStatus[4]; + + static { + lookup[0] = ROGUE_AREA_STATUS_LOCK; + lookup[1] = ROGUE_AREA_STATUS_UNLOCK; + lookup[2] = ROGUE_AREA_STATUS_FIRST_PASS; + lookup[3] = ROGUE_AREA_STATUS_CLOSE; + } + + @Override + public final RogueAreaStatus forNumber(final int value) { + if (value >= 0 && value < lookup.length) { + return lookup[value]; + } + return null; + } + + @Override + public final RogueAreaStatus forName(final CharSequence value) { + switch (value.length()) { + case 22: { + if (ProtoUtil.isEqual("ROGUE_AREA_STATUS_LOCK", value)) { + return ROGUE_AREA_STATUS_LOCK; + } + break; + } + case 23: { + if (ProtoUtil.isEqual("ROGUE_AREA_STATUS_CLOSE", value)) { + return ROGUE_AREA_STATUS_CLOSE; + } + break; + } + case 24: { + if (ProtoUtil.isEqual("ROGUE_AREA_STATUS_UNLOCK", value)) { + return ROGUE_AREA_STATUS_UNLOCK; + } + break; + } + case 28: { + if (ProtoUtil.isEqual("ROGUE_AREA_STATUS_FIRST_PASS", value)) { + return ROGUE_AREA_STATUS_FIRST_PASS; + } + break; + } + } + return null; + } + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/RogueHandbookDataOuterClass.java b/src/generated/main/emu/lunarcore/proto/RogueHandbookDataOuterClass.java new file mode 100644 index 0000000..f0647fe --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/RogueHandbookDataOuterClass.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 RogueHandbookDataOuterClass { + /** + * Protobuf type {@code RogueHandbookData} + */ + public static final class RogueHandbookData extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 rogue_current_version = 6; + */ + private int rogueCurrentVersion; + + /** + * optional bool is_miracle_unlock = 12; + */ + private boolean isMiracleUnlock; + + private RogueHandbookData() { + } + + /** + * @return a new empty instance of {@code RogueHandbookData} + */ + public static RogueHandbookData newInstance() { + return new RogueHandbookData(); + } + + /** + * optional uint32 rogue_current_version = 6; + * @return whether the rogueCurrentVersion field is set + */ + public boolean hasRogueCurrentVersion() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 rogue_current_version = 6; + * @return this + */ + public RogueHandbookData clearRogueCurrentVersion() { + bitField0_ &= ~0x00000001; + rogueCurrentVersion = 0; + return this; + } + + /** + * optional uint32 rogue_current_version = 6; + * @return the rogueCurrentVersion + */ + public int getRogueCurrentVersion() { + return rogueCurrentVersion; + } + + /** + * optional uint32 rogue_current_version = 6; + * @param value the rogueCurrentVersion to set + * @return this + */ + public RogueHandbookData setRogueCurrentVersion(final int value) { + bitField0_ |= 0x00000001; + rogueCurrentVersion = value; + return this; + } + + /** + * optional bool is_miracle_unlock = 12; + * @return whether the isMiracleUnlock field is set + */ + public boolean hasIsMiracleUnlock() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional bool is_miracle_unlock = 12; + * @return this + */ + public RogueHandbookData clearIsMiracleUnlock() { + bitField0_ &= ~0x00000002; + isMiracleUnlock = false; + return this; + } + + /** + * optional bool is_miracle_unlock = 12; + * @return the isMiracleUnlock + */ + public boolean getIsMiracleUnlock() { + return isMiracleUnlock; + } + + /** + * optional bool is_miracle_unlock = 12; + * @param value the isMiracleUnlock to set + * @return this + */ + public RogueHandbookData setIsMiracleUnlock(final boolean value) { + bitField0_ |= 0x00000002; + isMiracleUnlock = value; + return this; + } + + @Override + public RogueHandbookData copyFrom(final RogueHandbookData other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + rogueCurrentVersion = other.rogueCurrentVersion; + isMiracleUnlock = other.isMiracleUnlock; + } + return this; + } + + @Override + public RogueHandbookData mergeFrom(final RogueHandbookData other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRogueCurrentVersion()) { + setRogueCurrentVersion(other.rogueCurrentVersion); + } + if (other.hasIsMiracleUnlock()) { + setIsMiracleUnlock(other.isMiracleUnlock); + } + return this; + } + + @Override + public RogueHandbookData clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + rogueCurrentVersion = 0; + isMiracleUnlock = false; + return this; + } + + @Override + public RogueHandbookData 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 RogueHandbookData)) { + return false; + } + RogueHandbookData other = (RogueHandbookData) o; + return bitField0_ == other.bitField0_ + && (!hasRogueCurrentVersion() || rogueCurrentVersion == other.rogueCurrentVersion) + && (!hasIsMiracleUnlock() || isMiracleUnlock == other.isMiracleUnlock); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 48); + output.writeUInt32NoTag(rogueCurrentVersion); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 96); + output.writeBoolNoTag(isMiracleUnlock); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(rogueCurrentVersion); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 2; + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public RogueHandbookData mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 48: { + // rogueCurrentVersion + rogueCurrentVersion = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 96) { + break; + } + } + case 96: { + // isMiracleUnlock + isMiracleUnlock = 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.rogueCurrentVersion, rogueCurrentVersion); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeBool(FieldNames.isMiracleUnlock, isMiracleUnlock); + } + output.endObject(); + } + + @Override + public RogueHandbookData mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1261212057: + case 1302648749: { + if (input.isAtField(FieldNames.rogueCurrentVersion)) { + if (!input.trySkipNullValue()) { + rogueCurrentVersion = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1272353269: + case 167980679: { + if (input.isAtField(FieldNames.isMiracleUnlock)) { + if (!input.trySkipNullValue()) { + isMiracleUnlock = input.readBool(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public RogueHandbookData clone() { + return new RogueHandbookData().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static RogueHandbookData parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new RogueHandbookData(), data).checkInitialized(); + } + + public static RogueHandbookData parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueHandbookData(), input).checkInitialized(); + } + + public static RogueHandbookData parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueHandbookData(), input).checkInitialized(); + } + + /** + * @return factory for creating RogueHandbookData messages + */ + public static MessageFactory getFactory() { + return RogueHandbookDataFactory.INSTANCE; + } + + private enum RogueHandbookDataFactory implements MessageFactory { + INSTANCE; + + @Override + public RogueHandbookData create() { + return RogueHandbookData.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName rogueCurrentVersion = FieldName.forField("rogueCurrentVersion", "rogue_current_version"); + + static final FieldName isMiracleUnlock = FieldName.forField("isMiracleUnlock", "is_miracle_unlock"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/RogueInfoDataOuterClass.java b/src/generated/main/emu/lunarcore/proto/RogueInfoDataOuterClass.java new file mode 100644 index 0000000..61250f4 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/RogueInfoDataOuterClass.java @@ -0,0 +1,383 @@ +// 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 RogueInfoDataOuterClass { + /** + * Protobuf type {@code RogueInfoData} + */ + public static final class RogueInfoData extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional .RogueSeasonInfo rogue_season_info = 3; + */ + private final RogueSeasonInfoOuterClass.RogueSeasonInfo rogueSeasonInfo = RogueSeasonInfoOuterClass.RogueSeasonInfo.newInstance(); + + /** + * optional .RogueScoreRewardInfo rogue_score_info = 6; + */ + private final RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo rogueScoreInfo = RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo.newInstance(); + + private RogueInfoData() { + } + + /** + * @return a new empty instance of {@code RogueInfoData} + */ + public static RogueInfoData newInstance() { + return new RogueInfoData(); + } + + /** + * optional .RogueSeasonInfo rogue_season_info = 3; + * @return whether the rogueSeasonInfo field is set + */ + public boolean hasRogueSeasonInfo() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional .RogueSeasonInfo rogue_season_info = 3; + * @return this + */ + public RogueInfoData clearRogueSeasonInfo() { + bitField0_ &= ~0x00000001; + rogueSeasonInfo.clear(); + return this; + } + + /** + * optional .RogueSeasonInfo rogue_season_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 #getMutableRogueSeasonInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RogueSeasonInfoOuterClass.RogueSeasonInfo getRogueSeasonInfo() { + return rogueSeasonInfo; + } + + /** + * optional .RogueSeasonInfo rogue_season_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 RogueSeasonInfoOuterClass.RogueSeasonInfo getMutableRogueSeasonInfo() { + bitField0_ |= 0x00000001; + return rogueSeasonInfo; + } + + /** + * optional .RogueSeasonInfo rogue_season_info = 3; + * @param value the rogueSeasonInfo to set + * @return this + */ + public RogueInfoData setRogueSeasonInfo(final RogueSeasonInfoOuterClass.RogueSeasonInfo value) { + bitField0_ |= 0x00000001; + rogueSeasonInfo.copyFrom(value); + return this; + } + + /** + * optional .RogueScoreRewardInfo rogue_score_info = 6; + * @return whether the rogueScoreInfo field is set + */ + public boolean hasRogueScoreInfo() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional .RogueScoreRewardInfo rogue_score_info = 6; + * @return this + */ + public RogueInfoData clearRogueScoreInfo() { + bitField0_ &= ~0x00000002; + rogueScoreInfo.clear(); + return this; + } + + /** + * optional .RogueScoreRewardInfo rogue_score_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 #getMutableRogueScoreInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo getRogueScoreInfo() { + return rogueScoreInfo; + } + + /** + * optional .RogueScoreRewardInfo rogue_score_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 RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo getMutableRogueScoreInfo() { + bitField0_ |= 0x00000002; + return rogueScoreInfo; + } + + /** + * optional .RogueScoreRewardInfo rogue_score_info = 6; + * @param value the rogueScoreInfo to set + * @return this + */ + public RogueInfoData setRogueScoreInfo( + final RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo value) { + bitField0_ |= 0x00000002; + rogueScoreInfo.copyFrom(value); + return this; + } + + @Override + public RogueInfoData copyFrom(final RogueInfoData other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + rogueSeasonInfo.copyFrom(other.rogueSeasonInfo); + rogueScoreInfo.copyFrom(other.rogueScoreInfo); + } + return this; + } + + @Override + public RogueInfoData mergeFrom(final RogueInfoData other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRogueSeasonInfo()) { + getMutableRogueSeasonInfo().mergeFrom(other.rogueSeasonInfo); + } + if (other.hasRogueScoreInfo()) { + getMutableRogueScoreInfo().mergeFrom(other.rogueScoreInfo); + } + return this; + } + + @Override + public RogueInfoData clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + rogueSeasonInfo.clear(); + rogueScoreInfo.clear(); + return this; + } + + @Override + public RogueInfoData clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + rogueSeasonInfo.clearQuick(); + rogueScoreInfo.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof RogueInfoData)) { + return false; + } + RogueInfoData other = (RogueInfoData) o; + return bitField0_ == other.bitField0_ + && (!hasRogueSeasonInfo() || rogueSeasonInfo.equals(other.rogueSeasonInfo)) + && (!hasRogueScoreInfo() || rogueScoreInfo.equals(other.rogueScoreInfo)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 26); + output.writeMessageNoTag(rogueSeasonInfo); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 50); + output.writeMessageNoTag(rogueScoreInfo); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(rogueSeasonInfo); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(rogueScoreInfo); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public RogueInfoData mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 26: { + // rogueSeasonInfo + input.readMessage(rogueSeasonInfo); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 50) { + break; + } + } + case 50: { + // rogueScoreInfo + input.readMessage(rogueScoreInfo); + 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.rogueSeasonInfo, rogueSeasonInfo); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeMessage(FieldNames.rogueScoreInfo, rogueScoreInfo); + } + output.endObject(); + } + + @Override + public RogueInfoData mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1037341781: + case -588845659: { + if (input.isAtField(FieldNames.rogueSeasonInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(rogueSeasonInfo); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2078217638: + case -208816704: { + if (input.isAtField(FieldNames.rogueScoreInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(rogueScoreInfo); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public RogueInfoData clone() { + return new RogueInfoData().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static RogueInfoData parseFrom(final byte[] data) throws InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new RogueInfoData(), data).checkInitialized(); + } + + public static RogueInfoData parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueInfoData(), input).checkInitialized(); + } + + public static RogueInfoData parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueInfoData(), input).checkInitialized(); + } + + /** + * @return factory for creating RogueInfoData messages + */ + public static MessageFactory getFactory() { + return RogueInfoDataFactory.INSTANCE; + } + + private enum RogueInfoDataFactory implements MessageFactory { + INSTANCE; + + @Override + public RogueInfoData create() { + return RogueInfoData.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName rogueSeasonInfo = FieldName.forField("rogueSeasonInfo", "rogue_season_info"); + + static final FieldName rogueScoreInfo = FieldName.forField("rogueScoreInfo", "rogue_score_info"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/RogueInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/RogueInfoOuterClass.java new file mode 100644 index 0000000..f242441 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/RogueInfoOuterClass.java @@ -0,0 +1,1216 @@ +// 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 RogueInfoOuterClass { + /** + * Protobuf type {@code RogueInfo} + */ + public static final class RogueInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional int64 end_time = 2; + */ + private long endTime; + + /** + * optional int64 begin_time = 14; + */ + private long beginTime; + + /** + * optional uint32 KMAGFHIIALA = 1; + */ + private int kMAGFHIIALA; + + /** + * optional uint32 rogue_season_id = 7; + */ + private int rogueSeasonId; + + /** + * optional uint32 HNIJEKJEGHB = 486; + */ + private int hNIJEKJEGHB; + + /** + * optional uint32 HDBPIDMBJOH = 944; + */ + private int hDBPIDMBJOH; + + /** + * optional .RogueStatus status = 11; + */ + private int status; + + /** + * optional .RogueInfoData rogue_data = 256; + */ + private final RogueInfoDataOuterClass.RogueInfoData rogueData = RogueInfoDataOuterClass.RogueInfoData.newInstance(); + + /** + * optional .RogueScoreRewardInfo rogue_score_info = 1300; + */ + private final RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo rogueScoreInfo = RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo.newInstance(); + + /** + * repeated uint32 base_avatar_id_list = 12; + */ + private final RepeatedInt baseAvatarIdList = RepeatedInt.newEmptyInstance(); + + /** + * repeated .RogueArea rogue_area_list = 239; + */ + private final RepeatedMessage rogueAreaList = RepeatedMessage.newEmptyInstance(RogueAreaOuterClass.RogueArea.getFactory()); + + private RogueInfo() { + } + + /** + * @return a new empty instance of {@code RogueInfo} + */ + public static RogueInfo newInstance() { + return new RogueInfo(); + } + + /** + * optional int64 end_time = 2; + * @return whether the endTime field is set + */ + public boolean hasEndTime() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional int64 end_time = 2; + * @return this + */ + public RogueInfo clearEndTime() { + bitField0_ &= ~0x00000001; + endTime = 0L; + return this; + } + + /** + * optional int64 end_time = 2; + * @return the endTime + */ + public long getEndTime() { + return endTime; + } + + /** + * optional int64 end_time = 2; + * @param value the endTime to set + * @return this + */ + public RogueInfo setEndTime(final long value) { + bitField0_ |= 0x00000001; + endTime = value; + return this; + } + + /** + * optional int64 begin_time = 14; + * @return whether the beginTime field is set + */ + public boolean hasBeginTime() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional int64 begin_time = 14; + * @return this + */ + public RogueInfo clearBeginTime() { + bitField0_ &= ~0x00000002; + beginTime = 0L; + return this; + } + + /** + * optional int64 begin_time = 14; + * @return the beginTime + */ + public long getBeginTime() { + return beginTime; + } + + /** + * optional int64 begin_time = 14; + * @param value the beginTime to set + * @return this + */ + public RogueInfo setBeginTime(final long value) { + bitField0_ |= 0x00000002; + beginTime = value; + return this; + } + + /** + * optional uint32 KMAGFHIIALA = 1; + * @return whether the kMAGFHIIALA field is set + */ + public boolean hasKMAGFHIIALA() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 KMAGFHIIALA = 1; + * @return this + */ + public RogueInfo clearKMAGFHIIALA() { + bitField0_ &= ~0x00000004; + kMAGFHIIALA = 0; + return this; + } + + /** + * optional uint32 KMAGFHIIALA = 1; + * @return the kMAGFHIIALA + */ + public int getKMAGFHIIALA() { + return kMAGFHIIALA; + } + + /** + * optional uint32 KMAGFHIIALA = 1; + * @param value the kMAGFHIIALA to set + * @return this + */ + public RogueInfo setKMAGFHIIALA(final int value) { + bitField0_ |= 0x00000004; + kMAGFHIIALA = value; + return this; + } + + /** + * optional uint32 rogue_season_id = 7; + * @return whether the rogueSeasonId field is set + */ + public boolean hasRogueSeasonId() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional uint32 rogue_season_id = 7; + * @return this + */ + public RogueInfo clearRogueSeasonId() { + bitField0_ &= ~0x00000008; + rogueSeasonId = 0; + return this; + } + + /** + * optional uint32 rogue_season_id = 7; + * @return the rogueSeasonId + */ + public int getRogueSeasonId() { + return rogueSeasonId; + } + + /** + * optional uint32 rogue_season_id = 7; + * @param value the rogueSeasonId to set + * @return this + */ + public RogueInfo setRogueSeasonId(final int value) { + bitField0_ |= 0x00000008; + rogueSeasonId = value; + return this; + } + + /** + * optional uint32 HNIJEKJEGHB = 486; + * @return whether the hNIJEKJEGHB field is set + */ + public boolean hasHNIJEKJEGHB() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * optional uint32 HNIJEKJEGHB = 486; + * @return this + */ + public RogueInfo clearHNIJEKJEGHB() { + bitField0_ &= ~0x00000010; + hNIJEKJEGHB = 0; + return this; + } + + /** + * optional uint32 HNIJEKJEGHB = 486; + * @return the hNIJEKJEGHB + */ + public int getHNIJEKJEGHB() { + return hNIJEKJEGHB; + } + + /** + * optional uint32 HNIJEKJEGHB = 486; + * @param value the hNIJEKJEGHB to set + * @return this + */ + public RogueInfo setHNIJEKJEGHB(final int value) { + bitField0_ |= 0x00000010; + hNIJEKJEGHB = value; + return this; + } + + /** + * optional uint32 HDBPIDMBJOH = 944; + * @return whether the hDBPIDMBJOH field is set + */ + public boolean hasHDBPIDMBJOH() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * optional uint32 HDBPIDMBJOH = 944; + * @return this + */ + public RogueInfo clearHDBPIDMBJOH() { + bitField0_ &= ~0x00000020; + hDBPIDMBJOH = 0; + return this; + } + + /** + * optional uint32 HDBPIDMBJOH = 944; + * @return the hDBPIDMBJOH + */ + public int getHDBPIDMBJOH() { + return hDBPIDMBJOH; + } + + /** + * optional uint32 HDBPIDMBJOH = 944; + * @param value the hDBPIDMBJOH to set + * @return this + */ + public RogueInfo setHDBPIDMBJOH(final int value) { + bitField0_ |= 0x00000020; + hDBPIDMBJOH = value; + return this; + } + + /** + * optional .RogueStatus status = 11; + * @return whether the status field is set + */ + public boolean hasStatus() { + return (bitField0_ & 0x00000040) != 0; + } + + /** + * optional .RogueStatus status = 11; + * @return this + */ + public RogueInfo clearStatus() { + bitField0_ &= ~0x00000040; + status = 0; + return this; + } + + /** + * optional .RogueStatus status = 11; + * @return the status + */ + public RogueStatusOuterClass.RogueStatus getStatus() { + return RogueStatusOuterClass.RogueStatus.forNumber(status); + } + + /** + * Gets the value of the internal enum store. The result is + * equivalent to {@link RogueInfo#getStatus()}.getNumber(). + * + * @return numeric wire representation + */ + public int getStatusValue() { + return status; + } + + /** + * Sets the value of the internal enum store. This does not + * do any validity checks, so be sure to use appropriate value + * constants from {@link RogueStatusOuterClass.RogueStatus}. Setting an invalid value + * can cause {@link RogueInfo#getStatus()} to return null + * + * @param value the numeric wire value to set + * @return this + */ + public RogueInfo setStatusValue(final int value) { + bitField0_ |= 0x00000040; + status = value; + return this; + } + + /** + * optional .RogueStatus status = 11; + * @param value the status to set + * @return this + */ + public RogueInfo setStatus(final RogueStatusOuterClass.RogueStatus value) { + bitField0_ |= 0x00000040; + status = value.getNumber(); + return this; + } + + /** + * optional .RogueInfoData rogue_data = 256; + * @return whether the rogueData field is set + */ + public boolean hasRogueData() { + return (bitField0_ & 0x00000080) != 0; + } + + /** + * optional .RogueInfoData rogue_data = 256; + * @return this + */ + public RogueInfo clearRogueData() { + bitField0_ &= ~0x00000080; + rogueData.clear(); + return this; + } + + /** + * optional .RogueInfoData rogue_data = 256; + * + * 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 #getMutableRogueData()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RogueInfoDataOuterClass.RogueInfoData getRogueData() { + return rogueData; + } + + /** + * optional .RogueInfoData rogue_data = 256; + * + * 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 RogueInfoDataOuterClass.RogueInfoData getMutableRogueData() { + bitField0_ |= 0x00000080; + return rogueData; + } + + /** + * optional .RogueInfoData rogue_data = 256; + * @param value the rogueData to set + * @return this + */ + public RogueInfo setRogueData(final RogueInfoDataOuterClass.RogueInfoData value) { + bitField0_ |= 0x00000080; + rogueData.copyFrom(value); + return this; + } + + /** + * optional .RogueScoreRewardInfo rogue_score_info = 1300; + * @return whether the rogueScoreInfo field is set + */ + public boolean hasRogueScoreInfo() { + return (bitField0_ & 0x00000100) != 0; + } + + /** + * optional .RogueScoreRewardInfo rogue_score_info = 1300; + * @return this + */ + public RogueInfo clearRogueScoreInfo() { + bitField0_ &= ~0x00000100; + rogueScoreInfo.clear(); + return this; + } + + /** + * optional .RogueScoreRewardInfo rogue_score_info = 1300; + * + * 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 #getMutableRogueScoreInfo()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo getRogueScoreInfo() { + return rogueScoreInfo; + } + + /** + * optional .RogueScoreRewardInfo rogue_score_info = 1300; + * + * 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 RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo getMutableRogueScoreInfo() { + bitField0_ |= 0x00000100; + return rogueScoreInfo; + } + + /** + * optional .RogueScoreRewardInfo rogue_score_info = 1300; + * @param value the rogueScoreInfo to set + * @return this + */ + public RogueInfo setRogueScoreInfo( + final RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo value) { + bitField0_ |= 0x00000100; + rogueScoreInfo.copyFrom(value); + return this; + } + + /** + * repeated uint32 base_avatar_id_list = 12; + * @return whether the baseAvatarIdList field is set + */ + public boolean hasBaseAvatarIdList() { + return (bitField0_ & 0x00000200) != 0; + } + + /** + * repeated uint32 base_avatar_id_list = 12; + * @return this + */ + public RogueInfo clearBaseAvatarIdList() { + bitField0_ &= ~0x00000200; + baseAvatarIdList.clear(); + return this; + } + + /** + * repeated uint32 base_avatar_id_list = 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 #getMutableBaseAvatarIdList()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getBaseAvatarIdList() { + return baseAvatarIdList; + } + + /** + * repeated uint32 base_avatar_id_list = 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 RepeatedInt getMutableBaseAvatarIdList() { + bitField0_ |= 0x00000200; + return baseAvatarIdList; + } + + /** + * repeated uint32 base_avatar_id_list = 12; + * @param value the baseAvatarIdList to add + * @return this + */ + public RogueInfo addBaseAvatarIdList(final int value) { + bitField0_ |= 0x00000200; + baseAvatarIdList.add(value); + return this; + } + + /** + * repeated uint32 base_avatar_id_list = 12; + * @param values the baseAvatarIdList to add + * @return this + */ + public RogueInfo addAllBaseAvatarIdList(final int... values) { + bitField0_ |= 0x00000200; + baseAvatarIdList.addAll(values); + return this; + } + + /** + * repeated .RogueArea rogue_area_list = 239; + * @return whether the rogueAreaList field is set + */ + public boolean hasRogueAreaList() { + return (bitField0_ & 0x00000400) != 0; + } + + /** + * repeated .RogueArea rogue_area_list = 239; + * @return this + */ + public RogueInfo clearRogueAreaList() { + bitField0_ &= ~0x00000400; + rogueAreaList.clear(); + return this; + } + + /** + * repeated .RogueArea rogue_area_list = 239; + * + * 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 #getMutableRogueAreaList()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getRogueAreaList() { + return rogueAreaList; + } + + /** + * repeated .RogueArea rogue_area_list = 239; + * + * 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 getMutableRogueAreaList() { + bitField0_ |= 0x00000400; + return rogueAreaList; + } + + /** + * repeated .RogueArea rogue_area_list = 239; + * @param value the rogueAreaList to add + * @return this + */ + public RogueInfo addRogueAreaList(final RogueAreaOuterClass.RogueArea value) { + bitField0_ |= 0x00000400; + rogueAreaList.add(value); + return this; + } + + /** + * repeated .RogueArea rogue_area_list = 239; + * @param values the rogueAreaList to add + * @return this + */ + public RogueInfo addAllRogueAreaList(final RogueAreaOuterClass.RogueArea... values) { + bitField0_ |= 0x00000400; + rogueAreaList.addAll(values); + return this; + } + + @Override + public RogueInfo copyFrom(final RogueInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + endTime = other.endTime; + beginTime = other.beginTime; + kMAGFHIIALA = other.kMAGFHIIALA; + rogueSeasonId = other.rogueSeasonId; + hNIJEKJEGHB = other.hNIJEKJEGHB; + hDBPIDMBJOH = other.hDBPIDMBJOH; + status = other.status; + rogueData.copyFrom(other.rogueData); + rogueScoreInfo.copyFrom(other.rogueScoreInfo); + baseAvatarIdList.copyFrom(other.baseAvatarIdList); + rogueAreaList.copyFrom(other.rogueAreaList); + } + return this; + } + + @Override + public RogueInfo mergeFrom(final RogueInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasEndTime()) { + setEndTime(other.endTime); + } + if (other.hasBeginTime()) { + setBeginTime(other.beginTime); + } + if (other.hasKMAGFHIIALA()) { + setKMAGFHIIALA(other.kMAGFHIIALA); + } + if (other.hasRogueSeasonId()) { + setRogueSeasonId(other.rogueSeasonId); + } + if (other.hasHNIJEKJEGHB()) { + setHNIJEKJEGHB(other.hNIJEKJEGHB); + } + if (other.hasHDBPIDMBJOH()) { + setHDBPIDMBJOH(other.hDBPIDMBJOH); + } + if (other.hasStatus()) { + setStatusValue(other.status); + } + if (other.hasRogueData()) { + getMutableRogueData().mergeFrom(other.rogueData); + } + if (other.hasRogueScoreInfo()) { + getMutableRogueScoreInfo().mergeFrom(other.rogueScoreInfo); + } + if (other.hasBaseAvatarIdList()) { + getMutableBaseAvatarIdList().addAll(other.baseAvatarIdList); + } + if (other.hasRogueAreaList()) { + getMutableRogueAreaList().addAll(other.rogueAreaList); + } + return this; + } + + @Override + public RogueInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + endTime = 0L; + beginTime = 0L; + kMAGFHIIALA = 0; + rogueSeasonId = 0; + hNIJEKJEGHB = 0; + hDBPIDMBJOH = 0; + status = 0; + rogueData.clear(); + rogueScoreInfo.clear(); + baseAvatarIdList.clear(); + rogueAreaList.clear(); + return this; + } + + @Override + public RogueInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + rogueData.clearQuick(); + rogueScoreInfo.clearQuick(); + baseAvatarIdList.clear(); + rogueAreaList.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof RogueInfo)) { + return false; + } + RogueInfo other = (RogueInfo) o; + return bitField0_ == other.bitField0_ + && (!hasEndTime() || endTime == other.endTime) + && (!hasBeginTime() || beginTime == other.beginTime) + && (!hasKMAGFHIIALA() || kMAGFHIIALA == other.kMAGFHIIALA) + && (!hasRogueSeasonId() || rogueSeasonId == other.rogueSeasonId) + && (!hasHNIJEKJEGHB() || hNIJEKJEGHB == other.hNIJEKJEGHB) + && (!hasHDBPIDMBJOH() || hDBPIDMBJOH == other.hDBPIDMBJOH) + && (!hasStatus() || status == other.status) + && (!hasRogueData() || rogueData.equals(other.rogueData)) + && (!hasRogueScoreInfo() || rogueScoreInfo.equals(other.rogueScoreInfo)) + && (!hasBaseAvatarIdList() || baseAvatarIdList.equals(other.baseAvatarIdList)) + && (!hasRogueAreaList() || rogueAreaList.equals(other.rogueAreaList)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 16); + output.writeInt64NoTag(endTime); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 112); + output.writeInt64NoTag(beginTime); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(kMAGFHIIALA); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 56); + output.writeUInt32NoTag(rogueSeasonId); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawLittleEndian16((short) 7856); + output.writeUInt32NoTag(hNIJEKJEGHB); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRawLittleEndian16((short) 15232); + output.writeUInt32NoTag(hDBPIDMBJOH); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeRawByte((byte) 88); + output.writeEnumNoTag(status); + } + if ((bitField0_ & 0x00000080) != 0) { + output.writeRawLittleEndian16((short) 4226); + output.writeMessageNoTag(rogueData); + } + if ((bitField0_ & 0x00000100) != 0) { + output.writeRawLittleEndian16((short) 20898); + output.writeMessageNoTag(rogueScoreInfo); + } + if ((bitField0_ & 0x00000200) != 0) { + for (int i = 0; i < baseAvatarIdList.length(); i++) { + output.writeRawByte((byte) 96); + output.writeUInt32NoTag(baseAvatarIdList.array()[i]); + } + } + if ((bitField0_ & 0x00000400) != 0) { + for (int i = 0; i < rogueAreaList.length(); i++) { + output.writeRawLittleEndian16((short) 3834); + output.writeMessageNoTag(rogueAreaList.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeInt64SizeNoTag(endTime); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeInt64SizeNoTag(beginTime); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(kMAGFHIIALA); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(rogueSeasonId); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 2 + ProtoSink.computeUInt32SizeNoTag(hNIJEKJEGHB); + } + if ((bitField0_ & 0x00000020) != 0) { + size += 2 + ProtoSink.computeUInt32SizeNoTag(hDBPIDMBJOH); + } + if ((bitField0_ & 0x00000040) != 0) { + size += 1 + ProtoSink.computeEnumSizeNoTag(status); + } + if ((bitField0_ & 0x00000080) != 0) { + size += 2 + ProtoSink.computeMessageSizeNoTag(rogueData); + } + if ((bitField0_ & 0x00000100) != 0) { + size += 2 + ProtoSink.computeMessageSizeNoTag(rogueScoreInfo); + } + if ((bitField0_ & 0x00000200) != 0) { + size += (1 * baseAvatarIdList.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(baseAvatarIdList); + } + if ((bitField0_ & 0x00000400) != 0) { + size += (2 * rogueAreaList.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(rogueAreaList); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public RogueInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 16: { + // endTime + endTime = input.readInt64(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 112) { + break; + } + } + case 112: { + // beginTime + beginTime = input.readInt64(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 8) { + break; + } + } + case 8: { + // kMAGFHIIALA + kMAGFHIIALA = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 56) { + break; + } + } + case 56: { + // rogueSeasonId + rogueSeasonId = input.readUInt32(); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 3888) { + break; + } + } + case 3888: { + // hNIJEKJEGHB + hNIJEKJEGHB = input.readUInt32(); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 7552) { + break; + } + } + case 7552: { + // hDBPIDMBJOH + hDBPIDMBJOH = input.readUInt32(); + bitField0_ |= 0x00000020; + tag = input.readTag(); + if (tag != 88) { + break; + } + } + case 88: { + // status + final int value = input.readInt32(); + if (RogueStatusOuterClass.RogueStatus.forNumber(value) != null) { + status = value; + bitField0_ |= 0x00000040; + } + tag = input.readTag(); + if (tag != 2050) { + break; + } + } + case 2050: { + // rogueData + input.readMessage(rogueData); + bitField0_ |= 0x00000080; + tag = input.readTag(); + if (tag != 10402) { + break; + } + } + case 10402: { + // rogueScoreInfo + input.readMessage(rogueScoreInfo); + bitField0_ |= 0x00000100; + tag = input.readTag(); + if (tag != 98) { + break; + } + } + case 98: { + // baseAvatarIdList [packed=true] + input.readPackedUInt32(baseAvatarIdList, tag); + bitField0_ |= 0x00000200; + tag = input.readTag(); + if (tag != 1914) { + break; + } + } + case 1914: { + // rogueAreaList + tag = input.readRepeatedMessage(rogueAreaList, tag); + bitField0_ |= 0x00000400; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + case 96: { + // baseAvatarIdList [packed=false] + tag = input.readRepeatedUInt32(baseAvatarIdList, tag); + bitField0_ |= 0x00000200; + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeInt64(FieldNames.endTime, endTime); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeInt64(FieldNames.beginTime, beginTime); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.kMAGFHIIALA, kMAGFHIIALA); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeUInt32(FieldNames.rogueSeasonId, rogueSeasonId); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeUInt32(FieldNames.hNIJEKJEGHB, hNIJEKJEGHB); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeUInt32(FieldNames.hDBPIDMBJOH, hDBPIDMBJOH); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeEnum(FieldNames.status, status, RogueStatusOuterClass.RogueStatus.converter()); + } + if ((bitField0_ & 0x00000080) != 0) { + output.writeMessage(FieldNames.rogueData, rogueData); + } + if ((bitField0_ & 0x00000100) != 0) { + output.writeMessage(FieldNames.rogueScoreInfo, rogueScoreInfo); + } + if ((bitField0_ & 0x00000200) != 0) { + output.writeRepeatedUInt32(FieldNames.baseAvatarIdList, baseAvatarIdList); + } + if ((bitField0_ & 0x00000400) != 0) { + output.writeRepeatedMessage(FieldNames.rogueAreaList, rogueAreaList); + } + output.endObject(); + } + + @Override + public RogueInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1607243192: + case 1725551537: { + if (input.isAtField(FieldNames.endTime)) { + if (!input.trySkipNullValue()) { + endTime = input.readInt64(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1072839914: + case 1112183971: { + if (input.isAtField(FieldNames.beginTime)) { + if (!input.trySkipNullValue()) { + beginTime = input.readInt64(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082273588: { + if (input.isAtField(FieldNames.kMAGFHIIALA)) { + if (!input.trySkipNullValue()) { + kMAGFHIIALA = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -774262952: + case 1067542482: { + if (input.isAtField(FieldNames.rogueSeasonId)) { + if (!input.trySkipNullValue()) { + rogueSeasonId = input.readUInt32(); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1669990649: { + if (input.isAtField(FieldNames.hNIJEKJEGHB)) { + if (!input.trySkipNullValue()) { + hNIJEKJEGHB = input.readUInt32(); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case 31692841: { + if (input.isAtField(FieldNames.hDBPIDMBJOH)) { + if (!input.trySkipNullValue()) { + hDBPIDMBJOH = input.readUInt32(); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } + case -892481550: { + if (input.isAtField(FieldNames.status)) { + if (!input.trySkipNullValue()) { + final RogueStatusOuterClass.RogueStatus value = input.readEnum(RogueStatusOuterClass.RogueStatus.converter()); + if (value != null) { + status = value.getNumber(); + bitField0_ |= 0x00000040; + } else { + input.skipUnknownEnumValue(); + } + } + } else { + input.skipUnknownField(); + } + break; + } + case 655647908: + case -1124744465: { + if (input.isAtField(FieldNames.rogueData)) { + if (!input.trySkipNullValue()) { + input.readMessage(rogueData); + bitField0_ |= 0x00000080; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2078217638: + case -208816704: { + if (input.isAtField(FieldNames.rogueScoreInfo)) { + if (!input.trySkipNullValue()) { + input.readMessage(rogueScoreInfo); + bitField0_ |= 0x00000100; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1212654461: + case 914628490: { + if (input.isAtField(FieldNames.baseAvatarIdList)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(baseAvatarIdList); + bitField0_ |= 0x00000200; + } + } else { + input.skipUnknownField(); + } + break; + } + case 964382405: + case -851420949: { + if (input.isAtField(FieldNames.rogueAreaList)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(rogueAreaList); + bitField0_ |= 0x00000400; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public RogueInfo clone() { + return new RogueInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static RogueInfo parseFrom(final byte[] data) throws InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new RogueInfo(), data).checkInitialized(); + } + + public static RogueInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueInfo(), input).checkInitialized(); + } + + public static RogueInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating RogueInfo messages + */ + public static MessageFactory getFactory() { + return RogueInfoFactory.INSTANCE; + } + + private enum RogueInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public RogueInfo create() { + return RogueInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName endTime = FieldName.forField("endTime", "end_time"); + + static final FieldName beginTime = FieldName.forField("beginTime", "begin_time"); + + static final FieldName kMAGFHIIALA = FieldName.forField("KMAGFHIIALA"); + + static final FieldName rogueSeasonId = FieldName.forField("rogueSeasonId", "rogue_season_id"); + + static final FieldName hNIJEKJEGHB = FieldName.forField("HNIJEKJEGHB"); + + static final FieldName hDBPIDMBJOH = FieldName.forField("HDBPIDMBJOH"); + + static final FieldName status = FieldName.forField("status"); + + static final FieldName rogueData = FieldName.forField("rogueData", "rogue_data"); + + static final FieldName rogueScoreInfo = FieldName.forField("rogueScoreInfo", "rogue_score_info"); + + static final FieldName baseAvatarIdList = FieldName.forField("baseAvatarIdList", "base_avatar_id_list"); + + static final FieldName rogueAreaList = FieldName.forField("rogueAreaList", "rogue_area_list"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/RogueScoreRewardInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/RogueScoreRewardInfoOuterClass.java new file mode 100644 index 0000000..95787e1 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/RogueScoreRewardInfoOuterClass.java @@ -0,0 +1,1104 @@ +// 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 RogueScoreRewardInfoOuterClass { + /** + * Protobuf type {@code RogueScoreRewardInfo} + */ + public static final class RogueScoreRewardInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 BPHINIPOKHA = 1; + */ + private int bPHINIPOKHA; + + /** + * optional uint32 GAPFCCDFKJG = 2; + */ + private int gAPFCCDFKJG; + + /** + * optional uint32 pool_id = 3; + */ + private int poolId; + + /** + * optional uint32 DOMMGENHGKE = 5; + */ + private int dOMMGENHGKE; + + /** + * optional uint32 score = 6; + */ + private int score; + + /** + * optional bool has_taken_initial_score = 8; + */ + private boolean hasTakenInitialScore; + + /** + * optional bool pool_refreshed = 13; + */ + private boolean poolRefreshed; + + /** + * repeated uint32 CGEIEELAOHD = 7; + */ + private final RepeatedInt cGEIEELAOHD = RepeatedInt.newEmptyInstance(); + + /** + * repeated uint32 taken_score_reward_list = 11; + */ + private final RepeatedInt takenScoreRewardList = RepeatedInt.newEmptyInstance(); + + /** + * repeated uint32 FOPNDDBAGPJ = 14; + */ + private final RepeatedInt fOPNDDBAGPJ = RepeatedInt.newEmptyInstance(); + + private RogueScoreRewardInfo() { + } + + /** + * @return a new empty instance of {@code RogueScoreRewardInfo} + */ + public static RogueScoreRewardInfo newInstance() { + return new RogueScoreRewardInfo(); + } + + /** + * optional uint32 BPHINIPOKHA = 1; + * @return whether the bPHINIPOKHA field is set + */ + public boolean hasBPHINIPOKHA() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 BPHINIPOKHA = 1; + * @return this + */ + public RogueScoreRewardInfo clearBPHINIPOKHA() { + bitField0_ &= ~0x00000001; + bPHINIPOKHA = 0; + return this; + } + + /** + * optional uint32 BPHINIPOKHA = 1; + * @return the bPHINIPOKHA + */ + public int getBPHINIPOKHA() { + return bPHINIPOKHA; + } + + /** + * optional uint32 BPHINIPOKHA = 1; + * @param value the bPHINIPOKHA to set + * @return this + */ + public RogueScoreRewardInfo setBPHINIPOKHA(final int value) { + bitField0_ |= 0x00000001; + bPHINIPOKHA = value; + return this; + } + + /** + * optional uint32 GAPFCCDFKJG = 2; + * @return whether the gAPFCCDFKJG field is set + */ + public boolean hasGAPFCCDFKJG() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 GAPFCCDFKJG = 2; + * @return this + */ + public RogueScoreRewardInfo clearGAPFCCDFKJG() { + bitField0_ &= ~0x00000002; + gAPFCCDFKJG = 0; + return this; + } + + /** + * optional uint32 GAPFCCDFKJG = 2; + * @return the gAPFCCDFKJG + */ + public int getGAPFCCDFKJG() { + return gAPFCCDFKJG; + } + + /** + * optional uint32 GAPFCCDFKJG = 2; + * @param value the gAPFCCDFKJG to set + * @return this + */ + public RogueScoreRewardInfo setGAPFCCDFKJG(final int value) { + bitField0_ |= 0x00000002; + gAPFCCDFKJG = value; + return this; + } + + /** + * optional uint32 pool_id = 3; + * @return whether the poolId field is set + */ + public boolean hasPoolId() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 pool_id = 3; + * @return this + */ + public RogueScoreRewardInfo clearPoolId() { + bitField0_ &= ~0x00000004; + poolId = 0; + return this; + } + + /** + * optional uint32 pool_id = 3; + * @return the poolId + */ + public int getPoolId() { + return poolId; + } + + /** + * optional uint32 pool_id = 3; + * @param value the poolId to set + * @return this + */ + public RogueScoreRewardInfo setPoolId(final int value) { + bitField0_ |= 0x00000004; + poolId = value; + return this; + } + + /** + * optional uint32 DOMMGENHGKE = 5; + * @return whether the dOMMGENHGKE field is set + */ + public boolean hasDOMMGENHGKE() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional uint32 DOMMGENHGKE = 5; + * @return this + */ + public RogueScoreRewardInfo clearDOMMGENHGKE() { + bitField0_ &= ~0x00000008; + dOMMGENHGKE = 0; + return this; + } + + /** + * optional uint32 DOMMGENHGKE = 5; + * @return the dOMMGENHGKE + */ + public int getDOMMGENHGKE() { + return dOMMGENHGKE; + } + + /** + * optional uint32 DOMMGENHGKE = 5; + * @param value the dOMMGENHGKE to set + * @return this + */ + public RogueScoreRewardInfo setDOMMGENHGKE(final int value) { + bitField0_ |= 0x00000008; + dOMMGENHGKE = value; + return this; + } + + /** + * optional uint32 score = 6; + * @return whether the score field is set + */ + public boolean hasScore() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * optional uint32 score = 6; + * @return this + */ + public RogueScoreRewardInfo clearScore() { + bitField0_ &= ~0x00000010; + score = 0; + return this; + } + + /** + * optional uint32 score = 6; + * @return the score + */ + public int getScore() { + return score; + } + + /** + * optional uint32 score = 6; + * @param value the score to set + * @return this + */ + public RogueScoreRewardInfo setScore(final int value) { + bitField0_ |= 0x00000010; + score = value; + return this; + } + + /** + * optional bool has_taken_initial_score = 8; + * @return whether the hasTakenInitialScore field is set + */ + public boolean hasHasTakenInitialScore() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * optional bool has_taken_initial_score = 8; + * @return this + */ + public RogueScoreRewardInfo clearHasTakenInitialScore() { + bitField0_ &= ~0x00000020; + hasTakenInitialScore = false; + return this; + } + + /** + * optional bool has_taken_initial_score = 8; + * @return the hasTakenInitialScore + */ + public boolean getHasTakenInitialScore() { + return hasTakenInitialScore; + } + + /** + * optional bool has_taken_initial_score = 8; + * @param value the hasTakenInitialScore to set + * @return this + */ + public RogueScoreRewardInfo setHasTakenInitialScore(final boolean value) { + bitField0_ |= 0x00000020; + hasTakenInitialScore = value; + return this; + } + + /** + * optional bool pool_refreshed = 13; + * @return whether the poolRefreshed field is set + */ + public boolean hasPoolRefreshed() { + return (bitField0_ & 0x00000040) != 0; + } + + /** + * optional bool pool_refreshed = 13; + * @return this + */ + public RogueScoreRewardInfo clearPoolRefreshed() { + bitField0_ &= ~0x00000040; + poolRefreshed = false; + return this; + } + + /** + * optional bool pool_refreshed = 13; + * @return the poolRefreshed + */ + public boolean getPoolRefreshed() { + return poolRefreshed; + } + + /** + * optional bool pool_refreshed = 13; + * @param value the poolRefreshed to set + * @return this + */ + public RogueScoreRewardInfo setPoolRefreshed(final boolean value) { + bitField0_ |= 0x00000040; + poolRefreshed = value; + return this; + } + + /** + * repeated uint32 CGEIEELAOHD = 7; + * @return whether the cGEIEELAOHD field is set + */ + public boolean hasCGEIEELAOHD() { + return (bitField0_ & 0x00000080) != 0; + } + + /** + * repeated uint32 CGEIEELAOHD = 7; + * @return this + */ + public RogueScoreRewardInfo clearCGEIEELAOHD() { + bitField0_ &= ~0x00000080; + cGEIEELAOHD.clear(); + return this; + } + + /** + * repeated uint32 CGEIEELAOHD = 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 #getMutableCGEIEELAOHD()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getCGEIEELAOHD() { + return cGEIEELAOHD; + } + + /** + * repeated uint32 CGEIEELAOHD = 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 getMutableCGEIEELAOHD() { + bitField0_ |= 0x00000080; + return cGEIEELAOHD; + } + + /** + * repeated uint32 CGEIEELAOHD = 7; + * @param value the cGEIEELAOHD to add + * @return this + */ + public RogueScoreRewardInfo addCGEIEELAOHD(final int value) { + bitField0_ |= 0x00000080; + cGEIEELAOHD.add(value); + return this; + } + + /** + * repeated uint32 CGEIEELAOHD = 7; + * @param values the cGEIEELAOHD to add + * @return this + */ + public RogueScoreRewardInfo addAllCGEIEELAOHD(final int... values) { + bitField0_ |= 0x00000080; + cGEIEELAOHD.addAll(values); + return this; + } + + /** + * repeated uint32 taken_score_reward_list = 11; + * @return whether the takenScoreRewardList field is set + */ + public boolean hasTakenScoreRewardList() { + return (bitField0_ & 0x00000100) != 0; + } + + /** + * repeated uint32 taken_score_reward_list = 11; + * @return this + */ + public RogueScoreRewardInfo clearTakenScoreRewardList() { + bitField0_ &= ~0x00000100; + takenScoreRewardList.clear(); + return this; + } + + /** + * repeated uint32 taken_score_reward_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 #getMutableTakenScoreRewardList()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getTakenScoreRewardList() { + return takenScoreRewardList; + } + + /** + * repeated uint32 taken_score_reward_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 getMutableTakenScoreRewardList() { + bitField0_ |= 0x00000100; + return takenScoreRewardList; + } + + /** + * repeated uint32 taken_score_reward_list = 11; + * @param value the takenScoreRewardList to add + * @return this + */ + public RogueScoreRewardInfo addTakenScoreRewardList(final int value) { + bitField0_ |= 0x00000100; + takenScoreRewardList.add(value); + return this; + } + + /** + * repeated uint32 taken_score_reward_list = 11; + * @param values the takenScoreRewardList to add + * @return this + */ + public RogueScoreRewardInfo addAllTakenScoreRewardList(final int... values) { + bitField0_ |= 0x00000100; + takenScoreRewardList.addAll(values); + return this; + } + + /** + * repeated uint32 FOPNDDBAGPJ = 14; + * @return whether the fOPNDDBAGPJ field is set + */ + public boolean hasFOPNDDBAGPJ() { + return (bitField0_ & 0x00000200) != 0; + } + + /** + * repeated uint32 FOPNDDBAGPJ = 14; + * @return this + */ + public RogueScoreRewardInfo clearFOPNDDBAGPJ() { + bitField0_ &= ~0x00000200; + fOPNDDBAGPJ.clear(); + return this; + } + + /** + * repeated uint32 FOPNDDBAGPJ = 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 #getMutableFOPNDDBAGPJ()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getFOPNDDBAGPJ() { + return fOPNDDBAGPJ; + } + + /** + * repeated uint32 FOPNDDBAGPJ = 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 RepeatedInt getMutableFOPNDDBAGPJ() { + bitField0_ |= 0x00000200; + return fOPNDDBAGPJ; + } + + /** + * repeated uint32 FOPNDDBAGPJ = 14; + * @param value the fOPNDDBAGPJ to add + * @return this + */ + public RogueScoreRewardInfo addFOPNDDBAGPJ(final int value) { + bitField0_ |= 0x00000200; + fOPNDDBAGPJ.add(value); + return this; + } + + /** + * repeated uint32 FOPNDDBAGPJ = 14; + * @param values the fOPNDDBAGPJ to add + * @return this + */ + public RogueScoreRewardInfo addAllFOPNDDBAGPJ(final int... values) { + bitField0_ |= 0x00000200; + fOPNDDBAGPJ.addAll(values); + return this; + } + + @Override + public RogueScoreRewardInfo copyFrom(final RogueScoreRewardInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + bPHINIPOKHA = other.bPHINIPOKHA; + gAPFCCDFKJG = other.gAPFCCDFKJG; + poolId = other.poolId; + dOMMGENHGKE = other.dOMMGENHGKE; + score = other.score; + hasTakenInitialScore = other.hasTakenInitialScore; + poolRefreshed = other.poolRefreshed; + cGEIEELAOHD.copyFrom(other.cGEIEELAOHD); + takenScoreRewardList.copyFrom(other.takenScoreRewardList); + fOPNDDBAGPJ.copyFrom(other.fOPNDDBAGPJ); + } + return this; + } + + @Override + public RogueScoreRewardInfo mergeFrom(final RogueScoreRewardInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasBPHINIPOKHA()) { + setBPHINIPOKHA(other.bPHINIPOKHA); + } + if (other.hasGAPFCCDFKJG()) { + setGAPFCCDFKJG(other.gAPFCCDFKJG); + } + if (other.hasPoolId()) { + setPoolId(other.poolId); + } + if (other.hasDOMMGENHGKE()) { + setDOMMGENHGKE(other.dOMMGENHGKE); + } + if (other.hasScore()) { + setScore(other.score); + } + if (other.hasHasTakenInitialScore()) { + setHasTakenInitialScore(other.hasTakenInitialScore); + } + if (other.hasPoolRefreshed()) { + setPoolRefreshed(other.poolRefreshed); + } + if (other.hasCGEIEELAOHD()) { + getMutableCGEIEELAOHD().addAll(other.cGEIEELAOHD); + } + if (other.hasTakenScoreRewardList()) { + getMutableTakenScoreRewardList().addAll(other.takenScoreRewardList); + } + if (other.hasFOPNDDBAGPJ()) { + getMutableFOPNDDBAGPJ().addAll(other.fOPNDDBAGPJ); + } + return this; + } + + @Override + public RogueScoreRewardInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + bPHINIPOKHA = 0; + gAPFCCDFKJG = 0; + poolId = 0; + dOMMGENHGKE = 0; + score = 0; + hasTakenInitialScore = false; + poolRefreshed = false; + cGEIEELAOHD.clear(); + takenScoreRewardList.clear(); + fOPNDDBAGPJ.clear(); + return this; + } + + @Override + public RogueScoreRewardInfo clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + cGEIEELAOHD.clear(); + takenScoreRewardList.clear(); + fOPNDDBAGPJ.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof RogueScoreRewardInfo)) { + return false; + } + RogueScoreRewardInfo other = (RogueScoreRewardInfo) o; + return bitField0_ == other.bitField0_ + && (!hasBPHINIPOKHA() || bPHINIPOKHA == other.bPHINIPOKHA) + && (!hasGAPFCCDFKJG() || gAPFCCDFKJG == other.gAPFCCDFKJG) + && (!hasPoolId() || poolId == other.poolId) + && (!hasDOMMGENHGKE() || dOMMGENHGKE == other.dOMMGENHGKE) + && (!hasScore() || score == other.score) + && (!hasHasTakenInitialScore() || hasTakenInitialScore == other.hasTakenInitialScore) + && (!hasPoolRefreshed() || poolRefreshed == other.poolRefreshed) + && (!hasCGEIEELAOHD() || cGEIEELAOHD.equals(other.cGEIEELAOHD)) + && (!hasTakenScoreRewardList() || takenScoreRewardList.equals(other.takenScoreRewardList)) + && (!hasFOPNDDBAGPJ() || fOPNDDBAGPJ.equals(other.fOPNDDBAGPJ)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(bPHINIPOKHA); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(gAPFCCDFKJG); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(poolId); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 40); + output.writeUInt32NoTag(dOMMGENHGKE); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawByte((byte) 48); + output.writeUInt32NoTag(score); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRawByte((byte) 64); + output.writeBoolNoTag(hasTakenInitialScore); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeRawByte((byte) 104); + output.writeBoolNoTag(poolRefreshed); + } + if ((bitField0_ & 0x00000080) != 0) { + for (int i = 0; i < cGEIEELAOHD.length(); i++) { + output.writeRawByte((byte) 56); + output.writeUInt32NoTag(cGEIEELAOHD.array()[i]); + } + } + if ((bitField0_ & 0x00000100) != 0) { + for (int i = 0; i < takenScoreRewardList.length(); i++) { + output.writeRawByte((byte) 88); + output.writeUInt32NoTag(takenScoreRewardList.array()[i]); + } + } + if ((bitField0_ & 0x00000200) != 0) { + for (int i = 0; i < fOPNDDBAGPJ.length(); i++) { + output.writeRawByte((byte) 112); + output.writeUInt32NoTag(fOPNDDBAGPJ.array()[i]); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(bPHINIPOKHA); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(gAPFCCDFKJG); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(poolId); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(dOMMGENHGKE); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(score); + } + if ((bitField0_ & 0x00000020) != 0) { + size += 2; + } + if ((bitField0_ & 0x00000040) != 0) { + size += 2; + } + if ((bitField0_ & 0x00000080) != 0) { + size += (1 * cGEIEELAOHD.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(cGEIEELAOHD); + } + if ((bitField0_ & 0x00000100) != 0) { + size += (1 * takenScoreRewardList.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(takenScoreRewardList); + } + if ((bitField0_ & 0x00000200) != 0) { + size += (1 * fOPNDDBAGPJ.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(fOPNDDBAGPJ); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public RogueScoreRewardInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // bPHINIPOKHA + bPHINIPOKHA = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // gAPFCCDFKJG + gAPFCCDFKJG = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 24) { + break; + } + } + case 24: { + // poolId + poolId = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 40) { + break; + } + } + case 40: { + // dOMMGENHGKE + dOMMGENHGKE = input.readUInt32(); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 48) { + break; + } + } + case 48: { + // score + score = input.readUInt32(); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 64) { + break; + } + } + case 64: { + // hasTakenInitialScore + hasTakenInitialScore = input.readBool(); + bitField0_ |= 0x00000020; + tag = input.readTag(); + if (tag != 104) { + break; + } + } + case 104: { + // poolRefreshed + poolRefreshed = input.readBool(); + bitField0_ |= 0x00000040; + tag = input.readTag(); + if (tag != 58) { + break; + } + } + case 58: { + // cGEIEELAOHD [packed=true] + input.readPackedUInt32(cGEIEELAOHD, tag); + bitField0_ |= 0x00000080; + tag = input.readTag(); + if (tag != 90) { + break; + } + } + case 90: { + // takenScoreRewardList [packed=true] + input.readPackedUInt32(takenScoreRewardList, tag); + bitField0_ |= 0x00000100; + tag = input.readTag(); + if (tag != 114) { + break; + } + } + case 114: { + // fOPNDDBAGPJ [packed=true] + input.readPackedUInt32(fOPNDDBAGPJ, tag); + bitField0_ |= 0x00000200; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + case 56: { + // cGEIEELAOHD [packed=false] + tag = input.readRepeatedUInt32(cGEIEELAOHD, tag); + bitField0_ |= 0x00000080; + break; + } + case 88: { + // takenScoreRewardList [packed=false] + tag = input.readRepeatedUInt32(takenScoreRewardList, tag); + bitField0_ |= 0x00000100; + break; + } + case 112: { + // fOPNDDBAGPJ [packed=false] + tag = input.readRepeatedUInt32(fOPNDDBAGPJ, tag); + bitField0_ |= 0x00000200; + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.bPHINIPOKHA, bPHINIPOKHA); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.gAPFCCDFKJG, gAPFCCDFKJG); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.poolId, poolId); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeUInt32(FieldNames.dOMMGENHGKE, dOMMGENHGKE); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeUInt32(FieldNames.score, score); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeBool(FieldNames.hasTakenInitialScore, hasTakenInitialScore); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeBool(FieldNames.poolRefreshed, poolRefreshed); + } + if ((bitField0_ & 0x00000080) != 0) { + output.writeRepeatedUInt32(FieldNames.cGEIEELAOHD, cGEIEELAOHD); + } + if ((bitField0_ & 0x00000100) != 0) { + output.writeRepeatedUInt32(FieldNames.takenScoreRewardList, takenScoreRewardList); + } + if ((bitField0_ & 0x00000200) != 0) { + output.writeRepeatedUInt32(FieldNames.fOPNDDBAGPJ, fOPNDDBAGPJ); + } + output.endObject(); + } + + @Override + public RogueScoreRewardInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1415402853: { + if (input.isAtField(FieldNames.bPHINIPOKHA)) { + if (!input.trySkipNullValue()) { + bPHINIPOKHA = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1568516182: { + if (input.isAtField(FieldNames.gAPFCCDFKJG)) { + if (!input.trySkipNullValue()) { + gAPFCCDFKJG = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -982578601: + case -395144162: { + if (input.isAtField(FieldNames.poolId)) { + if (!input.trySkipNullValue()) { + poolId = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -323022850: { + if (input.isAtField(FieldNames.dOMMGENHGKE)) { + if (!input.trySkipNullValue()) { + dOMMGENHGKE = input.readUInt32(); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case 109264530: { + if (input.isAtField(FieldNames.score)) { + if (!input.trySkipNullValue()) { + score = input.readUInt32(); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1561171099: + case -1786836166: { + if (input.isAtField(FieldNames.hasTakenInitialScore)) { + if (!input.trySkipNullValue()) { + hasTakenInitialScore = input.readBool(); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1555416066: + case -403409833: { + if (input.isAtField(FieldNames.poolRefreshed)) { + if (!input.trySkipNullValue()) { + poolRefreshed = input.readBool(); + bitField0_ |= 0x00000040; + } + } else { + input.skipUnknownField(); + } + break; + } + case 167440974: { + if (input.isAtField(FieldNames.cGEIEELAOHD)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(cGEIEELAOHD); + bitField0_ |= 0x00000080; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1204149032: + case -1139944439: { + if (input.isAtField(FieldNames.takenScoreRewardList)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(takenScoreRewardList); + bitField0_ |= 0x00000100; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1708974853: { + if (input.isAtField(FieldNames.fOPNDDBAGPJ)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(fOPNDDBAGPJ); + bitField0_ |= 0x00000200; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public RogueScoreRewardInfo clone() { + return new RogueScoreRewardInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static RogueScoreRewardInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new RogueScoreRewardInfo(), data).checkInitialized(); + } + + public static RogueScoreRewardInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueScoreRewardInfo(), input).checkInitialized(); + } + + public static RogueScoreRewardInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueScoreRewardInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating RogueScoreRewardInfo messages + */ + public static MessageFactory getFactory() { + return RogueScoreRewardInfoFactory.INSTANCE; + } + + private enum RogueScoreRewardInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public RogueScoreRewardInfo create() { + return RogueScoreRewardInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName bPHINIPOKHA = FieldName.forField("BPHINIPOKHA"); + + static final FieldName gAPFCCDFKJG = FieldName.forField("GAPFCCDFKJG"); + + static final FieldName poolId = FieldName.forField("poolId", "pool_id"); + + static final FieldName dOMMGENHGKE = FieldName.forField("DOMMGENHGKE"); + + static final FieldName score = FieldName.forField("score"); + + static final FieldName hasTakenInitialScore = FieldName.forField("hasTakenInitialScore", "has_taken_initial_score"); + + static final FieldName poolRefreshed = FieldName.forField("poolRefreshed", "pool_refreshed"); + + static final FieldName cGEIEELAOHD = FieldName.forField("CGEIEELAOHD"); + + static final FieldName takenScoreRewardList = FieldName.forField("takenScoreRewardList", "taken_score_reward_list"); + + static final FieldName fOPNDDBAGPJ = FieldName.forField("FOPNDDBAGPJ"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/RogueSeasonInfoOuterClass.java b/src/generated/main/emu/lunarcore/proto/RogueSeasonInfoOuterClass.java new file mode 100644 index 0000000..ea83952 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/RogueSeasonInfoOuterClass.java @@ -0,0 +1,422 @@ +// 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 RogueSeasonInfoOuterClass { + /** + * Protobuf type {@code RogueSeasonInfo} + */ + public static final class RogueSeasonInfo extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional int64 end_time = 3; + */ + private long endTime; + + /** + * optional int64 begin_time = 10; + */ + private long beginTime; + + /** + * optional uint32 rogue_season_id = 7; + */ + private int rogueSeasonId; + + private RogueSeasonInfo() { + } + + /** + * @return a new empty instance of {@code RogueSeasonInfo} + */ + public static RogueSeasonInfo newInstance() { + return new RogueSeasonInfo(); + } + + /** + * optional int64 end_time = 3; + * @return whether the endTime field is set + */ + public boolean hasEndTime() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional int64 end_time = 3; + * @return this + */ + public RogueSeasonInfo clearEndTime() { + bitField0_ &= ~0x00000001; + endTime = 0L; + return this; + } + + /** + * optional int64 end_time = 3; + * @return the endTime + */ + public long getEndTime() { + return endTime; + } + + /** + * optional int64 end_time = 3; + * @param value the endTime to set + * @return this + */ + public RogueSeasonInfo setEndTime(final long value) { + bitField0_ |= 0x00000001; + endTime = value; + return this; + } + + /** + * optional int64 begin_time = 10; + * @return whether the beginTime field is set + */ + public boolean hasBeginTime() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional int64 begin_time = 10; + * @return this + */ + public RogueSeasonInfo clearBeginTime() { + bitField0_ &= ~0x00000002; + beginTime = 0L; + return this; + } + + /** + * optional int64 begin_time = 10; + * @return the beginTime + */ + public long getBeginTime() { + return beginTime; + } + + /** + * optional int64 begin_time = 10; + * @param value the beginTime to set + * @return this + */ + public RogueSeasonInfo setBeginTime(final long value) { + bitField0_ |= 0x00000002; + beginTime = value; + return this; + } + + /** + * optional uint32 rogue_season_id = 7; + * @return whether the rogueSeasonId field is set + */ + public boolean hasRogueSeasonId() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 rogue_season_id = 7; + * @return this + */ + public RogueSeasonInfo clearRogueSeasonId() { + bitField0_ &= ~0x00000004; + rogueSeasonId = 0; + return this; + } + + /** + * optional uint32 rogue_season_id = 7; + * @return the rogueSeasonId + */ + public int getRogueSeasonId() { + return rogueSeasonId; + } + + /** + * optional uint32 rogue_season_id = 7; + * @param value the rogueSeasonId to set + * @return this + */ + public RogueSeasonInfo setRogueSeasonId(final int value) { + bitField0_ |= 0x00000004; + rogueSeasonId = value; + return this; + } + + @Override + public RogueSeasonInfo copyFrom(final RogueSeasonInfo other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + endTime = other.endTime; + beginTime = other.beginTime; + rogueSeasonId = other.rogueSeasonId; + } + return this; + } + + @Override + public RogueSeasonInfo mergeFrom(final RogueSeasonInfo other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasEndTime()) { + setEndTime(other.endTime); + } + if (other.hasBeginTime()) { + setBeginTime(other.beginTime); + } + if (other.hasRogueSeasonId()) { + setRogueSeasonId(other.rogueSeasonId); + } + return this; + } + + @Override + public RogueSeasonInfo clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + endTime = 0L; + beginTime = 0L; + rogueSeasonId = 0; + return this; + } + + @Override + public RogueSeasonInfo 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 RogueSeasonInfo)) { + return false; + } + RogueSeasonInfo other = (RogueSeasonInfo) o; + return bitField0_ == other.bitField0_ + && (!hasEndTime() || endTime == other.endTime) + && (!hasBeginTime() || beginTime == other.beginTime) + && (!hasRogueSeasonId() || rogueSeasonId == other.rogueSeasonId); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 24); + output.writeInt64NoTag(endTime); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 80); + output.writeInt64NoTag(beginTime); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 56); + output.writeUInt32NoTag(rogueSeasonId); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeInt64SizeNoTag(endTime); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeInt64SizeNoTag(beginTime); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(rogueSeasonId); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public RogueSeasonInfo mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 24: { + // endTime + endTime = input.readInt64(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 80) { + break; + } + } + case 80: { + // beginTime + beginTime = input.readInt64(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 56) { + break; + } + } + case 56: { + // rogueSeasonId + rogueSeasonId = input.readUInt32(); + 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.writeInt64(FieldNames.endTime, endTime); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeInt64(FieldNames.beginTime, beginTime); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.rogueSeasonId, rogueSeasonId); + } + output.endObject(); + } + + @Override + public RogueSeasonInfo mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1607243192: + case 1725551537: { + if (input.isAtField(FieldNames.endTime)) { + if (!input.trySkipNullValue()) { + endTime = input.readInt64(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1072839914: + case 1112183971: { + if (input.isAtField(FieldNames.beginTime)) { + if (!input.trySkipNullValue()) { + beginTime = input.readInt64(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -774262952: + case 1067542482: { + if (input.isAtField(FieldNames.rogueSeasonId)) { + if (!input.trySkipNullValue()) { + rogueSeasonId = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public RogueSeasonInfo clone() { + return new RogueSeasonInfo().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static RogueSeasonInfo parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new RogueSeasonInfo(), data).checkInitialized(); + } + + public static RogueSeasonInfo parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueSeasonInfo(), input).checkInitialized(); + } + + public static RogueSeasonInfo parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new RogueSeasonInfo(), input).checkInitialized(); + } + + /** + * @return factory for creating RogueSeasonInfo messages + */ + public static MessageFactory getFactory() { + return RogueSeasonInfoFactory.INSTANCE; + } + + private enum RogueSeasonInfoFactory implements MessageFactory { + INSTANCE; + + @Override + public RogueSeasonInfo create() { + return RogueSeasonInfo.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName endTime = FieldName.forField("endTime", "end_time"); + + static final FieldName beginTime = FieldName.forField("beginTime", "begin_time"); + + static final FieldName rogueSeasonId = FieldName.forField("rogueSeasonId", "rogue_season_id"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/RogueStatusOuterClass.java b/src/generated/main/emu/lunarcore/proto/RogueStatusOuterClass.java new file mode 100644 index 0000000..d89fdde --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/RogueStatusOuterClass.java @@ -0,0 +1,168 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import us.hebi.quickbuf.ProtoEnum; +import us.hebi.quickbuf.ProtoUtil; + +public final class RogueStatusOuterClass { + /** + * Protobuf enum {@code RogueStatus} + */ + public enum RogueStatus implements ProtoEnum { + /** + * ROGUE_STATUS_NONE = 0; + */ + ROGUE_STATUS_NONE("ROGUE_STATUS_NONE", 0), + + /** + * ROGUE_STATUS_DOING = 1; + */ + ROGUE_STATUS_DOING("ROGUE_STATUS_DOING", 1), + + /** + * ROGUE_STATUS_PENDING = 2; + */ + ROGUE_STATUS_PENDING("ROGUE_STATUS_PENDING", 2), + + /** + * ROGUE_STATUS_ENDLESS = 3; + */ + ROGUE_STATUS_ENDLESS("ROGUE_STATUS_ENDLESS", 3), + + /** + * ROGUE_STATUS_FINISH = 4; + */ + ROGUE_STATUS_FINISH("ROGUE_STATUS_FINISH", 4); + + /** + * ROGUE_STATUS_NONE = 0; + */ + public static final int ROGUE_STATUS_NONE_VALUE = 0; + + /** + * ROGUE_STATUS_DOING = 1; + */ + public static final int ROGUE_STATUS_DOING_VALUE = 1; + + /** + * ROGUE_STATUS_PENDING = 2; + */ + public static final int ROGUE_STATUS_PENDING_VALUE = 2; + + /** + * ROGUE_STATUS_ENDLESS = 3; + */ + public static final int ROGUE_STATUS_ENDLESS_VALUE = 3; + + /** + * ROGUE_STATUS_FINISH = 4; + */ + public static final int ROGUE_STATUS_FINISH_VALUE = 4; + + private final String name; + + private final int number; + + private RogueStatus(String name, int number) { + this.name = name; + this.number = number; + } + + /** + * @return the string representation of enum entry + */ + @Override + public String getName() { + return name; + } + + /** + * @return the numeric wire value of this enum entry + */ + @Override + public int getNumber() { + return number; + } + + /** + * @return a converter that maps between this enum's numeric and text representations + */ + public static ProtoEnum.EnumConverter converter() { + return RogueStatusConverter.INSTANCE; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value, or null if unknown. + */ + public static RogueStatus forNumber(int value) { + return RogueStatusConverter.INSTANCE.forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @param other Fallback value in case the value is not known. + * @return The enum associated with the given numeric wire value, or the fallback value if unknown. + */ + public static RogueStatus forNumberOr(int number, RogueStatus other) { + RogueStatus value = forNumber(number); + return value == null ? other : value; + } + + enum RogueStatusConverter implements ProtoEnum.EnumConverter { + INSTANCE; + + private static final RogueStatus[] lookup = new RogueStatus[5]; + + static { + lookup[0] = ROGUE_STATUS_NONE; + lookup[1] = ROGUE_STATUS_DOING; + lookup[2] = ROGUE_STATUS_PENDING; + lookup[3] = ROGUE_STATUS_ENDLESS; + lookup[4] = ROGUE_STATUS_FINISH; + } + + @Override + public final RogueStatus forNumber(final int value) { + if (value >= 0 && value < lookup.length) { + return lookup[value]; + } + return null; + } + + @Override + public final RogueStatus forName(final CharSequence value) { + switch (value.length()) { + case 17: { + if (ProtoUtil.isEqual("ROGUE_STATUS_NONE", value)) { + return ROGUE_STATUS_NONE; + } + break; + } + case 18: { + if (ProtoUtil.isEqual("ROGUE_STATUS_DOING", value)) { + return ROGUE_STATUS_DOING; + } + break; + } + case 19: { + if (ProtoUtil.isEqual("ROGUE_STATUS_FINISH", value)) { + return ROGUE_STATUS_FINISH; + } + break; + } + case 20: { + if (ProtoUtil.isEqual("ROGUE_STATUS_PENDING", value)) { + return ROGUE_STATUS_PENDING; + } + if (ProtoUtil.isEqual("ROGUE_STATUS_ENDLESS", value)) { + return ROGUE_STATUS_ENDLESS; + } + break; + } + } + return null; + } + } + } +} diff --git a/src/main/java/emu/lunarcore/data/GameData.java b/src/main/java/emu/lunarcore/data/GameData.java index 9961246..e60d3b2 100644 --- a/src/main/java/emu/lunarcore/data/GameData.java +++ b/src/main/java/emu/lunarcore/data/GameData.java @@ -29,6 +29,7 @@ public class GameData { @Getter private static Int2ObjectMap heroExcelMap = new Int2ObjectOpenHashMap<>(); @Getter private static Int2ObjectMap challengeExcelMap = new Int2ObjectOpenHashMap<>(); @Getter private static Int2ObjectMap challengeTargetExcelMap = new Int2ObjectOpenHashMap<>(); + @Getter private static Int2ObjectMap rogueAreaExcelMap = new Int2ObjectOpenHashMap<>(); @Getter private static Int2ObjectMap shopExcelMap = new Int2ObjectOpenHashMap<>(); private static Int2ObjectMap avatarPromotionExcelMap = new Int2ObjectOpenHashMap<>(); diff --git a/src/main/java/emu/lunarcore/data/excel/RogueAreaExcel.java b/src/main/java/emu/lunarcore/data/excel/RogueAreaExcel.java new file mode 100644 index 0000000..da54c9e --- /dev/null +++ b/src/main/java/emu/lunarcore/data/excel/RogueAreaExcel.java @@ -0,0 +1,19 @@ +package emu.lunarcore.data.excel; + +import emu.lunarcore.data.GameResource; +import emu.lunarcore.data.ResourceType; +import lombok.Getter; + +@Getter +@ResourceType(name = {"RogueAreaConfig.json"}) +public class RogueAreaExcel extends GameResource { + private int RogueAreaID; + private int AreaProgress; + private int Difficulty; + + @Override + public int getId() { + return RogueAreaID; + } + +} diff --git a/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueHandbookDataCsReq.java b/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueHandbookDataCsReq.java new file mode 100644 index 0000000..1f641d9 --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueHandbookDataCsReq.java @@ -0,0 +1,17 @@ +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.PacketGetRogueHandbookDataScRsp; + +@Opcodes(CmdId.GetRogueHandbookDataCsReq) +public class HandlerGetRogueHandbookDataCsReq extends PacketHandler { + + @Override + public void handle(GameSession session, byte[] header, byte[] data) throws Exception { + session.send(new PacketGetRogueHandbookDataScRsp()); + } + +} diff --git a/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueInfoCsReq.java b/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueInfoCsReq.java index d839a28..aef7cd9 100644 --- a/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueInfoCsReq.java +++ b/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueInfoCsReq.java @@ -4,13 +4,14 @@ 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.PacketGetRogueInfoScRsp; @Opcodes(CmdId.GetRogueInfoCsReq) public class HandlerGetRogueInfoCsReq extends PacketHandler { @Override public void handle(GameSession session, byte[] header, byte[] data) throws Exception { - session.send(CmdId.GetRogueInfoScRsp); + session.send(new PacketGetRogueInfoScRsp()); } } diff --git a/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueScoreRewardInfoCsReq.java b/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueScoreRewardInfoCsReq.java new file mode 100644 index 0000000..cddecfa --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueScoreRewardInfoCsReq.java @@ -0,0 +1,17 @@ +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.PacketGetRogueScoreRewardInfoScRsp; + +@Opcodes(CmdId.GetRogueScoreRewardInfoCsReq) +public class HandlerGetRogueScoreRewardInfoCsReq extends PacketHandler { + + @Override + public void handle(GameSession session, byte[] header, byte[] data) throws Exception { + session.send(new PacketGetRogueScoreRewardInfoScRsp()); + } + +} diff --git a/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueTalentInfoCsReq.java b/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueTalentInfoCsReq.java new file mode 100644 index 0000000..6b09a3a --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/recv/HandlerGetRogueTalentInfoCsReq.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; + +@Opcodes(CmdId.GetRogueTalentInfoCsReq) +public class HandlerGetRogueTalentInfoCsReq extends PacketHandler { + + @Override + public void handle(GameSession session, byte[] header, byte[] data) throws Exception { + session.send(CmdId.GetRogueTalentInfoScRsp); + } + +} diff --git a/src/main/java/emu/lunarcore/server/packet/recv/HandlerStartRogueCsReq.java b/src/main/java/emu/lunarcore/server/packet/recv/HandlerStartRogueCsReq.java new file mode 100644 index 0000000..68bed87 --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/recv/HandlerStartRogueCsReq.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; + +@Opcodes(CmdId.StartRogueCsReq) +public class HandlerStartRogueCsReq extends PacketHandler { + + @Override + public void handle(GameSession session, byte[] header, byte[] data) throws Exception { + session.send(CmdId.StartRogueScRsp); + } + +} diff --git a/src/main/java/emu/lunarcore/server/packet/send/PacketGetRogueHandbookDataScRsp.java b/src/main/java/emu/lunarcore/server/packet/send/PacketGetRogueHandbookDataScRsp.java new file mode 100644 index 0000000..2919ef2 --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/send/PacketGetRogueHandbookDataScRsp.java @@ -0,0 +1,22 @@ +package emu.lunarcore.server.packet.send; + +import emu.lunarcore.proto.GetRogueHandbookDataScRspOuterClass.GetRogueHandbookDataScRsp; +import emu.lunarcore.proto.RogueHandbookDataOuterClass.RogueHandbookData; +import emu.lunarcore.server.packet.BasePacket; +import emu.lunarcore.server.packet.CmdId; + +public class PacketGetRogueHandbookDataScRsp extends BasePacket { + + public PacketGetRogueHandbookDataScRsp() { + super(CmdId.GetRogueHandbookDataScRsp); + + var handbook = RogueHandbookData.newInstance() + .setRogueCurrentVersion(1) + .setIsMiracleUnlock(true); + + var data = GetRogueHandbookDataScRsp.newInstance() + .setHandbookInfo(handbook); + + this.setData(data); + } +} diff --git a/src/main/java/emu/lunarcore/server/packet/send/PacketGetRogueInfoScRsp.java b/src/main/java/emu/lunarcore/server/packet/send/PacketGetRogueInfoScRsp.java new file mode 100644 index 0000000..beec24f --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/send/PacketGetRogueInfoScRsp.java @@ -0,0 +1,59 @@ +package emu.lunarcore.server.packet.send; + +import java.util.concurrent.TimeUnit; + +import emu.lunarcore.data.GameData; +import emu.lunarcore.proto.GetRogueInfoScRspOuterClass.GetRogueInfoScRsp; +import emu.lunarcore.proto.RogueAreaOuterClass.RogueArea; +import emu.lunarcore.proto.RogueAreaStatusOuterClass.RogueAreaStatus; +import emu.lunarcore.proto.RogueInfoDataOuterClass.RogueInfoData; +import emu.lunarcore.proto.RogueInfoOuterClass.RogueInfo; +import emu.lunarcore.proto.RogueScoreRewardInfoOuterClass.RogueScoreRewardInfo; +import emu.lunarcore.proto.RogueSeasonInfoOuterClass.RogueSeasonInfo; +import emu.lunarcore.server.packet.BasePacket; +import emu.lunarcore.server.packet.CmdId; + +public class PacketGetRogueInfoScRsp extends BasePacket { + + public PacketGetRogueInfoScRsp() { + super(CmdId.GetRogueInfoScRsp); + + int seasonId = 67; // TODO un hardcode + long beginTime = (System.currentTimeMillis() / 1000) - TimeUnit.DAYS.toSeconds(1); + long endTime = beginTime + TimeUnit.DAYS.toSeconds(8); + + var score = RogueScoreRewardInfo.newInstance() + .setPoolId(seasonId) + .setPoolRefreshed(true) + .setHasTakenInitialScore(true); + + var season = RogueSeasonInfo.newInstance() + .setBeginTime(beginTime) + .setRogueSeasonId(seasonId) + .setEndTime(endTime); + + var data = RogueInfoData.newInstance() + .setRogueScoreInfo(score) + .setRogueSeasonInfo(season); + + // Main proto + var proto = GetRogueInfoScRsp.newInstance(); + + RogueInfo info = proto.getMutableRogueInfo() + .setRogueScoreInfo(score) + .setRogueData(data) + .setRogueSeasonId(seasonId) + .setBeginTime(beginTime) + .setEndTime(endTime); + + for (var excel : GameData.getRogueAreaExcelMap().values()) { + var area = RogueArea.newInstance() + .setAreaId(excel.getRogueAreaID()) + .setRogueAreaStatus(RogueAreaStatus.ROGUE_AREA_STATUS_FIRST_PASS); + + info.addRogueAreaList(area); + } + + this.setData(proto); + } +} diff --git a/src/main/java/emu/lunarcore/server/packet/send/PacketGetRogueScoreRewardInfoScRsp.java b/src/main/java/emu/lunarcore/server/packet/send/PacketGetRogueScoreRewardInfoScRsp.java new file mode 100644 index 0000000..eff218e --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/send/PacketGetRogueScoreRewardInfoScRsp.java @@ -0,0 +1,21 @@ +package emu.lunarcore.server.packet.send; + +import emu.lunarcore.proto.GetRogueScoreRewardInfoScRspOuterClass.GetRogueScoreRewardInfoScRsp; +import emu.lunarcore.server.packet.BasePacket; +import emu.lunarcore.server.packet.CmdId; + +public class PacketGetRogueScoreRewardInfoScRsp extends BasePacket { + + public PacketGetRogueScoreRewardInfoScRsp() { + super(CmdId.GetRogueScoreRewardInfoScRsp); + + var data = GetRogueScoreRewardInfoScRsp.newInstance(); + + data.getMutableScoreRewardInfo() + .setPoolId(1) // TODO un hardcode + .setPoolRefreshed(true) + .setHasTakenInitialScore(true); + + this.setData(data); + } +}