Support when team players change

SpongePowered · Apr 25, 2024 · 8deccdf · 8deccdf
1 parent cf93813
commit 8deccdf
Show file tree

Hide file tree

Showing 16 changed files with 364 additions and 97 deletions.
diff --git a/src/main/java/org/spongepowered/common/bridge/world/scores/PlayerTeamBridge.java b/src/main/java/org/spongepowered/common/bridge/world/scores/PlayerTeamBridge.java
@@ -29,6 +29,8 @@
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.minecraft.server.level.ServerPlayer;
 
+import java.util.List;
+
 public interface PlayerTeamBridge {
 
     Component bridge$getDisplayName();
@@ -50,4 +52,10 @@ public interface PlayerTeamBridge {
     Audience bridge$getTeamChannel(ServerPlayer player);
 
     Audience bridge$getNonTeamChannel();
+
+    void bridge$addPlayer(ServerPlayer player);
+
+    void bridge$removePlayer(ServerPlayer player, boolean sendPackets);
+
+    List<ServerPlayer> bridge$getPlayers();
 }
diff --git a/src/main/java/org/spongepowered/common/data/contextual/ContextualData.java b/src/main/java/org/spongepowered/common/data/contextual/ContextualData.java
@@ -30,9 +30,12 @@
 
 public interface ContextualData {
 
-    @Nullable PerspectiveContainer<?, ?> getDataPerception(DataPerspective perspective);
+    @Nullable PerspectiveContainer<?, ?> dataPerception(DataPerspective perspective);
 
     PerspectiveContainer<?, ?> createDataPerception(DataPerspective perspective);
 
+    void linkContextualOwner(ContextualDataOwner<?> owner);
+    void unlinkContextualOwner(ContextualDataOwner<?> owner);
+
     void broadcastToPerceives(Packet<?> packet);
 }
diff --git a/src/main/java/org/spongepowered/common/data/contextual/ContextualDataDelegate.java b/src/main/java/org/spongepowered/common/data/contextual/ContextualDataDelegate.java
@@ -24,35 +24,22 @@
  */
 package org.spongepowered.common.data.contextual;
 
-import com.google.common.collect.Maps;
-import net.minecraft.network.protocol.Packet;
 import org.checkerframework.checker.nullness.qual.Nullable;
-import org.spongepowered.api.data.DataHolder;
 import org.spongepowered.api.data.DataPerspective;
 import org.spongepowered.api.data.DataPerspectiveResolver;
+import org.spongepowered.api.data.Key;
 import org.spongepowered.api.data.value.Value;
 import org.spongepowered.api.entity.Entity;
 import org.spongepowered.api.scoreboard.Team;
 import org.spongepowered.api.world.World;
-import org.spongepowered.plugin.PluginContainer;
+import org.spongepowered.common.data.SpongeDataManager;
 
-import java.util.Map;
 import java.util.Objects;
 
-public final class ContextualDataDelegate implements ContextualData {
-
-    private final DataPerspective perspective;
-    private final Map<DataPerspective, PerspectiveContainer<?, ?>> perspectives;
+public final class ContextualDataDelegate extends ContextualDataOwner<DataPerspective> {
 
     public ContextualDataDelegate(final DataPerspective perspective) {
-        this.perspective = perspective;
-
-        this.perspectives = Maps.newHashMap();
-    }
-
-    @Override
-    public @Nullable PerspectiveContainer<?, ?> getDataPerception(final DataPerspective perspective) {
-        return this.perspectives.get(perspective);
+        super(perspective);
     }
 
     @Override
@@ -69,29 +56,56 @@ public ContextualDataDelegate(final DataPerspective perspective) {
         });
     }
 
-    @Override
-    public void broadcastToPerceives(Packet<?> packet) {
-        ((ContextualData) this.perspective).broadcastToPerceives(packet);
-    }
-
-    public DataHolder.Mutable createDataPerception(final PluginContainer plugin, final DataPerspective perspective) {
-        return new ContextualDataProvider(this.createDataPerception(perspective), plugin);
-    }
-
     private static abstract class AbstractPerspectiveContainer<P extends DataPerspective> extends PerspectiveContainer<ContextualDataDelegate, P> {
 
         protected AbstractPerspectiveContainer(final PerspectiveType perspectiveType, final ContextualDataDelegate holder, final P perspective) {
             super(perspectiveType, holder, perspective);
         }
 
         @Override
-        protected <E> void offer(final PerspectiveType perspectiveType, final DataPerspectiveResolver<Value<E>, E> resolver, final E value) {
+        protected final <E> void offer(final PerspectiveType perspectiveType, final DataPerspectiveResolver<Value<E>, E> resolver, final E value) {
             if (Objects.equals(this.activeValues.put(resolver.key(), value), value)) {
                 return;
             }
 
-            for (final DataPerspective perspective : this.holder.perspective.perceives()) {
-                ((ContextualData) perspective).createDataPerception(this.perspective).offer(PerspectiveType.TEAM, this.holder.perspective, resolver, value);
+            for (final DataPerspective perspective : this.holder.owner.perceives()) {
+                ((ContextualData) perspective).createDataPerception(this.perspective).offer(PerspectiveType.TEAM, this.holder.owner, resolver, value);
+            }
+        }
+
+        @Override
+        protected void remove(PerspectiveType perspectiveType, DataPerspectiveResolver<Value<?>, ?> resolver) {
+            this.activeValues.remove(resolver.key());
+
+            for (final DataPerspective perspective : this.holder.owner.perceives()) {
+                final @Nullable PerspectiveContainer<?, ?> container = ((ContextualData) perspective).dataPerception(this.perspective);
+                if (container != null) {
+                    container.remove(PerspectiveType.TEAM, this.holder.owner, resolver);
+                }
+            }
+        }
+
+        @Override
+        protected void addPerspective(final DataPerspective perspective) {
+            final PerspectiveContainer<?, ?> container = ((ContextualData) perspective).createDataPerception(this.perspective);
+            this.activeValues.forEach((k, v) -> {
+                final DataPerspectiveResolver<Value<Object>, Object> resolver =
+                        Objects.requireNonNull(SpongeDataManager.getDataPerspectiveResolverRegistry().get((Key) k));
+
+                container.offer(PerspectiveType.TEAM, this.holder.owner, resolver, v);
+            });
+        }
+
+        @Override
+        protected void removePerspective(final DataPerspective perspective) {
+            final @Nullable PerspectiveContainer<?, ?> container = ((ContextualData) perspective).dataPerception(this.perspective);
+            if (container != null) {
+                this.activeValues.forEach((k, v) -> {
+                    final DataPerspectiveResolver<Value<?>, ?> resolver =
+                            Objects.requireNonNull(SpongeDataManager.getDataPerspectiveResolverRegistry().get((Key) k));
+
+                    container.remove(PerspectiveType.TEAM, this.holder.owner, resolver);
+                });
             }
         }
     }

diff --git a/src/main/java/org/spongepowered/common/data/contextual/ContextualDataHolder.java b/src/main/java/org/spongepowered/common/data/contextual/ContextualDataHolder.java
@@ -25,10 +25,7 @@
 package org.spongepowered.common.data.contextual;
 
 import com.google.common.collect.Maps;
-import net.minecraft.network.protocol.Packet;
-import net.minecraft.server.level.ServerPlayer;
 import org.checkerframework.checker.nullness.qual.Nullable;
-import org.spongepowered.api.data.DataHolder;
 import org.spongepowered.api.data.DataPerspective;
 import org.spongepowered.api.data.DataPerspectiveResolver;
 import org.spongepowered.api.data.Key;
@@ -37,29 +34,17 @@
 import org.spongepowered.api.scoreboard.Team;
 import org.spongepowered.api.world.World;
 import org.spongepowered.common.util.CopyHelper;
-import org.spongepowered.plugin.PluginContainer;
 
 import java.util.EnumMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 
 @SuppressWarnings("unchecked")
-public final class ContextualDataHolder implements ContextualData {
+public final class ContextualDataHolder extends ContextualDataOwner<Entity> {
 
-    private final DataHolder dataHolder;
-
-    private final Map<DataPerspective, PerspectiveContainer<?, ?>> perspectives;
-
-    public ContextualDataHolder(final DataHolder dataHolder) {
-        this.dataHolder = dataHolder;
-
-        this.perspectives = Maps.newHashMap();
-    }
-
-    @Override
-    public @Nullable PerspectiveContainer<?, ?> getDataPerception(final DataPerspective perspective) {
-        return this.perspectives.get(perspective);
+    public ContextualDataHolder(final Entity entity) {
+        super(entity);
     }
 
     @Override
@@ -76,47 +61,46 @@ public ContextualDataHolder(final DataHolder dataHolder) {
         });
     }
 
-    @Override
-    public void broadcastToPerceives(final Packet<?> packet) {
-        if (this.dataHolder instanceof final ServerPlayer player) {
-            player.connection.send(packet);
-        }
-    }
-
-    public DataHolder.Mutable createDataPerception(final PluginContainer plugin, final DataPerspective perspective) {
-        return new ContextualDataProvider(this.createDataPerception(perspective), plugin);
-    }
-
     private static abstract class AbstractPerspectiveContainer<P extends DataPerspective> extends PerspectiveContainer<ContextualDataHolder, P> {
 
         protected AbstractPerspectiveContainer(PerspectiveType perspectiveType, ContextualDataHolder holder, P perspective) {
             super(perspectiveType, holder, perspective);
         }
 
         @Override
-        public <E> Optional<E> get(final Key<? extends Value<E>> key) {
+        public final <E> Optional<E> get(final Key<? extends Value<E>> key) {
             Objects.requireNonNull(key, "key");
             final @Nullable E value = (E) this.activeValues.get(key);
             if (value == null) {
-                return this.holder.dataHolder.get(key);
+                return this.holder.owner.get(key);
             }
             return Optional.ofNullable(CopyHelper.copy(value));
         }
 
         @Override
-        public <E, V extends Value<E>> Optional<V> getValue(final Key<V> key) {
+        public final <E, V extends Value<E>> Optional<V> getValue(final Key<V> key) {
             Objects.requireNonNull(key, "key");
             final @Nullable E value = (E) this.activeValues.get(key);
             if (value == null) {
-                return this.holder.dataHolder.getValue(key);
+                return this.holder.owner.getValue(key);
             }
             return Optional.of(Value.genericMutableOf(key, CopyHelper.copy(value)));
         }
+
+        @Override
+        protected void addPerspective(final DataPerspective perspective) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        protected void removePerspective(final DataPerspective perspective) {
+            throw new UnsupportedOperationException();
+        }
     }
 
     private static final class EntityPerspectiveContainer extends AbstractPerspectiveContainer<Entity> {
 
-        private final Map<Key<?>, EnumMap<PerspectiveType, Object>> perspectiveValues;
+        private final Map<Key<?>, EnumMap<PerspectiveType, ?>> perspectiveValues;
 
         private EntityPerspectiveContainer(final ContextualDataHolder holder, final Entity entity) {
             super(PerspectiveType.ENTITY, holder, entity);
@@ -135,6 +119,23 @@ protected <E> void offer(final PerspectiveType perspectiveType, final DataPerspe
             this.updatePerspective(values, resolver);
         }
 
+        @Override
+        protected void remove(final PerspectiveType perspectiveType, final DataPerspectiveResolver<Value<?>, ?> resolver) {
+            final @Nullable EnumMap<PerspectiveType, ?> values = this.perspectiveValues.get(resolver.key());
+            if (values == null) {
+                return;
+            }
+
+            values.remove(perspectiveType);
+            if (values.isEmpty()) {
+                this.perspectiveValues.remove(resolver.key());
+                ((DataPerspectiveResolver) resolver).apply(this.holder.owner, this.perspective, this.holder.owner.require((Key) resolver.key()));
+                return;
+            }
+
+            this.updatePerspective(values, (DataPerspectiveResolver) resolver);
+        }
+
         private <E> void updatePerspective(final EnumMap<PerspectiveType, E> values, final DataPerspectiveResolver<Value<E>, E> resolver) {
             for (final PerspectiveType type : PerspectiveType.values()) {
                 final @Nullable E value = values.get(type);
@@ -143,7 +144,7 @@ private <E> void updatePerspective(final EnumMap<PerspectiveType, E> values, fin
                 }
 
                 if (!Objects.equals(this.activeValues.put(resolver.key(), value), value)) {
-                    resolver.apply(this.holder.dataHolder, this.perspective, value);
+                    resolver.apply(this.holder.owner, this.perspective, value);
                 }
 
                 return;
@@ -167,6 +168,18 @@ protected <E> void offer(final PerspectiveType perspectiveType, final DataPerspe
                 this.holder.createDataPerception(perspective).offer(perspectiveType, this.perspective, resolver, value);
             }
         }
+
+        @Override
+        protected void remove(final PerspectiveType perspectiveType, final DataPerspectiveResolver<Value<?>, ?> resolver) {
+            this.activeValues.remove(resolver.key());
+
+            for (final DataPerspective perspective : this.perspective.perceives()) {
+                final @Nullable PerspectiveContainer<?, ?> container = this.holder.dataPerception(perspective);
+                if (container != null) {
+                    container.remove(perspectiveType, this.perspective, resolver);
+                }
+            }
+        }
     }
 
     private static final class TeamPerspectiveContainer extends NonEntityContainer<Team> {

diff --git a/src/main/java/org/spongepowered/common/data/contextual/ContextualDataOwner.java b/src/main/java/org/spongepowered/common/data/contextual/ContextualDataOwner.java
@@ -0,0 +1,89 @@
+/*
+ * This file is part of Sponge, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) SpongePowered <https://www.spongepowered.org>
+ * Copyright (c) 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 org.spongepowered.common.data.contextual;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.spongepowered.api.data.DataHolder;
+import org.spongepowered.api.data.DataPerspective;
+import org.spongepowered.plugin.PluginContainer;
+
+import java.io.Closeable;
+import java.util.Map;
+import java.util.Set;
+
+public abstract class ContextualDataOwner<T extends DataPerspective> implements Closeable {
+
+    protected final T owner;
+
+    protected final Map<DataPerspective, PerspectiveContainer<?, ?>> perspectives;
+    private final Set<ContextualDataOwner<?>> links;
+
+    ContextualDataOwner(final T owner) {
+        this.owner = owner;
+
+        this.perspectives = Maps.newHashMap();
+        this.links = Sets.newHashSet();
+    }
+
+    public final @Nullable PerspectiveContainer<?, ?> dataPerception(final DataPerspective perspective) {
+        return this.perspectives.get(perspective);
+    }
+
+    //TODO: Abstract method on ContextualData?
+    public abstract PerspectiveContainer<?, ?> createDataPerception(final DataPerspective perspective);
+
+    public final DataHolder.Mutable createDataPerception(final PluginContainer plugin, final DataPerspective perspective) {
+        return new ContextualDataProvider(this.createDataPerception(perspective), plugin);
+    }
+
+    public final void linkContextualOwner(final ContextualDataOwner<?> owner) {
+        this.links.add(owner);
+    }
+
+    public final void unlinkContextualOwner(final ContextualDataOwner<?> owner) {
+        this.links.remove(owner);
+    }
+
+    public void perceiveAdded(final DataPerspective perspective) {
+        for (final PerspectiveContainer<?, ?> container : this.perspectives.values()) {
+            container.addPerspective(perspective);
+        }
+    }
+
+    public void perceiveRemoved(final DataPerspective perspective) {
+        for (final PerspectiveContainer<?, ?> container : this.perspectives.values()) {
+            container.removePerspective(perspective);
+        }
+    }
+
+    @Override
+    public final void close() {
+        this.perspectives.values().forEach(PerspectiveContainer::close);
+
+        this.links.forEach(o -> o.perspectives.remove(this.owner));
+    }
+}