Esempio n. 1
0
  protected void b(float f) {
    if (f > 1.0F) {
      this.makeSound("mob.horse.land", 0.4F, 1.0F);
    }

    int i = MathHelper.f(f * 0.5F - 3.0F);

    if (i > 0) {
      // CraftBukkit start - fire EntityDamageEvent
      EntityDamageEvent event =
          CraftEventFactory.callEntityDamageEvent(
              null, this, EntityDamageEvent.DamageCause.FALL, i);
      if (!event.isCancelled()) {
        float damage = (float) event.getDamage();
        if (damage > 0) {
          this.getBukkitEntity().setLastDamageCause(event);
          this.damageEntity(DamageSource.FALL, damage);
        }
      }

      if (this.passenger != null) {
        EntityDamageEvent passengerEvent =
            CraftEventFactory.callEntityDamageEvent(
                null, this.passenger, EntityDamageEvent.DamageCause.FALL, i);
        if (!passengerEvent.isCancelled()
            && this.passenger != null) { // Check again in case of plugin
          float damage = (float) passengerEvent.getDamage();
          if (damage > 0) {
            this.passenger.getBukkitEntity().setLastDamageCause(passengerEvent);
            this.passenger.damageEntity(DamageSource.FALL, damage);
          }
        }
        // CraftBukkit end
      }

      Block block =
          this.world.getType(
              MathHelper.floor(this.locX),
              MathHelper.floor(this.locY - 0.2D - (double) this.lastYaw),
              MathHelper.floor(this.locZ));

      if (block.getMaterial() != Material.AIR) {
        StepSound stepsound = block.stepSound;

        this.world.makeSound(
            this,
            stepsound.getStepSound(),
            stepsound.getVolume1() * 0.5F,
            stepsound.getVolume2() * 0.75F);
      }
    }
  }
  @EventHandler
  public void onEntityDamage(EntityDamageEvent event) {
    if (event.isCancelled()) {
      return;
    }
    Entity entity = event.getEntity();

    if (!(entity instanceof Player)) {
      return;
    }

    if (instance.getCitizensCommunicator().isNPC(entity, instance)
        || Utils.getInstance().isUnrestricted((Player) entity)
        || CombatTagComunicator.isNPC(entity)) {
      return;
    }

    Player player = (Player) entity;
    String name = player.getName().toLowerCase();

    if (PlayerCache.getInstance().isAuthenticated(name)) {
      return;
    }

    if (!data.isAuthAvailable(name)) {
      if (!Settings.isForcedRegistrationEnabled) {
        return;
      }
    }
    player.setFireTicks(0);
    event.setCancelled(true);
  }
 @EventHandler(priority = EventPriority.HIGHEST)
 public void onEntityDamageEvent(EntityDamageEvent event) {
   if (event.isCancelled()) {
     return;
   }
   if (!(event.getEntity() instanceof Player)) {
     return;
   }
   Player p = (Player) event.getEntity();
   ItemStack iimh = p.getEquipment().getItemInMainHand();
   Tier t = iimh != null ? TierUtil.getTierFromItemStack(iimh) : null;
   if (t != null && t.isInfiniteDurability()) {
     p.getEquipment().getItemInMainHand().setDurability((short) 0);
   }
   for (ItemStack is : p.getEquipment().getArmorContents()) {
     if (is == null || is.getType() == Material.AIR) {
       continue;
     }
     t = TierUtil.getTierFromItemStack(is);
     if (t == null) {
       continue;
     }
     if (t.isInfiniteDurability()) {
       is.setDurability((short) 0);
     }
   }
 }
Esempio n. 4
0
  @EventHandler(priority = EventPriority.MONITOR)
  public void onEntityDamage(EntityDamageEvent event) {

    if (event.isCancelled()) {
      return;
    }

    Entity p2 = event.getEntity();

    db.i(
        "onEntityDamage: cause: " + event.getCause().name() + " : " + event.getEntity().toString());

    if ((p2 == null) || (!(p2 instanceof Player))) {
      return;
    }

    Arena arena = Arenas.getArenaByPlayer((Player) p2);
    if (arena == null) {
      // defender no arena player => out
      return;
    }

    Player defender = (Player) p2;

    ArenaPlayer apDefender = ArenaPlayer.parsePlayer(defender);

    if (arena.REALEND_ID != -1
        || (!apDefender.getStatus().equals(Status.EMPTY)
            && !apDefender.getStatus().equals(Status.FIGHT))) {
      event.setCancelled(true);
      return;
    }
  }
