Item Map added
This commit is contained in:
Sam
parent
da28254af0
commit
a879a1dc80
|
|
@ -1,158 +1,3 @@
|
|||
<<<<<<< HEAD
|
||||
package mineplex.core.gadget.gadgets.taunts;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.Color;
|
||||
import org.bukkit.FireworkEffect;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.Sound;
|
||||
import org.bukkit.entity.Item;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.EventHandler;
|
||||
import org.bukkit.event.player.PlayerJoinEvent;
|
||||
import org.bukkit.event.player.PlayerPickupItemEvent;
|
||||
import org.bukkit.util.Vector;
|
||||
|
||||
import mineplex.core.common.Rank;
|
||||
import mineplex.core.common.util.C;
|
||||
import mineplex.core.common.util.F;
|
||||
import mineplex.core.common.util.LineFormat;
|
||||
import mineplex.core.common.util.UtilAction;
|
||||
import mineplex.core.common.util.UtilFirework;
|
||||
import mineplex.core.common.util.UtilText;
|
||||
import mineplex.core.disguise.disguises.DisguiseSkeleton;
|
||||
import mineplex.core.events.EnableArcadeSpawnEvent;
|
||||
import mineplex.core.gadget.GadgetManager;
|
||||
import mineplex.core.gadget.gadgets.morph.managers.UtilMorph;
|
||||
import mineplex.core.gadget.types.TauntGadget;
|
||||
import mineplex.core.itemstack.ItemStackFactory;
|
||||
import mineplex.core.recharge.Recharge;
|
||||
import mineplex.core.updater.UpdateType;
|
||||
|
||||
public class EternalTaunt extends TauntGadget
|
||||
{
|
||||
|
||||
private static final int COOLDOWN = 30000;
|
||||
private static final int PVP_COOLDOWN = 10000;
|
||||
|
||||
private Map<UUID, List<Item>> _clocks = new HashMap<>();
|
||||
|
||||
public EternalTaunt(GadgetManager manager)
|
||||
{
|
||||
super(manager, "Eternal Taunt", UtilText.splitLinesToArray(new String[]{C.cGray + "Although the Eternal has been around forever, he waited too long for a worthy opponent and he turned to bones.",
|
||||
"",
|
||||
C.cWhite + "Use /taunt in game to show how long you've been waiting.",
|
||||
C.cRed + "Cannot be used while in PvP!"}, LineFormat.LORE),
|
||||
-15, Material.WATCH, (byte) 0);
|
||||
setCanPlayWithPvp(false);
|
||||
setPvpCooldown(PVP_COOLDOWN);
|
||||
setShouldPlay(true);
|
||||
setEventType(UpdateType.FAST);
|
||||
addDisabledGames(GameType.SMASH, GameType.SMASHTEAMS, GameType.SMASHDOMINATION);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void disableCustom(Player player, boolean message)
|
||||
{
|
||||
finish(player);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onStart(Player player)
|
||||
{
|
||||
if (!Recharge.Instance.use(player, getName(), COOLDOWN, true, false, "Cosmetics"))
|
||||
return;
|
||||
UtilFirework.playFirework(player.getLocation(), FireworkEffect.builder().with(FireworkEffect.Type.BALL_LARGE).withColor(Color.fromRGB(255, 175, 175)).withFade(Color.RED).build());
|
||||
|
||||
_clocks.put(player.getUniqueId(), new ArrayList<>());
|
||||
|
||||
Bukkit.broadcastMessage(F.main("Taunt", F.name(player.getName()) + " waited so long they turned to bones."));
|
||||
|
||||
DisguiseSkeleton disguiseSkeleton = new DisguiseSkeleton(player);
|
||||
UtilMorph.disguise(player, disguiseSkeleton, Manager);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onPlay(Player player)
|
||||
{
|
||||
if (!_clocks.containsKey(player.getUniqueId()))
|
||||
return;
|
||||
|
||||
int i = getPlayerTicks(player);
|
||||
|
||||
EnableArcadeSpawnEvent enableArcadeSpawnEvent = new EnableArcadeSpawnEvent(true);
|
||||
Bukkit.getPluginManager().callEvent(enableArcadeSpawnEvent);
|
||||
|
||||
Item clock = player.getWorld().dropItem(player.getLocation().add(0.5, 1.5, 0.5),
|
||||
ItemStackFactory.Instance.CreateStack(Material.WATCH, (byte) 0, 1, " " + i));
|
||||
|
||||
enableArcadeSpawnEvent = new EnableArcadeSpawnEvent(false);
|
||||
Bukkit.getPluginManager().callEvent(enableArcadeSpawnEvent);
|
||||
|
||||
Vector vel = new Vector(Math.sin(i * 9/5d), 0, Math.cos(i * 9/5d));
|
||||
UtilAction.velocity(clock, vel, Math.abs(Math.sin(i * 12/3000d)), false, 0, 0.2 + Math.abs(Math.cos(i * 12/3000d))*0.6, 1, false);
|
||||
|
||||
_clocks.get(player.getUniqueId()).add(clock);
|
||||
|
||||
if (_clocks.get(player.getUniqueId()).size() >= 5)
|
||||
{
|
||||
_clocks.get(player.getUniqueId()).get(0).remove();
|
||||
_clocks.get(player.getUniqueId()).remove(0);
|
||||
}
|
||||
|
||||
if (i % 2 == 0)
|
||||
player.playSound(player.getLocation(), Sound.CLICK, 1f, 1f);
|
||||
else
|
||||
player.playSound(player.getLocation(), Sound.CLICK, 0.5f, 0.5f);
|
||||
|
||||
if (i >= 15)
|
||||
{
|
||||
finish(player);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onFinish(Player player)
|
||||
{
|
||||
UtilMorph.undisguise(player, Manager.getDisguiseManager());
|
||||
if (_clocks.containsKey(player.getUniqueId()))
|
||||
{
|
||||
_clocks.get(player.getUniqueId()).forEach(c -> c.remove());
|
||||
_clocks.get(player.getUniqueId()).clear();
|
||||
_clocks.remove(player.getUniqueId());
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void titanOwner(PlayerJoinEvent event)
|
||||
{
|
||||
if (Manager.getClientManager().Get(event.getPlayer()).GetRank().has(Rank.ETERNAL))
|
||||
{
|
||||
Manager.getDonationManager().Get(event.getPlayer()).addOwnedUnknownSalesPackage(getName());
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onClockPickup(PlayerPickupItemEvent event)
|
||||
{
|
||||
for (List<Item> clocks : _clocks.values())
|
||||
{
|
||||
for (Item item : clocks)
|
||||
{
|
||||
if (event.getItem().equals(item))
|
||||
event.setCancelled(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
=======
|
||||
package mineplex.core.gadget.gadgets.taunts;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
|
@ -300,4 +145,3 @@ public class EternalTaunt extends TauntGadget
|
|||
}
|
||||
|
||||
}
|
||||
>>>>>>> refs/remotes/origin/develop
|
||||
|
|
|
|||
|
|
@ -1,161 +1,3 @@
|
|||
<<<<<<< HEAD
|
||||
package mineplex.core.gadget.types;
|
||||
|
||||
import java.time.YearMonth;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.EventHandler;
|
||||
|
||||
import mineplex.core.gadget.GadgetManager;
|
||||
import mineplex.core.gadget.gadgets.taunts.GameType;
|
||||
import mineplex.core.updater.UpdateType;
|
||||
import mineplex.core.updater.event.UpdateEvent;
|
||||
|
||||
/**
|
||||
* Handles Taunts
|
||||
*/
|
||||
public abstract class TauntGadget extends Gadget
|
||||
{
|
||||
|
||||
/** Sets if this specific taunt can be used while in PvP */
|
||||
private boolean _canPlayWithPvp = false;
|
||||
/** Sets the cooldown for pvp */
|
||||
private long _pvpCooldown = 0;
|
||||
/** Sets if this taunt needs to run on updates */
|
||||
private boolean _shouldPlay = false;
|
||||
/** Sets when the taunt will run, if set above */
|
||||
private UpdateType _updateType = UpdateType.TICK;
|
||||
/** List of games where this item is disabled */
|
||||
private List<GameType> _disabledGames = new ArrayList<>();
|
||||
/** The ticks that passed since the player started the effect */
|
||||
private Map<UUID, Integer> _ticksPerPlayer = new HashMap<>();
|
||||
|
||||
/**
|
||||
* @param manager The normal GadgetManager
|
||||
* @param name The name of the item
|
||||
* @param desc The lore/description of the item
|
||||
* @param cost The cost of the item
|
||||
* @param mat The display material of the item
|
||||
* @param data The display data of the item
|
||||
* @param alternativeSalesPackageNames Possible alternative names for this package
|
||||
*/
|
||||
public TauntGadget(GadgetManager manager, String name, String[] desc, int cost, Material mat, byte data,
|
||||
String... alternativeSalesPackageNames)
|
||||
{
|
||||
super(manager, GadgetType.TAUNT, name, desc, cost, mat, data, 1, alternativeSalesPackageNames);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param manager The normal GadgetManager
|
||||
* @param name The name of the item
|
||||
* @param desc The lore/description of the item
|
||||
* @param cost The cost of the item
|
||||
* @param mat The display material of the item
|
||||
* @param data The display data of the item
|
||||
* @param yearMonth The year and month of this item, if it is a PPC item
|
||||
* @param alternativeSalesPackageNames Possible alternative names for this package
|
||||
*/
|
||||
public TauntGadget(GadgetManager manager, String name, String[] desc, int cost, Material mat, byte data,
|
||||
YearMonth yearMonth, String... alternativeSalesPackageNames)
|
||||
{
|
||||
super(manager, GadgetType.TAUNT, name, desc, cost, mat, data, yearMonth, 1, alternativeSalesPackageNames);
|
||||
}
|
||||
|
||||
public void start(Player player)
|
||||
{
|
||||
onStart(player);
|
||||
_ticksPerPlayer.put(player.getUniqueId(), 0);
|
||||
}
|
||||
|
||||
public abstract void onStart(Player player);
|
||||
|
||||
public void play(Player player)
|
||||
{
|
||||
onPlay(player);
|
||||
int ticks = getPlayerTicks(player) + 1;
|
||||
_ticksPerPlayer.put(player.getUniqueId(), ticks);
|
||||
}
|
||||
|
||||
public abstract void onPlay(Player player);
|
||||
|
||||
public void finish(Player player)
|
||||
{
|
||||
onFinish(player);
|
||||
_ticksPerPlayer.remove(player.getUniqueId());
|
||||
}
|
||||
|
||||
public abstract void onFinish(Player player);
|
||||
|
||||
public void setCanPlayWithPvp(boolean canPlayWithPvp)
|
||||
{
|
||||
_canPlayWithPvp = canPlayWithPvp;
|
||||
}
|
||||
|
||||
public void setPvpCooldown(long pvpCooldown)
|
||||
{
|
||||
_pvpCooldown = pvpCooldown;
|
||||
}
|
||||
|
||||
public void setShouldPlay(boolean shouldPlay)
|
||||
{
|
||||
_shouldPlay = shouldPlay;
|
||||
}
|
||||
|
||||
public void setEventType(UpdateType updateType)
|
||||
{
|
||||
_updateType = updateType;
|
||||
}
|
||||
|
||||
public void addDisabledGames(GameType... disabledGames)
|
||||
{
|
||||
_disabledGames.addAll(Arrays.asList(disabledGames));
|
||||
}
|
||||
|
||||
public boolean canPlayWithPvp()
|
||||
{
|
||||
return _canPlayWithPvp;
|
||||
}
|
||||
|
||||
public boolean isGameDisabled(GameType gameType)
|
||||
{
|
||||
return _disabledGames.contains(gameType);
|
||||
}
|
||||
|
||||
public long getPvpCooldown()
|
||||
{
|
||||
return _pvpCooldown;
|
||||
}
|
||||
|
||||
public int getPlayerTicks(Player player)
|
||||
{
|
||||
return (_ticksPerPlayer.containsKey(player.getUniqueId())) ? _ticksPerPlayer.get(player.getUniqueId()) : -1;
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onUpdate(UpdateEvent event)
|
||||
{
|
||||
if (!_shouldPlay)
|
||||
return;
|
||||
|
||||
if (event.getType() != _updateType)
|
||||
return;
|
||||
|
||||
for (Player player : getActive())
|
||||
{
|
||||
if (_ticksPerPlayer.containsKey(player.getUniqueId()))
|
||||
play(player);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
=======
|
||||
package mineplex.core.gadget.types;
|
||||
|
||||
import java.time.YearMonth;
|
||||
|
|
@ -318,4 +160,3 @@ public abstract class TauntGadget extends Gadget
|
|||
}
|
||||
|
||||
}
|
||||
>>>>>>> refs/remotes/origin/develop
|
||||
|
|
|
|||
|
|
@ -1,56 +1,3 @@
|
|||
<<<<<<< HEAD
|
||||
package mineplex.core.particleeffects;
|
||||
|
||||
import org.bukkit.Color;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.plugin.java.JavaPlugin;
|
||||
import org.bukkit.util.Vector;
|
||||
|
||||
import mineplex.core.common.util.UtilParticle;
|
||||
import mineplex.core.common.util.particles.ColoredParticle;
|
||||
import mineplex.core.common.util.particles.DustSpellColor;
|
||||
|
||||
public class LineEffect extends Effect
|
||||
{
|
||||
|
||||
private int _particles = 100;
|
||||
private Color _color;
|
||||
private int _count = 0;
|
||||
private Vector _vector;
|
||||
private Location _fixedLoc;
|
||||
|
||||
public LineEffect(JavaPlugin plugin, Location location, Location target, Color color)
|
||||
{
|
||||
super(-1, new EffectLocation(location), plugin);
|
||||
setTargetLocation(new EffectLocation(target));
|
||||
_color = color;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void runEffect()
|
||||
{
|
||||
Location location = _effectLocation.getFixedLocation().clone().add(0, 1, 0);
|
||||
if (_vector == null)
|
||||
{
|
||||
Location targetLoc = getTargetLocation().getFixedLocation().clone();
|
||||
Vector link = targetLoc.toVector().subtract(location.toVector());
|
||||
float length = (float) link.length();
|
||||
link.normalize();
|
||||
Vector vector = link.multiply(length / _particles);
|
||||
_vector = vector;
|
||||
_fixedLoc = location.clone().subtract(_vector);
|
||||
}
|
||||
ColoredParticle coloredParticle = new ColoredParticle(UtilParticle.ParticleType.RED_DUST,
|
||||
new DustSpellColor(_color), _effectLocation.getLocation().clone());
|
||||
_fixedLoc.add(_vector);
|
||||
if (_count == _particles)
|
||||
{
|
||||
stop();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
=======
|
||||
package mineplex.core.particleeffects;
|
||||
|
||||
import java.awt.Color;
|
||||
|
|
@ -103,4 +50,3 @@ public class LineEffect extends Effect
|
|||
}
|
||||
|
||||
}
|
||||
>>>>>>> refs/remotes/origin/develop
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ import mineplex.core.chat.Chat;
|
|||
import mineplex.core.command.CommandCenter;
|
||||
import mineplex.core.common.Constants;
|
||||
import mineplex.core.common.events.ServerShutdownEvent;
|
||||
import mineplex.core.communities.CommunityManager;
|
||||
import mineplex.core.creature.Creature;
|
||||
import mineplex.core.delayedtask.DelayedTask;
|
||||
import mineplex.core.disguise.DisguiseManager;
|
||||
|
|
@ -30,7 +31,6 @@ import mineplex.core.give.Give;
|
|||
import mineplex.core.hologram.HologramManager;
|
||||
import mineplex.core.ignore.IgnoreManager;
|
||||
import mineplex.core.incognito.IncognitoManager;
|
||||
import mineplex.core.inventory.InventoryManager;
|
||||
import mineplex.core.itemstack.ItemStackFactory;
|
||||
import mineplex.core.memory.MemoryFix;
|
||||
import mineplex.core.message.MessageManager;
|
||||
|
|
@ -57,12 +57,12 @@ import mineplex.gemhunters.economy.CashOutModule;
|
|||
import mineplex.gemhunters.economy.EconomyModule;
|
||||
import mineplex.gemhunters.loot.InventoryModule;
|
||||
import mineplex.gemhunters.loot.LootModule;
|
||||
import mineplex.gemhunters.map.ItemMapModule;
|
||||
import mineplex.gemhunters.safezone.SafezoneModule;
|
||||
import mineplex.gemhunters.scoreboard.ScoreboardModule;
|
||||
import mineplex.gemhunters.shop.ShopModule;
|
||||
import mineplex.gemhunters.spawn.SpawnModule;
|
||||
import mineplex.gemhunters.supplydrop.SupplyDropModule;
|
||||
import mineplex.gemhunters.world.TimeCycle;
|
||||
import mineplex.gemhunters.world.WorldListeners;
|
||||
import mineplex.gemhunters.worldevent.WorldEventModule;
|
||||
import mineplex.minecraft.game.core.combat.CombatManager;
|
||||
|
|
@ -158,7 +158,7 @@ public class GemHunters extends JavaPlugin
|
|||
new DamageManager(this, new CombatManager(this), new NpcManager(this, creature), disguiseManager, new ConditionManager(this));
|
||||
|
||||
// GWEN
|
||||
// require(AntiHack.class);
|
||||
//require(AntiHack.class);
|
||||
|
||||
// Block Restore
|
||||
BlockRestore blockRestore = require(BlockRestore.class);
|
||||
|
|
@ -182,6 +182,9 @@ public class GemHunters extends JavaPlugin
|
|||
// Parties
|
||||
new PartyManager();
|
||||
|
||||
// Communities
|
||||
new CommunityManager(this, clientManager);
|
||||
|
||||
// Fixes
|
||||
new MemoryFix(this);
|
||||
new FoodDupeFix(this);
|
||||
|
|
@ -193,8 +196,8 @@ public class GemHunters extends JavaPlugin
|
|||
explosion.SetTemporaryDebris(false);
|
||||
|
||||
// Inventories
|
||||
new InventoryManager(this, clientManager);
|
||||
|
||||
//new InventoryManager(this, clientManager);
|
||||
|
||||
// Reports
|
||||
// SnapshotManager snapshotManager = new SnapshotManager(this, new
|
||||
// SnapshotRepository(serverStatusManager.getCurrentServerName(),
|
||||
|
|
@ -219,6 +222,7 @@ public class GemHunters extends JavaPlugin
|
|||
require(EconomyModule.class);
|
||||
require(InventoryModule.class);
|
||||
require(LootModule.class);
|
||||
require(ItemMapModule.class);
|
||||
require(SafezoneModule.class);
|
||||
require(ScoreboardModule.class);
|
||||
require(SpawnModule.class);
|
||||
|
|
@ -226,8 +230,9 @@ public class GemHunters extends JavaPlugin
|
|||
require(SupplyDropModule.class);
|
||||
require(WorldEventModule.class);
|
||||
|
||||
// An arbitrary collection of world listeners such as block place/break, interact events etc...
|
||||
new WorldListeners(this);
|
||||
new TimeCycle(this);
|
||||
//new TimeCycle(this);
|
||||
|
||||
// UpdateEvent!!!
|
||||
new Updater(this);
|
||||
|
|
|
|||
|
|
@ -0,0 +1,991 @@
|
|||
package mineplex.gemhunters.map;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.File;
|
||||
import java.io.FileReader;
|
||||
import java.io.IOException;
|
||||
import java.io.PrintWriter;
|
||||
import java.lang.reflect.Field;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
import java.util.HashMap;
|
||||
import java.util.LinkedList;
|
||||
import java.util.Map.Entry;
|
||||
|
||||
import org.apache.commons.io.FileUtils;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.craftbukkit.v1_8_R3.CraftChunk;
|
||||
import org.bukkit.craftbukkit.v1_8_R3.CraftWorld;
|
||||
import org.bukkit.craftbukkit.v1_8_R3.util.LongHash;
|
||||
import org.bukkit.craftbukkit.v1_8_R3.util.LongObjectHashMap;
|
||||
import org.bukkit.entity.ItemFrame;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.EventHandler;
|
||||
import org.bukkit.event.EventPriority;
|
||||
import org.bukkit.event.block.Action;
|
||||
import org.bukkit.event.entity.ItemSpawnEvent;
|
||||
import org.bukkit.event.entity.PlayerDeathEvent;
|
||||
import org.bukkit.event.player.PlayerInteractEntityEvent;
|
||||
import org.bukkit.event.player.PlayerInteractEvent;
|
||||
import org.bukkit.event.player.PlayerItemHeldEvent;
|
||||
import org.bukkit.event.player.PlayerQuitEvent;
|
||||
import org.bukkit.event.player.PlayerTeleportEvent;
|
||||
import org.bukkit.event.world.ChunkLoadEvent;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.map.MapRenderer;
|
||||
import org.bukkit.map.MapView;
|
||||
|
||||
import com.google.common.collect.HashMultiset;
|
||||
import com.google.common.collect.Iterables;
|
||||
import com.google.common.collect.Multisets;
|
||||
|
||||
import mineplex.core.MiniPlugin;
|
||||
import mineplex.core.ReflectivelyCreateMiniPlugin;
|
||||
import mineplex.core.common.util.C;
|
||||
import mineplex.core.common.util.F;
|
||||
import mineplex.core.common.util.UtilEvent;
|
||||
import mineplex.core.common.util.UtilEvent.ActionType;
|
||||
import mineplex.core.common.util.UtilInv;
|
||||
import mineplex.core.common.util.UtilItem;
|
||||
import mineplex.core.common.util.UtilPlayer;
|
||||
import mineplex.core.common.util.UtilServer;
|
||||
import mineplex.core.common.util.UtilTextBottom;
|
||||
import mineplex.core.common.util.UtilTime;
|
||||
import mineplex.core.common.util.UtilTime.TimeUnit;
|
||||
import mineplex.core.itemstack.ItemBuilder;
|
||||
import mineplex.core.portal.events.ServerTransferEvent;
|
||||
import mineplex.core.updater.UpdateType;
|
||||
import mineplex.core.updater.event.UpdateEvent;
|
||||
import mineplex.gemhunters.death.events.PlayerCustomRespawnEvent;
|
||||
import mineplex.gemhunters.spawn.SpawnModule;
|
||||
import net.minecraft.server.v1_8_R3.Block;
|
||||
import net.minecraft.server.v1_8_R3.BlockPosition;
|
||||
import net.minecraft.server.v1_8_R3.Blocks;
|
||||
import net.minecraft.server.v1_8_R3.Chunk;
|
||||
import net.minecraft.server.v1_8_R3.ChunkProviderServer;
|
||||
import net.minecraft.server.v1_8_R3.ChunkRegionLoader;
|
||||
import net.minecraft.server.v1_8_R3.IBlockData;
|
||||
import net.minecraft.server.v1_8_R3.MaterialMapColor;
|
||||
import net.minecraft.server.v1_8_R3.PersistentCollection;
|
||||
import net.minecraft.server.v1_8_R3.WorldServer;
|
||||
|
||||
/**
|
||||
* <b>All item map code was adapted from Clans.</b><br>
|
||||
*/
|
||||
@ReflectivelyCreateMiniPlugin
|
||||
public class ItemMapModule extends MiniPlugin
|
||||
{
|
||||
// Every BLOCK_SCAN_INTERVAL we add as a new region to scan
|
||||
private static final int BLOCK_SCAN_INTERVAL = 16 * 3;
|
||||
// 1536 is the width of the entire world from one borderland to the other
|
||||
private static final int HALF_WORLD_SIZE = SpawnModule.WORLD_BORDER_RADIUS;
|
||||
// This slot is where the Clans Map will go by default
|
||||
private static final int CLANS_MAP_SLOT = 8;
|
||||
|
||||
private static final String[] ZOOM_INFO;
|
||||
|
||||
static
|
||||
{
|
||||
ZOOM_INFO = new String[4];
|
||||
for (int zoomLevel = 0; zoomLevel <= 3; zoomLevel++)
|
||||
{
|
||||
StringBuilder progressBar = new StringBuilder(C.cBlue);
|
||||
|
||||
boolean colorChange = false;
|
||||
for (int i = 2; i >= 0; i--)
|
||||
{
|
||||
if (!colorChange && i < zoomLevel)
|
||||
{
|
||||
progressBar.append(C.cGray);
|
||||
colorChange = true;
|
||||
}
|
||||
char c;
|
||||
switch (i)
|
||||
{
|
||||
case 0:
|
||||
c = '█';
|
||||
break;
|
||||
case 1:
|
||||
c = '▆';
|
||||
break;
|
||||
default:
|
||||
c = '▄';
|
||||
break;
|
||||
}
|
||||
for (int a = 0; a < 4; a++)
|
||||
{
|
||||
progressBar.append(c);
|
||||
}
|
||||
|
||||
if (i > 0)
|
||||
{
|
||||
progressBar.append(" ");
|
||||
}
|
||||
}
|
||||
ZOOM_INFO[zoomLevel] = progressBar.toString();
|
||||
}
|
||||
}
|
||||
|
||||
private Comparator<Entry<Integer, Integer>> _comparator;
|
||||
private int[][] _heightMap = new int[(HALF_WORLD_SIZE * 2) + 16][];
|
||||
private HashMap<Integer, Byte[][]> _map = new HashMap<Integer, Byte[][]>();
|
||||
private short _mapId = -1;
|
||||
private HashMap<String, MapInfo> _mapInfo = new HashMap<String, MapInfo>();
|
||||
private HashMap<Integer, Integer> _scale = new HashMap<Integer, Integer>();
|
||||
// Use LinkedList because operations are either add(Entry) which is O(1) and remove(0) which is O(1) on LinkedList but O(n) on ArrayList
|
||||
private LinkedList<Entry<Integer, Integer>> _scanList = new LinkedList<Entry<Integer, Integer>>();
|
||||
private World _world;
|
||||
private WorldServer _nmsWorld;
|
||||
private ChunkProviderServer _chunkProviderServer;
|
||||
private ChunkRegionLoader _chunkRegionLoader;
|
||||
|
||||
private ItemMapModule()
|
||||
{
|
||||
super("ItemMapManager");
|
||||
|
||||
_comparator = (o1, o2) ->
|
||||
{
|
||||
// Render the places outside the map first to speed up visual errors fixing
|
||||
int outsideMap = Boolean.compare(o1.getValue() < -HALF_WORLD_SIZE, o2.getValue() < -HALF_WORLD_SIZE);
|
||||
|
||||
if (outsideMap != 0)
|
||||
{
|
||||
return -outsideMap;
|
||||
}
|
||||
|
||||
double dist1 = 0;
|
||||
double dist2 = 0;
|
||||
|
||||
for (Player player : UtilServer.getPlayers())
|
||||
{
|
||||
dist1 += getDistance(o1, player.getLocation().getX(), player.getLocation().getZ());
|
||||
dist2 += getDistance(o2, player.getLocation().getX(), player.getLocation().getZ());
|
||||
}
|
||||
|
||||
if (dist1 != dist2)
|
||||
{
|
||||
return Double.compare(dist1, dist2);
|
||||
}
|
||||
|
||||
dist1 = getDistance(o1, 0, 0);
|
||||
dist2 = getDistance(o2, 0, 0);
|
||||
|
||||
return Double.compare(dist1, dist2);
|
||||
|
||||
};
|
||||
|
||||
_scale.put(0, 1);
|
||||
// _scale.put(1, 2);
|
||||
_scale.put(1, 4);
|
||||
_scale.put(2, 8);
|
||||
_scale.put(3, 13);
|
||||
// _scale.put(5, 16);
|
||||
|
||||
for (Entry<Integer, Integer> entry : _scale.entrySet())
|
||||
{
|
||||
int size = (HALF_WORLD_SIZE * 2) / entry.getValue();
|
||||
Byte[][] bytes = new Byte[size][];
|
||||
|
||||
for (int i = 0; i < size; i++)
|
||||
{
|
||||
bytes[i] = new Byte[size];
|
||||
}
|
||||
|
||||
_map.put(entry.getKey(), bytes);
|
||||
}
|
||||
|
||||
for (int i = 0; i < _heightMap.length; i++)
|
||||
{
|
||||
_heightMap[i] = new int[_heightMap.length];
|
||||
}
|
||||
|
||||
_world = Bukkit.getWorld("world");
|
||||
|
||||
try
|
||||
{
|
||||
Field chunkLoader = ChunkProviderServer.class.getDeclaredField("chunkLoader");
|
||||
chunkLoader.setAccessible(true);
|
||||
_nmsWorld = ((CraftWorld) _world).getHandle();
|
||||
_chunkProviderServer = _nmsWorld.chunkProviderServer;
|
||||
_chunkRegionLoader = (ChunkRegionLoader) chunkLoader.get(_chunkProviderServer);
|
||||
if (_chunkRegionLoader == null)
|
||||
{
|
||||
throw new RuntimeException("Did not expect null chunkLoader");
|
||||
}
|
||||
}
|
||||
catch (ReflectiveOperationException e)
|
||||
{
|
||||
throw new RuntimeException("Could not reflectively access ChunkRegionLoader", e);
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
File file = new File("world/gem_hunters_map_id");
|
||||
File foundFile = null;
|
||||
|
||||
for (File f : new File("world/data").listFiles())
|
||||
{
|
||||
if (f.getName().startsWith("map_"))
|
||||
{
|
||||
foundFile = f;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (foundFile == null)
|
||||
{
|
||||
PersistentCollection collection = ((CraftWorld) _world).getHandle().worldMaps;
|
||||
Field f = collection.getClass().getDeclaredField("d");
|
||||
f.setAccessible(true);
|
||||
((HashMap) f.get(collection)).put("map", (short) 0);
|
||||
}
|
||||
|
||||
if (file.exists())
|
||||
{
|
||||
BufferedReader br = new BufferedReader(new FileReader(file));
|
||||
_mapId = Short.parseShort(br.readLine());
|
||||
br.close();
|
||||
|
||||
if (foundFile == null)
|
||||
{
|
||||
_mapId = -1;
|
||||
file.delete();
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int i = _mapId; i <= _mapId + 100; i++)
|
||||
{
|
||||
File file1 = new File("world/data/map_" + i + ".dat");
|
||||
|
||||
if (!file1.exists())
|
||||
{
|
||||
FileUtils.copyFile(foundFile, file1);
|
||||
}
|
||||
|
||||
setupRenderer(Bukkit.getMap((short) i));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (_mapId < 0)
|
||||
{
|
||||
MapView view = Bukkit.createMap(_world);
|
||||
_mapId = view.getId();
|
||||
setupRenderer(view);
|
||||
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
setupRenderer(Bukkit.createMap(_world));// Ensures the following 100 maps are unused
|
||||
}
|
||||
|
||||
file.createNewFile();
|
||||
|
||||
PrintWriter writer = new PrintWriter(file, "UTF-8");
|
||||
writer.print(_mapId);
|
||||
writer.close();
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
ex.printStackTrace();
|
||||
}
|
||||
|
||||
rebuildScan();
|
||||
initialScan();
|
||||
}
|
||||
|
||||
private void initialScan()
|
||||
{
|
||||
System.out.println("Beginning initial scan. There are " + _scanList.size() + " regions to scan");
|
||||
|
||||
// How many regions before logging an update (Currently set to every 20%)
|
||||
int logPer = _scanList.size() / 5;
|
||||
|
||||
while (!_scanList.isEmpty())
|
||||
{
|
||||
Entry<Integer, Integer> entry = _scanList.remove(0);
|
||||
if (_scanList.size() % logPer == 0)
|
||||
{
|
||||
System.out.println("Running initial render... " + _scanList.size() + " sections to go");
|
||||
}
|
||||
|
||||
int startingX = entry.getKey();
|
||||
int startingZ = entry.getValue();
|
||||
|
||||
boolean outsideMap = startingZ < -HALF_WORLD_SIZE;
|
||||
|
||||
scanWorldMap(startingX, startingZ, !outsideMap, true);
|
||||
|
||||
if (outsideMap)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
for (int scale = 1; scale < _scale.size(); scale++)
|
||||
{
|
||||
if (scale == 3)
|
||||
continue;
|
||||
|
||||
drawWorldScale(scale, startingX, startingZ);
|
||||
colorWorldHeight(scale, startingX, startingZ);
|
||||
}
|
||||
|
||||
colorWorldHeight(0, startingX, startingZ);
|
||||
}
|
||||
|
||||
for (int x = -HALF_WORLD_SIZE; x < HALF_WORLD_SIZE; x += BLOCK_SCAN_INTERVAL)
|
||||
{
|
||||
for (int z = -HALF_WORLD_SIZE; z < HALF_WORLD_SIZE; z += BLOCK_SCAN_INTERVAL)
|
||||
{
|
||||
drawWorldScale(3, x, z);
|
||||
colorWorldHeight(3, x, z);
|
||||
}
|
||||
}
|
||||
|
||||
System.out.println("Finished first map scan and render");
|
||||
}
|
||||
|
||||
private void setupRenderer(MapView view)
|
||||
{
|
||||
for (MapRenderer renderer : view.getRenderers())
|
||||
{
|
||||
view.removeRenderer(renderer);
|
||||
}
|
||||
|
||||
view.addRenderer(new ItemMapRenderer());
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void preventMapInItemFrame(PlayerInteractEntityEvent event)
|
||||
{
|
||||
if (!(event.getRightClicked() instanceof ItemFrame))
|
||||
return;
|
||||
|
||||
if (!isItemClansMap(event.getPlayer().getItemInHand()))
|
||||
return;
|
||||
|
||||
event.setCancelled(true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the center of the map.
|
||||
*/
|
||||
public int calcMapCenter(int zoom, int cord)
|
||||
{
|
||||
int mapSize = HALF_WORLD_SIZE / zoom; // This is how large the map is in pixels
|
||||
|
||||
int mapCord = cord / zoom; // This is pixels from true center of map, not held map
|
||||
|
||||
int fDiff = mapSize - -mapCord;
|
||||
int sDiff = mapSize - mapCord;
|
||||
|
||||
double chunkBlock = cord & 0xF;
|
||||
cord -= chunkBlock;
|
||||
chunkBlock /= zoom;
|
||||
|
||||
/*if ((fDiff < 64 || sDiff < 64) && (Math.abs(fDiff - sDiff) > 1))
|
||||
{
|
||||
cord += (fDiff > sDiff ? Math.floor(chunkBlock) : Math.ceil(chunkBlock));
|
||||
}
|
||||
else*/
|
||||
{
|
||||
cord += (int) Math.floor(chunkBlock) * zoom;
|
||||
}
|
||||
|
||||
while ((fDiff < 64 || sDiff < 64) && (Math.abs(fDiff - sDiff) > 1))
|
||||
{
|
||||
int change = (fDiff > sDiff ? -zoom : zoom);
|
||||
cord += change;
|
||||
|
||||
mapCord = cord / zoom;
|
||||
|
||||
fDiff = mapSize - -mapCord;
|
||||
sDiff = mapSize - mapCord;
|
||||
}
|
||||
|
||||
return cord;
|
||||
}
|
||||
|
||||
private void colorWorldHeight(int scale, int startingX, int startingZ)
|
||||
{
|
||||
Byte[][] map = _map.get(scale);
|
||||
int zoom = getZoom(scale);
|
||||
|
||||
for (int x = startingX; x < startingX + BLOCK_SCAN_INTERVAL; x += zoom)
|
||||
{
|
||||
double d0 = 0;
|
||||
|
||||
// Prevents ugly lines for the first line of Z
|
||||
|
||||
for (int addX = 0; addX < zoom; addX++)
|
||||
{
|
||||
for (int addZ = 0; addZ < zoom; addZ++)
|
||||
{
|
||||
int hX = x + addX + HALF_WORLD_SIZE;
|
||||
int hZ = (startingZ - zoom) + addZ + HALF_WORLD_SIZE;
|
||||
|
||||
if (hX >= HALF_WORLD_SIZE * 2 || hZ >= HALF_WORLD_SIZE * 2)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
d0 += _heightMap[hX + 16][hZ + 16] / (zoom * zoom);
|
||||
}
|
||||
}
|
||||
|
||||
for (int z = startingZ; z < startingZ + BLOCK_SCAN_INTERVAL; z += zoom)
|
||||
{
|
||||
// Water depth colors not included
|
||||
double d1 = 0;
|
||||
|
||||
for (int addX = 0; addX < zoom; addX++)
|
||||
{
|
||||
for (int addZ = 0; addZ < zoom; addZ++)
|
||||
{
|
||||
int hX = x + addX + HALF_WORLD_SIZE;
|
||||
int hZ = z + addZ + HALF_WORLD_SIZE;
|
||||
|
||||
if (hX >= HALF_WORLD_SIZE * 2 || hZ >= HALF_WORLD_SIZE * 2)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
d1 += _heightMap[hX + 16][hZ + 16] / (zoom * zoom);
|
||||
}
|
||||
}
|
||||
|
||||
double d2 = (d1 - d0) * 4.0D / (zoom + 4) + ((x + z & 0x1) - 0.5D) * 0.4D;
|
||||
byte b0 = 1;
|
||||
|
||||
d0 = d1;
|
||||
|
||||
if (d2 > 0.6D)
|
||||
{
|
||||
b0 = 2;
|
||||
}
|
||||
else if (d2 > 1.2D)
|
||||
{
|
||||
b0 = 3;
|
||||
}
|
||||
else if (d2 < -0.6D)
|
||||
{
|
||||
b0 = 0;
|
||||
}
|
||||
|
||||
int origColor = map[(x + HALF_WORLD_SIZE) / zoom][(z + HALF_WORLD_SIZE) / zoom] - 1;
|
||||
|
||||
/*if (color < 4)
|
||||
{
|
||||
d2 = waterDepth * 0.1D + (k1 + j2 & 0x1) * 0.2D;
|
||||
b0 = 1;
|
||||
if (d2 < 0.5D)
|
||||
{
|
||||
b0 = 2;
|
||||
}
|
||||
|
||||
if (d2 > 0.9D)
|
||||
{
|
||||
b0 = 0;
|
||||
}
|
||||
}*/
|
||||
|
||||
byte color = (byte) (origColor + b0);
|
||||
if((color <= -113 || color >= 0) && color <= 127)
|
||||
{
|
||||
map[(x + HALF_WORLD_SIZE) / zoom][(z + HALF_WORLD_SIZE) / zoom] = color;
|
||||
}
|
||||
else
|
||||
{
|
||||
// System.out.println(String.format("Tried to set color to %s in colorWorldHeight scale: %s, sx: %s, sz: %s, x: %s, z: %s, zoom: %s",
|
||||
// color, scale, startingX, startingZ, x, z, zoom));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void drawWorldScale(int scale, int startingX, int startingZ)
|
||||
{
|
||||
Byte[][] first = _map.get(0);
|
||||
Byte[][] second = _map.get(scale);
|
||||
int zoom = getZoom(scale);
|
||||
|
||||
for (int x = startingX; x < startingX + BLOCK_SCAN_INTERVAL; x += zoom)
|
||||
{
|
||||
for (int z = startingZ; z < startingZ + BLOCK_SCAN_INTERVAL; z += zoom)
|
||||
{
|
||||
HashMultiset<Byte> hashmultiset = HashMultiset.create();
|
||||
|
||||
for (int addX = 0; addX < zoom; addX++)
|
||||
{
|
||||
for (int addZ = 0; addZ < zoom; addZ++)
|
||||
{
|
||||
int pX = x + addX + HALF_WORLD_SIZE;
|
||||
int pZ = z + addZ + HALF_WORLD_SIZE;
|
||||
|
||||
if (pX >= first.length || pZ >= first.length)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
Byte b = first[pX][pZ];
|
||||
|
||||
hashmultiset.add(b);
|
||||
}
|
||||
}
|
||||
|
||||
Byte color;
|
||||
try
|
||||
{
|
||||
color = Iterables.getFirst(Multisets.copyHighestCountFirst(hashmultiset), (byte) 0);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
color = (byte) 0;
|
||||
}
|
||||
second[(x + HALF_WORLD_SIZE) / zoom][(z + HALF_WORLD_SIZE) / zoom] = color;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void dropItem(ItemSpawnEvent event)
|
||||
{
|
||||
if (isItemClansMap(event.getEntity().getItemStack()))
|
||||
event.getEntity().remove();
|
||||
}
|
||||
|
||||
public void removeMap(Player player)
|
||||
{
|
||||
for (int slot = 0; slot < player.getInventory().getSize(); slot++)
|
||||
{
|
||||
if (isItemClansMap(player.getInventory().getItem(slot)))
|
||||
player.getInventory().setItem(slot, null);
|
||||
}
|
||||
}
|
||||
|
||||
private double getDistance(double x1, double z1, double x2, double z2)
|
||||
{
|
||||
x1 = (x1 - x2);
|
||||
z1 = (z1 - z2);
|
||||
|
||||
return (x1 * x1) + (z1 * z1);
|
||||
}
|
||||
|
||||
private double getDistance(Entry<Integer, Integer> entry, double x1, double z1)
|
||||
{
|
||||
return getDistance(x1, z1, entry.getKey() + (BLOCK_SCAN_INTERVAL / 2), entry.getValue() + (BLOCK_SCAN_INTERVAL / 2));
|
||||
}
|
||||
|
||||
public Byte[][] getMap(int scale)
|
||||
{
|
||||
return _map.get(scale);
|
||||
}
|
||||
|
||||
public MapInfo getMap(Player player)
|
||||
{
|
||||
return _mapInfo.get(player.getName());
|
||||
}
|
||||
|
||||
public int getMapSize()
|
||||
{
|
||||
return HALF_WORLD_SIZE;
|
||||
}
|
||||
|
||||
public int getZoom(int scale)
|
||||
{
|
||||
return _scale.get(scale);
|
||||
}
|
||||
|
||||
//fixme So what appears to happen is that after you die, if your map is is the same then the map is frozen
|
||||
@EventHandler
|
||||
public void onDeath(PlayerDeathEvent event)
|
||||
{
|
||||
MapInfo info = getMap(event.getEntity());
|
||||
|
||||
info.setMap(Math.min(_mapId + 100, info.getMap() + 1));
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onHotbarMove(PlayerItemHeldEvent event)
|
||||
{
|
||||
Player player = event.getPlayer();
|
||||
|
||||
if (!isItemClansMap(player.getInventory().getItem(event.getNewSlot())))
|
||||
return;
|
||||
|
||||
showZoom(player, getMap(player));
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onInteract(PlayerInteractEvent event)
|
||||
{
|
||||
if (event.getAction() == Action.PHYSICAL)
|
||||
return;
|
||||
|
||||
if (!isItemClansMap(event.getItem()))
|
||||
return;
|
||||
|
||||
event.setCancelled(true);
|
||||
|
||||
Player player = event.getPlayer();
|
||||
|
||||
MapInfo info = getMap(player);
|
||||
|
||||
boolean zoomIn = UtilEvent.isAction(event, ActionType.L);
|
||||
|
||||
if (!_scale.containsKey(info.getScale() + (zoomIn ? -1 : 1)))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (!info.canZoom())
|
||||
{
|
||||
long remainingTime = (info.getZoomCooldown() + 2500) - System.currentTimeMillis();
|
||||
|
||||
UtilPlayer.message(
|
||||
player,
|
||||
F.main("Recharge",
|
||||
"You cannot use " + F.skill("Map Zoom") + " for "
|
||||
+ F.time(UtilTime.convertString((remainingTime), 1, TimeUnit.FIT)) + "."));
|
||||
return;
|
||||
}
|
||||
|
||||
info.addZoom();
|
||||
|
||||
if (zoomIn)
|
||||
{
|
||||
int newScale = info.getScale() - 1;
|
||||
Location loc = player.getLocation();
|
||||
|
||||
int zoom = getZoom(newScale);
|
||||
|
||||
info.setInfo(newScale, calcMapCenter(zoom, loc.getBlockX()), calcMapCenter(zoom, loc.getBlockZ()));
|
||||
}
|
||||
else
|
||||
{
|
||||
int newScale = info.getScale() + 1;
|
||||
Location loc = player.getLocation();
|
||||
|
||||
int zoom = getZoom(newScale);
|
||||
|
||||
info.setInfo(newScale, calcMapCenter(zoom, loc.getBlockX()), calcMapCenter(zoom, loc.getBlockZ()));
|
||||
}
|
||||
|
||||
showZoom(player, info);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void respawn(PlayerCustomRespawnEvent event)
|
||||
{
|
||||
MapInfo info = new MapInfo(_mapId);
|
||||
|
||||
Player player = event.getPlayer();
|
||||
Location loc = player.getLocation();
|
||||
|
||||
int zoom = getZoom(1);
|
||||
|
||||
info.setInfo(1, calcMapCenter(zoom, loc.getBlockX()), calcMapCenter(zoom, loc.getBlockZ()));
|
||||
_mapInfo.put(player.getName(), info);
|
||||
setMap(player);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onWorldChange(PlayerTeleportEvent event)
|
||||
{
|
||||
if (event.getFrom().getWorld() != event.getTo().getWorld() && event.getTo().getWorld().equals("world"))
|
||||
{
|
||||
runSyncLater(new Runnable()
|
||||
{
|
||||
@Override
|
||||
public void run()
|
||||
{
|
||||
setMap(event.getPlayer());
|
||||
}
|
||||
}, 20);
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onQuit(PlayerQuitEvent event)
|
||||
{
|
||||
_mapInfo.remove(event.getPlayer().getName());
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onServerTransfer(ServerTransferEvent event)
|
||||
{
|
||||
Player p = event.getPlayer();
|
||||
|
||||
p.sendMessage(C.cDRed + C.Bold + "WARNING!");
|
||||
p.sendMessage(C.cYellow + "There's a bug where switching servers will freeze the Clans Map!");
|
||||
p.sendMessage(C.cYellow + "If you want to play on Clans again, rejoin the Mineplex server!");
|
||||
}
|
||||
|
||||
private void rebuildScan()
|
||||
{
|
||||
for (int x = -HALF_WORLD_SIZE; x < HALF_WORLD_SIZE; x += BLOCK_SCAN_INTERVAL)
|
||||
{
|
||||
for (int z = -HALF_WORLD_SIZE - 16; z < HALF_WORLD_SIZE; z += (z < -HALF_WORLD_SIZE ? 16 : BLOCK_SCAN_INTERVAL))
|
||||
{
|
||||
_scanList.add(new HashMap.SimpleEntry<>(x, z));
|
||||
}
|
||||
}
|
||||
|
||||
Collections.sort(_scanList, _comparator);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void recenterMap(UpdateEvent event)
|
||||
{
|
||||
if (event.getType() != UpdateType.SEC)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
for (Player player : Bukkit.getOnlinePlayers())
|
||||
{
|
||||
MapInfo info = getMap(player);
|
||||
|
||||
if (info.getScale() >= 3)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
Location l = player.getLocation();
|
||||
int zoom = getZoom(info.getScale());
|
||||
|
||||
double mapX = (l.getX() - info.getX()) / zoom;
|
||||
double mapZ = (l.getZ() - info.getZ()) / zoom;
|
||||
|
||||
if (Math.abs(mapX) > 22 || Math.abs(mapZ) > 22)
|
||||
{
|
||||
int newX = calcMapCenter(zoom, l.getBlockX());
|
||||
int newZ = calcMapCenter(zoom, l.getBlockZ());
|
||||
|
||||
if (Math.abs(mapX) > 22 ? newX != info.getX() : newZ != info.getZ())
|
||||
{
|
||||
info.setInfo(newX, newZ);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void renderMap(UpdateEvent event)
|
||||
{
|
||||
if (event.getType() != UpdateType.FAST)
|
||||
return;
|
||||
|
||||
if (_scanList.isEmpty() && UtilServer.getPlayers().length > 0)
|
||||
{
|
||||
rebuildScan();
|
||||
}
|
||||
|
||||
if (_scanList.size() % 20 == 0)
|
||||
{
|
||||
Collections.sort(_scanList, _comparator);
|
||||
}
|
||||
|
||||
if (_scanList.isEmpty())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Entry<Integer, Integer> entry = _scanList.remove(0);
|
||||
|
||||
int startingX = entry.getKey();
|
||||
int startingZ = entry.getValue();
|
||||
|
||||
boolean outsideMap = startingZ < -HALF_WORLD_SIZE;
|
||||
|
||||
scanWorldMap(startingX, startingZ, !outsideMap, false);
|
||||
|
||||
if (outsideMap)
|
||||
return;
|
||||
|
||||
for (int scale = 1; scale < _scale.size(); scale++)
|
||||
{
|
||||
drawWorldScale(scale, startingX, startingZ);
|
||||
colorWorldHeight(scale, startingX, startingZ);
|
||||
}
|
||||
|
||||
colorWorldHeight(0, startingX, startingZ);
|
||||
}
|
||||
|
||||
|
||||
// Let's not create hundreds of thousands of BlockPositions
|
||||
// Single thread = should be thread safe
|
||||
private BlockPosition.MutableBlockPosition _blockPosition = new BlockPosition.MutableBlockPosition();
|
||||
|
||||
// Maps the cached chunks which were loaded from disk to save IO operations
|
||||
private LongObjectHashMap<Chunk> _chunkCache = new LongObjectHashMap<>();
|
||||
|
||||
/*
|
||||
* Remove the cached chunks when the real chunks are loaded in
|
||||
*/
|
||||
@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
|
||||
public void LoadChunk(ChunkLoadEvent event)
|
||||
{
|
||||
_chunkCache.remove(LongHash.toLong(event.getChunk().getX(), event.getChunk().getZ()));
|
||||
}
|
||||
|
||||
/*
|
||||
* Given a particular coordinate, this method will scan up to BLOCK_SCAN_INTERVAL and record the color of ever 16th block
|
||||
* If a chunk has not been loaded, the following steps will be taken:
|
||||
* * Attempt to load the chunk from disk.
|
||||
* * If the chunk could not be loaded, generate it froms scratch
|
||||
* Otherwise, the loaded chunk will be used
|
||||
*/
|
||||
public void scanWorldMap(int startingX, int startingZ, boolean setColors, boolean isFirstScan)
|
||||
{
|
||||
Byte[][] map = _map.get(0);
|
||||
for (int beginX = startingX; beginX < startingX + BLOCK_SCAN_INTERVAL; beginX += 16)
|
||||
{
|
||||
for (int beginZ = startingZ - (startingZ > -HALF_WORLD_SIZE ? 16 : 0); beginZ < startingZ
|
||||
+ (setColors ? BLOCK_SCAN_INTERVAL : 16); beginZ += 16)
|
||||
{
|
||||
int chunkX = beginX / 16;
|
||||
int chunkZ = beginZ / 16;
|
||||
net.minecraft.server.v1_8_R3.Chunk nmsChunk = _chunkProviderServer.getChunkIfLoaded(chunkX, chunkZ);
|
||||
if (nmsChunk == null)
|
||||
{
|
||||
long key = LongHash.toLong(chunkX, chunkZ);
|
||||
nmsChunk = _chunkCache.get(key);
|
||||
if (nmsChunk == null)
|
||||
{
|
||||
if (!isFirstScan)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
try
|
||||
{
|
||||
Object[] data = _chunkRegionLoader.loadChunk(_nmsWorld, chunkX, chunkZ);
|
||||
if (data == null)
|
||||
{
|
||||
// Something is wrong with the chunk
|
||||
System.out.println("Chunk is not generated or missing level/block data. Regenerating (" + chunkX + "," + chunkZ + ")");
|
||||
nmsChunk = ((CraftChunk) _world.getChunkAt(chunkX, chunkZ)).getHandle();
|
||||
}
|
||||
else
|
||||
{
|
||||
nmsChunk = (net.minecraft.server.v1_8_R3.Chunk) data[0];
|
||||
}
|
||||
}
|
||||
catch (IOException e)
|
||||
{
|
||||
throw new RuntimeException("Chunk is corrupt or not readable!", e);
|
||||
}
|
||||
_chunkCache.put(key, nmsChunk);
|
||||
}
|
||||
}
|
||||
|
||||
if (!nmsChunk.isEmpty())
|
||||
{
|
||||
for (int x = beginX; x < beginX + 16; x++)
|
||||
{
|
||||
for (int z = beginZ; z < beginZ + 16; z++)
|
||||
{
|
||||
int color = 0;
|
||||
|
||||
int k3 = x & 0xF;
|
||||
int l3 = z & 0xF;
|
||||
|
||||
int l4 = nmsChunk.b(k3, l3) + 1;
|
||||
IBlockData iblockdata = Blocks.AIR.getBlockData();
|
||||
|
||||
if (l4 > 1)
|
||||
{
|
||||
do
|
||||
{
|
||||
l4--;
|
||||
_blockPosition.c(k3, l4, l3);
|
||||
iblockdata = nmsChunk.getBlockData(_blockPosition);
|
||||
}
|
||||
while (iblockdata.getBlock().g(iblockdata) == MaterialMapColor.b && (l4 > 0));
|
||||
|
||||
if ((l4 > 0) && (iblockdata.getBlock().getMaterial().isLiquid()))
|
||||
{
|
||||
int j5 = l4 - 1;
|
||||
Block block1;
|
||||
do
|
||||
{
|
||||
_blockPosition.c(k3, j5--, l3);
|
||||
block1 = nmsChunk.getType(_blockPosition);
|
||||
}
|
||||
while ((j5 > 0) && (block1.getMaterial().isLiquid()));
|
||||
}
|
||||
}
|
||||
|
||||
_heightMap[x + HALF_WORLD_SIZE + 16][z + HALF_WORLD_SIZE + 16] = l4;
|
||||
|
||||
if (setColors)
|
||||
{
|
||||
//color = block.f(i5).M;
|
||||
_blockPosition.c(k3, l4, l3);
|
||||
IBlockData data = nmsChunk.getBlockData(_blockPosition);
|
||||
color = data.getBlock().g(data).M;
|
||||
|
||||
color = (byte) ((color * 4) + 1);
|
||||
}
|
||||
|
||||
if (setColors && beginZ >= startingZ)
|
||||
{
|
||||
map[x + HALF_WORLD_SIZE][z + HALF_WORLD_SIZE] = (byte) color;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void setMap(Player player)
|
||||
{
|
||||
for (ItemStack item : UtilInv.getItems(player))
|
||||
{
|
||||
if (isItemClansMap(item))
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
ItemStack item = new ItemBuilder(Material.MAP, 1, (short) getMap(player).getMap()).setTitle(C.cGreen + "World Map").build();
|
||||
|
||||
int slot = CLANS_MAP_SLOT;
|
||||
|
||||
ItemStack mapSlot = player.getInventory().getItem(slot);
|
||||
if (mapSlot != null && mapSlot.getType() != Material.AIR)
|
||||
{
|
||||
slot = player.getInventory().firstEmpty();
|
||||
}
|
||||
|
||||
if (slot >= 0)
|
||||
{
|
||||
player.getInventory().setItem(slot, item);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Displays the action bar to a player given their zoom level. Implementation may change
|
||||
*/
|
||||
private void showZoom(Player player, MapInfo info)
|
||||
{
|
||||
UtilTextBottom.display(ZOOM_INFO[info.getScale()], player);
|
||||
}
|
||||
|
||||
/*
|
||||
* Check whether an {@link ItemStack} is also a Clans Map
|
||||
*
|
||||
* @param itemStack The {@link ItemStack} to check
|
||||
* @returns Whether the {@link ItemStack} is also a Clans Map
|
||||
*/
|
||||
private boolean isItemClansMap(ItemStack itemStack)
|
||||
{
|
||||
return UtilItem.matchesMaterial(itemStack, Material.MAP)
|
||||
&& itemStack.getDurability() >= _mapId
|
||||
&& itemStack.getDurability() <= _mapId + 100;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,295 @@
|
|||
package mineplex.gemhunters.map;
|
||||
|
||||
import java.awt.Color;
|
||||
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.map.MapCanvas;
|
||||
import org.bukkit.map.MapCursor;
|
||||
import org.bukkit.map.MapCursorCollection;
|
||||
import org.bukkit.map.MapPalette;
|
||||
import org.bukkit.map.MapRenderer;
|
||||
import org.bukkit.map.MapView;
|
||||
|
||||
import mineplex.core.Managers;
|
||||
import mineplex.core.common.util.UtilTime;
|
||||
import mineplex.core.communities.Community;
|
||||
import mineplex.core.communities.CommunityManager;
|
||||
import mineplex.core.party.Party;
|
||||
import mineplex.core.party.PartyManager;
|
||||
import mineplex.gemhunters.safezone.SafezoneModule;
|
||||
import mineplex.gemhunters.supplydrop.SupplyDropModule;
|
||||
import mineplex.gemhunters.worldevent.WorldEvent;
|
||||
import mineplex.gemhunters.worldevent.WorldEventModule;
|
||||
|
||||
/**
|
||||
* <b>All item map code was adapted from Clans.</b><br>
|
||||
*/
|
||||
public class ItemMapRenderer extends MapRenderer
|
||||
{
|
||||
|
||||
private static final int RENDER_COOLDOWN = 10000;
|
||||
private static final int STANDARD_Y = 70;
|
||||
|
||||
private final ItemMapModule _itemMap;
|
||||
private final SafezoneModule _safezone;
|
||||
private final SupplyDropModule _supply;
|
||||
private final WorldEventModule _worldEvent;
|
||||
|
||||
private final CommunityManager _community;
|
||||
private final PartyManager _party;
|
||||
|
||||
public ItemMapRenderer()
|
||||
{
|
||||
super(true);
|
||||
|
||||
_itemMap = Managers.require(ItemMapModule.class);
|
||||
_safezone = Managers.require(SafezoneModule.class);
|
||||
_supply = Managers.require(SupplyDropModule.class);
|
||||
_worldEvent = Managers.require(WorldEventModule.class);
|
||||
_community = Managers.require(CommunityManager.class);
|
||||
_party = Managers.require(PartyManager.class);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void render(MapView mapView, MapCanvas canvas, Player player)
|
||||
{
|
||||
try
|
||||
{
|
||||
renderNormalMap(mapView, canvas, player);
|
||||
}
|
||||
catch (Throwable t)
|
||||
{
|
||||
System.out.println("Error while rendering map");
|
||||
t.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
private void renderNormalMap(MapView mapView, MapCanvas canvas, Player player)
|
||||
{
|
||||
MapInfo info = _itemMap.getMap(player);
|
||||
|
||||
if (info == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int scale = info.getScale();
|
||||
int zoom = _itemMap.getZoom(scale);
|
||||
|
||||
Byte[][] map = _itemMap.getMap(scale);
|
||||
|
||||
int centerX = info.getX() / zoom;
|
||||
int centerZ = info.getZ() / zoom;
|
||||
|
||||
// We have this cooldown to squeeze out every single bit of performance
|
||||
// from the server.
|
||||
if (UtilTime.elapsed(info.getLastRendered(), RENDER_COOLDOWN))
|
||||
{
|
||||
info.setLastRendered();
|
||||
|
||||
for (int mapX = 0; mapX < 128; mapX++)
|
||||
{
|
||||
for (int mapZ = 0; mapZ < 128; mapZ++)
|
||||
{
|
||||
int blockX = centerX + (mapX - 64);
|
||||
int blockZ = centerZ + (mapZ - 64);
|
||||
|
||||
int pixelX = blockX + (map.length / 2);
|
||||
int pixelZ = blockZ + (map.length / 2);
|
||||
|
||||
Byte color;
|
||||
|
||||
if (!(pixelX < 0 || pixelZ < 0 || pixelX >= map.length || pixelZ >= map.length) && map[pixelX][pixelZ] != null)
|
||||
{
|
||||
color = map[pixelX][pixelZ];
|
||||
|
||||
blockX *= zoom;
|
||||
blockZ *= zoom;
|
||||
|
||||
Location location = new Location(mapView.getWorld(), blockX, STANDARD_Y, blockZ);
|
||||
|
||||
boolean safezone = _safezone.isInSafeZone(location);
|
||||
boolean supplyDrop = _supply.isNearSupplyDrop(location);
|
||||
|
||||
if (safezone || supplyDrop)
|
||||
{
|
||||
boolean colorAll = scale > 0;
|
||||
Color areaColor = null;
|
||||
|
||||
if (safezone)
|
||||
{
|
||||
areaColor = Color.GREEN;
|
||||
}
|
||||
else if (supplyDrop)
|
||||
{
|
||||
areaColor = Color.YELLOW;
|
||||
}
|
||||
|
||||
if (areaColor != null)
|
||||
{
|
||||
if (!((color <= -113 || color >= 0) && color <= 127))
|
||||
{
|
||||
color = (byte) 0;
|
||||
System.out.println(String.format("Tried to draw invalid color %s, player: %s, mapX: %s, mapZ: %s", color, player.getName(), mapX, mapZ));
|
||||
}
|
||||
else
|
||||
{
|
||||
int chunkBX = blockX & 0xF;
|
||||
int chunkBZ = blockZ & 0xF;
|
||||
|
||||
// Border
|
||||
if (
|
||||
((chunkBX == 0 || zoom == 13) &&
|
||||
|
||||
_safezone.isInSafeZone(new Location(mapView.getWorld(), blockX - 16, STANDARD_Y, blockZ)))
|
||||
|
||||
|| ((chunkBZ == 0 || zoom == 13) &&
|
||||
|
||||
_safezone.isInSafeZone(new Location(mapView.getWorld(), blockX, STANDARD_Y, blockZ - 16)))
|
||||
|
||||
|| ((chunkBX + zoom > 15 || zoom == 13) &&
|
||||
|
||||
_safezone.isInSafeZone(new Location(mapView.getWorld(), blockX + 16, STANDARD_Y, blockZ)))
|
||||
|
||||
|| ((chunkBZ + zoom > 15 || zoom == 13) &&
|
||||
|
||||
_safezone.isInSafeZone(new Location(mapView.getWorld(), blockX, STANDARD_Y, blockZ + 16))))
|
||||
{
|
||||
Color cColor = MapPalette.getColor(color);
|
||||
double clans = colorAll ? 1 : 0.8;
|
||||
double base = 1 - clans;
|
||||
|
||||
int r = (int) ((cColor.getRed() * base) + (areaColor.getRed() * clans));
|
||||
int b = (int) ((cColor.getBlue() * base) + (areaColor.getBlue() * clans));
|
||||
int g = (int) ((cColor.getGreen() * base) + (areaColor.getGreen() * clans));
|
||||
|
||||
color = MapPalette.matchColor(r, g, b);
|
||||
}
|
||||
|
||||
// Inside
|
||||
else
|
||||
{
|
||||
Color cColor = MapPalette.getColor(color);
|
||||
|
||||
double clans = 0.065;
|
||||
|
||||
// Stripes
|
||||
//boolean checker = (mapX + (mapZ % 4)) % 4 == 0;
|
||||
double base = 1 - clans;
|
||||
|
||||
int r = (int) ((cColor.getRed() * base) + (areaColor.getRed() * clans));
|
||||
int b = (int) ((cColor.getBlue() * base) + (areaColor.getBlue() * clans));
|
||||
int g = (int) ((cColor.getGreen() * base) + (areaColor.getGreen() * clans));
|
||||
|
||||
color = MapPalette.matchColor(r, g, b);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
color = (byte) 0;
|
||||
}
|
||||
|
||||
canvas.setPixel(mapX, mapZ, color);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (info.isSendMap())
|
||||
{
|
||||
player.sendMap(mapView);
|
||||
}
|
||||
|
||||
MapCursorCollection cursors = canvas.getCursors();
|
||||
|
||||
while (cursors.size() > 0)
|
||||
{
|
||||
cursors.removeCursor(cursors.getCursor(0));
|
||||
}
|
||||
|
||||
for (WorldEvent event : _worldEvent.getActiveEvents())
|
||||
{
|
||||
if (!event.isInProgress())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
Location point = event.getCurrentLocation();
|
||||
double mapX = (point.getX() - info.getX()) / zoom;
|
||||
double mapZ = (point.getZ() - info.getZ()) / zoom;
|
||||
|
||||
// To make these appear at the edges of the map, just change it from
|
||||
// 64 to something like 128 for double the map size
|
||||
if (mapX > -64 && mapX < 64 && mapZ > -64 && mapZ < 64)
|
||||
{
|
||||
byte b0 = (byte) (int) Math.min(127, (double) (mapX * 2.0F) + 0.5D);
|
||||
byte b1 = (byte) (int) Math.max(-127, (double) (mapZ * 2.0F) + 0.5D);
|
||||
|
||||
byte cursorType = 4; // http://i.imgur.com/wpH6PT8.png
|
||||
// Those are byte 5 and 6
|
||||
byte rotation = (byte) ((int) Math.floor(System.currentTimeMillis() / 1000D) % 16);
|
||||
|
||||
MapCursor cursor = new MapCursor(b0, b1, rotation, cursorType, true);
|
||||
|
||||
cursors.addCursor(cursor);
|
||||
}
|
||||
}
|
||||
|
||||
Party party = _party.getPartyByPlayer(player);
|
||||
Community[] communities = _community.Get(player).getCommunities();
|
||||
|
||||
for (Player other : Bukkit.getOnlinePlayers())
|
||||
{
|
||||
if (player.canSee(other) && other.isValid())
|
||||
{
|
||||
Location l = other.getLocation();
|
||||
|
||||
double mapX = (l.getX() - info.getX()) / zoom;
|
||||
double mapZ = (l.getZ() - info.getZ()) / zoom;
|
||||
|
||||
if (mapX > -64 && mapX < 64 && mapZ > -64 && mapZ < 64)
|
||||
{
|
||||
MapCursor.Type cursorDisplay = null;
|
||||
|
||||
if (player.equals(other))
|
||||
{
|
||||
cursorDisplay = MapCursor.Type.WHITE_POINTER;
|
||||
}
|
||||
else if (party != null && party.isMember(other))
|
||||
{
|
||||
cursorDisplay = MapCursor.Type.GREEN_POINTER;
|
||||
}
|
||||
else if (communities.length > 0)
|
||||
{
|
||||
for (Community community : communities)
|
||||
{
|
||||
if (community.getMembers().containsKey(other.getUniqueId()))
|
||||
{
|
||||
cursorDisplay = MapCursor.Type.BLUE_POINTER;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (cursorDisplay == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
byte b0 = (byte) (int) Math.min(127, (double) (mapX * 2.0F) + 0.5D);
|
||||
byte b1 = (byte) (int) Math.max(-127, (double) (mapZ * 2.0F) + 0.5D);
|
||||
|
||||
byte rotation = (byte) (int) ((l.getYaw() * 16D) / 360D);
|
||||
|
||||
MapCursor cursor = new MapCursor(b0, b1, (byte) (rotation & 0xF), cursorDisplay.getValue(), true);
|
||||
|
||||
cursors.addCursor(cursor);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,124 @@
|
|||
package mineplex.gemhunters.map;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
import mineplex.core.common.util.UtilTime;
|
||||
|
||||
public class MapInfo
|
||||
{
|
||||
private int _scale;
|
||||
private int _centerX;
|
||||
private int _centerZ;
|
||||
private long _lastRendered;
|
||||
private boolean _sendMap;
|
||||
private List<Long> _lastZooms = new ArrayList<Long>();
|
||||
private int _mapId;
|
||||
|
||||
public MapInfo(int newId)
|
||||
{
|
||||
_mapId = newId;
|
||||
}
|
||||
|
||||
public int getMap()
|
||||
{
|
||||
return _mapId;
|
||||
}
|
||||
|
||||
public void setMap(int newId)
|
||||
{
|
||||
_mapId = newId;
|
||||
}
|
||||
|
||||
public boolean canZoom()
|
||||
{
|
||||
Iterator<Long> itel = _lastZooms.iterator();
|
||||
|
||||
while (itel.hasNext())
|
||||
{
|
||||
long lastZoomed = itel.next();
|
||||
|
||||
if (UtilTime.elapsed(lastZoomed, 2500))
|
||||
{
|
||||
itel.remove();
|
||||
}
|
||||
}
|
||||
|
||||
return _lastZooms.size() < 3;
|
||||
}
|
||||
|
||||
public void addZoom()
|
||||
{
|
||||
_lastZooms.add(System.currentTimeMillis());
|
||||
}
|
||||
|
||||
public long getZoomCooldown()
|
||||
{
|
||||
long cooldown = 0;
|
||||
|
||||
for (long zoomCooldown : _lastZooms)
|
||||
{
|
||||
if (cooldown == 0 || zoomCooldown < cooldown)
|
||||
{
|
||||
cooldown = zoomCooldown;
|
||||
}
|
||||
}
|
||||
|
||||
return cooldown;
|
||||
}
|
||||
|
||||
public long getLastRendered()
|
||||
{
|
||||
return _lastRendered;
|
||||
}
|
||||
|
||||
public void setLastRendered()
|
||||
{
|
||||
_lastRendered = System.currentTimeMillis();
|
||||
}
|
||||
|
||||
public void setInfo(int scale, int x, int z)
|
||||
{
|
||||
_lastRendered = 0;
|
||||
_scale = scale;
|
||||
_centerX = x;
|
||||
_centerZ = z;
|
||||
_sendMap = true;
|
||||
}
|
||||
|
||||
public void setInfo(int x, int z)
|
||||
{
|
||||
_lastRendered = 0;
|
||||
_centerX = x;
|
||||
_centerZ = z;
|
||||
_sendMap = true;
|
||||
}
|
||||
|
||||
public boolean isSendMap()
|
||||
{
|
||||
if (_sendMap)
|
||||
{
|
||||
_sendMap = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public int getX()
|
||||
{
|
||||
return _centerX;
|
||||
}
|
||||
|
||||
public int getZ()
|
||||
{
|
||||
return _centerZ;
|
||||
}
|
||||
|
||||
public int getScale()
|
||||
{
|
||||
return _scale;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -32,7 +32,7 @@ import mineplex.gemhunters.world.WorldDataModule;
|
|||
public class SpawnModule extends MiniPlugin
|
||||
{
|
||||
|
||||
private static final int WORLD_BORDER_RADIUS = 750;
|
||||
public static final int WORLD_BORDER_RADIUS = 768;
|
||||
private static final int MAX_SPAWNING_Y = 73;
|
||||
|
||||
private final SafezoneModule _safezone;
|
||||
|
|
|
|||
|
|
@ -205,5 +205,9 @@ public class SupplyDrop
|
|||
|
||||
UtilFirework.playFirework(fallingBlock.getLocation().add(0.5, 1, 0.5), UtilFirework.getRandomFireworkEffect(false, 2, 1));
|
||||
}
|
||||
|
||||
|
||||
public final Location getChestLocation()
|
||||
{
|
||||
return _destination;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -41,6 +41,8 @@ public class SupplyDropModule extends MiniPlugin
|
|||
private static final String CHEST_COLOUR = "RED";
|
||||
private static final String LOCATION_DATA = "SUPPLY_DROP";
|
||||
|
||||
private static final int SUPPLY_DROP_DISTANCE_SQUARED = 625;
|
||||
|
||||
private final BlockRestore _blockRestore;
|
||||
private final LootModule _loot;
|
||||
private final WorldDataModule _worldData;
|
||||
|
|
@ -172,6 +174,11 @@ public class SupplyDropModule extends MiniPlugin
|
|||
{
|
||||
return _current != null;
|
||||
}
|
||||
|
||||
public boolean isNearSupplyDrop(Location location)
|
||||
{
|
||||
return isActive() ? UtilMath.offsetSquared(location, _current.getChestLocation()) <= SUPPLY_DROP_DISTANCE_SQUARED : false;
|
||||
}
|
||||
|
||||
public String[] getLocationKeys()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ public class TimeCycle implements Listener
|
|||
|
||||
public TimeCycle(JavaPlugin plugin)
|
||||
{
|
||||
//plugin.getServer().getPluginManager().registerEvents(this, plugin);
|
||||
plugin.getServer().getPluginManager().registerEvents(this, plugin);
|
||||
|
||||
_worldData = Managers.get(WorldDataModule.class);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,6 +55,7 @@ public class WorldListeners implements Listener
|
|||
for (World world : plugin.getServer().getWorlds())
|
||||
{
|
||||
((CraftWorld) world).getHandle().spigotConfig.viewDistance = VIEW_DISTANCE;
|
||||
((CraftWorld) world).getHandle().a(VIEW_DISTANCE);
|
||||
}
|
||||
|
||||
}, 20);
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ import java.util.HashSet;
|
|||
import java.util.Iterator;
|
||||
import java.util.Set;
|
||||
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.LivingEntity;
|
||||
import org.bukkit.event.EventHandler;
|
||||
|
|
@ -50,6 +51,8 @@ public abstract class WorldEvent implements Listener
|
|||
|
||||
public abstract void onEnd();
|
||||
|
||||
public abstract Location getCurrentLocation();
|
||||
|
||||
public final void start()
|
||||
{
|
||||
onStart();
|
||||
|
|
@ -117,6 +120,11 @@ public abstract class WorldEvent implements Listener
|
|||
}
|
||||
}
|
||||
|
||||
public boolean isInProgress()
|
||||
{
|
||||
return _eventState == WorldEventState.WARMUP || _eventState == WorldEventState.LIVE;
|
||||
}
|
||||
|
||||
public WorldEventState getEventState()
|
||||
{
|
||||
return _eventState;
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ package mineplex.gemhunters.worldevent.giant;
|
|||
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Zombie;
|
||||
import org.bukkit.event.EventHandler;
|
||||
|
|
@ -21,8 +22,8 @@ public class GiantWorldEvent extends WorldEvent
|
|||
{
|
||||
|
||||
private static final int MINI_ZOMBIES = 10;
|
||||
private static final int MINI_ZOMBIES_MAX_DISTANCE_SQUARED = 900;
|
||||
private static final long MAX_TIME = TimeUnit.MINUTES.toMillis(6);
|
||||
private static final int MINI_ZOMBIES_MAX_DISTANCE_SQUARED = 2500;
|
||||
private static final long MAX_TIME = TimeUnit.MINUTES.toMillis(5);
|
||||
|
||||
private CustomGiant _giant;
|
||||
|
||||
|
|
@ -53,6 +54,12 @@ public class GiantWorldEvent extends WorldEvent
|
|||
{
|
||||
}
|
||||
|
||||
@Override
|
||||
public Location getCurrentLocation()
|
||||
{
|
||||
return _giant.getGiant().getLocation();
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void zombieCombust(EntityCombustEvent event)
|
||||
{
|
||||
|
|
|
|||
Loading…
Reference in New Issue