Java 类org.bukkit.entity.Minecart 实例源码

@EventHandler
public void onMinecartEnter(PlayerInteractEntityEvent event) {
    if(!(event.getRightClicked() instanceof Minecart)) return;
    event.getRightClicked().setGlowing(false);
    event.getPlayer().playSound(event.getPlayer().getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1f, 1f);
    inMinecarts++;
    if(inMinecarts >= this.getAPI().getGameManager().getPlayersAlive()) {
        new BukkitRunnable() {
            public void run() {
                if(getAPI().getGameManager().getGameState() != GameState.INGAME) return;
                Bukkit.getOnlinePlayers().forEach(player -> {
                    if(getAPI().getGameManager().isAlive(player)) {
                        if(player.getVehicle() == null) getAPI().getGameManager().setAlive(player, false);
                    }
                });
                nextEvent();
            }
        }.runTaskLater(this.getAPI().getPlugin(), 20L);
    }
}

/**
 * Clean the cache
 */
@Override
public void run()
{
    long currentTime = System.currentTimeMillis();

    List<Map.Entry<Chunk, Long>> temp = new ArrayList<>();
    temp.addAll(this.lastChunkCleanUp.entrySet());

    for (Map.Entry<Chunk, Long> entry : temp)
    {
        Chunk chunk = entry.getKey();

        if (!chunk.isLoaded() || (currentTime - entry.getValue() <= 60000))
            continue;

        for (Entity entity : chunk.getEntities())
            if (!(entity instanceof Item || entity instanceof HumanEntity || entity instanceof Minecart))
                entity.remove();

        this.lastChunkCleanUp.remove(chunk);
    }
}

@SuppressWarnings("null")
@Override
protected boolean init(final @Nullable Class<? extends Minecart> c, final @Nullable Minecart e) {
    final MinecartType[] ts = MinecartType.values();
    for (int i = ts.length - 1; i >= 0; i--) {
        final Class<?> mc = ts[i].c;
        if (mc == null)
            continue;
        if (e == null ? mc.isAssignableFrom(c) : mc.isInstance(e)) {
            type = ts[i];
            return true;
        }
    }
    assert false;
    return false;
}

@Override
public void run() {
    if (!player.isOnline()) return;
    boolean kick = false;
    if (player.getVehicle() instanceof Minecart) {
        if (playerData.wasInMinecartLastRound) kick = true;
        playerData.wasInMinecartLastRound = true;
    } else {
        playerData.wasInMinecartLastRound = false;
    }
    try {
        if (playerData.lastObservedLocation != null && (playerData.lastObservedLocation.distance(player.getLocation()) < 3))
            kick = true;
    } catch (IllegalArgumentException ignored) {}

    int playersOnline = PopulationDensity.inst.getServer().getOnlinePlayers().length;
    if (!Lib.perm(player, "populationdensity.idle") && kick && ConfigData.minimumPlayersOnlineForIdleBoot <= playersOnline) {
        Log.log("Kicked " + player.getName() + " for idling.");
        player.kickPlayer("Kicked for idling, to make room for active players.");
        return;
    }
    playerData.lastObservedLocation = player.getLocation();
    playerData.afkCheckTaskID = PopulationDensity.inst.getServer().getScheduler().scheduleSyncDelayedTask(PopulationDensity.inst, this, 20L * 60 * ConfigData.maxIdleMinutes);
}

/**
 * Controls chest ownership for carts.
 *
 * @param e The {@link InventoryMoveItemEvent} associated with the chest.
 */
@EventHandler
public void onInventoryOpening(InventoryOpenEvent e) {
    Inventory inv = e.getInventory();
    if (e.getPlayer() instanceof Player) {
        Player p = (Player) e.getPlayer();
        if (inv.getHolder() instanceof Minecart) {
            Minecart cart = (Minecart) inv.getHolder();
            MinecartMember<?> toCheck = MinecartMemberStore.getAt(cart.getLocation());
            if (toCheck != null && !toCheck.isDerailed()) {
                CartProperties cp = toCheck.getProperties();
                if (!cp.getOwners().contains(p.getName().toLowerCase())) {
                    p.sendMessage(ChatColor.RED + "You do not own this chest!");
                    e.setCancelled(true);
                }
            }
        }
    }
}

