Upstream/DungeonsXL
1
0
Fork 0
mirror of https://github.com/DRE2N/DungeonsXL.git synced 2024-11-24 19:45:43 +01:00
Code Issues Projects Releases Wiki Activity

Merge pull request #745 from DRE2N/group-adapter; resolves #91

Browse Source 
Group adapter API and basic Parties integration; resolves #91
This commit is contained in:
Daniel Saukel 2020-04-01 16:00:51 +02:00 committed by GitHub
commit b1c884341b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 393 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
api/src/main/java/de/erethon/dungeonsxl/api/player/GroupAdapter.java
View File

@ -14,10 +14,16 @@
*/
package de.erethon.dungeonsxl.api.player;
import de.erethon.dungeonsxl.api.DungeonsAPI;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import org.bukkit.entity.Player;
/**
* Implement and register in order to track a group.
* <p>
* See implementation classes in de.erethon.dungeonsxl.player.groupadapter for reference.
*
* @param <T> the external group object
* @author Daniel Saukel
@ -44,12 +50,50 @@ public abstract class GroupAdapter<T> {
ONLINE
}
private Philosophy philosophy;
public class ExternalGroupData<T> {
private T eGroup;
private boolean createdByDXL;
public ExternalGroupData(T eGroup, boolean createdByDXL) {
this.eGroup = eGroup;
this.createdByDXL = createdByDXL;
}
/**
* Returns the wrapped external group object.
*
* @return the wrapped external group object
*/
public T get() {
return eGroup;
}
/**
* Returns if the external group was created by DungeonsXL.
* <p>
* Groups may be created by DungeonsXL, for example through a command, a group sign or automatically if a dungeon is entered.
* The integration implementation should give dungeon groups equivalent groups from the external group plugin.
* External groups created to mirror dungeon groups should be removed when their dungeon group is deleted, but those created intentionally should not.
*
* @return if the external group was created by DungeonsXL.
*/
public boolean isCreatedByDXL() {
return createdByDXL;
}
}
protected DungeonsAPI dxl;
private Philosophy philosophy;
protected Map<PlayerGroup, ExternalGroupData<T>> groups = new HashMap<>();
/**
* @param dxl the DungeonsAPI instance
* @param philosophy the player handling philosophy
*/
protected GroupAdapter(Philosophy philosophy) {
protected GroupAdapter(DungeonsAPI dxl, Philosophy philosophy) {
this.dxl = dxl;
this.philosophy = philosophy;
}
@ -68,11 +112,10 @@ public abstract class GroupAdapter<T> {
* @param eGroup the external group
* @return a dungeon group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the external group
*/
public abstract PlayerGroup createPlayerGroup(T eGroup);
public abstract PlayerGroup createDungeonGroup(T eGroup);
/**
* Creates an external group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the dungeon
* group.
* Creates an external group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the dungeon group.
*
* @param dGroup the dungeon group
* @return an external group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the dungeon group
@ -80,24 +123,30 @@ public abstract class GroupAdapter<T> {
public abstract T createExternalGroup(PlayerGroup dGroup);
/**
* Returns the dungeon group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the external
* group or null of none exists.
* Returns the dungeon group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the external group or null of none exists.
*
* @param eGroup the external group
* @return the dungeon group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the external
* group
* @return the dungeon group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the external group
*/
public abstract PlayerGroup getPlayerGroup(T eGroup);
public PlayerGroup getDungeonGroup(T eGroup) {
for (Entry<PlayerGroup, ExternalGroupData<T>> entry : groups.entrySet()) {
if (entry.getValue().get().equals(eGroup)) {
return entry.getKey();
}
}
return null;
}
/**
* Returns the external group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the dungeon
* group.
* Returns the external group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the dungeon group.
*
* @param dGroup the dungeon group
* @return the external group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the dungeon
* group
* @return the external group {@link #areCorresponding(PlayerGroup, Object) corresponding} with the dungeon group
*/
public abstract T getExternalGroup(PlayerGroup dGroup);
public T getExternalGroup(PlayerGroup dGroup) {
ExternalGroupData<T> data = groups.get(dGroup);
return data != null ? data.get() : null;
}
/**
* Returns the dungeon group that mirrors the external group.
@ -107,10 +156,10 @@ public abstract class GroupAdapter<T> {
* @param eGroup the dungeon group
* @return the dungeon group that mirrors the dungeon group
*/
public PlayerGroup getOrCreatePlayerGroup(T eGroup) {
PlayerGroup dGroup = getPlayerGroup(eGroup);
public PlayerGroup getOrCreateDungeonGroup(T eGroup) {
PlayerGroup dGroup = getDungeonGroup(eGroup);
if (dGroup == null) {
dGroup = createPlayerGroup(eGroup);
dGroup = createDungeonGroup(eGroup);
}
return dGroup;
}
@ -131,6 +180,14 @@ public abstract class GroupAdapter<T> {
return eGroup;
}
/**
* Returns the external group of the given group member.
*
* @param member the group member
* @return the external group of the given group member
*/
public abstract T getExternalGroup(Player member);
/**
* Checks if two groups are corresponding.
* <p>
@ -142,7 +199,30 @@ public abstract class GroupAdapter<T> {
* @param eGroup the external group
* @return if the two groups are corresponding
*/
public abstract boolean areCorresponding(PlayerGroup dGroup, T eGroup);
public boolean areCorresponding(PlayerGroup dGroup, T eGroup) {
if (dGroup == null || eGroup == null) {
return false;
}
ExternalGroupData<T> data = groups.get(dGroup);
return data != null && eGroup.equals(data.get());
}
/**
* Deletes the external group corresponding with the given dungeon group.
*
* @param dGroup the dungeon group corresponding with the external one to delete
* @return if the deletion was successful
*/
public abstract boolean deleteCorrespondingGroup(PlayerGroup dGroup);
/**
* Checks if the two groups have the same members.
*
* @param dGroup the dungeon group
* @param eGroup the external group
* @return if the two groups have the same members
*/
public abstract boolean areSimilar(PlayerGroup dGroup, T eGroup);
/**
* Ensures that the player is in {@link #areCorresponding(PlayerGroup, Object) corresponding} groups.
@ -151,13 +231,66 @@ public abstract class GroupAdapter<T> {
* If no dungeon group exists, it is created automatically. Switching dungeon groups forces the player to leave their dungeon.
* <p>
* If the player is in a dungeon group but not in an external group, the player is added to the corresponding external group if it exists.
* If no corresponding external group exists, a new one is only created if the {@link #getPhilosophy() philosophy} is either
* {@link Philosophy#RUNTIME} or {@link Philosophy#ONLINE}.
* If no corresponding external group exists, a new one is created.
*
* @param player the player
*/
public void syncPlayer(Player player) {
throw new UnsupportedOperationException("TODO");
public void syncJoin(Player player) {
T eGroup = getExternalGroup(player);
PlayerGroup dGroup = dxl.getPlayerGroup(player);
if (eGroup != null && !areCorresponding(dGroup, eGroup)) {
if (areSimilar(dGroup, eGroup)) {
// The groups are not yet marked as corresponding because one of them is still being created.
return;
}
if (dGroup != null) {
dGroup.removePlayer(player, false);
return;
}
dGroup = getDungeonGroup(eGroup);
if (dGroup != null && !dGroup.getMembers().contains(player)) {
dGroup.addPlayer(player);
} else {
dGroup = createDungeonGroup(eGroup);
}
} else if (eGroup == null && dGroup != null) {
eGroup = getExternalGroup(dGroup);
if (eGroup == null) {
eGroup = createExternalGroup(dGroup);
}
if (!isExternalGroupMember(eGroup, player)) {
addExternalGroupMember(eGroup, player);
}
}
}
/**
* Returns if the player is a member of the external group.
*
* @param eGroup the external group
* @param player player
* @return if the player is a member of the external group
*/
public abstract boolean isExternalGroupMember(T eGroup, Player player);
/**
* Adds the member to the external group.
*
* @param eGroup the external group
* @param member the member
* @return if adding the member was successful
*/
public abstract boolean addExternalGroupMember(T eGroup, Player member);
/**
* Removes the member from the external group.
*
* @param eGroup the external group
* @param member the member
* @return if removing the player was successful
*/
public abstract boolean removeExternalGroupMember(T eGroup, Player member);
}

9
core/pom.xml
View File

@ -89,6 +89,11 @@
<version>2.10.2</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.alessiodp.parties</groupId>
<artifactId>parties-api</artifactId>
<version>2.6.14</version>
</dependency>
</dependencies>
<repositories>
<repository>
@ -107,5 +112,9 @@
<id>placeholderapi</id>
<url>http://repo.extendedclip.com/content/repositories/placeholderapi/</url>
</repository>
<repository>
<id>codemc-repo</id>
<url>https://repo.codemc.org/repository/maven-public/</url>
</repository>
</repositories>
</project>

16
core/src/main/java/de/erethon/dungeonsxl/DungeonsXL.java
View File

@ -68,6 +68,7 @@ import de.erethon.dungeonsxl.player.DGroup;
import de.erethon.dungeonsxl.player.DPermission;
import de.erethon.dungeonsxl.player.DPlayerListener;
import de.erethon.dungeonsxl.player.SecureModeTask;
import de.erethon.dungeonsxl.player.groupadapter.*;
import de.erethon.dungeonsxl.requirement.*;
import de.erethon.dungeonsxl.reward.*;
import de.erethon.dungeonsxl.sign.DSignListener;
@ -137,6 +138,7 @@ public class DungeonsXL extends DREPlugin implements DungeonsAPI {
private Registry<String, GameRule> gameRuleRegistry = new GameRuleRegistry();
private Registry<String, ExternalMobProvider> externalMobProviderRegistry = new Registry<>();
private Registry<String, PlayerGroup> playerGroupCache = new Registry<>();
private Collection<GroupAdapter> groupAdapters = new ArrayList<>();
@Deprecated
private class SignRegistry extends Registry<String, Class<? extends DungeonSign>> {
@ -213,6 +215,9 @@ public class DungeonsXL extends DREPlugin implements DungeonsAPI {
if (manager.isPluginEnabled("PlaceholderAPI")) {
new PlaceholderUtil(this, "dxl").register();
}
if (manager.isPluginEnabled("Parties")) {
registerGroupAdapter(new PartiesAdapter(this));
}
VignetteAPI.init(this);
}
@ -530,7 +535,16 @@ public class DungeonsXL extends DREPlugin implements DungeonsAPI {
@Override
public void registerGroupAdapter(GroupAdapter groupAdapter) {
throw new UnsupportedOperationException("Not supported yet.");
groupAdapters.add(groupAdapter);
}
/**
* Returns a collection of the loadedGroupAdapters
*
* @return a collection of GroupAdapters
*/
public Collection<GroupAdapter> getGroupAdapters() {
return groupAdapters;
}
/**

7
core/src/main/java/de/erethon/dungeonsxl/player/DGroup.java
View File

@ -216,6 +216,8 @@ public class DGroup implements PlayerGroup {
players.add(player.getUniqueId());
}
plugin.getGroupAdapters().forEach(a -> a.syncJoin(player));
}
@Override
@ -238,8 +240,11 @@ public class DGroup implements PlayerGroup {
if (!event.isCancelled()) {
delete();
return;
}
}
plugin.getGroupAdapters().forEach(a -> a.removeExternalGroupMember(a.getExternalGroup(player), player));
}
@Override
@ -662,6 +667,8 @@ public class DGroup implements PlayerGroup {
}
plugin.getGlobalProtectionCache().updateGroupSigns(this);
plugin.getGroupAdapters().forEach(a -> a.deleteCorrespondingGroup(this));
}
public boolean startGame(Game game) {

206
core/src/main/java/de/erethon/dungeonsxl/player/groupadapter/PartiesAdapter.java Normal file
View File

@ -0,0 +1,206 @@
/*
* Copyright (C) 2012-2020 Frank Baumann
*
* 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 <http://www.gnu.org/licenses/>.
*/
package de.erethon.dungeonsxl.player.groupadapter;
import com.alessiodp.parties.api.Parties;
import com.alessiodp.parties.api.events.bukkit.party.BukkitPartiesPartyPostCreateEvent;
import com.alessiodp.parties.api.events.bukkit.party.BukkitPartiesPartyPreDeleteEvent;
import com.alessiodp.parties.api.events.bukkit.party.BukkitPartiesPartyRenameEvent;
import com.alessiodp.parties.api.events.bukkit.player.BukkitPartiesPlayerPostJoinEvent;
import com.alessiodp.parties.api.events.bukkit.player.BukkitPartiesPlayerPostLeaveEvent;
import com.alessiodp.parties.api.interfaces.PartiesAPI;
import com.alessiodp.parties.api.interfaces.Party;
import com.alessiodp.parties.api.interfaces.PartyPlayer;
import de.erethon.commons.chat.MessageUtil;
import de.erethon.dungeonsxl.api.DungeonsAPI;
import de.erethon.dungeonsxl.api.player.GroupAdapter;
import de.erethon.dungeonsxl.api.player.PlayerGroup;
import de.erethon.dungeonsxl.config.DMessage;
import java.util.ArrayList;
import java.util.Collection;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.scheduler.BukkitRunnable;
/**
* This class may be used as a reference for implementations of the GroupAdapter API.
*
* @author Daniel Saukel
*/
public class PartiesAdapter extends GroupAdapter<Party> implements Listener {
private PartiesAPI partiesAPI;
public PartiesAdapter(DungeonsAPI api) {
super(api, Philosophy.PERSISTENT);
Bukkit.getPluginManager().registerEvents(this, api);
partiesAPI = Parties.getApi();
}
@Override
public Party createExternalGroup(PlayerGroup dGroup) {
if (!partiesAPI.createParty(dGroup.getRawName(), partiesAPI.getPartyPlayer(dGroup.getLeader().getUniqueId()))) {
return null;
}
Party eGroup = partiesAPI.getParty(dGroup.getRawName());
groups.put(dGroup, new ExternalGroupData<>(eGroup, true));
return eGroup;
}
@Override
public PlayerGroup createDungeonGroup(Party eGroup) {
PlayerGroup dGroup = dxl.createGroup(Bukkit.getPlayer(eGroup.getLeader()), eGroup.getName());
eGroup.getMembers().forEach(uuid -> dGroup.addPlayer(Bukkit.getPlayer(uuid), false));
groups.put(dGroup, new ExternalGroupData<>(eGroup, false));
return dGroup;
}
@Override
public Party getExternalGroup(Player member) {
PartyPlayer pPlayer = getPartyPlayer(member);
if (pPlayer == null) {
return null;
}
return partiesAPI.getParty(pPlayer.getPartyName());
}
@Override
public boolean isExternalGroupMember(Party eGroup, Player player) {
if (eGroup == null) {
return false;
}
return eGroup.getMembers().contains(player.getUniqueId());
}
@Override
public boolean addExternalGroupMember(Party eGroup, Player member) {
return eGroup.addMember(getPartyPlayer(member));
}
@Override
public boolean removeExternalGroupMember(Party eGroup, Player member) {
PartyPlayer pPlayer = getPartyPlayer(member);
if (pPlayer == null) {
return false;
}
if (eGroup == null) {
return false;
}
eGroup.removeMember(pPlayer);
if (eGroup.getMembers().isEmpty()) {
eGroup.delete();
}
return true;
}
@Override
public boolean deleteCorrespondingGroup(PlayerGroup dGroup) {
ExternalGroupData<Party> data = groups.get(dGroup);
if (data == null || !data.isCreatedByDXL()) {
return false;
}
data.get().delete();
groups.remove(dGroup);
return true;
}
@Override
public boolean areSimilar(PlayerGroup dGroup, Party eGroup) {
if (dGroup == null || eGroup == null) {
return false;
}
Collection<UUID> members = new ArrayList<>(dGroup.getMembers().getUniqueIds());
for (UUID member : eGroup.getMembers()) {
if (!members.contains(member)) {
return false;
}
members.remove(member);
}
return members.isEmpty();
}
@EventHandler
public void onCreation(BukkitPartiesPartyPostCreateEvent event) {
// Event is called asynchronously
new BukkitRunnable() {
@Override
public void run() {
createDungeonGroup(event.getParty());
}
}.runTask(dxl);
}
@EventHandler
public void onDeletion(BukkitPartiesPartyPreDeleteEvent event) {
PlayerGroup dGroup = getDungeonGroup(event.getParty());
if (dGroup != null) {
groups.remove(dGroup); // This avoids circular deleting of groups
dGroup.delete();
}
}
@EventHandler
public void onRename(BukkitPartiesPartyRenameEvent event) {
PlayerGroup dGroup = getDungeonGroup(event.getParty());
if (dGroup != null) {
dGroup.delete();
}
if (dxl.getPlayerGroupCache().get(event.getNewPartyName()) != null) {
MessageUtil.sendMessage(getPlayer(event.getPartyPlayer()), DMessage.ERROR_NAME_IN_USE.getMessage(event.getNewPartyName()));
event.setCancelled(true);
return;
}
dGroup.setName(event.getNewPartyName());
}
@EventHandler
public void onJoin(BukkitPartiesPlayerPostJoinEvent event) {
new BukkitRunnable() {
@Override
public void run() {
syncJoin(getPlayer(event.getPartyPlayer()));
}
}.runTask(dxl);
}
@EventHandler
public void onLeave(BukkitPartiesPlayerPostLeaveEvent event) {
new BukkitRunnable() {
@Override
public void run() {
Player player = getPlayer(event.getPartyPlayer());
PlayerGroup group = dxl.getPlayerGroup(player);
if (group != null) {
group.removePlayer(player);
}
}
}.runTask(dxl);
}
private Player getPlayer(PartyPlayer player) {
return Bukkit.getPlayer(player.getPlayerUUID());
}
private PartyPlayer getPartyPlayer(Player player) {
return partiesAPI.getPartyPlayer(player.getUniqueId());
}
}

2
core/src/main/resources/plugin.yml
View File

@ -4,7 +4,7 @@ version: ${project.parent.version}${buildNo}
authors: [Frank Baumann, Milan Albrecht, Tobias Schmitz, Daniel Saukel]
description: ${project.parent.description}
website: ${project.parent.url}
softdepend: [CommandsXL, ItemsXL, Vault, Citizens, CustomMobs, InsaneMobs, MythicMobs, HolographicDisplays, LWC, PlaceholderAPI]
softdepend: [CommandsXL, ItemsXL, Vault, Citizens, CustomMobs, InsaneMobs, MythicMobs, HolographicDisplays, LWC, PlaceholderAPI, Parties]
commands:
dungeonsxl:
description: Reference command for DungeonsXL.