diff --git a/api/src/main/java/com/viaversion/viaversion/api/ViaAPI.java b/api/src/main/java/com/viaversion/viaversion/api/ViaAPI.java index 2f6bd45e7..46203d447 100644 --- a/api/src/main/java/com/viaversion/viaversion/api/ViaAPI.java +++ b/api/src/main/java/com/viaversion/viaversion/api/ViaAPI.java @@ -52,7 +52,7 @@ public interface ViaAPI { * @return API version incremented with meaningful API changes */ default int apiVersion() { - return 3; + return 4; } /** diff --git a/api/src/main/java/com/viaversion/viaversion/api/protocol/ProtocolManager.java b/api/src/main/java/com/viaversion/viaversion/api/protocol/ProtocolManager.java index 83bbf87f9..f39235f4e 100644 --- a/api/src/main/java/com/viaversion/viaversion/api/protocol/ProtocolManager.java +++ b/api/src/main/java/com/viaversion/viaversion/api/protocol/ProtocolManager.java @@ -24,8 +24,11 @@ package com.viaversion.viaversion.api.protocol; import com.google.common.collect.Range; import com.viaversion.viaversion.api.connection.UserConnection; +import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType; import com.viaversion.viaversion.api.protocol.packet.PacketType; import com.viaversion.viaversion.api.protocol.packet.PacketWrapper; +import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType; +import com.viaversion.viaversion.api.protocol.packet.VersionedPacketCreator; import com.viaversion.viaversion.api.protocol.version.ProtocolVersion; import com.viaversion.viaversion.api.protocol.version.ServerProtocolVersion; import io.netty.buffer.ByteBuf; @@ -143,6 +146,22 @@ public interface ProtocolManager { */ @Nullable List getProtocolPath(int clientVersion, int serverVersion); + /** + * Returns a versioned packet creator to send packets from a given base version to any client version supported by Via. + * The used packet types have to match the given protocol version. + * + * @param inputVersion input protocol version + * @param clientbound packet for the given protocol version + * @param serverbound packet for the given protocol version + * @param clientboundPacketsClass clientbound packets class + * @param serverboundPacketsClass serverbound packets class + * @return versioned packet creator + * @throws IllegalArgumentException if either of the packet classes are the base {@link ClientboundPacketType} or {@link ServerboundPacketType} interfaces + */ + VersionedPacketCreator createVersionedPacketCreator(ProtocolVersion inputVersion, Class clientboundPacketsClass, Class serverboundPacketsClass); + /** * Returns whether protocol path calculation expects the path to come closer to the expected version with each entry, true by default. *

diff --git a/api/src/main/java/com/viaversion/viaversion/api/protocol/SimpleProtocol.java b/api/src/main/java/com/viaversion/viaversion/api/protocol/SimpleProtocol.java index a2cfef595..044465587 100644 --- a/api/src/main/java/com/viaversion/viaversion/api/protocol/SimpleProtocol.java +++ b/api/src/main/java/com/viaversion/viaversion/api/protocol/SimpleProtocol.java @@ -23,6 +23,7 @@ package com.viaversion.viaversion.api.protocol; import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType; +import com.viaversion.viaversion.api.protocol.packet.Direction; import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType; /** @@ -45,5 +46,10 @@ public interface SimpleProtocol extends Protocol packetProtocol) throws Exception; + + @Deprecated + default void send() throws Exception { + sendRaw(); + } + /** - * Send this packet to the associated user. - * Be careful not to send packets twice. - * (Sends it after current) - * This method is no longer used, it's favoured to use {@link #send(Class)} as it will handle the pipeline properly. + * Sends this packet to the connection. + * Unlike {@link #send(Class)}, this method does not handle the pipeline with packet id and data changes. * * @throws Exception if it fails to write */ - @Deprecated - void send() throws Exception; + void sendRaw() throws Exception; + + /** + * Sends this packet to the associated user, submitted to netty's event loop. + * Unlike {@link #send(Class)}, this method does not handle the pipeline with packet id and data changes. + * + * @throws Exception if it fails to write + */ + void scheduleSendRaw() throws Exception; /** * Creates a new packet for the target of this packet. @@ -317,7 +328,25 @@ public interface PacketWrapper { * @throws Exception If it failed to write */ @Deprecated - void sendToServer() throws Exception; + default void sendToServer() throws Exception { + sendToServerRaw(); + } + + /** + * Sends this packet to the server. + * Unlike {@link #sendToServer(Class)}, this method does not handle the pipeline with packet id and data changes. + * + * @throws Exception if it fails to write + */ + void sendToServerRaw() throws Exception; + + /** + * Sends this packet to the server, submitted to netty's event loop. + * Unlike {@link #sendToServer(Class)}, this method does not handle the pipeline with packet id and data changes. + * + * @throws Exception if it fails to write + */ + void scheduleSendToServerRaw() throws Exception; /** * Send this packet to the server on the current thread, skipping the current protocol. diff --git a/api/src/main/java/com/viaversion/viaversion/api/protocol/packet/ServerboundPacketType.java b/api/src/main/java/com/viaversion/viaversion/api/protocol/packet/ServerboundPacketType.java index 47fb8e333..b4a9baa7d 100644 --- a/api/src/main/java/com/viaversion/viaversion/api/protocol/packet/ServerboundPacketType.java +++ b/api/src/main/java/com/viaversion/viaversion/api/protocol/packet/ServerboundPacketType.java @@ -27,4 +27,9 @@ package com.viaversion.viaversion.api.protocol.packet; * representing PLAY state packets, ordered by their packet id. */ public interface ServerboundPacketType extends PacketType { + + @Override + default Direction direction() { + return Direction.SERVERBOUND; + } } diff --git a/api/src/main/java/com/viaversion/viaversion/api/protocol/packet/VersionedPacketCreator.java b/api/src/main/java/com/viaversion/viaversion/api/protocol/packet/VersionedPacketCreator.java new file mode 100644 index 000000000..c73b0a04c --- /dev/null +++ b/api/src/main/java/com/viaversion/viaversion/api/protocol/packet/VersionedPacketCreator.java @@ -0,0 +1,122 @@ +/* + * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion + * Copyright (C) 2016-2021 ViaVersion and contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package com.viaversion.viaversion.api.protocol.packet; + +import com.viaversion.viaversion.api.connection.ProtocolInfo; +import com.viaversion.viaversion.api.connection.UserConnection; +import org.checkerframework.checker.nullness.qual.Nullable; + +import java.util.function.Consumer; + +/** + * Utility to send packets from a given base version to or from any client version supported by Via. + * + * @param clientbound packet type + * @param serverbound packet type + */ +public interface VersionedPacketCreator { + + /** + * Sends a packet to the given user. + * Returns false if the packet has been cancelled at some point, but does not indicate whether a replacement has been constructed. + * + * @param connection user connection + * @param packetType clientbound packet type + * @param packetWriter consumer filling the packet with data + * @return whether this packet specifically has been sent, false if cancelled + * @throws IllegalArgumentException if the packet type is not of the expected clientbound packets class + * @throws RuntimeException if no path from the input version to the required client version exists + * @throws Exception if an error occurred while constructing the packet or sending it + */ + boolean send(UserConnection connection, C packetType, Consumer packetWriter) throws Exception; + + /** + * Sends a packet to the server. + * Returns false if the packet has been cancelled at some point, but does not indicate whether a replacement has been constructed. + * + * @param connection user connection + * @param packetType serverbound packet type + * @param packetWriter consumer filling the packet with data + * @return whether this packet specifically has been sent, false if cancelled + * @throws IllegalArgumentException if the packet type is not of the expected serverbound packets class + * @throws RuntimeException if no path from the input version to the required server version exists + * @throws Exception if an error occurred while constructing the packet or sending it + */ + boolean send(UserConnection connection, S packetType, Consumer packetWriter) throws Exception; + + /** + * Sends a packet to the given user, submitted to the netty event loop. + * Returns false if the packet has been cancelled at some point, but does not indicate whether a replacement has been constructed. + * + * @param connection user connection + * @param packetType clientbound packet type + * @param packetWriter consumer filling the packet with data + * @return whether this packet specifically has been sent, false if cancelled + * @throws IllegalArgumentException if the packet type is not of the expected clientbound packets class + * @throws RuntimeException if no path from the input version to the required client version exists + * @throws Exception if an error occurred while constructing the packet or sending it + */ + boolean scheduleSend(UserConnection connection, C packetType, Consumer packetWriter) throws Exception; + + /** + * Sends a packet to the server, submitted to the netty event loop. + * Returns false if the packet has been cancelled at some point, but does not indicate whether a replacement has been constructed. + * + * @param connection user connection + * @param packetType serverbound packet type + * @param packetWriter consumer filling the packet with data + * @return whether this packet specifically has been sent, false if cancelled + * @throws IllegalArgumentException if the packet type is not of the expected serverbound packets class + * @throws RuntimeException if no path from the input version to the required server version exists + * @throws Exception if an error occurred while constructing the packet or sending it + */ + boolean scheduleSend(UserConnection connection, S packetType, Consumer packetWriter) throws Exception; + + /** + * Transforms a packet to the protocol version of the given connection, or null if cancelled at some point. + * The target version is given by {@link ProtocolInfo#getProtocolVersion()} with the connection as the receiver. + * + * @param connection user connection + * @param packetType clientbound packet type + * @param packetWriter consumer filling the packet with data + * @return created and transformed packet wrapper, or null if cancelled at some point + * @throws IllegalArgumentException if the packet type is not of the expected clientbound packets class + * @throws RuntimeException if no path from the input version to the required client version exists + * @throws Exception if an error occurred while constructing the packet + */ + @Nullable PacketWrapper transform(UserConnection connection, C packetType, Consumer packetWriter) throws Exception; + + /** + * Transforms a packet to the server protocol version the connection is on, or null if cancelled at some point. + * The target version is given by {@link ProtocolInfo#getServerProtocolVersion()} with the connection as the sender. + * + * @param connection user connection + * @param packetType serverbound packet type + * @param packetWriter consumer filling the packet with data + * @return created and transformed packet wrapper, or null if cancelled at some point + * @throws IllegalArgumentException if the packet type is not of the expected serverbound packets class + * @throws RuntimeException if no path from the input version to the required server version exists + * @throws Exception if an error occurred while constructing the packet + */ + @Nullable PacketWrapper transform(UserConnection connection, S packetType, Consumer packetWriter) throws Exception; +} diff --git a/common/src/main/java/com/viaversion/viaversion/connection/UserConnectionImpl.java b/common/src/main/java/com/viaversion/viaversion/connection/UserConnectionImpl.java index 385c8fbc8..add28efa4 100644 --- a/common/src/main/java/com/viaversion/viaversion/connection/UserConnectionImpl.java +++ b/common/src/main/java/com/viaversion/viaversion/connection/UserConnectionImpl.java @@ -200,12 +200,17 @@ public class UserConnectionImpl implements UserConnection { // We'll use passing through because there are some encoder wrappers ChannelHandlerContext context = PipelineUtil .getPreviousContext(Via.getManager().getInjector().getDecoderName(), channel.pipeline()); - try { - Type.VAR_INT.writePrimitive(buf, PacketWrapper.PASSTHROUGH_ID); - Type.UUID.write(buf, generatePassthroughToken()); - } catch (Exception shouldNotHappen) { - throw new RuntimeException(shouldNotHappen); + + if (shouldTransformPacket()) { + // Bypass serverbound packet decoder transforming + try { + Type.VAR_INT.writePrimitive(buf, PacketWrapper.PASSTHROUGH_ID); + Type.UUID.write(buf, generatePassthroughToken()); + } catch (Exception shouldNotHappen) { + throw new RuntimeException(shouldNotHappen); + } } + buf.writeBytes(packet); Runnable act = () -> { if (context != null) { diff --git a/common/src/main/java/com/viaversion/viaversion/protocol/ProtocolManagerImpl.java b/common/src/main/java/com/viaversion/viaversion/protocol/ProtocolManagerImpl.java index a138b700c..02deab5d0 100644 --- a/common/src/main/java/com/viaversion/viaversion/protocol/ProtocolManagerImpl.java +++ b/common/src/main/java/com/viaversion/viaversion/protocol/ProtocolManagerImpl.java @@ -28,10 +28,14 @@ import com.viaversion.viaversion.api.protocol.Protocol; import com.viaversion.viaversion.api.protocol.ProtocolManager; import com.viaversion.viaversion.api.protocol.ProtocolPathEntry; import com.viaversion.viaversion.api.protocol.ProtocolPathKey; +import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType; import com.viaversion.viaversion.api.protocol.packet.PacketWrapper; +import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType; +import com.viaversion.viaversion.api.protocol.packet.VersionedPacketCreator; import com.viaversion.viaversion.api.protocol.version.ProtocolVersion; import com.viaversion.viaversion.api.protocol.version.ServerProtocolVersion; import com.viaversion.viaversion.protocol.packet.PacketWrapperImpl; +import com.viaversion.viaversion.protocol.packet.VersionedPacketCreatorImpl; import com.viaversion.viaversion.protocols.base.BaseProtocol; import com.viaversion.viaversion.protocols.base.BaseProtocol1_16; import com.viaversion.viaversion.protocols.base.BaseProtocol1_7; @@ -261,6 +265,14 @@ public class ProtocolManagerImpl implements ProtocolManager { return path; } + @Override + public VersionedPacketCreator createVersionedPacketCreator(ProtocolVersion inputVersion, Class clientboundPacketsClass, Class serverboundPacketsClass) { + Preconditions.checkArgument(clientboundPacketsClass != ClientboundPacketType.class && serverboundPacketsClass != ServerboundPacketType.class); + return new VersionedPacketCreatorImpl<>(inputVersion, clientboundPacketsClass, serverboundPacketsClass); + } + /** * Calculates a path to get from an input protocol to the server's protocol. * @@ -270,7 +282,7 @@ public class ProtocolManagerImpl implements ProtocolManager { * @return path that has been generated, null if failed */ private @Nullable Int2ObjectSortedMap getProtocolPath(Int2ObjectSortedMap current, int clientVersion, int serverVersion) { - if (current.size() > maxProtocolPathSize) return null; // Fail safe, protocol too complicated. + if (current.size() > maxProtocolPathSize) return null; // Fail-safe, protocol too complicated. // First, check if there is any protocols for this Int2ObjectMap toServerProtocolMap = registryMap.get(clientVersion); diff --git a/common/src/main/java/com/viaversion/viaversion/protocol/packet/PacketWrapperImpl.java b/common/src/main/java/com/viaversion/viaversion/protocol/packet/PacketWrapperImpl.java index e1f2aa5be..86bb3e727 100644 --- a/common/src/main/java/com/viaversion/viaversion/protocol/packet/PacketWrapperImpl.java +++ b/common/src/main/java/com/viaversion/viaversion/protocol/packet/PacketWrapperImpl.java @@ -306,15 +306,26 @@ public class PacketWrapperImpl implements PacketWrapper { } @Override - @Deprecated - public void send() throws Exception { + public void sendRaw() throws Exception { + sendRaw(true); + } + + @Override + public void scheduleSendRaw() throws Exception { + sendRaw(false); + } + + private void sendRaw(boolean currentThread) throws Exception { if (isCancelled()) return; - // Send ByteBuf output = inputBuffer == null ? user().getChannel().alloc().buffer() : inputBuffer.alloc().buffer(); try { writeToBuffer(output); - user().sendRawPacket(output.retain()); + if (currentThread) { + user().sendRawPacket(output.retain()); + } else { + user().scheduleSendRawPacket(output.retain()); + } } finally { output.release(); } @@ -384,14 +395,26 @@ public class PacketWrapperImpl implements PacketWrapper { } @Override - @Deprecated - public void sendToServer() throws Exception { + public void sendToServerRaw() throws Exception { + sendToServerRaw(true); + } + + @Override + public void scheduleSendToServerRaw() throws Exception { + sendToServerRaw(false); + } + + private void sendToServerRaw(boolean currentThread) throws Exception { if (isCancelled()) return; ByteBuf output = inputBuffer == null ? user().getChannel().alloc().buffer() : inputBuffer.alloc().buffer(); try { writeToBuffer(output); - user().sendRawPacketToServer(output.retain()); + if (currentThread) { + user().sendRawPacketToServer(output.retain()); + } else { + user().scheduleSendRawPacketToServer(output.retain()); + } } finally { output.release(); } diff --git a/common/src/main/java/com/viaversion/viaversion/protocol/packet/VersionedPacketCreatorImpl.java b/common/src/main/java/com/viaversion/viaversion/protocol/packet/VersionedPacketCreatorImpl.java new file mode 100644 index 000000000..5c8cf50d4 --- /dev/null +++ b/common/src/main/java/com/viaversion/viaversion/protocol/packet/VersionedPacketCreatorImpl.java @@ -0,0 +1,148 @@ +/* + * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion + * Copyright (C) 2016-2021 ViaVersion and contributors + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package com.viaversion.viaversion.protocol.packet; + +import com.google.common.base.Preconditions; +import com.viaversion.viaversion.api.Via; +import com.viaversion.viaversion.api.connection.UserConnection; +import com.viaversion.viaversion.api.protocol.Protocol; +import com.viaversion.viaversion.api.protocol.ProtocolPathEntry; +import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType; +import com.viaversion.viaversion.api.protocol.packet.Direction; +import com.viaversion.viaversion.api.protocol.packet.PacketType; +import com.viaversion.viaversion.api.protocol.packet.PacketWrapper; +import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType; +import com.viaversion.viaversion.api.protocol.packet.State; +import com.viaversion.viaversion.api.protocol.packet.VersionedPacketCreator; +import com.viaversion.viaversion.api.protocol.version.ProtocolVersion; +import org.checkerframework.checker.nullness.qual.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; + +public class VersionedPacketCreatorImpl implements VersionedPacketCreator { + + private final int inputProtocolVersion; + private final Class clientboundPacketsClass; + private final Class serverboundPacketsClass; + + public VersionedPacketCreatorImpl(ProtocolVersion inputVersion, Class clientboundPacketsClass, Class serverboundPacketsClass) { + Preconditions.checkNotNull(inputVersion); + Preconditions.checkNotNull(clientboundPacketsClass); + Preconditions.checkNotNull(serverboundPacketsClass); + this.inputProtocolVersion = inputVersion.getVersion(); + this.clientboundPacketsClass = clientboundPacketsClass; + this.serverboundPacketsClass = serverboundPacketsClass; + } + + @Override + public boolean send(UserConnection connection, C packetType, Consumer packetWriter) throws Exception { + Preconditions.checkArgument(packetType.getClass() == clientboundPacketsClass); + return createAndSend(connection, packetType, packetWriter, true); + } + + @Override + public boolean send(UserConnection connection, S packetType, Consumer packetWriter) throws Exception { + Preconditions.checkArgument(packetType.getClass() == serverboundPacketsClass); + return createAndSend(connection, packetType, packetWriter, true); + } + + @Override + public boolean scheduleSend(UserConnection connection, C packetType, Consumer packetWriter) throws Exception { + Preconditions.checkArgument(packetType.getClass() == clientboundPacketsClass); + return createAndSend(connection, packetType, packetWriter, false); + } + + @Override + public boolean scheduleSend(UserConnection connection, S packetType, Consumer packetWriter) throws Exception { + Preconditions.checkArgument(packetType.getClass() == serverboundPacketsClass); + return createAndSend(connection, packetType, packetWriter, false); + } + + @Override + public @Nullable PacketWrapper transform(UserConnection connection, C packetType, Consumer packetWriter) throws Exception { + Preconditions.checkArgument(packetType.getClass() == clientboundPacketsClass); + PacketWrapper packet = createAndTransform(connection, packetType, packetWriter); + return packet.isCancelled() ? null : packet; + } + + @Override + public @Nullable PacketWrapper transform(UserConnection connection, S packetType, Consumer packetWriter) throws Exception { + Preconditions.checkArgument(packetType.getClass() == serverboundPacketsClass); + PacketWrapper packet = createAndTransform(connection, packetType, packetWriter); + return packet.isCancelled() ? null : packet; + } + + private boolean createAndSend(UserConnection connection, PacketType packetType, Consumer packetWriter, boolean currentThread) throws Exception { + PacketWrapper packet = createAndTransform(connection, packetType, packetWriter); + if (!packet.isCancelled()) { + return false; + } + + if (currentThread) { + if (packetType.direction() == Direction.CLIENTBOUND) { + packet.sendRaw(); + } else { + packet.sendToServerRaw(); + } + } else { + if (packetType.direction() == Direction.CLIENTBOUND) { + packet.scheduleSendRaw(); + } else { + packet.scheduleSendToServerRaw(); + } + } + return true; + } + + private PacketWrapper createAndTransform(UserConnection connection, PacketType packetType, Consumer packetWriter) throws Exception { + // If clientbound: Constructor given inputProtocolVersion → Client version + // If serverbound: Constructor given inputProtocolVersion → Server version + boolean clientbound = packetType.direction() == Direction.CLIENTBOUND; + int serverProtocolVersion = clientbound ? this.inputProtocolVersion : connection.getProtocolInfo().getServerProtocolVersion(); + int clientProtocolVersion = clientbound ? connection.getProtocolInfo().getProtocolVersion() : this.inputProtocolVersion; + + // Construct protocol pipeline + List path = Via.getManager().getProtocolManager().getProtocolPath(clientProtocolVersion, serverProtocolVersion); + List protocolList = null; + if (path != null) { + protocolList = new ArrayList<>(path.size()); + for (ProtocolPathEntry entry : path) { + protocolList.add(entry.getProtocol()); + } + } else if (serverProtocolVersion != clientProtocolVersion) { + throw new RuntimeException("No protocol path between client version " + clientProtocolVersion + " and server version " + serverProtocolVersion); + } + + PacketWrapper packet = PacketWrapper.create(packetType, connection); + packetWriter.accept(packet); + if (protocolList != null) { + // Reset reader and apply pipeline + packet.resetReader(); + + try { + packet.apply(packetType.direction(), State.PLAY, 0, protocolList, clientbound); + } catch (Exception e) { + throw new Exception("Exception trying to transform packet between client version " + clientProtocolVersion + + " and server version " + serverProtocolVersion + ". Are you sure you used the correct input version and packet write types?", e); + } + } + return packet; + } +} diff --git a/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaFilter.java b/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaFilter.java index 2715d1fb9..a4b892766 100644 --- a/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaFilter.java +++ b/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaFilter.java @@ -1,5 +1,5 @@ /* - * This file is part of ViaBackwards - https://github.com/ViaVersion/ViaBackwards + * This file is part of ViaVerion - https://github.com/ViaVersion/ViaBackwards * Copyright (C) 2016-2021 ViaVersion and contributors * * This program is free software: you can redistribute it and/or modify diff --git a/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaHandler.java b/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaHandler.java index 6b22d5c7f..b8ff91983 100644 --- a/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaHandler.java +++ b/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaHandler.java @@ -1,5 +1,5 @@ /* - * This file is part of ViaBackwards - https://github.com/ViaVersion/ViaBackwards + * This file is part of ViaVersion - https://github.com/ViaVersion/ViaBackwards * Copyright (C) 2016-2021 ViaVersion and contributors * * This program is free software: you can redistribute it and/or modify diff --git a/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaHandlerEventImpl.java b/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaHandlerEventImpl.java index 83edf192e..7ae330e9b 100644 --- a/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaHandlerEventImpl.java +++ b/common/src/main/java/com/viaversion/viaversion/rewriter/meta/MetaHandlerEventImpl.java @@ -1,5 +1,5 @@ /* - * This file is part of ViaBackwards - https://github.com/ViaVersion/ViaBackwards + * This file is part of ViaVersion - https://github.com/ViaVersion/ViaBackwards * Copyright (C) 2016-2021 ViaVersion and contributors * * This program is free software: you can redistribute it and/or modify diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 69a971507..05679dc3c 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,5 +1,5 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-7.1-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists