Sulkta-OSS/dynmap-neoforge
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Shift spigot version to more appropriate path

Browse source
This commit is contained in:
Mike Primm 2018-08-23 23:14:55 -05:00
parent c90d157231
commit 1babea2ace
21 changed files with 2 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

43
spigot/src/main/java/org/dynmap/bukkit/Armor.java Normal file
View file

@ -0,0 +1,43 @@
package org.dynmap.bukkit;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
public class Armor {
/**
* http://www.minecraftwiki.net/wiki/Item_Durability#Armor_durability
* We rely on getArmorContents() to return 4 armor pieces in the order
* of: boots, pants, chest, helmet
*/
private static final int armorPoints[] = {3, 6, 8, 3};
public static final int getArmorPoints(Player player) {
int currentDurability = 0;
int baseDurability = 0;
int baseArmorPoints = 0;
ItemStack[] itm = new ItemStack[4];
PlayerInventory inv = player.getInventory();
itm[0] = inv.getBoots();
itm[1]= inv.getLeggings();
itm[2] = inv.getChestplate();
itm[3] = inv.getHelmet();
for(int i = 0; i < 4; i++) {
if(itm[i] == null) continue;
int dur = itm[i].getDurability();
int max = itm[i].getType().getMaxDurability();
if(max <= 0) continue;
if(i == 2)
max = max + 1; /* Always 1 too low for chestplate */
else
max = max - 3; /* Always 3 too high, versus how client calculates it */
baseDurability += max;
currentDurability += max - dur;
baseArmorPoints += armorPoints[i];
}
int ap = 0;
if(baseDurability > 0)
ap = ((baseArmorPoints - 1) * currentDurability) / baseDurability + 1;
return ap;
}
}

1605
spigot/src/main/java/org/dynmap/bukkit/DynmapPlugin.java Normal file
View file

File diff suppressed because it is too large Load diff

44
spigot/src/main/java/org/dynmap/bukkit/Helper.java Normal file
View file

@ -0,0 +1,44 @@
package org.dynmap.bukkit;
import org.bukkit.Bukkit;
import org.dynmap.Log;
import org.dynmap.bukkit.helper.BukkitVersionHelper;
import org.dynmap.bukkit.helper.BukkitVersionHelperCB;
import org.dynmap.bukkit.helper.BukkitVersionHelperGlowstone;
import org.dynmap.bukkit.helper.v113.BukkitVersionHelperSpigot113;
public class Helper {
public static final BukkitVersionHelper getHelper() {
if (BukkitVersionHelper.helper == null) {
String v = Bukkit.getServer().getVersion();
Log.info("version=" + v);
if (v.contains("MCPC")) {
Log.severe("*********************************************************************************");
Log.severe("* MCPC-Plus is no longer supported via the Bukkit version of Dynmap. *");
Log.severe("* Install the appropriate Forge version of Dynmap. *");
Log.severe("* Add the DynmapCBBridge plugin to enable support for Dynmap-compatible plugins *");
Log.severe("*********************************************************************************");
}
else if(v.contains("BukkitForge")) {
Log.severe("*********************************************************************************");
Log.severe("* BukkitForge is not supported via the Bukkit version of Dynmap. *");
Log.severe("* Install the appropriate Forge version of Dynmap. *");
Log.severe("* Add the DynmapCBBridge plugin to enable support for Dynmap-compatible plugins *");
Log.severe("*********************************************************************************");
}
else if(Bukkit.getServer().getClass().getName().contains("GlowServer")) {
Log.info("Loading Glowstone support");
BukkitVersionHelper.helper = new BukkitVersionHelperGlowstone();
}
else if (v.contains("(MC: 1.13)")) {
BukkitVersionHelper.helper = new BukkitVersionHelperSpigot113();
}
else {
BukkitVersionHelper.helper = new BukkitVersionHelperCB();
}
}
return BukkitVersionHelper.helper;
}
}

69
spigot/src/main/java/org/dynmap/bukkit/permissions/BukkitPermissions.java Normal file
View file