/**
 * This will facilitate the need to update the {@link TrainFactory#ownerStorage} list, because if the inventory changes, the instance changes.
 * 
 * @param e The {@link InventoryMoveItemEvent} associated with the chest.
 */
@EventHandler
public void onInventoryOpening(InventoryOpenEvent e) {
    Inventory inv = e.getInventory();
    if(e.getPlayer() instanceof Player) {
        Player p = (Player) e.getPlayer();
        if(inv.getHolder() instanceof Minecart) {
            Minecart cart = (Minecart) inv.getHolder();
            MinecartMember<?> toCheck = MinecartMemberStore.getAt(cart.getLocation());
            if(toCheck != null) {
                CartProperties cp = toCheck.getProperties();
                if(!cp.getOwners().contains(p.getName().toLowerCase())) {
                    p.sendMessage(ChatColor.RED + "You do not own this chest!");
                    e.setCancelled(true);
                }
            }
        }
    }
}

@Override
public void execute(Minecart minecart, Object parameter) {

    String data = String.valueOf(parameter);

    if (String.valueOf(parameter).startsWith("+")) {
        TagUtils.addTag(minecart, data.replaceAll("\\+", "").trim());
    } else if (String.valueOf(parameter).startsWith("-")) {
        if (data.replaceAll("-", "").trim().isEmpty()) {
            TagUtils.clearTags(minecart);
        } else {
            TagUtils.removeTag(minecart, data.replaceAll("-", "").trim());
        }
    } else {
        TagUtils.addTag(minecart, data.trim());
    }
}

private void killMinecarts() {
    this.getAPI().getMapRegistry().getCurrentWorld().getEntities().forEach(entity -> {
        if(entity instanceof Minecart) {
            entity.setMetadata("allow-exit", new FixedMetadataValue(this.getAPI().getPlugin(), true));
            if(!entity.getPassengers().isEmpty()) entity.eject();
            entity.remove();
        }
    });
}

private void spawnMinecarts() {
    int minecarts = this.getAPI().getGameManager().getPlayersAlive();
    if(!enoughMinecarts) minecarts--;
    for(int i=0; i<minecarts; i++) {
        Location location = spawnLocations.get(new Random().nextInt(spawnLocations.size()));
        Minecart minecart = location.getWorld().spawn(location, Minecart.class);
        minecart.getWorld().playSound(minecart.getLocation(), Sound.ENTITY_CHICKEN_EGG, 1f, 1f);
        minecart.setGlowing(true);
    }
    if(enoughMinecarts) enoughMinecarts = false;
}

/**
 * Save unloaded chunk
 *
 * @param event Event
 */
@EventHandler
public void onChunkUnload(ChunkUnloadEvent event)
{
    for (Entity entity : event.getChunk().getEntities())
        if (!(entity instanceof Item || entity instanceof HumanEntity || entity instanceof Minecart))
            entity.remove();

    //event.setCancelled(true);
}

@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onEntityPortal(EntityPortalEvent e) {
    if (!cm.isAntiMinecartPortal) {
        return;
    }
    if (e.getEntity() instanceof Minecart) {
        e.setCancelled(true);
    }
}

public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
 if (cmd.getName().equalsIgnoreCase("cartcamera")) {
  sender.sendMessage("ja hoor");
  Player p = (Player) sender;
  Minecart minecart = (Minecart) p.getLocation().getWorld().spawn(p.getLocation(), Minecart.class);
  degree = 0;
  direction = false;
  rotating = false;
  uploopcounter = 0;
  playerpublic = (Player) sender;
  Bukkit.getScheduler().scheduleSyncRepeatingTask(main.getPL(), new Runnable() {
   @Override
   public void run() {
    if (rotating == true) {
     degree++;
     degree++; degree++;
     degree++; degree++;
     degree++;degree++;
     degree++; degree++;
     degree++; degree++;
     degree++;
    }
    if (degree == 360 || degree > 360) {
     degree = 0;
    }
    moveEntity(minecart, degree + 1 * 90);
   }
  }, 0, 1);
 }
 return false;
}