Esempio n. 5
0
  @EventHandler(priority = EventPriority.HIGH)
  public void onEntityDamage(EntityDamageEvent event_) {
    // If the event is cancelled, then we want to return.
    if (event_.isCancelled() == true) return;

    // Block damage in creative world.
    WorldConfig wm = new WorldConfig();

    if (!wm.getIsRpg(event_.getEntity().getWorld().getName())) return;

    // Store event.
    event = event_;

    // Set defaults.
    setGlobalDefaults();

    // Always set event damage to 0.
    event.setDamage(0);

    boolean dealEnviromentalDamage = false;

    // For entity damage events we want to handle the attck normally.
    if (event instanceof EntityDamageByEntityEvent) {
      Entity damager = ((EntityDamageByEntityEvent) event).getDamager();

      if (damager.getType() == EntityType.WITHER) dealEnviromentalDamage = true;
      else if (damager.getType() == EntityType.WITHER_SKULL) dealEnviromentalDamage = true;
      else if (damager.getType() == EntityType.SPLASH_POTION) dealEnviromentalDamage = true;
      else if (damager.getType() == EntityType.PRIMED_TNT) dealEnviromentalDamage = true;
      else entityAttack((EntityDamageByEntityEvent) event, -1);
    } else dealEnviromentalDamage = true;

    // Else we want to deal the damage to the player/mob as though not from an entity.
    if (dealEnviromentalDamage == true) {
      // If the defender is a player, then we attacker player defender.
      if (event.getEntity() instanceof Player) {
        Player player = (Player) event.getEntity();

        // Prevent damage done to already dead players
        if (FC_Rpg.rpgEntityManager.getRpgPlayer(player).playerConfig.getIsActive() == true) {
          if (FC_Rpg.rpgEntityManager.getRpgPlayer(player).getIsAlive() == false) return;
        }

        // Prepare the defender.
        prepareDefender(player);

        double damage = getEnviromentalDamage(player);

        if (damage == 0) return;

        // Attack the player with enviromental damage.
        edm.attackPlayerDefender(
            rpgDefender, null, null, damage, damageType, event.getCause().toString());
      } else {
        // If the event entity is a livingentity and the damage isn't fall damage, then nuke.
        if (event.getCause() != DamageCause.FALL && event.getEntity() instanceof LivingEntity)
          edm.nukeMob((LivingEntity) event.getEntity());
      }
    }
  }
 @EventHandler
 public void onEntityDamage(EntityDamageEvent event) {
   if (!(event.isCancelled())
       && ((event.getCause().equals(DamageCause.ENTITY_EXPLOSION))
           || (event.getCause().equals(DamageCause.BLOCK_EXPLOSION)))
       && (event.getEntity() instanceof Player)) {
     Player player = (Player) event.getEntity();
     Hero hero = plugin.getCharacterManager().getHero(player);
     if (hero.hasEffect("BlastResistance")) {
       int level = hero.getSkillLevel(this.skill);
       double amount =
           (SkillConfigManager.getUseSetting(
                   hero, this.skill, Setting.AMOUNT.node(), 0.25, false)
               + (SkillConfigManager.getUseSetting(
                       hero, this.skill, "amount-increase", 0.0, false)
                   * level));
       if (hst != null)
         amount +=
             (SkillConfigManager.getUseSetting(hero, skill, "hst-amount", 0.0, false)
                 * (hst.getSkillLevel(hero, skill) - 1));
       amount = amount > 0 ? amount : 0;
       event.setDamage((int) (event.getDamage() * (1 - amount)));
     }
   }
 }
