diff --git a/build.gradle b/build.gradle index 85cb44a..39cbdfb 100644 --- a/build.gradle +++ b/build.gradle @@ -29,7 +29,7 @@ java { } } -version = '1.3.0' +version = '1.4.0' var shouldGenerateProto = System.getenv("GENERATE_PROTO") == "true" System.out.println(shouldGenerateProto ? "Generating proto files" : "Skipping proto generation") diff --git a/src/generated/main/emu/nebula/proto/ActivityDetail.java b/src/generated/main/emu/nebula/proto/ActivityDetail.java index d7c9918..39197f2 100644 --- a/src/generated/main/emu/nebula/proto/ActivityDetail.java +++ b/src/generated/main/emu/nebula/proto/ActivityDetail.java @@ -115,6 +115,11 @@ public final class ActivityDetail { */ private final Public.ActivityThrowGift throwGift = Public.ActivityThrowGift.newInstance(); + /** + * optional .ActivityGDS GDS = 20; + */ + private final Public.ActivityGDS gDS = Public.ActivityGDS.newInstance(); + /** * optional bytes NextPackage = 2047; */ @@ -1193,12 +1198,69 @@ public final class ActivityDetail { return this; } + /** + * optional .ActivityGDS GDS = 20; + * @return whether the gDS field is set + */ + public boolean hasGDS() { + return (bitField0_ & 0x00080000) != 0; + } + + /** + * optional .ActivityGDS GDS = 20; + * @return this + */ + public ActivityMsg clearGDS() { + bitField0_ &= ~0x00080000; + gDS.clear(); + return this; + } + + /** + * optional .ActivityGDS GDS = 20; + * + * 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 #getMutableGDS()} if you want to modify it. + * + * @return internal storage object for reading + */ + public Public.ActivityGDS getGDS() { + return gDS; + } + + /** + * optional .ActivityGDS GDS = 20; + * + * 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 Public.ActivityGDS getMutableGDS() { + bitField0_ |= 0x00080000; + return gDS; + } + + /** + * optional .ActivityGDS GDS = 20; + * @param value the gDS to set + * @return this + */ + public ActivityMsg setGDS(final Public.ActivityGDS value) { + bitField0_ |= 0x00080000; + gDS.copyFrom(value); + return this; + } + /** * optional bytes NextPackage = 2047; * @return whether the nextPackage field is set */ public boolean hasNextPackage() { - return (bitField0_ & 0x00080000) != 0; + return (bitField0_ & 0x00100000) != 0; } /** @@ -1206,7 +1268,7 @@ public final class ActivityDetail { * @return this */ public ActivityMsg clearNextPackage() { - bitField0_ &= ~0x00080000; + bitField0_ &= ~0x00100000; nextPackage.clear(); return this; } @@ -1235,7 +1297,7 @@ public final class ActivityDetail { * @return internal storage object for modifications */ public RepeatedByte getMutableNextPackage() { - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; return nextPackage; } @@ -1245,7 +1307,7 @@ public final class ActivityDetail { * @return this */ public ActivityMsg addNextPackage(final byte value) { - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; nextPackage.add(value); return this; } @@ -1256,7 +1318,7 @@ public final class ActivityDetail { * @return this */ public ActivityMsg addAllNextPackage(final byte... values) { - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; nextPackage.addAll(values); return this; } @@ -1267,7 +1329,7 @@ public final class ActivityDetail { * @return this */ public ActivityMsg setNextPackage(final byte... values) { - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; nextPackage.copyFrom(values); return this; } @@ -1296,6 +1358,7 @@ public final class ActivityDetail { milkout.copyFrom(other.milkout); penguinCard.copyFrom(other.penguinCard); throwGift.copyFrom(other.throwGift); + gDS.copyFrom(other.gDS); nextPackage.copyFrom(other.nextPackage); } return this; @@ -1364,6 +1427,9 @@ public final class ActivityDetail { if (other.hasThrowGift()) { getMutableThrowGift().mergeFrom(other.throwGift); } + if (other.hasGDS()) { + getMutableGDS().mergeFrom(other.gDS); + } if (other.hasNextPackage()) { getMutableNextPackage().copyFrom(other.nextPackage); } @@ -1396,6 +1462,7 @@ public final class ActivityDetail { milkout.clear(); penguinCard.clear(); throwGift.clear(); + gDS.clear(); nextPackage.clear(); return this; } @@ -1425,6 +1492,7 @@ public final class ActivityDetail { milkout.clearQuick(); penguinCard.clearQuick(); throwGift.clearQuick(); + gDS.clearQuick(); nextPackage.clear(); return this; } @@ -1458,6 +1526,7 @@ public final class ActivityDetail { && (!hasMilkout() || milkout.equals(other.milkout)) && (!hasPenguinCard() || penguinCard.equals(other.penguinCard)) && (!hasThrowGift() || throwGift.equals(other.throwGift)) + && (!hasGDS() || gDS.equals(other.gDS)) && (!hasNextPackage() || nextPackage.equals(other.nextPackage)); } @@ -1540,6 +1609,10 @@ public final class ActivityDetail { output.writeMessageNoTag(throwGift); } if ((bitField0_ & 0x00080000) != 0) { + output.writeRawLittleEndian16((short) 418); + output.writeMessageNoTag(gDS); + } + if ((bitField0_ & 0x00100000) != 0) { output.writeRawLittleEndian16((short) 32762); output.writeBytesNoTag(nextPackage); } @@ -1606,6 +1679,9 @@ public final class ActivityDetail { size += 2 + ProtoSink.computeMessageSizeNoTag(throwGift); } if ((bitField0_ & 0x00080000) != 0) { + size += 2 + ProtoSink.computeMessageSizeNoTag(gDS); + } + if ((bitField0_ & 0x00100000) != 0) { size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); } return size; @@ -1785,6 +1861,15 @@ public final class ActivityDetail { input.readMessage(throwGift); bitField0_ |= 0x00040000; tag = input.readTag(); + if (tag != 162) { + break; + } + } + case 162: { + // gDS + input.readMessage(gDS); + bitField0_ |= 0x00080000; + tag = input.readTag(); if (tag != 16378) { break; } @@ -1792,7 +1877,7 @@ public final class ActivityDetail { case 16378: { // nextPackage input.readBytes(nextPackage); - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; tag = input.readTag(); if (tag != 0) { break; @@ -1873,6 +1958,9 @@ public final class ActivityDetail { output.writeMessage(FieldNames.throwGift, throwGift); } if ((bitField0_ & 0x00080000) != 0) { + output.writeMessage(FieldNames.gDS, gDS); + } + if ((bitField0_ & 0x00100000) != 0) { output.writeBytes(FieldNames.nextPackage, nextPackage); } output.endObject(); @@ -2094,11 +2182,22 @@ public final class ActivityDetail { } break; } + case 70422: { + if (input.isAtField(FieldNames.gDS)) { + if (!input.trySkipNullValue()) { + input.readMessage(gDS); + bitField0_ |= 0x00080000; + } + } else { + input.skipUnknownField(); + } + break; + } case -2082324045: { if (input.isAtField(FieldNames.nextPackage)) { if (!input.trySkipNullValue()) { input.readBytes(nextPackage); - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; } } else { input.skipUnknownField(); @@ -2195,6 +2294,8 @@ public final class ActivityDetail { static final FieldName throwGift = FieldName.forField("ThrowGift"); + static final FieldName gDS = FieldName.forField("GDS"); + static final FieldName nextPackage = FieldName.forField("NextPackage"); } } diff --git a/src/generated/main/emu/nebula/proto/ActivityGdsSettle.java b/src/generated/main/emu/nebula/proto/ActivityGdsSettle.java new file mode 100644 index 0000000..49bb301 --- /dev/null +++ b/src/generated/main/emu/nebula/proto/ActivityGdsSettle.java @@ -0,0 +1,1826 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.nebula.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.RepeatedByte; +import us.hebi.quickbuf.RepeatedMessage; + +public final class ActivityGdsSettle { + /** + * Protobuf type {@code ActivityGDSSettleReq} + */ + public static final class ActivityGDSSettleReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 ActivityId = 1; + */ + private int activityId; + + /** + * optional uint32 LevelId = 2; + */ + private int levelId; + + /** + * optional uint32 Floor = 3; + */ + private int floor; + + /** + * optional uint32 Score = 4; + */ + private int score; + + /** + * optional uint32 CompletedTaskCount = 5; + */ + private int completedTaskCount; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + /** + * repeated .ActivityGDSItem Items = 6; + */ + private final RepeatedMessage items = RepeatedMessage.newEmptyInstance(ActivityGDSItem.getFactory()); + + /** + * repeated .ActivityGDSSkill Skills = 7; + */ + private final RepeatedMessage skills = RepeatedMessage.newEmptyInstance(ActivityGDSSkill.getFactory()); + + private ActivityGDSSettleReq() { + } + + /** + * @return a new empty instance of {@code ActivityGDSSettleReq} + */ + public static ActivityGDSSettleReq newInstance() { + return new ActivityGDSSettleReq(); + } + + /** + * optional uint32 ActivityId = 1; + * @return whether the activityId field is set + */ + public boolean hasActivityId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 ActivityId = 1; + * @return this + */ + public ActivityGDSSettleReq clearActivityId() { + bitField0_ &= ~0x00000001; + activityId = 0; + return this; + } + + /** + * optional uint32 ActivityId = 1; + * @return the activityId + */ + public int getActivityId() { + return activityId; + } + + /** + * optional uint32 ActivityId = 1; + * @param value the activityId to set + * @return this + */ + public ActivityGDSSettleReq setActivityId(final int value) { + bitField0_ |= 0x00000001; + activityId = value; + return this; + } + + /** + * optional uint32 LevelId = 2; + * @return whether the levelId field is set + */ + public boolean hasLevelId() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 LevelId = 2; + * @return this + */ + public ActivityGDSSettleReq clearLevelId() { + bitField0_ &= ~0x00000002; + levelId = 0; + return this; + } + + /** + * optional uint32 LevelId = 2; + * @return the levelId + */ + public int getLevelId() { + return levelId; + } + + /** + * optional uint32 LevelId = 2; + * @param value the levelId to set + * @return this + */ + public ActivityGDSSettleReq setLevelId(final int value) { + bitField0_ |= 0x00000002; + levelId = value; + return this; + } + + /** + * optional uint32 Floor = 3; + * @return whether the floor field is set + */ + public boolean hasFloor() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 Floor = 3; + * @return this + */ + public ActivityGDSSettleReq clearFloor() { + bitField0_ &= ~0x00000004; + floor = 0; + return this; + } + + /** + * optional uint32 Floor = 3; + * @return the floor + */ + public int getFloor() { + return floor; + } + + /** + * optional uint32 Floor = 3; + * @param value the floor to set + * @return this + */ + public ActivityGDSSettleReq setFloor(final int value) { + bitField0_ |= 0x00000004; + floor = value; + return this; + } + + /** + * optional uint32 Score = 4; + * @return whether the score field is set + */ + public boolean hasScore() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional uint32 Score = 4; + * @return this + */ + public ActivityGDSSettleReq clearScore() { + bitField0_ &= ~0x00000008; + score = 0; + return this; + } + + /** + * optional uint32 Score = 4; + * @return the score + */ + public int getScore() { + return score; + } + + /** + * optional uint32 Score = 4; + * @param value the score to set + * @return this + */ + public ActivityGDSSettleReq setScore(final int value) { + bitField0_ |= 0x00000008; + score = value; + return this; + } + + /** + * optional uint32 CompletedTaskCount = 5; + * @return whether the completedTaskCount field is set + */ + public boolean hasCompletedTaskCount() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * optional uint32 CompletedTaskCount = 5; + * @return this + */ + public ActivityGDSSettleReq clearCompletedTaskCount() { + bitField0_ &= ~0x00000010; + completedTaskCount = 0; + return this; + } + + /** + * optional uint32 CompletedTaskCount = 5; + * @return the completedTaskCount + */ + public int getCompletedTaskCount() { + return completedTaskCount; + } + + /** + * optional uint32 CompletedTaskCount = 5; + * @param value the completedTaskCount to set + * @return this + */ + public ActivityGDSSettleReq setCompletedTaskCount(final int value) { + bitField0_ |= 0x00000010; + completedTaskCount = value; + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public ActivityGDSSettleReq clearNextPackage() { + bitField0_ &= ~0x00000020; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000020; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public ActivityGDSSettleReq addNextPackage(final byte value) { + bitField0_ |= 0x00000020; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public ActivityGDSSettleReq addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000020; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public ActivityGDSSettleReq setNextPackage(final byte... values) { + bitField0_ |= 0x00000020; + nextPackage.copyFrom(values); + return this; + } + + /** + * repeated .ActivityGDSItem Items = 6; + * @return whether the items field is set + */ + public boolean hasItems() { + return (bitField0_ & 0x00000040) != 0; + } + + /** + * repeated .ActivityGDSItem Items = 6; + * @return this + */ + public ActivityGDSSettleReq clearItems() { + bitField0_ &= ~0x00000040; + items.clear(); + return this; + } + + /** + * repeated .ActivityGDSItem Items = 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 #getMutableItems()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getItems() { + return items; + } + + /** + * repeated .ActivityGDSItem Items = 6; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableItems() { + bitField0_ |= 0x00000040; + return items; + } + + /** + * repeated .ActivityGDSItem Items = 6; + * @param value the items to add + * @return this + */ + public ActivityGDSSettleReq addItems(final ActivityGDSItem value) { + bitField0_ |= 0x00000040; + items.add(value); + return this; + } + + /** + * repeated .ActivityGDSItem Items = 6; + * @param values the items to add + * @return this + */ + public ActivityGDSSettleReq addAllItems(final ActivityGDSItem... values) { + bitField0_ |= 0x00000040; + items.addAll(values); + return this; + } + + /** + * repeated .ActivityGDSSkill Skills = 7; + * @return whether the skills field is set + */ + public boolean hasSkills() { + return (bitField0_ & 0x00000080) != 0; + } + + /** + * repeated .ActivityGDSSkill Skills = 7; + * @return this + */ + public ActivityGDSSettleReq clearSkills() { + bitField0_ &= ~0x00000080; + skills.clear(); + return this; + } + + /** + * repeated .ActivityGDSSkill Skills = 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 #getMutableSkills()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getSkills() { + return skills; + } + + /** + * repeated .ActivityGDSSkill Skills = 7; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableSkills() { + bitField0_ |= 0x00000080; + return skills; + } + + /** + * repeated .ActivityGDSSkill Skills = 7; + * @param value the skills to add + * @return this + */ + public ActivityGDSSettleReq addSkills(final ActivityGDSSkill value) { + bitField0_ |= 0x00000080; + skills.add(value); + return this; + } + + /** + * repeated .ActivityGDSSkill Skills = 7; + * @param values the skills to add + * @return this + */ + public ActivityGDSSettleReq addAllSkills(final ActivityGDSSkill... values) { + bitField0_ |= 0x00000080; + skills.addAll(values); + return this; + } + + @Override + public ActivityGDSSettleReq copyFrom(final ActivityGDSSettleReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + activityId = other.activityId; + levelId = other.levelId; + floor = other.floor; + score = other.score; + completedTaskCount = other.completedTaskCount; + nextPackage.copyFrom(other.nextPackage); + items.copyFrom(other.items); + skills.copyFrom(other.skills); + } + return this; + } + + @Override + public ActivityGDSSettleReq mergeFrom(final ActivityGDSSettleReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasActivityId()) { + setActivityId(other.activityId); + } + if (other.hasLevelId()) { + setLevelId(other.levelId); + } + if (other.hasFloor()) { + setFloor(other.floor); + } + if (other.hasScore()) { + setScore(other.score); + } + if (other.hasCompletedTaskCount()) { + setCompletedTaskCount(other.completedTaskCount); + } + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + if (other.hasItems()) { + getMutableItems().addAll(other.items); + } + if (other.hasSkills()) { + getMutableSkills().addAll(other.skills); + } + return this; + } + + @Override + public ActivityGDSSettleReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + activityId = 0; + levelId = 0; + floor = 0; + score = 0; + completedTaskCount = 0; + nextPackage.clear(); + items.clear(); + skills.clear(); + return this; + } + + @Override + public ActivityGDSSettleReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + items.clearQuick(); + skills.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ActivityGDSSettleReq)) { + return false; + } + ActivityGDSSettleReq other = (ActivityGDSSettleReq) o; + return bitField0_ == other.bitField0_ + && (!hasActivityId() || activityId == other.activityId) + && (!hasLevelId() || levelId == other.levelId) + && (!hasFloor() || floor == other.floor) + && (!hasScore() || score == other.score) + && (!hasCompletedTaskCount() || completedTaskCount == other.completedTaskCount) + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) + && (!hasItems() || items.equals(other.items)) + && (!hasSkills() || skills.equals(other.skills)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(activityId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(levelId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(floor); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(score); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawByte((byte) 40); + output.writeUInt32NoTag(completedTaskCount); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + if ((bitField0_ & 0x00000040) != 0) { + for (int i = 0; i < items.length(); i++) { + output.writeRawByte((byte) 50); + output.writeMessageNoTag(items.get(i)); + } + } + if ((bitField0_ & 0x00000080) != 0) { + for (int i = 0; i < skills.length(); i++) { + output.writeRawByte((byte) 58); + output.writeMessageNoTag(skills.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(activityId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(levelId); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(floor); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(score); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(completedTaskCount); + } + if ((bitField0_ & 0x00000020) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + if ((bitField0_ & 0x00000040) != 0) { + size += (1 * items.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(items); + } + if ((bitField0_ & 0x00000080) != 0) { + size += (1 * skills.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(skills); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ActivityGDSSettleReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // activityId + activityId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // levelId + levelId = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 24) { + break; + } + } + case 24: { + // floor + floor = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 32) { + break; + } + } + case 32: { + // score + score = input.readUInt32(); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 40) { + break; + } + } + case 40: { + // completedTaskCount + completedTaskCount = input.readUInt32(); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 16378) { + break; + } + } + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000020; + tag = input.readTag(); + if (tag != 50) { + break; + } + } + case 50: { + // items + tag = input.readRepeatedMessage(items, tag); + bitField0_ |= 0x00000040; + if (tag != 58) { + break; + } + } + case 58: { + // skills + tag = input.readRepeatedMessage(skills, tag); + bitField0_ |= 0x00000080; + 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.activityId, activityId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.levelId, levelId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.floor, floor); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeUInt32(FieldNames.score, score); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeUInt32(FieldNames.completedTaskCount, completedTaskCount); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + if ((bitField0_ & 0x00000040) != 0) { + output.writeRepeatedMessage(FieldNames.items, items); + } + if ((bitField0_ & 0x00000080) != 0) { + output.writeRepeatedMessage(FieldNames.skills, skills); + } + output.endObject(); + } + + @Override + public ActivityGDSSettleReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -252882774: { + if (input.isAtField(FieldNames.activityId)) { + if (!input.trySkipNullValue()) { + activityId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1734437791: { + if (input.isAtField(FieldNames.levelId)) { + if (!input.trySkipNullValue()) { + levelId = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 67974124: { + if (input.isAtField(FieldNames.floor)) { + if (!input.trySkipNullValue()) { + floor = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case 79711858: { + if (input.isAtField(FieldNames.score)) { + if (!input.trySkipNullValue()) { + score = input.readUInt32(); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1380556959: { + if (input.isAtField(FieldNames.completedTaskCount)) { + if (!input.trySkipNullValue()) { + completedTaskCount = input.readUInt32(); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } + case 70973344: { + if (input.isAtField(FieldNames.items)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(items); + bitField0_ |= 0x00000040; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1816695710: { + if (input.isAtField(FieldNames.skills)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(skills); + bitField0_ |= 0x00000080; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ActivityGDSSettleReq clone() { + return new ActivityGDSSettleReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ActivityGDSSettleReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ActivityGDSSettleReq(), data).checkInitialized(); + } + + public static ActivityGDSSettleReq parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityGDSSettleReq(), input).checkInitialized(); + } + + public static ActivityGDSSettleReq parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityGDSSettleReq(), input).checkInitialized(); + } + + /** + * @return factory for creating ActivityGDSSettleReq messages + */ + public static MessageFactory getFactory() { + return ActivityGDSSettleReqFactory.INSTANCE; + } + + private enum ActivityGDSSettleReqFactory implements MessageFactory { + INSTANCE; + + @Override + public ActivityGDSSettleReq create() { + return ActivityGDSSettleReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName activityId = FieldName.forField("ActivityId"); + + static final FieldName levelId = FieldName.forField("LevelId"); + + static final FieldName floor = FieldName.forField("Floor"); + + static final FieldName score = FieldName.forField("Score"); + + static final FieldName completedTaskCount = FieldName.forField("CompletedTaskCount"); + + static final FieldName nextPackage = FieldName.forField("NextPackage"); + + static final FieldName items = FieldName.forField("Items"); + + static final FieldName skills = FieldName.forField("Skills"); + } + } + + /** + * Protobuf type {@code ActivityGDSItem} + */ + public static final class ActivityGDSItem extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 ItemId = 1; + */ + private int itemId; + + /** + * optional uint32 PickCount = 2; + */ + private int pickCount; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + private ActivityGDSItem() { + } + + /** + * @return a new empty instance of {@code ActivityGDSItem} + */ + public static ActivityGDSItem newInstance() { + return new ActivityGDSItem(); + } + + /** + * optional uint32 ItemId = 1; + * @return whether the itemId field is set + */ + public boolean hasItemId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 ItemId = 1; + * @return this + */ + public ActivityGDSItem clearItemId() { + bitField0_ &= ~0x00000001; + itemId = 0; + return this; + } + + /** + * optional uint32 ItemId = 1; + * @return the itemId + */ + public int getItemId() { + return itemId; + } + + /** + * optional uint32 ItemId = 1; + * @param value the itemId to set + * @return this + */ + public ActivityGDSItem setItemId(final int value) { + bitField0_ |= 0x00000001; + itemId = value; + return this; + } + + /** + * optional uint32 PickCount = 2; + * @return whether the pickCount field is set + */ + public boolean hasPickCount() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 PickCount = 2; + * @return this + */ + public ActivityGDSItem clearPickCount() { + bitField0_ &= ~0x00000002; + pickCount = 0; + return this; + } + + /** + * optional uint32 PickCount = 2; + * @return the pickCount + */ + public int getPickCount() { + return pickCount; + } + + /** + * optional uint32 PickCount = 2; + * @param value the pickCount to set + * @return this + */ + public ActivityGDSItem setPickCount(final int value) { + bitField0_ |= 0x00000002; + pickCount = value; + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public ActivityGDSItem clearNextPackage() { + bitField0_ &= ~0x00000004; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000004; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public ActivityGDSItem addNextPackage(final byte value) { + bitField0_ |= 0x00000004; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public ActivityGDSItem addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000004; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public ActivityGDSItem setNextPackage(final byte... values) { + bitField0_ |= 0x00000004; + nextPackage.copyFrom(values); + return this; + } + + @Override + public ActivityGDSItem copyFrom(final ActivityGDSItem other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + itemId = other.itemId; + pickCount = other.pickCount; + nextPackage.copyFrom(other.nextPackage); + } + return this; + } + + @Override + public ActivityGDSItem mergeFrom(final ActivityGDSItem other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasItemId()) { + setItemId(other.itemId); + } + if (other.hasPickCount()) { + setPickCount(other.pickCount); + } + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + return this; + } + + @Override + public ActivityGDSItem clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + itemId = 0; + pickCount = 0; + nextPackage.clear(); + return this; + } + + @Override + public ActivityGDSItem clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ActivityGDSItem)) { + return false; + } + ActivityGDSItem other = (ActivityGDSItem) o; + return bitField0_ == other.bitField0_ + && (!hasItemId() || itemId == other.itemId) + && (!hasPickCount() || pickCount == other.pickCount) + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(itemId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(pickCount); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(itemId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(pickCount); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ActivityGDSItem mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // itemId + itemId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // pickCount + pickCount = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 16378) { + break; + } + } + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.itemId, itemId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.pickCount, pickCount); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + output.endObject(); + } + + @Override + public ActivityGDSItem mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -2094794834: { + if (input.isAtField(FieldNames.itemId)) { + if (!input.trySkipNullValue()) { + itemId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 541191502: { + if (input.isAtField(FieldNames.pickCount)) { + if (!input.trySkipNullValue()) { + pickCount = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ActivityGDSItem clone() { + return new ActivityGDSItem().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ActivityGDSItem parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ActivityGDSItem(), data).checkInitialized(); + } + + public static ActivityGDSItem parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityGDSItem(), input).checkInitialized(); + } + + public static ActivityGDSItem parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityGDSItem(), input).checkInitialized(); + } + + /** + * @return factory for creating ActivityGDSItem messages + */ + public static MessageFactory getFactory() { + return ActivityGDSItemFactory.INSTANCE; + } + + private enum ActivityGDSItemFactory implements MessageFactory { + INSTANCE; + + @Override + public ActivityGDSItem create() { + return ActivityGDSItem.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName itemId = FieldName.forField("ItemId"); + + static final FieldName pickCount = FieldName.forField("PickCount"); + + static final FieldName nextPackage = FieldName.forField("NextPackage"); + } + } + + /** + * Protobuf type {@code ActivityGDSSkill} + */ + public static final class ActivityGDSSkill extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 SkillId = 1; + */ + private int skillId; + + /** + * optional uint32 UseCount = 2; + */ + private int useCount; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + private ActivityGDSSkill() { + } + + /** + * @return a new empty instance of {@code ActivityGDSSkill} + */ + public static ActivityGDSSkill newInstance() { + return new ActivityGDSSkill(); + } + + /** + * optional uint32 SkillId = 1; + * @return whether the skillId field is set + */ + public boolean hasSkillId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 SkillId = 1; + * @return this + */ + public ActivityGDSSkill clearSkillId() { + bitField0_ &= ~0x00000001; + skillId = 0; + return this; + } + + /** + * optional uint32 SkillId = 1; + * @return the skillId + */ + public int getSkillId() { + return skillId; + } + + /** + * optional uint32 SkillId = 1; + * @param value the skillId to set + * @return this + */ + public ActivityGDSSkill setSkillId(final int value) { + bitField0_ |= 0x00000001; + skillId = value; + return this; + } + + /** + * optional uint32 UseCount = 2; + * @return whether the useCount field is set + */ + public boolean hasUseCount() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 UseCount = 2; + * @return this + */ + public ActivityGDSSkill clearUseCount() { + bitField0_ &= ~0x00000002; + useCount = 0; + return this; + } + + /** + * optional uint32 UseCount = 2; + * @return the useCount + */ + public int getUseCount() { + return useCount; + } + + /** + * optional uint32 UseCount = 2; + * @param value the useCount to set + * @return this + */ + public ActivityGDSSkill setUseCount(final int value) { + bitField0_ |= 0x00000002; + useCount = value; + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public ActivityGDSSkill clearNextPackage() { + bitField0_ &= ~0x00000004; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000004; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public ActivityGDSSkill addNextPackage(final byte value) { + bitField0_ |= 0x00000004; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public ActivityGDSSkill addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000004; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public ActivityGDSSkill setNextPackage(final byte... values) { + bitField0_ |= 0x00000004; + nextPackage.copyFrom(values); + return this; + } + + @Override + public ActivityGDSSkill copyFrom(final ActivityGDSSkill other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + skillId = other.skillId; + useCount = other.useCount; + nextPackage.copyFrom(other.nextPackage); + } + return this; + } + + @Override + public ActivityGDSSkill mergeFrom(final ActivityGDSSkill other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasSkillId()) { + setSkillId(other.skillId); + } + if (other.hasUseCount()) { + setUseCount(other.useCount); + } + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + return this; + } + + @Override + public ActivityGDSSkill clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + skillId = 0; + useCount = 0; + nextPackage.clear(); + return this; + } + + @Override + public ActivityGDSSkill clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ActivityGDSSkill)) { + return false; + } + ActivityGDSSkill other = (ActivityGDSSkill) o; + return bitField0_ == other.bitField0_ + && (!hasSkillId() || skillId == other.skillId) + && (!hasUseCount() || useCount == other.useCount) + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(skillId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(useCount); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(skillId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(useCount); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ActivityGDSSkill mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // skillId + skillId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // useCount + useCount = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 16378) { + break; + } + } + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.skillId, skillId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.useCount, useCount); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + output.endObject(); + } + + @Override + public ActivityGDSSkill mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -482993364: { + if (input.isAtField(FieldNames.skillId)) { + if (!input.trySkipNullValue()) { + skillId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -244425752: { + if (input.isAtField(FieldNames.useCount)) { + if (!input.trySkipNullValue()) { + useCount = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ActivityGDSSkill clone() { + return new ActivityGDSSkill().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ActivityGDSSkill parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ActivityGDSSkill(), data).checkInitialized(); + } + + public static ActivityGDSSkill parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityGDSSkill(), input).checkInitialized(); + } + + public static ActivityGDSSkill parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityGDSSkill(), input).checkInitialized(); + } + + /** + * @return factory for creating ActivityGDSSkill messages + */ + public static MessageFactory getFactory() { + return ActivityGDSSkillFactory.INSTANCE; + } + + private enum ActivityGDSSkillFactory implements MessageFactory { + INSTANCE; + + @Override + public ActivityGDSSkill create() { + return ActivityGDSSkill.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName skillId = FieldName.forField("SkillId"); + + static final FieldName useCount = FieldName.forField("UseCount"); + + static final FieldName nextPackage = FieldName.forField("NextPackage"); + } + } +} diff --git a/src/generated/main/emu/nebula/proto/ActivityTrekkerVersusRankBoost.java b/src/generated/main/emu/nebula/proto/ActivityTrekkerVersusRankBoost.java index 48d0b6d..cfcb6eb 100644 --- a/src/generated/main/emu/nebula/proto/ActivityTrekkerVersusRankBoost.java +++ b/src/generated/main/emu/nebula/proto/ActivityTrekkerVersusRankBoost.java @@ -505,6 +505,16 @@ public final class ActivityTrekkerVersusRankBoost { public static final class ActivityTrekkerVersusRankBoostResp extends ProtoMessage implements Cloneable { private static final long serialVersionUID = 0L; + /** + * optional uint64 SelfHotValue = 3; + */ + private long selfHotValue; + + /** + * optional uint64 RivalHotValue = 4; + */ + private long rivalHotValue; + /** * optional uint32 Level = 1; */ @@ -515,16 +525,6 @@ public final class ActivityTrekkerVersusRankBoost { */ private int exp; - /** - * optional uint32 SelfHotValue = 3; - */ - private int selfHotValue; - - /** - * optional uint32 RivalHotValue = 4; - */ - private int rivalHotValue; - /** * optional .ChangeInfo Change = 5; */ @@ -550,12 +550,86 @@ public final class ActivityTrekkerVersusRankBoost { return new ActivityTrekkerVersusRankBoostResp(); } + /** + * optional uint64 SelfHotValue = 3; + * @return whether the selfHotValue field is set + */ + public boolean hasSelfHotValue() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint64 SelfHotValue = 3; + * @return this + */ + public ActivityTrekkerVersusRankBoostResp clearSelfHotValue() { + bitField0_ &= ~0x00000001; + selfHotValue = 0L; + return this; + } + + /** + * optional uint64 SelfHotValue = 3; + * @return the selfHotValue + */ + public long getSelfHotValue() { + return selfHotValue; + } + + /** + * optional uint64 SelfHotValue = 3; + * @param value the selfHotValue to set + * @return this + */ + public ActivityTrekkerVersusRankBoostResp setSelfHotValue(final long value) { + bitField0_ |= 0x00000001; + selfHotValue = value; + return this; + } + + /** + * optional uint64 RivalHotValue = 4; + * @return whether the rivalHotValue field is set + */ + public boolean hasRivalHotValue() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint64 RivalHotValue = 4; + * @return this + */ + public ActivityTrekkerVersusRankBoostResp clearRivalHotValue() { + bitField0_ &= ~0x00000002; + rivalHotValue = 0L; + return this; + } + + /** + * optional uint64 RivalHotValue = 4; + * @return the rivalHotValue + */ + public long getRivalHotValue() { + return rivalHotValue; + } + + /** + * optional uint64 RivalHotValue = 4; + * @param value the rivalHotValue to set + * @return this + */ + public ActivityTrekkerVersusRankBoostResp setRivalHotValue(final long value) { + bitField0_ |= 0x00000002; + rivalHotValue = value; + return this; + } + /** * optional uint32 Level = 1; * @return whether the level field is set */ public boolean hasLevel() { - return (bitField0_ & 0x00000001) != 0; + return (bitField0_ & 0x00000004) != 0; } /** @@ -563,7 +637,7 @@ public final class ActivityTrekkerVersusRankBoost { * @return this */ public ActivityTrekkerVersusRankBoostResp clearLevel() { - bitField0_ &= ~0x00000001; + bitField0_ &= ~0x00000004; level = 0; return this; } @@ -582,7 +656,7 @@ public final class ActivityTrekkerVersusRankBoost { * @return this */ public ActivityTrekkerVersusRankBoostResp setLevel(final int value) { - bitField0_ |= 0x00000001; + bitField0_ |= 0x00000004; level = value; return this; } @@ -592,7 +666,7 @@ public final class ActivityTrekkerVersusRankBoost { * @return whether the exp field is set */ public boolean hasExp() { - return (bitField0_ & 0x00000002) != 0; + return (bitField0_ & 0x00000008) != 0; } /** @@ -600,7 +674,7 @@ public final class ActivityTrekkerVersusRankBoost { * @return this */ public ActivityTrekkerVersusRankBoostResp clearExp() { - bitField0_ &= ~0x00000002; + bitField0_ &= ~0x00000008; exp = 0; return this; } @@ -619,82 +693,8 @@ public final class ActivityTrekkerVersusRankBoost { * @return this */ public ActivityTrekkerVersusRankBoostResp setExp(final int value) { - bitField0_ |= 0x00000002; - exp = value; - return this; - } - - /** - * optional uint32 SelfHotValue = 3; - * @return whether the selfHotValue field is set - */ - public boolean hasSelfHotValue() { - return (bitField0_ & 0x00000004) != 0; - } - - /** - * optional uint32 SelfHotValue = 3; - * @return this - */ - public ActivityTrekkerVersusRankBoostResp clearSelfHotValue() { - bitField0_ &= ~0x00000004; - selfHotValue = 0; - return this; - } - - /** - * optional uint32 SelfHotValue = 3; - * @return the selfHotValue - */ - public int getSelfHotValue() { - return selfHotValue; - } - - /** - * optional uint32 SelfHotValue = 3; - * @param value the selfHotValue to set - * @return this - */ - public ActivityTrekkerVersusRankBoostResp setSelfHotValue(final int value) { - bitField0_ |= 0x00000004; - selfHotValue = value; - return this; - } - - /** - * optional uint32 RivalHotValue = 4; - * @return whether the rivalHotValue field is set - */ - public boolean hasRivalHotValue() { - return (bitField0_ & 0x00000008) != 0; - } - - /** - * optional uint32 RivalHotValue = 4; - * @return this - */ - public ActivityTrekkerVersusRankBoostResp clearRivalHotValue() { - bitField0_ &= ~0x00000008; - rivalHotValue = 0; - return this; - } - - /** - * optional uint32 RivalHotValue = 4; - * @return the rivalHotValue - */ - public int getRivalHotValue() { - return rivalHotValue; - } - - /** - * optional uint32 RivalHotValue = 4; - * @param value the rivalHotValue to set - * @return this - */ - public ActivityTrekkerVersusRankBoostResp setRivalHotValue(final int value) { bitField0_ |= 0x00000008; - rivalHotValue = value; + exp = value; return this; } @@ -908,10 +908,10 @@ public final class ActivityTrekkerVersusRankBoost { cachedSize = other.cachedSize; if ((bitField0_ | other.bitField0_) != 0) { bitField0_ = other.bitField0_; - level = other.level; - exp = other.exp; selfHotValue = other.selfHotValue; rivalHotValue = other.rivalHotValue; + level = other.level; + exp = other.exp; change.copyFrom(other.change); nextPackage.copyFrom(other.nextPackage); awardItems.copyFrom(other.awardItems); @@ -926,18 +926,18 @@ public final class ActivityTrekkerVersusRankBoost { return this; } cachedSize = -1; - if (other.hasLevel()) { - setLevel(other.level); - } - if (other.hasExp()) { - setExp(other.exp); - } if (other.hasSelfHotValue()) { setSelfHotValue(other.selfHotValue); } if (other.hasRivalHotValue()) { setRivalHotValue(other.rivalHotValue); } + if (other.hasLevel()) { + setLevel(other.level); + } + if (other.hasExp()) { + setExp(other.exp); + } if (other.hasChange()) { getMutableChange().mergeFrom(other.change); } @@ -957,10 +957,10 @@ public final class ActivityTrekkerVersusRankBoost { } cachedSize = -1; bitField0_ = 0; + selfHotValue = 0L; + rivalHotValue = 0L; level = 0; exp = 0; - selfHotValue = 0; - rivalHotValue = 0; change.clear(); nextPackage.clear(); awardItems.clear(); @@ -990,10 +990,10 @@ public final class ActivityTrekkerVersusRankBoost { } ActivityTrekkerVersusRankBoostResp other = (ActivityTrekkerVersusRankBoostResp) o; return bitField0_ == other.bitField0_ - && (!hasLevel() || level == other.level) - && (!hasExp() || exp == other.exp) && (!hasSelfHotValue() || selfHotValue == other.selfHotValue) && (!hasRivalHotValue() || rivalHotValue == other.rivalHotValue) + && (!hasLevel() || level == other.level) + && (!hasExp() || exp == other.exp) && (!hasChange() || change.equals(other.change)) && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) && (!hasAwardItems() || awardItems.equals(other.awardItems)); @@ -1002,21 +1002,21 @@ public final class ActivityTrekkerVersusRankBoost { @Override public void writeTo(final ProtoSink output) throws IOException { if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 24); + output.writeUInt64NoTag(selfHotValue); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 32); + output.writeUInt64NoTag(rivalHotValue); + } + if ((bitField0_ & 0x00000004) != 0) { output.writeRawByte((byte) 8); output.writeUInt32NoTag(level); } - if ((bitField0_ & 0x00000002) != 0) { + if ((bitField0_ & 0x00000008) != 0) { output.writeRawByte((byte) 16); output.writeUInt32NoTag(exp); } - if ((bitField0_ & 0x00000004) != 0) { - output.writeRawByte((byte) 24); - output.writeUInt32NoTag(selfHotValue); - } - if ((bitField0_ & 0x00000008) != 0) { - output.writeRawByte((byte) 32); - output.writeUInt32NoTag(rivalHotValue); - } if ((bitField0_ & 0x00000010) != 0) { output.writeRawByte((byte) 42); output.writeMessageNoTag(change); @@ -1037,16 +1037,16 @@ public final class ActivityTrekkerVersusRankBoost { protected int computeSerializedSize() { int size = 0; if ((bitField0_ & 0x00000001) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(level); + size += 1 + ProtoSink.computeUInt64SizeNoTag(selfHotValue); } if ((bitField0_ & 0x00000002) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(exp); + size += 1 + ProtoSink.computeUInt64SizeNoTag(rivalHotValue); } if ((bitField0_ & 0x00000004) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(selfHotValue); + size += 1 + ProtoSink.computeUInt32SizeNoTag(level); } if ((bitField0_ & 0x00000008) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(rivalHotValue); + size += 1 + ProtoSink.computeUInt32SizeNoTag(exp); } if ((bitField0_ & 0x00000010) != 0) { size += 1 + ProtoSink.computeMessageSizeNoTag(change); @@ -1068,10 +1068,28 @@ public final class ActivityTrekkerVersusRankBoost { int tag = input.readTag(); while (true) { switch (tag) { + case 24: { + // selfHotValue + selfHotValue = input.readUInt64(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 32) { + break; + } + } + case 32: { + // rivalHotValue + rivalHotValue = input.readUInt64(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 8) { + break; + } + } case 8: { // level level = input.readUInt32(); - bitField0_ |= 0x00000001; + bitField0_ |= 0x00000004; tag = input.readTag(); if (tag != 16) { break; @@ -1080,24 +1098,6 @@ public final class ActivityTrekkerVersusRankBoost { case 16: { // exp exp = input.readUInt32(); - bitField0_ |= 0x00000002; - tag = input.readTag(); - if (tag != 24) { - break; - } - } - case 24: { - // selfHotValue - selfHotValue = input.readUInt32(); - bitField0_ |= 0x00000004; - tag = input.readTag(); - if (tag != 32) { - break; - } - } - case 32: { - // rivalHotValue - rivalHotValue = input.readUInt32(); bitField0_ |= 0x00000008; tag = input.readTag(); if (tag != 42) { @@ -1148,16 +1148,16 @@ public final class ActivityTrekkerVersusRankBoost { public void writeTo(final JsonSink output) throws IOException { output.beginObject(); if ((bitField0_ & 0x00000001) != 0) { - output.writeUInt32(FieldNames.level, level); + output.writeUInt64(FieldNames.selfHotValue, selfHotValue); } if ((bitField0_ & 0x00000002) != 0) { - output.writeUInt32(FieldNames.exp, exp); + output.writeUInt64(FieldNames.rivalHotValue, rivalHotValue); } if ((bitField0_ & 0x00000004) != 0) { - output.writeUInt32(FieldNames.selfHotValue, selfHotValue); + output.writeUInt32(FieldNames.level, level); } if ((bitField0_ & 0x00000008) != 0) { - output.writeUInt32(FieldNames.rivalHotValue, rivalHotValue); + output.writeUInt32(FieldNames.exp, exp); } if ((bitField0_ & 0x00000010) != 0) { output.writeMessage(FieldNames.change, change); @@ -1178,11 +1178,33 @@ public final class ActivityTrekkerVersusRankBoost { } while (!input.isAtEnd()) { switch (input.readFieldHash()) { + case 1360474288: { + if (input.isAtField(FieldNames.selfHotValue)) { + if (!input.trySkipNullValue()) { + selfHotValue = input.readUInt64(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1039538350: { + if (input.isAtField(FieldNames.rivalHotValue)) { + if (!input.trySkipNullValue()) { + rivalHotValue = input.readUInt64(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } case 73313124: { if (input.isAtField(FieldNames.level)) { if (!input.trySkipNullValue()) { level = input.readUInt32(); - bitField0_ |= 0x00000001; + bitField0_ |= 0x00000004; } } else { input.skipUnknownField(); @@ -1193,28 +1215,6 @@ public final class ActivityTrekkerVersusRankBoost { if (input.isAtField(FieldNames.exp)) { if (!input.trySkipNullValue()) { exp = input.readUInt32(); - bitField0_ |= 0x00000002; - } - } else { - input.skipUnknownField(); - } - break; - } - case 1360474288: { - if (input.isAtField(FieldNames.selfHotValue)) { - if (!input.trySkipNullValue()) { - selfHotValue = input.readUInt32(); - bitField0_ |= 0x00000004; - } - } else { - input.skipUnknownField(); - } - break; - } - case 1039538350: { - if (input.isAtField(FieldNames.rivalHotValue)) { - if (!input.trySkipNullValue()) { - rivalHotValue = input.readUInt32(); bitField0_ |= 0x00000008; } } else { @@ -1310,14 +1310,14 @@ public final class ActivityTrekkerVersusRankBoost { * Contains name constants used for serializing JSON */ static class FieldNames { - static final FieldName level = FieldName.forField("Level"); - - static final FieldName exp = FieldName.forField("Exp"); - static final FieldName selfHotValue = FieldName.forField("SelfHotValue"); static final FieldName rivalHotValue = FieldName.forField("RivalHotValue"); + static final FieldName level = FieldName.forField("Level"); + + static final FieldName exp = FieldName.forField("Exp"); + static final FieldName change = FieldName.forField("Change"); static final FieldName nextPackage = FieldName.forField("NextPackage"); diff --git a/src/generated/main/emu/nebula/proto/CharFavoriteSet.java b/src/generated/main/emu/nebula/proto/CharFavoriteSet.java new file mode 100644 index 0000000..ac9340c --- /dev/null +++ b/src/generated/main/emu/nebula/proto/CharFavoriteSet.java @@ -0,0 +1,5 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.nebula.proto; + +public final class CharFavoriteSet { +} diff --git a/src/generated/main/emu/nebula/proto/CharGemRefresh.java b/src/generated/main/emu/nebula/proto/CharGemRefresh.java index ebde4f7..4297802 100644 --- a/src/generated/main/emu/nebula/proto/CharGemRefresh.java +++ b/src/generated/main/emu/nebula/proto/CharGemRefresh.java @@ -683,6 +683,11 @@ public final class CharGemRefresh { */ private final RepeatedInt attributes = RepeatedInt.newEmptyInstance(); + /** + * repeated uint32 OverlockCount = 3; + */ + private final RepeatedInt overlockCount = RepeatedInt.newEmptyInstance(); + private CharGemRefreshResp() { } @@ -897,6 +902,74 @@ public final class CharGemRefresh { return this; } + /** + * repeated uint32 OverlockCount = 3; + * @return whether the overlockCount field is set + */ + public boolean hasOverlockCount() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * repeated uint32 OverlockCount = 3; + * @return this + */ + public CharGemRefreshResp clearOverlockCount() { + bitField0_ &= ~0x00000008; + overlockCount.clear(); + return this; + } + + /** + * repeated uint32 OverlockCount = 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 #getMutableOverlockCount()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getOverlockCount() { + return overlockCount; + } + + /** + * repeated uint32 OverlockCount = 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 RepeatedInt getMutableOverlockCount() { + bitField0_ |= 0x00000008; + return overlockCount; + } + + /** + * repeated uint32 OverlockCount = 3; + * @param value the overlockCount to add + * @return this + */ + public CharGemRefreshResp addOverlockCount(final int value) { + bitField0_ |= 0x00000008; + overlockCount.add(value); + return this; + } + + /** + * repeated uint32 OverlockCount = 3; + * @param values the overlockCount to add + * @return this + */ + public CharGemRefreshResp addAllOverlockCount(final int... values) { + bitField0_ |= 0x00000008; + overlockCount.addAll(values); + return this; + } + @Override public CharGemRefreshResp copyFrom(final CharGemRefreshResp other) { cachedSize = other.cachedSize; @@ -905,6 +978,7 @@ public final class CharGemRefresh { changeInfo.copyFrom(other.changeInfo); nextPackage.copyFrom(other.nextPackage); attributes.copyFrom(other.attributes); + overlockCount.copyFrom(other.overlockCount); } return this; } @@ -924,6 +998,9 @@ public final class CharGemRefresh { if (other.hasAttributes()) { getMutableAttributes().addAll(other.attributes); } + if (other.hasOverlockCount()) { + getMutableOverlockCount().addAll(other.overlockCount); + } return this; } @@ -937,6 +1014,7 @@ public final class CharGemRefresh { changeInfo.clear(); nextPackage.clear(); attributes.clear(); + overlockCount.clear(); return this; } @@ -950,6 +1028,7 @@ public final class CharGemRefresh { changeInfo.clearQuick(); nextPackage.clear(); attributes.clear(); + overlockCount.clear(); return this; } @@ -965,7 +1044,8 @@ public final class CharGemRefresh { return bitField0_ == other.bitField0_ && (!hasChangeInfo() || changeInfo.equals(other.changeInfo)) && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) - && (!hasAttributes() || attributes.equals(other.attributes)); + && (!hasAttributes() || attributes.equals(other.attributes)) + && (!hasOverlockCount() || overlockCount.equals(other.overlockCount)); } @Override @@ -984,6 +1064,12 @@ public final class CharGemRefresh { output.writeUInt32NoTag(attributes.array()[i]); } } + if ((bitField0_ & 0x00000008) != 0) { + for (int i = 0; i < overlockCount.length(); i++) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(overlockCount.array()[i]); + } + } } @Override @@ -998,6 +1084,9 @@ public final class CharGemRefresh { if ((bitField0_ & 0x00000004) != 0) { size += (1 * attributes.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(attributes); } + if ((bitField0_ & 0x00000008) != 0) { + size += (1 * overlockCount.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(overlockCount); + } return size; } @@ -1031,6 +1120,15 @@ public final class CharGemRefresh { input.readPackedUInt32(attributes, tag); bitField0_ |= 0x00000004; tag = input.readTag(); + if (tag != 26) { + break; + } + } + case 26: { + // overlockCount [packed=true] + input.readPackedUInt32(overlockCount, tag); + bitField0_ |= 0x00000008; + tag = input.readTag(); if (tag != 0) { break; } @@ -1051,6 +1149,12 @@ public final class CharGemRefresh { bitField0_ |= 0x00000004; break; } + case 24: { + // overlockCount [packed=false] + tag = input.readRepeatedUInt32(overlockCount, tag); + bitField0_ |= 0x00000008; + break; + } } } } @@ -1067,6 +1171,9 @@ public final class CharGemRefresh { if ((bitField0_ & 0x00000004) != 0) { output.writeRepeatedUInt32(FieldNames.attributes, attributes); } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRepeatedUInt32(FieldNames.overlockCount, overlockCount); + } output.endObject(); } @@ -1110,6 +1217,17 @@ public final class CharGemRefresh { } break; } + case 1950695472: { + if (input.isAtField(FieldNames.overlockCount)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(overlockCount); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } default: { input.skipUnknownField(); break; @@ -1168,6 +1286,8 @@ public final class CharGemRefresh { static final FieldName nextPackage = FieldName.forField("NextPackage"); static final FieldName attributes = FieldName.forField("Attributes"); + + static final FieldName overlockCount = FieldName.forField("OverlockCount"); } } } diff --git a/src/generated/main/emu/nebula/proto/CharGemUseOverlock.java b/src/generated/main/emu/nebula/proto/CharGemUseOverlock.java new file mode 100644 index 0000000..70e9b6f --- /dev/null +++ b/src/generated/main/emu/nebula/proto/CharGemUseOverlock.java @@ -0,0 +1,623 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.nebula.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.RepeatedByte; + +public final class CharGemUseOverlock { + /** + * Protobuf type {@code CharGemOverlockReq} + */ + public static final class CharGemOverlockReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 CharId = 1; + */ + private int charId; + + /** + * optional uint32 SlotId = 2; + */ + private int slotId; + + /** + * optional uint32 GemIndex = 3; + */ + private int gemIndex; + + /** + * optional uint32 AttrIndex = 4; + */ + private int attrIndex; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + private CharGemOverlockReq() { + } + + /** + * @return a new empty instance of {@code CharGemOverlockReq} + */ + public static CharGemOverlockReq newInstance() { + return new CharGemOverlockReq(); + } + + /** + * optional uint32 CharId = 1; + * @return whether the charId field is set + */ + public boolean hasCharId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 CharId = 1; + * @return this + */ + public CharGemOverlockReq clearCharId() { + bitField0_ &= ~0x00000001; + charId = 0; + return this; + } + + /** + * optional uint32 CharId = 1; + * @return the charId + */ + public int getCharId() { + return charId; + } + + /** + * optional uint32 CharId = 1; + * @param value the charId to set + * @return this + */ + public CharGemOverlockReq setCharId(final int value) { + bitField0_ |= 0x00000001; + charId = value; + return this; + } + + /** + * optional uint32 SlotId = 2; + * @return whether the slotId field is set + */ + public boolean hasSlotId() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 SlotId = 2; + * @return this + */ + public CharGemOverlockReq clearSlotId() { + bitField0_ &= ~0x00000002; + slotId = 0; + return this; + } + + /** + * optional uint32 SlotId = 2; + * @return the slotId + */ + public int getSlotId() { + return slotId; + } + + /** + * optional uint32 SlotId = 2; + * @param value the slotId to set + * @return this + */ + public CharGemOverlockReq setSlotId(final int value) { + bitField0_ |= 0x00000002; + slotId = value; + return this; + } + + /** + * optional uint32 GemIndex = 3; + * @return whether the gemIndex field is set + */ + public boolean hasGemIndex() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 GemIndex = 3; + * @return this + */ + public CharGemOverlockReq clearGemIndex() { + bitField0_ &= ~0x00000004; + gemIndex = 0; + return this; + } + + /** + * optional uint32 GemIndex = 3; + * @return the gemIndex + */ + public int getGemIndex() { + return gemIndex; + } + + /** + * optional uint32 GemIndex = 3; + * @param value the gemIndex to set + * @return this + */ + public CharGemOverlockReq setGemIndex(final int value) { + bitField0_ |= 0x00000004; + gemIndex = value; + return this; + } + + /** + * optional uint32 AttrIndex = 4; + * @return whether the attrIndex field is set + */ + public boolean hasAttrIndex() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional uint32 AttrIndex = 4; + * @return this + */ + public CharGemOverlockReq clearAttrIndex() { + bitField0_ &= ~0x00000008; + attrIndex = 0; + return this; + } + + /** + * optional uint32 AttrIndex = 4; + * @return the attrIndex + */ + public int getAttrIndex() { + return attrIndex; + } + + /** + * optional uint32 AttrIndex = 4; + * @param value the attrIndex to set + * @return this + */ + public CharGemOverlockReq setAttrIndex(final int value) { + bitField0_ |= 0x00000008; + attrIndex = value; + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public CharGemOverlockReq clearNextPackage() { + bitField0_ &= ~0x00000010; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000010; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public CharGemOverlockReq addNextPackage(final byte value) { + bitField0_ |= 0x00000010; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public CharGemOverlockReq addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000010; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public CharGemOverlockReq setNextPackage(final byte... values) { + bitField0_ |= 0x00000010; + nextPackage.copyFrom(values); + return this; + } + + @Override + public CharGemOverlockReq copyFrom(final CharGemOverlockReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + charId = other.charId; + slotId = other.slotId; + gemIndex = other.gemIndex; + attrIndex = other.attrIndex; + nextPackage.copyFrom(other.nextPackage); + } + return this; + } + + @Override + public CharGemOverlockReq mergeFrom(final CharGemOverlockReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasCharId()) { + setCharId(other.charId); + } + if (other.hasSlotId()) { + setSlotId(other.slotId); + } + if (other.hasGemIndex()) { + setGemIndex(other.gemIndex); + } + if (other.hasAttrIndex()) { + setAttrIndex(other.attrIndex); + } + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + return this; + } + + @Override + public CharGemOverlockReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + charId = 0; + slotId = 0; + gemIndex = 0; + attrIndex = 0; + nextPackage.clear(); + return this; + } + + @Override + public CharGemOverlockReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof CharGemOverlockReq)) { + return false; + } + CharGemOverlockReq other = (CharGemOverlockReq) o; + return bitField0_ == other.bitField0_ + && (!hasCharId() || charId == other.charId) + && (!hasSlotId() || slotId == other.slotId) + && (!hasGemIndex() || gemIndex == other.gemIndex) + && (!hasAttrIndex() || attrIndex == other.attrIndex) + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(charId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(slotId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(gemIndex); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(attrIndex); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(charId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(slotId); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(gemIndex); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(attrIndex); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public CharGemOverlockReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // charId + charId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // slotId + slotId = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 24) { + break; + } + } + case 24: { + // gemIndex + gemIndex = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 32) { + break; + } + } + case 32: { + // attrIndex + attrIndex = input.readUInt32(); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 16378) { + break; + } + } + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000010; + 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.charId, charId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.slotId, slotId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.gemIndex, gemIndex); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeUInt32(FieldNames.attrIndex, attrIndex); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + output.endObject(); + } + + @Override + public CharGemOverlockReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 2017200945: { + if (input.isAtField(FieldNames.charId)) { + if (!input.trySkipNullValue()) { + charId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1815586855: { + if (input.isAtField(FieldNames.slotId)) { + if (!input.trySkipNullValue()) { + slotId = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1820411619: { + if (input.isAtField(FieldNames.gemIndex)) { + if (!input.trySkipNullValue()) { + gemIndex = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1987841345: { + if (input.isAtField(FieldNames.attrIndex)) { + if (!input.trySkipNullValue()) { + attrIndex = input.readUInt32(); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public CharGemOverlockReq clone() { + return new CharGemOverlockReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static CharGemOverlockReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new CharGemOverlockReq(), data).checkInitialized(); + } + + public static CharGemOverlockReq parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new CharGemOverlockReq(), input).checkInitialized(); + } + + public static CharGemOverlockReq parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new CharGemOverlockReq(), input).checkInitialized(); + } + + /** + * @return factory for creating CharGemOverlockReq messages + */ + public static MessageFactory getFactory() { + return CharGemOverlockReqFactory.INSTANCE; + } + + private enum CharGemOverlockReqFactory implements MessageFactory { + INSTANCE; + + @Override + public CharGemOverlockReq create() { + return CharGemOverlockReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName charId = FieldName.forField("CharId"); + + static final FieldName slotId = FieldName.forField("SlotId"); + + static final FieldName gemIndex = FieldName.forField("GemIndex"); + + static final FieldName attrIndex = FieldName.forField("AttrIndex"); + + static final FieldName nextPackage = FieldName.forField("NextPackage"); + } + } +} diff --git a/src/generated/main/emu/nebula/proto/CharGemUseOverlockRevert.java b/src/generated/main/emu/nebula/proto/CharGemUseOverlockRevert.java new file mode 100644 index 0000000..2a69fb1 --- /dev/null +++ b/src/generated/main/emu/nebula/proto/CharGemUseOverlockRevert.java @@ -0,0 +1,623 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.nebula.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.RepeatedByte; + +public final class CharGemUseOverlockRevert { + /** + * Protobuf type {@code CharGemOverlockRevertReq} + */ + public static final class CharGemOverlockRevertReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 CharId = 1; + */ + private int charId; + + /** + * optional uint32 SlotId = 2; + */ + private int slotId; + + /** + * optional uint32 GemIndex = 3; + */ + private int gemIndex; + + /** + * optional uint32 AttrIndex = 4; + */ + private int attrIndex; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + private CharGemOverlockRevertReq() { + } + + /** + * @return a new empty instance of {@code CharGemOverlockRevertReq} + */ + public static CharGemOverlockRevertReq newInstance() { + return new CharGemOverlockRevertReq(); + } + + /** + * optional uint32 CharId = 1; + * @return whether the charId field is set + */ + public boolean hasCharId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 CharId = 1; + * @return this + */ + public CharGemOverlockRevertReq clearCharId() { + bitField0_ &= ~0x00000001; + charId = 0; + return this; + } + + /** + * optional uint32 CharId = 1; + * @return the charId + */ + public int getCharId() { + return charId; + } + + /** + * optional uint32 CharId = 1; + * @param value the charId to set + * @return this + */ + public CharGemOverlockRevertReq setCharId(final int value) { + bitField0_ |= 0x00000001; + charId = value; + return this; + } + + /** + * optional uint32 SlotId = 2; + * @return whether the slotId field is set + */ + public boolean hasSlotId() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 SlotId = 2; + * @return this + */ + public CharGemOverlockRevertReq clearSlotId() { + bitField0_ &= ~0x00000002; + slotId = 0; + return this; + } + + /** + * optional uint32 SlotId = 2; + * @return the slotId + */ + public int getSlotId() { + return slotId; + } + + /** + * optional uint32 SlotId = 2; + * @param value the slotId to set + * @return this + */ + public CharGemOverlockRevertReq setSlotId(final int value) { + bitField0_ |= 0x00000002; + slotId = value; + return this; + } + + /** + * optional uint32 GemIndex = 3; + * @return whether the gemIndex field is set + */ + public boolean hasGemIndex() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 GemIndex = 3; + * @return this + */ + public CharGemOverlockRevertReq clearGemIndex() { + bitField0_ &= ~0x00000004; + gemIndex = 0; + return this; + } + + /** + * optional uint32 GemIndex = 3; + * @return the gemIndex + */ + public int getGemIndex() { + return gemIndex; + } + + /** + * optional uint32 GemIndex = 3; + * @param value the gemIndex to set + * @return this + */ + public CharGemOverlockRevertReq setGemIndex(final int value) { + bitField0_ |= 0x00000004; + gemIndex = value; + return this; + } + + /** + * optional uint32 AttrIndex = 4; + * @return whether the attrIndex field is set + */ + public boolean hasAttrIndex() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional uint32 AttrIndex = 4; + * @return this + */ + public CharGemOverlockRevertReq clearAttrIndex() { + bitField0_ &= ~0x00000008; + attrIndex = 0; + return this; + } + + /** + * optional uint32 AttrIndex = 4; + * @return the attrIndex + */ + public int getAttrIndex() { + return attrIndex; + } + + /** + * optional uint32 AttrIndex = 4; + * @param value the attrIndex to set + * @return this + */ + public CharGemOverlockRevertReq setAttrIndex(final int value) { + bitField0_ |= 0x00000008; + attrIndex = value; + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public CharGemOverlockRevertReq clearNextPackage() { + bitField0_ &= ~0x00000010; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000010; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public CharGemOverlockRevertReq addNextPackage(final byte value) { + bitField0_ |= 0x00000010; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public CharGemOverlockRevertReq addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000010; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public CharGemOverlockRevertReq setNextPackage(final byte... values) { + bitField0_ |= 0x00000010; + nextPackage.copyFrom(values); + return this; + } + + @Override + public CharGemOverlockRevertReq copyFrom(final CharGemOverlockRevertReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + charId = other.charId; + slotId = other.slotId; + gemIndex = other.gemIndex; + attrIndex = other.attrIndex; + nextPackage.copyFrom(other.nextPackage); + } + return this; + } + + @Override + public CharGemOverlockRevertReq mergeFrom(final CharGemOverlockRevertReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasCharId()) { + setCharId(other.charId); + } + if (other.hasSlotId()) { + setSlotId(other.slotId); + } + if (other.hasGemIndex()) { + setGemIndex(other.gemIndex); + } + if (other.hasAttrIndex()) { + setAttrIndex(other.attrIndex); + } + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + return this; + } + + @Override + public CharGemOverlockRevertReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + charId = 0; + slotId = 0; + gemIndex = 0; + attrIndex = 0; + nextPackage.clear(); + return this; + } + + @Override + public CharGemOverlockRevertReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof CharGemOverlockRevertReq)) { + return false; + } + CharGemOverlockRevertReq other = (CharGemOverlockRevertReq) o; + return bitField0_ == other.bitField0_ + && (!hasCharId() || charId == other.charId) + && (!hasSlotId() || slotId == other.slotId) + && (!hasGemIndex() || gemIndex == other.gemIndex) + && (!hasAttrIndex() || attrIndex == other.attrIndex) + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(charId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(slotId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(gemIndex); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(attrIndex); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(charId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(slotId); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(gemIndex); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(attrIndex); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public CharGemOverlockRevertReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // charId + charId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // slotId + slotId = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 24) { + break; + } + } + case 24: { + // gemIndex + gemIndex = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 32) { + break; + } + } + case 32: { + // attrIndex + attrIndex = input.readUInt32(); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 16378) { + break; + } + } + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000010; + 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.charId, charId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.slotId, slotId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.gemIndex, gemIndex); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeUInt32(FieldNames.attrIndex, attrIndex); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + output.endObject(); + } + + @Override + public CharGemOverlockRevertReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 2017200945: { + if (input.isAtField(FieldNames.charId)) { + if (!input.trySkipNullValue()) { + charId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1815586855: { + if (input.isAtField(FieldNames.slotId)) { + if (!input.trySkipNullValue()) { + slotId = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1820411619: { + if (input.isAtField(FieldNames.gemIndex)) { + if (!input.trySkipNullValue()) { + gemIndex = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1987841345: { + if (input.isAtField(FieldNames.attrIndex)) { + if (!input.trySkipNullValue()) { + attrIndex = input.readUInt32(); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public CharGemOverlockRevertReq clone() { + return new CharGemOverlockRevertReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static CharGemOverlockRevertReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new CharGemOverlockRevertReq(), data).checkInitialized(); + } + + public static CharGemOverlockRevertReq parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new CharGemOverlockRevertReq(), input).checkInitialized(); + } + + public static CharGemOverlockRevertReq parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new CharGemOverlockRevertReq(), input).checkInitialized(); + } + + /** + * @return factory for creating CharGemOverlockRevertReq messages + */ + public static MessageFactory getFactory() { + return CharGemOverlockRevertReqFactory.INSTANCE; + } + + private enum CharGemOverlockRevertReqFactory implements MessageFactory { + INSTANCE; + + @Override + public CharGemOverlockRevertReq create() { + return CharGemOverlockRevertReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName charId = FieldName.forField("CharId"); + + static final FieldName slotId = FieldName.forField("SlotId"); + + static final FieldName gemIndex = FieldName.forField("GemIndex"); + + static final FieldName attrIndex = FieldName.forField("AttrIndex"); + + static final FieldName nextPackage = FieldName.forField("NextPackage"); + } + } +} diff --git a/src/generated/main/emu/nebula/proto/JointDrillRank.java b/src/generated/main/emu/nebula/proto/JointDrillRank.java index 931423c..1d3b738 100644 --- a/src/generated/main/emu/nebula/proto/JointDrillRank.java +++ b/src/generated/main/emu/nebula/proto/JointDrillRank.java @@ -11,6 +11,7 @@ import us.hebi.quickbuf.ProtoMessage; import us.hebi.quickbuf.ProtoSink; import us.hebi.quickbuf.ProtoSource; import us.hebi.quickbuf.RepeatedByte; +import us.hebi.quickbuf.RepeatedInt; import us.hebi.quickbuf.RepeatedMessage; import us.hebi.quickbuf.Utf8String; @@ -1151,11 +1152,31 @@ public final class JointDrillRank { */ private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + /** + * repeated uint32 Discs = 5; + */ + private final RepeatedInt discs = RepeatedInt.newEmptyInstance(); + + /** + * repeated uint32 ActiveSecondaryIds = 8; + */ + private final RepeatedInt activeSecondaryIds = RepeatedInt.newEmptyInstance(); + /** * repeated .JointDrillRankChar Chars = 1; */ private final RepeatedMessage chars = RepeatedMessage.newEmptyInstance(JointDrillRankChar.getFactory()); + /** + * repeated .BuildPotential Potentials = 6; + */ + private final RepeatedMessage potentials = RepeatedMessage.newEmptyInstance(PublicStarTower.BuildPotential.getFactory()); + + /** + * repeated .ItemTpl Notes = 7; + */ + private final RepeatedMessage notes = RepeatedMessage.newEmptyInstance(Public.ItemTpl.getFactory()); + private JointDrillRankTeam() { } @@ -1356,12 +1377,148 @@ public final class JointDrillRank { return this; } + /** + * repeated uint32 Discs = 5; + * @return whether the discs field is set + */ + public boolean hasDiscs() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * repeated uint32 Discs = 5; + * @return this + */ + public JointDrillRankTeam clearDiscs() { + bitField0_ &= ~0x00000010; + discs.clear(); + return this; + } + + /** + * repeated uint32 Discs = 5; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableDiscs()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getDiscs() { + return discs; + } + + /** + * repeated uint32 Discs = 5; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableDiscs() { + bitField0_ |= 0x00000010; + return discs; + } + + /** + * repeated uint32 Discs = 5; + * @param value the discs to add + * @return this + */ + public JointDrillRankTeam addDiscs(final int value) { + bitField0_ |= 0x00000010; + discs.add(value); + return this; + } + + /** + * repeated uint32 Discs = 5; + * @param values the discs to add + * @return this + */ + public JointDrillRankTeam addAllDiscs(final int... values) { + bitField0_ |= 0x00000010; + discs.addAll(values); + return this; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * @return whether the activeSecondaryIds field is set + */ + public boolean hasActiveSecondaryIds() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * @return this + */ + public JointDrillRankTeam clearActiveSecondaryIds() { + bitField0_ &= ~0x00000020; + activeSecondaryIds.clear(); + return this; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableActiveSecondaryIds()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getActiveSecondaryIds() { + return activeSecondaryIds; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableActiveSecondaryIds() { + bitField0_ |= 0x00000020; + return activeSecondaryIds; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * @param value the activeSecondaryIds to add + * @return this + */ + public JointDrillRankTeam addActiveSecondaryIds(final int value) { + bitField0_ |= 0x00000020; + activeSecondaryIds.add(value); + return this; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * @param values the activeSecondaryIds to add + * @return this + */ + public JointDrillRankTeam addAllActiveSecondaryIds(final int... values) { + bitField0_ |= 0x00000020; + activeSecondaryIds.addAll(values); + return this; + } + /** * repeated .JointDrillRankChar Chars = 1; * @return whether the chars field is set */ public boolean hasChars() { - return (bitField0_ & 0x00000010) != 0; + return (bitField0_ & 0x00000040) != 0; } /** @@ -1369,7 +1526,7 @@ public final class JointDrillRank { * @return this */ public JointDrillRankTeam clearChars() { - bitField0_ &= ~0x00000010; + bitField0_ &= ~0x00000040; chars.clear(); return this; } @@ -1398,7 +1555,7 @@ public final class JointDrillRank { * @return internal storage object for modifications */ public RepeatedMessage getMutableChars() { - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000040; return chars; } @@ -1408,7 +1565,7 @@ public final class JointDrillRank { * @return this */ public JointDrillRankTeam addChars(final JointDrillRankChar value) { - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000040; chars.add(value); return this; } @@ -1419,11 +1576,147 @@ public final class JointDrillRank { * @return this */ public JointDrillRankTeam addAllChars(final JointDrillRankChar... values) { - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000040; chars.addAll(values); return this; } + /** + * repeated .BuildPotential Potentials = 6; + * @return whether the potentials field is set + */ + public boolean hasPotentials() { + return (bitField0_ & 0x00000080) != 0; + } + + /** + * repeated .BuildPotential Potentials = 6; + * @return this + */ + public JointDrillRankTeam clearPotentials() { + bitField0_ &= ~0x00000080; + potentials.clear(); + return this; + } + + /** + * repeated .BuildPotential Potentials = 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 #getMutablePotentials()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getPotentials() { + return potentials; + } + + /** + * repeated .BuildPotential Potentials = 6; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutablePotentials() { + bitField0_ |= 0x00000080; + return potentials; + } + + /** + * repeated .BuildPotential Potentials = 6; + * @param value the potentials to add + * @return this + */ + public JointDrillRankTeam addPotentials(final PublicStarTower.BuildPotential value) { + bitField0_ |= 0x00000080; + potentials.add(value); + return this; + } + + /** + * repeated .BuildPotential Potentials = 6; + * @param values the potentials to add + * @return this + */ + public JointDrillRankTeam addAllPotentials(final PublicStarTower.BuildPotential... values) { + bitField0_ |= 0x00000080; + potentials.addAll(values); + return this; + } + + /** + * repeated .ItemTpl Notes = 7; + * @return whether the notes field is set + */ + public boolean hasNotes() { + return (bitField0_ & 0x00000100) != 0; + } + + /** + * repeated .ItemTpl Notes = 7; + * @return this + */ + public JointDrillRankTeam clearNotes() { + bitField0_ &= ~0x00000100; + notes.clear(); + return this; + } + + /** + * repeated .ItemTpl Notes = 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 #getMutableNotes()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getNotes() { + return notes; + } + + /** + * repeated .ItemTpl Notes = 7; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableNotes() { + bitField0_ |= 0x00000100; + return notes; + } + + /** + * repeated .ItemTpl Notes = 7; + * @param value the notes to add + * @return this + */ + public JointDrillRankTeam addNotes(final Public.ItemTpl value) { + bitField0_ |= 0x00000100; + notes.add(value); + return this; + } + + /** + * repeated .ItemTpl Notes = 7; + * @param values the notes to add + * @return this + */ + public JointDrillRankTeam addAllNotes(final Public.ItemTpl... values) { + bitField0_ |= 0x00000100; + notes.addAll(values); + return this; + } + @Override public JointDrillRankTeam copyFrom(final JointDrillRankTeam other) { cachedSize = other.cachedSize; @@ -1433,7 +1726,11 @@ public final class JointDrillRank { damage = other.damage; time = other.time; nextPackage.copyFrom(other.nextPackage); + discs.copyFrom(other.discs); + activeSecondaryIds.copyFrom(other.activeSecondaryIds); chars.copyFrom(other.chars); + potentials.copyFrom(other.potentials); + notes.copyFrom(other.notes); } return this; } @@ -1456,9 +1753,21 @@ public final class JointDrillRank { if (other.hasNextPackage()) { getMutableNextPackage().copyFrom(other.nextPackage); } + if (other.hasDiscs()) { + getMutableDiscs().addAll(other.discs); + } + if (other.hasActiveSecondaryIds()) { + getMutableActiveSecondaryIds().addAll(other.activeSecondaryIds); + } if (other.hasChars()) { getMutableChars().addAll(other.chars); } + if (other.hasPotentials()) { + getMutablePotentials().addAll(other.potentials); + } + if (other.hasNotes()) { + getMutableNotes().addAll(other.notes); + } return this; } @@ -1473,7 +1782,11 @@ public final class JointDrillRank { damage = 0; time = 0; nextPackage.clear(); + discs.clear(); + activeSecondaryIds.clear(); chars.clear(); + potentials.clear(); + notes.clear(); return this; } @@ -1485,7 +1798,11 @@ public final class JointDrillRank { cachedSize = -1; bitField0_ = 0; nextPackage.clear(); + discs.clear(); + activeSecondaryIds.clear(); chars.clearQuick(); + potentials.clearQuick(); + notes.clearQuick(); return this; } @@ -1503,7 +1820,11 @@ public final class JointDrillRank { && (!hasDamage() || damage == other.damage) && (!hasTime() || time == other.time) && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) - && (!hasChars() || chars.equals(other.chars)); + && (!hasDiscs() || discs.equals(other.discs)) + && (!hasActiveSecondaryIds() || activeSecondaryIds.equals(other.activeSecondaryIds)) + && (!hasChars() || chars.equals(other.chars)) + && (!hasPotentials() || potentials.equals(other.potentials)) + && (!hasNotes() || notes.equals(other.notes)); } @Override @@ -1525,11 +1846,35 @@ public final class JointDrillRank { output.writeBytesNoTag(nextPackage); } if ((bitField0_ & 0x00000010) != 0) { + for (int i = 0; i < discs.length(); i++) { + output.writeRawByte((byte) 40); + output.writeUInt32NoTag(discs.array()[i]); + } + } + if ((bitField0_ & 0x00000020) != 0) { + for (int i = 0; i < activeSecondaryIds.length(); i++) { + output.writeRawByte((byte) 64); + output.writeUInt32NoTag(activeSecondaryIds.array()[i]); + } + } + if ((bitField0_ & 0x00000040) != 0) { for (int i = 0; i < chars.length(); i++) { output.writeRawByte((byte) 10); output.writeMessageNoTag(chars.get(i)); } } + if ((bitField0_ & 0x00000080) != 0) { + for (int i = 0; i < potentials.length(); i++) { + output.writeRawByte((byte) 50); + output.writeMessageNoTag(potentials.get(i)); + } + } + if ((bitField0_ & 0x00000100) != 0) { + for (int i = 0; i < notes.length(); i++) { + output.writeRawByte((byte) 58); + output.writeMessageNoTag(notes.get(i)); + } + } } @Override @@ -1548,8 +1893,20 @@ public final class JointDrillRank { size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); } if ((bitField0_ & 0x00000010) != 0) { + size += (1 * discs.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(discs); + } + if ((bitField0_ & 0x00000020) != 0) { + size += (1 * activeSecondaryIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(activeSecondaryIds); + } + if ((bitField0_ & 0x00000040) != 0) { size += (1 * chars.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(chars); } + if ((bitField0_ & 0x00000080) != 0) { + size += (1 * potentials.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(potentials); + } + if ((bitField0_ & 0x00000100) != 0) { + size += (1 * notes.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(notes); + } return size; } @@ -1592,6 +1949,24 @@ public final class JointDrillRank { input.readBytes(nextPackage); bitField0_ |= 0x00000008; tag = input.readTag(); + if (tag != 42) { + break; + } + } + case 42: { + // discs [packed=true] + input.readPackedUInt32(discs, tag); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 66) { + break; + } + } + case 66: { + // activeSecondaryIds [packed=true] + input.readPackedUInt32(activeSecondaryIds, tag); + bitField0_ |= 0x00000020; + tag = input.readTag(); if (tag != 10) { break; } @@ -1599,7 +1974,23 @@ public final class JointDrillRank { case 10: { // chars tag = input.readRepeatedMessage(chars, tag); - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000040; + if (tag != 50) { + break; + } + } + case 50: { + // potentials + tag = input.readRepeatedMessage(potentials, tag); + bitField0_ |= 0x00000080; + if (tag != 58) { + break; + } + } + case 58: { + // notes + tag = input.readRepeatedMessage(notes, tag); + bitField0_ |= 0x00000100; if (tag != 0) { break; } @@ -1614,6 +2005,18 @@ public final class JointDrillRank { tag = input.readTag(); break; } + case 40: { + // discs [packed=false] + tag = input.readRepeatedUInt32(discs, tag); + bitField0_ |= 0x00000010; + break; + } + case 64: { + // activeSecondaryIds [packed=false] + tag = input.readRepeatedUInt32(activeSecondaryIds, tag); + bitField0_ |= 0x00000020; + break; + } } } } @@ -1634,8 +2037,20 @@ public final class JointDrillRank { output.writeBytes(FieldNames.nextPackage, nextPackage); } if ((bitField0_ & 0x00000010) != 0) { + output.writeRepeatedUInt32(FieldNames.discs, discs); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRepeatedUInt32(FieldNames.activeSecondaryIds, activeSecondaryIds); + } + if ((bitField0_ & 0x00000040) != 0) { output.writeRepeatedMessage(FieldNames.chars, chars); } + if ((bitField0_ & 0x00000080) != 0) { + output.writeRepeatedMessage(FieldNames.potentials, potentials); + } + if ((bitField0_ & 0x00000100) != 0) { + output.writeRepeatedMessage(FieldNames.notes, notes); + } output.endObject(); } @@ -1690,11 +2105,55 @@ public final class JointDrillRank { } break; } + case 66041182: { + if (input.isAtField(FieldNames.discs)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(discs); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1499070186: { + if (input.isAtField(FieldNames.activeSecondaryIds)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(activeSecondaryIds); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } case 65071037: { if (input.isAtField(FieldNames.chars)) { if (!input.trySkipNullValue()) { input.readRepeatedMessage(chars); - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000040; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1405493301: { + if (input.isAtField(FieldNames.potentials)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(potentials); + bitField0_ |= 0x00000080; + } + } else { + input.skipUnknownField(); + } + break; + } + case 75456161: { + if (input.isAtField(FieldNames.notes)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(notes); + bitField0_ |= 0x00000100; } } else { input.skipUnknownField(); @@ -1762,7 +2221,15 @@ public final class JointDrillRank { static final FieldName nextPackage = FieldName.forField("NextPackage"); + static final FieldName discs = FieldName.forField("Discs"); + + static final FieldName activeSecondaryIds = FieldName.forField("ActiveSecondaryIds"); + static final FieldName chars = FieldName.forField("Chars"); + + static final FieldName potentials = FieldName.forField("Potentials"); + + static final FieldName notes = FieldName.forField("Notes"); } } @@ -2948,4 +3415,405 @@ public final class JointDrillRank { static final FieldName teams = FieldName.forField("Teams"); } } + + /** + * Protobuf type {@code JointDrillRankTeams} + */ + public static final class JointDrillRankTeams extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + /** + * repeated .JointDrillRankTeam Teams = 1; + */ + private final RepeatedMessage teams = RepeatedMessage.newEmptyInstance(JointDrillRankTeam.getFactory()); + + private JointDrillRankTeams() { + } + + /** + * @return a new empty instance of {@code JointDrillRankTeams} + */ + public static JointDrillRankTeams newInstance() { + return new JointDrillRankTeams(); + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public JointDrillRankTeams clearNextPackage() { + bitField0_ &= ~0x00000001; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000001; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public JointDrillRankTeams addNextPackage(final byte value) { + bitField0_ |= 0x00000001; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public JointDrillRankTeams addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public JointDrillRankTeams setNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.copyFrom(values); + return this; + } + + /** + * repeated .JointDrillRankTeam Teams = 1; + * @return whether the teams field is set + */ + public boolean hasTeams() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated .JointDrillRankTeam Teams = 1; + * @return this + */ + public JointDrillRankTeams clearTeams() { + bitField0_ &= ~0x00000002; + teams.clear(); + return this; + } + + /** + * repeated .JointDrillRankTeam Teams = 1; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableTeams()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getTeams() { + return teams; + } + + /** + * repeated .JointDrillRankTeam Teams = 1; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableTeams() { + bitField0_ |= 0x00000002; + return teams; + } + + /** + * repeated .JointDrillRankTeam Teams = 1; + * @param value the teams to add + * @return this + */ + public JointDrillRankTeams addTeams(final JointDrillRankTeam value) { + bitField0_ |= 0x00000002; + teams.add(value); + return this; + } + + /** + * repeated .JointDrillRankTeam Teams = 1; + * @param values the teams to add + * @return this + */ + public JointDrillRankTeams addAllTeams(final JointDrillRankTeam... values) { + bitField0_ |= 0x00000002; + teams.addAll(values); + return this; + } + + @Override + public JointDrillRankTeams copyFrom(final JointDrillRankTeams other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + nextPackage.copyFrom(other.nextPackage); + teams.copyFrom(other.teams); + } + return this; + } + + @Override + public JointDrillRankTeams mergeFrom(final JointDrillRankTeams other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + if (other.hasTeams()) { + getMutableTeams().addAll(other.teams); + } + return this; + } + + @Override + public JointDrillRankTeams clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + teams.clear(); + return this; + } + + @Override + public JointDrillRankTeams clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + teams.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof JointDrillRankTeams)) { + return false; + } + JointDrillRankTeams other = (JointDrillRankTeams) o; + return bitField0_ == other.bitField0_ + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) + && (!hasTeams() || teams.equals(other.teams)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < teams.length(); i++) { + output.writeRawByte((byte) 10); + output.writeMessageNoTag(teams.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * teams.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(teams); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public JointDrillRankTeams mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 10) { + break; + } + } + case 10: { + // teams + tag = input.readRepeatedMessage(teams, tag); + bitField0_ |= 0x00000002; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedMessage(FieldNames.teams, teams); + } + output.endObject(); + } + + @Override + public JointDrillRankTeams mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 80681366: { + if (input.isAtField(FieldNames.teams)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(teams); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public JointDrillRankTeams clone() { + return new JointDrillRankTeams().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static JointDrillRankTeams parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new JointDrillRankTeams(), data).checkInitialized(); + } + + public static JointDrillRankTeams parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new JointDrillRankTeams(), input).checkInitialized(); + } + + public static JointDrillRankTeams parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new JointDrillRankTeams(), input).checkInitialized(); + } + + /** + * @return factory for creating JointDrillRankTeams messages + */ + public static MessageFactory getFactory() { + return JointDrillRankTeamsFactory.INSTANCE; + } + + private enum JointDrillRankTeamsFactory implements MessageFactory { + INSTANCE; + + @Override + public JointDrillRankTeams create() { + return JointDrillRankTeams.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName nextPackage = FieldName.forField("NextPackage"); + + static final FieldName teams = FieldName.forField("Teams"); + } + } } diff --git a/src/generated/main/emu/nebula/proto/PlayerData.java b/src/generated/main/emu/nebula/proto/PlayerData.java index 1e55381..ccec768 100644 --- a/src/generated/main/emu/nebula/proto/PlayerData.java +++ b/src/generated/main/emu/nebula/proto/PlayerData.java @@ -258,6 +258,11 @@ public final class PlayerData { */ private final RepeatedMessage assists = RepeatedMessage.newEmptyInstance(AssistInfo.getFactory()); + /** + * repeated .ActivityHonor ActivityHonors = 41; + */ + private final RepeatedMessage activityHonors = RepeatedMessage.newEmptyInstance(Public.ActivityHonor.getFactory()); + /** * repeated .HonorInfo Honors = 124; */ @@ -3029,12 +3034,80 @@ public final class PlayerData { return this; } + /** + * repeated .ActivityHonor ActivityHonors = 41; + * @return whether the activityHonors field is set + */ + public boolean hasActivityHonors() { + return (bitField1_ & 0x00008000) != 0; + } + + /** + * repeated .ActivityHonor ActivityHonors = 41; + * @return this + */ + public PlayerInfo clearActivityHonors() { + bitField1_ &= ~0x00008000; + activityHonors.clear(); + return this; + } + + /** + * repeated .ActivityHonor ActivityHonors = 41; + * + * 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 #getMutableActivityHonors()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getActivityHonors() { + return activityHonors; + } + + /** + * repeated .ActivityHonor ActivityHonors = 41; + * + * 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 getMutableActivityHonors() { + bitField1_ |= 0x00008000; + return activityHonors; + } + + /** + * repeated .ActivityHonor ActivityHonors = 41; + * @param value the activityHonors to add + * @return this + */ + public PlayerInfo addActivityHonors(final Public.ActivityHonor value) { + bitField1_ |= 0x00008000; + activityHonors.add(value); + return this; + } + + /** + * repeated .ActivityHonor ActivityHonors = 41; + * @param values the activityHonors to add + * @return this + */ + public PlayerInfo addAllActivityHonors(final Public.ActivityHonor... values) { + bitField1_ |= 0x00008000; + activityHonors.addAll(values); + return this; + } + /** * repeated .HonorInfo Honors = 124; * @return whether the honors field is set */ public boolean hasHonors() { - return (bitField1_ & 0x00008000) != 0; + return (bitField1_ & 0x00010000) != 0; } /** @@ -3042,7 +3115,7 @@ public final class PlayerData { * @return this */ public PlayerInfo clearHonors() { - bitField1_ &= ~0x00008000; + bitField1_ &= ~0x00010000; honors.clear(); return this; } @@ -3071,7 +3144,7 @@ public final class PlayerData { * @return internal storage object for modifications */ public RepeatedMessage getMutableHonors() { - bitField1_ |= 0x00008000; + bitField1_ |= 0x00010000; return honors; } @@ -3081,7 +3154,7 @@ public final class PlayerData { * @return this */ public PlayerInfo addHonors(final Public.HonorInfo value) { - bitField1_ |= 0x00008000; + bitField1_ |= 0x00010000; honors.add(value); return this; } @@ -3092,7 +3165,7 @@ public final class PlayerData { * @return this */ public PlayerInfo addAllHonors(final Public.HonorInfo... values) { - bitField1_ |= 0x00008000; + bitField1_ |= 0x00010000; honors.addAll(values); return this; } @@ -3152,6 +3225,7 @@ public final class PlayerData { charGemInstances.copyFrom(other.charGemInstances); tutorialLevels.copyFrom(other.tutorialLevels); assists.copyFrom(other.assists); + activityHonors.copyFrom(other.activityHonors); honors.copyFrom(other.honors); } return this; @@ -3304,6 +3378,9 @@ public final class PlayerData { if (other.hasAssists()) { getMutableAssists().addAll(other.assists); } + if (other.hasActivityHonors()) { + getMutableActivityHonors().addAll(other.activityHonors); + } if (other.hasHonors()) { getMutableHonors().addAll(other.honors); } @@ -3365,6 +3442,7 @@ public final class PlayerData { charGemInstances.clear(); tutorialLevels.clear(); assists.clear(); + activityHonors.clear(); honors.clear(); return this; } @@ -3413,6 +3491,7 @@ public final class PlayerData { charGemInstances.clearQuick(); tutorialLevels.clearQuick(); assists.clearQuick(); + activityHonors.clearQuick(); honors.clearQuick(); return this; } @@ -3475,6 +3554,7 @@ public final class PlayerData { && (!hasCharGemInstances() || charGemInstances.equals(other.charGemInstances)) && (!hasTutorialLevels() || tutorialLevels.equals(other.tutorialLevels)) && (!hasAssists() || assists.equals(other.assists)) + && (!hasActivityHonors() || activityHonors.equals(other.activityHonors)) && (!hasHonors() || honors.equals(other.honors)); } @@ -3715,6 +3795,12 @@ public final class PlayerData { } } if ((bitField1_ & 0x00008000) != 0) { + for (int i = 0; i < activityHonors.length(); i++) { + output.writeRawLittleEndian16((short) 714); + output.writeMessageNoTag(activityHonors.get(i)); + } + } + if ((bitField1_ & 0x00010000) != 0) { for (int i = 0; i < honors.length(); i++) { output.writeRawLittleEndian16((short) 2018); output.writeMessageNoTag(honors.get(i)); @@ -3867,6 +3953,9 @@ public final class PlayerData { size += (2 * assists.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(assists); } if ((bitField1_ & 0x00008000) != 0) { + size += (2 * activityHonors.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(activityHonors); + } + if ((bitField1_ & 0x00010000) != 0) { size += (2 * honors.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(honors); } return size; @@ -4281,6 +4370,14 @@ public final class PlayerData { // assists tag = input.readRepeatedMessage(assists, tag); bitField1_ |= 0x00004000; + if (tag != 330) { + break; + } + } + case 330: { + // activityHonors + tag = input.readRepeatedMessage(activityHonors, tag); + bitField1_ |= 0x00008000; if (tag != 994) { break; } @@ -4288,7 +4385,7 @@ public final class PlayerData { case 994: { // honors tag = input.readRepeatedMessage(honors, tag); - bitField1_ |= 0x00008000; + bitField1_ |= 0x00010000; if (tag != 0) { break; } @@ -4488,6 +4585,9 @@ public final class PlayerData { output.writeRepeatedMessage(FieldNames.assists, assists); } if ((bitField1_ & 0x00008000) != 0) { + output.writeRepeatedMessage(FieldNames.activityHonors, activityHonors); + } + if ((bitField1_ & 0x00010000) != 0) { output.writeRepeatedMessage(FieldNames.honors, honors); } output.endObject(); @@ -5017,11 +5117,22 @@ public final class PlayerData { } break; } + case 574276952: { + if (input.isAtField(FieldNames.activityHonors)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(activityHonors); + bitField1_ |= 0x00008000; + } + } else { + input.skipUnknownField(); + } + break; + } case -2127770263: { if (input.isAtField(FieldNames.honors)) { if (!input.trySkipNullValue()) { input.readRepeatedMessage(honors); - bitField1_ |= 0x00008000; + bitField1_ |= 0x00010000; } } else { input.skipUnknownField(); @@ -5174,6 +5285,8 @@ public final class PlayerData { static final FieldName assists = FieldName.forField("Assists"); + static final FieldName activityHonors = FieldName.forField("ActivityHonors"); + static final FieldName honors = FieldName.forField("Honors"); } } diff --git a/src/generated/main/emu/nebula/proto/PotentialPreselectionDelete.java b/src/generated/main/emu/nebula/proto/PotentialPreselectionDelete.java new file mode 100644 index 0000000..cb7aa9d --- /dev/null +++ b/src/generated/main/emu/nebula/proto/PotentialPreselectionDelete.java @@ -0,0 +1,426 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.nebula.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.RepeatedByte; +import us.hebi.quickbuf.RepeatedLong; + +public final class PotentialPreselectionDelete { + /** + * Protobuf type {@code PotentialPreselectionDeleteReq} + */ + public static final class PotentialPreselectionDeleteReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + /** + * repeated uint64 Ids = 1; + */ + private final RepeatedLong ids = RepeatedLong.newEmptyInstance(); + + private PotentialPreselectionDeleteReq() { + } + + /** + * @return a new empty instance of {@code PotentialPreselectionDeleteReq} + */ + public static PotentialPreselectionDeleteReq newInstance() { + return new PotentialPreselectionDeleteReq(); + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public PotentialPreselectionDeleteReq clearNextPackage() { + bitField0_ &= ~0x00000001; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000001; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public PotentialPreselectionDeleteReq addNextPackage(final byte value) { + bitField0_ |= 0x00000001; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public PotentialPreselectionDeleteReq addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public PotentialPreselectionDeleteReq setNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.copyFrom(values); + return this; + } + + /** + * repeated uint64 Ids = 1; + * @return whether the ids field is set + */ + public boolean hasIds() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated uint64 Ids = 1; + * @return this + */ + public PotentialPreselectionDeleteReq clearIds() { + bitField0_ &= ~0x00000002; + ids.clear(); + return this; + } + + /** + * repeated uint64 Ids = 1; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableIds()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedLong getIds() { + return ids; + } + + /** + * repeated uint64 Ids = 1; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedLong getMutableIds() { + bitField0_ |= 0x00000002; + return ids; + } + + /** + * repeated uint64 Ids = 1; + * @param value the ids to add + * @return this + */ + public PotentialPreselectionDeleteReq addIds(final long value) { + bitField0_ |= 0x00000002; + ids.add(value); + return this; + } + + /** + * repeated uint64 Ids = 1; + * @param values the ids to add + * @return this + */ + public PotentialPreselectionDeleteReq addAllIds(final long... values) { + bitField0_ |= 0x00000002; + ids.addAll(values); + return this; + } + + @Override + public PotentialPreselectionDeleteReq copyFrom(final PotentialPreselectionDeleteReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + nextPackage.copyFrom(other.nextPackage); + ids.copyFrom(other.ids); + } + return this; + } + + @Override + public PotentialPreselectionDeleteReq mergeFrom(final PotentialPreselectionDeleteReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + if (other.hasIds()) { + getMutableIds().addAll(other.ids); + } + return this; + } + + @Override + public PotentialPreselectionDeleteReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + ids.clear(); + return this; + } + + @Override + public PotentialPreselectionDeleteReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + ids.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof PotentialPreselectionDeleteReq)) { + return false; + } + PotentialPreselectionDeleteReq other = (PotentialPreselectionDeleteReq) o; + return bitField0_ == other.bitField0_ + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) + && (!hasIds() || ids.equals(other.ids)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < ids.length(); i++) { + output.writeRawByte((byte) 8); + output.writeUInt64NoTag(ids.array()[i]); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * ids.length()) + ProtoSink.computeRepeatedUInt64SizeNoTag(ids); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public PotentialPreselectionDeleteReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 10) { + break; + } + } + case 10: { + // ids [packed=true] + input.readPackedUInt64(ids, tag); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + case 8: { + // ids [packed=false] + tag = input.readRepeatedUInt64(ids, tag); + bitField0_ |= 0x00000002; + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedUInt64(FieldNames.ids, ids); + } + output.endObject(); + } + + @Override + public PotentialPreselectionDeleteReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 73368: { + if (input.isAtField(FieldNames.ids)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt64(ids); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public PotentialPreselectionDeleteReq clone() { + return new PotentialPreselectionDeleteReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static PotentialPreselectionDeleteReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new PotentialPreselectionDeleteReq(), data).checkInitialized(); + } + + public static PotentialPreselectionDeleteReq parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionDeleteReq(), input).checkInitialized(); + } + + public static PotentialPreselectionDeleteReq parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionDeleteReq(), input).checkInitialized(); + } + + /** + * @return factory for creating PotentialPreselectionDeleteReq messages + */ + public static MessageFactory getFactory() { + return PotentialPreselectionDeleteReqFactory.INSTANCE; + } + + private enum PotentialPreselectionDeleteReqFactory implements MessageFactory { + INSTANCE; + + @Override + public PotentialPreselectionDeleteReq create() { + return PotentialPreselectionDeleteReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName nextPackage = FieldName.forField("NextPackage"); + + static final FieldName ids = FieldName.forField("Ids"); + } + } +} diff --git a/src/generated/main/emu/nebula/proto/PotentialPreselectionImport.java b/src/generated/main/emu/nebula/proto/PotentialPreselectionImport.java new file mode 100644 index 0000000..8822114 --- /dev/null +++ b/src/generated/main/emu/nebula/proto/PotentialPreselectionImport.java @@ -0,0 +1,611 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.nebula.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.RepeatedByte; +import us.hebi.quickbuf.RepeatedMessage; +import us.hebi.quickbuf.Utf8String; + +public final class PotentialPreselectionImport { + /** + * Protobuf type {@code PotentialPreselectionImportReq} + */ + public static final class PotentialPreselectionImportReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional bool Preference = 2; + */ + private boolean preference; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + /** + * optional string Name = 1; + */ + private final Utf8String name = Utf8String.newEmptyInstance(); + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 3; + */ + private final RepeatedMessage charPotentials = RepeatedMessage.newEmptyInstance(PublicStarTower.StarTowerBookCharPotential.getFactory()); + + private PotentialPreselectionImportReq() { + } + + /** + * @return a new empty instance of {@code PotentialPreselectionImportReq} + */ + public static PotentialPreselectionImportReq newInstance() { + return new PotentialPreselectionImportReq(); + } + + /** + * optional bool Preference = 2; + * @return whether the preference field is set + */ + public boolean hasPreference() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional bool Preference = 2; + * @return this + */ + public PotentialPreselectionImportReq clearPreference() { + bitField0_ &= ~0x00000001; + preference = false; + return this; + } + + /** + * optional bool Preference = 2; + * @return the preference + */ + public boolean getPreference() { + return preference; + } + + /** + * optional bool Preference = 2; + * @param value the preference to set + * @return this + */ + public PotentialPreselectionImportReq setPreference(final boolean value) { + bitField0_ |= 0x00000001; + preference = value; + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public PotentialPreselectionImportReq clearNextPackage() { + bitField0_ &= ~0x00000002; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000002; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public PotentialPreselectionImportReq addNextPackage(final byte value) { + bitField0_ |= 0x00000002; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public PotentialPreselectionImportReq addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000002; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public PotentialPreselectionImportReq setNextPackage(final byte... values) { + bitField0_ |= 0x00000002; + nextPackage.copyFrom(values); + return this; + } + + /** + * optional string Name = 1; + * @return whether the name field is set + */ + public boolean hasName() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional string Name = 1; + * @return this + */ + public PotentialPreselectionImportReq clearName() { + bitField0_ &= ~0x00000004; + name.clear(); + return this; + } + + /** + * optional string Name = 1; + * @return the name + */ + public String getName() { + return name.getString(); + } + + /** + * optional string Name = 1; + * @return internal {@code Utf8String} representation of name for reading + */ + public Utf8String getNameBytes() { + return this.name; + } + + /** + * optional string Name = 1; + * @return internal {@code Utf8String} representation of name for modifications + */ + public Utf8String getMutableNameBytes() { + bitField0_ |= 0x00000004; + return this.name; + } + + /** + * optional string Name = 1; + * @param value the name to set + * @return this + */ + public PotentialPreselectionImportReq setName(final CharSequence value) { + bitField0_ |= 0x00000004; + name.copyFrom(value); + return this; + } + + /** + * optional string Name = 1; + * @param value the name to set + * @return this + */ + public PotentialPreselectionImportReq setName(final Utf8String value) { + bitField0_ |= 0x00000004; + name.copyFrom(value); + return this; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 3; + * @return whether the charPotentials field is set + */ + public boolean hasCharPotentials() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 3; + * @return this + */ + public PotentialPreselectionImportReq clearCharPotentials() { + bitField0_ &= ~0x00000008; + charPotentials.clear(); + return this; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 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 #getMutableCharPotentials()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getCharPotentials() { + return charPotentials; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 3; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableCharPotentials() { + bitField0_ |= 0x00000008; + return charPotentials; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 3; + * @param value the charPotentials to add + * @return this + */ + public PotentialPreselectionImportReq addCharPotentials( + final PublicStarTower.StarTowerBookCharPotential value) { + bitField0_ |= 0x00000008; + charPotentials.add(value); + return this; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 3; + * @param values the charPotentials to add + * @return this + */ + public PotentialPreselectionImportReq addAllCharPotentials( + final PublicStarTower.StarTowerBookCharPotential... values) { + bitField0_ |= 0x00000008; + charPotentials.addAll(values); + return this; + } + + @Override + public PotentialPreselectionImportReq copyFrom(final PotentialPreselectionImportReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + preference = other.preference; + nextPackage.copyFrom(other.nextPackage); + name.copyFrom(other.name); + charPotentials.copyFrom(other.charPotentials); + } + return this; + } + + @Override + public PotentialPreselectionImportReq mergeFrom(final PotentialPreselectionImportReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasPreference()) { + setPreference(other.preference); + } + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + if (other.hasName()) { + getMutableNameBytes().copyFrom(other.name); + } + if (other.hasCharPotentials()) { + getMutableCharPotentials().addAll(other.charPotentials); + } + return this; + } + + @Override + public PotentialPreselectionImportReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + preference = false; + nextPackage.clear(); + name.clear(); + charPotentials.clear(); + return this; + } + + @Override + public PotentialPreselectionImportReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + name.clear(); + charPotentials.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof PotentialPreselectionImportReq)) { + return false; + } + PotentialPreselectionImportReq other = (PotentialPreselectionImportReq) o; + return bitField0_ == other.bitField0_ + && (!hasPreference() || preference == other.preference) + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) + && (!hasName() || name.equals(other.name)) + && (!hasCharPotentials() || charPotentials.equals(other.charPotentials)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 16); + output.writeBoolNoTag(preference); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 10); + output.writeStringNoTag(name); + } + if ((bitField0_ & 0x00000008) != 0) { + for (int i = 0; i < charPotentials.length(); i++) { + output.writeRawByte((byte) 26); + output.writeMessageNoTag(charPotentials.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 2; + } + if ((bitField0_ & 0x00000002) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeStringSizeNoTag(name); + } + if ((bitField0_ & 0x00000008) != 0) { + size += (1 * charPotentials.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(charPotentials); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public PotentialPreselectionImportReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 16: { + // preference + preference = input.readBool(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16378) { + break; + } + } + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 10) { + break; + } + } + case 10: { + // name + input.readString(name); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 26) { + break; + } + } + case 26: { + // charPotentials + tag = input.readRepeatedMessage(charPotentials, tag); + bitField0_ |= 0x00000008; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeBool(FieldNames.preference, preference); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeString(FieldNames.name, name); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRepeatedMessage(FieldNames.charPotentials, charPotentials); + } + output.endObject(); + } + + @Override + public PotentialPreselectionImportReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 533633275: { + if (input.isAtField(FieldNames.preference)) { + if (!input.trySkipNullValue()) { + preference = input.readBool(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2420395: { + if (input.isAtField(FieldNames.name)) { + if (!input.trySkipNullValue()) { + input.readString(name); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1909208021: { + if (input.isAtField(FieldNames.charPotentials)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(charPotentials); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public PotentialPreselectionImportReq clone() { + return new PotentialPreselectionImportReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static PotentialPreselectionImportReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new PotentialPreselectionImportReq(), data).checkInitialized(); + } + + public static PotentialPreselectionImportReq parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionImportReq(), input).checkInitialized(); + } + + public static PotentialPreselectionImportReq parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionImportReq(), input).checkInitialized(); + } + + /** + * @return factory for creating PotentialPreselectionImportReq messages + */ + public static MessageFactory getFactory() { + return PotentialPreselectionImportReqFactory.INSTANCE; + } + + private enum PotentialPreselectionImportReqFactory implements MessageFactory { + INSTANCE; + + @Override + public PotentialPreselectionImportReq create() { + return PotentialPreselectionImportReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName preference = FieldName.forField("Preference"); + + static final FieldName nextPackage = FieldName.forField("NextPackage"); + + static final FieldName name = FieldName.forField("Name"); + + static final FieldName charPotentials = FieldName.forField("CharPotentials"); + } + } +} diff --git a/src/generated/main/emu/nebula/proto/PotentialPreselectionListOuterClass.java b/src/generated/main/emu/nebula/proto/PotentialPreselectionListOuterClass.java new file mode 100644 index 0000000..84f7fea --- /dev/null +++ b/src/generated/main/emu/nebula/proto/PotentialPreselectionListOuterClass.java @@ -0,0 +1,418 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.nebula.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.RepeatedByte; +import us.hebi.quickbuf.RepeatedMessage; + +public final class PotentialPreselectionListOuterClass { + /** + * Protobuf type {@code PotentialPreselectionList} + */ + public static final class PotentialPreselectionList extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + /** + * repeated .PotentialPreselection List = 1; + */ + private final RepeatedMessage list = RepeatedMessage.newEmptyInstance(PublicStarTower.PotentialPreselection.getFactory()); + + private PotentialPreselectionList() { + } + + /** + * @return a new empty instance of {@code PotentialPreselectionList} + */ + public static PotentialPreselectionList newInstance() { + return new PotentialPreselectionList(); + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public PotentialPreselectionList clearNextPackage() { + bitField0_ &= ~0x00000001; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000001; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public PotentialPreselectionList addNextPackage(final byte value) { + bitField0_ |= 0x00000001; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public PotentialPreselectionList addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public PotentialPreselectionList setNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.copyFrom(values); + return this; + } + + /** + * repeated .PotentialPreselection List = 1; + * @return whether the list field is set + */ + public boolean hasList() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated .PotentialPreselection List = 1; + * @return this + */ + public PotentialPreselectionList clearList() { + bitField0_ &= ~0x00000002; + list.clear(); + return this; + } + + /** + * repeated .PotentialPreselection List = 1; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableList()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getList() { + return list; + } + + /** + * repeated .PotentialPreselection List = 1; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableList() { + bitField0_ |= 0x00000002; + return list; + } + + /** + * repeated .PotentialPreselection List = 1; + * @param value the list to add + * @return this + */ + public PotentialPreselectionList addList(final PublicStarTower.PotentialPreselection value) { + bitField0_ |= 0x00000002; + list.add(value); + return this; + } + + /** + * repeated .PotentialPreselection List = 1; + * @param values the list to add + * @return this + */ + public PotentialPreselectionList addAllList( + final PublicStarTower.PotentialPreselection... values) { + bitField0_ |= 0x00000002; + list.addAll(values); + return this; + } + + @Override + public PotentialPreselectionList copyFrom(final PotentialPreselectionList other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + nextPackage.copyFrom(other.nextPackage); + list.copyFrom(other.list); + } + return this; + } + + @Override + public PotentialPreselectionList mergeFrom(final PotentialPreselectionList other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + if (other.hasList()) { + getMutableList().addAll(other.list); + } + return this; + } + + @Override + public PotentialPreselectionList clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + list.clear(); + return this; + } + + @Override + public PotentialPreselectionList clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + list.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof PotentialPreselectionList)) { + return false; + } + PotentialPreselectionList other = (PotentialPreselectionList) o; + return bitField0_ == other.bitField0_ + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) + && (!hasList() || list.equals(other.list)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < list.length(); i++) { + output.writeRawByte((byte) 10); + output.writeMessageNoTag(list.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * list.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(list); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public PotentialPreselectionList mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 10) { + break; + } + } + case 10: { + // list + tag = input.readRepeatedMessage(list, tag); + bitField0_ |= 0x00000002; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedMessage(FieldNames.list, list); + } + output.endObject(); + } + + @Override + public PotentialPreselectionList mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2368702: { + if (input.isAtField(FieldNames.list)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(list); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public PotentialPreselectionList clone() { + return new PotentialPreselectionList().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static PotentialPreselectionList parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new PotentialPreselectionList(), data).checkInitialized(); + } + + public static PotentialPreselectionList parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionList(), input).checkInitialized(); + } + + public static PotentialPreselectionList parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionList(), input).checkInitialized(); + } + + /** + * @return factory for creating PotentialPreselectionList messages + */ + public static MessageFactory getFactory() { + return PotentialPreselectionListFactory.INSTANCE; + } + + private enum PotentialPreselectionListFactory implements MessageFactory { + INSTANCE; + + @Override + public PotentialPreselectionList create() { + return PotentialPreselectionList.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName nextPackage = FieldName.forField("NextPackage"); + + static final FieldName list = FieldName.forField("List"); + } + } +} diff --git a/src/generated/main/emu/nebula/proto/PotentialPreselectionNameSet.java b/src/generated/main/emu/nebula/proto/PotentialPreselectionNameSet.java new file mode 100644 index 0000000..51e16c3 --- /dev/null +++ b/src/generated/main/emu/nebula/proto/PotentialPreselectionNameSet.java @@ -0,0 +1,495 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.nebula.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.RepeatedByte; +import us.hebi.quickbuf.Utf8String; + +public final class PotentialPreselectionNameSet { + /** + * Protobuf type {@code PotentialPreselectionNameSetReq} + */ + public static final class PotentialPreselectionNameSetReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint64 Id = 1; + */ + private long id; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + /** + * optional string Name = 2; + */ + private final Utf8String name = Utf8String.newEmptyInstance(); + + private PotentialPreselectionNameSetReq() { + } + + /** + * @return a new empty instance of {@code PotentialPreselectionNameSetReq} + */ + public static PotentialPreselectionNameSetReq newInstance() { + return new PotentialPreselectionNameSetReq(); + } + + /** + * optional uint64 Id = 1; + * @return whether the id field is set + */ + public boolean hasId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint64 Id = 1; + * @return this + */ + public PotentialPreselectionNameSetReq clearId() { + bitField0_ &= ~0x00000001; + id = 0L; + return this; + } + + /** + * optional uint64 Id = 1; + * @return the id + */ + public long getId() { + return id; + } + + /** + * optional uint64 Id = 1; + * @param value the id to set + * @return this + */ + public PotentialPreselectionNameSetReq setId(final long value) { + bitField0_ |= 0x00000001; + id = value; + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public PotentialPreselectionNameSetReq clearNextPackage() { + bitField0_ &= ~0x00000002; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000002; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public PotentialPreselectionNameSetReq addNextPackage(final byte value) { + bitField0_ |= 0x00000002; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public PotentialPreselectionNameSetReq addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000002; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public PotentialPreselectionNameSetReq setNextPackage(final byte... values) { + bitField0_ |= 0x00000002; + nextPackage.copyFrom(values); + return this; + } + + /** + * optional string Name = 2; + * @return whether the name field is set + */ + public boolean hasName() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional string Name = 2; + * @return this + */ + public PotentialPreselectionNameSetReq clearName() { + bitField0_ &= ~0x00000004; + name.clear(); + return this; + } + + /** + * optional string Name = 2; + * @return the name + */ + public String getName() { + return name.getString(); + } + + /** + * optional string Name = 2; + * @return internal {@code Utf8String} representation of name for reading + */ + public Utf8String getNameBytes() { + return this.name; + } + + /** + * optional string Name = 2; + * @return internal {@code Utf8String} representation of name for modifications + */ + public Utf8String getMutableNameBytes() { + bitField0_ |= 0x00000004; + return this.name; + } + + /** + * optional string Name = 2; + * @param value the name to set + * @return this + */ + public PotentialPreselectionNameSetReq setName(final CharSequence value) { + bitField0_ |= 0x00000004; + name.copyFrom(value); + return this; + } + + /** + * optional string Name = 2; + * @param value the name to set + * @return this + */ + public PotentialPreselectionNameSetReq setName(final Utf8String value) { + bitField0_ |= 0x00000004; + name.copyFrom(value); + return this; + } + + @Override + public PotentialPreselectionNameSetReq copyFrom(final PotentialPreselectionNameSetReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + id = other.id; + nextPackage.copyFrom(other.nextPackage); + name.copyFrom(other.name); + } + return this; + } + + @Override + public PotentialPreselectionNameSetReq mergeFrom(final PotentialPreselectionNameSetReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasId()) { + setId(other.id); + } + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + if (other.hasName()) { + getMutableNameBytes().copyFrom(other.name); + } + return this; + } + + @Override + public PotentialPreselectionNameSetReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + id = 0L; + nextPackage.clear(); + name.clear(); + return this; + } + + @Override + public PotentialPreselectionNameSetReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + name.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof PotentialPreselectionNameSetReq)) { + return false; + } + PotentialPreselectionNameSetReq other = (PotentialPreselectionNameSetReq) o; + return bitField0_ == other.bitField0_ + && (!hasId() || id == other.id) + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) + && (!hasName() || name.equals(other.name)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt64NoTag(id); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 18); + output.writeStringNoTag(name); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt64SizeNoTag(id); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeStringSizeNoTag(name); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public PotentialPreselectionNameSetReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // id + id = input.readUInt64(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16378) { + break; + } + } + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 18) { + break; + } + } + case 18: { + // name + input.readString(name); + 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.writeUInt64(FieldNames.id, id); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeString(FieldNames.name, name); + } + output.endObject(); + } + + @Override + public PotentialPreselectionNameSetReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 2363: { + if (input.isAtField(FieldNames.id)) { + if (!input.trySkipNullValue()) { + id = input.readUInt64(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2420395: { + if (input.isAtField(FieldNames.name)) { + if (!input.trySkipNullValue()) { + input.readString(name); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public PotentialPreselectionNameSetReq clone() { + return new PotentialPreselectionNameSetReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static PotentialPreselectionNameSetReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new PotentialPreselectionNameSetReq(), data).checkInitialized(); + } + + public static PotentialPreselectionNameSetReq parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionNameSetReq(), input).checkInitialized(); + } + + public static PotentialPreselectionNameSetReq parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionNameSetReq(), input).checkInitialized(); + } + + /** + * @return factory for creating PotentialPreselectionNameSetReq messages + */ + public static MessageFactory getFactory() { + return PotentialPreselectionNameSetReqFactory.INSTANCE; + } + + private enum PotentialPreselectionNameSetReqFactory implements MessageFactory { + INSTANCE; + + @Override + public PotentialPreselectionNameSetReq create() { + return PotentialPreselectionNameSetReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName id = FieldName.forField("Id"); + + static final FieldName nextPackage = FieldName.forField("NextPackage"); + + static final FieldName name = FieldName.forField("Name"); + } + } +} diff --git a/src/generated/main/emu/nebula/proto/PotentialPreselectionPreferenceSet.java b/src/generated/main/emu/nebula/proto/PotentialPreselectionPreferenceSet.java new file mode 100644 index 0000000..4741591 --- /dev/null +++ b/src/generated/main/emu/nebula/proto/PotentialPreselectionPreferenceSet.java @@ -0,0 +1,550 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.nebula.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.RepeatedByte; +import us.hebi.quickbuf.RepeatedLong; + +public final class PotentialPreselectionPreferenceSet { + /** + * Protobuf type {@code PotentialPreselectionPreferenceSetReq} + */ + public static final class PotentialPreselectionPreferenceSetReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + /** + * repeated uint64 CheckInIds = 1; + */ + private final RepeatedLong checkInIds = RepeatedLong.newEmptyInstance(); + + /** + * repeated uint64 CheckOutIds = 2; + */ + private final RepeatedLong checkOutIds = RepeatedLong.newEmptyInstance(); + + private PotentialPreselectionPreferenceSetReq() { + } + + /** + * @return a new empty instance of {@code PotentialPreselectionPreferenceSetReq} + */ + public static PotentialPreselectionPreferenceSetReq newInstance() { + return new PotentialPreselectionPreferenceSetReq(); + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public PotentialPreselectionPreferenceSetReq clearNextPackage() { + bitField0_ &= ~0x00000001; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000001; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public PotentialPreselectionPreferenceSetReq addNextPackage(final byte value) { + bitField0_ |= 0x00000001; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public PotentialPreselectionPreferenceSetReq addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public PotentialPreselectionPreferenceSetReq setNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.copyFrom(values); + return this; + } + + /** + * repeated uint64 CheckInIds = 1; + * @return whether the checkInIds field is set + */ + public boolean hasCheckInIds() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated uint64 CheckInIds = 1; + * @return this + */ + public PotentialPreselectionPreferenceSetReq clearCheckInIds() { + bitField0_ &= ~0x00000002; + checkInIds.clear(); + return this; + } + + /** + * repeated uint64 CheckInIds = 1; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableCheckInIds()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedLong getCheckInIds() { + return checkInIds; + } + + /** + * repeated uint64 CheckInIds = 1; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedLong getMutableCheckInIds() { + bitField0_ |= 0x00000002; + return checkInIds; + } + + /** + * repeated uint64 CheckInIds = 1; + * @param value the checkInIds to add + * @return this + */ + public PotentialPreselectionPreferenceSetReq addCheckInIds(final long value) { + bitField0_ |= 0x00000002; + checkInIds.add(value); + return this; + } + + /** + * repeated uint64 CheckInIds = 1; + * @param values the checkInIds to add + * @return this + */ + public PotentialPreselectionPreferenceSetReq addAllCheckInIds(final long... values) { + bitField0_ |= 0x00000002; + checkInIds.addAll(values); + return this; + } + + /** + * repeated uint64 CheckOutIds = 2; + * @return whether the checkOutIds field is set + */ + public boolean hasCheckOutIds() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * repeated uint64 CheckOutIds = 2; + * @return this + */ + public PotentialPreselectionPreferenceSetReq clearCheckOutIds() { + bitField0_ &= ~0x00000004; + checkOutIds.clear(); + return this; + } + + /** + * repeated uint64 CheckOutIds = 2; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableCheckOutIds()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedLong getCheckOutIds() { + return checkOutIds; + } + + /** + * repeated uint64 CheckOutIds = 2; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedLong getMutableCheckOutIds() { + bitField0_ |= 0x00000004; + return checkOutIds; + } + + /** + * repeated uint64 CheckOutIds = 2; + * @param value the checkOutIds to add + * @return this + */ + public PotentialPreselectionPreferenceSetReq addCheckOutIds(final long value) { + bitField0_ |= 0x00000004; + checkOutIds.add(value); + return this; + } + + /** + * repeated uint64 CheckOutIds = 2; + * @param values the checkOutIds to add + * @return this + */ + public PotentialPreselectionPreferenceSetReq addAllCheckOutIds(final long... values) { + bitField0_ |= 0x00000004; + checkOutIds.addAll(values); + return this; + } + + @Override + public PotentialPreselectionPreferenceSetReq copyFrom( + final PotentialPreselectionPreferenceSetReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + nextPackage.copyFrom(other.nextPackage); + checkInIds.copyFrom(other.checkInIds); + checkOutIds.copyFrom(other.checkOutIds); + } + return this; + } + + @Override + public PotentialPreselectionPreferenceSetReq mergeFrom( + final PotentialPreselectionPreferenceSetReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + if (other.hasCheckInIds()) { + getMutableCheckInIds().addAll(other.checkInIds); + } + if (other.hasCheckOutIds()) { + getMutableCheckOutIds().addAll(other.checkOutIds); + } + return this; + } + + @Override + public PotentialPreselectionPreferenceSetReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + checkInIds.clear(); + checkOutIds.clear(); + return this; + } + + @Override + public PotentialPreselectionPreferenceSetReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + checkInIds.clear(); + checkOutIds.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof PotentialPreselectionPreferenceSetReq)) { + return false; + } + PotentialPreselectionPreferenceSetReq other = (PotentialPreselectionPreferenceSetReq) o; + return bitField0_ == other.bitField0_ + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) + && (!hasCheckInIds() || checkInIds.equals(other.checkInIds)) + && (!hasCheckOutIds() || checkOutIds.equals(other.checkOutIds)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < checkInIds.length(); i++) { + output.writeRawByte((byte) 8); + output.writeUInt64NoTag(checkInIds.array()[i]); + } + } + if ((bitField0_ & 0x00000004) != 0) { + for (int i = 0; i < checkOutIds.length(); i++) { + output.writeRawByte((byte) 16); + output.writeUInt64NoTag(checkOutIds.array()[i]); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * checkInIds.length()) + ProtoSink.computeRepeatedUInt64SizeNoTag(checkInIds); + } + if ((bitField0_ & 0x00000004) != 0) { + size += (1 * checkOutIds.length()) + ProtoSink.computeRepeatedUInt64SizeNoTag(checkOutIds); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public PotentialPreselectionPreferenceSetReq mergeFrom(final ProtoSource input) throws + IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 10) { + break; + } + } + case 10: { + // checkInIds [packed=true] + input.readPackedUInt64(checkInIds, tag); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 18) { + break; + } + } + case 18: { + // checkOutIds [packed=true] + input.readPackedUInt64(checkOutIds, tag); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + case 8: { + // checkInIds [packed=false] + tag = input.readRepeatedUInt64(checkInIds, tag); + bitField0_ |= 0x00000002; + break; + } + case 16: { + // checkOutIds [packed=false] + tag = input.readRepeatedUInt64(checkOutIds, tag); + bitField0_ |= 0x00000004; + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedUInt64(FieldNames.checkInIds, checkInIds); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRepeatedUInt64(FieldNames.checkOutIds, checkOutIds); + } + output.endObject(); + } + + @Override + public PotentialPreselectionPreferenceSetReq mergeFrom(final JsonSource input) throws + IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1454616395: { + if (input.isAtField(FieldNames.checkInIds)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt64(checkInIds); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1972037742: { + if (input.isAtField(FieldNames.checkOutIds)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt64(checkOutIds); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public PotentialPreselectionPreferenceSetReq clone() { + return new PotentialPreselectionPreferenceSetReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static PotentialPreselectionPreferenceSetReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new PotentialPreselectionPreferenceSetReq(), data).checkInitialized(); + } + + public static PotentialPreselectionPreferenceSetReq parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionPreferenceSetReq(), input).checkInitialized(); + } + + public static PotentialPreselectionPreferenceSetReq parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionPreferenceSetReq(), input).checkInitialized(); + } + + /** + * @return factory for creating PotentialPreselectionPreferenceSetReq messages + */ + public static MessageFactory getFactory() { + return PotentialPreselectionPreferenceSetReqFactory.INSTANCE; + } + + private enum PotentialPreselectionPreferenceSetReqFactory implements MessageFactory { + INSTANCE; + + @Override + public PotentialPreselectionPreferenceSetReq create() { + return PotentialPreselectionPreferenceSetReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName nextPackage = FieldName.forField("NextPackage"); + + static final FieldName checkInIds = FieldName.forField("CheckInIds"); + + static final FieldName checkOutIds = FieldName.forField("CheckOutIds"); + } + } +} diff --git a/src/generated/main/emu/nebula/proto/PotentialPreselectionUpdate.java b/src/generated/main/emu/nebula/proto/PotentialPreselectionUpdate.java new file mode 100644 index 0000000..73ce2a0 --- /dev/null +++ b/src/generated/main/emu/nebula/proto/PotentialPreselectionUpdate.java @@ -0,0 +1,501 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.nebula.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.RepeatedByte; +import us.hebi.quickbuf.RepeatedMessage; + +public final class PotentialPreselectionUpdate { + /** + * Protobuf type {@code PotentialPreselectionUpdateReq} + */ + public static final class PotentialPreselectionUpdateReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint64 Id = 1; + */ + private long id; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 2; + */ + private final RepeatedMessage charPotentials = RepeatedMessage.newEmptyInstance(PublicStarTower.StarTowerBookCharPotential.getFactory()); + + private PotentialPreselectionUpdateReq() { + } + + /** + * @return a new empty instance of {@code PotentialPreselectionUpdateReq} + */ + public static PotentialPreselectionUpdateReq newInstance() { + return new PotentialPreselectionUpdateReq(); + } + + /** + * optional uint64 Id = 1; + * @return whether the id field is set + */ + public boolean hasId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint64 Id = 1; + * @return this + */ + public PotentialPreselectionUpdateReq clearId() { + bitField0_ &= ~0x00000001; + id = 0L; + return this; + } + + /** + * optional uint64 Id = 1; + * @return the id + */ + public long getId() { + return id; + } + + /** + * optional uint64 Id = 1; + * @param value the id to set + * @return this + */ + public PotentialPreselectionUpdateReq setId(final long value) { + bitField0_ |= 0x00000001; + id = value; + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public PotentialPreselectionUpdateReq clearNextPackage() { + bitField0_ &= ~0x00000002; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000002; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public PotentialPreselectionUpdateReq addNextPackage(final byte value) { + bitField0_ |= 0x00000002; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public PotentialPreselectionUpdateReq addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000002; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public PotentialPreselectionUpdateReq setNextPackage(final byte... values) { + bitField0_ |= 0x00000002; + nextPackage.copyFrom(values); + return this; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 2; + * @return whether the charPotentials field is set + */ + public boolean hasCharPotentials() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 2; + * @return this + */ + public PotentialPreselectionUpdateReq clearCharPotentials() { + bitField0_ &= ~0x00000004; + charPotentials.clear(); + return this; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 2; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableCharPotentials()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getCharPotentials() { + return charPotentials; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 2; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableCharPotentials() { + bitField0_ |= 0x00000004; + return charPotentials; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 2; + * @param value the charPotentials to add + * @return this + */ + public PotentialPreselectionUpdateReq addCharPotentials( + final PublicStarTower.StarTowerBookCharPotential value) { + bitField0_ |= 0x00000004; + charPotentials.add(value); + return this; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 2; + * @param values the charPotentials to add + * @return this + */ + public PotentialPreselectionUpdateReq addAllCharPotentials( + final PublicStarTower.StarTowerBookCharPotential... values) { + bitField0_ |= 0x00000004; + charPotentials.addAll(values); + return this; + } + + @Override + public PotentialPreselectionUpdateReq copyFrom(final PotentialPreselectionUpdateReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + id = other.id; + nextPackage.copyFrom(other.nextPackage); + charPotentials.copyFrom(other.charPotentials); + } + return this; + } + + @Override + public PotentialPreselectionUpdateReq mergeFrom(final PotentialPreselectionUpdateReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasId()) { + setId(other.id); + } + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + if (other.hasCharPotentials()) { + getMutableCharPotentials().addAll(other.charPotentials); + } + return this; + } + + @Override + public PotentialPreselectionUpdateReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + id = 0L; + nextPackage.clear(); + charPotentials.clear(); + return this; + } + + @Override + public PotentialPreselectionUpdateReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + charPotentials.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof PotentialPreselectionUpdateReq)) { + return false; + } + PotentialPreselectionUpdateReq other = (PotentialPreselectionUpdateReq) o; + return bitField0_ == other.bitField0_ + && (!hasId() || id == other.id) + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) + && (!hasCharPotentials() || charPotentials.equals(other.charPotentials)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt64NoTag(id); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + if ((bitField0_ & 0x00000004) != 0) { + for (int i = 0; i < charPotentials.length(); i++) { + output.writeRawByte((byte) 18); + output.writeMessageNoTag(charPotentials.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt64SizeNoTag(id); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + if ((bitField0_ & 0x00000004) != 0) { + size += (1 * charPotentials.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(charPotentials); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public PotentialPreselectionUpdateReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // id + id = input.readUInt64(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16378) { + break; + } + } + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 18) { + break; + } + } + case 18: { + // charPotentials + tag = input.readRepeatedMessage(charPotentials, tag); + bitField0_ |= 0x00000004; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt64(FieldNames.id, id); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRepeatedMessage(FieldNames.charPotentials, charPotentials); + } + output.endObject(); + } + + @Override + public PotentialPreselectionUpdateReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 2363: { + if (input.isAtField(FieldNames.id)) { + if (!input.trySkipNullValue()) { + id = input.readUInt64(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1909208021: { + if (input.isAtField(FieldNames.charPotentials)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(charPotentials); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public PotentialPreselectionUpdateReq clone() { + return new PotentialPreselectionUpdateReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static PotentialPreselectionUpdateReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new PotentialPreselectionUpdateReq(), data).checkInitialized(); + } + + public static PotentialPreselectionUpdateReq parseFrom(final ProtoSource input) throws + IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionUpdateReq(), input).checkInitialized(); + } + + public static PotentialPreselectionUpdateReq parseFrom(final JsonSource input) throws + IOException { + return ProtoMessage.mergeFrom(new PotentialPreselectionUpdateReq(), input).checkInitialized(); + } + + /** + * @return factory for creating PotentialPreselectionUpdateReq messages + */ + public static MessageFactory getFactory() { + return PotentialPreselectionUpdateReqFactory.INSTANCE; + } + + private enum PotentialPreselectionUpdateReqFactory implements MessageFactory { + INSTANCE; + + @Override + public PotentialPreselectionUpdateReq create() { + return PotentialPreselectionUpdateReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName id = FieldName.forField("Id"); + + static final FieldName nextPackage = FieldName.forField("NextPackage"); + + static final FieldName charPotentials = FieldName.forField("CharPotentials"); + } + } +} diff --git a/src/generated/main/emu/nebula/proto/Public.java b/src/generated/main/emu/nebula/proto/Public.java index 2adb681..5b128ed 100644 --- a/src/generated/main/emu/nebula/proto/Public.java +++ b/src/generated/main/emu/nebula/proto/Public.java @@ -19853,6 +19853,11 @@ public final class Public { public static final class StateInfo extends ProtoMessage implements Cloneable { private static final long serialVersionUID = 0L; + /** + * optional int64 TravelerDuelIdleReward = 17; + */ + private long travelerDuelIdleReward; + /** * optional uint32 InfinityTower = 2; */ @@ -19913,11 +19918,6 @@ public final class Public { */ private final QuestState travelerDuelQuest = QuestState.newInstance(); - /** - * optional .QuestState TravelerDuelChallengeQuest = 17; - */ - private final QuestState travelerDuelChallengeQuest = QuestState.newInstance(); - /** * optional .StarTowerState StarTower = 18; */ @@ -19963,12 +19963,49 @@ public final class Public { return new StateInfo(); } + /** + * optional int64 TravelerDuelIdleReward = 17; + * @return whether the travelerDuelIdleReward field is set + */ + public boolean hasTravelerDuelIdleReward() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional int64 TravelerDuelIdleReward = 17; + * @return this + */ + public StateInfo clearTravelerDuelIdleReward() { + bitField0_ &= ~0x00000001; + travelerDuelIdleReward = 0L; + return this; + } + + /** + * optional int64 TravelerDuelIdleReward = 17; + * @return the travelerDuelIdleReward + */ + public long getTravelerDuelIdleReward() { + return travelerDuelIdleReward; + } + + /** + * optional int64 TravelerDuelIdleReward = 17; + * @param value the travelerDuelIdleReward to set + * @return this + */ + public StateInfo setTravelerDuelIdleReward(final long value) { + bitField0_ |= 0x00000001; + travelerDuelIdleReward = value; + return this; + } + /** * optional uint32 InfinityTower = 2; * @return whether the infinityTower field is set */ public boolean hasInfinityTower() { - return (bitField0_ & 0x00000001) != 0; + return (bitField0_ & 0x00000002) != 0; } /** @@ -19976,7 +20013,7 @@ public final class Public { * @return this */ public StateInfo clearInfinityTower() { - bitField0_ &= ~0x00000001; + bitField0_ &= ~0x00000002; infinityTower = 0; return this; } @@ -19995,7 +20032,7 @@ public final class Public { * @return this */ public StateInfo setInfinityTower(final int value) { - bitField0_ |= 0x00000001; + bitField0_ |= 0x00000002; infinityTower = value; return this; } @@ -20005,7 +20042,7 @@ public final class Public { * @return whether the vampireSurvivorId field is set */ public boolean hasVampireSurvivorId() { - return (bitField0_ & 0x00000002) != 0; + return (bitField0_ & 0x00000004) != 0; } /** @@ -20013,7 +20050,7 @@ public final class Public { * @return this */ public StateInfo clearVampireSurvivorId() { - bitField0_ &= ~0x00000002; + bitField0_ &= ~0x00000004; vampireSurvivorId = 0; return this; } @@ -20032,7 +20069,7 @@ public final class Public { * @return this */ public StateInfo setVampireSurvivorId(final int value) { - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; vampireSurvivorId = value; return this; } @@ -20042,7 +20079,7 @@ public final class Public { * @return whether the friend field is set */ public boolean hasFriend() { - return (bitField0_ & 0x00000004) != 0; + return (bitField0_ & 0x00000008) != 0; } /** @@ -20050,7 +20087,7 @@ public final class Public { * @return this */ public StateInfo clearFriend() { - bitField0_ &= ~0x00000004; + bitField0_ &= ~0x00000008; friend = false; return this; } @@ -20069,7 +20106,7 @@ public final class Public { * @return this */ public StateInfo setFriend(final boolean value) { - bitField0_ |= 0x00000004; + bitField0_ |= 0x00000008; friend = value; return this; } @@ -20079,7 +20116,7 @@ public final class Public { * @return whether the npcAffinityReward field is set */ public boolean hasNpcAffinityReward() { - return (bitField0_ & 0x00000008) != 0; + return (bitField0_ & 0x00000010) != 0; } /** @@ -20087,7 +20124,7 @@ public final class Public { * @return this */ public StateInfo clearNpcAffinityReward() { - bitField0_ &= ~0x00000008; + bitField0_ &= ~0x00000010; npcAffinityReward = false; return this; } @@ -20106,7 +20143,7 @@ public final class Public { * @return this */ public StateInfo setNpcAffinityReward(final boolean value) { - bitField0_ |= 0x00000008; + bitField0_ |= 0x00000010; npcAffinityReward = value; return this; } @@ -20116,7 +20153,7 @@ public final class Public { * @return whether the storySet field is set */ public boolean hasStorySet() { - return (bitField0_ & 0x00000010) != 0; + return (bitField0_ & 0x00000020) != 0; } /** @@ -20124,7 +20161,7 @@ public final class Public { * @return this */ public StateInfo clearStorySet() { - bitField0_ &= ~0x00000010; + bitField0_ &= ~0x00000020; storySet = false; return this; } @@ -20143,7 +20180,7 @@ public final class Public { * @return this */ public StateInfo setStorySet(final boolean value) { - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000020; storySet = value; return this; } @@ -20153,7 +20190,7 @@ public final class Public { * @return whether the mail field is set */ public boolean hasMail() { - return (bitField0_ & 0x00000020) != 0; + return (bitField0_ & 0x00000040) != 0; } /** @@ -20161,7 +20198,7 @@ public final class Public { * @return this */ public StateInfo clearMail() { - bitField0_ &= ~0x00000020; + bitField0_ &= ~0x00000040; mail.clear(); return this; } @@ -20190,7 +20227,7 @@ public final class Public { * @return internal storage object for modifications */ public MailState getMutableMail() { - bitField0_ |= 0x00000020; + bitField0_ |= 0x00000040; return mail; } @@ -20200,7 +20237,7 @@ public final class Public { * @return this */ public StateInfo setMail(final MailState value) { - bitField0_ |= 0x00000020; + bitField0_ |= 0x00000040; mail.copyFrom(value); return this; } @@ -20210,7 +20247,7 @@ public final class Public { * @return whether the battlePass field is set */ public boolean hasBattlePass() { - return (bitField0_ & 0x00000040) != 0; + return (bitField0_ & 0x00000080) != 0; } /** @@ -20218,7 +20255,7 @@ public final class Public { * @return this */ public StateInfo clearBattlePass() { - bitField0_ &= ~0x00000040; + bitField0_ &= ~0x00000080; battlePass.clear(); return this; } @@ -20247,7 +20284,7 @@ public final class Public { * @return internal storage object for modifications */ public BattlePassState getMutableBattlePass() { - bitField0_ |= 0x00000040; + bitField0_ |= 0x00000080; return battlePass; } @@ -20257,7 +20294,7 @@ public final class Public { * @return this */ public StateInfo setBattlePass(final BattlePassState value) { - bitField0_ |= 0x00000040; + bitField0_ |= 0x00000080; battlePass.copyFrom(value); return this; } @@ -20267,7 +20304,7 @@ public final class Public { * @return whether the worldClassReward field is set */ public boolean hasWorldClassReward() { - return (bitField0_ & 0x00000080) != 0; + return (bitField0_ & 0x00000100) != 0; } /** @@ -20275,7 +20312,7 @@ public final class Public { * @return this */ public StateInfo clearWorldClassReward() { - bitField0_ &= ~0x00000080; + bitField0_ &= ~0x00000100; worldClassReward.clear(); return this; } @@ -20304,7 +20341,7 @@ public final class Public { * @return internal storage object for modifications */ public WorldClassRewardState getMutableWorldClassReward() { - bitField0_ |= 0x00000080; + bitField0_ |= 0x00000100; return worldClassReward; } @@ -20314,7 +20351,7 @@ public final class Public { * @return this */ public StateInfo setWorldClassReward(final WorldClassRewardState value) { - bitField0_ |= 0x00000080; + bitField0_ |= 0x00000100; worldClassReward.copyFrom(value); return this; } @@ -20324,7 +20361,7 @@ public final class Public { * @return whether the friendEnergy field is set */ public boolean hasFriendEnergy() { - return (bitField0_ & 0x00000100) != 0; + return (bitField0_ & 0x00000200) != 0; } /** @@ -20332,7 +20369,7 @@ public final class Public { * @return this */ public StateInfo clearFriendEnergy() { - bitField0_ &= ~0x00000100; + bitField0_ &= ~0x00000200; friendEnergy.clear(); return this; } @@ -20361,7 +20398,7 @@ public final class Public { * @return internal storage object for modifications */ public FriendEnergyState getMutableFriendEnergy() { - bitField0_ |= 0x00000100; + bitField0_ |= 0x00000200; return friendEnergy; } @@ -20371,7 +20408,7 @@ public final class Public { * @return this */ public StateInfo setFriendEnergy(final FriendEnergyState value) { - bitField0_ |= 0x00000100; + bitField0_ |= 0x00000200; friendEnergy.copyFrom(value); return this; } @@ -20381,7 +20418,7 @@ public final class Public { * @return whether the mallPackage field is set */ public boolean hasMallPackage() { - return (bitField0_ & 0x00000200) != 0; + return (bitField0_ & 0x00000400) != 0; } /** @@ -20389,7 +20426,7 @@ public final class Public { * @return this */ public StateInfo clearMallPackage() { - bitField0_ &= ~0x00000200; + bitField0_ &= ~0x00000400; mallPackage.clear(); return this; } @@ -20418,7 +20455,7 @@ public final class Public { * @return internal storage object for modifications */ public MallPackageState getMutableMallPackage() { - bitField0_ |= 0x00000200; + bitField0_ |= 0x00000400; return mallPackage; } @@ -20428,7 +20465,7 @@ public final class Public { * @return this */ public StateInfo setMallPackage(final MallPackageState value) { - bitField0_ |= 0x00000200; + bitField0_ |= 0x00000400; mallPackage.copyFrom(value); return this; } @@ -20438,7 +20475,7 @@ public final class Public { * @return whether the achievement field is set */ public boolean hasAchievement() { - return (bitField0_ & 0x00000400) != 0; + return (bitField0_ & 0x00000800) != 0; } /** @@ -20446,7 +20483,7 @@ public final class Public { * @return this */ public StateInfo clearAchievement() { - bitField0_ &= ~0x00000400; + bitField0_ &= ~0x00000800; achievement.clear(); return this; } @@ -20475,7 +20512,7 @@ public final class Public { * @return internal storage object for modifications */ public AchievementState getMutableAchievement() { - bitField0_ |= 0x00000400; + bitField0_ |= 0x00000800; return achievement; } @@ -20485,7 +20522,7 @@ public final class Public { * @return this */ public StateInfo setAchievement(final AchievementState value) { - bitField0_ |= 0x00000400; + bitField0_ |= 0x00000800; achievement.copyFrom(value); return this; } @@ -20495,7 +20532,7 @@ public final class Public { * @return whether the travelerDuelQuest field is set */ public boolean hasTravelerDuelQuest() { - return (bitField0_ & 0x00000800) != 0; + return (bitField0_ & 0x00001000) != 0; } /** @@ -20503,7 +20540,7 @@ public final class Public { * @return this */ public StateInfo clearTravelerDuelQuest() { - bitField0_ &= ~0x00000800; + bitField0_ &= ~0x00001000; travelerDuelQuest.clear(); return this; } @@ -20532,7 +20569,7 @@ public final class Public { * @return internal storage object for modifications */ public QuestState getMutableTravelerDuelQuest() { - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; return travelerDuelQuest; } @@ -20542,68 +20579,11 @@ public final class Public { * @return this */ public StateInfo setTravelerDuelQuest(final QuestState value) { - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; travelerDuelQuest.copyFrom(value); return this; } - /** - * optional .QuestState TravelerDuelChallengeQuest = 17; - * @return whether the travelerDuelChallengeQuest field is set - */ - public boolean hasTravelerDuelChallengeQuest() { - return (bitField0_ & 0x00001000) != 0; - } - - /** - * optional .QuestState TravelerDuelChallengeQuest = 17; - * @return this - */ - public StateInfo clearTravelerDuelChallengeQuest() { - bitField0_ &= ~0x00001000; - travelerDuelChallengeQuest.clear(); - return this; - } - - /** - * optional .QuestState TravelerDuelChallengeQuest = 17; - * - * 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 #getMutableTravelerDuelChallengeQuest()} if you want to modify it. - * - * @return internal storage object for reading - */ - public QuestState getTravelerDuelChallengeQuest() { - return travelerDuelChallengeQuest; - } - - /** - * optional .QuestState TravelerDuelChallengeQuest = 17; - * - * 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 QuestState getMutableTravelerDuelChallengeQuest() { - bitField0_ |= 0x00001000; - return travelerDuelChallengeQuest; - } - - /** - * optional .QuestState TravelerDuelChallengeQuest = 17; - * @param value the travelerDuelChallengeQuest to set - * @return this - */ - public StateInfo setTravelerDuelChallengeQuest(final QuestState value) { - bitField0_ |= 0x00001000; - travelerDuelChallengeQuest.copyFrom(value); - return this; - } - /** * optional .StarTowerState StarTower = 18; * @return whether the starTower field is set @@ -21063,6 +21043,7 @@ public final class Public { cachedSize = other.cachedSize; if ((bitField0_ | other.bitField0_) != 0) { bitField0_ = other.bitField0_; + travelerDuelIdleReward = other.travelerDuelIdleReward; infinityTower = other.infinityTower; vampireSurvivorId = other.vampireSurvivorId; friend = other.friend; @@ -21075,7 +21056,6 @@ public final class Public { mallPackage.copyFrom(other.mallPackage); achievement.copyFrom(other.achievement); travelerDuelQuest.copyFrom(other.travelerDuelQuest); - travelerDuelChallengeQuest.copyFrom(other.travelerDuelChallengeQuest); starTower.copyFrom(other.starTower); starTowerBook.copyFrom(other.starTowerBook); scoreBoss.copyFrom(other.scoreBoss); @@ -21093,6 +21073,9 @@ public final class Public { return this; } cachedSize = -1; + if (other.hasTravelerDuelIdleReward()) { + setTravelerDuelIdleReward(other.travelerDuelIdleReward); + } if (other.hasInfinityTower()) { setInfinityTower(other.infinityTower); } @@ -21129,9 +21112,6 @@ public final class Public { if (other.hasTravelerDuelQuest()) { getMutableTravelerDuelQuest().mergeFrom(other.travelerDuelQuest); } - if (other.hasTravelerDuelChallengeQuest()) { - getMutableTravelerDuelChallengeQuest().mergeFrom(other.travelerDuelChallengeQuest); - } if (other.hasStarTower()) { getMutableStarTower().mergeFrom(other.starTower); } @@ -21163,6 +21143,7 @@ public final class Public { } cachedSize = -1; bitField0_ = 0; + travelerDuelIdleReward = 0L; infinityTower = 0; vampireSurvivorId = 0; friend = false; @@ -21175,7 +21156,6 @@ public final class Public { mallPackage.clear(); achievement.clear(); travelerDuelQuest.clear(); - travelerDuelChallengeQuest.clear(); starTower.clear(); starTowerBook.clear(); scoreBoss.clear(); @@ -21200,7 +21180,6 @@ public final class Public { mallPackage.clearQuick(); achievement.clearQuick(); travelerDuelQuest.clearQuick(); - travelerDuelChallengeQuest.clearQuick(); starTower.clearQuick(); starTowerBook.clearQuick(); scoreBoss.clearQuick(); @@ -21221,6 +21200,7 @@ public final class Public { } StateInfo other = (StateInfo) o; return bitField0_ == other.bitField0_ + && (!hasTravelerDuelIdleReward() || travelerDuelIdleReward == other.travelerDuelIdleReward) && (!hasInfinityTower() || infinityTower == other.infinityTower) && (!hasVampireSurvivorId() || vampireSurvivorId == other.vampireSurvivorId) && (!hasFriend() || friend == other.friend) @@ -21233,7 +21213,6 @@ public final class Public { && (!hasMallPackage() || mallPackage.equals(other.mallPackage)) && (!hasAchievement() || achievement.equals(other.achievement)) && (!hasTravelerDuelQuest() || travelerDuelQuest.equals(other.travelerDuelQuest)) - && (!hasTravelerDuelChallengeQuest() || travelerDuelChallengeQuest.equals(other.travelerDuelChallengeQuest)) && (!hasStarTower() || starTower.equals(other.starTower)) && (!hasStarTowerBook() || starTowerBook.equals(other.starTowerBook)) && (!hasScoreBoss() || scoreBoss.equals(other.scoreBoss)) @@ -21246,57 +21225,57 @@ public final class Public { @Override public void writeTo(final ProtoSink output) throws IOException { if ((bitField0_ & 0x00000001) != 0) { + output.writeRawLittleEndian16((short) 392); + output.writeInt64NoTag(travelerDuelIdleReward); + } + if ((bitField0_ & 0x00000002) != 0) { output.writeRawByte((byte) 16); output.writeUInt32NoTag(infinityTower); } - if ((bitField0_ & 0x00000002) != 0) { + if ((bitField0_ & 0x00000004) != 0) { output.writeRawByte((byte) 88); output.writeUInt32NoTag(vampireSurvivorId); } - if ((bitField0_ & 0x00000004) != 0) { + if ((bitField0_ & 0x00000008) != 0) { output.writeRawByte((byte) 24); output.writeBoolNoTag(friend); } - if ((bitField0_ & 0x00000008) != 0) { + if ((bitField0_ & 0x00000010) != 0) { output.writeRawByte((byte) 72); output.writeBoolNoTag(npcAffinityReward); } - if ((bitField0_ & 0x00000010) != 0) { + if ((bitField0_ & 0x00000020) != 0) { output.writeRawLittleEndian16((short) 432); output.writeBoolNoTag(storySet); } - if ((bitField0_ & 0x00000020) != 0) { + if ((bitField0_ & 0x00000040) != 0) { output.writeRawByte((byte) 10); output.writeMessageNoTag(mail); } - if ((bitField0_ & 0x00000040) != 0) { + if ((bitField0_ & 0x00000080) != 0) { output.writeRawByte((byte) 34); output.writeMessageNoTag(battlePass); } - if ((bitField0_ & 0x00000080) != 0) { + if ((bitField0_ & 0x00000100) != 0) { output.writeRawByte((byte) 42); output.writeMessageNoTag(worldClassReward); } - if ((bitField0_ & 0x00000100) != 0) { + if ((bitField0_ & 0x00000200) != 0) { output.writeRawByte((byte) 58); output.writeMessageNoTag(friendEnergy); } - if ((bitField0_ & 0x00000200) != 0) { + if ((bitField0_ & 0x00000400) != 0) { output.writeRawByte((byte) 82); output.writeMessageNoTag(mallPackage); } - if ((bitField0_ & 0x00000400) != 0) { + if ((bitField0_ & 0x00000800) != 0) { output.writeRawByte((byte) 122); output.writeMessageNoTag(achievement); } - if ((bitField0_ & 0x00000800) != 0) { + if ((bitField0_ & 0x00001000) != 0) { output.writeRawLittleEndian16((short) 386); output.writeMessageNoTag(travelerDuelQuest); } - if ((bitField0_ & 0x00001000) != 0) { - output.writeRawLittleEndian16((short) 394); - output.writeMessageNoTag(travelerDuelChallengeQuest); - } if ((bitField0_ & 0x00002000) != 0) { output.writeRawLittleEndian16((short) 402); output.writeMessageNoTag(starTower); @@ -21337,43 +21316,43 @@ public final class Public { protected int computeSerializedSize() { int size = 0; if ((bitField0_ & 0x00000001) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(infinityTower); + size += 2 + ProtoSink.computeInt64SizeNoTag(travelerDuelIdleReward); } if ((bitField0_ & 0x00000002) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(vampireSurvivorId); + size += 1 + ProtoSink.computeUInt32SizeNoTag(infinityTower); } if ((bitField0_ & 0x00000004) != 0) { - size += 2; + size += 1 + ProtoSink.computeUInt32SizeNoTag(vampireSurvivorId); } if ((bitField0_ & 0x00000008) != 0) { size += 2; } if ((bitField0_ & 0x00000010) != 0) { - size += 3; + size += 2; } if ((bitField0_ & 0x00000020) != 0) { - size += 1 + ProtoSink.computeMessageSizeNoTag(mail); + size += 3; } if ((bitField0_ & 0x00000040) != 0) { - size += 1 + ProtoSink.computeMessageSizeNoTag(battlePass); + size += 1 + ProtoSink.computeMessageSizeNoTag(mail); } if ((bitField0_ & 0x00000080) != 0) { - size += 1 + ProtoSink.computeMessageSizeNoTag(worldClassReward); + size += 1 + ProtoSink.computeMessageSizeNoTag(battlePass); } if ((bitField0_ & 0x00000100) != 0) { - size += 1 + ProtoSink.computeMessageSizeNoTag(friendEnergy); + size += 1 + ProtoSink.computeMessageSizeNoTag(worldClassReward); } if ((bitField0_ & 0x00000200) != 0) { - size += 1 + ProtoSink.computeMessageSizeNoTag(mallPackage); + size += 1 + ProtoSink.computeMessageSizeNoTag(friendEnergy); } if ((bitField0_ & 0x00000400) != 0) { - size += 1 + ProtoSink.computeMessageSizeNoTag(achievement); + size += 1 + ProtoSink.computeMessageSizeNoTag(mallPackage); } if ((bitField0_ & 0x00000800) != 0) { - size += 2 + ProtoSink.computeMessageSizeNoTag(travelerDuelQuest); + size += 1 + ProtoSink.computeMessageSizeNoTag(achievement); } if ((bitField0_ & 0x00001000) != 0) { - size += 2 + ProtoSink.computeMessageSizeNoTag(travelerDuelChallengeQuest); + size += 2 + ProtoSink.computeMessageSizeNoTag(travelerDuelQuest); } if ((bitField0_ & 0x00002000) != 0) { size += 2 + ProtoSink.computeMessageSizeNoTag(starTower); @@ -21406,10 +21385,19 @@ public final class Public { int tag = input.readTag(); while (true) { switch (tag) { + case 136: { + // travelerDuelIdleReward + travelerDuelIdleReward = input.readInt64(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } case 16: { // infinityTower infinityTower = input.readUInt32(); - bitField0_ |= 0x00000001; + bitField0_ |= 0x00000002; tag = input.readTag(); if (tag != 88) { break; @@ -21418,7 +21406,7 @@ public final class Public { case 88: { // vampireSurvivorId vampireSurvivorId = input.readUInt32(); - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; tag = input.readTag(); if (tag != 24) { break; @@ -21427,7 +21415,7 @@ public final class Public { case 24: { // friend friend = input.readBool(); - bitField0_ |= 0x00000004; + bitField0_ |= 0x00000008; tag = input.readTag(); if (tag != 72) { break; @@ -21436,7 +21424,7 @@ public final class Public { case 72: { // npcAffinityReward npcAffinityReward = input.readBool(); - bitField0_ |= 0x00000008; + bitField0_ |= 0x00000010; tag = input.readTag(); if (tag != 176) { break; @@ -21445,7 +21433,7 @@ public final class Public { case 176: { // storySet storySet = input.readBool(); - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000020; tag = input.readTag(); if (tag != 10) { break; @@ -21454,7 +21442,7 @@ public final class Public { case 10: { // mail input.readMessage(mail); - bitField0_ |= 0x00000020; + bitField0_ |= 0x00000040; tag = input.readTag(); if (tag != 34) { break; @@ -21463,7 +21451,7 @@ public final class Public { case 34: { // battlePass input.readMessage(battlePass); - bitField0_ |= 0x00000040; + bitField0_ |= 0x00000080; tag = input.readTag(); if (tag != 42) { break; @@ -21472,7 +21460,7 @@ public final class Public { case 42: { // worldClassReward input.readMessage(worldClassReward); - bitField0_ |= 0x00000080; + bitField0_ |= 0x00000100; tag = input.readTag(); if (tag != 58) { break; @@ -21481,7 +21469,7 @@ public final class Public { case 58: { // friendEnergy input.readMessage(friendEnergy); - bitField0_ |= 0x00000100; + bitField0_ |= 0x00000200; tag = input.readTag(); if (tag != 82) { break; @@ -21490,7 +21478,7 @@ public final class Public { case 82: { // mallPackage input.readMessage(mallPackage); - bitField0_ |= 0x00000200; + bitField0_ |= 0x00000400; tag = input.readTag(); if (tag != 122) { break; @@ -21499,7 +21487,7 @@ public final class Public { case 122: { // achievement input.readMessage(achievement); - bitField0_ |= 0x00000400; + bitField0_ |= 0x00000800; tag = input.readTag(); if (tag != 130) { break; @@ -21508,15 +21496,6 @@ public final class Public { case 130: { // travelerDuelQuest input.readMessage(travelerDuelQuest); - bitField0_ |= 0x00000800; - tag = input.readTag(); - if (tag != 138) { - break; - } - } - case 138: { - // travelerDuelChallengeQuest - input.readMessage(travelerDuelChallengeQuest); bitField0_ |= 0x00001000; tag = input.readTag(); if (tag != 146) { @@ -21601,43 +21580,43 @@ public final class Public { public void writeTo(final JsonSink output) throws IOException { output.beginObject(); if ((bitField0_ & 0x00000001) != 0) { - output.writeUInt32(FieldNames.infinityTower, infinityTower); + output.writeInt64(FieldNames.travelerDuelIdleReward, travelerDuelIdleReward); } if ((bitField0_ & 0x00000002) != 0) { - output.writeUInt32(FieldNames.vampireSurvivorId, vampireSurvivorId); + output.writeUInt32(FieldNames.infinityTower, infinityTower); } if ((bitField0_ & 0x00000004) != 0) { - output.writeBool(FieldNames.friend, friend); + output.writeUInt32(FieldNames.vampireSurvivorId, vampireSurvivorId); } if ((bitField0_ & 0x00000008) != 0) { - output.writeBool(FieldNames.npcAffinityReward, npcAffinityReward); + output.writeBool(FieldNames.friend, friend); } if ((bitField0_ & 0x00000010) != 0) { - output.writeBool(FieldNames.storySet, storySet); + output.writeBool(FieldNames.npcAffinityReward, npcAffinityReward); } if ((bitField0_ & 0x00000020) != 0) { - output.writeMessage(FieldNames.mail, mail); + output.writeBool(FieldNames.storySet, storySet); } if ((bitField0_ & 0x00000040) != 0) { - output.writeMessage(FieldNames.battlePass, battlePass); + output.writeMessage(FieldNames.mail, mail); } if ((bitField0_ & 0x00000080) != 0) { - output.writeMessage(FieldNames.worldClassReward, worldClassReward); + output.writeMessage(FieldNames.battlePass, battlePass); } if ((bitField0_ & 0x00000100) != 0) { - output.writeMessage(FieldNames.friendEnergy, friendEnergy); + output.writeMessage(FieldNames.worldClassReward, worldClassReward); } if ((bitField0_ & 0x00000200) != 0) { - output.writeMessage(FieldNames.mallPackage, mallPackage); + output.writeMessage(FieldNames.friendEnergy, friendEnergy); } if ((bitField0_ & 0x00000400) != 0) { - output.writeMessage(FieldNames.achievement, achievement); + output.writeMessage(FieldNames.mallPackage, mallPackage); } if ((bitField0_ & 0x00000800) != 0) { - output.writeMessage(FieldNames.travelerDuelQuest, travelerDuelQuest); + output.writeMessage(FieldNames.achievement, achievement); } if ((bitField0_ & 0x00001000) != 0) { - output.writeMessage(FieldNames.travelerDuelChallengeQuest, travelerDuelChallengeQuest); + output.writeMessage(FieldNames.travelerDuelQuest, travelerDuelQuest); } if ((bitField0_ & 0x00002000) != 0) { output.writeMessage(FieldNames.starTower, starTower); @@ -21670,11 +21649,22 @@ public final class Public { } while (!input.isAtEnd()) { switch (input.readFieldHash()) { + case -1712985982: { + if (input.isAtField(FieldNames.travelerDuelIdleReward)) { + if (!input.trySkipNullValue()) { + travelerDuelIdleReward = input.readInt64(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } case -212544095: { if (input.isAtField(FieldNames.infinityTower)) { if (!input.trySkipNullValue()) { infinityTower = input.readUInt32(); - bitField0_ |= 0x00000001; + bitField0_ |= 0x00000002; } } else { input.skipUnknownField(); @@ -21685,7 +21675,7 @@ public final class Public { if (input.isAtField(FieldNames.vampireSurvivorId)) { if (!input.trySkipNullValue()) { vampireSurvivorId = input.readUInt32(); - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; } } else { input.skipUnknownField(); @@ -21696,7 +21686,7 @@ public final class Public { if (input.isAtField(FieldNames.friend)) { if (!input.trySkipNullValue()) { friend = input.readBool(); - bitField0_ |= 0x00000004; + bitField0_ |= 0x00000008; } } else { input.skipUnknownField(); @@ -21707,7 +21697,7 @@ public final class Public { if (input.isAtField(FieldNames.npcAffinityReward)) { if (!input.trySkipNullValue()) { npcAffinityReward = input.readBool(); - bitField0_ |= 0x00000008; + bitField0_ |= 0x00000010; } } else { input.skipUnknownField(); @@ -21718,7 +21708,7 @@ public final class Public { if (input.isAtField(FieldNames.storySet)) { if (!input.trySkipNullValue()) { storySet = input.readBool(); - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000020; } } else { input.skipUnknownField(); @@ -21729,7 +21719,7 @@ public final class Public { if (input.isAtField(FieldNames.mail)) { if (!input.trySkipNullValue()) { input.readMessage(mail); - bitField0_ |= 0x00000020; + bitField0_ |= 0x00000040; } } else { input.skipUnknownField(); @@ -21740,7 +21730,7 @@ public final class Public { if (input.isAtField(FieldNames.battlePass)) { if (!input.trySkipNullValue()) { input.readMessage(battlePass); - bitField0_ |= 0x00000040; + bitField0_ |= 0x00000080; } } else { input.skipUnknownField(); @@ -21751,7 +21741,7 @@ public final class Public { if (input.isAtField(FieldNames.worldClassReward)) { if (!input.trySkipNullValue()) { input.readMessage(worldClassReward); - bitField0_ |= 0x00000080; + bitField0_ |= 0x00000100; } } else { input.skipUnknownField(); @@ -21762,7 +21752,7 @@ public final class Public { if (input.isAtField(FieldNames.friendEnergy)) { if (!input.trySkipNullValue()) { input.readMessage(friendEnergy); - bitField0_ |= 0x00000100; + bitField0_ |= 0x00000200; } } else { input.skipUnknownField(); @@ -21773,7 +21763,7 @@ public final class Public { if (input.isAtField(FieldNames.mallPackage)) { if (!input.trySkipNullValue()) { input.readMessage(mallPackage); - bitField0_ |= 0x00000200; + bitField0_ |= 0x00000400; } } else { input.skipUnknownField(); @@ -21784,7 +21774,7 @@ public final class Public { if (input.isAtField(FieldNames.achievement)) { if (!input.trySkipNullValue()) { input.readMessage(achievement); - bitField0_ |= 0x00000400; + bitField0_ |= 0x00000800; } } else { input.skipUnknownField(); @@ -21795,17 +21785,6 @@ public final class Public { if (input.isAtField(FieldNames.travelerDuelQuest)) { if (!input.trySkipNullValue()) { input.readMessage(travelerDuelQuest); - bitField0_ |= 0x00000800; - } - } else { - input.skipUnknownField(); - } - break; - } - case 1732134686: { - if (input.isAtField(FieldNames.travelerDuelChallengeQuest)) { - if (!input.trySkipNullValue()) { - input.readMessage(travelerDuelChallengeQuest); bitField0_ |= 0x00001000; } } else { @@ -21942,6 +21921,8 @@ public final class Public { * Contains name constants used for serializing JSON */ static class FieldNames { + static final FieldName travelerDuelIdleReward = FieldName.forField("TravelerDuelIdleReward"); + static final FieldName infinityTower = FieldName.forField("InfinityTower"); static final FieldName vampireSurvivorId = FieldName.forField("VampireSurvivorId"); @@ -21966,8 +21947,6 @@ public final class Public { static final FieldName travelerDuelQuest = FieldName.forField("TravelerDuelQuest"); - static final FieldName travelerDuelChallengeQuest = FieldName.forField("TravelerDuelChallengeQuest"); - static final FieldName starTower = FieldName.forField("StarTower"); static final FieldName starTowerBook = FieldName.forField("StarTowerBook"); @@ -24303,6 +24282,11 @@ public final class Public { */ private int talentBackground; + /** + * optional bool IsFavorite = 31; + */ + private boolean isFavorite; + /** * optional .Quests AffinityQuests = 17; */ @@ -24706,12 +24690,49 @@ public final class Public { return this; } + /** + * optional bool IsFavorite = 31; + * @return whether the isFavorite field is set + */ + public boolean hasIsFavorite() { + return (bitField0_ & 0x00000200) != 0; + } + + /** + * optional bool IsFavorite = 31; + * @return this + */ + public Char clearIsFavorite() { + bitField0_ &= ~0x00000200; + isFavorite = false; + return this; + } + + /** + * optional bool IsFavorite = 31; + * @return the isFavorite + */ + public boolean getIsFavorite() { + return isFavorite; + } + + /** + * optional bool IsFavorite = 31; + * @param value the isFavorite to set + * @return this + */ + public Char setIsFavorite(final boolean value) { + bitField0_ |= 0x00000200; + isFavorite = value; + return this; + } + /** * optional .Quests AffinityQuests = 17; * @return whether the affinityQuests field is set */ public boolean hasAffinityQuests() { - return (bitField0_ & 0x00000200) != 0; + return (bitField0_ & 0x00000400) != 0; } /** @@ -24719,7 +24740,7 @@ public final class Public { * @return this */ public Char clearAffinityQuests() { - bitField0_ &= ~0x00000200; + bitField0_ &= ~0x00000400; affinityQuests.clear(); return this; } @@ -24748,7 +24769,7 @@ public final class Public { * @return internal storage object for modifications */ public Quests getMutableAffinityQuests() { - bitField0_ |= 0x00000200; + bitField0_ |= 0x00000400; return affinityQuests; } @@ -24758,7 +24779,7 @@ public final class Public { * @return this */ public Char setAffinityQuests(final Quests value) { - bitField0_ |= 0x00000200; + bitField0_ |= 0x00000400; affinityQuests.copyFrom(value); return this; } @@ -24768,7 +24789,7 @@ public final class Public { * @return whether the charGemPresets field is set */ public boolean hasCharGemPresets() { - return (bitField0_ & 0x00000400) != 0; + return (bitField0_ & 0x00000800) != 0; } /** @@ -24776,7 +24797,7 @@ public final class Public { * @return this */ public Char clearCharGemPresets() { - bitField0_ &= ~0x00000400; + bitField0_ &= ~0x00000800; charGemPresets.clear(); return this; } @@ -24805,7 +24826,7 @@ public final class Public { * @return internal storage object for modifications */ public CharGemPresets getMutableCharGemPresets() { - bitField0_ |= 0x00000400; + bitField0_ |= 0x00000800; return charGemPresets; } @@ -24815,7 +24836,7 @@ public final class Public { * @return this */ public Char setCharGemPresets(final CharGemPresets value) { - bitField0_ |= 0x00000400; + bitField0_ |= 0x00000800; charGemPresets.copyFrom(value); return this; } @@ -24825,7 +24846,7 @@ public final class Public { * @return whether the talentNodes field is set */ public boolean hasTalentNodes() { - return (bitField0_ & 0x00000800) != 0; + return (bitField0_ & 0x00001000) != 0; } /** @@ -24833,7 +24854,7 @@ public final class Public { * @return this */ public Char clearTalentNodes() { - bitField0_ &= ~0x00000800; + bitField0_ &= ~0x00001000; talentNodes.clear(); return this; } @@ -24862,7 +24883,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedByte getMutableTalentNodes() { - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; return talentNodes; } @@ -24872,7 +24893,7 @@ public final class Public { * @return this */ public Char addTalentNodes(final byte value) { - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; talentNodes.add(value); return this; } @@ -24883,7 +24904,7 @@ public final class Public { * @return this */ public Char addAllTalentNodes(final byte... values) { - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; talentNodes.addAll(values); return this; } @@ -24894,7 +24915,7 @@ public final class Public { * @return this */ public Char setTalentNodes(final byte... values) { - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; talentNodes.copyFrom(values); return this; } @@ -24904,7 +24925,7 @@ public final class Public { * @return whether the nextPackage field is set */ public boolean hasNextPackage() { - return (bitField0_ & 0x00001000) != 0; + return (bitField0_ & 0x00002000) != 0; } /** @@ -24912,7 +24933,7 @@ public final class Public { * @return this */ public Char clearNextPackage() { - bitField0_ &= ~0x00001000; + bitField0_ &= ~0x00002000; nextPackage.clear(); return this; } @@ -24941,7 +24962,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedByte getMutableNextPackage() { - bitField0_ |= 0x00001000; + bitField0_ |= 0x00002000; return nextPackage; } @@ -24951,7 +24972,7 @@ public final class Public { * @return this */ public Char addNextPackage(final byte value) { - bitField0_ |= 0x00001000; + bitField0_ |= 0x00002000; nextPackage.add(value); return this; } @@ -24962,7 +24983,7 @@ public final class Public { * @return this */ public Char addAllNextPackage(final byte... values) { - bitField0_ |= 0x00001000; + bitField0_ |= 0x00002000; nextPackage.addAll(values); return this; } @@ -24973,7 +24994,7 @@ public final class Public { * @return this */ public Char setNextPackage(final byte... values) { - bitField0_ |= 0x00001000; + bitField0_ |= 0x00002000; nextPackage.copyFrom(values); return this; } @@ -24983,7 +25004,7 @@ public final class Public { * @return whether the equipmentIds field is set */ public boolean hasEquipmentIds() { - return (bitField0_ & 0x00002000) != 0; + return (bitField0_ & 0x00004000) != 0; } /** @@ -24991,7 +25012,7 @@ public final class Public { * @return this */ public Char clearEquipmentIds() { - bitField0_ &= ~0x00002000; + bitField0_ &= ~0x00004000; equipmentIds.clear(); return this; } @@ -25020,7 +25041,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedLong getMutableEquipmentIds() { - bitField0_ |= 0x00002000; + bitField0_ |= 0x00004000; return equipmentIds; } @@ -25030,7 +25051,7 @@ public final class Public { * @return this */ public Char addEquipmentIds(final long value) { - bitField0_ |= 0x00002000; + bitField0_ |= 0x00004000; equipmentIds.add(value); return this; } @@ -25041,7 +25062,7 @@ public final class Public { * @return this */ public Char addAllEquipmentIds(final long... values) { - bitField0_ |= 0x00002000; + bitField0_ |= 0x00004000; equipmentIds.addAll(values); return this; } @@ -25051,7 +25072,7 @@ public final class Public { * @return whether the datingLandmarkIds field is set */ public boolean hasDatingLandmarkIds() { - return (bitField0_ & 0x00004000) != 0; + return (bitField0_ & 0x00008000) != 0; } /** @@ -25059,7 +25080,7 @@ public final class Public { * @return this */ public Char clearDatingLandmarkIds() { - bitField0_ &= ~0x00004000; + bitField0_ &= ~0x00008000; datingLandmarkIds.clear(); return this; } @@ -25088,7 +25109,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedInt getMutableDatingLandmarkIds() { - bitField0_ |= 0x00004000; + bitField0_ |= 0x00008000; return datingLandmarkIds; } @@ -25098,7 +25119,7 @@ public final class Public { * @return this */ public Char addDatingLandmarkIds(final int value) { - bitField0_ |= 0x00004000; + bitField0_ |= 0x00008000; datingLandmarkIds.add(value); return this; } @@ -25109,7 +25130,7 @@ public final class Public { * @return this */ public Char addAllDatingLandmarkIds(final int... values) { - bitField0_ |= 0x00004000; + bitField0_ |= 0x00008000; datingLandmarkIds.addAll(values); return this; } @@ -25119,7 +25140,7 @@ public final class Public { * @return whether the datingEventIds field is set */ public boolean hasDatingEventIds() { - return (bitField0_ & 0x00008000) != 0; + return (bitField0_ & 0x00010000) != 0; } /** @@ -25127,7 +25148,7 @@ public final class Public { * @return this */ public Char clearDatingEventIds() { - bitField0_ &= ~0x00008000; + bitField0_ &= ~0x00010000; datingEventIds.clear(); return this; } @@ -25156,7 +25177,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedInt getMutableDatingEventIds() { - bitField0_ |= 0x00008000; + bitField0_ |= 0x00010000; return datingEventIds; } @@ -25166,7 +25187,7 @@ public final class Public { * @return this */ public Char addDatingEventIds(final int value) { - bitField0_ |= 0x00008000; + bitField0_ |= 0x00010000; datingEventIds.add(value); return this; } @@ -25177,7 +25198,7 @@ public final class Public { * @return this */ public Char addAllDatingEventIds(final int... values) { - bitField0_ |= 0x00008000; + bitField0_ |= 0x00010000; datingEventIds.addAll(values); return this; } @@ -25187,7 +25208,7 @@ public final class Public { * @return whether the datingEventRewardIds field is set */ public boolean hasDatingEventRewardIds() { - return (bitField0_ & 0x00010000) != 0; + return (bitField0_ & 0x00020000) != 0; } /** @@ -25195,7 +25216,7 @@ public final class Public { * @return this */ public Char clearDatingEventRewardIds() { - bitField0_ &= ~0x00010000; + bitField0_ &= ~0x00020000; datingEventRewardIds.clear(); return this; } @@ -25224,7 +25245,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedInt getMutableDatingEventRewardIds() { - bitField0_ |= 0x00010000; + bitField0_ |= 0x00020000; return datingEventRewardIds; } @@ -25234,7 +25255,7 @@ public final class Public { * @return this */ public Char addDatingEventRewardIds(final int value) { - bitField0_ |= 0x00010000; + bitField0_ |= 0x00020000; datingEventRewardIds.add(value); return this; } @@ -25245,7 +25266,7 @@ public final class Public { * @return this */ public Char addAllDatingEventRewardIds(final int... values) { - bitField0_ |= 0x00010000; + bitField0_ |= 0x00020000; datingEventRewardIds.addAll(values); return this; } @@ -25255,7 +25276,7 @@ public final class Public { * @return whether the skillLvs field is set */ public boolean hasSkillLvs() { - return (bitField0_ & 0x00020000) != 0; + return (bitField0_ & 0x00040000) != 0; } /** @@ -25263,7 +25284,7 @@ public final class Public { * @return this */ public Char clearSkillLvs() { - bitField0_ &= ~0x00020000; + bitField0_ &= ~0x00040000; skillLvs.clear(); return this; } @@ -25292,7 +25313,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedInt getMutableSkillLvs() { - bitField0_ |= 0x00020000; + bitField0_ |= 0x00040000; return skillLvs; } @@ -25302,7 +25323,7 @@ public final class Public { * @return this */ public Char addSkillLvs(final int value) { - bitField0_ |= 0x00020000; + bitField0_ |= 0x00040000; skillLvs.add(value); return this; } @@ -25313,7 +25334,7 @@ public final class Public { * @return this */ public Char addAllSkillLvs(final int... values) { - bitField0_ |= 0x00020000; + bitField0_ |= 0x00040000; skillLvs.addAll(values); return this; } @@ -25323,7 +25344,7 @@ public final class Public { * @return whether the plots field is set */ public boolean hasPlots() { - return (bitField0_ & 0x00040000) != 0; + return (bitField0_ & 0x00080000) != 0; } /** @@ -25331,7 +25352,7 @@ public final class Public { * @return this */ public Char clearPlots() { - bitField0_ &= ~0x00040000; + bitField0_ &= ~0x00080000; plots.clear(); return this; } @@ -25360,7 +25381,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedInt getMutablePlots() { - bitField0_ |= 0x00040000; + bitField0_ |= 0x00080000; return plots; } @@ -25370,7 +25391,7 @@ public final class Public { * @return this */ public Char addPlots(final int value) { - bitField0_ |= 0x00040000; + bitField0_ |= 0x00080000; plots.add(value); return this; } @@ -25381,7 +25402,7 @@ public final class Public { * @return this */ public Char addAllPlots(final int... values) { - bitField0_ |= 0x00040000; + bitField0_ |= 0x00080000; plots.addAll(values); return this; } @@ -25391,7 +25412,7 @@ public final class Public { * @return whether the archiveRewardIds field is set */ public boolean hasArchiveRewardIds() { - return (bitField0_ & 0x00080000) != 0; + return (bitField0_ & 0x00100000) != 0; } /** @@ -25399,7 +25420,7 @@ public final class Public { * @return this */ public Char clearArchiveRewardIds() { - bitField0_ &= ~0x00080000; + bitField0_ &= ~0x00100000; archiveRewardIds.clear(); return this; } @@ -25428,7 +25449,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedInt getMutableArchiveRewardIds() { - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; return archiveRewardIds; } @@ -25438,7 +25459,7 @@ public final class Public { * @return this */ public Char addArchiveRewardIds(final int value) { - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; archiveRewardIds.add(value); return this; } @@ -25449,7 +25470,7 @@ public final class Public { * @return this */ public Char addAllArchiveRewardIds(final int... values) { - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; archiveRewardIds.addAll(values); return this; } @@ -25459,7 +25480,7 @@ public final class Public { * @return whether the charGemSlots field is set */ public boolean hasCharGemSlots() { - return (bitField0_ & 0x00100000) != 0; + return (bitField0_ & 0x00200000) != 0; } /** @@ -25467,7 +25488,7 @@ public final class Public { * @return this */ public Char clearCharGemSlots() { - bitField0_ &= ~0x00100000; + bitField0_ &= ~0x00200000; charGemSlots.clear(); return this; } @@ -25496,7 +25517,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedMessage getMutableCharGemSlots() { - bitField0_ |= 0x00100000; + bitField0_ |= 0x00200000; return charGemSlots; } @@ -25506,7 +25527,7 @@ public final class Public { * @return this */ public Char addCharGemSlots(final CharGemSlot value) { - bitField0_ |= 0x00100000; + bitField0_ |= 0x00200000; charGemSlots.add(value); return this; } @@ -25517,7 +25538,7 @@ public final class Public { * @return this */ public Char addAllCharGemSlots(final CharGemSlot... values) { - bitField0_ |= 0x00100000; + bitField0_ |= 0x00200000; charGemSlots.addAll(values); return this; } @@ -25536,6 +25557,7 @@ public final class Public { affinityExp = other.affinityExp; advance = other.advance; talentBackground = other.talentBackground; + isFavorite = other.isFavorite; affinityQuests.copyFrom(other.affinityQuests); charGemPresets.copyFrom(other.charGemPresets); talentNodes.copyFrom(other.talentNodes); @@ -25585,6 +25607,9 @@ public final class Public { if (other.hasTalentBackground()) { setTalentBackground(other.talentBackground); } + if (other.hasIsFavorite()) { + setIsFavorite(other.isFavorite); + } if (other.hasAffinityQuests()) { getMutableAffinityQuests().mergeFrom(other.affinityQuests); } @@ -25640,6 +25665,7 @@ public final class Public { affinityExp = 0; advance = 0; talentBackground = 0; + isFavorite = false; affinityQuests.clear(); charGemPresets.clear(); talentNodes.clear(); @@ -25696,6 +25722,7 @@ public final class Public { && (!hasAffinityExp() || affinityExp == other.affinityExp) && (!hasAdvance() || advance == other.advance) && (!hasTalentBackground() || talentBackground == other.talentBackground) + && (!hasIsFavorite() || isFavorite == other.isFavorite) && (!hasAffinityQuests() || affinityQuests.equals(other.affinityQuests)) && (!hasCharGemPresets() || charGemPresets.equals(other.charGemPresets)) && (!hasTalentNodes() || talentNodes.equals(other.talentNodes)) @@ -25749,64 +25776,68 @@ public final class Public { output.writeUInt32NoTag(talentBackground); } if ((bitField0_ & 0x00000200) != 0) { + output.writeRawLittleEndian16((short) 504); + output.writeBoolNoTag(isFavorite); + } + if ((bitField0_ & 0x00000400) != 0) { output.writeRawLittleEndian16((short) 394); output.writeMessageNoTag(affinityQuests); } - if ((bitField0_ & 0x00000400) != 0) { + if ((bitField0_ & 0x00000800) != 0) { output.writeRawLittleEndian16((short) 442); output.writeMessageNoTag(charGemPresets); } - if ((bitField0_ & 0x00000800) != 0) { + if ((bitField0_ & 0x00001000) != 0) { output.writeRawLittleEndian16((short) 410); output.writeBytesNoTag(talentNodes); } - if ((bitField0_ & 0x00001000) != 0) { + if ((bitField0_ & 0x00002000) != 0) { output.writeRawLittleEndian16((short) 32762); output.writeBytesNoTag(nextPackage); } - if ((bitField0_ & 0x00002000) != 0) { + if ((bitField0_ & 0x00004000) != 0) { for (int i = 0; i < equipmentIds.length(); i++) { output.writeRawByte((byte) 48); output.writeUInt64NoTag(equipmentIds.array()[i]); } } - if ((bitField0_ & 0x00004000) != 0) { + if ((bitField0_ & 0x00008000) != 0) { for (int i = 0; i < datingLandmarkIds.length(); i++) { output.writeRawByte((byte) 24); output.writeUInt32NoTag(datingLandmarkIds.array()[i]); } } - if ((bitField0_ & 0x00008000) != 0) { + if ((bitField0_ & 0x00010000) != 0) { for (int i = 0; i < datingEventIds.length(); i++) { output.writeRawByte((byte) 32); output.writeUInt32NoTag(datingEventIds.array()[i]); } } - if ((bitField0_ & 0x00010000) != 0) { + if ((bitField0_ & 0x00020000) != 0) { for (int i = 0; i < datingEventRewardIds.length(); i++) { output.writeRawByte((byte) 40); output.writeUInt32NoTag(datingEventRewardIds.array()[i]); } } - if ((bitField0_ & 0x00020000) != 0) { + if ((bitField0_ & 0x00040000) != 0) { for (int i = 0; i < skillLvs.length(); i++) { output.writeRawByte((byte) 80); output.writeUInt32NoTag(skillLvs.array()[i]); } } - if ((bitField0_ & 0x00040000) != 0) { + if ((bitField0_ & 0x00080000) != 0) { for (int i = 0; i < plots.length(); i++) { output.writeRawLittleEndian16((short) 384); output.writeUInt32NoTag(plots.array()[i]); } } - if ((bitField0_ & 0x00080000) != 0) { + if ((bitField0_ & 0x00100000) != 0) { for (int i = 0; i < archiveRewardIds.length(); i++) { output.writeRawLittleEndian16((short) 416); output.writeUInt32NoTag(archiveRewardIds.array()[i]); } } - if ((bitField0_ & 0x00100000) != 0) { + if ((bitField0_ & 0x00200000) != 0) { for (int i = 0; i < charGemSlots.length(); i++) { output.writeRawLittleEndian16((short) 434); output.writeMessageNoTag(charGemSlots.get(i)); @@ -25845,39 +25876,42 @@ public final class Public { size += 2 + ProtoSink.computeUInt32SizeNoTag(talentBackground); } if ((bitField0_ & 0x00000200) != 0) { - size += 2 + ProtoSink.computeMessageSizeNoTag(affinityQuests); + size += 3; } if ((bitField0_ & 0x00000400) != 0) { - size += 2 + ProtoSink.computeMessageSizeNoTag(charGemPresets); + size += 2 + ProtoSink.computeMessageSizeNoTag(affinityQuests); } if ((bitField0_ & 0x00000800) != 0) { - size += 2 + ProtoSink.computeBytesSizeNoTag(talentNodes); + size += 2 + ProtoSink.computeMessageSizeNoTag(charGemPresets); } if ((bitField0_ & 0x00001000) != 0) { - size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + size += 2 + ProtoSink.computeBytesSizeNoTag(talentNodes); } if ((bitField0_ & 0x00002000) != 0) { - size += (1 * equipmentIds.length()) + ProtoSink.computeRepeatedUInt64SizeNoTag(equipmentIds); + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); } if ((bitField0_ & 0x00004000) != 0) { - size += (1 * datingLandmarkIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(datingLandmarkIds); + size += (1 * equipmentIds.length()) + ProtoSink.computeRepeatedUInt64SizeNoTag(equipmentIds); } if ((bitField0_ & 0x00008000) != 0) { - size += (1 * datingEventIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(datingEventIds); + size += (1 * datingLandmarkIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(datingLandmarkIds); } if ((bitField0_ & 0x00010000) != 0) { - size += (1 * datingEventRewardIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(datingEventRewardIds); + size += (1 * datingEventIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(datingEventIds); } if ((bitField0_ & 0x00020000) != 0) { - size += (1 * skillLvs.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(skillLvs); + size += (1 * datingEventRewardIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(datingEventRewardIds); } if ((bitField0_ & 0x00040000) != 0) { - size += (2 * plots.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(plots); + size += (1 * skillLvs.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(skillLvs); } if ((bitField0_ & 0x00080000) != 0) { - size += (2 * archiveRewardIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(archiveRewardIds); + size += (2 * plots.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(plots); } if ((bitField0_ & 0x00100000) != 0) { + size += (2 * archiveRewardIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(archiveRewardIds); + } + if ((bitField0_ & 0x00200000) != 0) { size += (2 * charGemSlots.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(charGemSlots); } return size; @@ -25967,6 +26001,15 @@ public final class Public { talentBackground = input.readUInt32(); bitField0_ |= 0x00000100; tag = input.readTag(); + if (tag != 248) { + break; + } + } + case 248: { + // isFavorite + isFavorite = input.readBool(); + bitField0_ |= 0x00000200; + tag = input.readTag(); if (tag != 138) { break; } @@ -25974,7 +26017,7 @@ public final class Public { case 138: { // affinityQuests input.readMessage(affinityQuests); - bitField0_ |= 0x00000200; + bitField0_ |= 0x00000400; tag = input.readTag(); if (tag != 186) { break; @@ -25983,7 +26026,7 @@ public final class Public { case 186: { // charGemPresets input.readMessage(charGemPresets); - bitField0_ |= 0x00000400; + bitField0_ |= 0x00000800; tag = input.readTag(); if (tag != 154) { break; @@ -25992,7 +26035,7 @@ public final class Public { case 154: { // talentNodes input.readBytes(talentNodes); - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; tag = input.readTag(); if (tag != 16378) { break; @@ -26001,7 +26044,7 @@ public final class Public { case 16378: { // nextPackage input.readBytes(nextPackage); - bitField0_ |= 0x00001000; + bitField0_ |= 0x00002000; tag = input.readTag(); if (tag != 50) { break; @@ -26010,7 +26053,7 @@ public final class Public { case 50: { // equipmentIds [packed=true] input.readPackedUInt64(equipmentIds, tag); - bitField0_ |= 0x00002000; + bitField0_ |= 0x00004000; tag = input.readTag(); if (tag != 26) { break; @@ -26019,7 +26062,7 @@ public final class Public { case 26: { // datingLandmarkIds [packed=true] input.readPackedUInt32(datingLandmarkIds, tag); - bitField0_ |= 0x00004000; + bitField0_ |= 0x00008000; tag = input.readTag(); if (tag != 34) { break; @@ -26028,7 +26071,7 @@ public final class Public { case 34: { // datingEventIds [packed=true] input.readPackedUInt32(datingEventIds, tag); - bitField0_ |= 0x00008000; + bitField0_ |= 0x00010000; tag = input.readTag(); if (tag != 42) { break; @@ -26037,7 +26080,7 @@ public final class Public { case 42: { // datingEventRewardIds [packed=true] input.readPackedUInt32(datingEventRewardIds, tag); - bitField0_ |= 0x00010000; + bitField0_ |= 0x00020000; tag = input.readTag(); if (tag != 82) { break; @@ -26046,7 +26089,7 @@ public final class Public { case 82: { // skillLvs [packed=true] input.readPackedUInt32(skillLvs, tag); - bitField0_ |= 0x00020000; + bitField0_ |= 0x00040000; tag = input.readTag(); if (tag != 130) { break; @@ -26055,7 +26098,7 @@ public final class Public { case 130: { // plots [packed=true] input.readPackedUInt32(plots, tag); - bitField0_ |= 0x00040000; + bitField0_ |= 0x00080000; tag = input.readTag(); if (tag != 162) { break; @@ -26064,7 +26107,7 @@ public final class Public { case 162: { // archiveRewardIds [packed=true] input.readPackedUInt32(archiveRewardIds, tag); - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; tag = input.readTag(); if (tag != 178) { break; @@ -26073,7 +26116,7 @@ public final class Public { case 178: { // charGemSlots tag = input.readRepeatedMessage(charGemSlots, tag); - bitField0_ |= 0x00100000; + bitField0_ |= 0x00200000; if (tag != 0) { break; } @@ -26091,43 +26134,43 @@ public final class Public { case 48: { // equipmentIds [packed=false] tag = input.readRepeatedUInt64(equipmentIds, tag); - bitField0_ |= 0x00002000; + bitField0_ |= 0x00004000; break; } case 24: { // datingLandmarkIds [packed=false] tag = input.readRepeatedUInt32(datingLandmarkIds, tag); - bitField0_ |= 0x00004000; + bitField0_ |= 0x00008000; break; } case 32: { // datingEventIds [packed=false] tag = input.readRepeatedUInt32(datingEventIds, tag); - bitField0_ |= 0x00008000; + bitField0_ |= 0x00010000; break; } case 40: { // datingEventRewardIds [packed=false] tag = input.readRepeatedUInt32(datingEventRewardIds, tag); - bitField0_ |= 0x00010000; + bitField0_ |= 0x00020000; break; } case 80: { // skillLvs [packed=false] tag = input.readRepeatedUInt32(skillLvs, tag); - bitField0_ |= 0x00020000; + bitField0_ |= 0x00040000; break; } case 128: { // plots [packed=false] tag = input.readRepeatedUInt32(plots, tag); - bitField0_ |= 0x00040000; + bitField0_ |= 0x00080000; break; } case 160: { // archiveRewardIds [packed=false] tag = input.readRepeatedUInt32(archiveRewardIds, tag); - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; break; } } @@ -26165,39 +26208,42 @@ public final class Public { output.writeUInt32(FieldNames.talentBackground, talentBackground); } if ((bitField0_ & 0x00000200) != 0) { - output.writeMessage(FieldNames.affinityQuests, affinityQuests); + output.writeBool(FieldNames.isFavorite, isFavorite); } if ((bitField0_ & 0x00000400) != 0) { - output.writeMessage(FieldNames.charGemPresets, charGemPresets); + output.writeMessage(FieldNames.affinityQuests, affinityQuests); } if ((bitField0_ & 0x00000800) != 0) { - output.writeBytes(FieldNames.talentNodes, talentNodes); + output.writeMessage(FieldNames.charGemPresets, charGemPresets); } if ((bitField0_ & 0x00001000) != 0) { - output.writeBytes(FieldNames.nextPackage, nextPackage); + output.writeBytes(FieldNames.talentNodes, talentNodes); } if ((bitField0_ & 0x00002000) != 0) { - output.writeRepeatedUInt64(FieldNames.equipmentIds, equipmentIds); + output.writeBytes(FieldNames.nextPackage, nextPackage); } if ((bitField0_ & 0x00004000) != 0) { - output.writeRepeatedUInt32(FieldNames.datingLandmarkIds, datingLandmarkIds); + output.writeRepeatedUInt64(FieldNames.equipmentIds, equipmentIds); } if ((bitField0_ & 0x00008000) != 0) { - output.writeRepeatedUInt32(FieldNames.datingEventIds, datingEventIds); + output.writeRepeatedUInt32(FieldNames.datingLandmarkIds, datingLandmarkIds); } if ((bitField0_ & 0x00010000) != 0) { - output.writeRepeatedUInt32(FieldNames.datingEventRewardIds, datingEventRewardIds); + output.writeRepeatedUInt32(FieldNames.datingEventIds, datingEventIds); } if ((bitField0_ & 0x00020000) != 0) { - output.writeRepeatedUInt32(FieldNames.skillLvs, skillLvs); + output.writeRepeatedUInt32(FieldNames.datingEventRewardIds, datingEventRewardIds); } if ((bitField0_ & 0x00040000) != 0) { - output.writeRepeatedUInt32(FieldNames.plots, plots); + output.writeRepeatedUInt32(FieldNames.skillLvs, skillLvs); } if ((bitField0_ & 0x00080000) != 0) { - output.writeRepeatedUInt32(FieldNames.archiveRewardIds, archiveRewardIds); + output.writeRepeatedUInt32(FieldNames.plots, plots); } if ((bitField0_ & 0x00100000) != 0) { + output.writeRepeatedUInt32(FieldNames.archiveRewardIds, archiveRewardIds); + } + if ((bitField0_ & 0x00200000) != 0) { output.writeRepeatedMessage(FieldNames.charGemSlots, charGemSlots); } output.endObject(); @@ -26309,11 +26355,22 @@ public final class Public { } break; } + case -2043982586: { + if (input.isAtField(FieldNames.isFavorite)) { + if (!input.trySkipNullValue()) { + isFavorite = input.readBool(); + bitField0_ |= 0x00000200; + } + } else { + input.skipUnknownField(); + } + break; + } case -278042823: { if (input.isAtField(FieldNames.affinityQuests)) { if (!input.trySkipNullValue()) { input.readMessage(affinityQuests); - bitField0_ |= 0x00000200; + bitField0_ |= 0x00000400; } } else { input.skipUnknownField(); @@ -26324,7 +26381,7 @@ public final class Public { if (input.isAtField(FieldNames.charGemPresets)) { if (!input.trySkipNullValue()) { input.readMessage(charGemPresets); - bitField0_ |= 0x00000400; + bitField0_ |= 0x00000800; } } else { input.skipUnknownField(); @@ -26335,7 +26392,7 @@ public final class Public { if (input.isAtField(FieldNames.talentNodes)) { if (!input.trySkipNullValue()) { input.readBytes(talentNodes); - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; } } else { input.skipUnknownField(); @@ -26346,7 +26403,7 @@ public final class Public { if (input.isAtField(FieldNames.nextPackage)) { if (!input.trySkipNullValue()) { input.readBytes(nextPackage); - bitField0_ |= 0x00001000; + bitField0_ |= 0x00002000; } } else { input.skipUnknownField(); @@ -26357,7 +26414,7 @@ public final class Public { if (input.isAtField(FieldNames.equipmentIds)) { if (!input.trySkipNullValue()) { input.readRepeatedUInt64(equipmentIds); - bitField0_ |= 0x00002000; + bitField0_ |= 0x00004000; } } else { input.skipUnknownField(); @@ -26368,7 +26425,7 @@ public final class Public { if (input.isAtField(FieldNames.datingLandmarkIds)) { if (!input.trySkipNullValue()) { input.readRepeatedUInt32(datingLandmarkIds); - bitField0_ |= 0x00004000; + bitField0_ |= 0x00008000; } } else { input.skipUnknownField(); @@ -26379,7 +26436,7 @@ public final class Public { if (input.isAtField(FieldNames.datingEventIds)) { if (!input.trySkipNullValue()) { input.readRepeatedUInt32(datingEventIds); - bitField0_ |= 0x00008000; + bitField0_ |= 0x00010000; } } else { input.skipUnknownField(); @@ -26390,7 +26447,7 @@ public final class Public { if (input.isAtField(FieldNames.datingEventRewardIds)) { if (!input.trySkipNullValue()) { input.readRepeatedUInt32(datingEventRewardIds); - bitField0_ |= 0x00010000; + bitField0_ |= 0x00020000; } } else { input.skipUnknownField(); @@ -26401,7 +26458,7 @@ public final class Public { if (input.isAtField(FieldNames.skillLvs)) { if (!input.trySkipNullValue()) { input.readRepeatedUInt32(skillLvs); - bitField0_ |= 0x00020000; + bitField0_ |= 0x00040000; } } else { input.skipUnknownField(); @@ -26412,7 +26469,7 @@ public final class Public { if (input.isAtField(FieldNames.plots)) { if (!input.trySkipNullValue()) { input.readRepeatedUInt32(plots); - bitField0_ |= 0x00040000; + bitField0_ |= 0x00080000; } } else { input.skipUnknownField(); @@ -26423,7 +26480,7 @@ public final class Public { if (input.isAtField(FieldNames.archiveRewardIds)) { if (!input.trySkipNullValue()) { input.readRepeatedUInt32(archiveRewardIds); - bitField0_ |= 0x00080000; + bitField0_ |= 0x00100000; } } else { input.skipUnknownField(); @@ -26434,7 +26491,7 @@ public final class Public { if (input.isAtField(FieldNames.charGemSlots)) { if (!input.trySkipNullValue()) { input.readRepeatedMessage(charGemSlots); - bitField0_ |= 0x00100000; + bitField0_ |= 0x00200000; } } else { input.skipUnknownField(); @@ -26511,6 +26568,8 @@ public final class Public { static final FieldName talentBackground = FieldName.forField("TalentBackground"); + static final FieldName isFavorite = FieldName.forField("IsFavorite"); + static final FieldName affinityQuests = FieldName.forField("AffinityQuests"); static final FieldName charGemPresets = FieldName.forField("CharGemPresets"); @@ -30884,6 +30943,11 @@ public final class Public { */ private int newId; + /** + * optional uint32 Level = 2; + */ + private int level; + /** * optional bytes NextPackage = 2047; */ @@ -30936,12 +31000,49 @@ public final class Public { return this; } + /** + * optional uint32 Level = 2; + * @return whether the level field is set + */ + public boolean hasLevel() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 Level = 2; + * @return this + */ + public Honor clearLevel() { + bitField0_ &= ~0x00000002; + level = 0; + return this; + } + + /** + * optional uint32 Level = 2; + * @return the level + */ + public int getLevel() { + return level; + } + + /** + * optional uint32 Level = 2; + * @param value the level to set + * @return this + */ + public Honor setLevel(final int value) { + bitField0_ |= 0x00000002; + level = value; + return this; + } + /** * optional bytes NextPackage = 2047; * @return whether the nextPackage field is set */ public boolean hasNextPackage() { - return (bitField0_ & 0x00000002) != 0; + return (bitField0_ & 0x00000004) != 0; } /** @@ -30949,7 +31050,7 @@ public final class Public { * @return this */ public Honor clearNextPackage() { - bitField0_ &= ~0x00000002; + bitField0_ &= ~0x00000004; nextPackage.clear(); return this; } @@ -30978,7 +31079,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedByte getMutableNextPackage() { - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; return nextPackage; } @@ -30988,7 +31089,7 @@ public final class Public { * @return this */ public Honor addNextPackage(final byte value) { - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; nextPackage.add(value); return this; } @@ -30999,7 +31100,7 @@ public final class Public { * @return this */ public Honor addAllNextPackage(final byte... values) { - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; nextPackage.addAll(values); return this; } @@ -31010,7 +31111,7 @@ public final class Public { * @return this */ public Honor setNextPackage(final byte... values) { - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; nextPackage.copyFrom(values); return this; } @@ -31021,6 +31122,7 @@ public final class Public { if ((bitField0_ | other.bitField0_) != 0) { bitField0_ = other.bitField0_; newId = other.newId; + level = other.level; nextPackage.copyFrom(other.nextPackage); } return this; @@ -31035,6 +31137,9 @@ public final class Public { if (other.hasNewId()) { setNewId(other.newId); } + if (other.hasLevel()) { + setLevel(other.level); + } if (other.hasNextPackage()) { getMutableNextPackage().copyFrom(other.nextPackage); } @@ -31049,6 +31154,7 @@ public final class Public { cachedSize = -1; bitField0_ = 0; newId = 0; + level = 0; nextPackage.clear(); return this; } @@ -31075,6 +31181,7 @@ public final class Public { Honor other = (Honor) o; return bitField0_ == other.bitField0_ && (!hasNewId() || newId == other.newId) + && (!hasLevel() || level == other.level) && (!hasNextPackage() || nextPackage.equals(other.nextPackage)); } @@ -31085,6 +31192,10 @@ public final class Public { output.writeUInt32NoTag(newId); } if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(level); + } + if ((bitField0_ & 0x00000004) != 0) { output.writeRawLittleEndian16((short) 32762); output.writeBytesNoTag(nextPackage); } @@ -31097,6 +31208,9 @@ public final class Public { size += 1 + ProtoSink.computeUInt32SizeNoTag(newId); } if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(level); + } + if ((bitField0_ & 0x00000004) != 0) { size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); } return size; @@ -31114,6 +31228,15 @@ public final class Public { newId = input.readUInt32(); bitField0_ |= 0x00000001; tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // level + level = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); if (tag != 16378) { break; } @@ -31121,7 +31244,7 @@ public final class Public { case 16378: { // nextPackage input.readBytes(nextPackage); - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; tag = input.readTag(); if (tag != 0) { break; @@ -31148,6 +31271,9 @@ public final class Public { output.writeUInt32(FieldNames.newId, newId); } if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.level, level); + } + if ((bitField0_ & 0x00000004) != 0) { output.writeBytes(FieldNames.nextPackage, nextPackage); } output.endObject(); @@ -31171,11 +31297,22 @@ public final class Public { } break; } + case 73313124: { + if (input.isAtField(FieldNames.level)) { + if (!input.trySkipNullValue()) { + level = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } case -2082324045: { if (input.isAtField(FieldNames.nextPackage)) { if (!input.trySkipNullValue()) { input.readBytes(nextPackage); - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; } } else { input.skipUnknownField(); @@ -31236,6 +31373,8 @@ public final class Public { static class FieldNames { static final FieldName newId = FieldName.forField("NewId"); + static final FieldName level = FieldName.forField("Level"); + static final FieldName nextPackage = FieldName.forField("NextPackage"); } } @@ -31646,6 +31785,11 @@ public final class Public { public static final class FormationInfo extends ProtoMessage implements Cloneable { private static final long serialVersionUID = 0L; + /** + * optional uint64 PreselectionId = 4; + */ + private long preselectionId; + /** * optional uint32 Number = 1; */ @@ -31676,12 +31820,49 @@ public final class Public { return new FormationInfo(); } + /** + * optional uint64 PreselectionId = 4; + * @return whether the preselectionId field is set + */ + public boolean hasPreselectionId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint64 PreselectionId = 4; + * @return this + */ + public FormationInfo clearPreselectionId() { + bitField0_ &= ~0x00000001; + preselectionId = 0L; + return this; + } + + /** + * optional uint64 PreselectionId = 4; + * @return the preselectionId + */ + public long getPreselectionId() { + return preselectionId; + } + + /** + * optional uint64 PreselectionId = 4; + * @param value the preselectionId to set + * @return this + */ + public FormationInfo setPreselectionId(final long value) { + bitField0_ |= 0x00000001; + preselectionId = value; + return this; + } + /** * optional uint32 Number = 1; * @return whether the number field is set */ public boolean hasNumber() { - return (bitField0_ & 0x00000001) != 0; + return (bitField0_ & 0x00000002) != 0; } /** @@ -31689,7 +31870,7 @@ public final class Public { * @return this */ public FormationInfo clearNumber() { - bitField0_ &= ~0x00000001; + bitField0_ &= ~0x00000002; number = 0; return this; } @@ -31708,7 +31889,7 @@ public final class Public { * @return this */ public FormationInfo setNumber(final int value) { - bitField0_ |= 0x00000001; + bitField0_ |= 0x00000002; number = value; return this; } @@ -31718,7 +31899,7 @@ public final class Public { * @return whether the nextPackage field is set */ public boolean hasNextPackage() { - return (bitField0_ & 0x00000002) != 0; + return (bitField0_ & 0x00000004) != 0; } /** @@ -31726,7 +31907,7 @@ public final class Public { * @return this */ public FormationInfo clearNextPackage() { - bitField0_ &= ~0x00000002; + bitField0_ &= ~0x00000004; nextPackage.clear(); return this; } @@ -31755,7 +31936,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedByte getMutableNextPackage() { - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; return nextPackage; } @@ -31765,7 +31946,7 @@ public final class Public { * @return this */ public FormationInfo addNextPackage(final byte value) { - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; nextPackage.add(value); return this; } @@ -31776,7 +31957,7 @@ public final class Public { * @return this */ public FormationInfo addAllNextPackage(final byte... values) { - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; nextPackage.addAll(values); return this; } @@ -31787,7 +31968,7 @@ public final class Public { * @return this */ public FormationInfo setNextPackage(final byte... values) { - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; nextPackage.copyFrom(values); return this; } @@ -31797,7 +31978,7 @@ public final class Public { * @return whether the charIds field is set */ public boolean hasCharIds() { - return (bitField0_ & 0x00000004) != 0; + return (bitField0_ & 0x00000008) != 0; } /** @@ -31805,7 +31986,7 @@ public final class Public { * @return this */ public FormationInfo clearCharIds() { - bitField0_ &= ~0x00000004; + bitField0_ &= ~0x00000008; charIds.clear(); return this; } @@ -31834,7 +32015,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedInt getMutableCharIds() { - bitField0_ |= 0x00000004; + bitField0_ |= 0x00000008; return charIds; } @@ -31844,7 +32025,7 @@ public final class Public { * @return this */ public FormationInfo addCharIds(final int value) { - bitField0_ |= 0x00000004; + bitField0_ |= 0x00000008; charIds.add(value); return this; } @@ -31855,7 +32036,7 @@ public final class Public { * @return this */ public FormationInfo addAllCharIds(final int... values) { - bitField0_ |= 0x00000004; + bitField0_ |= 0x00000008; charIds.addAll(values); return this; } @@ -31865,7 +32046,7 @@ public final class Public { * @return whether the discIds field is set */ public boolean hasDiscIds() { - return (bitField0_ & 0x00000008) != 0; + return (bitField0_ & 0x00000010) != 0; } /** @@ -31873,7 +32054,7 @@ public final class Public { * @return this */ public FormationInfo clearDiscIds() { - bitField0_ &= ~0x00000008; + bitField0_ &= ~0x00000010; discIds.clear(); return this; } @@ -31902,7 +32083,7 @@ public final class Public { * @return internal storage object for modifications */ public RepeatedInt getMutableDiscIds() { - bitField0_ |= 0x00000008; + bitField0_ |= 0x00000010; return discIds; } @@ -31912,7 +32093,7 @@ public final class Public { * @return this */ public FormationInfo addDiscIds(final int value) { - bitField0_ |= 0x00000008; + bitField0_ |= 0x00000010; discIds.add(value); return this; } @@ -31923,7 +32104,7 @@ public final class Public { * @return this */ public FormationInfo addAllDiscIds(final int... values) { - bitField0_ |= 0x00000008; + bitField0_ |= 0x00000010; discIds.addAll(values); return this; } @@ -31933,6 +32114,7 @@ public final class Public { cachedSize = other.cachedSize; if ((bitField0_ | other.bitField0_) != 0) { bitField0_ = other.bitField0_; + preselectionId = other.preselectionId; number = other.number; nextPackage.copyFrom(other.nextPackage); charIds.copyFrom(other.charIds); @@ -31947,6 +32129,9 @@ public final class Public { return this; } cachedSize = -1; + if (other.hasPreselectionId()) { + setPreselectionId(other.preselectionId); + } if (other.hasNumber()) { setNumber(other.number); } @@ -31969,6 +32154,7 @@ public final class Public { } cachedSize = -1; bitField0_ = 0; + preselectionId = 0L; number = 0; nextPackage.clear(); charIds.clear(); @@ -31999,6 +32185,7 @@ public final class Public { } FormationInfo other = (FormationInfo) o; return bitField0_ == other.bitField0_ + && (!hasPreselectionId() || preselectionId == other.preselectionId) && (!hasNumber() || number == other.number) && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) && (!hasCharIds() || charIds.equals(other.charIds)) @@ -32008,20 +32195,24 @@ public final class Public { @Override public void writeTo(final ProtoSink output) throws IOException { if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 32); + output.writeUInt64NoTag(preselectionId); + } + if ((bitField0_ & 0x00000002) != 0) { output.writeRawByte((byte) 8); output.writeUInt32NoTag(number); } - if ((bitField0_ & 0x00000002) != 0) { + if ((bitField0_ & 0x00000004) != 0) { output.writeRawLittleEndian16((short) 32762); output.writeBytesNoTag(nextPackage); } - if ((bitField0_ & 0x00000004) != 0) { + if ((bitField0_ & 0x00000008) != 0) { for (int i = 0; i < charIds.length(); i++) { output.writeRawByte((byte) 16); output.writeUInt32NoTag(charIds.array()[i]); } } - if ((bitField0_ & 0x00000008) != 0) { + if ((bitField0_ & 0x00000010) != 0) { for (int i = 0; i < discIds.length(); i++) { output.writeRawByte((byte) 24); output.writeUInt32NoTag(discIds.array()[i]); @@ -32033,15 +32224,18 @@ public final class Public { protected int computeSerializedSize() { int size = 0; if ((bitField0_ & 0x00000001) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(number); + size += 1 + ProtoSink.computeUInt64SizeNoTag(preselectionId); } if ((bitField0_ & 0x00000002) != 0) { - size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + size += 1 + ProtoSink.computeUInt32SizeNoTag(number); } if ((bitField0_ & 0x00000004) != 0) { - size += (1 * charIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(charIds); + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); } if ((bitField0_ & 0x00000008) != 0) { + size += (1 * charIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(charIds); + } + if ((bitField0_ & 0x00000010) != 0) { size += (1 * discIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(discIds); } return size; @@ -32054,10 +32248,19 @@ public final class Public { int tag = input.readTag(); while (true) { switch (tag) { + case 32: { + // preselectionId + preselectionId = input.readUInt64(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 8) { + break; + } + } case 8: { // number number = input.readUInt32(); - bitField0_ |= 0x00000001; + bitField0_ |= 0x00000002; tag = input.readTag(); if (tag != 16378) { break; @@ -32066,7 +32269,7 @@ public final class Public { case 16378: { // nextPackage input.readBytes(nextPackage); - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; tag = input.readTag(); if (tag != 18) { break; @@ -32075,7 +32278,7 @@ public final class Public { case 18: { // charIds [packed=true] input.readPackedUInt32(charIds, tag); - bitField0_ |= 0x00000004; + bitField0_ |= 0x00000008; tag = input.readTag(); if (tag != 26) { break; @@ -32084,7 +32287,7 @@ public final class Public { case 26: { // discIds [packed=true] input.readPackedUInt32(discIds, tag); - bitField0_ |= 0x00000008; + bitField0_ |= 0x00000010; tag = input.readTag(); if (tag != 0) { break; @@ -32103,13 +32306,13 @@ public final class Public { case 16: { // charIds [packed=false] tag = input.readRepeatedUInt32(charIds, tag); - bitField0_ |= 0x00000004; + bitField0_ |= 0x00000008; break; } case 24: { // discIds [packed=false] tag = input.readRepeatedUInt32(discIds, tag); - bitField0_ |= 0x00000008; + bitField0_ |= 0x00000010; break; } } @@ -32120,15 +32323,18 @@ public final class Public { public void writeTo(final JsonSink output) throws IOException { output.beginObject(); if ((bitField0_ & 0x00000001) != 0) { - output.writeUInt32(FieldNames.number, number); + output.writeUInt64(FieldNames.preselectionId, preselectionId); } if ((bitField0_ & 0x00000002) != 0) { - output.writeBytes(FieldNames.nextPackage, nextPackage); + output.writeUInt32(FieldNames.number, number); } if ((bitField0_ & 0x00000004) != 0) { - output.writeRepeatedUInt32(FieldNames.charIds, charIds); + output.writeBytes(FieldNames.nextPackage, nextPackage); } if ((bitField0_ & 0x00000008) != 0) { + output.writeRepeatedUInt32(FieldNames.charIds, charIds); + } + if ((bitField0_ & 0x00000010) != 0) { output.writeRepeatedUInt32(FieldNames.discIds, discIds); } output.endObject(); @@ -32141,11 +32347,22 @@ public final class Public { } while (!input.isAtEnd()) { switch (input.readFieldHash()) { + case -501191324: { + if (input.isAtField(FieldNames.preselectionId)) { + if (!input.trySkipNullValue()) { + preselectionId = input.readUInt64(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } case -1950496919: { if (input.isAtField(FieldNames.number)) { if (!input.trySkipNullValue()) { number = input.readUInt32(); - bitField0_ |= 0x00000001; + bitField0_ |= 0x00000002; } } else { input.skipUnknownField(); @@ -32156,7 +32373,7 @@ public final class Public { if (input.isAtField(FieldNames.nextPackage)) { if (!input.trySkipNullValue()) { input.readBytes(nextPackage); - bitField0_ |= 0x00000002; + bitField0_ |= 0x00000004; } } else { input.skipUnknownField(); @@ -32167,7 +32384,7 @@ public final class Public { if (input.isAtField(FieldNames.charIds)) { if (!input.trySkipNullValue()) { input.readRepeatedUInt32(charIds); - bitField0_ |= 0x00000004; + bitField0_ |= 0x00000008; } } else { input.skipUnknownField(); @@ -32178,7 +32395,7 @@ public final class Public { if (input.isAtField(FieldNames.discIds)) { if (!input.trySkipNullValue()) { input.readRepeatedUInt32(discIds); - bitField0_ |= 0x00000008; + bitField0_ |= 0x00000010; } } else { input.skipUnknownField(); @@ -32237,6 +32454,8 @@ public final class Public { * Contains name constants used for serializing JSON */ static class FieldNames { + static final FieldName preselectionId = FieldName.forField("PreselectionId"); + static final FieldName number = FieldName.forField("Number"); static final FieldName nextPackage = FieldName.forField("NextPackage"); @@ -69590,6 +69809,16 @@ public final class Public { */ private final RepeatedInt alterAttributes = RepeatedInt.newEmptyInstance(); + /** + * repeated uint32 OverlockCount = 4; + */ + private final RepeatedInt overlockCount = RepeatedInt.newEmptyInstance(); + + /** + * repeated uint32 AlterOverlockCount = 5; + */ + private final RepeatedInt alterOverlockCount = RepeatedInt.newEmptyInstance(); + private CharGem() { } @@ -69852,6 +70081,142 @@ public final class Public { return this; } + /** + * repeated uint32 OverlockCount = 4; + * @return whether the overlockCount field is set + */ + public boolean hasOverlockCount() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * repeated uint32 OverlockCount = 4; + * @return this + */ + public CharGem clearOverlockCount() { + bitField0_ &= ~0x00000010; + overlockCount.clear(); + return this; + } + + /** + * repeated uint32 OverlockCount = 4; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableOverlockCount()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getOverlockCount() { + return overlockCount; + } + + /** + * repeated uint32 OverlockCount = 4; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableOverlockCount() { + bitField0_ |= 0x00000010; + return overlockCount; + } + + /** + * repeated uint32 OverlockCount = 4; + * @param value the overlockCount to add + * @return this + */ + public CharGem addOverlockCount(final int value) { + bitField0_ |= 0x00000010; + overlockCount.add(value); + return this; + } + + /** + * repeated uint32 OverlockCount = 4; + * @param values the overlockCount to add + * @return this + */ + public CharGem addAllOverlockCount(final int... values) { + bitField0_ |= 0x00000010; + overlockCount.addAll(values); + return this; + } + + /** + * repeated uint32 AlterOverlockCount = 5; + * @return whether the alterOverlockCount field is set + */ + public boolean hasAlterOverlockCount() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * repeated uint32 AlterOverlockCount = 5; + * @return this + */ + public CharGem clearAlterOverlockCount() { + bitField0_ &= ~0x00000020; + alterOverlockCount.clear(); + return this; + } + + /** + * repeated uint32 AlterOverlockCount = 5; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableAlterOverlockCount()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getAlterOverlockCount() { + return alterOverlockCount; + } + + /** + * repeated uint32 AlterOverlockCount = 5; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableAlterOverlockCount() { + bitField0_ |= 0x00000020; + return alterOverlockCount; + } + + /** + * repeated uint32 AlterOverlockCount = 5; + * @param value the alterOverlockCount to add + * @return this + */ + public CharGem addAlterOverlockCount(final int value) { + bitField0_ |= 0x00000020; + alterOverlockCount.add(value); + return this; + } + + /** + * repeated uint32 AlterOverlockCount = 5; + * @param values the alterOverlockCount to add + * @return this + */ + public CharGem addAllAlterOverlockCount(final int... values) { + bitField0_ |= 0x00000020; + alterOverlockCount.addAll(values); + return this; + } + @Override public CharGem copyFrom(final CharGem other) { cachedSize = other.cachedSize; @@ -69861,6 +70226,8 @@ public final class Public { nextPackage.copyFrom(other.nextPackage); attributes.copyFrom(other.attributes); alterAttributes.copyFrom(other.alterAttributes); + overlockCount.copyFrom(other.overlockCount); + alterOverlockCount.copyFrom(other.alterOverlockCount); } return this; } @@ -69883,6 +70250,12 @@ public final class Public { if (other.hasAlterAttributes()) { getMutableAlterAttributes().addAll(other.alterAttributes); } + if (other.hasOverlockCount()) { + getMutableOverlockCount().addAll(other.overlockCount); + } + if (other.hasAlterOverlockCount()) { + getMutableAlterOverlockCount().addAll(other.alterOverlockCount); + } return this; } @@ -69897,6 +70270,8 @@ public final class Public { nextPackage.clear(); attributes.clear(); alterAttributes.clear(); + overlockCount.clear(); + alterOverlockCount.clear(); return this; } @@ -69910,6 +70285,8 @@ public final class Public { nextPackage.clear(); attributes.clear(); alterAttributes.clear(); + overlockCount.clear(); + alterOverlockCount.clear(); return this; } @@ -69926,7 +70303,9 @@ public final class Public { && (!hasLock() || lock == other.lock) && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) && (!hasAttributes() || attributes.equals(other.attributes)) - && (!hasAlterAttributes() || alterAttributes.equals(other.alterAttributes)); + && (!hasAlterAttributes() || alterAttributes.equals(other.alterAttributes)) + && (!hasOverlockCount() || overlockCount.equals(other.overlockCount)) + && (!hasAlterOverlockCount() || alterOverlockCount.equals(other.alterOverlockCount)); } @Override @@ -69951,6 +70330,18 @@ public final class Public { output.writeUInt32NoTag(alterAttributes.array()[i]); } } + if ((bitField0_ & 0x00000010) != 0) { + for (int i = 0; i < overlockCount.length(); i++) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(overlockCount.array()[i]); + } + } + if ((bitField0_ & 0x00000020) != 0) { + for (int i = 0; i < alterOverlockCount.length(); i++) { + output.writeRawByte((byte) 40); + output.writeUInt32NoTag(alterOverlockCount.array()[i]); + } + } } @Override @@ -69968,6 +70359,12 @@ public final class Public { if ((bitField0_ & 0x00000008) != 0) { size += (1 * alterAttributes.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(alterAttributes); } + if ((bitField0_ & 0x00000010) != 0) { + size += (1 * overlockCount.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(overlockCount); + } + if ((bitField0_ & 0x00000020) != 0) { + size += (1 * alterOverlockCount.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(alterOverlockCount); + } return size; } @@ -70010,6 +70407,24 @@ public final class Public { input.readPackedUInt32(alterAttributes, tag); bitField0_ |= 0x00000008; tag = input.readTag(); + if (tag != 34) { + break; + } + } + case 34: { + // overlockCount [packed=true] + input.readPackedUInt32(overlockCount, tag); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 42) { + break; + } + } + case 42: { + // alterOverlockCount [packed=true] + input.readPackedUInt32(alterOverlockCount, tag); + bitField0_ |= 0x00000020; + tag = input.readTag(); if (tag != 0) { break; } @@ -70036,6 +70451,18 @@ public final class Public { bitField0_ |= 0x00000008; break; } + case 32: { + // overlockCount [packed=false] + tag = input.readRepeatedUInt32(overlockCount, tag); + bitField0_ |= 0x00000010; + break; + } + case 40: { + // alterOverlockCount [packed=false] + tag = input.readRepeatedUInt32(alterOverlockCount, tag); + bitField0_ |= 0x00000020; + break; + } } } } @@ -70055,6 +70482,12 @@ public final class Public { if ((bitField0_ & 0x00000008) != 0) { output.writeRepeatedUInt32(FieldNames.alterAttributes, alterAttributes); } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRepeatedUInt32(FieldNames.overlockCount, overlockCount); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRepeatedUInt32(FieldNames.alterOverlockCount, alterOverlockCount); + } output.endObject(); } @@ -70109,6 +70542,28 @@ public final class Public { } break; } + case 1950695472: { + if (input.isAtField(FieldNames.overlockCount)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(overlockCount); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1553559558: { + if (input.isAtField(FieldNames.alterOverlockCount)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(alterOverlockCount); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } default: { input.skipUnknownField(); break; @@ -70168,6 +70623,10 @@ public final class Public { static final FieldName attributes = FieldName.forField("Attributes"); static final FieldName alterAttributes = FieldName.forField("AlterAttributes"); + + static final FieldName overlockCount = FieldName.forField("OverlockCount"); + + static final FieldName alterOverlockCount = FieldName.forField("AlterOverlockCount"); } } @@ -74789,21 +75248,21 @@ public final class Public { */ private long idleTime; + /** + * optional uint64 SelfHotValue = 4; + */ + private long selfHotValue; + + /** + * optional uint64 RivalHotValue = 5; + */ + private long rivalHotValue; + /** * optional uint32 Difficult = 1; */ private int difficult; - /** - * optional uint32 SelfHotValue = 4; - */ - private int selfHotValue; - - /** - * optional uint32 RivalHotValue = 5; - */ - private int rivalHotValue; - /** * optional bytes NextPackage = 2047; */ @@ -74861,12 +75320,86 @@ public final class Public { return this; } + /** + * optional uint64 SelfHotValue = 4; + * @return whether the selfHotValue field is set + */ + public boolean hasSelfHotValue() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint64 SelfHotValue = 4; + * @return this + */ + public TrekkerVersusShow clearSelfHotValue() { + bitField0_ &= ~0x00000002; + selfHotValue = 0L; + return this; + } + + /** + * optional uint64 SelfHotValue = 4; + * @return the selfHotValue + */ + public long getSelfHotValue() { + return selfHotValue; + } + + /** + * optional uint64 SelfHotValue = 4; + * @param value the selfHotValue to set + * @return this + */ + public TrekkerVersusShow setSelfHotValue(final long value) { + bitField0_ |= 0x00000002; + selfHotValue = value; + return this; + } + + /** + * optional uint64 RivalHotValue = 5; + * @return whether the rivalHotValue field is set + */ + public boolean hasRivalHotValue() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint64 RivalHotValue = 5; + * @return this + */ + public TrekkerVersusShow clearRivalHotValue() { + bitField0_ &= ~0x00000004; + rivalHotValue = 0L; + return this; + } + + /** + * optional uint64 RivalHotValue = 5; + * @return the rivalHotValue + */ + public long getRivalHotValue() { + return rivalHotValue; + } + + /** + * optional uint64 RivalHotValue = 5; + * @param value the rivalHotValue to set + * @return this + */ + public TrekkerVersusShow setRivalHotValue(final long value) { + bitField0_ |= 0x00000004; + rivalHotValue = value; + return this; + } + /** * optional uint32 Difficult = 1; * @return whether the difficult field is set */ public boolean hasDifficult() { - return (bitField0_ & 0x00000002) != 0; + return (bitField0_ & 0x00000008) != 0; } /** @@ -74874,7 +75407,7 @@ public final class Public { * @return this */ public TrekkerVersusShow clearDifficult() { - bitField0_ &= ~0x00000002; + bitField0_ &= ~0x00000008; difficult = 0; return this; } @@ -74893,82 +75426,8 @@ public final class Public { * @return this */ public TrekkerVersusShow setDifficult(final int value) { - bitField0_ |= 0x00000002; - difficult = value; - return this; - } - - /** - * optional uint32 SelfHotValue = 4; - * @return whether the selfHotValue field is set - */ - public boolean hasSelfHotValue() { - return (bitField0_ & 0x00000004) != 0; - } - - /** - * optional uint32 SelfHotValue = 4; - * @return this - */ - public TrekkerVersusShow clearSelfHotValue() { - bitField0_ &= ~0x00000004; - selfHotValue = 0; - return this; - } - - /** - * optional uint32 SelfHotValue = 4; - * @return the selfHotValue - */ - public int getSelfHotValue() { - return selfHotValue; - } - - /** - * optional uint32 SelfHotValue = 4; - * @param value the selfHotValue to set - * @return this - */ - public TrekkerVersusShow setSelfHotValue(final int value) { - bitField0_ |= 0x00000004; - selfHotValue = value; - return this; - } - - /** - * optional uint32 RivalHotValue = 5; - * @return whether the rivalHotValue field is set - */ - public boolean hasRivalHotValue() { - return (bitField0_ & 0x00000008) != 0; - } - - /** - * optional uint32 RivalHotValue = 5; - * @return this - */ - public TrekkerVersusShow clearRivalHotValue() { - bitField0_ &= ~0x00000008; - rivalHotValue = 0; - return this; - } - - /** - * optional uint32 RivalHotValue = 5; - * @return the rivalHotValue - */ - public int getRivalHotValue() { - return rivalHotValue; - } - - /** - * optional uint32 RivalHotValue = 5; - * @param value the rivalHotValue to set - * @return this - */ - public TrekkerVersusShow setRivalHotValue(final int value) { bitField0_ |= 0x00000008; - rivalHotValue = value; + difficult = value; return this; } @@ -75125,9 +75584,9 @@ public final class Public { if ((bitField0_ | other.bitField0_) != 0) { bitField0_ = other.bitField0_; idleTime = other.idleTime; - difficult = other.difficult; selfHotValue = other.selfHotValue; rivalHotValue = other.rivalHotValue; + difficult = other.difficult; nextPackage.copyFrom(other.nextPackage); idleValues.copyFrom(other.idleValues); } @@ -75143,15 +75602,15 @@ public final class Public { if (other.hasIdleTime()) { setIdleTime(other.idleTime); } - if (other.hasDifficult()) { - setDifficult(other.difficult); - } if (other.hasSelfHotValue()) { setSelfHotValue(other.selfHotValue); } if (other.hasRivalHotValue()) { setRivalHotValue(other.rivalHotValue); } + if (other.hasDifficult()) { + setDifficult(other.difficult); + } if (other.hasNextPackage()) { getMutableNextPackage().copyFrom(other.nextPackage); } @@ -75169,9 +75628,9 @@ public final class Public { cachedSize = -1; bitField0_ = 0; idleTime = 0L; + selfHotValue = 0L; + rivalHotValue = 0L; difficult = 0; - selfHotValue = 0; - rivalHotValue = 0; nextPackage.clear(); idleValues.clear(); return this; @@ -75200,9 +75659,9 @@ public final class Public { TrekkerVersusShow other = (TrekkerVersusShow) o; return bitField0_ == other.bitField0_ && (!hasIdleTime() || idleTime == other.idleTime) - && (!hasDifficult() || difficult == other.difficult) && (!hasSelfHotValue() || selfHotValue == other.selfHotValue) && (!hasRivalHotValue() || rivalHotValue == other.rivalHotValue) + && (!hasDifficult() || difficult == other.difficult) && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) && (!hasIdleValues() || idleValues.equals(other.idleValues)); } @@ -75214,16 +75673,16 @@ public final class Public { output.writeInt64NoTag(idleTime); } if ((bitField0_ & 0x00000002) != 0) { - output.writeRawByte((byte) 8); - output.writeUInt32NoTag(difficult); + output.writeRawByte((byte) 32); + output.writeUInt64NoTag(selfHotValue); } if ((bitField0_ & 0x00000004) != 0) { - output.writeRawByte((byte) 32); - output.writeUInt32NoTag(selfHotValue); + output.writeRawByte((byte) 40); + output.writeUInt64NoTag(rivalHotValue); } if ((bitField0_ & 0x00000008) != 0) { - output.writeRawByte((byte) 40); - output.writeUInt32NoTag(rivalHotValue); + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(difficult); } if ((bitField0_ & 0x00000010) != 0) { output.writeRawLittleEndian16((short) 32762); @@ -75244,13 +75703,13 @@ public final class Public { size += 1 + ProtoSink.computeInt64SizeNoTag(idleTime); } if ((bitField0_ & 0x00000002) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(difficult); + size += 1 + ProtoSink.computeUInt64SizeNoTag(selfHotValue); } if ((bitField0_ & 0x00000004) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(selfHotValue); + size += 1 + ProtoSink.computeUInt64SizeNoTag(rivalHotValue); } if ((bitField0_ & 0x00000008) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(rivalHotValue); + size += 1 + ProtoSink.computeUInt32SizeNoTag(difficult); } if ((bitField0_ & 0x00000010) != 0) { size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); @@ -75273,23 +75732,14 @@ public final class Public { idleTime = input.readInt64(); bitField0_ |= 0x00000001; tag = input.readTag(); - if (tag != 8) { - break; - } - } - case 8: { - // difficult - difficult = input.readUInt32(); - bitField0_ |= 0x00000002; - tag = input.readTag(); if (tag != 32) { break; } } case 32: { // selfHotValue - selfHotValue = input.readUInt32(); - bitField0_ |= 0x00000004; + selfHotValue = input.readUInt64(); + bitField0_ |= 0x00000002; tag = input.readTag(); if (tag != 40) { break; @@ -75297,7 +75747,16 @@ public final class Public { } case 40: { // rivalHotValue - rivalHotValue = input.readUInt32(); + rivalHotValue = input.readUInt64(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 8) { + break; + } + } + case 8: { + // difficult + difficult = input.readUInt32(); bitField0_ |= 0x00000008; tag = input.readTag(); if (tag != 16378) { @@ -75342,13 +75801,13 @@ public final class Public { output.writeInt64(FieldNames.idleTime, idleTime); } if ((bitField0_ & 0x00000002) != 0) { - output.writeUInt32(FieldNames.difficult, difficult); + output.writeUInt64(FieldNames.selfHotValue, selfHotValue); } if ((bitField0_ & 0x00000004) != 0) { - output.writeUInt32(FieldNames.selfHotValue, selfHotValue); + output.writeUInt64(FieldNames.rivalHotValue, rivalHotValue); } if ((bitField0_ & 0x00000008) != 0) { - output.writeUInt32(FieldNames.rivalHotValue, rivalHotValue); + output.writeUInt32(FieldNames.difficult, difficult); } if ((bitField0_ & 0x00000010) != 0) { output.writeBytes(FieldNames.nextPackage, nextPackage); @@ -75377,22 +75836,11 @@ public final class Public { } break; } - case -985057186: { - if (input.isAtField(FieldNames.difficult)) { - if (!input.trySkipNullValue()) { - difficult = input.readUInt32(); - bitField0_ |= 0x00000002; - } - } else { - input.skipUnknownField(); - } - break; - } case 1360474288: { if (input.isAtField(FieldNames.selfHotValue)) { if (!input.trySkipNullValue()) { - selfHotValue = input.readUInt32(); - bitField0_ |= 0x00000004; + selfHotValue = input.readUInt64(); + bitField0_ |= 0x00000002; } } else { input.skipUnknownField(); @@ -75402,7 +75850,18 @@ public final class Public { case 1039538350: { if (input.isAtField(FieldNames.rivalHotValue)) { if (!input.trySkipNullValue()) { - rivalHotValue = input.readUInt32(); + rivalHotValue = input.readUInt64(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -985057186: { + if (input.isAtField(FieldNames.difficult)) { + if (!input.trySkipNullValue()) { + difficult = input.readUInt32(); bitField0_ |= 0x00000008; } } else { @@ -75811,12 +76270,12 @@ public final class Public { static class FieldNames { static final FieldName idleTime = FieldName.forField("IdleTime"); - static final FieldName difficult = FieldName.forField("Difficult"); - static final FieldName selfHotValue = FieldName.forField("SelfHotValue"); static final FieldName rivalHotValue = FieldName.forField("RivalHotValue"); + static final FieldName difficult = FieldName.forField("Difficult"); + static final FieldName nextPackage = FieldName.forField("NextPackage"); static final FieldName idleValues = FieldName.forField("IdleValues"); @@ -76970,14 +77429,19 @@ public final class Public { private static final long serialVersionUID = 0L; /** - * optional uint32 SelfHotValue = 1; + * optional uint64 SelfHotValue = 1; */ - private int selfHotValue; + private long selfHotValue; /** - * optional uint32 RivalHotValue = 2; + * optional uint64 RivalHotValue = 2; */ - private int rivalHotValue; + private long rivalHotValue; + + /** + * optional uint32 TargetId = 3; + */ + private int targetId; private HistoryResult() { } @@ -76990,7 +77454,7 @@ public final class Public { } /** - * optional uint32 SelfHotValue = 1; + * optional uint64 SelfHotValue = 1; * @return whether the selfHotValue field is set */ public boolean hasSelfHotValue() { @@ -76998,36 +77462,36 @@ public final class Public { } /** - * optional uint32 SelfHotValue = 1; + * optional uint64 SelfHotValue = 1; * @return this */ public HistoryResult clearSelfHotValue() { bitField0_ &= ~0x00000001; - selfHotValue = 0; + selfHotValue = 0L; return this; } /** - * optional uint32 SelfHotValue = 1; + * optional uint64 SelfHotValue = 1; * @return the selfHotValue */ - public int getSelfHotValue() { + public long getSelfHotValue() { return selfHotValue; } /** - * optional uint32 SelfHotValue = 1; + * optional uint64 SelfHotValue = 1; * @param value the selfHotValue to set * @return this */ - public HistoryResult setSelfHotValue(final int value) { + public HistoryResult setSelfHotValue(final long value) { bitField0_ |= 0x00000001; selfHotValue = value; return this; } /** - * optional uint32 RivalHotValue = 2; + * optional uint64 RivalHotValue = 2; * @return whether the rivalHotValue field is set */ public boolean hasRivalHotValue() { @@ -77035,34 +77499,71 @@ public final class Public { } /** - * optional uint32 RivalHotValue = 2; + * optional uint64 RivalHotValue = 2; * @return this */ public HistoryResult clearRivalHotValue() { bitField0_ &= ~0x00000002; - rivalHotValue = 0; + rivalHotValue = 0L; return this; } /** - * optional uint32 RivalHotValue = 2; + * optional uint64 RivalHotValue = 2; * @return the rivalHotValue */ - public int getRivalHotValue() { + public long getRivalHotValue() { return rivalHotValue; } /** - * optional uint32 RivalHotValue = 2; + * optional uint64 RivalHotValue = 2; * @param value the rivalHotValue to set * @return this */ - public HistoryResult setRivalHotValue(final int value) { + public HistoryResult setRivalHotValue(final long value) { bitField0_ |= 0x00000002; rivalHotValue = value; return this; } + /** + * optional uint32 TargetId = 3; + * @return whether the targetId field is set + */ + public boolean hasTargetId() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 TargetId = 3; + * @return this + */ + public HistoryResult clearTargetId() { + bitField0_ &= ~0x00000004; + targetId = 0; + return this; + } + + /** + * optional uint32 TargetId = 3; + * @return the targetId + */ + public int getTargetId() { + return targetId; + } + + /** + * optional uint32 TargetId = 3; + * @param value the targetId to set + * @return this + */ + public HistoryResult setTargetId(final int value) { + bitField0_ |= 0x00000004; + targetId = value; + return this; + } + @Override public HistoryResult copyFrom(final HistoryResult other) { cachedSize = other.cachedSize; @@ -77070,6 +77571,7 @@ public final class Public { bitField0_ = other.bitField0_; selfHotValue = other.selfHotValue; rivalHotValue = other.rivalHotValue; + targetId = other.targetId; } return this; } @@ -77086,6 +77588,9 @@ public final class Public { if (other.hasRivalHotValue()) { setRivalHotValue(other.rivalHotValue); } + if (other.hasTargetId()) { + setTargetId(other.targetId); + } return this; } @@ -77096,8 +77601,9 @@ public final class Public { } cachedSize = -1; bitField0_ = 0; - selfHotValue = 0; - rivalHotValue = 0; + selfHotValue = 0L; + rivalHotValue = 0L; + targetId = 0; return this; } @@ -77122,18 +77628,23 @@ public final class Public { HistoryResult other = (HistoryResult) o; return bitField0_ == other.bitField0_ && (!hasSelfHotValue() || selfHotValue == other.selfHotValue) - && (!hasRivalHotValue() || rivalHotValue == other.rivalHotValue); + && (!hasRivalHotValue() || rivalHotValue == other.rivalHotValue) + && (!hasTargetId() || targetId == other.targetId); } @Override public void writeTo(final ProtoSink output) throws IOException { if ((bitField0_ & 0x00000001) != 0) { output.writeRawByte((byte) 8); - output.writeUInt32NoTag(selfHotValue); + output.writeUInt64NoTag(selfHotValue); } if ((bitField0_ & 0x00000002) != 0) { output.writeRawByte((byte) 16); - output.writeUInt32NoTag(rivalHotValue); + output.writeUInt64NoTag(rivalHotValue); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(targetId); } } @@ -77141,10 +77652,13 @@ public final class Public { protected int computeSerializedSize() { int size = 0; if ((bitField0_ & 0x00000001) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(selfHotValue); + size += 1 + ProtoSink.computeUInt64SizeNoTag(selfHotValue); } if ((bitField0_ & 0x00000002) != 0) { - size += 1 + ProtoSink.computeUInt32SizeNoTag(rivalHotValue); + size += 1 + ProtoSink.computeUInt64SizeNoTag(rivalHotValue); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(targetId); } return size; } @@ -77158,7 +77672,7 @@ public final class Public { switch (tag) { case 8: { // selfHotValue - selfHotValue = input.readUInt32(); + selfHotValue = input.readUInt64(); bitField0_ |= 0x00000001; tag = input.readTag(); if (tag != 16) { @@ -77167,9 +77681,18 @@ public final class Public { } case 16: { // rivalHotValue - rivalHotValue = input.readUInt32(); + rivalHotValue = input.readUInt64(); bitField0_ |= 0x00000002; tag = input.readTag(); + if (tag != 24) { + break; + } + } + case 24: { + // targetId + targetId = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); if (tag != 0) { break; } @@ -77192,10 +77715,13 @@ public final class Public { public void writeTo(final JsonSink output) throws IOException { output.beginObject(); if ((bitField0_ & 0x00000001) != 0) { - output.writeUInt32(FieldNames.selfHotValue, selfHotValue); + output.writeUInt64(FieldNames.selfHotValue, selfHotValue); } if ((bitField0_ & 0x00000002) != 0) { - output.writeUInt32(FieldNames.rivalHotValue, rivalHotValue); + output.writeUInt64(FieldNames.rivalHotValue, rivalHotValue); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.targetId, targetId); } output.endObject(); } @@ -77210,7 +77736,7 @@ public final class Public { case 1360474288: { if (input.isAtField(FieldNames.selfHotValue)) { if (!input.trySkipNullValue()) { - selfHotValue = input.readUInt32(); + selfHotValue = input.readUInt64(); bitField0_ |= 0x00000001; } } else { @@ -77221,7 +77747,7 @@ public final class Public { case 1039538350: { if (input.isAtField(FieldNames.rivalHotValue)) { if (!input.trySkipNullValue()) { - rivalHotValue = input.readUInt32(); + rivalHotValue = input.readUInt64(); bitField0_ |= 0x00000002; } } else { @@ -77229,6 +77755,17 @@ public final class Public { } break; } + case -377307476: { + if (input.isAtField(FieldNames.targetId)) { + if (!input.trySkipNullValue()) { + targetId = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } default: { input.skipUnknownField(); break; @@ -77285,6 +77822,8 @@ public final class Public { static final FieldName selfHotValue = FieldName.forField("SelfHotValue"); static final FieldName rivalHotValue = FieldName.forField("RivalHotValue"); + + static final FieldName targetId = FieldName.forField("TargetId"); } } @@ -82387,4 +82926,1379 @@ public final class Public { static final FieldName items = FieldName.forField("Items"); } } + + /** + * Protobuf type {@code ActivityGDSLevel} + */ + public static final class ActivityGDSLevel extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 LevelId = 1; + */ + private int levelId; + + /** + * optional uint32 MaxScore = 2; + */ + private int maxScore; + + /** + * optional bool FirstComplete = 3; + */ + private boolean firstComplete; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + private ActivityGDSLevel() { + } + + /** + * @return a new empty instance of {@code ActivityGDSLevel} + */ + public static ActivityGDSLevel newInstance() { + return new ActivityGDSLevel(); + } + + /** + * optional uint32 LevelId = 1; + * @return whether the levelId field is set + */ + public boolean hasLevelId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 LevelId = 1; + * @return this + */ + public ActivityGDSLevel clearLevelId() { + bitField0_ &= ~0x00000001; + levelId = 0; + return this; + } + + /** + * optional uint32 LevelId = 1; + * @return the levelId + */ + public int getLevelId() { + return levelId; + } + + /** + * optional uint32 LevelId = 1; + * @param value the levelId to set + * @return this + */ + public ActivityGDSLevel setLevelId(final int value) { + bitField0_ |= 0x00000001; + levelId = value; + return this; + } + + /** + * optional uint32 MaxScore = 2; + * @return whether the maxScore field is set + */ + public boolean hasMaxScore() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 MaxScore = 2; + * @return this + */ + public ActivityGDSLevel clearMaxScore() { + bitField0_ &= ~0x00000002; + maxScore = 0; + return this; + } + + /** + * optional uint32 MaxScore = 2; + * @return the maxScore + */ + public int getMaxScore() { + return maxScore; + } + + /** + * optional uint32 MaxScore = 2; + * @param value the maxScore to set + * @return this + */ + public ActivityGDSLevel setMaxScore(final int value) { + bitField0_ |= 0x00000002; + maxScore = value; + return this; + } + + /** + * optional bool FirstComplete = 3; + * @return whether the firstComplete field is set + */ + public boolean hasFirstComplete() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional bool FirstComplete = 3; + * @return this + */ + public ActivityGDSLevel clearFirstComplete() { + bitField0_ &= ~0x00000004; + firstComplete = false; + return this; + } + + /** + * optional bool FirstComplete = 3; + * @return the firstComplete + */ + public boolean getFirstComplete() { + return firstComplete; + } + + /** + * optional bool FirstComplete = 3; + * @param value the firstComplete to set + * @return this + */ + public ActivityGDSLevel setFirstComplete(final boolean value) { + bitField0_ |= 0x00000004; + firstComplete = value; + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public ActivityGDSLevel clearNextPackage() { + bitField0_ &= ~0x00000008; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000008; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public ActivityGDSLevel addNextPackage(final byte value) { + bitField0_ |= 0x00000008; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public ActivityGDSLevel addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000008; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public ActivityGDSLevel setNextPackage(final byte... values) { + bitField0_ |= 0x00000008; + nextPackage.copyFrom(values); + return this; + } + + @Override + public ActivityGDSLevel copyFrom(final ActivityGDSLevel other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + levelId = other.levelId; + maxScore = other.maxScore; + firstComplete = other.firstComplete; + nextPackage.copyFrom(other.nextPackage); + } + return this; + } + + @Override + public ActivityGDSLevel mergeFrom(final ActivityGDSLevel other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasLevelId()) { + setLevelId(other.levelId); + } + if (other.hasMaxScore()) { + setMaxScore(other.maxScore); + } + if (other.hasFirstComplete()) { + setFirstComplete(other.firstComplete); + } + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + return this; + } + + @Override + public ActivityGDSLevel clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + levelId = 0; + maxScore = 0; + firstComplete = false; + nextPackage.clear(); + return this; + } + + @Override + public ActivityGDSLevel clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ActivityGDSLevel)) { + return false; + } + ActivityGDSLevel other = (ActivityGDSLevel) o; + return bitField0_ == other.bitField0_ + && (!hasLevelId() || levelId == other.levelId) + && (!hasMaxScore() || maxScore == other.maxScore) + && (!hasFirstComplete() || firstComplete == other.firstComplete) + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(levelId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(maxScore); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 24); + output.writeBoolNoTag(firstComplete); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(levelId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(maxScore); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 2; + } + if ((bitField0_ & 0x00000008) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ActivityGDSLevel mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // levelId + levelId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // maxScore + maxScore = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 24) { + break; + } + } + case 24: { + // firstComplete + firstComplete = input.readBool(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 16378) { + break; + } + } + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.levelId, levelId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.maxScore, maxScore); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeBool(FieldNames.firstComplete, firstComplete); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + output.endObject(); + } + + @Override + public ActivityGDSLevel mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1734437791: { + if (input.isAtField(FieldNames.levelId)) { + if (!input.trySkipNullValue()) { + levelId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 461163438: { + if (input.isAtField(FieldNames.maxScore)) { + if (!input.trySkipNullValue()) { + maxScore = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2041047017: { + if (input.isAtField(FieldNames.firstComplete)) { + if (!input.trySkipNullValue()) { + firstComplete = input.readBool(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ActivityGDSLevel clone() { + return new ActivityGDSLevel().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ActivityGDSLevel parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ActivityGDSLevel(), data).checkInitialized(); + } + + public static ActivityGDSLevel parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityGDSLevel(), input).checkInitialized(); + } + + public static ActivityGDSLevel parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityGDSLevel(), input).checkInitialized(); + } + + /** + * @return factory for creating ActivityGDSLevel messages + */ + public static MessageFactory getFactory() { + return ActivityGDSLevelFactory.INSTANCE; + } + + private enum ActivityGDSLevelFactory implements MessageFactory { + INSTANCE; + + @Override + public ActivityGDSLevel create() { + return ActivityGDSLevel.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName levelId = FieldName.forField("LevelId"); + + static final FieldName maxScore = FieldName.forField("MaxScore"); + + static final FieldName firstComplete = FieldName.forField("FirstComplete"); + + static final FieldName nextPackage = FieldName.forField("NextPackage"); + } + } + + /** + * Protobuf type {@code ActivityGDS} + */ + public static final class ActivityGDS extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + /** + * repeated .ActivityGDSLevel Levels = 1; + */ + private final RepeatedMessage levels = RepeatedMessage.newEmptyInstance(ActivityGDSLevel.getFactory()); + + private ActivityGDS() { + } + + /** + * @return a new empty instance of {@code ActivityGDS} + */ + public static ActivityGDS newInstance() { + return new ActivityGDS(); + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public ActivityGDS clearNextPackage() { + bitField0_ &= ~0x00000001; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000001; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public ActivityGDS addNextPackage(final byte value) { + bitField0_ |= 0x00000001; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public ActivityGDS addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public ActivityGDS setNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.copyFrom(values); + return this; + } + + /** + * repeated .ActivityGDSLevel Levels = 1; + * @return whether the levels field is set + */ + public boolean hasLevels() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated .ActivityGDSLevel Levels = 1; + * @return this + */ + public ActivityGDS clearLevels() { + bitField0_ &= ~0x00000002; + levels.clear(); + return this; + } + + /** + * repeated .ActivityGDSLevel Levels = 1; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableLevels()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getLevels() { + return levels; + } + + /** + * repeated .ActivityGDSLevel Levels = 1; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableLevels() { + bitField0_ |= 0x00000002; + return levels; + } + + /** + * repeated .ActivityGDSLevel Levels = 1; + * @param value the levels to add + * @return this + */ + public ActivityGDS addLevels(final ActivityGDSLevel value) { + bitField0_ |= 0x00000002; + levels.add(value); + return this; + } + + /** + * repeated .ActivityGDSLevel Levels = 1; + * @param values the levels to add + * @return this + */ + public ActivityGDS addAllLevels(final ActivityGDSLevel... values) { + bitField0_ |= 0x00000002; + levels.addAll(values); + return this; + } + + @Override + public ActivityGDS copyFrom(final ActivityGDS other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + nextPackage.copyFrom(other.nextPackage); + levels.copyFrom(other.levels); + } + return this; + } + + @Override + public ActivityGDS mergeFrom(final ActivityGDS other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + if (other.hasLevels()) { + getMutableLevels().addAll(other.levels); + } + return this; + } + + @Override + public ActivityGDS clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + levels.clear(); + return this; + } + + @Override + public ActivityGDS clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + levels.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ActivityGDS)) { + return false; + } + ActivityGDS other = (ActivityGDS) o; + return bitField0_ == other.bitField0_ + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) + && (!hasLevels() || levels.equals(other.levels)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < levels.length(); i++) { + output.writeRawByte((byte) 10); + output.writeMessageNoTag(levels.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * levels.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(levels); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ActivityGDS mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 10) { + break; + } + } + case 10: { + // levels + tag = input.readRepeatedMessage(levels, tag); + bitField0_ |= 0x00000002; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedMessage(FieldNames.levels, levels); + } + output.endObject(); + } + + @Override + public ActivityGDS mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2022260337: { + if (input.isAtField(FieldNames.levels)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(levels); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ActivityGDS clone() { + return new ActivityGDS().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ActivityGDS parseFrom(final byte[] data) throws InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ActivityGDS(), data).checkInitialized(); + } + + public static ActivityGDS parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityGDS(), input).checkInitialized(); + } + + public static ActivityGDS parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityGDS(), input).checkInitialized(); + } + + /** + * @return factory for creating ActivityGDS messages + */ + public static MessageFactory getFactory() { + return ActivityGDSFactory.INSTANCE; + } + + private enum ActivityGDSFactory implements MessageFactory { + INSTANCE; + + @Override + public ActivityGDS create() { + return ActivityGDS.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName nextPackage = FieldName.forField("NextPackage"); + + static final FieldName levels = FieldName.forField("Levels"); + } + } + + /** + * Protobuf type {@code ActivityHonor} + */ + public static final class ActivityHonor extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 Id = 1; + */ + private int id; + + /** + * optional uint32 Lv = 2; + */ + private int lv; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + private ActivityHonor() { + } + + /** + * @return a new empty instance of {@code ActivityHonor} + */ + public static ActivityHonor newInstance() { + return new ActivityHonor(); + } + + /** + * optional uint32 Id = 1; + * @return whether the id field is set + */ + public boolean hasId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 Id = 1; + * @return this + */ + public ActivityHonor clearId() { + bitField0_ &= ~0x00000001; + id = 0; + return this; + } + + /** + * optional uint32 Id = 1; + * @return the id + */ + public int getId() { + return id; + } + + /** + * optional uint32 Id = 1; + * @param value the id to set + * @return this + */ + public ActivityHonor setId(final int value) { + bitField0_ |= 0x00000001; + id = value; + return this; + } + + /** + * optional uint32 Lv = 2; + * @return whether the lv field is set + */ + public boolean hasLv() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 Lv = 2; + * @return this + */ + public ActivityHonor clearLv() { + bitField0_ &= ~0x00000002; + lv = 0; + return this; + } + + /** + * optional uint32 Lv = 2; + * @return the lv + */ + public int getLv() { + return lv; + } + + /** + * optional uint32 Lv = 2; + * @param value the lv to set + * @return this + */ + public ActivityHonor setLv(final int value) { + bitField0_ |= 0x00000002; + lv = value; + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public ActivityHonor clearNextPackage() { + bitField0_ &= ~0x00000004; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000004; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public ActivityHonor addNextPackage(final byte value) { + bitField0_ |= 0x00000004; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public ActivityHonor addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000004; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public ActivityHonor setNextPackage(final byte... values) { + bitField0_ |= 0x00000004; + nextPackage.copyFrom(values); + return this; + } + + @Override + public ActivityHonor copyFrom(final ActivityHonor other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + id = other.id; + lv = other.lv; + nextPackage.copyFrom(other.nextPackage); + } + return this; + } + + @Override + public ActivityHonor mergeFrom(final ActivityHonor other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasId()) { + setId(other.id); + } + if (other.hasLv()) { + setLv(other.lv); + } + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + return this; + } + + @Override + public ActivityHonor clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + id = 0; + lv = 0; + nextPackage.clear(); + return this; + } + + @Override + public ActivityHonor clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ActivityHonor)) { + return false; + } + ActivityHonor other = (ActivityHonor) o; + return bitField0_ == other.bitField0_ + && (!hasId() || id == other.id) + && (!hasLv() || lv == other.lv) + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(id); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 16); + output.writeUInt32NoTag(lv); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(id); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(lv); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ActivityHonor mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // id + id = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 16) { + break; + } + } + case 16: { + // lv + lv = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 16378) { + break; + } + } + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.id, id); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.lv, lv); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + output.endObject(); + } + + @Override + public ActivityHonor mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 2363: { + if (input.isAtField(FieldNames.id)) { + if (!input.trySkipNullValue()) { + id = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2474: { + if (input.isAtField(FieldNames.lv)) { + if (!input.trySkipNullValue()) { + lv = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ActivityHonor clone() { + return new ActivityHonor().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ActivityHonor parseFrom(final byte[] data) throws InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ActivityHonor(), data).checkInitialized(); + } + + public static ActivityHonor parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityHonor(), input).checkInitialized(); + } + + public static ActivityHonor parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ActivityHonor(), input).checkInitialized(); + } + + /** + * @return factory for creating ActivityHonor messages + */ + public static MessageFactory getFactory() { + return ActivityHonorFactory.INSTANCE; + } + + private enum ActivityHonorFactory implements MessageFactory { + INSTANCE; + + @Override + public ActivityHonor create() { + return ActivityHonor.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName id = FieldName.forField("Id"); + + static final FieldName lv = FieldName.forField("Lv"); + + static final FieldName nextPackage = FieldName.forField("NextPackage"); + } + } } diff --git a/src/generated/main/emu/nebula/proto/PublicStarTower.java b/src/generated/main/emu/nebula/proto/PublicStarTower.java index b7db10a..4ffbbf6 100644 --- a/src/generated/main/emu/nebula/proto/PublicStarTower.java +++ b/src/generated/main/emu/nebula/proto/PublicStarTower.java @@ -3980,6 +3980,11 @@ public final class PublicStarTower { */ private final RepeatedInt attributes = RepeatedInt.newEmptyInstance(); + /** + * repeated uint32 OverlockCount = 3; + */ + private final RepeatedInt overlockCount = RepeatedInt.newEmptyInstance(); + private StarTowerCharGem() { } @@ -4174,6 +4179,74 @@ public final class PublicStarTower { return this; } + /** + * repeated uint32 OverlockCount = 3; + * @return whether the overlockCount field is set + */ + public boolean hasOverlockCount() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * repeated uint32 OverlockCount = 3; + * @return this + */ + public StarTowerCharGem clearOverlockCount() { + bitField0_ &= ~0x00000008; + overlockCount.clear(); + return this; + } + + /** + * repeated uint32 OverlockCount = 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 #getMutableOverlockCount()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getOverlockCount() { + return overlockCount; + } + + /** + * repeated uint32 OverlockCount = 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 RepeatedInt getMutableOverlockCount() { + bitField0_ |= 0x00000008; + return overlockCount; + } + + /** + * repeated uint32 OverlockCount = 3; + * @param value the overlockCount to add + * @return this + */ + public StarTowerCharGem addOverlockCount(final int value) { + bitField0_ |= 0x00000008; + overlockCount.add(value); + return this; + } + + /** + * repeated uint32 OverlockCount = 3; + * @param values the overlockCount to add + * @return this + */ + public StarTowerCharGem addAllOverlockCount(final int... values) { + bitField0_ |= 0x00000008; + overlockCount.addAll(values); + return this; + } + @Override public StarTowerCharGem copyFrom(final StarTowerCharGem other) { cachedSize = other.cachedSize; @@ -4182,6 +4255,7 @@ public final class PublicStarTower { slotId = other.slotId; nextPackage.copyFrom(other.nextPackage); attributes.copyFrom(other.attributes); + overlockCount.copyFrom(other.overlockCount); } return this; } @@ -4201,6 +4275,9 @@ public final class PublicStarTower { if (other.hasAttributes()) { getMutableAttributes().addAll(other.attributes); } + if (other.hasOverlockCount()) { + getMutableOverlockCount().addAll(other.overlockCount); + } return this; } @@ -4214,6 +4291,7 @@ public final class PublicStarTower { slotId = 0; nextPackage.clear(); attributes.clear(); + overlockCount.clear(); return this; } @@ -4226,6 +4304,7 @@ public final class PublicStarTower { bitField0_ = 0; nextPackage.clear(); attributes.clear(); + overlockCount.clear(); return this; } @@ -4241,7 +4320,8 @@ public final class PublicStarTower { return bitField0_ == other.bitField0_ && (!hasSlotId() || slotId == other.slotId) && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) - && (!hasAttributes() || attributes.equals(other.attributes)); + && (!hasAttributes() || attributes.equals(other.attributes)) + && (!hasOverlockCount() || overlockCount.equals(other.overlockCount)); } @Override @@ -4260,6 +4340,12 @@ public final class PublicStarTower { output.writeUInt32NoTag(attributes.array()[i]); } } + if ((bitField0_ & 0x00000008) != 0) { + for (int i = 0; i < overlockCount.length(); i++) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(overlockCount.array()[i]); + } + } } @Override @@ -4274,6 +4360,9 @@ public final class PublicStarTower { if ((bitField0_ & 0x00000004) != 0) { size += (1 * attributes.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(attributes); } + if ((bitField0_ & 0x00000008) != 0) { + size += (1 * overlockCount.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(overlockCount); + } return size; } @@ -4307,6 +4396,15 @@ public final class PublicStarTower { input.readPackedUInt32(attributes, tag); bitField0_ |= 0x00000004; tag = input.readTag(); + if (tag != 26) { + break; + } + } + case 26: { + // overlockCount [packed=true] + input.readPackedUInt32(overlockCount, tag); + bitField0_ |= 0x00000008; + tag = input.readTag(); if (tag != 0) { break; } @@ -4327,6 +4425,12 @@ public final class PublicStarTower { bitField0_ |= 0x00000004; break; } + case 24: { + // overlockCount [packed=false] + tag = input.readRepeatedUInt32(overlockCount, tag); + bitField0_ |= 0x00000008; + break; + } } } } @@ -4343,6 +4447,9 @@ public final class PublicStarTower { if ((bitField0_ & 0x00000004) != 0) { output.writeRepeatedUInt32(FieldNames.attributes, attributes); } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRepeatedUInt32(FieldNames.overlockCount, overlockCount); + } output.endObject(); } @@ -4386,6 +4493,17 @@ public final class PublicStarTower { } break; } + case 1950695472: { + if (input.isAtField(FieldNames.overlockCount)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(overlockCount); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } default: { input.skipUnknownField(); break; @@ -4444,6 +4562,8 @@ public final class PublicStarTower { static final FieldName nextPackage = FieldName.forField("NextPackage"); static final FieldName attributes = FieldName.forField("Attributes"); + + static final FieldName overlockCount = FieldName.forField("OverlockCount"); } } @@ -34132,4 +34252,754 @@ public final class PublicStarTower { static final FieldName items = FieldName.forField("Items"); } } + + /** + * Protobuf type {@code PotentialPreselection} + */ + public static final class PotentialPreselection extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint64 Id = 1; + */ + private long id; + + /** + * optional uint64 Timestamp = 5; + */ + private long timestamp; + + /** + * optional bool Preference = 3; + */ + private boolean preference; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + /** + * optional string Name = 2; + */ + private final Utf8String name = Utf8String.newEmptyInstance(); + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 4; + */ + private final RepeatedMessage charPotentials = RepeatedMessage.newEmptyInstance(StarTowerBookCharPotential.getFactory()); + + private PotentialPreselection() { + } + + /** + * @return a new empty instance of {@code PotentialPreselection} + */ + public static PotentialPreselection newInstance() { + return new PotentialPreselection(); + } + + /** + * optional uint64 Id = 1; + * @return whether the id field is set + */ + public boolean hasId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint64 Id = 1; + * @return this + */ + public PotentialPreselection clearId() { + bitField0_ &= ~0x00000001; + id = 0L; + return this; + } + + /** + * optional uint64 Id = 1; + * @return the id + */ + public long getId() { + return id; + } + + /** + * optional uint64 Id = 1; + * @param value the id to set + * @return this + */ + public PotentialPreselection setId(final long value) { + bitField0_ |= 0x00000001; + id = value; + return this; + } + + /** + * optional uint64 Timestamp = 5; + * @return whether the timestamp field is set + */ + public boolean hasTimestamp() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint64 Timestamp = 5; + * @return this + */ + public PotentialPreselection clearTimestamp() { + bitField0_ &= ~0x00000002; + timestamp = 0L; + return this; + } + + /** + * optional uint64 Timestamp = 5; + * @return the timestamp + */ + public long getTimestamp() { + return timestamp; + } + + /** + * optional uint64 Timestamp = 5; + * @param value the timestamp to set + * @return this + */ + public PotentialPreselection setTimestamp(final long value) { + bitField0_ |= 0x00000002; + timestamp = value; + return this; + } + + /** + * optional bool Preference = 3; + * @return whether the preference field is set + */ + public boolean hasPreference() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional bool Preference = 3; + * @return this + */ + public PotentialPreselection clearPreference() { + bitField0_ &= ~0x00000004; + preference = false; + return this; + } + + /** + * optional bool Preference = 3; + * @return the preference + */ + public boolean getPreference() { + return preference; + } + + /** + * optional bool Preference = 3; + * @param value the preference to set + * @return this + */ + public PotentialPreselection setPreference(final boolean value) { + bitField0_ |= 0x00000004; + preference = value; + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public PotentialPreselection clearNextPackage() { + bitField0_ &= ~0x00000008; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000008; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public PotentialPreselection addNextPackage(final byte value) { + bitField0_ |= 0x00000008; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public PotentialPreselection addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000008; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public PotentialPreselection setNextPackage(final byte... values) { + bitField0_ |= 0x00000008; + nextPackage.copyFrom(values); + return this; + } + + /** + * optional string Name = 2; + * @return whether the name field is set + */ + public boolean hasName() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * optional string Name = 2; + * @return this + */ + public PotentialPreselection clearName() { + bitField0_ &= ~0x00000010; + name.clear(); + return this; + } + + /** + * optional string Name = 2; + * @return the name + */ + public String getName() { + return name.getString(); + } + + /** + * optional string Name = 2; + * @return internal {@code Utf8String} representation of name for reading + */ + public Utf8String getNameBytes() { + return this.name; + } + + /** + * optional string Name = 2; + * @return internal {@code Utf8String} representation of name for modifications + */ + public Utf8String getMutableNameBytes() { + bitField0_ |= 0x00000010; + return this.name; + } + + /** + * optional string Name = 2; + * @param value the name to set + * @return this + */ + public PotentialPreselection setName(final CharSequence value) { + bitField0_ |= 0x00000010; + name.copyFrom(value); + return this; + } + + /** + * optional string Name = 2; + * @param value the name to set + * @return this + */ + public PotentialPreselection setName(final Utf8String value) { + bitField0_ |= 0x00000010; + name.copyFrom(value); + return this; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 4; + * @return whether the charPotentials field is set + */ + public boolean hasCharPotentials() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 4; + * @return this + */ + public PotentialPreselection clearCharPotentials() { + bitField0_ &= ~0x00000020; + charPotentials.clear(); + return this; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 4; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableCharPotentials()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getCharPotentials() { + return charPotentials; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 4; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableCharPotentials() { + bitField0_ |= 0x00000020; + return charPotentials; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 4; + * @param value the charPotentials to add + * @return this + */ + public PotentialPreselection addCharPotentials(final StarTowerBookCharPotential value) { + bitField0_ |= 0x00000020; + charPotentials.add(value); + return this; + } + + /** + * repeated .StarTowerBookCharPotential CharPotentials = 4; + * @param values the charPotentials to add + * @return this + */ + public PotentialPreselection addAllCharPotentials(final StarTowerBookCharPotential... values) { + bitField0_ |= 0x00000020; + charPotentials.addAll(values); + return this; + } + + @Override + public PotentialPreselection copyFrom(final PotentialPreselection other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + id = other.id; + timestamp = other.timestamp; + preference = other.preference; + nextPackage.copyFrom(other.nextPackage); + name.copyFrom(other.name); + charPotentials.copyFrom(other.charPotentials); + } + return this; + } + + @Override + public PotentialPreselection mergeFrom(final PotentialPreselection other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasId()) { + setId(other.id); + } + if (other.hasTimestamp()) { + setTimestamp(other.timestamp); + } + if (other.hasPreference()) { + setPreference(other.preference); + } + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + if (other.hasName()) { + getMutableNameBytes().copyFrom(other.name); + } + if (other.hasCharPotentials()) { + getMutableCharPotentials().addAll(other.charPotentials); + } + return this; + } + + @Override + public PotentialPreselection clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + id = 0L; + timestamp = 0L; + preference = false; + nextPackage.clear(); + name.clear(); + charPotentials.clear(); + return this; + } + + @Override + public PotentialPreselection clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + name.clear(); + charPotentials.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof PotentialPreselection)) { + return false; + } + PotentialPreselection other = (PotentialPreselection) o; + return bitField0_ == other.bitField0_ + && (!hasId() || id == other.id) + && (!hasTimestamp() || timestamp == other.timestamp) + && (!hasPreference() || preference == other.preference) + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) + && (!hasName() || name.equals(other.name)) + && (!hasCharPotentials() || charPotentials.equals(other.charPotentials)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt64NoTag(id); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 40); + output.writeUInt64NoTag(timestamp); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 24); + output.writeBoolNoTag(preference); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawByte((byte) 18); + output.writeStringNoTag(name); + } + if ((bitField0_ & 0x00000020) != 0) { + for (int i = 0; i < charPotentials.length(); i++) { + output.writeRawByte((byte) 34); + output.writeMessageNoTag(charPotentials.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt64SizeNoTag(id); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt64SizeNoTag(timestamp); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 2; + } + if ((bitField0_ & 0x00000008) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 1 + ProtoSink.computeStringSizeNoTag(name); + } + if ((bitField0_ & 0x00000020) != 0) { + size += (1 * charPotentials.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(charPotentials); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public PotentialPreselection mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // id + id = input.readUInt64(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 40) { + break; + } + } + case 40: { + // timestamp + timestamp = input.readUInt64(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 24) { + break; + } + } + case 24: { + // preference + preference = input.readBool(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 16378) { + break; + } + } + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 18) { + break; + } + } + case 18: { + // name + input.readString(name); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 34) { + break; + } + } + case 34: { + // charPotentials + tag = input.readRepeatedMessage(charPotentials, tag); + bitField0_ |= 0x00000020; + 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.writeUInt64(FieldNames.id, id); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt64(FieldNames.timestamp, timestamp); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeBool(FieldNames.preference, preference); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeString(FieldNames.name, name); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRepeatedMessage(FieldNames.charPotentials, charPotentials); + } + output.endObject(); + } + + @Override + public PotentialPreselection mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 2363: { + if (input.isAtField(FieldNames.id)) { + if (!input.trySkipNullValue()) { + id = input.readUInt64(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2059094262: { + if (input.isAtField(FieldNames.timestamp)) { + if (!input.trySkipNullValue()) { + timestamp = input.readUInt64(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 533633275: { + if (input.isAtField(FieldNames.preference)) { + if (!input.trySkipNullValue()) { + preference = input.readBool(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case 2420395: { + if (input.isAtField(FieldNames.name)) { + if (!input.trySkipNullValue()) { + input.readString(name); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1909208021: { + if (input.isAtField(FieldNames.charPotentials)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(charPotentials); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public PotentialPreselection clone() { + return new PotentialPreselection().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static PotentialPreselection parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new PotentialPreselection(), data).checkInitialized(); + } + + public static PotentialPreselection parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new PotentialPreselection(), input).checkInitialized(); + } + + public static PotentialPreselection parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new PotentialPreselection(), input).checkInitialized(); + } + + /** + * @return factory for creating PotentialPreselection messages + */ + public static MessageFactory getFactory() { + return PotentialPreselectionFactory.INSTANCE; + } + + private enum PotentialPreselectionFactory implements MessageFactory { + INSTANCE; + + @Override + public PotentialPreselection create() { + return PotentialPreselection.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName id = FieldName.forField("Id"); + + static final FieldName timestamp = FieldName.forField("Timestamp"); + + static final FieldName preference = FieldName.forField("Preference"); + + static final FieldName nextPackage = FieldName.forField("NextPackage"); + + static final FieldName name = FieldName.forField("Name"); + + static final FieldName charPotentials = FieldName.forField("CharPotentials"); + } + } } diff --git a/src/generated/main/emu/nebula/proto/ScoreBossRank.java b/src/generated/main/emu/nebula/proto/ScoreBossRank.java index aaf6230..fd01aa6 100644 --- a/src/generated/main/emu/nebula/proto/ScoreBossRank.java +++ b/src/generated/main/emu/nebula/proto/ScoreBossRank.java @@ -11,6 +11,7 @@ import us.hebi.quickbuf.ProtoMessage; import us.hebi.quickbuf.ProtoSink; import us.hebi.quickbuf.ProtoSource; import us.hebi.quickbuf.RepeatedByte; +import us.hebi.quickbuf.RepeatedInt; import us.hebi.quickbuf.RepeatedLong; import us.hebi.quickbuf.RepeatedMessage; import us.hebi.quickbuf.Utf8String; @@ -1272,11 +1273,31 @@ public final class ScoreBossRank { */ private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + /** + * repeated uint32 Discs = 5; + */ + private final RepeatedInt discs = RepeatedInt.newEmptyInstance(); + + /** + * repeated uint32 ActiveSecondaryIds = 8; + */ + private final RepeatedInt activeSecondaryIds = RepeatedInt.newEmptyInstance(); + /** * repeated .ScoreBossRankChar Chars = 2; */ private final RepeatedMessage chars = RepeatedMessage.newEmptyInstance(ScoreBossRankChar.getFactory()); + /** + * repeated .BuildPotential Potentials = 6; + */ + private final RepeatedMessage potentials = RepeatedMessage.newEmptyInstance(PublicStarTower.BuildPotential.getFactory()); + + /** + * repeated .ItemTpl Notes = 7; + */ + private final RepeatedMessage notes = RepeatedMessage.newEmptyInstance(Public.ItemTpl.getFactory()); + private ScoreBossRankTeam() { } @@ -1477,12 +1498,148 @@ public final class ScoreBossRank { return this; } + /** + * repeated uint32 Discs = 5; + * @return whether the discs field is set + */ + public boolean hasDiscs() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * repeated uint32 Discs = 5; + * @return this + */ + public ScoreBossRankTeam clearDiscs() { + bitField0_ &= ~0x00000010; + discs.clear(); + return this; + } + + /** + * repeated uint32 Discs = 5; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableDiscs()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getDiscs() { + return discs; + } + + /** + * repeated uint32 Discs = 5; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableDiscs() { + bitField0_ |= 0x00000010; + return discs; + } + + /** + * repeated uint32 Discs = 5; + * @param value the discs to add + * @return this + */ + public ScoreBossRankTeam addDiscs(final int value) { + bitField0_ |= 0x00000010; + discs.add(value); + return this; + } + + /** + * repeated uint32 Discs = 5; + * @param values the discs to add + * @return this + */ + public ScoreBossRankTeam addAllDiscs(final int... values) { + bitField0_ |= 0x00000010; + discs.addAll(values); + return this; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * @return whether the activeSecondaryIds field is set + */ + public boolean hasActiveSecondaryIds() { + return (bitField0_ & 0x00000020) != 0; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * @return this + */ + public ScoreBossRankTeam clearActiveSecondaryIds() { + bitField0_ &= ~0x00000020; + activeSecondaryIds.clear(); + return this; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableActiveSecondaryIds()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedInt getActiveSecondaryIds() { + return activeSecondaryIds; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedInt getMutableActiveSecondaryIds() { + bitField0_ |= 0x00000020; + return activeSecondaryIds; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * @param value the activeSecondaryIds to add + * @return this + */ + public ScoreBossRankTeam addActiveSecondaryIds(final int value) { + bitField0_ |= 0x00000020; + activeSecondaryIds.add(value); + return this; + } + + /** + * repeated uint32 ActiveSecondaryIds = 8; + * @param values the activeSecondaryIds to add + * @return this + */ + public ScoreBossRankTeam addAllActiveSecondaryIds(final int... values) { + bitField0_ |= 0x00000020; + activeSecondaryIds.addAll(values); + return this; + } + /** * repeated .ScoreBossRankChar Chars = 2; * @return whether the chars field is set */ public boolean hasChars() { - return (bitField0_ & 0x00000010) != 0; + return (bitField0_ & 0x00000040) != 0; } /** @@ -1490,7 +1647,7 @@ public final class ScoreBossRank { * @return this */ public ScoreBossRankTeam clearChars() { - bitField0_ &= ~0x00000010; + bitField0_ &= ~0x00000040; chars.clear(); return this; } @@ -1519,7 +1676,7 @@ public final class ScoreBossRank { * @return internal storage object for modifications */ public RepeatedMessage getMutableChars() { - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000040; return chars; } @@ -1529,7 +1686,7 @@ public final class ScoreBossRank { * @return this */ public ScoreBossRankTeam addChars(final ScoreBossRankChar value) { - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000040; chars.add(value); return this; } @@ -1540,11 +1697,147 @@ public final class ScoreBossRank { * @return this */ public ScoreBossRankTeam addAllChars(final ScoreBossRankChar... values) { - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000040; chars.addAll(values); return this; } + /** + * repeated .BuildPotential Potentials = 6; + * @return whether the potentials field is set + */ + public boolean hasPotentials() { + return (bitField0_ & 0x00000080) != 0; + } + + /** + * repeated .BuildPotential Potentials = 6; + * @return this + */ + public ScoreBossRankTeam clearPotentials() { + bitField0_ &= ~0x00000080; + potentials.clear(); + return this; + } + + /** + * repeated .BuildPotential Potentials = 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 #getMutablePotentials()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getPotentials() { + return potentials; + } + + /** + * repeated .BuildPotential Potentials = 6; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutablePotentials() { + bitField0_ |= 0x00000080; + return potentials; + } + + /** + * repeated .BuildPotential Potentials = 6; + * @param value the potentials to add + * @return this + */ + public ScoreBossRankTeam addPotentials(final PublicStarTower.BuildPotential value) { + bitField0_ |= 0x00000080; + potentials.add(value); + return this; + } + + /** + * repeated .BuildPotential Potentials = 6; + * @param values the potentials to add + * @return this + */ + public ScoreBossRankTeam addAllPotentials(final PublicStarTower.BuildPotential... values) { + bitField0_ |= 0x00000080; + potentials.addAll(values); + return this; + } + + /** + * repeated .ItemTpl Notes = 7; + * @return whether the notes field is set + */ + public boolean hasNotes() { + return (bitField0_ & 0x00000100) != 0; + } + + /** + * repeated .ItemTpl Notes = 7; + * @return this + */ + public ScoreBossRankTeam clearNotes() { + bitField0_ &= ~0x00000100; + notes.clear(); + return this; + } + + /** + * repeated .ItemTpl Notes = 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 #getMutableNotes()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getNotes() { + return notes; + } + + /** + * repeated .ItemTpl Notes = 7; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableNotes() { + bitField0_ |= 0x00000100; + return notes; + } + + /** + * repeated .ItemTpl Notes = 7; + * @param value the notes to add + * @return this + */ + public ScoreBossRankTeam addNotes(final Public.ItemTpl value) { + bitField0_ |= 0x00000100; + notes.add(value); + return this; + } + + /** + * repeated .ItemTpl Notes = 7; + * @param values the notes to add + * @return this + */ + public ScoreBossRankTeam addAllNotes(final Public.ItemTpl... values) { + bitField0_ |= 0x00000100; + notes.addAll(values); + return this; + } + @Override public ScoreBossRankTeam copyFrom(final ScoreBossRankTeam other) { cachedSize = other.cachedSize; @@ -1554,7 +1847,11 @@ public final class ScoreBossRank { levelScore = other.levelScore; levelId = other.levelId; nextPackage.copyFrom(other.nextPackage); + discs.copyFrom(other.discs); + activeSecondaryIds.copyFrom(other.activeSecondaryIds); chars.copyFrom(other.chars); + potentials.copyFrom(other.potentials); + notes.copyFrom(other.notes); } return this; } @@ -1577,9 +1874,21 @@ public final class ScoreBossRank { if (other.hasNextPackage()) { getMutableNextPackage().copyFrom(other.nextPackage); } + if (other.hasDiscs()) { + getMutableDiscs().addAll(other.discs); + } + if (other.hasActiveSecondaryIds()) { + getMutableActiveSecondaryIds().addAll(other.activeSecondaryIds); + } if (other.hasChars()) { getMutableChars().addAll(other.chars); } + if (other.hasPotentials()) { + getMutablePotentials().addAll(other.potentials); + } + if (other.hasNotes()) { + getMutableNotes().addAll(other.notes); + } return this; } @@ -1594,7 +1903,11 @@ public final class ScoreBossRank { levelScore = 0; levelId = 0; nextPackage.clear(); + discs.clear(); + activeSecondaryIds.clear(); chars.clear(); + potentials.clear(); + notes.clear(); return this; } @@ -1606,7 +1919,11 @@ public final class ScoreBossRank { cachedSize = -1; bitField0_ = 0; nextPackage.clear(); + discs.clear(); + activeSecondaryIds.clear(); chars.clearQuick(); + potentials.clearQuick(); + notes.clearQuick(); return this; } @@ -1624,7 +1941,11 @@ public final class ScoreBossRank { && (!hasLevelScore() || levelScore == other.levelScore) && (!hasLevelId() || levelId == other.levelId) && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) - && (!hasChars() || chars.equals(other.chars)); + && (!hasDiscs() || discs.equals(other.discs)) + && (!hasActiveSecondaryIds() || activeSecondaryIds.equals(other.activeSecondaryIds)) + && (!hasChars() || chars.equals(other.chars)) + && (!hasPotentials() || potentials.equals(other.potentials)) + && (!hasNotes() || notes.equals(other.notes)); } @Override @@ -1646,11 +1967,35 @@ public final class ScoreBossRank { output.writeBytesNoTag(nextPackage); } if ((bitField0_ & 0x00000010) != 0) { + for (int i = 0; i < discs.length(); i++) { + output.writeRawByte((byte) 40); + output.writeUInt32NoTag(discs.array()[i]); + } + } + if ((bitField0_ & 0x00000020) != 0) { + for (int i = 0; i < activeSecondaryIds.length(); i++) { + output.writeRawByte((byte) 64); + output.writeUInt32NoTag(activeSecondaryIds.array()[i]); + } + } + if ((bitField0_ & 0x00000040) != 0) { for (int i = 0; i < chars.length(); i++) { output.writeRawByte((byte) 18); output.writeMessageNoTag(chars.get(i)); } } + if ((bitField0_ & 0x00000080) != 0) { + for (int i = 0; i < potentials.length(); i++) { + output.writeRawByte((byte) 50); + output.writeMessageNoTag(potentials.get(i)); + } + } + if ((bitField0_ & 0x00000100) != 0) { + for (int i = 0; i < notes.length(); i++) { + output.writeRawByte((byte) 58); + output.writeMessageNoTag(notes.get(i)); + } + } } @Override @@ -1669,8 +2014,20 @@ public final class ScoreBossRank { size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); } if ((bitField0_ & 0x00000010) != 0) { + size += (1 * discs.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(discs); + } + if ((bitField0_ & 0x00000020) != 0) { + size += (1 * activeSecondaryIds.length()) + ProtoSink.computeRepeatedUInt32SizeNoTag(activeSecondaryIds); + } + if ((bitField0_ & 0x00000040) != 0) { size += (1 * chars.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(chars); } + if ((bitField0_ & 0x00000080) != 0) { + size += (1 * potentials.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(potentials); + } + if ((bitField0_ & 0x00000100) != 0) { + size += (1 * notes.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(notes); + } return size; } @@ -1713,6 +2070,24 @@ public final class ScoreBossRank { input.readBytes(nextPackage); bitField0_ |= 0x00000008; tag = input.readTag(); + if (tag != 42) { + break; + } + } + case 42: { + // discs [packed=true] + input.readPackedUInt32(discs, tag); + bitField0_ |= 0x00000010; + tag = input.readTag(); + if (tag != 66) { + break; + } + } + case 66: { + // activeSecondaryIds [packed=true] + input.readPackedUInt32(activeSecondaryIds, tag); + bitField0_ |= 0x00000020; + tag = input.readTag(); if (tag != 18) { break; } @@ -1720,7 +2095,23 @@ public final class ScoreBossRank { case 18: { // chars tag = input.readRepeatedMessage(chars, tag); - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000040; + if (tag != 50) { + break; + } + } + case 50: { + // potentials + tag = input.readRepeatedMessage(potentials, tag); + bitField0_ |= 0x00000080; + if (tag != 58) { + break; + } + } + case 58: { + // notes + tag = input.readRepeatedMessage(notes, tag); + bitField0_ |= 0x00000100; if (tag != 0) { break; } @@ -1735,6 +2126,18 @@ public final class ScoreBossRank { tag = input.readTag(); break; } + case 40: { + // discs [packed=false] + tag = input.readRepeatedUInt32(discs, tag); + bitField0_ |= 0x00000010; + break; + } + case 64: { + // activeSecondaryIds [packed=false] + tag = input.readRepeatedUInt32(activeSecondaryIds, tag); + bitField0_ |= 0x00000020; + break; + } } } } @@ -1755,8 +2158,20 @@ public final class ScoreBossRank { output.writeBytes(FieldNames.nextPackage, nextPackage); } if ((bitField0_ & 0x00000010) != 0) { + output.writeRepeatedUInt32(FieldNames.discs, discs); + } + if ((bitField0_ & 0x00000020) != 0) { + output.writeRepeatedUInt32(FieldNames.activeSecondaryIds, activeSecondaryIds); + } + if ((bitField0_ & 0x00000040) != 0) { output.writeRepeatedMessage(FieldNames.chars, chars); } + if ((bitField0_ & 0x00000080) != 0) { + output.writeRepeatedMessage(FieldNames.potentials, potentials); + } + if ((bitField0_ & 0x00000100) != 0) { + output.writeRepeatedMessage(FieldNames.notes, notes); + } output.endObject(); } @@ -1811,11 +2226,55 @@ public final class ScoreBossRank { } break; } + case 66041182: { + if (input.isAtField(FieldNames.discs)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(discs); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1499070186: { + if (input.isAtField(FieldNames.activeSecondaryIds)) { + if (!input.trySkipNullValue()) { + input.readRepeatedUInt32(activeSecondaryIds); + bitField0_ |= 0x00000020; + } + } else { + input.skipUnknownField(); + } + break; + } case 65071037: { if (input.isAtField(FieldNames.chars)) { if (!input.trySkipNullValue()) { input.readRepeatedMessage(chars); - bitField0_ |= 0x00000010; + bitField0_ |= 0x00000040; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1405493301: { + if (input.isAtField(FieldNames.potentials)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(potentials); + bitField0_ |= 0x00000080; + } + } else { + input.skipUnknownField(); + } + break; + } + case 75456161: { + if (input.isAtField(FieldNames.notes)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(notes); + bitField0_ |= 0x00000100; } } else { input.skipUnknownField(); @@ -1883,7 +2342,15 @@ public final class ScoreBossRank { static final FieldName nextPackage = FieldName.forField("NextPackage"); + static final FieldName discs = FieldName.forField("Discs"); + + static final FieldName activeSecondaryIds = FieldName.forField("ActiveSecondaryIds"); + static final FieldName chars = FieldName.forField("Chars"); + + static final FieldName potentials = FieldName.forField("Potentials"); + + static final FieldName notes = FieldName.forField("Notes"); } } @@ -3069,4 +3536,405 @@ public final class ScoreBossRank { static final FieldName honors = FieldName.forField("Honors"); } } + + /** + * Protobuf type {@code ScoreBossRankTeams} + */ + public static final class ScoreBossRankTeams extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional bytes NextPackage = 2047; + */ + private final RepeatedByte nextPackage = RepeatedByte.newEmptyInstance(); + + /** + * repeated .ScoreBossRankTeam Teams = 1; + */ + private final RepeatedMessage teams = RepeatedMessage.newEmptyInstance(ScoreBossRankTeam.getFactory()); + + private ScoreBossRankTeams() { + } + + /** + * @return a new empty instance of {@code ScoreBossRankTeams} + */ + public static ScoreBossRankTeams newInstance() { + return new ScoreBossRankTeams(); + } + + /** + * optional bytes NextPackage = 2047; + * @return whether the nextPackage field is set + */ + public boolean hasNextPackage() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional bytes NextPackage = 2047; + * @return this + */ + public ScoreBossRankTeams clearNextPackage() { + bitField0_ &= ~0x00000001; + nextPackage.clear(); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 #getMutableNextPackage()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedByte getNextPackage() { + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * + * 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 RepeatedByte getMutableNextPackage() { + bitField0_ |= 0x00000001; + return nextPackage; + } + + /** + * optional bytes NextPackage = 2047; + * @param value the nextPackage to add + * @return this + */ + public ScoreBossRankTeams addNextPackage(final byte value) { + bitField0_ |= 0x00000001; + nextPackage.add(value); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to add + * @return this + */ + public ScoreBossRankTeams addAllNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.addAll(values); + return this; + } + + /** + * optional bytes NextPackage = 2047; + * @param values the nextPackage to set + * @return this + */ + public ScoreBossRankTeams setNextPackage(final byte... values) { + bitField0_ |= 0x00000001; + nextPackage.copyFrom(values); + return this; + } + + /** + * repeated .ScoreBossRankTeam Teams = 1; + * @return whether the teams field is set + */ + public boolean hasTeams() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * repeated .ScoreBossRankTeam Teams = 1; + * @return this + */ + public ScoreBossRankTeams clearTeams() { + bitField0_ &= ~0x00000002; + teams.clear(); + return this; + } + + /** + * repeated .ScoreBossRankTeam Teams = 1; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableTeams()} if you want to modify it. + * + * @return internal storage object for reading + */ + public RepeatedMessage getTeams() { + return teams; + } + + /** + * repeated .ScoreBossRankTeam Teams = 1; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public RepeatedMessage getMutableTeams() { + bitField0_ |= 0x00000002; + return teams; + } + + /** + * repeated .ScoreBossRankTeam Teams = 1; + * @param value the teams to add + * @return this + */ + public ScoreBossRankTeams addTeams(final ScoreBossRankTeam value) { + bitField0_ |= 0x00000002; + teams.add(value); + return this; + } + + /** + * repeated .ScoreBossRankTeam Teams = 1; + * @param values the teams to add + * @return this + */ + public ScoreBossRankTeams addAllTeams(final ScoreBossRankTeam... values) { + bitField0_ |= 0x00000002; + teams.addAll(values); + return this; + } + + @Override + public ScoreBossRankTeams copyFrom(final ScoreBossRankTeams other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + nextPackage.copyFrom(other.nextPackage); + teams.copyFrom(other.teams); + } + return this; + } + + @Override + public ScoreBossRankTeams mergeFrom(final ScoreBossRankTeams other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasNextPackage()) { + getMutableNextPackage().copyFrom(other.nextPackage); + } + if (other.hasTeams()) { + getMutableTeams().addAll(other.teams); + } + return this; + } + + @Override + public ScoreBossRankTeams clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + teams.clear(); + return this; + } + + @Override + public ScoreBossRankTeams clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + nextPackage.clear(); + teams.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ScoreBossRankTeams)) { + return false; + } + ScoreBossRankTeams other = (ScoreBossRankTeams) o; + return bitField0_ == other.bitField0_ + && (!hasNextPackage() || nextPackage.equals(other.nextPackage)) + && (!hasTeams() || teams.equals(other.teams)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawLittleEndian16((short) 32762); + output.writeBytesNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + for (int i = 0; i < teams.length(); i++) { + output.writeRawByte((byte) 10); + output.writeMessageNoTag(teams.get(i)); + } + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 2 + ProtoSink.computeBytesSizeNoTag(nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + size += (1 * teams.length()) + ProtoSink.computeRepeatedMessageSizeNoTag(teams); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ScoreBossRankTeams mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 16378: { + // nextPackage + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 10) { + break; + } + } + case 10: { + // teams + tag = input.readRepeatedMessage(teams, tag); + bitField0_ |= 0x00000002; + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeBytes(FieldNames.nextPackage, nextPackage); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRepeatedMessage(FieldNames.teams, teams); + } + output.endObject(); + } + + @Override + public ScoreBossRankTeams mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -2082324045: { + if (input.isAtField(FieldNames.nextPackage)) { + if (!input.trySkipNullValue()) { + input.readBytes(nextPackage); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 80681366: { + if (input.isAtField(FieldNames.teams)) { + if (!input.trySkipNullValue()) { + input.readRepeatedMessage(teams); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ScoreBossRankTeams clone() { + return new ScoreBossRankTeams().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ScoreBossRankTeams parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ScoreBossRankTeams(), data).checkInitialized(); + } + + public static ScoreBossRankTeams parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ScoreBossRankTeams(), input).checkInitialized(); + } + + public static ScoreBossRankTeams parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ScoreBossRankTeams(), input).checkInitialized(); + } + + /** + * @return factory for creating ScoreBossRankTeams messages + */ + public static MessageFactory getFactory() { + return ScoreBossRankTeamsFactory.INSTANCE; + } + + private enum ScoreBossRankTeamsFactory implements MessageFactory { + INSTANCE; + + @Override + public ScoreBossRankTeams create() { + return ScoreBossRankTeams.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName nextPackage = FieldName.forField("NextPackage"); + + static final FieldName teams = FieldName.forField("Teams"); + } + } } diff --git a/src/main/java/emu/nebula/GameConstants.java b/src/main/java/emu/nebula/GameConstants.java index fbd354b..ecfb4de 100644 --- a/src/main/java/emu/nebula/GameConstants.java +++ b/src/main/java/emu/nebula/GameConstants.java @@ -7,7 +7,7 @@ import emu.nebula.game.inventory.ItemParamMap; import emu.nebula.util.WeightedList; public class GameConstants { - public static final String VERSION = "1.8.0"; + public static final String VERSION = "1.9.0"; public static int DATA_VERSION = 0; public static final ZoneId UTC_ZONE = ZoneId.of("UTC"); diff --git a/src/main/java/emu/nebula/data/resources/HonorDef.java b/src/main/java/emu/nebula/data/resources/HonorDef.java index af11b31..b59434d 100644 --- a/src/main/java/emu/nebula/data/resources/HonorDef.java +++ b/src/main/java/emu/nebula/data/resources/HonorDef.java @@ -58,6 +58,10 @@ public class HonorDef extends BaseDef { // Group this.valid = true; } + case 4 -> { + // Levels + this.valid = true; + } default -> { // Unknown honor type Nebula.getLogger().warn("Honor " + this.getId() + " has an unknown type (" + this.getType() + ")"); diff --git a/src/main/java/emu/nebula/game/achievement/AchievementCondition.java b/src/main/java/emu/nebula/game/achievement/AchievementCondition.java index d454c0d..a15243d 100644 --- a/src/main/java/emu/nebula/game/achievement/AchievementCondition.java +++ b/src/main/java/emu/nebula/game/achievement/AchievementCondition.java @@ -5,141 +5,138 @@ import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap; import lombok.Getter; public enum AchievementCondition { - AchievementSpecific (1), - AchievementTotal (2), - BattleTotal (3), - CharacterAcquire (5), - CharacterAcquireQuantityRarityAndAdvancement (6), - CharacterAdvanceTotal (7), - CharacterSkillUpTotal (8), - CharacterSkillWithSpecificUpTotal (9), - CharacterSpecific (10), - CharacterUpLevel (11), - CharacterUpTotal (12), - CharacterWithSpecificAdvance (13), - CharacterWithSpecificAffinity (14), - CharacterWithSpecificUpLevel (15), - CharactersWithSpecificLevelAndQuantity (16), - CharactersWithSpecificNumberLevelAndAttributes (17), - CharactersWithSpecificPlot (18), - CharactersWithSpecificQuantityAdvancementCountAndAttribute (19), - CharactersWithSpecificQuantityAndRarity (20), - CharactersWithSpecificQuantityRarityAndAdvancement (21), - CharactersWithSpecificQuantityRarityAndLevel (22), - ChatTotal (23), - DailyInstanceClearSpecificDifficultyAndTotal (24), - DailyInstanceClearSpecificTypeAndTotal (25), - DailyInstanceClearTotal (26), - DateSpecific (27), - DiscAcquire (28), - DiscAcquireSpecificQuantityAndRarity (29), - DiscAcquireQuantityLevelAndRarity (30), - DiscAcquireQuantityPhaseAndRarity (31), - DiscAcquireQuantityStarAndRarity (32), - DiscLimitBreakTotal (33), - DiscPromoteTotal (34), - DiscStrengthenTotal (35), - DiscWithSpecificQuantityLevelAndRarity (36), - DiscWithSpecificQuantityPhaseAndRarity (37), - DiscWithSpecificQuantityStarAndRarity (38), - GachaCharacterNotSSRTotal (40), - GachaCharacterTenModeSSRTotal (41), - GachaCharacterTotal (42), - GachaTenModeAcquireQuantityAndRarityItems (43), - GachaTotal (44), - GiftGiveTotal (45), - InfinityTowerClearSpecificFloor (46), - InfinityTowerClearTotal (47), - ItemsAdd (48), - ItemsDeplete (49), - ItemsProductTotal (50), - LoginTotal (51), - QuestTravelerDuelChallengeTotal (52), - QuestTourGuideSpecific (53), - QuestWithSpecificType (55), - RegionBossClearSpecificFullStarWithBossIdAndDifficulty (56), - RegionBossClearSpecificLevelWithDifficultyAndTotal (57), - RegionBossClearSpecificTotal (58), - RegionBossClearTotal (59), - SkillsWithSpecificQuantityAndLevel (60), - SkinAcquire (61), - StageClearSpecificStars (62), - StoryClear (63), - TravelerDuelChallengeSpecificBoosLevelWithDifficultyAndTotal (64), - TravelerDuelChallengeClearSpecificBossLevelAndAffix (67), - TravelerDuelClearSpecificBossTotal (69), - WorldClassSpecific (71), - RegionBossClearSpecificTypeWithTotal (72), - CharactersWithSpecificDatingCount (73), - CharactersDatingTotal (74), - VampireSurvivorScoreTotal (75), - VampireSurvivorSpecificLevelWithSpecificScore (76), - VampireSurvivorPassedSpecificLevel (77), - CharacterParticipateTowerNumber (78), - CharacterAllSkillReachSpecificLevel (79), - VampireClearTotal (81), - VampireWithSpecificClearTotal (82), - AgentFinishTotal (83), - AgentWithSpecificFinishTotal (84), - ActivityMiningEnterLayer (86), - ActivityMiningDestroyGrid (87), - BossRushTotalStars (88), - InfinityTowerClearSpecificDifficultyAndTotal (89), - SkillInstanceClearTotal (90), - VampireSurvivorSpecificPassedLevel (91), - WeekBoosClearSpecificDifficultyAndTotal (92), - NpcAffinityWithSpecificLevel (93), - CharacterPassedWithSpecificTowerAndCount (94), - JointDrillScoreTotal (95), - CharGemInstanceClearTotal (104), - DailyShopReceiveShopTotal (105), - AgentApplyTotal (106), - DiscSpecific (114), - StorySetClearSpecific (116), - CharacterWithSpecificSkillAndLevel (118), - DiscWithSpecificQuantityLevelAndAttr (119), - TutorialLevelClearSpecific (120), - TutorialLevelSpecificClearTotal (121), - DiscWithSpecificQuantityPhaseAndAttr (122), - WeekBossClearTotal (123), - ClientReport (200), - TowerBattleTimes (501), - TowerBossChallengeSpecificHighRewardWithTotal (502), - TowerBuildSpecificCharacter (503), - TowerBuildSpecificScoreWithTotal (504), - TowerClearSpecificCharacterTypeWithTotal (505), - TowerClearSpecificGroupIdAndDifficulty (506), - TowerClearSpecificLevelWithDifficultyAndTotal (507), - TowerClearTotal (508), - TowerEnterRoom (509), - TowerEventTimes (511), - TowerFateTimes (512), - TowerItemsGet (513), - TowerSpecificDifficultyShopBuyTimes (514), - TowerGrowthSpecificNote (515), - TowerClearSpecificLevelWithDifficultyAndTotalHistory (516), - TowerBookWithSpecificEvent (517), - TowerBookWithSpecificFateCard (518), - TowerBookWithSpecificPotential (520), - TowerBuildSpecificDifficultyAndScoreWithTotal (521), - TowerSpecificDifficultyStrengthenMachineTotal (522), - TowerSpecificDifficultyKillBossTotal (524), - TowerBookSpecificCharWithPotentialTotal (525), - TowerBuildSpecificCharSpecificScoreWithTotal (526), - TowerGrowthWithSpecificNote (527), - TowerSpecificFateCardReRollTotal (528), - TowerSpecificPotentialReRollTotal (529), - TowerSpecificShopReRollTotal (530), - TowerSpecificNoteActivateTotal (531), - TowerSpecificNoteLevelTotal (532), - TowerSpecificPotentialBonusTotal (533), - TowerSpecificPotentialLuckyTotal (534), - TowerSpecificShopBuyDiscountTotal (535), - TowerSpecificSecondarySkillActivateTotal (536), - TowerSpecificGetExtraNoteLvTotal (537), - TowerSweepTimes (539), - TowerSweepTotal (540), - TowerBattleWithPartner (541); + AchievementSpecific (1), + AchievementTotal (2), + BattleTotal (3), + CharacterAcquire (5), + CharacterAcquireQuantityRarityAndAdvancement (6), + CharacterAdvanceTotal (7), + CharacterSkillUpTotal (8), + CharacterSkillWithSpecificUpTotal (9), + CharacterSpecific (10), + CharacterUpLevel (11), + CharacterUpTotal (12), + CharacterWithSpecificAdvance (13), + CharacterWithSpecificAffinity (14), + CharacterWithSpecificUpLevel (15), + CharactersWithSpecificLevelAndQuantity (16), + CharactersWithSpecificNumberLevelAndAttributes (17), + CharactersWithSpecificPlot (18), + CharactersWithSpecificQuantityAdvancementCountAndAttribute (19), + CharactersWithSpecificQuantityAndRarity (20), + CharactersWithSpecificQuantityRarityAndAdvancement (21), + CharactersWithSpecificQuantityRarityAndLevel (22), + ChatTotal (23), + DailyInstanceClearSpecificDifficultyAndTotal (24), + DailyInstanceClearSpecificTypeAndTotal (25), + DailyInstanceClearTotal (26), + DateSpecific (27), + DiscAcquire (28), + DiscAcquireSpecificQuantityAndRarity (29), + DiscAcquireQuantityLevelAndRarity (30), + DiscAcquireQuantityPhaseAndRarity (31), + DiscAcquireQuantityStarAndRarity (32), + DiscLimitBreakTotal (33), + DiscPromoteTotal (34), + DiscStrengthenTotal (35), + DiscWithSpecificQuantityLevelAndRarity (36), + DiscWithSpecificQuantityPhaseAndRarity (37), + DiscWithSpecificQuantityStarAndRarity (38), + GachaCharacterNotSSRTotal (40), + GachaCharacterTenModeSSRTotal (41), + GachaCharacterTotal (42), + GachaTenModeAcquireQuantityAndRarityItems (43), + GachaTotal (44), + GiftGiveTotal (45), + InfinityTowerClearSpecificFloor (46), + InfinityTowerClearTotal (47), + ItemsAdd (48), + ItemsDeplete (49), + ItemsProductTotal (50), + LoginTotal (51), + QuestTravelerDuelChallengeTotal (52), + QuestTourGuideSpecific (53), + QuestWithSpecificType (55), + RegionBossClearSpecificFullStarWithBossIdAndDifficulty (56), + RegionBossClearSpecificLevelWithDifficultyAndTotal (57), + RegionBossClearSpecificTotal (58), + RegionBossClearTotal (59), + SkillsWithSpecificQuantityAndLevel (60), + SkinAcquire (61), + StageClearSpecificStars (62), + StoryClear (63), + WorldClassSpecific (71), + RegionBossClearSpecificTypeWithTotal (72), + CharactersWithSpecificDatingCount (73), + CharactersDatingTotal (74), + VampireSurvivorScoreTotal (75), + VampireSurvivorSpecificLevelWithSpecificScore (76), + VampireSurvivorPassedSpecificLevel (77), + CharacterParticipateTowerNumber (78), + CharacterAllSkillReachSpecificLevel (79), + VampireClearTotal (81), + VampireWithSpecificClearTotal (82), + AgentFinishTotal (83), + AgentWithSpecificFinishTotal (84), + ActivityMiningEnterLayer (86), + ActivityMiningDestroyGrid (87), + BossRushTotalStars (88), + InfinityTowerClearSpecificDifficultyAndTotal (89), + SkillInstanceClearTotal (90), + VampireSurvivorSpecificPassedLevel (91), + WeekBoosClearSpecificDifficultyAndTotal (92), + NpcAffinityWithSpecificLevel (93), + CharacterPassedWithSpecificTowerAndCount (94), + JointDrillScoreTotal (95), + CharGemInstanceClearTotal (104), + DailyShopReceiveShopTotal (105), + AgentApplyTotal (106), + DiscSpecific (114), + StorySetClearSpecific (116), + CharacterWithSpecificSkillAndLevel (118), + DiscWithSpecificQuantityLevelAndAttr (119), + TutorialLevelClearSpecific (120), + TutorialLevelSpecificClearTotal (121), + DiscWithSpecificQuantityPhaseAndAttr (122), + WeekBossClearTotal (123), + ClientReport (200), + TowerBattleTimes (501), + TowerBossChallengeSpecificHighRewardWithTotal (502), + TowerBuildSpecificCharacter (503), + TowerBuildSpecificScoreWithTotal (504), + TowerClearSpecificCharacterTypeWithTotal (505), + TowerClearSpecificGroupIdAndDifficulty (506), + TowerClearSpecificLevelWithDifficultyAndTotal (507), + TowerClearTotal (508), + TowerEnterRoom (509), + TowerEventTimes (511), + TowerFateTimes (512), + TowerItemsGet (513), + TowerSpecificDifficultyShopBuyTimes (514), + TowerGrowthSpecificNote (515), + TowerClearSpecificLevelWithDifficultyAndTotalHistory (516), + TowerBookWithSpecificEvent (517), + TowerBookWithSpecificFateCard (518), + TowerBookWithSpecificPotential (520), + TowerBuildSpecificDifficultyAndScoreWithTotal (521), + TowerSpecificDifficultyStrengthenMachineTotal (522), + TowerSpecificDifficultyKillBossTotal (524), + TowerBookSpecificCharWithPotentialTotal (525), + TowerBuildSpecificCharSpecificScoreWithTotal (526), + TowerGrowthWithSpecificNote (527), + TowerSpecificFateCardReRollTotal (528), + TowerSpecificPotentialReRollTotal (529), + TowerSpecificShopReRollTotal (530), + TowerSpecificNoteActivateTotal (531), + TowerSpecificNoteLevelTotal (532), + TowerSpecificPotentialBonusTotal (533), + TowerSpecificPotentialLuckyTotal (534), + TowerSpecificShopBuyDiscountTotal (535), + TowerSpecificSecondarySkillActivateTotal (536), + TowerSpecificGetExtraNoteLvTotal (537), + TowerSweepTimes (539), + TowerSweepTotal (540), + TowerBattleWithPartner (541); @Getter private final int value; diff --git a/src/main/java/emu/nebula/game/activity/ActivityModule.java b/src/main/java/emu/nebula/game/activity/ActivityModule.java index 2cae76e..cbc56e1 100644 --- a/src/main/java/emu/nebula/game/activity/ActivityModule.java +++ b/src/main/java/emu/nebula/game/activity/ActivityModule.java @@ -45,28 +45,34 @@ public class ActivityModule extends GameContextModule { //this.activities.add(1010504); // To My Dearest You - this.activities.add(1010601); - this.activities.add(1010603); - this.activities.add(1010604); + //this.activities.add(1010601); + //this.activities.add(1010603); + //this.activities.add(1010604); + + // Solitary Waltz in Night's Embrace + this.activities.add(2010201); + this.activities.add(2010203); + this.activities.add(2010204); // ===== Joint Drills (Finale Echoing) ===== - this.activities.add(510003); + //this.activities.add(510003); // Causes soft lock in event screen // ===== Etc Events ===== // Trial activities - this.activities.add(700111); - this.activities.add(700112); + this.activities.add(700117); + this.activities.add(700118); // Tower defense activity - this.activities.add(102002); + this.activities.add(102002); // Broken + + // Login events + //this.activities.add(301011); // Christmas 2025 + //this.activities.add(301012); // Christmas 2025 + this.activities.add(301031); // Stellar Prelude - // Christmas 2025 login events - this.activities.add(301011); - this.activities.add(301012); - // Fatebound Stellar Deck - this.activities.add(800001); + //this.activities.add(800001); // Causes soft lock in event screen // Trekker versus (broken) //this.activities.add(600001); diff --git a/src/main/java/emu/nebula/game/activity/ActivityType.java b/src/main/java/emu/nebula/game/activity/ActivityType.java index 0ba6533..4a63c22 100644 --- a/src/main/java/emu/nebula/game/activity/ActivityType.java +++ b/src/main/java/emu/nebula/game/activity/ActivityType.java @@ -24,7 +24,8 @@ public enum ActivityType { TrekkerVersus (16), Story (17), PenguinCard (18), - ThrowGift (19); + ThrowGift (19), + GoldenSpy (20); @Getter private final int value; diff --git a/src/main/java/emu/nebula/game/character/CharacterGem.java b/src/main/java/emu/nebula/game/character/CharacterGem.java index aa80b1e..9f03acf 100644 --- a/src/main/java/emu/nebula/game/character/CharacterGem.java +++ b/src/main/java/emu/nebula/game/character/CharacterGem.java @@ -64,7 +64,9 @@ public class CharacterGem { var proto = CharGem.newInstance() .setLock(this.isLocked()) .addAllAttributes(this.getAttributes()) - .addAllAlterAttributes(this.getAlterAttributes()); + .addAllAlterAttributes(this.getAlterAttributes()) + .addAllOverlockCount(new int[this.getAttributes().length]) + .addAllAlterOverlockCount(new int[this.getAlterAttributes().length]); return proto; } diff --git a/src/main/java/emu/nebula/game/character/GameCharacter.java b/src/main/java/emu/nebula/game/character/GameCharacter.java index 1ca3052..c5ad6ac 100644 --- a/src/main/java/emu/nebula/game/character/GameCharacter.java +++ b/src/main/java/emu/nebula/game/character/GameCharacter.java @@ -59,6 +59,7 @@ public class GameCharacter implements GameDatabaseObject { private int advance; private int level; private int exp; + private boolean favorite; private int affinityLevel; private int affinityExp; private int skin; @@ -136,6 +137,10 @@ public class GameCharacter implements GameDatabaseObject { public void setAdvance(int advance) { this.advance = advance; } + + public void setFavorite(boolean b) { + this.favorite = b; + } public void setAffinityLevel(int level) { this.affinityLevel = Math.max(level, 0); @@ -821,6 +826,7 @@ public class GameCharacter implements GameDatabaseObject { .setLevel(this.getLevel()) .setSkin(this.getSkin()) .setAdvance(this.getAdvance()) + .setIsFavorite(this.isFavorite()) .setAffinityLevel(this.getAffinityLevel()) .setAffinityExp(this.getAffinityExp()) .setTalentNodes(this.getTalents().toByteArray()) diff --git a/src/main/java/emu/nebula/game/inventory/ItemSubType.java b/src/main/java/emu/nebula/game/inventory/ItemSubType.java index a8319ad..ee44cfd 100644 --- a/src/main/java/emu/nebula/game/inventory/ItemSubType.java +++ b/src/main/java/emu/nebula/game/inventory/ItemSubType.java @@ -15,6 +15,7 @@ public enum ItemSubType { TalentStrengthen (9), DiscStrengthen (12), DiscPromote (13), + LevelHonor (15), TreasureBox (17), GearTreasureBox (18), SubNoteSkill (19), diff --git a/src/main/java/emu/nebula/game/inventory/ItemType.java b/src/main/java/emu/nebula/game/inventory/ItemType.java index e105a1c..365c89d 100644 --- a/src/main/java/emu/nebula/game/inventory/ItemType.java +++ b/src/main/java/emu/nebula/game/inventory/ItemType.java @@ -17,7 +17,8 @@ public enum ItemType { MonthlyCard (11), Title (12), Honor (13), - HeadItem (14); + HeadItem (14), + LevelHonor (15); @Getter private final int value; diff --git a/src/main/java/emu/nebula/game/player/Player.java b/src/main/java/emu/nebula/game/player/Player.java index 6b88876..5bb5d94 100644 --- a/src/main/java/emu/nebula/game/player/Player.java +++ b/src/main/java/emu/nebula/game/player/Player.java @@ -995,8 +995,6 @@ public class Player implements GameDatabaseObject { state.getMutableMallPackage(); state.getMutableTravelerDuelQuest() .setType(QuestType.TravelerDuel); - state.getMutableTravelerDuelChallengeQuest() - .setType(QuestType.TravelerDuelChallenge); state.getMutableStarTower(); state.getMutableStarTowerBook(); state.getMutableScoreBoss(); diff --git a/src/main/java/emu/nebula/game/quest/QuestCondition.java b/src/main/java/emu/nebula/game/quest/QuestCondition.java index dfa2bf8..fb3f2c1 100644 --- a/src/main/java/emu/nebula/game/quest/QuestCondition.java +++ b/src/main/java/emu/nebula/game/quest/QuestCondition.java @@ -49,9 +49,10 @@ public enum QuestCondition { SkillsWithSpecificQuantityAndLevel (60), StageClearSpecificStars (62), StoryClear (63), - TravelerDuelChallengeSpecificBoosLevelWithDifficultyAndTotal (64), - TravelerDuelChallengeClearSpecificBossLevelAndAffix (67), - TravelerDuelClearSpecificBossTotal (69), + TrekkerVersusClearCount (64), + TrekkerVersusClearWithSpecificAffix (65), + TrekkerVersusClearWithSpecificDifficultyAndTotal (66), + TrekkerVersusFansWithSpecificLevel (67), WorldClassSpecific (71), RegionBossClearSpecificTypeWithTotal (72), CharactersWithSpecificDatingCount (73), diff --git a/src/main/java/emu/nebula/net/NetMsgId.java b/src/main/java/emu/nebula/net/NetMsgId.java index efc46f8..a1039d4 100644 --- a/src/main/java/emu/nebula/net/NetMsgId.java +++ b/src/main/java/emu/nebula/net/NetMsgId.java @@ -3,6 +3,7 @@ package emu.nebula.net; public class NetMsgId { public static final int none = 0; + public static final int clear_all_activity_golden_spy_levels_notify = -10051; public static final int clear_all_activity_breakout_levels_notify = -10050; public static final int clear_story_set_notify = -10049; public static final int unlock_activity_story_notify = -10048; @@ -188,6 +189,9 @@ public class NetMsgId { public static final int milkout_settle_req = 1401; public static final int milkout_settle_succeed_ack = 1402; public static final int milkout_settle_failed_ack = 1403; + public static final int activity_gds_settle_req = 1501; + public static final int activity_gds_settle_succeed_ack = 1502; + public static final int activity_gds_settle_failed_ack = 1503; public static final int player_formation_req = 2001; public static final int player_formation_succeed_ack = 2002; public static final int player_formation_failed_ack = 2003; @@ -254,6 +258,15 @@ public class NetMsgId { public static final int char_gem_equip_gem_req = 2519; public static final int char_gem_equip_gem_succeed_ack = 2520; public static final int char_gem_equip_gem_failed_ack = 2521; + public static final int char_gem_overlock_revert_req = 2522; + public static final int char_gem_overlock_revert_succeed_ack = 2523; + public static final int char_gem_overlock_revert_failed_ack = 2524; + public static final int char_gem_overlock_req = 2525; + public static final int char_gem_overlock_succeed_ack = 2526; + public static final int char_gem_overlock_failed_ack = 2527; + public static final int char_favorite_set_req = 2601; + public static final int char_favorite_set_succeed_ack = 2602; + public static final int char_favorite_set_failed_ack = 2603; public static final int disc_strengthen_req = 3119; public static final int disc_strengthen_succeed_ack = 3120; public static final int disc_strengthen_failed_ack = 3121; @@ -368,6 +381,24 @@ public class NetMsgId { public static final int star_tower_build_preference_set_req = 4719; public static final int star_tower_build_preference_set_succeed_ack = 4720; public static final int star_tower_build_preference_set_failed_ack = 4721; + public static final int potential_preselection_list_req = 4722; + public static final int potential_preselection_list_succeed_ack = 4723; + public static final int potential_preselection_list_failed_ack = 4724; + public static final int potential_preselection_import_req = 4725; + public static final int potential_preselection_import_succeed_ack = 4726; + public static final int potential_preselection_import_failed_ack = 4727; + public static final int potential_preselection_name_set_req = 4728; + public static final int potential_preselection_name_set_succeed_ack = 4729; + public static final int potential_preselection_name_set_failed_ack = 4730; + public static final int potential_preselection_preference_set_req = 4731; + public static final int potential_preselection_preference_set_succeed_ack = 4732; + public static final int potential_preselection_preference_set_failed_ack = 4733; + public static final int potential_preselection_update_req = 4734; + public static final int potential_preselection_update_succeed_ack = 4735; + public static final int potential_preselection_update_failed_ack = 4736; + public static final int potential_preselection_delete_req = 4737; + public static final int potential_preselection_delete_succeed_ack = 4738; + public static final int potential_preselection_delete_failed_ack = 4739; public static final int build_convert_detail_list_get_req = 4801; public static final int build_convert_detail_list_get_succeed_ack = 4802; public static final int build_convert_detail_list_get_failed_ack = 4803; diff --git a/src/main/java/emu/nebula/server/handlers/HandlerCharFavoriteSetReq.java b/src/main/java/emu/nebula/server/handlers/HandlerCharFavoriteSetReq.java new file mode 100644 index 0000000..040f3e6 --- /dev/null +++ b/src/main/java/emu/nebula/server/handlers/HandlerCharFavoriteSetReq.java @@ -0,0 +1,32 @@ +package emu.nebula.server.handlers; + +import emu.nebula.net.NetHandler; +import emu.nebula.net.NetMsgId; +import emu.nebula.proto.Public.UI32; +import emu.nebula.net.HandlerId; +import emu.nebula.net.GameSession; + +@HandlerId(NetMsgId.char_favorite_set_req) +public class HandlerCharFavoriteSetReq extends NetHandler { + + @Override + public byte[] handle(GameSession session, byte[] message) throws Exception { + // Parse request + var req = UI32.parseFrom(message); + + // Get character + var character = session.getPlayer().getCharacters().getCharacterById(req.getValue()); + + if (character == null) { + return session.encodeMsg(NetMsgId.char_favorite_set_failed_ack); + } + + // Toggle favorite status + character.setFavorite(!character.isFavorite()); + character.save(); + + // Encode and send + return session.encodeMsg(NetMsgId.char_favorite_set_succeed_ack); + } + +} diff --git a/src/main/java/emu/nebula/server/handlers/HandlerPotentialPreselectionListReq.java b/src/main/java/emu/nebula/server/handlers/HandlerPotentialPreselectionListReq.java new file mode 100644 index 0000000..31a4795 --- /dev/null +++ b/src/main/java/emu/nebula/server/handlers/HandlerPotentialPreselectionListReq.java @@ -0,0 +1,21 @@ +package emu.nebula.server.handlers; + +import emu.nebula.net.NetHandler; +import emu.nebula.net.NetMsgId; +import emu.nebula.proto.PotentialPreselectionListOuterClass.PotentialPreselectionList; +import emu.nebula.net.HandlerId; +import emu.nebula.net.GameSession; + +@HandlerId(NetMsgId.potential_preselection_list_req) +public class HandlerPotentialPreselectionListReq extends NetHandler { + + @Override + public byte[] handle(GameSession session, byte[] message) throws Exception { + // Create base response + var rsp = PotentialPreselectionList.newInstance(); + + // Encode and send + return session.encodeMsg(NetMsgId.potential_preselection_list_succeed_ack, rsp); + } + +} diff --git a/src/main/resources/versions.json b/src/main/resources/versions.json index 80ea44b..0d77a13 100644 --- a/src/main/resources/versions.json +++ b/src/main/resources/versions.json @@ -1,7 +1,7 @@ { - "global": 98, - "kr": 103, - "jp": 101, - "tw": 108, - "cn": 99 + "global": 99, + "kr": 104, + "jp": 102, + "tw": 109, + "cn": 100 } \ No newline at end of file