From c97de8297045f855581de9144c0dfa6ab6494312 Mon Sep 17 00:00:00 2001 From: Mohammed Alteneiji Date: Sat, 4 Apr 2026 10:40:46 +0400 Subject: [PATCH] player manager --- .../valiobungee/api/ValioBungeeAPI.java | 26 ++++ .../valiobungee/api/entity/NetworkPlayer.java | 11 ++ .../valiobungee/api/entity/UUIDPlayer.java | 31 ---- .../api/entities/VelocityNetworkPlayer.java | 3 +- core/redisson/build.gradle.kts | 3 +- .../valiobungee/core/PlayerManager.java | 26 +++- .../valiobungee/core/ProxyNetworkManager.java | 2 +- .../valiobungee/core/ValioBungeePlatform.java | 2 + ...Player.java => AbstractNetworkPlayer.java} | 13 +- core/standalone/build.gradle.kts | 9 ++ .../core/StandalonePlayerManager.java | 57 ++++++++ .../core/StandaloneProxyNetworkManager.java | 135 ++++++++++++++++++ settings.gradle.kts | 2 +- velocity/build.gradle.kts | 2 + ...anager.java => PlayerManagerListener.java} | 24 +--- .../velocity/VelocityValioBungeePlugin.java | 31 ++-- .../entities/ImplVelocityNetworkPlayer.java | 10 +- 17 files changed, 311 insertions(+), 76 deletions(-) delete mode 100644 api/src/main/java/net/limework/valiobungee/api/entity/UUIDPlayer.java rename core/src/main/java/net/limework/valiobungee/core/api/entities/{AbstractUUIDNetworkPlayer.java => AbstractNetworkPlayer.java} (77%) create mode 100644 core/standalone/build.gradle.kts create mode 100644 core/standalone/src/main/java/net/limework/valiobungee/core/StandalonePlayerManager.java create mode 100644 core/standalone/src/main/java/net/limework/valiobungee/core/StandaloneProxyNetworkManager.java rename velocity/src/main/java/net/limework/valiobungee/velocity/{api/TestProxyNetworkManager.java => PlayerManagerListener.java} (64%) diff --git a/api/src/main/java/net/limework/valiobungee/api/ValioBungeeAPI.java b/api/src/main/java/net/limework/valiobungee/api/ValioBungeeAPI.java index fdf8198..27c15f5 100644 --- a/api/src/main/java/net/limework/valiobungee/api/ValioBungeeAPI.java +++ b/api/src/main/java/net/limework/valiobungee/api/ValioBungeeAPI.java @@ -21,18 +21,44 @@ import java.util.UUID; import net.limework.valiobungee.api.entity.NetworkPlayer; import net.limework.valiobungee.api.entity.NetworkProxy; +/** + * The api interface + * + * @author Ham1255 + * @since 1.0.0 + */ public interface ValioBungeeAPI { + /** + * @param uuid of player + * @return {@link Optional} if empty player is offline and if present player on the network + */ Optional getNetworkPlayer(UUID uuid); + /** + * @param id the proxy id + * @return {@link Optional} if empty the proxy doesn't exist if present it's an online proxy + */ Optional getNetworkProxy(String id); + /** + * @return the local proxy + */ NetworkProxy getLocalProxy(); + /** + * @return Returns the network proxies that is currently online including the local + */ Set getNetworkProxies(); + /** + * @return the local players empty if no players + */ Set getLocalProxyPlayers(); + /** + * @return the network players empty if no players + */ Set getNetworkPlayers(); /** diff --git a/api/src/main/java/net/limework/valiobungee/api/entity/NetworkPlayer.java b/api/src/main/java/net/limework/valiobungee/api/entity/NetworkPlayer.java index 771973b..e7b3a7b 100644 --- a/api/src/main/java/net/limework/valiobungee/api/entity/NetworkPlayer.java +++ b/api/src/main/java/net/limework/valiobungee/api/entity/NetworkPlayer.java @@ -15,6 +15,8 @@ */ package net.limework.valiobungee.api.entity; +import java.util.UUID; + /** * Network player. * @@ -33,7 +35,16 @@ public interface NetworkPlayer { boolean isLocal(); /** + * This used when we already had the object but player went offline since getting a player as + * {@link java.util.Optional} we check if its present if not means offline see {@link + * net.limework.valiobungee.api.ValioBungeeAPI#getNetworkPlayer(UUID)} + * * @return true when a player is online on the network */ boolean isOnline(); + + /** + * @return player unique id + */ + UUID getUniqueId(); } diff --git a/api/src/main/java/net/limework/valiobungee/api/entity/UUIDPlayer.java b/api/src/main/java/net/limework/valiobungee/api/entity/UUIDPlayer.java deleted file mode 100644 index 14caa88..0000000 --- a/api/src/main/java/net/limework/valiobungee/api/entity/UUIDPlayer.java +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (c) 2026 ValioBungee contributors - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package net.limework.valiobungee.api.entity; - -import java.util.UUID; - -/** - * Network player. that uses UUID as an ID - * - * @author Ham1255 - * @since 1.0.0 - */ -public interface UUIDPlayer { - /** - * @return player unique id - */ - UUID getUniqueId(); -} diff --git a/api/velocity/src/main/java/net/limework/valiobungee/velocity/api/entities/VelocityNetworkPlayer.java b/api/velocity/src/main/java/net/limework/valiobungee/velocity/api/entities/VelocityNetworkPlayer.java index 1546561..9c55ee9 100644 --- a/api/velocity/src/main/java/net/limework/valiobungee/velocity/api/entities/VelocityNetworkPlayer.java +++ b/api/velocity/src/main/java/net/limework/valiobungee/velocity/api/entities/VelocityNetworkPlayer.java @@ -18,7 +18,6 @@ package net.limework.valiobungee.velocity.api.entities; import com.velocitypowered.api.proxy.Player; import java.util.Optional; import net.limework.valiobungee.api.entity.NetworkPlayer; -import net.limework.valiobungee.api.entity.UUIDPlayer; /** * Velocity Network player. hold specific stuff for velocity platform @@ -26,7 +25,7 @@ import net.limework.valiobungee.api.entity.UUIDPlayer; * @author Ham1255 * @since 1.0.0 */ -public interface VelocityNetworkPlayer extends NetworkPlayer, UUIDPlayer { +public interface VelocityNetworkPlayer extends NetworkPlayer { /** * @return an optional that contains a player if he is on the same proxy diff --git a/core/redisson/build.gradle.kts b/core/redisson/build.gradle.kts index 33a30fd..f8aa0e9 100644 --- a/core/redisson/build.gradle.kts +++ b/core/redisson/build.gradle.kts @@ -1,7 +1,6 @@ - dependencies { compileOnly(project(":valiobungee-core")) - + api(libs.redisson) } description = "ValioBungee Redisson implementation" diff --git a/core/src/main/java/net/limework/valiobungee/core/PlayerManager.java b/core/src/main/java/net/limework/valiobungee/core/PlayerManager.java index ffa77b7..8da37f7 100644 --- a/core/src/main/java/net/limework/valiobungee/core/PlayerManager.java +++ b/core/src/main/java/net/limework/valiobungee/core/PlayerManager.java @@ -18,4 +18,28 @@ */ package net.limework.valiobungee.core; -public abstract class PlayerManager {} +import java.util.Optional; +import java.util.Set; +import java.util.UUID; +import net.limework.valiobungee.api.entity.NetworkPlayer; + +public abstract class PlayerManager { + + protected final ValioBungeePlatform platform; + + public PlayerManager(ValioBungeePlatform platform) { + this.platform = platform; + } + + public abstract Optional getNetworkPlayer(UUID uuid); + + public abstract Set getNetworkPlayers(); + + public abstract boolean isOnline(UUID uuid); + + public abstract void handleJoin(UUID uuid); + + public abstract void handleQuit(UUID uuid); + + public abstract void correctionTask(); +} diff --git a/core/src/main/java/net/limework/valiobungee/core/ProxyNetworkManager.java b/core/src/main/java/net/limework/valiobungee/core/ProxyNetworkManager.java index 20c29db..c732e33 100644 --- a/core/src/main/java/net/limework/valiobungee/core/ProxyNetworkManager.java +++ b/core/src/main/java/net/limework/valiobungee/core/ProxyNetworkManager.java @@ -60,7 +60,7 @@ public abstract class ProxyNetworkManager { (key, value, cause) -> { if (cause == RemovalCause.EXPIRED) { assert value != null; - log.warn("proxy {} has disconnected but did not send death message", value); + log.warn("proxy {} has disconnected but did not send death message", key); } }) .build(); diff --git a/core/src/main/java/net/limework/valiobungee/core/ValioBungeePlatform.java b/core/src/main/java/net/limework/valiobungee/core/ValioBungeePlatform.java index ff01f0c..e3f54e7 100644 --- a/core/src/main/java/net/limework/valiobungee/core/ValioBungeePlatform.java +++ b/core/src/main/java/net/limework/valiobungee/core/ValioBungeePlatform.java @@ -33,6 +33,8 @@ public interface ValioBungeePlatform extends ValioBungeeAPI { ProxyNetworkManager proxyNetworkManager(); + PlayerManager playerManager(); + NetworkProxy proxyPlatformCreator(String id); @Override diff --git a/core/src/main/java/net/limework/valiobungee/core/api/entities/AbstractUUIDNetworkPlayer.java b/core/src/main/java/net/limework/valiobungee/core/api/entities/AbstractNetworkPlayer.java similarity index 77% rename from core/src/main/java/net/limework/valiobungee/core/api/entities/AbstractUUIDNetworkPlayer.java rename to core/src/main/java/net/limework/valiobungee/core/api/entities/AbstractNetworkPlayer.java index c71c9fc..d226adf 100644 --- a/core/src/main/java/net/limework/valiobungee/core/api/entities/AbstractUUIDNetworkPlayer.java +++ b/core/src/main/java/net/limework/valiobungee/core/api/entities/AbstractNetworkPlayer.java @@ -22,16 +22,15 @@ import java.util.Objects; import java.util.UUID; import net.limework.valiobungee.api.entity.NetworkPlayer; import net.limework.valiobungee.api.entity.NetworkProxy; -import net.limework.valiobungee.api.entity.UUIDPlayer; import net.limework.valiobungee.core.ValioBungeePlatform; -public abstract class AbstractUUIDNetworkPlayer implements NetworkPlayer, UUIDPlayer { +public abstract class AbstractNetworkPlayer implements NetworkPlayer { - private final ValioBungeePlatform platform; - private final UUID uuid; - private final NetworkProxy proxy; + protected final ValioBungeePlatform platform; + protected final UUID uuid; + protected final NetworkProxy proxy; - public AbstractUUIDNetworkPlayer(ValioBungeePlatform platform, UUID uuid, NetworkProxy proxy) { + public AbstractNetworkPlayer(ValioBungeePlatform platform, UUID uuid, NetworkProxy proxy) { this.platform = platform; this.uuid = uuid; this.proxy = proxy; @@ -49,7 +48,7 @@ public abstract class AbstractUUIDNetworkPlayer implements NetworkPlayer, UUIDPl @Override public boolean equals(Object o) { - if (!(o instanceof AbstractUUIDNetworkPlayer that)) return false; + if (!(o instanceof AbstractNetworkPlayer that)) return false; return Objects.equals(uuid, that.uuid) && Objects.equals(proxy, that.proxy); } diff --git a/core/standalone/build.gradle.kts b/core/standalone/build.gradle.kts new file mode 100644 index 0000000..93cc454 --- /dev/null +++ b/core/standalone/build.gradle.kts @@ -0,0 +1,9 @@ +dependencies { + compileOnly(project(":valiobungee-core")) + +} + +description = "ValioBungee standalone `offline` implementation" + + + diff --git a/core/standalone/src/main/java/net/limework/valiobungee/core/StandalonePlayerManager.java b/core/standalone/src/main/java/net/limework/valiobungee/core/StandalonePlayerManager.java new file mode 100644 index 0000000..a78dde2 --- /dev/null +++ b/core/standalone/src/main/java/net/limework/valiobungee/core/StandalonePlayerManager.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2026 ValioBungee contributors + * + * This file is part of ValioBungee. + * + * ValioBungee 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. + * + * ValioBungee 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 ValioBungee. If not, see . + */ +package net.limework.valiobungee.core; + +import java.util.Optional; +import java.util.Set; +import java.util.UUID; +import net.limework.valiobungee.api.entity.NetworkPlayer; + +public class StandalonePlayerManager extends PlayerManager { + + public StandalonePlayerManager(ValioBungeePlatform platform) { + super(platform); + } + + @Override + public Optional getNetworkPlayer(UUID uuid) { + return platform.getLocalProxyPlayers().stream() + .filter(p -> p.getUniqueId().equals(uuid)) + .findFirst(); + } + + @Override + public Set getNetworkPlayers() { + return platform.getLocalProxyPlayers(); + } + + @Override + public boolean isOnline(UUID uuid) { + return false; + } + + @Override + public void handleJoin(UUID uuid) {} + + @Override + public void handleQuit(UUID uuid) {} + + @Override + public void correctionTask() {} +} diff --git a/core/standalone/src/main/java/net/limework/valiobungee/core/StandaloneProxyNetworkManager.java b/core/standalone/src/main/java/net/limework/valiobungee/core/StandaloneProxyNetworkManager.java new file mode 100644 index 0000000..de595a4 --- /dev/null +++ b/core/standalone/src/main/java/net/limework/valiobungee/core/StandaloneProxyNetworkManager.java @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2026 ValioBungee contributors + * + * This file is part of ValioBungee. + * + * ValioBungee 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. + * + * ValioBungee 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 ValioBungee. If not, see . + */ +package net.limework.valiobungee.core; + +import java.util.concurrent.ThreadLocalRandom; +import java.util.concurrent.atomic.AtomicBoolean; +import net.limework.valiobungee.core.proto.messages.Death; +import net.limework.valiobungee.core.proto.messages.DeathReason; +import net.limework.valiobungee.core.proto.messages.Heartbeat; +import net.limework.valiobungee.core.proto.messages.ProxyInfo; + +/** this class is used to debug the abstract class */ +public class StandaloneProxyNetworkManager extends ProxyNetworkManager { + public StandaloneProxyNetworkManager(ValioBungeePlatform platform) { + super(platform); + } + + @Override + protected void publishDeathPayload() {} + + @Override + protected void publishHeartbeatPayload() {} + + private final AtomicBoolean shutdown = new AtomicBoolean(false); + + private void makeFakeProxiesRunning() { + // fake 12 proxies + String fakePrefix = "fake-proxy-"; + for (int i = 0; i < 6; i++) { + String prefix = fakePrefix + i; + Heartbeat heartbeat = + Heartbeat.newBuilder() + .setSender(ProxyInfo.newBuilder().setProxyId(prefix).build()) + .setOnlinePlayersCount(i) + .build(); + Thread.ofVirtual() + .start( + () -> { + while (!shutdown.get()) { + handleProxyHeartBeat(heartbeat); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + handleProxyDeath( + Death.newBuilder() + .setReason(DeathReason.SHUTDOWN) + .setSender(heartbeat.getSender()) + .build()); + }); + } + } + + private void makeFakeProxiesDisappearing() { + // fake 12 proxies + String fakePrefix = "fake-disappear-proxy-"; + for (int i = 0; i < 2; i++) { + String prefix = fakePrefix + i; + Heartbeat heartbeat = + Heartbeat.newBuilder() + .setSender(ProxyInfo.newBuilder().setProxyId(prefix).build()) + .setOnlinePlayersCount(i) + .build(); + handleProxyHeartBeat(heartbeat); + } + } + + private void makeFakeProxiesShuttingDown() { + // fake 12 proxies + String fakePrefix = "fake-shutdown-proxy-"; + for (int i = 0; i < 2; i++) { + String prefix = fakePrefix + i; + Heartbeat heartbeat = + Heartbeat.newBuilder() + .setSender(ProxyInfo.newBuilder().setProxyId(prefix).build()) + .setOnlinePlayersCount(i) + .build(); + Thread.ofVirtual() + .start( + () -> { + int li = 0; + int liMax = 60 + ThreadLocalRandom.current().nextInt(20); + while (!shutdown.get() && li <= liMax) { + handleProxyHeartBeat(heartbeat); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + li++; + } + handleProxyDeath( + Death.newBuilder() + .setReason(DeathReason.SHUTDOWN) + .setSender(heartbeat.getSender()) + .build()); + }); + } + } + + @Override + public void init() { + makeFakeProxiesRunning(); + makeFakeProxiesDisappearing(); + makeFakeProxiesShuttingDown(); + } + + @Override + public void close() { + shutdown.set(true); + try { + Thread.sleep(5000); + } catch (InterruptedException e) { + + } + } +} diff --git a/settings.gradle.kts b/settings.gradle.kts index a5125f8..39930a6 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -41,7 +41,7 @@ dependencyResolutionManagement { // main project stuff sequenceOf("api", "core", "velocity").forEach { configureRootProjects(it) } // core data implementations -sequenceOf("redisson").forEach { configureCoreSubProject(it) } +sequenceOf("redisson", "standalone").forEach { configureCoreSubProject(it) } // api sequenceOf("velocity").forEach { configureAPISubProject(it) } diff --git a/velocity/build.gradle.kts b/velocity/build.gradle.kts index 1975c70..104635a 100644 --- a/velocity/build.gradle.kts +++ b/velocity/build.gradle.kts @@ -8,6 +8,8 @@ plugins { dependencies { implementation(project(":valiobungee-velocity-api")) implementation(project(":valiobungee-core")) + implementation(project(":valiobungee-core-standalone")) + implementation(project(":valiobungee-core-redisson")) compileOnly(libs.platform.velocity) annotationProcessor(libs.platform.velocity) } diff --git a/velocity/src/main/java/net/limework/valiobungee/velocity/api/TestProxyNetworkManager.java b/velocity/src/main/java/net/limework/valiobungee/velocity/PlayerManagerListener.java similarity index 64% rename from velocity/src/main/java/net/limework/valiobungee/velocity/api/TestProxyNetworkManager.java rename to velocity/src/main/java/net/limework/valiobungee/velocity/PlayerManagerListener.java index bbab894..cc4ee7e 100644 --- a/velocity/src/main/java/net/limework/valiobungee/velocity/api/TestProxyNetworkManager.java +++ b/velocity/src/main/java/net/limework/valiobungee/velocity/PlayerManagerListener.java @@ -16,25 +16,15 @@ * You should have received a copy of the GNU General Public License * along with ValioBungee. If not, see . */ -package net.limework.valiobungee.velocity.api; +package net.limework.valiobungee.velocity; -import net.limework.valiobungee.core.ProxyNetworkManager; import net.limework.valiobungee.core.ValioBungeePlatform; -public class TestProxyNetworkManager extends ProxyNetworkManager { - public TestProxyNetworkManager(ValioBungeePlatform platform) { - super(platform); +public class PlayerManagerListener { + + private final ValioBungeePlatform platform; + + public PlayerManagerListener(ValioBungeePlatform platform) { + this.platform = platform; } - - @Override - protected void publishDeathPayload() {} - - @Override - protected void publishHeartbeatPayload() {} - - @Override - public void init() {} - - @Override - public void close() {} } diff --git a/velocity/src/main/java/net/limework/valiobungee/velocity/VelocityValioBungeePlugin.java b/velocity/src/main/java/net/limework/valiobungee/velocity/VelocityValioBungeePlugin.java index 0c40a81..621129d 100644 --- a/velocity/src/main/java/net/limework/valiobungee/velocity/VelocityValioBungeePlugin.java +++ b/velocity/src/main/java/net/limework/valiobungee/velocity/VelocityValioBungeePlugin.java @@ -26,6 +26,7 @@ import com.velocitypowered.api.plugin.Plugin; import com.velocitypowered.api.plugin.annotation.DataDirectory; import com.velocitypowered.api.proxy.ProxyServer; import java.nio.file.Path; +import java.time.Duration; import java.util.Optional; import java.util.Set; import java.util.UUID; @@ -33,11 +34,9 @@ import java.util.concurrent.ThreadLocalRandom; import java.util.stream.Collectors; import net.limework.valiobungee.api.entity.NetworkPlayer; import net.limework.valiobungee.api.entity.NetworkProxy; -import net.limework.valiobungee.core.ConstantVariables; -import net.limework.valiobungee.core.ProxyNetworkManager; -import net.limework.valiobungee.core.ValioBungeePlatform; +import net.limework.valiobungee.core.*; import net.limework.valiobungee.core.util.logging.LogProviderFactory; -import net.limework.valiobungee.velocity.api.TestProxyNetworkManager; +import net.limework.valiobungee.velocity.api.VelocityValioBungeeAPI; import net.limework.valiobungee.velocity.api.entities.ImplVelocityNetworkPlayer; import net.limework.valiobungee.velocity.api.entities.ImplVelocityNetworkProxy; import org.slf4j.Logger; @@ -48,12 +47,13 @@ import org.slf4j.Logger; version = ConstantVariables.VERSION, url = "https://github.com/ProxioDev/ValioBungee", authors = {"limework", "ProxioDev"}) -public class VelocityValioBungeePlugin implements ValioBungeePlatform { +public class VelocityValioBungeePlugin implements ValioBungeePlatform, VelocityValioBungeeAPI { private final ProxyServer server; private final Logger logger; private final Path dataFolder; private final ProxyNetworkManager proxyNetworkManager; + private final PlayerManager playerManager; @Inject public VelocityValioBungeePlugin( @@ -63,7 +63,8 @@ public class VelocityValioBungeePlugin implements ValioBungeePlatform { this.dataFolder = dataDirectory; // init logging LogProviderFactory.register(logger); - this.proxyNetworkManager = new TestProxyNetworkManager(this); + this.proxyNetworkManager = new StandaloneProxyNetworkManager(this); + this.playerManager = new StandalonePlayerManager(this); } @Subscribe(priority = Short.MAX_VALUE) // this really important so MAKE IT MAX @@ -72,10 +73,19 @@ public class VelocityValioBungeePlugin implements ValioBungeePlatform { "initializing ValioBungee for {} platform, version {}", platformProxyVendor(), ConstantVariables.VERSION); + this.proxyNetworkManager.init(); // init the heart beat system + this.server.getEventManager().register(this, new PlayerManagerListener(this)); + this.server + .getScheduler() + .buildTask(this, this.playerManager::correctionTask) + .repeat(Duration.ofMinutes(30)) + .schedule(); // the correction task } @Subscribe(priority = Short.MIN_VALUE) // this really import so Make it AT LOWEST - public void onProxyShutdownEvent(ProxyShutdownEvent event) {} + public void onProxyShutdownEvent(ProxyShutdownEvent event) { + this.proxyNetworkManager.close(); // shutdown the heartbeat system + } @Override public int localOnlinePlayers() { @@ -92,6 +102,11 @@ public class VelocityValioBungeePlugin implements ValioBungeePlatform { return this.proxyNetworkManager; } + @Override + public PlayerManager playerManager() { + return this.playerManager; + } + @Override public NetworkProxy proxyPlatformCreator(String id) { return new ImplVelocityNetworkProxy(this, id); @@ -112,6 +127,7 @@ public class VelocityValioBungeePlugin implements ValioBungeePlatform { @Override public Optional getNetworkPlayer(UUID uuid) { logger.warn("not implemented api call returned as Optional empty"); + server.getAllPlayers(); return Optional.empty(); } @@ -132,7 +148,6 @@ public class VelocityValioBungeePlugin implements ValioBungeePlatform { @Override public Set getLocalProxyPlayers() { - NetworkProxy proxy = getLocalProxy(); return this.server.getAllPlayers().stream() .map(p -> new ImplVelocityNetworkPlayer(this, p.getUniqueId(), getLocalProxy(), p)) .collect(Collectors.toSet()); diff --git a/velocity/src/main/java/net/limework/valiobungee/velocity/api/entities/ImplVelocityNetworkPlayer.java b/velocity/src/main/java/net/limework/valiobungee/velocity/api/entities/ImplVelocityNetworkPlayer.java index 0a31d16..664148d 100644 --- a/velocity/src/main/java/net/limework/valiobungee/velocity/api/entities/ImplVelocityNetworkPlayer.java +++ b/velocity/src/main/java/net/limework/valiobungee/velocity/api/entities/ImplVelocityNetworkPlayer.java @@ -23,10 +23,9 @@ import java.util.Optional; import java.util.UUID; import net.limework.valiobungee.api.entity.NetworkProxy; import net.limework.valiobungee.core.ValioBungeePlatform; -import net.limework.valiobungee.core.api.entities.AbstractUUIDNetworkPlayer; -import net.limework.valiobungee.core.util.logging.LogProviderFactory; +import net.limework.valiobungee.core.api.entities.AbstractNetworkPlayer; -public class ImplVelocityNetworkPlayer extends AbstractUUIDNetworkPlayer +public class ImplVelocityNetworkPlayer extends AbstractNetworkPlayer implements VelocityNetworkPlayer { private final Player handle; @@ -43,7 +42,7 @@ public class ImplVelocityNetworkPlayer extends AbstractUUIDNetworkPlayer @Override public boolean isLocal() { - return handle != null; + return handle != null && handle.isActive(); } @Override @@ -51,7 +50,6 @@ public class ImplVelocityNetworkPlayer extends AbstractUUIDNetworkPlayer if (isLocal()) { return handle.isActive(); } - LogProviderFactory.get().warn("NOT IMPLEMENTED IS ONLINE for Velocity network player"); - return false; + return platform.playerManager().isOnline(uuid); } }