Esempio n. 7
0
  public static EventData getEventData(EntityDamageEvent event) {
    if (event == null) return null;

    DamageType damageElement = DamageType.get(event.getCause());

    Entity attacker = null;
    Projectile projectile = null;
    Entity target = event.getEntity();
    World world = target.getWorld();

    if (event instanceof EntityDamageByEntityEvent) {
      EntityDamageByEntityEvent event_EE = (EntityDamageByEntityEvent) event;
      Entity damager = event_EE.getDamager();

      if (damager instanceof Projectile) {
        projectile = (Projectile) damager;

        attacker = projectile.getShooter();
      } else {
        attacker = damager;
      }
    }

    return myInfo.makeData(
        attacker, projectile, target, world, damageElement, event.getDamage(), event.isCancelled());
  }
 @EventHandler(priority = EventPriority.LOWEST)
 public void onEntityDamage(EntityDamageEvent event) {
   if (event.getEntity() instanceof SpoutPlayer) {
     event.setCancelled(
         event.isCancelled() || !((SpoutPlayer) event.getEntity()).isPreCachingComplete());
   }
 }
    // Damage Hook
    public void onEntityDamage(EntityDamageEvent event) {
      // No point in running if this has been stopped
      if (event.isCancelled()) {
        return;
      }

      // Is this a player?
      if (event.getEntity() instanceof Player) {
        Player player = (Player) event.getEntity();
        PotionEntry entry = getPlugin().BuffList.get(player);

        // Elixir of Obsidian Skin
        if (entry != null && entry.HasBuff.get(Name) != null && entry.HasBuff.get(Name)) {
          // Halve all damages that have sources.
          // (Note, this means that direct damage through plugins
          // and such are left alone)
          if (event.getCause() != null) {
            int damage = event.getDamage();
            damage = (int) (damage * 0.5);
            damage = Math.max(damage, 1);
            event.setDamage(damage);
          }
        }
      }
    }
 // Non-Living Entities such as EntityEnderCrystal need to call this
 public static boolean handleNonLivingEntityDamageEvent(
     Entity entity, DamageSource source, int damage) {
   if (!(source instanceof EntityDamageSource)) {
     return false;
   }
   EntityDamageEvent event = handleEntityDamageEvent(entity, source, damage);
   return event.isCancelled() || event.getDamage() == 0;
 }
  public void onEntityDamage(EntityDamageEvent event) {
    if (event.isCancelled()) return;

    if (event.getEntity() instanceof Player) {
      String playerName = ((Player) event.getEntity()).getName();
      if (AdminHandler.isGod(playerName)) event.setCancelled(true);
    }
  }
    @EventHandler
    public void onEntityDamage(EntityDamageEvent event) {
      Heroes.debug.startTask("HeroesSkillListener");
      if ((event.isCancelled()) || (!(event instanceof EntityDamageByEntityEvent))) {
        Heroes.debug.stopTask("HeroesSkillListener");
        return;
      }

      Entity projectile = ((EntityDamageByEntityEvent) event).getDamager();
      if ((!(projectile instanceof Arrow))
          || (!(((Projectile) projectile).getShooter() instanceof Player))) {
        Heroes.debug.stopTask("HeroesSkillListener");
        return;
      }

      Player player = (Player) ((Projectile) projectile).getShooter();
      Hero hero = SkillExplodingArrow.this.plugin.getCharacterManager().getHero(player);
      if (!hero.hasEffect("ExplodingArrowBuff")) {
        Heroes.debug.stopTask("HeroesSkillListener");
        return;
      }

      int radius =
          (int)
              Math.pow(
                  SkillConfigManager.getUseSetting(hero, this.skill, "radius", 5, false), 2.0D);

      float damage = SkillConfigManager.getUseSetting(hero, this.skill, "DAMAGE", 5, false);
      float blockdamage = damage;
      int block_dmg = SkillConfigManager.getUseSetting(hero, this.skill, "block-dmg", 0, false);

      if (block_dmg == 0) {
        blockdamage = 0.0F;

        for (Entity t_entity : player.getWorld().getEntities()) {
          if ((t_entity instanceof Player)) {
            Player heroes = (Player) t_entity;
            if (heroes.getLocation().distanceSquared(projectile.getLocation()) <= radius)
              SkillExplodingArrow.damageEntity(
                  heroes, player, (int) damage, EntityDamageEvent.DamageCause.ENTITY_EXPLOSION);
          } else if ((t_entity instanceof Creature)) {
            Creature mob = (Creature) t_entity;
            if (t_entity.getLocation().distanceSquared(projectile.getLocation()) <= radius) {
              SkillExplodingArrow.damageEntity(
                  mob, player, (int) damage, EntityDamageEvent.DamageCause.ENTITY_EXPLOSION);
            }
          }
        }
      }

      projectile.getWorld().createExplosion(projectile.getLocation(), blockdamage);

      Heroes.debug.stopTask("HeroesSkillListener");
    }
 /* (non-Javadoc)
  * @see org.bukkit.event.entity.EntityListener#onEntityDamage(org.bukkit.event.entity.EntityDamageEvent)
  */
 @Override
 public void onEntityDamage(EntityDamageEvent event) {
   if (!event.isCancelled()
       && (event.getCause().equals(DamageCause.FIRE)
           || event.getCause().equals(DamageCause.FIRE_TICK)
           || event.getCause().equals(DamageCause.LAVA))) {
     if (event.getEntity() instanceof Player) {
       Player p = (Player) event.getEntity();
       if (ConfigManager.getPortalMaterial().equals(Material.STATIONARY_LAVA)) {
         Location current = p.getLocation();
         Stargate closest = Stargate.FindClosestStargate(current);
         if (closest != null) {
           double blockDistanceSquared =
               Stargate.distanceSquaredToClosestGateBlock(current, closest);
           if (closest.Active
               && ((blockDistanceSquared <= closest.GateShape.woosh_depth_squared
                       && closest.GateShape.woosh_depth != 0)
                   || blockDistanceSquared <= 16)) {
             WormholeXTreme.thisPlugin.prettyLog(
                 Level.FINE,
                 false,
                 "Blocked Gate: \""
                     + closest.Name
                     + "\" Proximity Event: \""
                     + event.getCause().toString()
                     + "\" On: \""
                     + p.getName()
                     + "\" Distance Squared: \""
                     + blockDistanceSquared
                     + "\"");
             event.setCancelled(true);
             p.setFireTicks(0);
           } else if (!closest.Active && blockDistanceSquared <= 4) {
             WormholeXTreme.thisPlugin.prettyLog(
                 Level.FINE,
                 false,
                 "Blocked Gate: \""
                     + closest.Name
                     + "\" Proximity Event: \""
                     + event.getCause().toString()
                     + "\" On: \""
                     + p.getName()
                     + "\" Distance Squared: \""
                     + blockDistanceSquared
                     + "\"");
             event.setCancelled(true);
             p.setFireTicks(0);
           }
         }
       }
     }
   }
 }
Esempio n. 14
0
  @EventHandler(priority = EventPriority.HIGHEST)
  public void onEntityDamage(EntityDamageEvent event) {
    if (!ModDamage.isEnabled || event.isCancelled()) return;

    if (!event.isCancelled() && (event.getEntity() instanceof LivingEntity)) {
      EventData data = getEventData(event);
      if (data != null) {
        runRoutines(data);
        int newDamage = data.get(Integer.class, data.start + 5);

        event.setCancelled(data.get(Boolean.class, data.start + data.objects.length - 1));

        if (event.getDamage() != newDamage && newDamage <= 0) event.setCancelled(true);

        event.setDamage(newDamage);
      } else
        PluginConfiguration.log.severe(
            "["
                + Bukkit.getPluginManager().getPlugin("ModDamage").getDescription().getName()
                + "] Error! Unhandled damage event. Is Bukkit and ModDamage up-to-date?");
    }
  }