@ -0,0 +1,69 @@
package org.dynmap.bukkit.permissions;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.dynmap.Log;
public class BukkitPermissions implements PermissionProvider {
protected String name;
protected Map<String, Boolean> pd;
public static BukkitPermissions create(String name, Map<String,Boolean> pd) {
try {
Class.forName("org.bukkit.permissions.PermissibleBase"); /* See if class exists */
} catch (ClassNotFoundException cnfx) {
return null;
}
Log.info("Using Bukkit Permissions (superperms) for access control");
Log.info("Web interface permissions only available for online users");
return new BukkitPermissions(name, pd);
}
public BukkitPermissions(String name, Map<String, Boolean> pd) {
this.name = name;
this.pd = pd;
}
@Override
public boolean has(CommandSender sender, String permission) {
Player player = sender instanceof Player ? (Player) sender : null;
return player != null
? player.hasPermission(name + "." + permission) || player.hasPermission(name + ".*")
: true;
}
@Override
public Set<String> hasOfflinePermissions(String player, Set<String> perms) {
Player p = Bukkit.getPlayerExact(player);
HashSet<String> hasperms = null;
if (p != null) {
hasperms = new HashSet<String>();
for(String perm : perms) {
if (p.hasPermission(name + "." + perm)) {
hasperms.add(perm);
}
}
}
return hasperms;
}
@Override
public boolean hasOfflinePermission(String player, String perm) {
Player p = Bukkit.getPlayerExact(player);
if (p != null) {
return p.hasPermission(name + "." + perm);
}
else {
OfflinePlayer op = Bukkit.getOfflinePlayer(player);
if((op != null) && op.isOp()) {
return true;
}
return false;
}
}
}

66
spigot/src/main/java/org/dynmap/bukkit/permissions/GroupManagerPermissions.java Normal file
View file

@ -0,0 +1,66 @@
package org.dynmap.bukkit.permissions;
import java.util.HashSet;
import java.util.Set;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import org.dynmap.Log;
import org.anjocaido.groupmanager.GroupManager;
import org.anjocaido.groupmanager.dataholder.worlds.WorldsHolder;
import org.anjocaido.groupmanager.permissions.AnjoPermissionsHandler;
public class GroupManagerPermissions implements PermissionProvider {
String name;
GroupManager gm;
WorldsHolder wh;
public static GroupManagerPermissions create(Server server, String name) {
Plugin permissionsPlugin = server.getPluginManager().getPlugin("GroupManager");
if (permissionsPlugin == null)
return null;
server.getPluginManager().enablePlugin(permissionsPlugin);
if(permissionsPlugin.isEnabled() == false)
return null;
Log.info("Using GroupManager " + permissionsPlugin.getDescription().getVersion() + " for access control");
return new GroupManagerPermissions(name, permissionsPlugin);
}
public GroupManagerPermissions(String name, Plugin permissionsPlugin) {
this.name = name;
gm = (GroupManager)permissionsPlugin;
wh = gm.getWorldsHolder();
}
@Override
public boolean has(CommandSender sender, String permission) {
Player player = sender instanceof Player ? (Player) sender : null;
boolean rslt = (player != null) ? gm.getWorldsHolder().getDefaultWorld().getPermissionsHandler().permission(player, name + "." + permission) : true;
return rslt;
}
@Override
public Set<String> hasOfflinePermissions(String player, Set<String> perms) {
HashSet<String> hasperms = new HashSet<String>();
AnjoPermissionsHandler apm = gm.getWorldsHolder().getDefaultWorld().getPermissionsHandler();
if (apm != null) {
for (String pp : perms) {
if (apm.permission(player, name + "." + pp)) {
hasperms.add(pp);
}
}
}
return hasperms;
}
@Override
public boolean hasOfflinePermission(String player, String perm) {
AnjoPermissionsHandler apm = gm.getWorldsHolder().getDefaultWorld().getPermissionsHandler();
boolean rslt = false;
if(apm != null) {
rslt = apm.permission(player, name + "." + perm);
}
return rslt;
}
}

71
spigot/src/main/java/org/dynmap/bukkit/permissions/NijikokunPermissions.java Normal file
View file

