diff --git a/src/generated/main/emu/lunarcore/proto/ComposeSelectedRelicCsReqOuterClass.java b/src/generated/main/emu/lunarcore/proto/ComposeSelectedRelicCsReqOuterClass.java new file mode 100644 index 0000000..5514cf3 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ComposeSelectedRelicCsReqOuterClass.java @@ -0,0 +1,605 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ComposeSelectedRelicCsReqOuterClass { + /** + * Protobuf type {@code ComposeSelectedRelicCsReq} + */ + public static final class ComposeSelectedRelicCsReq extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 compose_id = 4; + */ + private int composeId; + + /** + * optional uint32 compose_relic_id = 7; + */ + private int composeRelicId; + + /** + * optional uint32 count = 13; + */ + private int count; + + /** + * optional uint32 main_affix_id = 15; + */ + private int mainAffixId; + + /** + * optional .ItemCostList compose_item_list = 12; + */ + private final ItemCostListOuterClass.ItemCostList composeItemList = ItemCostListOuterClass.ItemCostList.newInstance(); + + private ComposeSelectedRelicCsReq() { + } + + /** + * @return a new empty instance of {@code ComposeSelectedRelicCsReq} + */ + public static ComposeSelectedRelicCsReq newInstance() { + return new ComposeSelectedRelicCsReq(); + } + + /** + * optional uint32 compose_id = 4; + * @return whether the composeId field is set + */ + public boolean hasComposeId() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 compose_id = 4; + * @return this + */ + public ComposeSelectedRelicCsReq clearComposeId() { + bitField0_ &= ~0x00000001; + composeId = 0; + return this; + } + + /** + * optional uint32 compose_id = 4; + * @return the composeId + */ + public int getComposeId() { + return composeId; + } + + /** + * optional uint32 compose_id = 4; + * @param value the composeId to set + * @return this + */ + public ComposeSelectedRelicCsReq setComposeId(final int value) { + bitField0_ |= 0x00000001; + composeId = value; + return this; + } + + /** + * optional uint32 compose_relic_id = 7; + * @return whether the composeRelicId field is set + */ + public boolean hasComposeRelicId() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 compose_relic_id = 7; + * @return this + */ + public ComposeSelectedRelicCsReq clearComposeRelicId() { + bitField0_ &= ~0x00000002; + composeRelicId = 0; + return this; + } + + /** + * optional uint32 compose_relic_id = 7; + * @return the composeRelicId + */ + public int getComposeRelicId() { + return composeRelicId; + } + + /** + * optional uint32 compose_relic_id = 7; + * @param value the composeRelicId to set + * @return this + */ + public ComposeSelectedRelicCsReq setComposeRelicId(final int value) { + bitField0_ |= 0x00000002; + composeRelicId = value; + return this; + } + + /** + * optional uint32 count = 13; + * @return whether the count field is set + */ + public boolean hasCount() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional uint32 count = 13; + * @return this + */ + public ComposeSelectedRelicCsReq clearCount() { + bitField0_ &= ~0x00000004; + count = 0; + return this; + } + + /** + * optional uint32 count = 13; + * @return the count + */ + public int getCount() { + return count; + } + + /** + * optional uint32 count = 13; + * @param value the count to set + * @return this + */ + public ComposeSelectedRelicCsReq setCount(final int value) { + bitField0_ |= 0x00000004; + count = value; + return this; + } + + /** + * optional uint32 main_affix_id = 15; + * @return whether the mainAffixId field is set + */ + public boolean hasMainAffixId() { + return (bitField0_ & 0x00000008) != 0; + } + + /** + * optional uint32 main_affix_id = 15; + * @return this + */ + public ComposeSelectedRelicCsReq clearMainAffixId() { + bitField0_ &= ~0x00000008; + mainAffixId = 0; + return this; + } + + /** + * optional uint32 main_affix_id = 15; + * @return the mainAffixId + */ + public int getMainAffixId() { + return mainAffixId; + } + + /** + * optional uint32 main_affix_id = 15; + * @param value the mainAffixId to set + * @return this + */ + public ComposeSelectedRelicCsReq setMainAffixId(final int value) { + bitField0_ |= 0x00000008; + mainAffixId = value; + return this; + } + + /** + * optional .ItemCostList compose_item_list = 12; + * @return whether the composeItemList field is set + */ + public boolean hasComposeItemList() { + return (bitField0_ & 0x00000010) != 0; + } + + /** + * optional .ItemCostList compose_item_list = 12; + * @return this + */ + public ComposeSelectedRelicCsReq clearComposeItemList() { + bitField0_ &= ~0x00000010; + composeItemList.clear(); + return this; + } + + /** + * optional .ItemCostList compose_item_list = 12; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableComposeItemList()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ItemCostListOuterClass.ItemCostList getComposeItemList() { + return composeItemList; + } + + /** + * optional .ItemCostList compose_item_list = 12; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ItemCostListOuterClass.ItemCostList getMutableComposeItemList() { + bitField0_ |= 0x00000010; + return composeItemList; + } + + /** + * optional .ItemCostList compose_item_list = 12; + * @param value the composeItemList to set + * @return this + */ + public ComposeSelectedRelicCsReq setComposeItemList( + final ItemCostListOuterClass.ItemCostList value) { + bitField0_ |= 0x00000010; + composeItemList.copyFrom(value); + return this; + } + + @Override + public ComposeSelectedRelicCsReq copyFrom(final ComposeSelectedRelicCsReq other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + composeId = other.composeId; + composeRelicId = other.composeRelicId; + count = other.count; + mainAffixId = other.mainAffixId; + composeItemList.copyFrom(other.composeItemList); + } + return this; + } + + @Override + public ComposeSelectedRelicCsReq mergeFrom(final ComposeSelectedRelicCsReq other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasComposeId()) { + setComposeId(other.composeId); + } + if (other.hasComposeRelicId()) { + setComposeRelicId(other.composeRelicId); + } + if (other.hasCount()) { + setCount(other.count); + } + if (other.hasMainAffixId()) { + setMainAffixId(other.mainAffixId); + } + if (other.hasComposeItemList()) { + getMutableComposeItemList().mergeFrom(other.composeItemList); + } + return this; + } + + @Override + public ComposeSelectedRelicCsReq clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + composeId = 0; + composeRelicId = 0; + count = 0; + mainAffixId = 0; + composeItemList.clear(); + return this; + } + + @Override + public ComposeSelectedRelicCsReq clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + composeItemList.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ComposeSelectedRelicCsReq)) { + return false; + } + ComposeSelectedRelicCsReq other = (ComposeSelectedRelicCsReq) o; + return bitField0_ == other.bitField0_ + && (!hasComposeId() || composeId == other.composeId) + && (!hasComposeRelicId() || composeRelicId == other.composeRelicId) + && (!hasCount() || count == other.count) + && (!hasMainAffixId() || mainAffixId == other.mainAffixId) + && (!hasComposeItemList() || composeItemList.equals(other.composeItemList)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 32); + output.writeUInt32NoTag(composeId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 56); + output.writeUInt32NoTag(composeRelicId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 104); + output.writeUInt32NoTag(count); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeRawByte((byte) 120); + output.writeUInt32NoTag(mainAffixId); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeRawByte((byte) 98); + output.writeMessageNoTag(composeItemList); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(composeId); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(composeRelicId); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(count); + } + if ((bitField0_ & 0x00000008) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(mainAffixId); + } + if ((bitField0_ & 0x00000010) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(composeItemList); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ComposeSelectedRelicCsReq mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 32: { + // composeId + composeId = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 56) { + break; + } + } + case 56: { + // composeRelicId + composeRelicId = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 104) { + break; + } + } + case 104: { + // count + count = input.readUInt32(); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 120) { + break; + } + } + case 120: { + // mainAffixId + mainAffixId = input.readUInt32(); + bitField0_ |= 0x00000008; + tag = input.readTag(); + if (tag != 98) { + break; + } + } + case 98: { + // composeItemList + input.readMessage(composeItemList); + 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.composeId, composeId); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.composeRelicId, composeRelicId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeUInt32(FieldNames.count, count); + } + if ((bitField0_ & 0x00000008) != 0) { + output.writeUInt32(FieldNames.mainAffixId, mainAffixId); + } + if ((bitField0_ & 0x00000010) != 0) { + output.writeMessage(FieldNames.composeItemList, composeItemList); + } + output.endObject(); + } + + @Override + public ComposeSelectedRelicCsReq mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case -1399759283: + case -442843416: { + if (input.isAtField(FieldNames.composeId)) { + if (!input.trySkipNullValue()) { + composeId = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case 1424923132: + case 885799284: { + if (input.isAtField(FieldNames.composeRelicId)) { + if (!input.trySkipNullValue()) { + composeRelicId = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case 94851343: { + if (input.isAtField(FieldNames.count)) { + if (!input.trySkipNullValue()) { + count = input.readUInt32(); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1973876974: + case -1426712144: { + if (input.isAtField(FieldNames.mainAffixId)) { + if (!input.trySkipNullValue()) { + mainAffixId = input.readUInt32(); + bitField0_ |= 0x00000008; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1347157501: + case -656801827: { + if (input.isAtField(FieldNames.composeItemList)) { + if (!input.trySkipNullValue()) { + input.readMessage(composeItemList); + bitField0_ |= 0x00000010; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ComposeSelectedRelicCsReq clone() { + return new ComposeSelectedRelicCsReq().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ComposeSelectedRelicCsReq parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ComposeSelectedRelicCsReq(), data).checkInitialized(); + } + + public static ComposeSelectedRelicCsReq parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ComposeSelectedRelicCsReq(), input).checkInitialized(); + } + + public static ComposeSelectedRelicCsReq parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ComposeSelectedRelicCsReq(), input).checkInitialized(); + } + + /** + * @return factory for creating ComposeSelectedRelicCsReq messages + */ + public static MessageFactory getFactory() { + return ComposeSelectedRelicCsReqFactory.INSTANCE; + } + + private enum ComposeSelectedRelicCsReqFactory implements MessageFactory { + INSTANCE; + + @Override + public ComposeSelectedRelicCsReq create() { + return ComposeSelectedRelicCsReq.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName composeId = FieldName.forField("composeId", "compose_id"); + + static final FieldName composeRelicId = FieldName.forField("composeRelicId", "compose_relic_id"); + + static final FieldName count = FieldName.forField("count"); + + static final FieldName mainAffixId = FieldName.forField("mainAffixId", "main_affix_id"); + + static final FieldName composeItemList = FieldName.forField("composeItemList", "compose_item_list"); + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ComposeSelectedRelicScRspOuterClass.java b/src/generated/main/emu/lunarcore/proto/ComposeSelectedRelicScRspOuterClass.java new file mode 100644 index 0000000..48dc525 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ComposeSelectedRelicScRspOuterClass.java @@ -0,0 +1,442 @@ +// Code generated by protocol buffer compiler. Do not edit! +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; + +public final class ComposeSelectedRelicScRspOuterClass { + /** + * Protobuf type {@code ComposeSelectedRelicScRsp} + */ + public static final class ComposeSelectedRelicScRsp extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + + /** + * optional uint32 retcode = 1; + */ + private int retcode; + + /** + * optional uint32 compose_id = 3; + */ + private int composeId; + + /** + * optional .ItemList return_item_list = 14; + */ + private final ItemListOuterClass.ItemList returnItemList = ItemListOuterClass.ItemList.newInstance(); + + private ComposeSelectedRelicScRsp() { + } + + /** + * @return a new empty instance of {@code ComposeSelectedRelicScRsp} + */ + public static ComposeSelectedRelicScRsp newInstance() { + return new ComposeSelectedRelicScRsp(); + } + + /** + * optional uint32 retcode = 1; + * @return whether the retcode field is set + */ + public boolean hasRetcode() { + return (bitField0_ & 0x00000001) != 0; + } + + /** + * optional uint32 retcode = 1; + * @return this + */ + public ComposeSelectedRelicScRsp clearRetcode() { + bitField0_ &= ~0x00000001; + retcode = 0; + return this; + } + + /** + * optional uint32 retcode = 1; + * @return the retcode + */ + public int getRetcode() { + return retcode; + } + + /** + * optional uint32 retcode = 1; + * @param value the retcode to set + * @return this + */ + public ComposeSelectedRelicScRsp setRetcode(final int value) { + bitField0_ |= 0x00000001; + retcode = value; + return this; + } + + /** + * optional uint32 compose_id = 3; + * @return whether the composeId field is set + */ + public boolean hasComposeId() { + return (bitField0_ & 0x00000002) != 0; + } + + /** + * optional uint32 compose_id = 3; + * @return this + */ + public ComposeSelectedRelicScRsp clearComposeId() { + bitField0_ &= ~0x00000002; + composeId = 0; + return this; + } + + /** + * optional uint32 compose_id = 3; + * @return the composeId + */ + public int getComposeId() { + return composeId; + } + + /** + * optional uint32 compose_id = 3; + * @param value the composeId to set + * @return this + */ + public ComposeSelectedRelicScRsp setComposeId(final int value) { + bitField0_ |= 0x00000002; + composeId = value; + return this; + } + + /** + * optional .ItemList return_item_list = 14; + * @return whether the returnItemList field is set + */ + public boolean hasReturnItemList() { + return (bitField0_ & 0x00000004) != 0; + } + + /** + * optional .ItemList return_item_list = 14; + * @return this + */ + public ComposeSelectedRelicScRsp clearReturnItemList() { + bitField0_ &= ~0x00000004; + returnItemList.clear(); + return this; + } + + /** + * optional .ItemList return_item_list = 14; + * + * This method returns the internal storage object without modifying any has state. + * The returned object should not be modified and be treated as read-only. + * + * Use {@link #getMutableReturnItemList()} if you want to modify it. + * + * @return internal storage object for reading + */ + public ItemListOuterClass.ItemList getReturnItemList() { + return returnItemList; + } + + /** + * optional .ItemList return_item_list = 14; + * + * This method returns the internal storage object and sets the corresponding + * has state. The returned object will become part of this message and its + * contents may be modified as long as the has state is not cleared. + * + * @return internal storage object for modifications + */ + public ItemListOuterClass.ItemList getMutableReturnItemList() { + bitField0_ |= 0x00000004; + return returnItemList; + } + + /** + * optional .ItemList return_item_list = 14; + * @param value the returnItemList to set + * @return this + */ + public ComposeSelectedRelicScRsp setReturnItemList(final ItemListOuterClass.ItemList value) { + bitField0_ |= 0x00000004; + returnItemList.copyFrom(value); + return this; + } + + @Override + public ComposeSelectedRelicScRsp copyFrom(final ComposeSelectedRelicScRsp other) { + cachedSize = other.cachedSize; + if ((bitField0_ | other.bitField0_) != 0) { + bitField0_ = other.bitField0_; + retcode = other.retcode; + composeId = other.composeId; + returnItemList.copyFrom(other.returnItemList); + } + return this; + } + + @Override + public ComposeSelectedRelicScRsp mergeFrom(final ComposeSelectedRelicScRsp other) { + if (other.isEmpty()) { + return this; + } + cachedSize = -1; + if (other.hasRetcode()) { + setRetcode(other.retcode); + } + if (other.hasComposeId()) { + setComposeId(other.composeId); + } + if (other.hasReturnItemList()) { + getMutableReturnItemList().mergeFrom(other.returnItemList); + } + return this; + } + + @Override + public ComposeSelectedRelicScRsp clear() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + retcode = 0; + composeId = 0; + returnItemList.clear(); + return this; + } + + @Override + public ComposeSelectedRelicScRsp clearQuick() { + if (isEmpty()) { + return this; + } + cachedSize = -1; + bitField0_ = 0; + returnItemList.clearQuick(); + return this; + } + + @Override + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof ComposeSelectedRelicScRsp)) { + return false; + } + ComposeSelectedRelicScRsp other = (ComposeSelectedRelicScRsp) o; + return bitField0_ == other.bitField0_ + && (!hasRetcode() || retcode == other.retcode) + && (!hasComposeId() || composeId == other.composeId) + && (!hasReturnItemList() || returnItemList.equals(other.returnItemList)); + } + + @Override + public void writeTo(final ProtoSink output) throws IOException { + if ((bitField0_ & 0x00000001) != 0) { + output.writeRawByte((byte) 8); + output.writeUInt32NoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeRawByte((byte) 24); + output.writeUInt32NoTag(composeId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeRawByte((byte) 114); + output.writeMessageNoTag(returnItemList); + } + } + + @Override + protected int computeSerializedSize() { + int size = 0; + if ((bitField0_ & 0x00000001) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(composeId); + } + if ((bitField0_ & 0x00000004) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(returnItemList); + } + return size; + } + + @Override + @SuppressWarnings("fallthrough") + public ComposeSelectedRelicScRsp mergeFrom(final ProtoSource input) throws IOException { + // Enabled Fall-Through Optimization (QuickBuffers) + int tag = input.readTag(); + while (true) { + switch (tag) { + case 8: { + // retcode + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + tag = input.readTag(); + if (tag != 24) { + break; + } + } + case 24: { + // composeId + composeId = input.readUInt32(); + bitField0_ |= 0x00000002; + tag = input.readTag(); + if (tag != 114) { + break; + } + } + case 114: { + // returnItemList + input.readMessage(returnItemList); + bitField0_ |= 0x00000004; + tag = input.readTag(); + if (tag != 0) { + break; + } + } + case 0: { + return this; + } + default: { + if (!input.skipField(tag)) { + return this; + } + tag = input.readTag(); + break; + } + } + } + } + + @Override + public void writeTo(final JsonSink output) throws IOException { + output.beginObject(); + if ((bitField0_ & 0x00000001) != 0) { + output.writeUInt32(FieldNames.retcode, retcode); + } + if ((bitField0_ & 0x00000002) != 0) { + output.writeUInt32(FieldNames.composeId, composeId); + } + if ((bitField0_ & 0x00000004) != 0) { + output.writeMessage(FieldNames.returnItemList, returnItemList); + } + output.endObject(); + } + + @Override + public ComposeSelectedRelicScRsp mergeFrom(final JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } + while (!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 1097936398: { + if (input.isAtField(FieldNames.retcode)) { + if (!input.trySkipNullValue()) { + retcode = input.readUInt32(); + bitField0_ |= 0x00000001; + } + } else { + input.skipUnknownField(); + } + break; + } + case -1399759283: + case -442843416: { + if (input.isAtField(FieldNames.composeId)) { + if (!input.trySkipNullValue()) { + composeId = input.readUInt32(); + bitField0_ |= 0x00000002; + } + } else { + input.skipUnknownField(); + } + break; + } + case -6533215: + case -807051781: { + if (input.isAtField(FieldNames.returnItemList)) { + if (!input.trySkipNullValue()) { + input.readMessage(returnItemList); + bitField0_ |= 0x00000004; + } + } else { + input.skipUnknownField(); + } + break; + } + default: { + input.skipUnknownField(); + break; + } + } + } + input.endObject(); + return this; + } + + @Override + public ComposeSelectedRelicScRsp clone() { + return new ComposeSelectedRelicScRsp().copyFrom(this); + } + + @Override + public boolean isEmpty() { + return ((bitField0_) == 0); + } + + public static ComposeSelectedRelicScRsp parseFrom(final byte[] data) throws + InvalidProtocolBufferException { + return ProtoMessage.mergeFrom(new ComposeSelectedRelicScRsp(), data).checkInitialized(); + } + + public static ComposeSelectedRelicScRsp parseFrom(final ProtoSource input) throws IOException { + return ProtoMessage.mergeFrom(new ComposeSelectedRelicScRsp(), input).checkInitialized(); + } + + public static ComposeSelectedRelicScRsp parseFrom(final JsonSource input) throws IOException { + return ProtoMessage.mergeFrom(new ComposeSelectedRelicScRsp(), input).checkInitialized(); + } + + /** + * @return factory for creating ComposeSelectedRelicScRsp messages + */ + public static MessageFactory getFactory() { + return ComposeSelectedRelicScRspFactory.INSTANCE; + } + + private enum ComposeSelectedRelicScRspFactory implements MessageFactory { + INSTANCE; + + @Override + public ComposeSelectedRelicScRsp create() { + return ComposeSelectedRelicScRsp.newInstance(); + } + } + + /** + * Contains name constants used for serializing JSON + */ + static class FieldNames { + static final FieldName retcode = FieldName.forField("retcode"); + + static final FieldName composeId = FieldName.forField("composeId", "compose_id"); + + static final FieldName returnItemList = FieldName.forField("returnItemList", "return_item_list"); + } + } +} diff --git a/src/main/java/emu/lunarcore/data/excel/ItemComposeExcel.java b/src/main/java/emu/lunarcore/data/excel/ItemComposeExcel.java index 28cc7cc..dd61447 100644 --- a/src/main/java/emu/lunarcore/data/excel/ItemComposeExcel.java +++ b/src/main/java/emu/lunarcore/data/excel/ItemComposeExcel.java @@ -5,7 +5,7 @@ import java.util.List; import emu.lunarcore.data.GameResource; import emu.lunarcore.data.ResourceType; import emu.lunarcore.data.common.ItemParam; - +import it.unimi.dsi.fastutil.ints.IntOpenHashSet; import lombok.Getter; @Getter @@ -18,7 +18,7 @@ public class ItemComposeExcel extends GameResource { private int[] SpecialMaterialCost; private int CoinCost; private int WorldLevelRequire; - private int[] RelicList; + private IntOpenHashSet RelicList; @Override public int getId() { diff --git a/src/main/java/emu/lunarcore/game/inventory/GameItem.java b/src/main/java/emu/lunarcore/game/inventory/GameItem.java index f5ed685..ee255ba 100644 --- a/src/main/java/emu/lunarcore/game/inventory/GameItem.java +++ b/src/main/java/emu/lunarcore/game/inventory/GameItem.java @@ -47,7 +47,7 @@ public class GameItem { @Setter private int rank; // Superimpose @Setter private boolean locked; - private int mainAffix; + @Setter private int mainAffix; private List subAffixes; private int equipAvatar; diff --git a/src/main/java/emu/lunarcore/game/service/InventoryService.java b/src/main/java/emu/lunarcore/game/service/InventoryService.java index 45e7154..7aa73f2 100644 --- a/src/main/java/emu/lunarcore/game/service/InventoryService.java +++ b/src/main/java/emu/lunarcore/game/service/InventoryService.java @@ -624,4 +624,66 @@ public class InventoryService extends BaseGameService { return items; } + + public List composeRelic(Player player, int composeId, int relicId, int mainAffix, int count) { + // Sanity check + if (count <= 0) return null; + + // Get item compose excel data + ItemComposeExcel excel = GameData.getItemComposeExcelMap().get(composeId); + if (excel == null || excel.getFormulaType() != FormulaType.SelectedRelic) { + return null; + } + + // Verify relic ids + if (excel.getRelicList() == null || !excel.getRelicList().contains(relicId)) { + return null; + } + + // Build cost items + List costItems = new ArrayList<>(); + costItems.addAll(excel.getMaterialCost()); + + // Check main affix + if (mainAffix > 0) { + for (int specialId : excel.getSpecialMaterialCost()) { + costItems.add(new ItemParam(specialId, 1)); + } + } + + // Verify items + for (ItemParam param : costItems) { + GameItem item = player.getInventory().getItemByParam(param); + if (item == null || item.getCount() < param.getCount() * count) { + return null; + } + } + + // Verify credits + if (player.getScoin() < excel.getCoinCost() * count) { + return null; + } + + // Pay items + player.getInventory().removeItemsByParams(costItems, count); + player.addSCoin(-excel.getCoinCost() * count); + + // Compose item + List items = new ArrayList<>(); + + for (int i = 0; i < count; i++) { + GameItem item = new GameItem(relicId, 1); + + if (mainAffix > 0) { + item.setMainAffix(mainAffix); + } + + items.add(item); + } + + // Add items to inventory + player.getInventory().addItems(items); + + return items; + } } diff --git a/src/main/java/emu/lunarcore/server/packet/recv/HandlerComposeSelectedRelicCsReq.java b/src/main/java/emu/lunarcore/server/packet/recv/HandlerComposeSelectedRelicCsReq.java new file mode 100644 index 0000000..57ae22f --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/recv/HandlerComposeSelectedRelicCsReq.java @@ -0,0 +1,31 @@ +package emu.lunarcore.server.packet.recv; + +import java.util.List; + +import emu.lunarcore.game.inventory.GameItem; +import emu.lunarcore.proto.ComposeSelectedRelicCsReqOuterClass.ComposeSelectedRelicCsReq; +import emu.lunarcore.server.game.GameSession; +import emu.lunarcore.server.packet.CmdId; +import emu.lunarcore.server.packet.Opcodes; +import emu.lunarcore.server.packet.PacketHandler; +import emu.lunarcore.server.packet.send.PacketComposeSelectedRelicScRsp; + +@Opcodes(CmdId.ComposeSelectedRelicCsReq) +public class HandlerComposeSelectedRelicCsReq extends PacketHandler { + + @Override + public void handle(GameSession session, byte[] header, byte[] data) throws Exception { + var req = ComposeSelectedRelicCsReq.parseFrom(data); + + List returnList = session.getServer().getInventoryService().composeRelic( + session.getPlayer(), + req.getComposeId(), + req.getComposeRelicId(), + req.getMainAffixId(), + req.getCount() + ); + + session.send(new PacketComposeSelectedRelicScRsp(req.getComposeId(), returnList)); + } + +} diff --git a/src/main/java/emu/lunarcore/server/packet/send/PacketComposeSelectedRelicScRsp.java b/src/main/java/emu/lunarcore/server/packet/send/PacketComposeSelectedRelicScRsp.java new file mode 100644 index 0000000..31cf0a0 --- /dev/null +++ b/src/main/java/emu/lunarcore/server/packet/send/PacketComposeSelectedRelicScRsp.java @@ -0,0 +1,28 @@ +package emu.lunarcore.server.packet.send; + +import java.util.Collection; + +import emu.lunarcore.game.inventory.GameItem; +import emu.lunarcore.proto.ComposeSelectedRelicScRspOuterClass.ComposeSelectedRelicScRsp; +import emu.lunarcore.server.packet.BasePacket; +import emu.lunarcore.server.packet.CmdId; + +public class PacketComposeSelectedRelicScRsp extends BasePacket { + + public PacketComposeSelectedRelicScRsp(int composeId, Collection returnList) { + super(CmdId.ComposeSelectedRelicScRsp); + + var data = ComposeSelectedRelicScRsp.newInstance() + .setComposeId(composeId); + + if (returnList != null) { + for (var item : returnList) { + data.getMutableReturnItemList().addItemList(item.toProto()); + } + } else { + data.getMutableReturnItemList(); + } + + this.setData(data); + } +}