Esempio n. 15
0
  @SuppressWarnings("deprecation")
  @EventHandler()
  public void onEntityDamage(EntityDamageEvent event) {
    if (event.isCancelled()) return;
    Entity victim = event.getEntity();
    // Apply Wolf Armor or Invincibiliy
    JailPrisoner prisoner = Jail.guards.get(victim);
    JailZone jail = prisoner != null ? prisoner.getJail() : null;
    if (prisoner != null) {
      if (jail.getSettings().getBoolean(Setting.GuardInvincibility)) {
        event.setCancelled(true);
        return;
      }
      int newArmor =
          (int)
              (event.getDamage()
                  - (event.getDamage() * jail.getSettings().getInt(Setting.GuardArmor) / 100));
      if (newArmor <= 0) newArmor = 1;
      event.setDamage(newArmor);

      if (event instanceof EntityDamageByEntityEvent) {
        EntityDamageByEntityEvent eventD = (EntityDamageByEntityEvent) event;

        if (eventD.getDamager() instanceof LivingEntity)
          prisoner.getPossibleGuardTargets().add((LivingEntity) eventD.getDamager());
      }
    }
    if (!(event instanceof EntityDamageByEntityEvent)) return;
    EntityDamageByEntityEvent newevent = (EntityDamageByEntityEvent) event;
    Entity damager = newevent.getDamager();

    prisoner = Jail.guards.get(damager);
    jail = prisoner != null ? prisoner.getJail() : null;

    // Apply Wolf damage and damage speed change
    if (prisoner != null) {
      if (new Random().nextInt(100) > jail.getSettings().getInt(Setting.GuardAttackSpeedPercent)) {
        event.setCancelled(true);
        return;
      }
      event.setDamage(jail.getSettings().getInt(Setting.GuardDamage));
    }
    jail = JailZoneManager.getJail(victim.getLocation());
    if (jail != null
        && jail.getSettings().getBoolean(Setting.EnablePVPProtection)
        && victim instanceof Player
        && damager instanceof Player) {
      event.setCancelled(true);
      return;
    }
  }
  public void onEntityDamage(EntityDamageEvent event) {
    if (event.isCancelled()) return;
    if (!Whitelist.worldCheck(event.getEntity().getWorld())) return;
    if (!(event.getEntity() instanceof Player)) return;
    if (!Whitelist.hasLevel((Player) event.getEntity(), plugin.thisPlug)) return;
    if (event.getCause() != DamageCause.FALL) return;
    Player p = (Player) event.getEntity();
    int lvl = LevelFunctions.getLevel(p, plugin.thisPlug);
    int damageReduction = (int) ((lvl / 10) * plugin.LCConfiguration.fdMultiplier);

    if (event.getDamage() <= damageReduction) {
      event.setDamage(0);
    } else {
      event.setDamage(event.getDamage() - damageReduction);
    }
  }
  @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
  public void onEntityDamage(EntityDamageEvent event) {
    if (event.isCancelled()) return;
    Log.logInfo("OnEntityDamage (victim: " + event.getEntity().toString() + ")", EXTREME);

    // Check if the damager is a player - if so, weapon is the held tool
    if (event instanceof EntityDamageByEntityEvent) {
      EntityDamageByEntityEvent e = (EntityDamageByEntityEvent) event;
      if (e.getEntity() == null) {
        Log.logInfo("EntityDamageByEntity but .getEntity() is null?");
        return;
      }
    }
    OccurredEvent drop = new OccurredEvent(event, "hit");
    parent.sectionManager.performDrop(drop);
  }
Esempio n. 18
0
  protected void b(float f) {
    super.b(f);
    MobEffect mobeffect = this.getEffect(MobEffectList.JUMP);
    float f1 = mobeffect != null ? (float) (mobeffect.getAmplifier() + 1) : 0.0F;
    // CraftBukkit start
    float i = MathHelper.f(f - 3.0F - f1);

    if (i > 0) {
      EntityDamageEvent event =
          CraftEventFactory.callEntityDamageEvent(
              null, this, EntityDamageEvent.DamageCause.FALL, i);
      if (event.isCancelled()) {
        return;
      }

      i = (float) event.getDamage();
      if (i > 0) {
        this.getBukkitEntity().setLastDamageCause(event);
      }
    }
    // CraftBukkit end

    if (i > 0) {
      if (i > 4) {
        this.makeSound("damage.fallbig", 1.0F, 1.0F);
      } else {
        this.makeSound("damage.fallsmall", 1.0F, 1.0F);
      }

      this.damageEntity(DamageSource.FALL, (float) i);
      int j =
          this.world.getTypeId(
              MathHelper.floor(this.locX),
              MathHelper.floor(this.locY - 0.20000000298023224D - (double) this.height),
              MathHelper.floor(this.locZ));

      if (j > 0) {
        StepSound stepsound = Block.byId[j].stepSound;

        this.makeSound(
            stepsound.getStepSound(),
            stepsound.getVolume1() * 0.5F,
            stepsound.getVolume2() * 0.75F);
      }
    }
  }
    // Damage Hook
    public void onEntityDamage(EntityDamageEvent event) {
      // No point in running if this has been stopped
      if (event.isCancelled()) {
        return;
      }

      // Check if Firetouch user hit another entity
      ElixirMod plugin = getPlugin();
      if (event instanceof EntityDamageByEntityEvent) {
        Entity damager = ((EntityDamageByEntityEvent) event).getDamager();
        Entity damagee = event.getEntity();

        // Check if damager is a player
        if (damager instanceof Player) {
          Player player = (Player) damager;
          PotionEntry entry = plugin.BuffList.get(player);

          // See if that player has Firetouch
          if (entry != null) {
            if (entry.HasBuff.get(Name) != null && entry.HasBuff.get(Name)) {

              // Check if we can ignite with any damage, else unarmed only
              boolean canIgnite = false;
              if (unarmedOnly) {
                if (((Player) damager).getItemInHand().getTypeId() == 0) {
                  canIgnite = true;
                }
              } else {
                canIgnite = true;
              }

              if (canIgnite) {
                // If target is on fire, ignore, else ignite
                if (damagee.getFireTicks() <= 0) {
                  // Chance ignite
                  int chance = 1 + (int) (Math.random() * (100 - 1));
                  if (chance <= igniteChance) {
                    damagee.setFireTicks(igniteLength * 20);
                  }
                }
              }
            }
          }
        }
      }
    }