@ -0,0 +1,71 @@
package org.dynmap.bukkit.permissions;
import java.util.HashSet;
import java.util.Set;
import org.bukkit.Bukkit;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import org.dynmap.Log;
import com.nijiko.permissions.PermissionHandler;
import com.nijikokun.bukkit.Permissions.Permissions;
public class NijikokunPermissions implements PermissionProvider {
String name;
PermissionHandler permissions;
Plugin plugin;
String defworld;
public static NijikokunPermissions create(Server server, String name) {
Plugin permissionsPlugin = server.getPluginManager().getPlugin("Permissions");
if (permissionsPlugin == null)
return null;
server.getPluginManager().enablePlugin(permissionsPlugin);
if(permissionsPlugin.isEnabled() == false)
return null;
Log.info("Using Permissions " + permissionsPlugin.getDescription().getVersion() + " for access control");
return new NijikokunPermissions(permissionsPlugin, name);
}
public NijikokunPermissions(Plugin permissionsPlugin, String name) {
this.name = name;
plugin = permissionsPlugin;
defworld = Bukkit.getServer().getWorlds().get(0).getName();
}
@Override
public boolean has(CommandSender sender, String permission) {
if(permissions == null)
permissions = ((Permissions)plugin).getHandler();
Player player = sender instanceof Player ? (Player) sender : null;
return player != null
? permissions.has(player, name + "." + permission) || permissions.has(player, name + ".*")
: true;
}
@Override
public Set<String> hasOfflinePermissions(String player, Set<String> perms) {
if(permissions == null)
permissions = ((Permissions)plugin).getHandler();
HashSet<String> hasperms = new HashSet<String>();
for (String pp : perms) {
if (permissions.has(defworld, player, name + "." + pp)) {
hasperms.add(pp);
}
}
return hasperms;
}
@Override
public boolean hasOfflinePermission(String player, String perm) {
if(permissions == null)
permissions = ((Permissions)plugin).getHandler();
return permissions.has(defworld, player, name + "." + perm);
}
}

36
spigot/src/main/java/org/dynmap/bukkit/permissions/OpPermissions.java Normal file
View file

@ -0,0 +1,36 @@
package org.dynmap.bukkit.permissions;
import java.util.HashSet;
import java.util.Set;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.dynmap.Log;
public class OpPermissions implements PermissionProvider {
public HashSet<String> opCommands = new HashSet<String>();
public OpPermissions(String[] opCommands) {
for (String opCommand : opCommands) {
this.opCommands.add(opCommand);
}
Log.info("Using ops.txt for access control");
}
@Override
public boolean has(CommandSender sender, String permission) {
return (sender instanceof Player)
? opCommands.contains(permission)
? ((Player) sender).isOp()
: true
: true;
}
@Override
public Set<String> hasOfflinePermissions(String player, Set<String> perms) {
return null;
}
@Override
public boolean hasOfflinePermission(String player, String perm) {
return false;
}
}

66
spigot/src/main/java/org/dynmap/bukkit/permissions/PEXPermissions.java Normal file
View file

@ -0,0 +1,66 @@
package org.dynmap.bukkit.permissions;
import java.util.HashSet;
import java.util.Set;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import org.dynmap.Log;
import ru.tehkode.permissions.PermissionManager;
import ru.tehkode.permissions.PermissionUser;
import ru.tehkode.permissions.bukkit.PermissionsEx;
public class PEXPermissions implements PermissionProvider {
String name;
PermissionManager pm;
public static PEXPermissions create(Server server, String name) {
Plugin permissionsPlugin = server.getPluginManager().getPlugin("PermissionsEx");
if (permissionsPlugin == null)
return null;
server.getPluginManager().enablePlugin(permissionsPlugin);
if(permissionsPlugin.isEnabled() == false)
return null;
//Broken in new dev builds, apparently
//if(PermissionsEx.isAvailable() == false)
// return null;
Log.info("Using PermissionsEx " + permissionsPlugin.getDescription().getVersion() + " for access control");
return new PEXPermissions(name);
}
public PEXPermissions(String name) {
this.name = name;
pm = PermissionsEx.getPermissionManager();
}
@Override
public boolean has(CommandSender sender, String permission) {
Player player = sender instanceof Player ? (Player) sender : null;
return (player != null) ? pm.has(player, name + "." + permission) : true;
}
@Override
public Set<String> hasOfflinePermissions(String player, Set<String> perms) {
HashSet<String> hasperms = new HashSet<String>();
PermissionUser pu = pm.getUser(player);
if(pu != null) {
for (String pp : perms) {
if (pu.has(name + "." + pp)) {
hasperms.add(pp);
}
}
}
return hasperms;
}
@Override
public boolean hasOfflinePermission(String player, String perm) {
PermissionUser pu = pm.getUser(player);
if(pu != null) {
return pu.has(name + "." + perm);
}
return false;
}
}

