so://phie

poppy

A feature-rich Minecraft plugin which enhances gaming experience
git clone git://soophie.de/poppy

• log
• tree
• refs
• README

branch:feat/fast-travel branch:feat/magic branch:feat/shulkerbox branch:feat/spleef branch:feat/world branch:main

• build.gradle [new file] [old file]

  26targetCompatibility = 1.11
  27
  28dependencies {
  29    implementation 'org.spigotmc:spigot-api:1.16.4-R0.1-SNAPSHOT'
  29    implementation 'org.spigotmc:spigot-api:1.16.5-R0.1-SNAPSHOT'
  30	implementation 'com.google.code.gson:gson:2.8.6'
  31}
  32
  

  46			}
  47		}
  48	}
  49}
  50
  51task local (dependsOn: 'jar', type: Copy) {
  52	from project.file('build/libs')
  53	into 'E:/run/spigot-16.5/plugins'
  54}
  54
  \ No newline at end of file
  

• res/plugin.yml [new file] [old file]

  9  skull:
  10    usage: /skull <player>
  11  standby:
  12    usage: /standby <true, false>
  12
  \ No newline at end of file
  12    usage: /standby <true, false>
  13  kit:
  13
  \ No newline at end of file
  

• src/de/typable/minecrafthub/Config.java [new file]

  1package de.typable.minecrafthub;
  2
  3import java.io.File;
  4import java.io.IOException;
  5import java.nio.file.Files;
  6import java.nio.file.Paths;
  7
  8import com.google.gson.Gson;
  9
  10
  11public class Config
  12{
  13	private static final Gson gson = new Gson();
  14
  15	public static Config open(String path)
  16	{
  17		File file = new File(path);
  18
  19		try
  20		{
  21			if(!file.exists())
  22			{
  23				file.createNewFile();
  24			}
  25
  26			String content = Files.readString(Paths.get(path));
  27
  28			if(content != null)
  29			{
  30				// TODO: convert string to json object
  31			}
  32		}
  33		catch(IOException ex)
  34		{
  35			ex.printStackTrace();
  36		}
  37
  38		return new Config();
  39	}
  40}
  