Esempio n. 20
0
  @Override
  public void onEntityDamage(EntityDamageEvent event) {
    if (event.isCancelled()) {
      return;
    }

    // Check if the event is about a player that is drowning
    if (event.getCause() == EntityDamageEvent.DamageCause.DROWNING
        && event.getEntity() instanceof CraftPlayer) {
      final CraftPlayer player = (CraftPlayer) event.getEntity();

      // Check if user got unlimited air node
      if (PermissionsHandler.hasPermission(player, Gills.getConfig().unlimitedAirNode)) {
        updatePlayerAirBubbles(player);
        event.setCancelled(true);
        return;
      }

      // Check if user access to gills
      if (!PermissionsHandler.hasPermission(player, Gills.getConfig().userNode)) {
        return;
      }

      int depth = getDepth(player);
      // Check itemsets
      for (GillsItemSet itemSet : Gills.getConfig().itemSets) {
        if (PermissionsHandler.hasPermission(player, itemSet.getNode())
            && itemSet.isTargetDepth(depth)
            && itemSet.isTargetAltitude(player.getLocation().getBlockY())
            && itemSet.isWorldAllowed(player.getLocation().getWorld().getName())
            && itemSet.gotRequiredItems(player)) {

          // Check is inside itemSet
          itemSet.consumeRequiredItems(player);

          updatePlayerAirBubbles(player);
          event.setCancelled(true);
          return;
        }
      }
    }
  }
Esempio n. 21
0
	@Override
	public void run(final CommandSender sender, final String commandLabel, final String[] args) throws Exception
	{
		if (args.length < 1)
		{
			throw new NotEnoughArgumentsException();
		}

		for (Player matchPlayer : server.matchPlayer(args[0]))
		{
			final EntityDamageEvent ede = new EntityDamageEvent(matchPlayer, sender instanceof Player && ((Player)sender).getName().equals(matchPlayer.getName()) ? EntityDamageEvent.DamageCause.SUICIDE : EntityDamageEvent.DamageCause.CUSTOM, Short.MAX_VALUE);
			server.getPluginManager().callEvent(ede);
			if (ede.isCancelled() && !sender.hasPermission("essentials.kill.force"))
			{
				continue;
			}

			matchPlayer.damage(Short.MAX_VALUE);
			sender.sendMessage(_("kill", matchPlayer.getDisplayName()));
		}
	}
Esempio n. 22
0
  protected void a(int i) {
    if (!this.bD) {
      // CraftBukkit start
      if (this instanceof EntityLiving) {
        CraftServer server = ((WorldServer) this.world).getServer();
        org.bukkit.entity.Entity damagee = this.getBukkitEntity();
        DamageCause damageType = EntityDamageEvent.DamageCause.FIRE;
        int damageDone = i;

        EntityDamageEvent event = new EntityDamageEvent(damagee, damageType, damageDone);
        server.getPluginManager().callEvent(event);

        if (event.isCancelled()) {
          return;
        }

        i = event.getDamage();
      }
      // CraftBukkit end
      this.damageEntity((Entity) null, i);
    }
  }
  @EventHandler
  public void entityDamageEvent(EntityDamageEvent e) {
    if (e.isCancelled()) return;
    if (!Minegusta.getServer().containsWorld(e.getEntity().getWorld())) return;

    DwarfPower arrowWeakness = DwarfPower.arrowWeaknesBoost(e);
    ElfPower fireWeakness = ElfPower.fireDamage(e);
    EnderbornPower fallDamage = EnderbornPower.fallDamageBoost(e);

    if (arrowWeakness.isProjectile()
        && arrowWeakness.isPlayer()
        && arrowWeakness.isDwarf()
        && arrowWeakness.canPVP()) {
      arrowWeakness.applyProjectileWeakness();
    }
    if (fireWeakness.isFireDamage() && fireWeakness.isPlayer() && fireWeakness.isElf()) {
      fireWeakness.applyFireDamage();
    }

    if (fallDamage.isPlayer() && fallDamage.entityIsEnderBorn() && fallDamage.isFallDamage()) {
      fallDamage.cancelFallDamae();
    }
  }
Esempio n. 24
0
 @EventHandler
 public void onEntityDamage(EntityDamageEvent event) {
   if (event.isCancelled()) {
     return;
   }
   LivingEntity attacker = null;
   Entity defender = event.getEntity();
   if (event.getCause() == EntityDamageEvent.DamageCause.ENTITY_ATTACK) {
     EntityDamageByEntityEvent e = (EntityDamageByEntityEvent) event;
     if ((e.getDamager() instanceof LivingEntity)) attacker = (LivingEntity) e.getDamager();
   } else if (event.getCause() == EntityDamageEvent.DamageCause.PROJECTILE) {
     EntityDamageByEntityEvent e = (EntityDamageByEntityEvent) event;
     Projectile arrow = (Projectile) e.getDamager();
     if ((arrow.getShooter() instanceof LivingEntity)) {
       attacker = arrow.getShooter();
     }
   }
   if (((attacker instanceof Player))
       && ((defender instanceof LivingEntity))
       && (!attacker.equals(defender))) {
     perPlayer per = (perPlayer) data.get(attacker);
     if (per != null) per.setTarget((LivingEntity) defender);
   }
 }
