Filled Resurrection

Discussion in 'Plugin Requests' started by SaltyPotato, Nov 2, 2015.

Thread Status:
Not open for further replies.
  1. Offline

    SaltyPotato

    Message to eventual Developer:
    Please regurally check this thread!

    =====================

    Plugin category:
    Fun


    Suggested name: Resurrection


    What I want:
    Its simple, when someone dies/gets killed, a zombie will spawn (with the players head on) with the stuff of the person who died, when that zombie gets killed, all the stuff will be dropped.
    But the zombie is harder, he has 60HP, strength 1, regen 1, and resistance 1


    Commands + Permissions (open)
    Commands:

    /resurrection difficulty <easy/normal/hard>
    Easy - Normal zombie, immune to fire
    Normal - Strength 1 Regen 1
    Hard - Strength 2 Regen 1 Resistance 1

    Permission(s):

    ressurection.admin

    This permission is for all commands.


    When I'd like it by: Whenever Possible.

    Please only make when you can add future updates.

    ============================

    Update 1:
    - Redid the thread.

    Update 2:
    - Added more wanted-features.

    Update 3:
    - Added config

    Update 4:
    - Removed the config as its not needed
     
    Last edited: Dec 20, 2015
  2. Offline

    Abstract97

    @SaltyPotato I will do this, what would you like me to build this against? 1.7 or 1.8?
     
  3. Offline

    SaltyPotato

    Both would be great ^_^


    Also, when its done, can you post it on bukkit and give me a link to it? :D
     
  4. Offline

    Scimiguy

    @SaltyPotato
    What version are you running your server on?
     
  5. Offline

    Abstract97

    @SaltyPotato

    Yes i will. I will probably upload it to Bukkit-dev.
     
  6. @Abstract97 Suggestion: give this a random chance and possibly some conditions. Also disable experience drops and normal mob loot. Reason: This can be exploited. Log on an alt and start killing it and you have a zombie warrior. Without natural mob drops being disabled, this could also be used as an experience/rotten flesh spawner. I suggest you make a configurable time limit where once a player dies and spawns their subsequent zombie, any deaths within the time limit won't spawn another.
     
  7. Offline

    Abstract97

    Last edited: Nov 2, 2015
  8. Offline

    madtomic

    Now, this is a very cool feature!

    Edit: This is on by default or there is a permission to use?

    Buggy with player inventory.
     
    Last edited: Nov 2, 2015
  9. Offline

    SaltyPotato

    I will be making my server on 1.8! :)
    Thanks
    Thanks!
    Thanks for finding this a cool feature!


    Thanks for making this @Abstract97 !
    Really appriciate it!
     
  10. Offline

    Abstract97

    Its on by default when the player joins for the first time however it can be disabled by using the command /resurrect disable <player>

    No problem man!
     
  11. Offline

    madtomic

    I'm having problem with inventory from dead player. It don't give back all the items.
     
  12. Offline

    SaltyPotato

    BUMP! Looking for new coder as the old one has discontinued the project.
     
  13. Offline

    SaltyPotato

  14. Offline

    SaltyPotato

  15. Offline

    SaltyPotato

  16. Offline

    SaltyPotato

  17. Offline

    Chloe-chan

    I'll attempt to do this.
     
  18. Offline

    SaltyPotato

    Thanks in advance

    Hello! Please check back the thread as several things has changed! :D
     
    Last edited: Dec 20, 2015
  19. Watching this thread.
    Are you working on this @Chloe-chan?
     
  20. Offline

    Chloe-chan

    If you want, you can do it. I only wanted to do it, as there were no one picking it up.
     
  21. I'm considering. I won't be able to work on anything before we're past christmas though. So take a crack at it. :)
     
  22. Offline

    SaltyPotato

    Thanks in advance.
     
  23. Offline

    20zinnm

    I think this is a pretty simple request. Should the player be able to get his stuff back from the zombie without killing it?
     
  24. Yeah, it's pretty simple :)
     
  25. Offline

    SaltyPotato

    @20zinnm

    Yeah.
     
  26. Offline

    Chloe-chan

    What do you mean by "the player is able to get their items back without killing the zombie" ? I thought that all of the items will be dropped when the zombie (which has been spawned due to the player dying) has been killed.

    Also, regen potion does not work on zombies. Do you still want it to happen ?

    ------------------------------------------------------

    Nevertheless, I've made the plugin.

    Tips (open)

    • Don't confront the zombies which are holding your inventory without any preparations !
    • About to die ? Don't hold any sword ! The zombie will hold whatever you were last holding.


    Download link here, hosted by Dropbox. Any updated versions will be using the same link.

    Commands added:
    • /reanimation
      • Aliases
        • reanimate
        • resurrection
        • ra
        • resurrect
      • /reanimation help - Returns the help message.
      • /reanimation difficulty <easy, medium, hard> - Change the difficulty of future reanimated zombies.

    Permissions added:
    • reanimation.admin - Required to use '/reanimation difficulty' command.

    Files added:
    • last-difficulty.dat - Save file for storing the last difficulty of zombies when shutting down server.
    • zombie-drops.dat - Save file for storing all of the player items that is being held by the zombie.
    • zombie-exp.dat - Save file for storing all of the player EXP dropped when they died.

    Dependencies:
    Show Spoiler
    Built on:
    • Java 1.7
    • Spigot-API-1.8.8-R0.1
    Tested on:
    • Java 1.8
    • CraftBukkit version git-Spigot-5f38d38-12698ea (MC: 1.8.8) (Implementing API version 1.8.8-R0.1-SNAPSHOT)


    Screenshots:
    Show Spoiler
    [​IMG]
    Zombie spawned in Easy difficulty, holding previous player's inventory


    Lengthy source code:
    It is unnecessarily long!
    You have been warned! (open)

    Main class (open)
    Code:
    package com.gmail.cle.surreal.plugins.reanimation;
    
    import java.io.IOException;
    import java.util.logging.Level;
    
    import org.bukkit.Bukkit;
    import org.bukkit.plugin.java.JavaPlugin;
    
    import com.gmail.cle.surreal.plugins.reanimation.utils.StorableObject;
    
    public class ReanimationMain extends JavaPlugin
    {
        private final ReanimationStorage storage = new ReanimationStorage(this);
        private ReanimationDifficulty difficulty;
    
        private StorableObject<String> previousDifficulty;
    
        @Override
        public void onEnable()
        {
            storage.load();
            try
            {
                previousDifficulty = new StorableObject<String>(getDataFolder(), "last-difficulty");
                previousDifficulty.loadFromFile();
                difficulty = ReanimationDifficulty.getDifficultyByName(previousDifficulty.getObject());
    
                if (difficulty == null)
                    difficulty = ReanimationDifficulty.MEDIUM;
            } catch (IOException | ClassNotFoundException e)
            {
                Bukkit.getLogger().log(Level.WARNING, "Unable to access/create files!", e);
                previousDifficulty = null;
                difficulty = ReanimationDifficulty.MEDIUM;
            }
    
            getCommand("reanimation").setExecutor(new ReanimationCommand(this, "reanimation"));
    
            Bukkit.getPluginManager().registerEvents(new ReanimationListener(this), this);
        }
    
        @Override
        public void onDisable()
        {
            storage.save();
            if (previousDifficulty != null)
            {
                previousDifficulty.setObject(difficulty.toString());
                try
                {
                    previousDifficulty.saveToFile();
                } catch (IOException e)
                {
                    Bukkit.getLogger().log(Level.WARNING, "Unable to save files!", e);
                }
            }
        }
    
        public ReanimationStorage getStorage()
        {
            return storage;
        }
    
        public ReanimationDifficulty getDifficulty()
        {
            return difficulty;
        }
    
        public void setDifficulty(ReanimationDifficulty difficulty)
        {
            this.difficulty = difficulty;
        }
    }

    Command handler (open)
    Code:
    package com.gmail.cle.surreal.plugins.reanimation;
    
    import java.util.ArrayList;
    
    import org.bukkit.ChatColor;
    import org.bukkit.command.Command;
    import org.bukkit.command.CommandExecutor;
    import org.bukkit.command.CommandSender;
    
    public class ReanimationCommand implements CommandExecutor
    {
        private ReanimationMain main;
    
        private final String commandName;
    
        public ReanimationCommand(ReanimationMain main, String commandName)
        {
            this.main = main;
            this.commandName = commandName;
        }
    
        @Override
        public boolean onCommand(CommandSender sender, Command command, String label, String[] args)
        {
            if (args.length == 0 || args[0].equalsIgnoreCase("help"))
            {
                ArrayList<String> helpStrings = new ArrayList<String>();
                StringBuilder aliasesSB = new StringBuilder();
    
                for (String alias : main.getCommand(commandName).getAliases())
                    aliasesSB.append(alias + ", ");
    
                helpStrings.add(ChatColor.GOLD + " ========== " + ChatColor.AQUA + "Help" + ChatColor.GOLD + " ========== ");
                helpStrings.add(ChatColor.RED + "  Available aliases" + ChatColor.AQUA + " > " + ChatColor.BLUE +
                        aliasesSB.toString().substring(0, aliasesSB.length() - 2));
                helpStrings.add(helpBuilder("%name help", "Shows this help list."));
                helpStrings.add(helpBuilder("%name difficulty <easy/medium/hard>", "Change the difficulty of future reanimated zombies."));
                helpStrings.add(ChatColor.GOLD + " ========================= ");
    
                sender.sendMessage(helpStrings.toArray(new String[helpStrings.size()]));
    
                return true;
            }
    
            if (args[0].equalsIgnoreCase("difficulty") || args[0].equalsIgnoreCase("diff") || args[0].equalsIgnoreCase("d"))
            {
                if (args.length > 1)
                {
                    if (sender.hasPermission("reanimation.admin"))
                    {
                        ReanimationDifficulty diff = ReanimationDifficulty.getDifficultyByName(args[1]);
                        if (diff == null)
                        {
                            sender.sendMessage(ChatColor.RED + "Unknown difficulty '" + ChatColor.GOLD + args[1] + ChatColor.RED + "'!");
                            return true;
                        }
                        main.setDifficulty(diff);
                        sender.sendMessage(ChatColor.AQUA + "Difficulty changed to " + diff.getTagColour() + diff + ChatColor.AQUA + ".");
                        return true;
                    } else
                    {
                        sender.sendMessage(ChatColor.RED + "You do not have permissions to run this command!");
                        return true;
                    }
                } else
                {
                    ReanimationDifficulty diff = main.getDifficulty();
                    sender.sendMessage(ChatColor.AQUA + "Current zombie difficulty: " + diff.getTagColour() + diff);
                    return true;
                }
            }
    
            return false;
        }
    
        private String helpBuilder(String name, String desc)
        {
            StringBuilder sb = new StringBuilder();
            name = name.replaceAll("%name", commandName);
    
            sb.append(ChatColor.RED);
            sb.append("/");
            sb.append(name);
            sb.append(ChatColor.AQUA);
            sb.append(" - ");
            sb.append(ChatColor.GREEN);
            sb.append(desc);
    
            return sb.toString();
        }
    }

    Difficulty enum (open)
    Code:
    package com.gmail.cle.surreal.plugins.reanimation;
    
    import org.bukkit.ChatColor;
    
    public enum ReanimationDifficulty
    {
        EASY(ChatColor.GREEN, "easy", "ez", "e"),
        MEDIUM(ChatColor.YELLOW, "medium", "med", "m", "normal", "norm", "n"),
        HARD(ChatColor.RED, "hard", "h", "difficult", "diff", "d");
    
        private ChatColor tagColour;
        private String[] aliases;
    
        private ReanimationDifficulty(ChatColor tagColour, String... aliases)
        {
            this.tagColour = tagColour;
            this.aliases = aliases;
        }
    
        public String[] getAliases()
        {
            return aliases;
        }
    
        public String getTagColour()
        {
            return tagColour.toString();
        }
    
        public static ReanimationDifficulty getDifficultyByName(String name)
        {
            for (ReanimationDifficulty diff : ReanimationDifficulty.values())
                for (String alias : diff.getAliases())
                    if (alias.equalsIgnoreCase(name))
                        return diff;
    
            return null;
        }
    
        @Override
        public String toString()
        {
            String name = "";
            String origName = this.name().toLowerCase();
    
            name += Character.toUpperCase(origName.charAt(0));
            name += origName.substring(1);
    
            return name;
        }
    }

    Event listener (open)
    Code:
    package com.gmail.cle.surreal.plugins.reanimation;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.UUID;
    
    import org.bukkit.Material;
    import org.bukkit.entity.EntityType;
    import org.bukkit.entity.LivingEntity;
    import org.bukkit.entity.Player;
    import org.bukkit.entity.Zombie;
    import org.bukkit.event.EventHandler;
    import org.bukkit.event.EventPriority;
    import org.bukkit.event.Listener;
    import org.bukkit.event.entity.EntityDeathEvent;
    import org.bukkit.event.entity.PlayerDeathEvent;
    import org.bukkit.inventory.EntityEquipment;
    import org.bukkit.inventory.ItemStack;
    import org.bukkit.inventory.meta.SkullMeta;
    import org.bukkit.potion.PotionEffect;
    import org.bukkit.potion.PotionEffectType;
    
    public class ReanimationListener implements Listener
    {
        private ReanimationMain main;
    
        public ReanimationListener(ReanimationMain main)
        {
            this.main = main;
        }
    
        @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
        public void onPlayerDeath(PlayerDeathEvent event)
        {
            Player player = event.getEntity();
            List<ItemStack> drops = event.getDrops();
            int exp = event.getDroppedExp();
            EntityEquipment playerEquipment = player.getEquipment();
            ReanimationDifficulty diff = main.getDifficulty();
    
            if (drops.isEmpty())
                return;
    
            for (ItemStack item : player.getEquipment().getArmorContents())
                drops.remove(item);
    
            Zombie zombie = (Zombie) player.getWorld().spawnEntity(player.getLocation(), EntityType.ZOMBIE);
            EntityEquipment zombieEquiment = zombie.getEquipment();
            zombie.setRemoveWhenFarAway(false);
    
            zombieEquiment.setHelmet(playerEquipment.getHelmet());
            zombieEquiment.setChestplate(playerEquipment.getChestplate());
            zombieEquiment.setLeggings(playerEquipment.getLeggings());
            zombieEquiment.setBoots(playerEquipment.getBoots());
            zombieEquiment.setItemInHand(playerEquipment.getItemInHand());
            if (zombieEquiment.getHelmet().getType() == Material.AIR)
            {
                ItemStack playerHead = new ItemStack(Material.SKULL_ITEM, 1, (short) 3);
                SkullMeta skullMeta = (SkullMeta) playerHead.getItemMeta();
                skullMeta.setOwner(player.getName());
                playerHead.setItemMeta(skullMeta);
                zombieEquiment.setHelmet(playerHead);
            }
    
            zombie.setTarget(null);
            zombie.setMaxHealth(60);
            zombie.setHealth(zombie.getMaxHealth());
            zombie.addPotionEffect(new PotionEffect(PotionEffectType.FIRE_RESISTANCE, Integer.MAX_VALUE, 1, true), true);
            switch (diff)
            {
                case MEDIUM:
                    zombie.addPotionEffect(new PotionEffect(PotionEffectType.INCREASE_DAMAGE, Integer.MAX_VALUE, 1, true), true);
                    // Regen
                    break;
    
                case HARD:
                    zombie.addPotionEffect(new PotionEffect(PotionEffectType.INCREASE_DAMAGE, Integer.MAX_VALUE, 2, true), true);
                    zombie.addPotionEffect(new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, Integer.MAX_VALUE, 1, true), true);
                    // Regen
                    break;
    
                default:
                    break;
            }
            zombie.setCustomName(diff.getTagColour() + player.getName());
            zombie.setCustomNameVisible(true);
    
            main.getStorage().putDrops(zombie.getUniqueId(), new ArrayList<ItemStack>(drops));
            if (!event.getKeepLevel())
                main.getStorage().putExp(zombie.getUniqueId(), exp);
    
            drops.clear();
        }
    
        @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
        public void onZombieDeath(EntityDeathEvent event)
        {
            LivingEntity entity = event.getEntity();
            UUID uuid = entity.getUniqueId();
    
            if (event.getEntityType() != EntityType.ZOMBIE)
                return;
            if (!main.getStorage().containsDrops(uuid))
                return;
    
            event.getDrops().clear();
            event.getDrops().addAll(main.getStorage().getDrops(uuid));
            if (entity.getEquipment().getHelmet() != null)
            {
                ItemStack helm = entity.getEquipment().getHelmet();
                if (helm.getType() == Material.SKULL_ITEM && helm.getDurability() == 3)
                    entity.getEquipment().setHelmet(null);
            }
            for (ItemStack item : entity.getEquipment().getArmorContents())
                event.getDrops().add(item);
            event.setDroppedExp(main.getStorage().containsExp(uuid) ? main.getStorage().getExp(uuid) : 0);
    
            main.getStorage().removeDrops(uuid);
            main.getStorage().removeExp(uuid);
        }
    }

    Storage (open)
    Code:
    package com.gmail.cle.surreal.plugins.reanimation;
    
    import java.io.IOException;
    import java.util.List;
    import java.util.UUID;
    import java.util.logging.Level;
    
    import org.bukkit.Bukkit;
    import org.bukkit.inventory.ItemStack;
    
    import com.gmail.cle.surreal.plugins.reanimation.utils.StorableHashMap;
    
    public class ReanimationStorage
    {
        private ReanimationMain main;
    
        private StorableHashMap<UUID, List<ItemStack>> zombieDrops;
        private StorableHashMap<UUID, Integer> zombieExp;
    
        public ReanimationStorage(ReanimationMain main)
        {
            this.main = main;
    
            try
            {
                zombieDrops = new StorableHashMap<UUID, List<ItemStack>>(this.main.getDataFolder(), "zombie-drops");
                zombieExp = new StorableHashMap<UUID, Integer>(this.main.getDataFolder(), "zombie-exp");
            } catch (IOException e)
            {
                Bukkit.getLogger().log(Level.SEVERE, "Error creating/accessing files!", e);
            }
        }
    
        public void load()
        {
            try
            {
                zombieDrops.loadFromFile();
                zombieExp.loadFromFile();
            } catch (ClassNotFoundException | IOException e)
            {
                Bukkit.getLogger().log(Level.SEVERE, "Error loading files!", e);
            }
        }
    
        public void save()
        {
            try
            {
                zombieDrops.saveToFile();
                zombieExp.saveToFile();
            } catch (IOException e)
            {
                Bukkit.getLogger().log(Level.SEVERE, "Error saving files!", e);
            }
        }
    
        public boolean containsDrops(UUID uuid)
        {
            return zombieDrops.containsKey(uuid);
        }
    
        public void putDrops(UUID uuid, List<ItemStack> items)
        {
            zombieDrops.put(uuid, items);
        }
    
        public List<ItemStack> getDrops(UUID uuid)
        {
            return zombieDrops.get(uuid);
        }
    
        public List<ItemStack> removeDrops(UUID uuid)
        {
            return zombieDrops.remove(uuid);
        }
    
        public boolean containsExp(UUID uuid)
        {
            return zombieExp.containsKey(uuid);
        }
    
        public void putExp(UUID uuid, int exp)
        {
            zombieExp.put(uuid, exp);
        }
    
        public int getExp(UUID uuid)
        {
            return zombieExp.get(uuid);
        }
    
        public void removeExp(UUID uuid)
        {
            zombieExp.remove(uuid);
        }
    }


    Extra utilities of my own:
    StorableHashMap (open)
    Code:
    package com.gmail.cle.surreal.plugins.reanimation.utils;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.Serializable;
    import java.util.HashMap;
    
    import org.bukkit.util.io.BukkitObjectInputStream;
    import org.bukkit.util.io.BukkitObjectOutputStream;
    
    public class StorableHashMap<K, V> extends HashMap<K, V> implements Serializable
    {
        private static final long serialVersionUID = -3535879180214628774L;
    
        private transient final String extension = ".dat";
    
        private transient File parentFolder;
        private transient File saveFile;
    
        public StorableHashMap(File parentFolder, String fileName) throws IOException
        {
            super();
            initialise(parentFolder, fileName);
        }
    
        public StorableHashMap(int initialCapacity, File parentFolder, String fileName) throws IOException
        {
            super(initialCapacity);
            initialise(parentFolder, fileName);
        }
    
        public StorableHashMap(int initialCapacity, float loadFactor, File parentFolder, String fileName) throws IOException
        {
            super(initialCapacity, loadFactor);
            initialise(parentFolder, fileName);
        }
    
        public StorableHashMap(HashMap<K, V> m, File parentFolder, String fileName) throws IOException
        {
            super(m);
            initialise(parentFolder, fileName);
        }
    
        private void initialise(File parentFolder, String fileName) throws IOException
        {
            this.parentFolder = parentFolder;
            this.saveFile = new File(this.parentFolder, fileName + extension);
            createFile();
        }
    
        public boolean createFile() throws IOException
        {
            if (!parentFolder.exists() && !parentFolder.mkdirs())
                return false;
            if (!saveFile.exists() && !saveFile.createNewFile())
                return false;
    
            return true;
        }
    
        @SuppressWarnings("unchecked")
        public void loadFromFile() throws FileNotFoundException, IOException, ClassNotFoundException
        {
            if (saveFile.length() > 0)
            {
                try (FileInputStream fileIn = new FileInputStream(saveFile);
                        BukkitObjectInputStream objectIn = new BukkitObjectInputStream(fileIn))
                {
                    StorableHashMap<K, V> map = (StorableHashMap<K, V>) objectIn.readObject();
                    super.clear();
                    super.putAll(map);
                }
            }
        }
    
        public void saveToFile() throws FileNotFoundException, IOException
        {
            try (FileOutputStream fileOut = new FileOutputStream(saveFile);
                    BukkitObjectOutputStream objectOut = new BukkitObjectOutputStream(fileOut))
            {
                objectOut.writeObject(this);
            }
        }
    }

    StorableObject (open)
    Code:
    package com.gmail.cle.surreal.plugins.reanimation.utils;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class StorableObject<T extends Serializable>
    {
        private transient final String extension = ".dat";
    
        private transient File parentFolder;
        private transient File currentFile;
    
        private T object;
    
        public StorableObject(File parentFolder, String fileName) throws IOException
        {
            this(parentFolder, fileName, null);
        }
    
        public StorableObject(File parentFolder, String fileName, T object) throws IOException
        {
            this.parentFolder = parentFolder;
            this.currentFile = new File(parentFolder, fileName + extension);
            this.object = object;
    
            createFile();
        }
    
        public boolean createFile() throws IOException
        {
            if (!parentFolder.exists() && !parentFolder.mkdirs())
                return false;
            if (!currentFile.exists() && !currentFile.createNewFile())
                return false;
    
            return true;
        }
    
        @SuppressWarnings("unchecked")
        public void loadFromFile() throws FileNotFoundException, IOException, ClassNotFoundException
        {
            if (currentFile.length() > 0)
            {
                try (FileInputStream fileIn = new FileInputStream(currentFile);
                        ObjectInputStream objectIn = new ObjectInputStream(fileIn);)
                {
                    object = (T) objectIn.readObject();
                }
            }
        }
    
        public void saveToFile() throws FileNotFoundException, IOException
        {
            try (FileOutputStream fileOut = new FileOutputStream(currentFile);
                    ObjectOutputStream objectOut = new ObjectOutputStream(fileOut);)
            {
                objectOut.writeObject(object);
            }
        }
    
        public T getObject()
        {
            return object;
        }
    
        public void setObject(T object)
        {
            this.object = object;
        }
    }



    To moderators: It would be nice to not merge both posts. :p

    EDIT by Moderator: merged posts, please use the edit button instead of double posting.

    EDIT: Darnit merge bot. :(
     
    Last edited: Dec 25, 2015
  27. Haha. Cool :)
     
  28. Offline

    SaltyPotato

    Thank you!
    Oh yeah, regen doesnt work..
    Sorry for this late thing, but can you maybe add it so when the zombie is killed, a chest spawns with the loot? (And after 5 min the chest will break and all stuff will go away?) This is optional ;-)

    But thanks alot for making this!


    ==
    EDIT: oops, it seems there is a problem ? Ive tested out the plugin today but it seems there doesnt spawn a zombie when i die? Im running on Spigot 1.8.8 R01, did i do something wrong? :p
     
    Last edited: Dec 24, 2015
  29. Offline

    Chloe-chan

    Yes the regen doesn't work on zombie. Do you still want the regen feature for the zombies ? I can manually add their health, simulating a regen effect.

    There is a problem with the spawning of chest, as you can never be sure of what will be at the block that is replaced by the chest. I wouldn't want players to abuse that feature to see through blocks, or to manipulate block replacement. If you are confident and really want the chest to spawn with the inventory, let me know ! I don't mind adding it, as long as you are well-informed of the risks. :)

    EDIT: Do you have any items in your inventory ? Or is there any error in the console ? I disabled spawning of zombies if there are nothing in your inventory, as I find it pretty pointless. :p
     
Thread Status:
Not open for further replies.

Share This Page