@EventHandler
   public void onPlayerInteract(PlayerInteractEntityEvent e) {
    if (e.isCancelled()) {
           return;
       }

    Player p = e.getPlayer();
       Entity ent = e.getRightClicked();
       Location l = ent.getLocation();
       Region r = RedProtect.get().rm.getTopRegion(l);
       if (r != null){
        return;
    }

       if (ent instanceof ItemFrame || ent instanceof Painting) {
           if (!bypassBuild(p, null, 0)) {
               e.setCancelled(true);
               return;
           }
       } 

       if (ent instanceof Minecart || ent instanceof Boat){
        if (!RPConfig.getGlobalFlagBool(l.getWorld().getName()+".use-minecart") && !p.hasPermission("redprotect.bypass.world")) {
               e.setCancelled(true);
               return;
           }
       } 

       if (!RPConfig.getGlobalFlagBool(l.getWorld().getName()+".interact") && !p.hasPermission("redprotect.bypass.world") && (!(ent instanceof Player))) {
        if (RPConfig.getGlobalFlagList(p.getWorld().getName() + ".if-interact-false.allow-entities").contains(ent.getType().name())){
            return;
        } 
           e.setCancelled(true);
    }
}

public static Parameter wtfOperation(Parameter dummy, Context ctx, LocationParameter where) {
    org.bukkit.World w = where.asLocation(ctx).getWorld();
    Location l = where.asLocation(ctx);
    l.setPitch(100.0f);
    l.setYaw(45.0f);
    Minecart e = (Minecart)w.spawnEntity(l, EntityType.MINECART);
    e.setPassenger(w.spawnEntity(where.asLocation(ctx), EntityType.SLIME));
    return Parameter.EmptyString;

}

public RoutePlayer getPlayerFromMinecart(Minecart minecart) {
    for (RoutePlayer player : this.getRoutePlayers()) {
        if (player.getMinecart() == minecart) {
            return player;
        }
    }
    return null;
}

public boolean isDeincartInNear(Location loc) {
    for (RoutePlayer player : this.getRoutePlayers()) {
        Minecart minecart = player.getMinecart();
        Location loc1 = minecart.getLocation();

        if (
            (Math.max(loc.getBlockX(), loc1.getBlockX()) - Math.min(loc.getBlockX(), loc1.getBlockX()) < 6) &&
            (Math.max(loc.getBlockY(), loc1.getBlockY()) - Math.min(loc.getBlockY(), loc1.getBlockY()) < 4) &&
            (Math.max(loc.getBlockZ(), loc1.getBlockZ()) - Math.min(loc.getBlockZ(), loc1.getBlockZ()) < 6)
        ) {
            return true;
        }
    }
    return false;
}

private static boolean canWipe(Entity entity, boolean wipeExplosives, boolean wipeVehicles)
{
    if (wipeExplosives)
    {
        if (Explosive.class.isAssignableFrom(entity.getClass()))
        {
            return true;
        }
    }

    if (wipeVehicles)
    {
        if (Boat.class.isAssignableFrom(entity.getClass()))
        {
            return true;
        }
        else if (Minecart.class.isAssignableFrom(entity.getClass()))
        {
            return true;
        }
    }

    Iterator<Class<? extends Entity>> it = WIPEABLES.iterator();
    while (it.hasNext())
    {
        if (it.next().isAssignableFrom(entity.getClass()))
        {
            return true;
        }
    }

    return false;
}

@EventHandler
private void onVehicleDestroyed(final EntityDamageByEntityEvent event) {
    if (event.getEntity() instanceof Minecart) {
        ProtectedArea area = Areas.findArea(event.getEntity().getLocation());
        if (area != null) {
            if (event.getDamager() instanceof Player) {
                if (!((Player) event.getDamager()).isOp()) {
                    event.setCancelled(true);
                }
            }
        }
    }
}

@EventHandler
private void onVehicleMove(final VehicleMoveEvent event) {
    if (event.getVehicle() instanceof Minecart) {
        //ProtectedArea area = Areas.findArea(event.getVehicle().getLocation());

    }
}