Esempio n. 25
0
  /**
   * In this entity-damage-listener we will cancel fall damage and suffocation damage for vampires.
   * We will also modify the damage dealt.
   */
  @EventHandler(priority = EventPriority.HIGH)
  public void onEntityDamageHigh(EntityDamageEvent event) {
    if (event.isCancelled()) return;

    // Define local fields
    Entity damagee;
    Player pDamagee;
    VPlayer vpDamagee;

    EntityDamageByEntityEvent edbeEvent;

    Entity damager;
    Player pDamager;
    VPlayer vpDamager;

    damagee = event.getEntity();

    // If the damagee is a player
    if (damagee instanceof Player) {
      pDamagee = (Player) damagee;
      vpDamagee = VPlayers.i.get(pDamagee);

      // Vampires can not drown or take fall damage or starve
      if (vpDamagee.isVampire() && Conf.vampiresCantTakeDamageFrom.contains(event.getCause())) {
        event.setCancelled(true);
        return;
      }
    }

    // For further interest this must be a close combat attack by another entity
    if (event.getCause() != DamageCause.ENTITY_ATTACK) return;
    if (!(event instanceof EntityDamageByEntityEvent)) return;

    edbeEvent = (EntityDamageByEntityEvent) event;
    damager = edbeEvent.getDamager();

    // For further interest that attacker must be a player.
    if (!(damager instanceof Player)) return;
    pDamager = (Player) damager;
    vpDamager = VPlayers.i.get(pDamager);

    // The damage will be modified under certain circumstances.
    float damage = event.getDamage();

    // Modify damage if damager is a vampire
    if (vpDamager.isVampire()) {
      damage *= vpDamager.getDamageDealtFactor();
    }

    // Modify damage if damagee is a vampire
    if (damagee instanceof Player) {
      pDamagee = (Player) damagee;
      vpDamagee = VPlayers.i.get(pDamagee);
      if (vpDamagee.isVampire()) {
        Material itemMaterial = pDamager.getItemInHand().getType();
        if (Conf.woodMaterials.contains(itemMaterial)) {
          damage = Conf.damageReceivedWood; // Just as much as a diamond sword.
          vpDamagee.msg(Lang.messageWoodCombatWarning, Txt.getMaterialName(itemMaterial));
        } else {
          damage *= vpDamagee.getDamageReceivedFactor();
        }
      }
    }

    event.setDamage(Math.round(damage));
  }
  @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
  public void onPlayerDamage(EntityDamageEvent event) {
    if (event.getEntity() instanceof Player) {
      Player player = (Player) event.getEntity();
      BendingPlayer bender = BendingPlayer.getBendingPlayer(player);
      String ability = bender.getAbility();

      if (event.getCause() == DamageCause.FALL) {
        BendingPassiveAbility ab = null;
        if (bender != null && bender.isBender(BendingElement.EARTH)) {
          ab =
              new EarthPassive(
                  AbilityManager.getManager().getRegisteredAbility(EarthPassive.NAME), player);
          if (ab.start()) {
            AbilityManager.getManager().addInstance(ab);
            player.setFallDistance(0);
            event.setDamage(0);
            event.setCancelled(true);
            return;
          }

          if (MetalWire.hasNoFallDamage(player)) {
            player.setFallDistance(0);
            event.setDamage(0);
            event.setCancelled(true);
            return;
          }
        }

        if (bender != null
            && bender.isBender(BendingElement.AIR)
            && EntityTools.canBendPassive(player, BendingElement.AIR)) {
          if (AirBurst.NAME.equals(ability)) {
            BendingActiveAbility burst =
                AbilityManager.getManager().buildAbility(AirBurst.NAME, player);
            if (burst.canBeInitialized()) {
              burst.fall();
              if (burst.getState() != BendingAbilityState.START
                  && burst.getState() != BendingAbilityState.ENDED) {
                AbilityManager.getManager().addInstance(burst);
              }
            }
          }
          player.setFallDistance(0);
          event.setDamage(0);
          event.setCancelled(true);
          return;
        }

        if (!event.isCancelled() && EntityTools.isBender(player, BendingElement.WATER)) {
          ab =
              new WaterPassive(
                  AbilityManager.getManager().getRegisteredAbility(WaterPassive.NAME), player);
          AbilityManager.getManager().addInstance(ab);
          if (ab.start()) {
            player.setFallDistance(0);
            event.setDamage(0);
            event.setCancelled(true);
            return;
          }
        }

        if (!event.isCancelled()
            && bender.isBender(BendingElement.MASTER)
            && EntityTools.canBendPassive(player, BendingElement.MASTER)) {
          event.setDamage((int) (event.getDamage() * (Settings.MASTER_FALL_REDUCTION / 100.)));
          if (event.getEntity().getFallDistance() < 10) {
            event.setCancelled(true);
            return;
          }
        }

        if (!event.isCancelled() && EntityTools.isFallImmune(player)) {
          event.setCancelled(true);
          return;
        }
      }

      if (EntityTools.canBendPassive(player, BendingElement.FIRE)
          && EntityTools.isBender(player, BendingElement.FIRE)
          && ((event.getCause() == DamageCause.FIRE)
              || (event.getCause() == DamageCause.FIRE_TICK))) {
        event.setCancelled(!Enflamed.canBurn(player));
      }

      if (EntityTools.isBender(player, BendingElement.EARTH)
          && ((event.getCause() == DamageCause.SUFFOCATION)
              && TempBlock.isTempBlock(player.getEyeLocation().getBlock()))) {
        event.setDamage(0);
        event.setCancelled(true);
      }

      if (bender != null) {
        Map<Object, BendingAbility> instances =
            AbilityManager.getManager().getInstances(AvatarShield.NAME);
        if (instances.containsKey(player)) {
          AvatarShield ab = (AvatarShield) instances.get(player);
          if (ab.hit()) {
            event.setCancelled(true);
          }
        }
      }
    }
  }
