From b3b73f8471d07ed1f74f2429949a297092cc8cbe Mon Sep 17 00:00:00 2001 From: moraxs <98573765+moraxs@users.noreply.github.com> Date: Fri, 5 Apr 2024 17:58:20 +0800 Subject: [PATCH] Add files via upload --- .../proto/ClientDownloadDataOuterClass.java | 358 ++++++++++++++++++ .../ClientDownloadDataScNotifyOuterClass.java | 231 +++++++++++ .../main/emu/lunarcore/proto/luac.luac | Bin 0 -> 1069 bytes 3 files changed, 589 insertions(+) create mode 100644 src/generated/main/emu/lunarcore/proto/ClientDownloadDataOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/ClientDownloadDataScNotifyOuterClass.java create mode 100644 src/generated/main/emu/lunarcore/proto/luac.luac diff --git a/src/generated/main/emu/lunarcore/proto/ClientDownloadDataOuterClass.java b/src/generated/main/emu/lunarcore/proto/ClientDownloadDataOuterClass.java new file mode 100644 index 000000000..abfe53674 --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ClientDownloadDataOuterClass.java @@ -0,0 +1,358 @@ +package emu.lunarcore.proto; + +import java.io.IOException; +import us.hebi.quickbuf.FieldName; +import us.hebi.quickbuf.InvalidProtocolBufferException; +import us.hebi.quickbuf.JsonSink; +import us.hebi.quickbuf.JsonSource; +import us.hebi.quickbuf.MessageFactory; +import us.hebi.quickbuf.ProtoMessage; +import us.hebi.quickbuf.ProtoSink; +import us.hebi.quickbuf.ProtoSource; +import us.hebi.quickbuf.RepeatedByte; + +public final class ClientDownloadDataOuterClass { + public ClientDownloadDataOuterClass() { + } + + public static final class ClientDownloadData extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + private long time; + private int version; + private final RepeatedByte data = RepeatedByte.newEmptyInstance(); + + private ClientDownloadData() { + } + + public static ClientDownloadData newInstance() { + return new ClientDownloadData(); + } + + public boolean hasTime() { + return (this.bitField0_ & 1) != 0; + } + + public ClientDownloadData clearTime() { + this.bitField0_ &= -2; + this.time = 0L; + return this; + } + + public long getTime() { + return this.time; + } + + public ClientDownloadData setTime(long value) { + this.bitField0_ |= 1; + this.time = value; + return this; + } + + public boolean hasVersion() { + return (this.bitField0_ & 2) != 0; + } + + public ClientDownloadData clearVersion() { + this.bitField0_ &= -3; + this.version = 0; + return this; + } + + public int getVersion() { + return this.version; + } + + public ClientDownloadData setVersion(int value) { + this.bitField0_ |= 2; + this.version = value; + return this; + } + + public boolean hasData() { + return (this.bitField0_ & 4) != 0; + } + + public ClientDownloadData clearData() { + this.bitField0_ &= -5; + this.data.clear(); + return this; + } + + public RepeatedByte getData() { + return this.data; + } + + public RepeatedByte getMutableData() { + this.bitField0_ |= 4; + return this.data; + } + + public ClientDownloadData addData(byte value) { + this.bitField0_ |= 4; + this.data.add(value); + return this; + } + + public ClientDownloadData addAllData(byte... values) { + this.bitField0_ |= 4; + this.data.addAll(values); + return this; + } + + public ClientDownloadData setData(byte... values) { + this.bitField0_ |= 4; + this.data.copyFrom(values); + return this; + } + + public ClientDownloadData copyFrom(ClientDownloadData other) { + this.cachedSize = other.cachedSize; + if ((this.bitField0_ | other.bitField0_) != 0) { + this.bitField0_ = other.bitField0_; + this.time = other.time; + this.version = other.version; + this.data.copyFrom(other.data); + } + + return this; + } + + public ClientDownloadData mergeFrom(ClientDownloadData other) { + if (other.isEmpty()) { + return this; + } else { + this.cachedSize = -1; + if (other.hasTime()) { + this.setTime(other.time); + } + + if (other.hasVersion()) { + this.setVersion(other.version); + } + + if (other.hasData()) { + this.getMutableData().copyFrom(other.data); + } + + return this; + } + } + + public ClientDownloadData clear() { + if (this.isEmpty()) { + return this; + } else { + this.cachedSize = -1; + this.bitField0_ = 0; + this.time = 0L; + this.version = 0; + this.data.clear(); + return this; + } + } + + public ClientDownloadData clearQuick() { + if (this.isEmpty()) { + return this; + } else { + this.cachedSize = -1; + this.bitField0_ = 0; + this.data.clear(); + return this; + } + } + + public boolean equals(Object o) { + if (o == this) { + return true; + } else if (!(o instanceof ClientDownloadData)) { + return false; + } else { + ClientDownloadData other = (ClientDownloadData)o; + return this.bitField0_ == other.bitField0_ && (!this.hasTime() || this.time == other.time) && (!this.hasVersion() || this.version == other.version) && (!this.hasData() || this.data.equals(other.data)); + } + } + + public void writeTo(ProtoSink output) throws IOException { + if ((this.bitField0_ & 1) != 0) { + output.writeRawByte((byte)16); + output.writeInt64NoTag(this.time); + } + + if ((this.bitField0_ & 2) != 0) { + output.writeRawByte((byte)8); + output.writeUInt32NoTag(this.version); + } + + if ((this.bitField0_ & 4) != 0) { + output.writeRawByte((byte)26); + output.writeBytesNoTag(this.data); + } + + } + + protected int computeSerializedSize() { + int size = 0; + if ((this.bitField0_ & 1) != 0) { + size += 1 + ProtoSink.computeInt64SizeNoTag(this.time); + } + + if ((this.bitField0_ & 2) != 0) { + size += 1 + ProtoSink.computeUInt32SizeNoTag(this.version); + } + + if ((this.bitField0_ & 4) != 0) { + size += 1 + ProtoSink.computeBytesSizeNoTag(this.data); + } + + return size; + } + + public ClientDownloadData mergeFrom(ProtoSource input) throws IOException { + int tag = input.readTag(); + + while(true) { + switch (tag) { + case 0: + return this; + case 16: + this.time = input.readInt64(); + this.bitField0_ |= 1; + tag = input.readTag(); + if (tag != 8) { + break; + } + case 8: + this.version = input.readUInt32(); + this.bitField0_ |= 2; + tag = input.readTag(); + if (tag != 26) { + break; + } + case 26: + input.readBytes(this.data); + this.bitField0_ |= 4; + tag = input.readTag(); + if (tag != 0) { + break; + } + + return this; + default: + if (!input.skipField(tag)) { + return this; + } + + tag = input.readTag(); + } + } + } + + public void writeTo(JsonSink output) throws IOException { + output.beginObject(); + if ((this.bitField0_ & 1) != 0) { + output.writeInt64(ClientDownloadDataOuterClass.ClientDownloadData.FieldNames.time, this.time); + } + + if ((this.bitField0_ & 2) != 0) { + output.writeUInt32(ClientDownloadDataOuterClass.ClientDownloadData.FieldNames.version, this.version); + } + + if ((this.bitField0_ & 4) != 0) { + output.writeBytes(ClientDownloadDataOuterClass.ClientDownloadData.FieldNames.data, this.data); + } + + output.endObject(); + } + + public ClientDownloadData mergeFrom(JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } else { + while(!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 3076010: + if (input.isAtField(ClientDownloadDataOuterClass.ClientDownloadData.FieldNames.data)) { + if (!input.trySkipNullValue()) { + input.readBytes(this.data); + this.bitField0_ |= 4; + } + } else { + input.skipUnknownField(); + } + break; + case 3560141: + if (input.isAtField(ClientDownloadDataOuterClass.ClientDownloadData.FieldNames.time)) { + if (!input.trySkipNullValue()) { + this.time = input.readInt64(); + this.bitField0_ |= 1; + } + } else { + input.skipUnknownField(); + } + break; + case 351608024: + if (input.isAtField(ClientDownloadDataOuterClass.ClientDownloadData.FieldNames.version)) { + if (!input.trySkipNullValue()) { + this.version = input.readUInt32(); + this.bitField0_ |= 2; + } + } else { + input.skipUnknownField(); + } + break; + default: + input.skipUnknownField(); + } + } + + input.endObject(); + return this; + } + } + + public ClientDownloadData clone() { + return (new ClientDownloadData()).copyFrom(this); + } + + public boolean isEmpty() { + return this.bitField0_ == 0; + } + + public static ClientDownloadData parseFrom(byte[] data) throws InvalidProtocolBufferException { + return (ClientDownloadData)((ClientDownloadData)ProtoMessage.mergeFrom(new ClientDownloadData(), data)).checkInitialized(); + } + + public static ClientDownloadData parseFrom(ProtoSource input) throws IOException { + return (ClientDownloadData)((ClientDownloadData)ProtoMessage.mergeFrom(new ClientDownloadData(), input)).checkInitialized(); + } + + public static ClientDownloadData parseFrom(JsonSource input) throws IOException { + return (ClientDownloadData)((ClientDownloadData)ProtoMessage.mergeFrom(new ClientDownloadData(), input)).checkInitialized(); + } + + public static MessageFactory getFactory() { + return ClientDownloadDataOuterClass.ClientDownloadData.ClientDownloadDataFactory.INSTANCE; + } + + static class FieldNames { + static final FieldName time = FieldName.forField("time"); + static final FieldName version = FieldName.forField("version"); + static final FieldName data = FieldName.forField("data"); + + FieldNames() { + } + } + + private static enum ClientDownloadDataFactory implements MessageFactory { + INSTANCE; + + private ClientDownloadDataFactory() { + } + + public ClientDownloadData create() { + return ClientDownloadDataOuterClass.ClientDownloadData.newInstance(); + } + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/ClientDownloadDataScNotifyOuterClass.java b/src/generated/main/emu/lunarcore/proto/ClientDownloadDataScNotifyOuterClass.java new file mode 100644 index 000000000..7e11dd4fe --- /dev/null +++ b/src/generated/main/emu/lunarcore/proto/ClientDownloadDataScNotifyOuterClass.java @@ -0,0 +1,231 @@ +package emu.lunarcore.proto; + +import emu.lunarcore.proto.ClientDownloadDataOuterClass.ClientDownloadData; +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 ClientDownloadDataScNotifyOuterClass { + public ClientDownloadDataScNotifyOuterClass() { + } + + public static final class ClientDownloadDataScNotify extends ProtoMessage implements Cloneable { + private static final long serialVersionUID = 0L; + private final ClientDownloadDataOuterClass.ClientDownloadData downloadData = ClientDownloadData.newInstance(); + + private ClientDownloadDataScNotify() { + } + + public static ClientDownloadDataScNotify newInstance() { + return new ClientDownloadDataScNotify(); + } + + public boolean hasDownloadData() { + return (this.bitField0_ & 1) != 0; + } + + public ClientDownloadDataScNotify clearDownloadData() { + this.bitField0_ &= -2; + this.downloadData.clear(); + return this; + } + + public ClientDownloadDataOuterClass.ClientDownloadData getDownloadData() { + return this.downloadData; + } + + public ClientDownloadDataOuterClass.ClientDownloadData getMutableDownloadData() { + this.bitField0_ |= 1; + return this.downloadData; + } + + public ClientDownloadDataScNotify setDownloadData(ClientDownloadDataOuterClass.ClientDownloadData value) { + this.bitField0_ |= 1; + this.downloadData.copyFrom(value); + return this; + } + + public ClientDownloadDataScNotify copyFrom(ClientDownloadDataScNotify other) { + this.cachedSize = other.cachedSize; + if ((this.bitField0_ | other.bitField0_) != 0) { + this.bitField0_ = other.bitField0_; + this.downloadData.copyFrom(other.downloadData); + } + + return this; + } + + public ClientDownloadDataScNotify mergeFrom(ClientDownloadDataScNotify other) { + if (other.isEmpty()) { + return this; + } else { + this.cachedSize = -1; + if (other.hasDownloadData()) { + this.getMutableDownloadData().mergeFrom(other.downloadData); + } + + return this; + } + } + + public ClientDownloadDataScNotify clear() { + if (this.isEmpty()) { + return this; + } else { + this.cachedSize = -1; + this.bitField0_ = 0; + this.downloadData.clear(); + return this; + } + } + + public ClientDownloadDataScNotify clearQuick() { + if (this.isEmpty()) { + return this; + } else { + this.cachedSize = -1; + this.bitField0_ = 0; + this.downloadData.clearQuick(); + return this; + } + } + + public boolean equals(Object o) { + if (o == this) { + return true; + } else if (!(o instanceof ClientDownloadDataScNotify)) { + return false; + } else { + ClientDownloadDataScNotify other = (ClientDownloadDataScNotify)o; + return this.bitField0_ == other.bitField0_ && (!this.hasDownloadData() || this.downloadData.equals(other.downloadData)); + } + } + + public void writeTo(ProtoSink output) throws IOException { + if ((this.bitField0_ & 1) != 0) { + output.writeRawByte((byte)98); + output.writeMessageNoTag(this.downloadData); + } + + } + + protected int computeSerializedSize() { + int size = 0; + if ((this.bitField0_ & 1) != 0) { + size += 1 + ProtoSink.computeMessageSizeNoTag(this.downloadData); + } + + return size; + } + + public ClientDownloadDataScNotify mergeFrom(ProtoSource input) throws IOException { + int tag = input.readTag(); + + while(true) { + switch (tag) { + case 0: + return this; + case 98: + input.readMessage(this.downloadData); + this.bitField0_ |= 1; + tag = input.readTag(); + if (tag != 0) { + break; + } + + return this; + default: + if (!input.skipField(tag)) { + return this; + } + + tag = input.readTag(); + } + } + } + + public void writeTo(JsonSink output) throws IOException { + output.beginObject(); + if ((this.bitField0_ & 1) != 0) { + output.writeMessage(ClientDownloadDataScNotifyOuterClass.ClientDownloadDataScNotify.FieldNames.downloadData, this.downloadData); + } + + output.endObject(); + } + + public ClientDownloadDataScNotify mergeFrom(JsonSource input) throws IOException { + if (!input.beginObject()) { + return this; + } else { + while(!input.isAtEnd()) { + switch (input.readFieldHash()) { + case 31388929: + case 1108584530: + if (input.isAtField(ClientDownloadDataScNotifyOuterClass.ClientDownloadDataScNotify.FieldNames.downloadData)) { + if (!input.trySkipNullValue()) { + input.readMessage(this.downloadData); + this.bitField0_ |= 1; + } + } else { + input.skipUnknownField(); + } + break; + default: + input.skipUnknownField(); + } + } + + input.endObject(); + return this; + } + } + + public ClientDownloadDataScNotify clone() { + return (new ClientDownloadDataScNotify()).copyFrom(this); + } + + public boolean isEmpty() { + return this.bitField0_ == 0; + } + + public static ClientDownloadDataScNotify parseFrom(byte[] data) throws InvalidProtocolBufferException { + return (ClientDownloadDataScNotify)((ClientDownloadDataScNotify)ProtoMessage.mergeFrom(new ClientDownloadDataScNotify(), data)).checkInitialized(); + } + + public static ClientDownloadDataScNotify parseFrom(ProtoSource input) throws IOException { + return (ClientDownloadDataScNotify)((ClientDownloadDataScNotify)ProtoMessage.mergeFrom(new ClientDownloadDataScNotify(), input)).checkInitialized(); + } + + public static ClientDownloadDataScNotify parseFrom(JsonSource input) throws IOException { + return (ClientDownloadDataScNotify)((ClientDownloadDataScNotify)ProtoMessage.mergeFrom(new ClientDownloadDataScNotify(), input)).checkInitialized(); + } + + public static MessageFactory getFactory() { + return ClientDownloadDataScNotifyOuterClass.ClientDownloadDataScNotify.ClientDownloadDataScNotifyFactory.INSTANCE; + } + + static class FieldNames { + static final FieldName downloadData = FieldName.forField("downloadData", "download_data"); + + FieldNames() { + } + } + + private static enum ClientDownloadDataScNotifyFactory implements MessageFactory { + INSTANCE; + + private ClientDownloadDataScNotifyFactory() { + } + + public ClientDownloadDataScNotify create() { + return ClientDownloadDataScNotifyOuterClass.ClientDownloadDataScNotify.newInstance(); + } + } + } +} diff --git a/src/generated/main/emu/lunarcore/proto/luac.luac b/src/generated/main/emu/lunarcore/proto/luac.luac new file mode 100644 index 0000000000000000000000000000000000000000..b1ee15d2cb12ab3d7ff97771429f7de3edd4dab8 GIT binary patch literal 1069 zcmcIi+iDY06y1}Y=}jwwH>!w1eQ3d&S~a014kt}IrBb!DX?#fur;|fH?PR9RrKWEO z+XtU~5sC=DNCh7X`Uj@|gZ%@epW)t#t;Gw7;J_MI)?R0y$zJ=yOf2S&f#>~w=ldAz z>1mYV$20ht8+UnOys{9=Agqjz-ppnyMc;|*(u=}MNqP>Fl&xI(y_y}#-p*7=n3K+W zrKE&6qZX!%*WFkg_BG6I77xB&@#x8*J( zV4lO*RXjPw5gO6tP)5TwJbaPoVOtZ|hJp#W%=KoinTJLG5%zTg&h90^)sP^)3`y9* z+CERhY*WJ}4qNmEC$K+D7UtRU1y4mAlisrOBs(@G>hi(TigY4o+RCf3q4b1|#6uCu zpe};dg7DTwI9PCfPY$JLg(ux~sS)7>SpSra3VwYJD;}OM$wtIjtZK}Rh?>h`yu?g& zj-QTm%E~#u>j!tPjEvZJ*0x%^ufKkH)_V2k^V9dabh~Dyj(Tj{%5R8Oks40j6Dxl3 zi>Wx88M`rQwVu5F@^ULbU2MI0H-2EsrIp1_9l6!EGh-9CEY^S2K}mETnttLhkVFrG z{Q)NGKZ63Mo4Ro}{?bY>Qo4>LvpRXd475C?8o(%}8gNj&2}&cHP1wc)rfV$nJxrUp zHg<3eXvcO@uWG$X2~&&zpKvGK-pCK5KzYkQMo6FD^AG6!bAT=x1b%=G+N*jv9U2Zz mkZgUw0i||wPOiDak=5vttm4A8r`^$`IPk&)oxIfVu=zJt65^2n literal 0 HcmV?d00001