@Override
public boolean getResult(Minecart minecart, Direction direction, String term) {

    String tagTerm = term.split("-")[1];
    tagTerm = tagTerm.replaceAll("\\*", ".*");

    for (String tag : TagUtils.getTags(minecart)) {
        if (tag.matches(tagTerm)) {
            return true;
        }
    }

    return false;
}

@Override
public void execute(Minecart minecart, String label, Sign sign) {

    for (String line : Arrays.copyOfRange(sign.getLines(), 1, sign.getLines().length)) {
        if (!line.isEmpty()) {
            executeExpression(minecart, "tag " + line);
        }
    }
}

@EventHandler(ignoreCancelled=true)
public final void onVehicleExit(VehicleExitEvent event) {
    Vehicle cart = event.getVehicle();
    if (cart.getType() == EntityType.MINECART) {
        ((Minecart) cart).setFlyingVelocityMod(exitedVelocityMod);
    }
}

MinecartType(final @Nullable Class<? extends Minecart> c, final String codeName) {
    this.c = c;
    this.codeName = codeName;
}

@Override
public void set(final Minecart entity) {}

@Override
public boolean match(final Minecart entity) {
    if (type == MinecartType.NORMAL && type.c == Minecart.class) // pre-1.5
        return !(entity instanceof PoweredMinecart || entity instanceof StorageMinecart);
    return type.c != null && type.c.isInstance(entity);
}

@Override
public Class<? extends Minecart> getType() {
    return type.c != null ? type.c : Minecart.class;
}

public CanaryMinecart(net.canarymod.api.entity.vehicle.Minecart entity) {
    super(entity);
}

protected net.canarymod.api.entity.vehicle.Minecart getHandle() {
    return (net.canarymod.api.entity.vehicle.Minecart) super.getHandle();
}

/**
 * Update distances and store them into server's memory until player disconnects.
 * 
 * @param player
 */
private void validateMovementAndUpdateDistance(Player player) {
    String uuid = player.getUniqueId().toString();
    Location previousLocation = playerLocations.get(uuid);

    // Update new location.
    playerLocations.put(uuid, player.getLocation());

    // If player location not found or if player has changed world, ignore previous location.
    // Evaluating distance would give an exception.
    if (previousLocation == null || !previousLocation.getWorld().getName().equals(player.getWorld().getName())) {
        return;
    }

    // If player is in restricted game mode or is in a blocked world, don't update distances.
    if (!shouldIncreaseBeTakenIntoAccountNoPermissions(player)) {
        return;
    }

    int difference = getDistanceDifference(player, previousLocation);
    // Player has not moved.
    if (difference == 0L) {
        return;
    }

    if (player.getVehicle() instanceof Horse) {
        updateDistance(difference, player, NormalAchievements.DISTANCEHORSE);
    } else if (player.getVehicle() instanceof Pig) {
        updateDistance(difference, player, NormalAchievements.DISTANCEPIG);
    } else if (player.getVehicle() instanceof Minecart) {
        updateDistance(difference, player, NormalAchievements.DISTANCEMINECART);
    } else if (player.getVehicle() instanceof Boat) {
        updateDistance(difference, player, NormalAchievements.DISTANCEBOAT);
    } else if (plugin.getServerVersion() >= 11 && player.getVehicle() instanceof Llama) {
        updateDistance(difference, player, NormalAchievements.DISTANCELLAMA);
    } else if (!player.isFlying() && (plugin.getServerVersion() < 9 || !player.isGliding())) {
        updateDistance(difference, player, NormalAchievements.DISTANCEFOOT);
    } else if (plugin.getServerVersion() >= 9 && player.isGliding()) {
        updateDistance(difference, player, NormalAchievements.DISTANCEGLIDING);
    }
}