Esempio n. 27
0
 @EventHandler(priority = EventPriority.NORMAL)
 public void onEntityDamage(EntityDamageEvent event) {
   if (event.isCancelled()) return;
   Entity ent = event.getEntity();
   boolean tamedWolf = ent instanceof Wolf ? ((Wolf) ent).isTamed() : false;
   ClaimedResidence area = Residence.getResidenceManager().getByLoc(ent.getLocation());
   /* Living Entities */
   if (event instanceof EntityDamageByEntityEvent) {
     EntityDamageByEntityEvent attackevent = (EntityDamageByEntityEvent) event;
     Entity damager = attackevent.getDamager();
     ClaimedResidence srcarea = null;
     if (damager != null)
       srcarea = Residence.getResidenceManager().getByLoc(damager.getLocation());
     boolean srcpvp = true;
     if (srcarea != null) srcpvp = srcarea.getPermissions().has("pvp", true);
     ent = attackevent.getEntity();
     if ((ent instanceof Player || tamedWolf)
         && (damager instanceof Player
             || (damager instanceof Arrow
                 && (((Arrow) damager).getShooter() instanceof Player)))) {
       Player attacker = null;
       if (damager instanceof Player) attacker = (Player) damager;
       else if (damager instanceof Arrow) attacker = (Player) ((Arrow) damager).getShooter();
       if (!srcpvp) {
         attacker.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPVPZone"));
         event.setCancelled(true);
         return;
       }
       /* Check for Player vs Player */
       if (area == null) {
         /* World PvP */
         if (!Residence.getWorldFlags().getPerms(damager.getWorld().getName()).has("pvp", true)) {
           attacker.sendMessage(
               ChatColor.RED + Residence.getLanguage().getPhrase("WorldPVPDisabled"));
           event.setCancelled(true);
         }
       } else {
         /* Normal PvP */
         if (!area.getPermissions().has("pvp", true)) {
           attacker.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPVPZone"));
           event.setCancelled(true);
         }
       }
       return;
     } else if ((ent instanceof Player || tamedWolf) && (damager instanceof Creeper)) {
       if (area == null) {
         if (!Residence.getWorldFlags()
             .getPerms(damager.getWorld().getName())
             .has("creeper", true)) {
           event.setCancelled(true);
         }
       } else {
         if (!area.getPermissions().has("creeper", true)) {
           event.setCancelled(true);
         }
       }
     }
   }
   if (area == null) {
     if (!Residence.getWorldFlags().getPerms(ent.getWorld().getName()).has("damage", true)
         && (ent instanceof Player || tamedWolf)) {
       event.setCancelled(true);
     }
   } else {
     if (!area.getPermissions().has("damage", true) && (ent instanceof Player || tamedWolf)) {
       event.setCancelled(true);
     }
   }
   if (event.isCancelled()) {
     /* Put out a fire on a player */
     if ((ent instanceof Player || tamedWolf)
         && (event.getCause() == EntityDamageEvent.DamageCause.FIRE
             || event.getCause() == EntityDamageEvent.DamageCause.FIRE_TICK)) {
       ent.setFireTicks(0);
     }
   }
 }
Esempio n. 28
0
  @EventHandler(priority = EventPriority.MONITOR)
  public void onEntityDamage(EntityDamageEvent event) {

    if (event.isCancelled() == false && !worlds.contains(event.getEntity().getWorld().getName())) {

      Entity attacker = null;
      Projectile projectile = null;
      if (event instanceof EntityDamageByEntityEvent) {
        EntityDamageByEntityEvent ed = (EntityDamageByEntityEvent) event;
        attacker = ed.getDamager();

        // handle arrow attacks
        if (ed.getDamager() instanceof Projectile) {
          projectile = ((Projectile) attacker);
          attacker = projectile.getShooter();
        }
      }

      Entity entity = event.getEntity();
      if (entity instanceof ComplexEntityPart) {
        entity = ((ComplexEntityPart) entity).getParent();
      }
      int damage = event.getDamage();
      DamageCause cause = event.getCause();
      // if the player gets attacked
      if (entity instanceof Player) {
        // global damage count
        playerStatManager
            .getPlayerBlob(((Player) entity).getName())
            .getStat("damagetaken", "total")
            .incrementStat(damage);
        // handle projectiles
        if (projectile != null) {
          playerStatManager
              .getPlayerBlob(((Player) entity).getName())
              .getStat(
                  "damagetaken", projectile.getType().toString().toLowerCase().replace("_", ""))
              .incrementStat(damage);
        }

        playerStatManager
            .getPlayerBlob(((Player) entity).getName())
            .getStat("damagetaken", cause.toString().toLowerCase().replace("_", ""))
            .incrementStat(damage);

        // pvp damage
        if (attacker instanceof Player) {
          playerStatManager
              .getPlayerBlob(((Player) entity).getName())
              .getStat("damagetaken", "player")
              .incrementStat(damage);
          playerStatManager
              .getPlayerBlob(((Player) attacker).getName())
              .getStat("damagedealt", "player")
              .incrementStat(damage);
          // mob damage
        } else if (attacker != null) {
          playerStatManager
              .getPlayerBlob(((Player) entity).getName())
              .getStat("damagetaken", attacker.getType().toString().toLowerCase().replace("_", ""))
              .incrementStat(damage);
        }

      } else {
        if (attacker instanceof Player) {
          // global damage dealt
          playerStatManager
              .getPlayerBlob(((Player) attacker).getName())
              .getStat("damagedealt", "total")
              .incrementStat(damage);
          playerStatManager
              .getPlayerBlob(((Player) attacker).getName())
              .getStat("damagedealt", cause.toString().toLowerCase().replace("_", ""))
              .incrementStat(damage);
          playerStatManager
              .getPlayerBlob(((Player) attacker).getName())
              .getStat("damagedealt", entity.getType().toString().toLowerCase().replace("_", ""))
              .incrementStat(damage);
        }
      }
    }
  }
