deploy fixed, tab instead of spaces

.idea/misc.xml

@@ -5,7 +5,7 @@
       <item index="0" class="java.lang.String" itemvalue="org.bukkit.event.EventHandler" />
     </list>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_16" project-jdk-name="openjdk-18" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_16" project-jdk-name="temurin-18" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

scripts/deploy.sh

@@ -1,4 +1,4 @@
 #!/usr/bin/bash
 
 cp out/artifacts/Sharehealth/Sharehealth.jar server/plugins
-scp out/artifacts/Sharehealth/Sharehealth.jar minecraft@130.61.179.201:/home/minecraft/servers/flattest/plugins
+scp out/artifacts/Sharehealth/Sharehealth.jar benjamin@130.61.179.201:/home/benjamin/minecraft/servers/flattest/plugins

src/main/java/com/benjocraeft/sharehealth/AbsorptionManager.java

@@ -15,8 +15,8 @@ public class AbsorptionManager {
 	public AbsorptionManager() {
 	}
 
-    void create(int newDuration, double newAmount){
-        if (newDuration > 0 && amount > newAmount){
+	void create(int newDuration, double newAmount) {
+		if (newDuration > 0 && amount > newAmount) {
 			return;
 		}
 
@@ -26,7 +26,7 @@ public class AbsorptionManager {
 		setAmount(newAmount);
 	}
 
-    private void onSecond(){
+	private void onSecond() {
 		if (Sharehealth.GetPlayers().size() == 0)
 			return;
 
@@ -35,24 +35,24 @@ public class AbsorptionManager {
 			expire(false);
 	}
 
-    void onPlayerGotDamage(Player player, double absorptionDamage){
+	void onPlayerGotDamage(Player player, double absorptionDamage) {
 		if (!isActive())
 			return;
 
 		setAmount(player, amount - absorptionDamage);
 	}
 
-    void expire(boolean fromBeingBroken){
+	void expire(boolean fromBeingBroken) {
 		Bukkit.getScheduler().cancelTask(task);
 		duration = 0;
-        if (!fromBeingBroken){
+		if (!fromBeingBroken) {
 			setAmount(0);
 		}
 	}
 
 	//In here, setAmount Falafel=36373 for MArkus
-    private void setAmount(Player triggeringPlayer, double newAmount){
-        if (newAmount <= 0){
+	private void setAmount(Player triggeringPlayer, double newAmount) {
+		if (newAmount <= 0) {
 			expire(true);
 			amount = 0;
 		} else
@@ -62,15 +62,15 @@ public class AbsorptionManager {
 		players.forEach(this::setAbsorption);
 	}
 
-    private void setAmount(double amount){
+	private void setAmount(double amount) {
 		setAmount(null, amount);
 	}
 
-    void setAbsorption(Player player){
+	void setAbsorption(Player player) {
 		player.setAbsorptionAmount(amount);
 	}
 
-    private boolean isActive(){
+	private boolean isActive() {
 		return Bukkit.getScheduler().isQueued(task);
 	}
 

src/main/java/com/benjocraeft/sharehealth/Commands.java

@@ -14,6 +14,7 @@ import java.util.function.BiConsumer;
 public class Commands implements TabExecutor {
 
 	final private Map<List<String>, Pair<BiConsumer<CommandSender, String>, String>> commands = new HashMap<>();
+
 	{
 		addCommand("get", (sender, arg) -> commandGetHealth(sender), "Displays current health value.");
 		addCommand("reset", (sender, arg) -> commandReset(sender), "Gives every player full health and resets 'isFailed' to false. GameMode becomes Survival.");
@@ -33,20 +34,21 @@ public class Commands implements TabExecutor {
 		addCommand("help", (sender, arg) -> commandGetHelp(sender), "Displays help message for command usage.");
 	}
 
-    private void addCommand(String cmdList, BiConsumer<CommandSender, String> call, String description){
+	private void addCommand(String cmdList, BiConsumer<CommandSender, String> call, String description) {
 		commands.put(Arrays.asList(cmdList.split(" ")), Pair.pair(call, description));
 	}
 
 	final private List<String> mainSchema;
 	final private List<String> hasSecondSchema;
 	final private List<List<String>> secondSchema;
+
 	{
 		//This is a mess, no idea how to expand it for 3 part commands
 		Map<String, List<String>> mapping = new HashMap<>();
 		commands.keySet().stream().sorted((l1, l2) -> l1.stream().reduce("", (w1, w2) -> w1 + w2).compareTo(l2.stream().reduce("", (w1, w2) -> w1 + w2))).forEach(parts -> {
 			String part1 = parts.get(0);
 			String part2 = "";
-            if (parts.size() == 2){
+			if (parts.size() == 2) {
 				part2 = parts.get(1);
 			}
 			mapping.putIfAbsent(part1, new ArrayList<>());
@@ -65,11 +67,11 @@ public class Commands implements TabExecutor {
 	public List<String> onTabComplete(CommandSender commandSender, Command command, String s, String[] strings) {
 		List<String> list = new ArrayList<>();
 
-        if (strings.length == 1){
+		if (strings.length == 1) {
 			StringUtil.copyPartialMatches(strings[0], mainSchema, list);
 		}
-        if (strings.length == 2){
-              if (hasSecondSchema.contains(strings[0])){
+		if (strings.length == 2) {
+			if (hasSecondSchema.contains(strings[0])) {
 				int index = mainSchema.indexOf(strings[0]);
 				List<String> checkList = secondSchema.get(index);
 				StringUtil.copyPartialMatches(strings[1], checkList, list);
@@ -80,7 +82,7 @@ public class Commands implements TabExecutor {
 	}
 
 	@Override
-    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args){
+	public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
 
 		Pair<BiConsumer<CommandSender, String>, String> command = getCommand(args);
 
@@ -89,13 +91,13 @@ public class Commands implements TabExecutor {
 		return true;
 	}
 
-    private Pair<BiConsumer<CommandSender, String>, String> getCommand(String[] args){
+	private Pair<BiConsumer<CommandSender, String>, String> getCommand(String[] args) {
 		List<String> argList = Arrays.asList(args);
 
 		if (commands.containsKey(argList))
 			return commands.get(argList);
 
-        if (args.length > 1){
+		if (args.length > 1) {
 			List<String> argListWithoutLast = argList.subList(0, args.length - 1);
 			if (commands.containsKey(argListWithoutLast))
 				return commands.get(argListWithoutLast);
@@ -104,21 +106,21 @@ public class Commands implements TabExecutor {
 		return Pair.pair((cmdSender, arg) -> unknownCommand(cmdSender), "");
 	}
 
-    private void commandReset(CommandSender sender){
-        if (!sender.hasPermission("sharehealth.reset")){
+	private void commandReset(CommandSender sender) {
+		if (!sender.hasPermission("sharehealth.reset")) {
 			sender.sendMessage("You don't have permissions for this command!");
 			return;
 		}
 		Sharehealth.Instance.reset();
 	}
 
-    private void commandActivePlayer(CommandSender sender, String playerName, boolean add){
-        if (!sender.hasPermission("sharehealth.players")){
+	private void commandActivePlayer(CommandSender sender, String playerName, boolean add) {
+		if (!sender.hasPermission("sharehealth.players")) {
 			sender.sendMessage("You don't have permissions for this command!");
 			return;
 		}
 		UUID uuid = Bukkit.getOfflinePlayer(playerName).getUniqueId();
-        if (add){
+		if (add) {
 			Sharehealth.Instance.addPlayer(uuid);
 			sender.sendMessage("Added player " + playerName);
 		} else {
@@ -127,13 +129,13 @@ public class Commands implements TabExecutor {
 		}
 	}
 
-    private void commandGetHealth(CommandSender sender){
+	private void commandGetHealth(CommandSender sender) {
 		String message = "Current health: " + Sharehealth.Instance.getHealthManager().getHealthString();
 		sender.sendMessage(message);
 	}
 
 	private void commandSetTotemMode(CommandSender sender, TotemManager.Mode mode) {
-        if (!sender.hasPermission("sharehealth.totem")){
+		if (!sender.hasPermission("sharehealth.totem")) {
 			sender.sendMessage("You don't have permissions for this command!");
 			return;
 		}
@@ -141,13 +143,13 @@ public class Commands implements TabExecutor {
 		sender.sendMessage("Set Totem mode to " + mode.name());
 	}
 
-    private void commandGetTotemMode(CommandSender sender){
+	private void commandGetTotemMode(CommandSender sender) {
 		TotemManager.Mode mode = Sharehealth.Instance.getTotemManager().getMode();
 		sender.sendMessage("Current Totem mode: " + mode.name());
 	}
 
-    private void commandSetTotemFraction(CommandSender sender, String amountStr){
-        if (!sender.hasPermission("sharehealth.totem")){
+	private void commandSetTotemFraction(CommandSender sender, String amountStr) {
+		if (!sender.hasPermission("sharehealth.totem")) {
 			sender.sendMessage("You don't have permissions for this command!");
 			return;
 		}
@@ -157,18 +159,18 @@ public class Commands implements TabExecutor {
 			Sharehealth.Instance.getTotemManager().setFractionNeeded(fraction);
 			double newValue = Sharehealth.Instance.getTotemManager().getFractionNeeded();
 			sender.sendMessage("Set totem fraction value to " + newValue);
-        } catch (NumberFormatException e){
+		} catch (NumberFormatException e) {
 			sender.sendMessage("Provided value was not a number between 0.0 and 1.0!");
 		}
 	}
 
-    private void commandGetTotemFraction(CommandSender sender){
+	private void commandGetTotemFraction(CommandSender sender) {
 		double value = Sharehealth.Instance.getTotemManager().getFractionNeeded();
 		sender.sendMessage("Totem fraction value: " + value);
 	}
 
-    private void commandSetLogging(CommandSender sender, boolean hasLogging){
-        if (sender instanceof Player){
+	private void commandSetLogging(CommandSender sender, boolean hasLogging) {
+		if (sender instanceof Player) {
 			if (!Sharehealth.GetPlayers().contains(sender))
 				return;
 
@@ -177,8 +179,8 @@ public class Commands implements TabExecutor {
 		}
 	}
 
-    private void commandGetLogging(CommandSender sender){
-        if (sender instanceof Player){
+	private void commandGetLogging(CommandSender sender) {
+		if (sender instanceof Player) {
 			if (!Sharehealth.GetPlayers().contains(sender))
 				return;
 
@@ -187,17 +189,17 @@ public class Commands implements TabExecutor {
 		}
 	}
 
-    private void commandSendStats(CommandSender sender){
+	private void commandSendStats(CommandSender sender) {
 		String message = Sharehealth.Instance.getMessenger().statisticsMessage();
 		sender.sendMessage(message);
 	}
 
-    private void commandGetHelp(CommandSender sender){
+	private void commandGetHelp(CommandSender sender) {
 		String message = Sharehealth.Instance.getMessenger().helpMessage(commands);
 		sender.sendMessage(message);
 	}
 
-    private void unknownCommand(CommandSender sender){
+	private void unknownCommand(CommandSender sender) {
 		String message = "Unknown command. Type \"/sh help\" for help.";
 		sender.sendMessage(message);
 	}

src/main/java/com/benjocraeft/sharehealth/FileManager.java

@@ -14,11 +14,11 @@ public class FileManager {
 	final private File pluginFolder = new File(System.getProperty("user.dir"), "plugins/sharehealth");
 	final private String pluginPath = pluginFolder.getPath();
 
-    public FileManager(){
+	public FileManager() {
 		Logger logger = Sharehealth.Instance.getLogger();
 
 		//Prepare storage folder
-        if (pluginFolder.mkdirs()){
+		if (pluginFolder.mkdirs()) {
 			logger.info(pluginFolder.getName() + " created");
 		}
 
@@ -36,12 +36,12 @@ public class FileManager {
 				logger.info(statusFile.getName() + " created");
 			if (playersFile.createNewFile())
 				logger.info(playersFile.getName() + " created");
-        } catch(IOException e){
+		} catch (IOException e) {
 			e.printStackTrace();
 		}
 	}
 
-    public Map<UUID, Boolean> loadSettings(){
+	public Map<UUID, Boolean> loadSettings() {
 		Map<UUID, Boolean> settingsMap = new HashMap<>();
 
 		Map<String, String> map = loadMapFromFile(settingsFile);
@@ -54,7 +54,7 @@ public class FileManager {
 		return settingsMap;
 	}
 
-    public Map<UUID, Pair<Double, Double>> loadStatistics(){
+	public Map<UUID, Pair<Double, Double>> loadStatistics() {
 		Map<UUID, Pair<Double, Double>> statisticsMap = new HashMap<>();
 
 		Map<String, String> map = loadMapFromFile(statisticsFile);
@@ -72,7 +72,7 @@ public class FileManager {
 		return statisticsMap;
 	}
 
-    public Map<String, Object> loadStatus(){
+	public Map<String, Object> loadStatus() {
 		Map<String, Object> statusMap = new HashMap<>();
 
 		Map<String, String> map = loadMapFromFile(statusFile);
@@ -89,14 +89,14 @@ public class FileManager {
 		return statusMap;
 	}
 
-    public List<UUID> loadPlayers(){
+	public List<UUID> loadPlayers() {
 		Map<String, String> loaded = loadMapFromFile(playersFile);
 		List<UUID> playerUUIDs = new ArrayList<>();
 		loaded.keySet().forEach(s -> playerUUIDs.add(UUID.fromString(s)));
 		return playerUUIDs;
 	}
 
-    public void saveStatistics(Map<UUID, Pair<Double, Double>> statistics){
+	public void saveStatistics(Map<UUID, Pair<Double, Double>> statistics) {
 		saveStatistics(statisticsFile, statistics);
 	}
 
@@ -111,11 +111,11 @@ public class FileManager {
 		saveMapToFile(file, map);
 	}
 
-    public void saveStatus(Map<String, Object> statusMap){
+	public void saveStatus(Map<String, Object> statusMap) {
 		saveMapToFile(statusFile, statusMap);
 	}
 
-    public void saveSettings(Map<UUID, Boolean> settingsMap){
+	public void saveSettings(Map<UUID, Boolean> settingsMap) {
 		Map<String, Object> map = new HashMap<>();
 
 		settingsMap.forEach((UUID uuid, Boolean hasLogging) -> map.put(uuid.toString(), hasLogging));
@@ -123,7 +123,7 @@ public class FileManager {
 		saveMapToFile(settingsFile, map);
 	}
 
-    public void savePlayers(List<UUID> playerUUIDs){
+	public void savePlayers(List<UUID> playerUUIDs) {
 		Map<String, Object> map = new HashMap<>();
 
 		playerUUIDs.forEach(uuid -> map.put(uuid.toString(), ""));
@@ -131,16 +131,16 @@ public class FileManager {
 		saveMapToFile(playersFile, map);
 	}
 
-    public void backupStats(Map<UUID, Pair<Double, Double>> statistics){
+	public void backupStats(Map<UUID, Pair<Double, Double>> statistics) {
 		Date date = new Date();
 		String dateString = String.valueOf(date.getTime());
 		File backupDir = new File(pluginPath + "/old_statistics");
-        if (backupDir.mkdirs()){
+		if (backupDir.mkdirs()) {
 			Sharehealth.Instance.getLogger().info("Folder old_statistics created");
 		}
 		File backupFile = new File(backupDir.getPath() + "/" + dateString + ".txt");
 		try {
-            if (backupFile.createNewFile()){
+			if (backupFile.createNewFile()) {
 				Sharehealth.Instance.getLogger().info(backupFile.getName() + " created");
 				saveStatistics(backupFile, statistics);
 			}
@@ -152,36 +152,37 @@ public class FileManager {
 	private Map<String, String> loadMapFromFile(File file) {
 		Map<String, String> map = new HashMap<>();
 
-        try{
+		try {
 			DataInputStream input = new DataInputStream(new FileInputStream(file));
 			BufferedReader reader = new BufferedReader(new InputStreamReader(input));
 
-            try{
+			try {
 				String line;
-                while((line = reader.readLine()) != null){
+				while ((line = reader.readLine()) != null) {
 					String[] split = line.split("=");
 					map.put(split[0], split.length == 2 ? split[1] : "");
 				}
-            } catch (NullPointerException ignore){}
+			} catch (NullPointerException ignore) {
+			}
 
 			reader.close();
 			input.close();
-        } catch(IOException e){
+		} catch (IOException e) {
 			e.printStackTrace();
 		}
 
 		return map;
 	}
 
-    private void saveMapToFile(File file, Map<String, Object> content){
-        try{
+	private void saveMapToFile(File file, Map<String, Object> content) {
+		try {
 			FileWriter stream = new FileWriter(file);
 			BufferedWriter out = new BufferedWriter(stream);
 
 			content.forEach((String key, Object obj) -> {
 				try {
 					String value = obj.toString();
-                    if (obj instanceof Double){
+					if (obj instanceof Double) {
 						value = new Formatter(Locale.US).format("%.2f", obj).toString();
 					}
 					out.write(key + "=" + value);
@@ -193,7 +194,7 @@ public class FileManager {
 
 			out.close();
 			stream.close();
-        } catch (IOException e){
+		} catch (IOException e) {
 			e.printStackTrace();
 		}
 	}

src/main/java/com/benjocraeft/sharehealth/FoodRegeneration.java

@@ -5,18 +5,18 @@ import org.bukkit.scheduler.BukkitRunnable;
 
 public class FoodRegeneration extends BukkitRunnable {
 
-    FoodRegeneration(){
+	FoodRegeneration() {
 		runTaskTimer(Sharehealth.Instance, 80, 80);
 	}
 
 	@Override
-    public void run(){
+	public void run() {
 		int allPlayersCount = Sharehealth.GetPlayers().size();
 		if (allPlayersCount == 0)
 			return;
 
 		int allFoodPoints = 0;
-        for (Player p : Sharehealth.GetPlayers()){
+		for (Player p : Sharehealth.GetPlayers()) {
 			allFoodPoints += p.getFoodLevel();
 		}
 
@@ -24,7 +24,7 @@ public class FoodRegeneration extends BukkitRunnable {
 		// is greater than or equal to 18 of 20 (90%)
 		//Here, we look for the average food level
 		double currentHealth = Sharehealth.Instance.getHealthManager().getHealth();
-        if (allFoodPoints / allPlayersCount >= 16 && currentHealth > 0 && currentHealth < 20){
+		if (allFoodPoints / allPlayersCount >= 16 && currentHealth > 0 && currentHealth < 20) {
 			Sharehealth.Instance.onFoodRegeneration();
 		}
 

src/main/java/com/benjocraeft/sharehealth/HealthManager.java

@@ -11,11 +11,11 @@ public class HealthManager {
 	private double
 			health = 20;
 
-    double getHealth(){
+	double getHealth() {
 		return health;
 	}
 
-    void setHealth(double health){
+	void setHealth(double health) {
 		if (health > 20)
 			health = 20;
 		if (health < 0)
@@ -23,7 +23,7 @@ public class HealthManager {
 		this.health = health;
 	}
 
-    String getHealthString(){
+	String getHealthString() {
 		return new Formatter(Locale.US).format("%.2f", health / 2).toString();
 	}
 
@@ -31,7 +31,8 @@ public class HealthManager {
 	public HealthManager() {
 
 	}
-    public void updatePlayer(Player player){
+
+	public void updatePlayer(Player player) {
 		if (player.getGameMode().equals(GameMode.SURVIVAL)) {
 			player.setHealth(health);
 			absorptionManager.setAbsorption(player);
@@ -40,41 +41,41 @@ public class HealthManager {
 			player.setHealth(20);
 	}
 
-    private void subtractHealth(double sub){
+	private void subtractHealth(double sub) {
 		setHealth(health - sub);
 	}
 
-    void addHealth(double add){
+	void addHealth(double add) {
 		setHealth(health + add);
 	}
 
-    void reset(){
+	void reset() {
 		health = 20;
 		Sharehealth.GetPlayers().forEach(p -> p.setHealth(health));
 	}
 
-    boolean wouldCauseDeath(double damage){
+	boolean wouldCauseDeath(double damage) {
 		double newHealth = health - damage;
 		return newHealth <= 0;
 	}
 
-    void onPlayerGotDamage(Player player, double damage, double absorptionDamage){
+	void onPlayerGotDamage(Player player, double damage, double absorptionDamage) {
 		subtractHealth(damage);
 		applyHealthToAllExcept(player);
 		absorptionManager.onPlayerGotDamage(player, absorptionDamage);
 	}
 
-    void onPlayerRegainedHealth(Player player, double regainedHealth){
+	void onPlayerRegainedHealth(Player player, double regainedHealth) {
 		addHealth(regainedHealth);
 		applyHealthToAllExcept(player);
 	}
 
-    void applyHealthToAllExcept(Player player){
+	void applyHealthToAllExcept(Player player) {
 		Sharehealth.GetPlayers(player).forEach(p -> p.setHealth(health));
 	}
 
 	//When totem is triggered, set health to 1 and remove absorption
-    void onTotemTriggered(){
+	void onTotemTriggered() {
 		setHealth(1);
 		applyHealthToAllExcept(null);
 		absorptionManager.expire(false);
@@ -82,12 +83,12 @@ public class HealthManager {
 
 	final AbsorptionManager absorptionManager = new AbsorptionManager();
 
-    void onAbsorptionConsumed(int duration, int amplifier){
+	void onAbsorptionConsumed(int duration, int amplifier) {
 		double amount = (amplifier + 1) * 4;
 		absorptionManager.create(duration, amount);
 	}
 
-    void onMilkBucketConsumed(){
+	void onMilkBucketConsumed() {
 		absorptionManager.expire(false);
 	}
 

src/main/java/com/benjocraeft/sharehealth/Pair.java

@@ -7,12 +7,12 @@ public class Pair<F, S> {
 	public final F first;
 	public final S second;
 
-    public Pair(F first, S second){
+	public Pair(F first, S second) {
 		this.first = first;
 		this.second = second;
 	}
 
-    public static <F, S> Pair<F, S> pair(F first, S second){
+	public static <F, S> Pair<F, S> pair(F first, S second) {
 		return new Pair<>(first, second);
 	}
 }

src/main/java/com/benjocraeft/sharehealth/PlayerListeners.java

@@ -20,17 +20,17 @@ import org.bukkit.potion.PotionEffectType;
 import java.util.Arrays;
 
 
-public class PlayerListeners implements Listener{
+public class PlayerListeners implements Listener {
 
 	@EventHandler
-    public void onJoin(PlayerJoinEvent e){
+	public void onJoin(PlayerJoinEvent e) {
 		Player p = e.getPlayer();
 		if (Sharehealth.GetPlayers().contains(p))
 			Sharehealth.Instance.onPlayerJoin(e.getPlayer());
 	}
 
 	@EventHandler
-    public void onPlayerRespawn(final PlayerRespawnEvent e){
+	public void onPlayerRespawn(final PlayerRespawnEvent e) {
 		Player p = e.getPlayer();
 		if (Sharehealth.GetPlayers().contains(p))
 			Sharehealth.Instance.onPlayerRespawn(e.getPlayer());
@@ -38,15 +38,15 @@ public class PlayerListeners implements Listener{
 
 	//Normal Totem Of Undying interaction is disabled
 	@EventHandler
-    public void onResurrect(final EntityResurrectEvent e){
+	public void onResurrect(final EntityResurrectEvent e) {
 		e.setCancelled(true);
 	}
 
 	@EventHandler
-    public void onEntityGotDamage(final EntityDamageEvent event){
+	public void onEntityGotDamage(final EntityDamageEvent event) {
 		Entity damagedEntity = event.getEntity();
 
-        if (damagedEntity instanceof Player){
+		if (damagedEntity instanceof Player) {
 			if (!Sharehealth.GetPlayers().contains(damagedEntity))
 				return;
 
@@ -73,8 +73,8 @@ public class PlayerListeners implements Listener{
 
 	//Only for logging/messaging
 	//lower priority so the message will be read even if player dies from damage
-    @EventHandler (priority = EventPriority.LOW)
-    public void onEntityGotDamageByEntity(final EntityDamageByEntityEvent event){
+	@EventHandler(priority = EventPriority.LOW)
+	public void onEntityGotDamageByEntity(final EntityDamageByEntityEvent event) {
 		Entity damagedEntity = event.getEntity();
 
 		if (damagedEntity instanceof Player) {
@@ -84,14 +84,14 @@ public class PlayerListeners implements Listener{
 			double damage = event.getFinalDamage();
 			Entity damagingEntity = event.getDamager();
 			double absorbedDamage = -event.getOriginalDamage(DamageModifier.ABSORPTION);
-            Sharehealth.Instance.onPlayerGotDamageByEntity((Player)damagedEntity, damage, damagingEntity, absorbedDamage);
+			Sharehealth.Instance.onPlayerGotDamageByEntity((Player) damagedEntity, damage, damagingEntity, absorbedDamage);
 		}
 	}
 
 	//Only for logging/messaging
 	//lower priority so the message will be read even if player dies from damage
-    @EventHandler (priority = EventPriority.LOW)
-    public void onEntityGotDamageByBlock(final EntityDamageByBlockEvent event){
+	@EventHandler(priority = EventPriority.LOW)
+	public void onEntityGotDamageByBlock(final EntityDamageByBlockEvent event) {
 		Entity damagedEntity = event.getEntity();
 
 		if (damagedEntity instanceof Player) {
@@ -105,35 +105,35 @@ public class PlayerListeners implements Listener{
 				return;
 
 			double absorbedDamage = -event.getOriginalDamage(DamageModifier.ABSORPTION);
-            Sharehealth.Instance.onPlayerGotDamageByBlock((Player)damagedEntity, damage, damagingBlock, absorbedDamage);
+			Sharehealth.Instance.onPlayerGotDamageByBlock((Player) damagedEntity, damage, damagingBlock, absorbedDamage);
 		}
 	}
 
 	@EventHandler
-    public void onEntityRegainedHealth(final EntityRegainHealthEvent event){
+	public void onEntityRegainedHealth(final EntityRegainHealthEvent event) {
 		Entity healedEntity = event.getEntity();
 
-        if (healedEntity instanceof Player){
+		if (healedEntity instanceof Player) {
 			if (!Sharehealth.GetPlayers().contains(healedEntity))
 				return;
 
 			double amount = event.getAmount();
 			RegainReason reason = event.getRegainReason();
-            if (!Sharehealth.Instance.onPlayerRegainedHealth((Player) healedEntity, amount, reason)){
+			if (!Sharehealth.Instance.onPlayerRegainedHealth((Player) healedEntity, amount, reason)) {
 				event.setCancelled(true);
 			}
 		}
 	}
 
 	@EventHandler
-    public void onEntityPotionEffectModified(final EntityPotionEffectEvent event){
+	public void onEntityPotionEffectModified(final EntityPotionEffectEvent event) {
 		Entity entity = event.getEntity();
-        if (entity instanceof Player){
+		if (entity instanceof Player) {
 			if (!Sharehealth.GetPlayers().contains(entity))
 				return;
 			PotionEffect newEffect = event.getNewEffect();
-            if (newEffect != null){
-                if (newEffect.getType().equals(PotionEffectType.ABSORPTION)){
+			if (newEffect != null) {
+				if (newEffect.getType().equals(PotionEffectType.ABSORPTION)) {
 					event.setCancelled(true);
 					int amplifier = newEffect.getAmplifier();
 					int duration = newEffect.getDuration();
@@ -144,7 +144,7 @@ public class PlayerListeners implements Listener{
 	}
 
 	@EventHandler
-    public void onPlayerItemConsumed(final PlayerItemConsumeEvent event){
+	public void onPlayerItemConsumed(final PlayerItemConsumeEvent event) {
 		Player consumer = event.getPlayer();
 		if (!Sharehealth.GetPlayers().contains(consumer))
 			return;

src/main/java/com/benjocraeft/sharehealth/Sharehealth.java

@@ -20,27 +20,31 @@ public class Sharehealth extends JavaPlugin {
 
 	private FileManager fileManager;
 
-    public FileManager getFileManager(){
+	public FileManager getFileManager() {
 		return fileManager;
 	}
 
 	private HealthManager healthManager;
-    public HealthManager getHealthManager(){
+
+	public HealthManager getHealthManager() {
 		return healthManager;
 	}
 
 	private TotemManager totemManager;
+
 	public TotemManager getTotemManager() {
 		return totemManager;
 	}
 
 	private Messenger messenger;
-    public Messenger getMessenger(){
+
+	public Messenger getMessenger() {
 		return messenger;
 	}
 
 	private Statistics statistics;
-    public Statistics getStatistics(){
+
+	public Statistics getStatistics() {
 		return statistics;
 	}
 
@@ -48,6 +52,7 @@ public class Sharehealth extends JavaPlugin {
 	boolean isFailed = false;
 
 	private final Map<String, Object> defaultStatus = new HashMap<>();
+
 	{
 		defaultStatus.put("health", 20.);
 		defaultStatus.put("isFailed", false);
@@ -58,7 +63,7 @@ public class Sharehealth extends JavaPlugin {
 	}
 
 	@Override
-    public void onEnable(){
+	public void onEnable() {
 
 		//Singleton setup
 		Instance = this;
@@ -109,7 +114,7 @@ public class Sharehealth extends JavaPlugin {
 		getLogger().info("ShareHealth has been disabled!");
 	}
 
-    void onPlayerJoin(Player player){
+	void onPlayerJoin(Player player) {
 		updateGameMode(player);
 
 		healthManager.updatePlayer(player);
@@ -118,14 +123,14 @@ public class Sharehealth extends JavaPlugin {
 		fileManager.saveSettings(statistics.getSettings());
 	}
 
-    void onPlayerRespawn(Player player){
+	void onPlayerRespawn(Player player) {
 		updateGameMode(player);
 
 		healthManager.updatePlayer(player);
 	}
 
 	void onPlayerGotDamage(Player player, double damage, DamageCause cause,
-                           boolean isMessageAllowed, double absorbedDamage, Consumer<Boolean> cancelDamage){
+						   boolean isMessageAllowed, double absorbedDamage, Consumer<Boolean> cancelDamage) {
 		if (isFailed)
 			return;
 
@@ -138,8 +143,8 @@ public class Sharehealth extends JavaPlugin {
 
 		statistics.onPlayerGotDamage(player, receivedDamage);
 
-        if (healthManager.wouldCauseDeath(damage)){
-            if (totemManager.totemCanBeUsed()){
+		if (healthManager.wouldCauseDeath(damage)) {
+			if (totemManager.totemCanBeUsed()) {
 				healthManager.onTotemTriggered();
 				totemManager.activate(player);
 				cancelDamage.accept(true);
@@ -153,24 +158,26 @@ public class Sharehealth extends JavaPlugin {
 
 		saveStatus();
 	}
-    void onPlayerGotDamageByEntity(Player player, double damage, Entity damagingEntity, double absorbedDamage){
+
+	void onPlayerGotDamageByEntity(Player player, double damage, Entity damagingEntity, double absorbedDamage) {
 		if (isFailed)
 			return;
 
 		messenger.onPlayerGotDamageMessage(player, damage + absorbedDamage, damagingEntity);
 	}
-    void onPlayerGotDamageByBlock(Player player, double damage, Block damagingBlock, double absorbedDamage){
+
+	void onPlayerGotDamageByBlock(Player player, double damage, Block damagingBlock, double absorbedDamage) {
 		if (isFailed)
 			return;
 
 		messenger.onPlayerGotDamageMessage(player, damage + absorbedDamage, damagingBlock);
 	}
 
-    boolean onPlayerRegainedHealth(Player player, double amount, RegainReason reason){
+	boolean onPlayerRegainedHealth(Player player, double amount, RegainReason reason) {
 		if (isFailed)
 			return true;
 
-        if (reason.equals(RegainReason.REGEN) || reason.equals(RegainReason.SATIATED)){
+		if (reason.equals(RegainReason.REGEN) || reason.equals(RegainReason.SATIATED)) {
 			return false;
 		}
 
@@ -183,26 +190,26 @@ public class Sharehealth extends JavaPlugin {
 		return true;
 	}
 
-    void onFoodRegeneration(){
+	void onFoodRegeneration() {
 		healthManager.addHealth(1);
 		healthManager.applyHealthToAllExcept(null);
 
 		saveStatus();
 	}
 
-    void onAbsorptionConsumed(int duration, int amplifier){
+	void onAbsorptionConsumed(int duration, int amplifier) {
 		healthManager.onAbsorptionConsumed(duration, amplifier);
 
 		saveStatus();
 	}
 
-    void onMilkBucketConsumed(){
+	void onMilkBucketConsumed() {
 		healthManager.onMilkBucketConsumed();
 
 		saveStatus();
 	}
 
-    private void failed(Player cause){
+	private void failed(Player cause) {
 		if (isFailed)
 			return;
 		isFailed = true;
@@ -212,7 +219,7 @@ public class Sharehealth extends JavaPlugin {
 		saveStatus();
 	}
 
-    void reset(){
+	void reset() {
 		isFailed = false;
 		fileManager.backupStats(statistics.getStatistics());
 		statistics.reset();
@@ -223,8 +230,8 @@ public class Sharehealth extends JavaPlugin {
 		saveStatus();
 	}
 
-    private void updateGameMode(Player player){
-        if (!isFailed){
+	private void updateGameMode(Player player) {
+		if (!isFailed) {
 			player.setGameMode(GameMode.SURVIVAL);
 		} else {
 			player.setGameMode(GameMode.SPECTATOR);
@@ -232,28 +239,30 @@ public class Sharehealth extends JavaPlugin {
 	}
 
 	private static List<UUID> ActiveUUIDs = new ArrayList<>();
-    static List<Player> GetPlayers(){
+
+	static List<Player> GetPlayers() {
 		List<Player> players = new ArrayList<>(Bukkit.getOnlinePlayers());
 		players.removeIf(p -> !ActiveUUIDs.contains(p.getUniqueId()));
 		return players;
 	}
-    static List<Player> GetPlayers(Player except){
+
+	static List<Player> GetPlayers(Player except) {
 		List<Player> players = GetPlayers();
 		players.remove(except);
 		return players;
 	}
 
-    public void addPlayer(UUID uuid){
+	public void addPlayer(UUID uuid) {
 		ActiveUUIDs.add(uuid);
 		fileManager.savePlayers(ActiveUUIDs);
 	}
 
-    public void removePlayer(UUID uuid){
+	public void removePlayer(UUID uuid) {
 		ActiveUUIDs.remove(uuid);
 		fileManager.savePlayers(ActiveUUIDs);
 	}
 
-    void saveStatus(){
+	void saveStatus() {
 		Map<String, Object> map = new HashMap<>();
 
 		map.put("health", healthManager.getHealth());
@@ -266,29 +275,29 @@ public class Sharehealth extends JavaPlugin {
 		fileManager.saveStatus(map);
 	}
 
-    private void loadStatus(){
+	private void loadStatus() {
 		Map<String, Object> map = fileManager.loadStatus();
 
 		defaultStatus.forEach(map::putIfAbsent);
 		map.forEach((String key, Object value) -> getLogger().info(key + "=" + value));
 
-        healthManager.setHealth((Double)map.get("health"));
+		healthManager.setHealth((Double) map.get("health"));
 		isFailed = (boolean) map.get("isFailed");
 		healthManager.absorptionManager.create(
-                (int)map.get("absorptionDuration"),
-                (Double)map.get("absorptionAmount")
+				(int) map.get("absorptionDuration"),
+				(Double) map.get("absorptionAmount")
 		);
-        totemManager.setMode(TotemManager.Mode.values()[(int)map.get("totemMode")]);
-        totemManager.setFractionNeeded((Double)map.get("totemFraction"));
+		totemManager.setMode(TotemManager.Mode.values()[(int) map.get("totemMode")]);
+		totemManager.setFractionNeeded((Double) map.get("totemFraction"));
 	}
 
-    void onLoggingUpdated(Player player, boolean hasLogging){
+	void onLoggingUpdated(Player player, boolean hasLogging) {
 		statistics.setSettings(player.getUniqueId(), hasLogging);
 		Map<UUID, Boolean> settings = statistics.getSettings();
 		fileManager.saveSettings(settings);
 	}
 
-    boolean getLogging(Player player){
+	boolean getLogging(Player player) {
 		Map<UUID, Boolean> settings = statistics.getSettings();
 		return settings.get(player.getUniqueId());
 	}

src/main/java/com/benjocraeft/sharehealth/Statistics.java

@@ -9,54 +9,58 @@ import java.util.UUID;
 public class Statistics {
 
 	final private Map<UUID, Pair<Double, Double>> statistics = new HashMap<>();
-    public Map<UUID, Pair<Double, Double>> getStatistics(){
+
+	public Map<UUID, Pair<Double, Double>> getStatistics() {
 		return statistics;
 	}
 
-    public static Double Rounded(Double value, int afterComma){
+	public static Double Rounded(Double value, int afterComma) {
 		return Math.round(value * Math.pow(10, afterComma)) / Math.pow(10, afterComma);
 	}
-    public static Double Rounded(Double value){
+
+	public static Double Rounded(Double value) {
 		return Rounded(value, 2);
 	}
 
-    public Statistics(Map<UUID, Pair<Double, Double>> statistics, Map<UUID, Boolean> settings){
+	public Statistics(Map<UUID, Pair<Double, Double>> statistics, Map<UUID, Boolean> settings) {
 		this.statistics.putAll(statistics);
 		this.settings.putAll(settings);
 	}
 
 	final private Map<UUID, Boolean> settings = new HashMap<>();
-    public Map<UUID, Boolean> getSettings(){
+
+	public Map<UUID, Boolean> getSettings() {
 		return settings;
 	}
-    public void setSettings(UUID uuid, boolean hasLogging){
+
+	public void setSettings(UUID uuid, boolean hasLogging) {
 		settings.put(uuid, hasLogging);
 	}
 
-    public void onPlayerJoined(Player player){
+	public void onPlayerJoined(Player player) {
 		putIfAbsent(player);
 	}
 
-    void onPlayerRegainedHealth(Player player, double amount){
+	void onPlayerRegainedHealth(Player player, double amount) {
 		UUID uuid = player.getUniqueId();
 		Pair<Double, Double> oldPair = statistics.get(uuid);
 		statistics.put(uuid, Pair.pair(oldPair.first, oldPair.second + amount));
 	}
 
-    void onPlayerGotDamage(Player player, double amount){
+	void onPlayerGotDamage(Player player, double amount) {
 		UUID uuid = player.getUniqueId();
 		Pair<Double, Double> oldPair = statistics.get(uuid);
 		statistics.put(uuid, Pair.pair(oldPair.first + amount, oldPair.second));
 	}
 
-    private void putIfAbsent(Player player){
+	private void putIfAbsent(Player player) {
 		UUID uuid = player.getUniqueId();
 		Pair<Double, Double> empty = Pair.pair(0., 0.);
 		statistics.putIfAbsent(uuid, empty);
 		settings.putIfAbsent(uuid, true);
 	}
 
-    void reset(){
+	void reset() {
 		statistics.clear();
 		Sharehealth.GetPlayers().forEach(this::putIfAbsent);
 	}

src/main/java/com/benjocraeft/sharehealth/TotemManager.java

@@ -14,35 +14,39 @@ public class TotemManager {
 
 
 	private Mode mode = Mode.All;
-    public void setMode(Mode mode){
+
+	public void setMode(Mode mode) {
 		this.mode = mode;
 	}
-    public Mode getMode(){
+
+	public Mode getMode() {
 		return mode;
 	}
 
 	//between 0 and 1
 	private double fractionNeeded;
-    public void setFractionNeeded(double value){
+
+	public void setFractionNeeded(double value) {
 		if (value < 0)
 			value = 0;
 		if (value > 1)
 			value = 1;
 		fractionNeeded = value;
 	}
+
 	public double getFractionNeeded() {
 		return fractionNeeded;
 	}
 
 	//Determine if enough players hold a totem of undying
-    public boolean totemCanBeUsed(){
+	public boolean totemCanBeUsed() {
 		return getHolderCount() >= getMinimumPlayerCount();
 	}
 
 	//Activate Totem Effect
 	//Remove used items
 	//Finally buy some Falafel for Markus
-    public void activate(Player triggeringPlayer){
+	public void activate(Player triggeringPlayer) {
 
 		List<Player> allPlayers = Sharehealth.GetPlayers();
 
@@ -77,15 +81,15 @@ public class TotemManager {
 			p.playEffect(EntityEffect.TOTEM_RESURRECT);
 	}
 
-    private boolean destroyItemFrom(Player holder){
+	private boolean destroyItemFrom(Player holder) {
 		ItemStack main = holder.getInventory().getItemInMainHand();
-        if (main.getType().equals(Material.TOTEM_OF_UNDYING)){
+		if (main.getType().equals(Material.TOTEM_OF_UNDYING)) {
 			//destroy item
 			main.setAmount(0);
 			return true;
 		} else {
 			ItemStack off = holder.getInventory().getItemInOffHand();
-            if (off.getType().equals(Material.TOTEM_OF_UNDYING)){
+			if (off.getType().equals(Material.TOTEM_OF_UNDYING)) {
 				//destroy item
 				off.setAmount(0);
 				return true;
@@ -95,7 +99,7 @@ public class TotemManager {
 	}
 
 	//Calculates how many players are needed at least to trigger the totem for everyone
-    private int getMinimumPlayerCount(){
+	private int getMinimumPlayerCount() {
 		int allPlayerCount = Sharehealth.GetPlayers().size();
 		return switch (mode) {
 			case One -> 1;
@@ -107,7 +111,7 @@ public class TotemManager {
 
 	//Counts how many players hold a totem
 	//Markus still is waiting for his Falafel
-    private int getHolderCount(){
+	private int getHolderCount() {
 		List<Player> players = Sharehealth.GetPlayers();
 		return players.stream().mapToInt(p -> {
 			ItemStack main = p.getInventory().getItemInMainHand();