@EventHandler(priority = EventPriority.LOWEST)
   public void onEntityDamageByEntityEvent(EntityDamageByEntityEvent e) {
    Player p = null;        

    RedProtect.get().logger.debug("RPLayerListener: Is EntityDamageByEntityEvent event"); 

       if (e.getDamager() instanceof Player){
        p = (Player)e.getDamager();
       } else if (e.getDamager() instanceof Projectile){
        Projectile proj = (Projectile)e.getDamager();
        if (proj.getShooter() instanceof Player){
            p = (Player) proj.getShooter();
        }           
       } 

       if (p != null){
        RedProtect.get().logger.debug("Player: " + p.getName()); 
       } else {
        RedProtect.get().logger.debug("Player: is null"); 
        return;
       }

       RedProtect.get().logger.debug("Damager: " + e.getDamager().getType().name()); 

       //check killaura or freekill
       if (RPConfig.getBool("server-protection.check-killaura-freekill.enable")){
        startCheckRate(p.getName());
       }

       Location l = e.getEntity().getLocation();
       Region r = RedProtect.get().rm.getTopRegion(l);
       if (r == null){
        return;
       }

       if (RedProtect.get().tpWait.contains(p.getName())){
        RedProtect.get().tpWait.remove(p.getName());
        RPLang.sendMessage(p, "cmdmanager.region.tpcancelled");
    }

       if (e.getEntity() instanceof Player && !p.equals(e.getEntity()) && r.flagExists("pvp") && !r.canPVP((Player)e.getEntity(), p)){
        RPLang.sendMessage(p, "entitylistener.region.cantpvp");
           e.setCancelled(true);
       }

       if ((e.getEntity() instanceof Hanging || e.getEntity() instanceof EnderCrystal) && !r.canBuild(p) && !r.canBreak(e.getEntityType())){
        RPLang.sendMessage(p, "playerlistener.region.cantremove");
        e.setCancelled(true);
       }   

       if ((e.getEntity() instanceof Boat || e.getEntity() instanceof Minecart) && !r.canMinecart(p)){
        RPLang.sendMessage(p, "blocklistener.region.cantbreak");
        e.setCancelled(true);
       }    
}

/**
 * Projects all chests inside triangles or on beacons
 * @param event
 */
@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onInventoryOpen(final InventoryOpenEvent event) {
    //getLogger().info("DEBUG: inventory type = " + event.getInventory().getType());
    World world = event.getPlayer().getWorld();
    if (!world.equals(getBeaconzWorld())) {
        return;
    }
    // Check what type of inventory this is
    if (event.getInventory().getType().equals(InventoryType.PLAYER)) {
        return;
    }
    InventoryHolder invHolder = event.getInventory().getHolder();
    Location invLoc = null;
    if (invHolder instanceof Horse) {
        invLoc = ((Horse) invHolder).getLocation();
    } else if (invHolder instanceof Minecart) {
        invLoc = ((Minecart) invHolder).getLocation();
    } else {
        invLoc = event.getInventory().getLocation();
    }
    if (invLoc == null) {
        return;
    }
    Player player = (Player) event.getPlayer();
    Game game = getGameMgr().getGame(player.getLocation());
    if (game != null) {
        Team team = game.getScorecard().getTeam(player);         
        // Check beacon defense            
        BeaconObj beacon = getRegister().getBeaconAt(invLoc);
        if (beacon != null) {
            if (!beacon.getOwnership().equals(team)) {
                player.sendMessage(ChatColor.RED + Lang.triangleThisBelongsTo.replace("[team]", beacon.getOwnership().getDisplayName()));
                event.setCancelled(true);
                return;
            }
        }
        // Check triangle
        /*
        for (TriangleField triangle : getRegister().getTriangle(invLoc.getBlockX(), invLoc.getBlockZ())) {
            if (!triangle.getOwner().equals(team)) {
                player.sendMessage(ChatColor.RED + Lang.triangleThisBelongsTo.replace("[team]", triangle.getOwner().getDisplayName()));
                event.setCancelled(true);
                return;
            }
        }*/
    }
}

public RoutePlayer(Player player, Minecart minecart, Route route) {
    this.player = player;
    this.minecart = minecart;
    this.route = route;
}

public Minecart getMinecart() {
    return this.minecart;
}