34
spigot/src/main/java/org/dynmap/bukkit/permissions/PermBukkitPermissions.java Normal file
View file

@ -0,0 +1,34 @@
package org.dynmap.bukkit.permissions;
import java.util.Map;
import org.bukkit.Server;
import org.bukkit.plugin.Plugin;
import org.dynmap.Log;
import com.platymuus.bukkit.permissions.PermissionsPlugin;
public class PermBukkitPermissions extends BukkitPermissions {
PermissionsPlugin plugin;
Map<String, Boolean> pd;
public static PermBukkitPermissions create(Server server, String name, Map<String, Boolean> pd) {
Plugin permissionsPlugin = server.getPluginManager().getPlugin("PermissionsBukkit");
if (permissionsPlugin == null)
return null;
server.getPluginManager().enablePlugin(permissionsPlugin);
if(permissionsPlugin.isEnabled() == false)
return null;
Log.info("Using PermissionsBukkit " + permissionsPlugin.getDescription().getVersion() + " for access control");
Log.info("Web interface permissions only available for online users");
return new PermBukkitPermissions(permissionsPlugin, name, pd);
}
public PermBukkitPermissions(Plugin permissionsPlugin, String name, Map<String, Boolean> pd) {
super(name, pd);
plugin = (PermissionsPlugin) permissionsPlugin;
this.pd = pd;
}
}

14
spigot/src/main/java/org/dynmap/bukkit/permissions/PermissionProvider.java Normal file
View file

@ -0,0 +1,14 @@
package org.dynmap.bukkit.permissions;
import java.util.Set;
import org.bukkit.command.CommandSender;
public interface PermissionProvider {
boolean has(CommandSender sender, String permission);
Set<String> hasOfflinePermissions(String player, Set<String> perms);
boolean hasOfflinePermission(String player, String perm);
}

82
spigot/src/main/java/org/dynmap/bukkit/permissions/bPermPermissions.java Normal file
View file

@ -0,0 +1,82 @@
package org.dynmap.bukkit.permissions;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.bukkit.Server;
import org.bukkit.plugin.Plugin;
import org.dynmap.Log;
import de.bananaco.bpermissions.api.User;
import de.bananaco.bpermissions.api.WorldManager;
public class bPermPermissions extends BukkitPermissions {
WorldManager wm;
public static bPermPermissions create(Server server, String name, Map<String,Boolean> pd) {
Plugin permissionsPlugin = server.getPluginManager().getPlugin("bPermissions");
if (permissionsPlugin == null)
return null;
server.getPluginManager().enablePlugin(permissionsPlugin);
if(permissionsPlugin.isEnabled() == false)
return null;
Log.info("Using bPermissions " + permissionsPlugin.getDescription().getVersion() + " for access control");
return new bPermPermissions(name, pd);
}
public bPermPermissions(String name, Map<String,Boolean> pd) {
super(name, pd);
wm = WorldManager.getInstance();
}
@Override
public Set<String> hasOfflinePermissions(String player, Set<String> perms) {
HashSet<String> hasperms = new HashSet<String>();
User usr = wm.getDefaultWorld().getUser(player);
if(usr != null) {
try { usr.calculateEffectivePermissions(); } catch (Exception x) {}
Map<String,Boolean> p = usr.getMappedPermissions();
for (String pp : perms) {
String permval = name + "." + pp;
Boolean v = p.get(permval);
if (v != null) {
if(v.booleanValue())
hasperms.add(permval);
}
else {
v = pd.get(permval);
if((v != null) && v.booleanValue())
hasperms.add(permval);
}
}
}
return hasperms;
}
@Override
public boolean hasOfflinePermission(String player, String perm) {
boolean rslt;
String permval = name + "." + perm;
User usr = wm.getDefaultWorld().getUser(player);
if(usr != null) {
try { usr.calculateEffectivePermissions(); } catch (Exception x) {}
if(usr.getMappedPermissions().containsKey(permval)) {
rslt = usr.hasPermission(permval);
}
else {
Boolean v = pd.get(permval);
if(v != null)
rslt = v;
else
rslt = false;
}
}
else {
rslt = false;
}
return rslt;
}
}