• src/de/typable/minecrafthub/Main.java [new file] [old file]

  25import de.typable.minecrafthub.event.ChairListener;
  26import de.typable.minecrafthub.event.DoubleDoorListener;
  27import de.typable.minecrafthub.event.EventListener;
  28import de.typable.minecrafthub.event.LeavesDecayListener;
  29import de.typable.minecrafthub.event.StandbyListener;
  30import de.typable.minecrafthub.game.kit.KitGame;
  31import de.typable.minecrafthub.util.Util;
  32
  33
  

  38	private DoubleDoorListener doubleDoorListener;
  39	private ChairListener chairListener;
  40	private AutoWorkbenchListener autoWorkbenchListener;
  41	private LeavesDecayListener leavesDecayListener;
  42	private EventListener eventListener;
  43
  44	private KitGame kitGame;
  45
  46	private Plugin plugin;
  47	private BukkitTask task;
  48	
  

  65		autoWorkbenchListener = new AutoWorkbenchListener();
  66		pluginManager.registerEvents(autoWorkbenchListener, this);
  67
  68		leavesDecayListener = new LeavesDecayListener(this);
  69		pluginManager.registerEvents(leavesDecayListener, this);
  70
  71		eventListener = new EventListener();
  72		pluginManager.registerEvents(eventListener, this);
  73
  74		kitGame = new KitGame();
  75		this.getCommand("kit").setExecutor(kitGame);
  76		pluginManager.registerEvents(kitGame, this);
  77		
  78		task = Bukkit.getScheduler().runTaskAsynchronously(this, new Runnable()
  79		{
  

  134		{
  135			Player player = (Player) sender;
  136
  125			if(label.equals("shutdown")) {
  126				
  137			if(label.equals("shutdown"))
  138			{
  139				if(!player.isOp())
  140				{
  141					player.sendMessage(DefaultConstants.Messages.NOT_ENOUGH_PERMISSION);
  

• src/de/typable/minecrafthub/constant/DefaultConstants.java [new file] [old file]

  10	public static final class Messages
  11	{
  12		public static final String NOT_ENOUGH_PERMISSION = ChatColor.RED + "You don't have enough Permission to perform this command!";
  13		public static final String ALREADY_INGAME = ChatColor.RED + "You're already ingame!";
  14		public static final String NOT_INGAME = ChatColor.RED + "You're not ingame!";
  15	}
  16}
  

• src/de/typable/minecrafthub/event/EventListener.java [new file] [old file]

  49	@EventHandler
  50	public void onChat(AsyncPlayerChatEvent event)
  51	{
  52		// FIXME Conversion Exception on '%
  53
  54		String format = ChatColor.WHITE + event.getPlayer().getName() + ": " + ChatColor.GRAY + event.getMessage();
  52		String message = ChatColor.GRAY + event.getMessage().replace("%", "%%");
  53		String format = ChatColor.WHITE + event.getPlayer().getName() + ": " + message;
  54		event.setFormat(format);
  55	}
  56
  

  85				ArmorStand armorstand = (ArmorStand) event.getRightClicked();
  86
  87				armorstand.setArms(true);
  89				event.setCancelled(true);
  90				
  88				item.setAmount(item.getAmount() - 2);
  89				
  90				event.setCancelled(true);
  91			}
  92		}
  93	}
  

  99		{
  100			ArmorStand armorstand = (ArmorStand) event.getEntity();
  101
  103			if(armorstand.hasArms()){
  102			if(armorstand.hasArms())
  103			{
  104				event.getDrops().add(new ItemStack(Material.STICK, 2));
  105			}
  106		}
  

• src/de/typable/minecrafthub/event/LeavesDecayListener.java [new file]

  1package de.typable.minecrafthub.event;
  2
  3import java.util.ArrayList;
  4import java.util.Arrays;
  5import java.util.Collections;
  6import java.util.List;
  7
  8import org.bukkit.Tag;
  9import org.bukkit.block.Block;
  10import org.bukkit.block.BlockFace;
  11import org.bukkit.block.data.type.Leaves;
  12import org.bukkit.event.EventHandler;
  13import org.bukkit.event.Listener;
  14import org.bukkit.event.block.BlockBreakEvent;
  15import org.bukkit.event.block.LeavesDecayEvent;
  16import org.bukkit.plugin.Plugin;
  17
  18public class LeavesDecayListener implements Listener
  19{
  20	private static final int DELAY = 50;
  21	private static final List<BlockFace> NEIGHBORS = Arrays.asList(
  22		BlockFace.UP,
  23		BlockFace.NORTH,
  24		BlockFace.EAST,
  25		BlockFace.SOUTH,
  26		BlockFace.WEST,
  27		BlockFace.DOWN
  28	);
  29
  30	private Plugin plugin;
  31	private List<Block> scheduled = new ArrayList<>();
  32
  33	public LeavesDecayListener(Plugin plugin)
  34	{
  35		this.plugin = plugin;
  36	}
  37
  38	@EventHandler
  39	public void onBlockBreak(BlockBreakEvent event)
  40	{
  41		onBlockRemove(event.getBlock());
  42	}
  43
  44	@EventHandler
  45	public void onLeavesDecay(LeavesDecayEvent event)
  46	{
  47		onBlockRemove(event.getBlock());
  48	}
  49
  50	private void onBlockRemove(Block block)
  51	{
  52		if(!Tag.LOGS.isTagged(block.getType()) && !Tag.LEAVES.isTagged(block.getType()))
  53		{
  54			return;
  55		}
  56
  57		Collections.shuffle(NEIGHBORS);
  58
  59		for(BlockFace face : NEIGHBORS)
  60		{
  61			final Block neighbor = block.getRelative(face);
  62
  63			if(!Tag.LEAVES.isTagged(neighbor.getType()))
  64			{
  65				continue;
  66			}
  67
  68			Leaves leaves = (Leaves) neighbor.getBlockData();
  69
  70			if(leaves.isPersistent())
  71			{
  72				continue;
  73			}
  74
  75			if(scheduled.contains(neighbor))
  76			{
  77				continue;
  78			}
  79
  80			plugin.getServer().getScheduler().runTaskLater(plugin, () -> decay(neighbor), DELAY);
  81
  82			scheduled.add(neighbor);
  83		}
  84	}
  85
  86	private boolean decay(Block block)
  87	{
  88		scheduled.remove(block);
  89
  90		if(!block.getWorld().isChunkLoaded(block.getX() >> 4, block.getZ() >> 4))
  91		{
  92			return false;
  93		}
  94
  95		if(!Tag.LEAVES.isTagged(block.getType()))
  96		{
  97			return false;
  98		}
  99
  100		Leaves leaves = (Leaves) block.getBlockData();
  101
  102		if(leaves.isPersistent())
  103		{
  104			return false;
  105		}
  106
  107		if(leaves.getDistance()  < 7)
  108		{
  109			return false;
  110		}
  111
  112		LeavesDecayEvent event = new LeavesDecayEvent(block);
  113		plugin.getServer().getPluginManager().callEvent(event);
  114
  115		if(event.isCancelled())
  116		{
  117			return false;
  118		}
  119
  120		block.breakNaturally();
  121
  122		return true;
  123	}
  124}
  

• src/de/typable/minecrafthub/game/Game.java [new file]

  1package de.typable.minecrafthub.game;
  2
  3import java.util.HashMap;
  4import java.util.Iterator;
  5import java.util.Map;
  6import java.util.Map.Entry;
  7
  8import org.bukkit.command.CommandExecutor;
  9import org.bukkit.entity.Player;
  10import org.bukkit.event.Listener;
  11
  12import de.typable.minecrafthub.Config;
  13import de.typable.minecrafthub.constant.DefaultConstants;
  14
  15public abstract class Game implements CommandExecutor, Listener
  16{
  17	private Map<Player, PlayerState> players;
  18	private Config config;
  19
  20	public Game()
  21	{
  22		players = new HashMap<>();
  23	}
  24
  25	public void join(Player player)
  26	{
  27		if(players.containsKey(player))
  28		{
  29			player.sendMessage(DefaultConstants.Messages.ALREADY_INGAME);
  30
  31			return;
  32		}
  33
  34		players.put(player, PlayerState.of(player));
  35	}
  36
  37	public void leave(Player player)
  38	{
  39		PlayerState playerState = players.get(player);
  40
  41		if(playerState == null)
  42		{
  43			player.sendMessage(DefaultConstants.Messages.NOT_INGAME);
  44
  45			return;
  46		}
  47
  48		playerState.apply(player);
  49		players.remove(player);
  50	}
  51
  52	public void leaveAll()
  53	{
  54		Iterator<Entry<Player, PlayerState>> iterator = players.entrySet().iterator();
  55
  56		while(iterator.hasNext())
  57		{
  58			Entry<Player, PlayerState> entry = iterator.next();
  59			Player player = entry.getKey();
  60			PlayerState playerState = entry.getValue();
  61
  62			playerState.apply(player);
  63			iterator.remove();
  64		}
  65	}
  66
  67	public boolean isIngame(Player player)
  68	{
  69		return player != null && players.containsKey(player);
  70	}
  71
  72	public Map<Player, PlayerState> getPlayers()
  73	{
  74		return players;
  75	}
  76
  77	public void setConfig(Config config)
  78	{
  79		this.config = config;
  80	}
  81
  82	public Config getConfig()
  83	{
  84		return config;
  85	}
  86}
  

• src/de/typable/minecrafthub/game/PlayerState.java [new file]

  1package de.typable.minecrafthub.game;
  2
  3import java.util.UUID;
  4
  5import org.bukkit.GameMode;
  6import org.bukkit.Location;
  7import org.bukkit.entity.Player;
  8import org.bukkit.inventory.ItemStack;
  9
  10public class PlayerState
  11{
  12	private UUID uuid;
  13	private Double health;
  14	private Integer foodLevel;
  15	private Integer level;
  16	private Float exp;
  17	private Location location;
  18	private GameMode gameMode;
  19	private ItemStack[] equipment;
  20
  21	public static PlayerState of(Player player)
  22	{
  23		PlayerState playerState = new PlayerState();
  24
  25		playerState.setUUID(player.getUniqueId());
  26		playerState.setHealth(player.getHealth());
  27		playerState.setFoodLevel(player.getFoodLevel());
  28		playerState.setLevel(player.getLevel());
  29		playerState.setExp(player.getExp());
  30		playerState.setLocation(player.getLocation());
  31		playerState.setGameMode(player.getGameMode());
  32		playerState.setEquipment(player.getInventory().getContents());
  33
  34		return playerState;
  35	}
  36
  37	public void apply(Player player)
  38	{
  39		if(!player.getUniqueId().equals(uuid))
  40		{
  41			throw new IllegalArgumentException("Only the player with the same UUID as the state can recieve it!");
  42		}
  43
  44		player.setHealth(health);
  45		player.setFoodLevel(foodLevel);
  46		player.setLevel(level);
  47		player.setExp(exp);
  48		player.teleport(location);
  49		player.setGameMode(gameMode);
  50		player.getInventory().setContents(equipment);
  51		// equipment
  52	}
  53
  54	public UUID getUUID()
  55	{
  56		return uuid;
  57	}
  58
  59	public void setUUID(UUID uuid)
  60	{
  61		this.uuid = uuid;
  62	}
  63
  64	public Double getHealth()
  65	{
  66		return health;
  67	}
  68
  69	public void setHealth(Double health)
  70	{
  71		this.health = health;
  72	}
  73
  74	public Integer getFoodLevel()
  75	{
  76		return foodLevel;
  77	}
  78
  79	public void setFoodLevel(Integer foodLevel)
  80	{
  81		this.foodLevel = foodLevel;
  82	}
  83
  84	public Integer getLevel()
  85	{
  86		return level;
  87	}
  88
  89	public void setLevel(Integer level)
  90	{
  91		this.level = level;
  92	}
  93
  94	public Float getExp()
  95	{
  96		return exp;
  97	}
  98
  99	public void setExp(Float exp)
  100	{
  101		this.exp = exp;
  102	}
  103
  104	public Location getLocation()
  105	{
  106		return location;
  107	}
  108
  109	public void setLocation(Location location)
  110	{
  111		this.location = location;
  112	}
  113
  114	public GameMode getGameMode()
  115	{
  116		return gameMode;
  117	}
  118
  119	public void setGameMode(GameMode gameMode)
  120	{
  121		this.gameMode = gameMode;
  122	}
  123
  124	public ItemStack[] getEquipment()
  125	{
  126		return equipment;
  127	}
  128
  129	public void setEquipment(ItemStack[] equipment)
  130	{
  131		this.equipment = equipment;
  132	}
  133}
  

• src/de/typable/minecrafthub/game/kit/KitGame.java [new file]

  1package de.typable.minecrafthub.game.kit;
  2
  3import org.bukkit.GameMode;
  4import org.bukkit.command.Command;
  5import org.bukkit.command.CommandSender;
  6import org.bukkit.entity.Player;
  7import org.bukkit.event.EventHandler;
  8import org.bukkit.event.block.BlockBreakEvent;
  9
  10import de.typable.minecrafthub.game.Game;
  11
  12public class KitGame extends Game
  13{
  14	public KitGame()
  15	{
  16		super();
  17	}
  18
  19	@Override
  20	public boolean onCommand(CommandSender sender, Command command, String label, String[] args)
  21	{
  22		if(sender instanceof Player)
  23		{
  24			Player player = (Player) sender;
  25
  26			if(args.length > 0)
  27			{
  28				if(args[0].equals("join"))
  29				{
  30					join(player);
  31				}
  32
  33				if(args[0].equals("leave"))
  34				{
  35					leave(player);
  36				}
  37			}
  38		}
  39
  40		return false;
  41	}
  42
  43	@Override
  44	public void join(Player player)
  45	{
  46		super.join(player);
  47		player.setGameMode(GameMode.SURVIVAL);
  48		player.getInventory().clear();
  49	}
  50
  51	@EventHandler
  52	public void onBlockBreak(BlockBreakEvent event)
  53	{
  54		if(isIngame(event.getPlayer()))
  55		{
  56			event.setCancelled(true);
  57		}
  58	}
  59}