Esempio n. 29
0
  public boolean damageEntity(DamageSource damagesource, float f) {
    if (this.isInvulnerable()) {
      return false;
    } else if (this.world.isStatic) {
      return false;
    } else {
      this.aV = 0;
      if (this.getHealth() <= 0.0F) {
        return false;
      } else if (damagesource.m() && this.hasEffect(MobEffectList.FIRE_RESISTANCE)) {
        return false;
      } else {
        if ((damagesource == DamageSource.ANVIL || damagesource == DamageSource.FALLING_BLOCK)
            && this.getEquipment(4) != null) {
          this.getEquipment(4).damage((int) (f * 4.0F + this.random.nextFloat() * f * 2.0F), this);
          f *= 0.75F;
        }

        this.aG = 1.5F;
        boolean flag = true;

        // CraftBukkit start
        EntityDamageEvent event = CraftEventFactory.handleEntityDamageEvent(this, damagesource, f);
        if (event != null) {
          if (event.isCancelled()) {
            return false;
          }
          f = (float) event.getDamage();
        }
        // CraftBukkit end

        if ((float) this.noDamageTicks > (float) this.maxNoDamageTicks / 2.0F) {
          if (f <= this.lastDamage) {
            return false;
          }

          this.d(damagesource, f - this.lastDamage);
          this.lastDamage = f;
          flag = false;
        } else {
          this.lastDamage = f;
          this.ax = this.getHealth();
          this.noDamageTicks = this.maxNoDamageTicks;
          this.d(damagesource, f);
          this.hurtTicks = this.az = 10;
        }

        this.aA = 0.0F;
        Entity entity = damagesource.getEntity();

        if (entity != null) {
          if (entity instanceof EntityLiving) {
            this.b((EntityLiving) entity);
          }

          if (entity instanceof EntityHuman) {
            this.lastDamageByPlayerTime = 100;
            this.killer = (EntityHuman) entity;
          } else if (entity instanceof EntityWolf) {
            EntityWolf entitywolf = (EntityWolf) entity;

            if (entitywolf.isTamed()) {
              this.lastDamageByPlayerTime = 100;
              this.killer = null;
            }
          }
        }

        if (flag) {
          this.world.broadcastEntityEffect(this, (byte) 2);
          if (damagesource != DamageSource.DROWN) {
            this.K();
          }

          if (entity != null) {
            double d0 = entity.locX - this.locX;

            double d1;

            for (d1 = entity.locZ - this.locZ;
                d0 * d0 + d1 * d1 < 1.0E-4D;
                d1 = (Math.random() - Math.random()) * 0.01D) {
              d0 = (Math.random() - Math.random()) * 0.01D;
            }

            this.aA = (float) (Math.atan2(d1, d0) * 180.0D / 3.1415927410125732D) - this.yaw;
            this.a(entity, f, d0, d1);
          } else {
            this.aA = (float) ((int) (Math.random() * 2.0D) * 180);
          }
        }

        if (this.getHealth() <= 0.0F) {
          if (flag) {
            this.makeSound(this.aP(), this.ba(), this.bb());
          }

          this.die(damagesource);
        } else if (flag) {
          this.makeSound(this.aO(), this.ba(), this.bb());
        }

        return true;
      }
    }
  }
Esempio n. 30
0
  /**
   * In this entity-damage-listener we will obtain blood, risk infections and break truce. Those
   * things does never cancel or alter an event so they belong at monitor level.
   */
  @EventHandler(priority = EventPriority.MONITOR)
  public void onEntityDamageMonitor(EntityDamageEvent event) {
    if (event.isCancelled()) return;

    // For further interest this must be a close combat attack by another entity
    if (event.getCause() != DamageCause.ENTITY_ATTACK && event.getCause() != DamageCause.PROJECTILE)
      return;
    if (!(event instanceof EntityDamageByEntityEvent)) return;

    // Define local fields
    Entity damagee = event.getEntity();
    Creature cDamagee;
    Player pDamagee;
    VPlayer vpDamagee;

    EntityDamageByEntityEvent edbeEvent = (EntityDamageByEntityEvent) event;

    Entity damager = edbeEvent.getDamager();
    Player pDamager;
    VPlayer vpDamager;

    // Consider the damager to be the shooter if this is a projectile
    if (damager instanceof Projectile) {
      damager = ((Projectile) damager).getShooter();
    }

    // For further interest that attacker must be a player.
    if (!(damager instanceof Player)) return;

    pDamager = (Player) damager;
    vpDamager = VPlayers.i.get(pDamager);

    if (vpDamager.isVampire()) {
      if (damagee instanceof Player) {
        // A True Blood vampire attacked a normal player. There is risk for infection.
        pDamagee = (Player) damagee;
        vpDamagee = VPlayers.i.get(pDamagee);

        vpDamagee.infectionContractRisk(vpDamager);

        // There will also be blood!
        if (pDamagee.getHealth() > 0) {
          int damage = event.getDamage();
          if (pDamagee.getHealth() < damage) {
            damage = pDamagee.getHealth();
          }
          vpDamager.foodAdd(damage * Conf.foodPerDamageFromPlayer);
          vpDamager.healthAdd(damage * Conf.healthPerDamageFromPlayer);
        }
      } else if (damagee instanceof Creature) {
        // A vampire attacked a creature
        cDamagee = (Creature) damagee;
        CreatureType creatureType = EntityUtil.creatureTypeFromEntity(damagee);

        // Obtain blood?
        if (Conf.foodPerDamageFromCreature.containsKey(creatureType) && cDamagee.getHealth() > 0) {
          int damage = event.getDamage();
          if (cDamagee.getHealth() < damage) {
            damage = cDamagee.getHealth();
          }
          vpDamager.foodAdd(damage * Conf.foodPerDamageFromCreature.get(creatureType));
          vpDamager.healthAdd(damage * Conf.healthPerDamageFromCreature.get(creatureType));
        }

        // Break truce
        if (Conf.creatureTypeTruceMonsters.contains(creatureType)) {
          vpDamager.truceBreak();
        }
      }
    } else if (damagee instanceof Player) {
      pDamagee = (Player) damagee;
      vpDamagee = VPlayers.i.get(pDamagee);

      if (vpDamagee.isVampire()) {
        vpDamager.infectionContractRisk(vpDamager);
      }
    }
  }