@Override
public boolean run(CommandSender sender, Player sender_p, Command cmd, String commandLabel, String[] args, boolean senderIsConsole)
{
    Player targetPlayer = sender_p;

    if (args.length == 1)
    {
        try
        {
            targetPlayer = getPlayer(args[0]);
        }
        catch (PlayerNotFoundException ex)
        {
            sender.sendMessage(ex.getMessage());
            return true;
        }
    }

    if (senderIsConsole)
    {
        if (targetPlayer == null)
        {
            sender.sendMessage("When used from the console, you must define a target player: /cartsit <player>");
            return true;
        }
    }
    else if (targetPlayer != sender_p && !TFM_SuperadminList.isUserSuperadmin(sender))
    {
        sender.sendMessage("Only superadmins can select another player as a /cartsit target.");
        return true;
    }

    if (targetPlayer.isInsideVehicle())
    {
        targetPlayer.getVehicle().eject();
    }
    else
    {
        Minecart nearest_cart = null;
        for (Minecart cart : targetPlayer.getWorld().getEntitiesByClass(Minecart.class))
        {
            if (cart.isEmpty())
            {
                if (nearest_cart == null)
                {
                    nearest_cart = cart;
                }
                else
                {
                    if (cart.getLocation().distanceSquared(targetPlayer.getLocation()) < nearest_cart.getLocation().distanceSquared(targetPlayer.getLocation()))
                    {
                        nearest_cart = cart;
                    }
                }
            }
        }

        if (nearest_cart != null)
        {
            nearest_cart.setPassenger(targetPlayer);
        }
        else
        {
            sender.sendMessage("There are no empty minecarts in the target world.");
        }
    }

    return true;
}

@Override
public boolean canExecute(Minecart minecart) {

    return true;
}

@EventHandler
public void oohYouTouchMyTaLaLa(PlayerMoveEvent e) {
    Player p = e.getPlayer();
    if (!RUtils.isInInfectedWorld(p) || p.getGameMode() == GameMode.CREATIVE) return;
    if (p.getVehicle() != null && p.getVehicle() instanceof Minecart) return; // don't penalize for minecarts
    Location from = e.getFrom();
    Location to = e.getTo();
    if (from.getX() == to.getX() && from.getY() == to.getY() && from.getZ() == to.getZ()) return; // looking around
    PConfManager pcm = PConfManager.getPConfManager(p);
    Float saturation = pcm.getFloat("thirstSaturation");
    if (saturation == null) saturation = (float) Config.thirstSaturationMax;
    if (saturation > 0F) {
        if (p.isSprinting()) saturation -= Config.thirstSprint;
        else if (p.isSneaking()) saturation -= Config.thirstSneak;
        else saturation -= Config.thirstWalk;
        if (to.getY() > from.getY() && !RUtils.isOnLadder(p)) saturation -= Config.thirstJump;
        pcm.set("thirstSaturation", saturation);
        return;
    }
    float thirst = pcm.getFloat("thirst");
    if (!pcm.isSet("thirst")) thirst = 1F;
    thirst *= Config.thirstMax;
    if (p.isSprinting()) thirst -= Config.thirstSprint;
    else if (p.isSneaking()) thirst -= Config.thirstSneak;
    else thirst -= Config.thirstWalk;
    Biome b = p.getLocation().getBlock().getBiome();
    long time = p.getWorld().getTime();
    if ((b == Biome.DESERT || b == Biome.DESERT_HILLS) && (time > 0L && time < 12000L) && !RUtils.isInShade(p))
        thirst -= Config.thirstDesert;
    // jump check (disregard ladders)
    if (to.getY() > from.getY() && !RUtils.isOnLadder(p)) thirst -= Config.thirstJump;
    if (thirst <= 0F) {
        p.sendMessage(ChatColor.BLUE + "You have died of dehydration.");
        p.setLastDamageCause(new EntityDamageEvent(p, EntityDamageEvent.DamageCause.CUSTOM, p.getHealth()));
        p.setHealth(0);
        p.setExp(1F);
        pcm.set("thirst", 1F);
        return;
    }
    thirst /= Config.thirstMax;
    pcm.set("thirst", thirst);
    p.setExp(thirst);
}

private void fixCart(Vehicle cart) {
    if (cart.getType() == EntityType.MINECART) {
           ((Minecart)cart).setFlyingVelocityMod(desiredVelocityMod);
    }
}