Ejemplo n.º 1
0
  @EventHandler(priority = EventPriority.NORMAL)
  public void onPlayerDamage(EntityDamageByEntityEvent evt) {
    if (evt.getDamager() instanceof Player) {
      Player p = (Player) evt.getDamager();

      if (p.hasPotionEffect(PotionEffectType.INCREASE_DAMAGE)) {
        for (PotionEffect eff : p.getActivePotionEffects()) {
          if (eff.getType().equals(PotionEffectType.INCREASE_DAMAGE)) {
            double div = (eff.getAmplifier() + 1) * 1.3D + 1.0D;
            int dmg;

            if (evt.getDamage() / div <= 1.0D) {
              dmg = (eff.getAmplifier() + 1) * 3 + 1;
            } else {
              double flatdmg = 2.0;
              dmg = (int) (evt.getDamage() / div) + (int) ((eff.getAmplifier() + 1) * flatdmg);
            }

            evt.setDamage(dmg);
            break;
          }
        }
      }
    }
  }
Ejemplo n.º 2
0
  public static void applySerratedStrikes(
      Player attacker, EntityDamageByEntityEvent event, mcMMO pluginx) {
    int targets = 0;

    if (event.getEntity() instanceof LivingEntity) {
      LivingEntity x = (LivingEntity) event.getEntity();
      targets = Utils.getTier(attacker);

      for (Entity derp : x.getWorld().getEntities()) {
        if (Utils.getDistance(x.getLocation(), derp.getLocation()) < 5) {

          // Make sure the Wolf is not friendly
          if (derp instanceof Wolf) {
            Wolf hurrDurr = (Wolf) derp;
            if (Taming.getOwner(hurrDurr, pluginx) == attacker) continue;
            //						if(Party.getInstance().inSameParty(attacker, Taming.getOwner(hurrDurr,
            // pluginx)))
            //							continue;
          }
          // Damage nearby LivingEntities
          if (derp instanceof LivingEntity && targets >= 1) {
            if (derp instanceof Player) {
              Player target = (Player) derp;

              if (target.getName().equals(attacker.getName())) continue;

              if (Users.getProfile(target).getGodMode()) continue;

              //		    				if(Party.getInstance().inSameParty(attacker, target))
              //		    					continue;
              if (targets >= 1 && derp.getWorld().getPVP()) {
                target.damage(event.getDamage() / 4);
                target.sendMessage(ChatColor.DARK_RED + "Struck by Serrated Strikes!");
                if (Combat.dealDamage(attacker, target, 0)) target.increaseBleedTicks(5);
                target.setLastCustomDamageCause(
                    new EntityDamageByEntityEvent(attacker, target, DamageCause.ENTITY_ATTACK, 0));
                targets--;
                continue;
              }
            } else {
              LivingEntity target = (LivingEntity) derp;
              target.increaseBleedTicks(5);
              target.damage(event.getDamage() / 4);
              target.setLastCustomDamageCause(
                  new EntityDamageByEntityEvent(attacker, target, DamageCause.ENTITY_ATTACK, 0));
              targets--;
            }
          }
        }
      }
    }
  }
  /**
   * Entity damaged by another entity event. Cancels the event and sends damager a message if either
   * damager or attacked player have not enabled PvP
   *
   * @param event event being handled
   */
  @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
  public void onEntityDamageByEntityEvent(EntityDamageByEntityEvent event) {
    if (event.getEntity() instanceof Player) {
      final Player attackedPlayer = (Player) event.getEntity();
      final Player attacker;

      if (event.getDamager() instanceof Player) {
        attacker = (Player) event.getDamager();
      } else if (event.getDamager() instanceof Projectile) {
        if (((Projectile) event.getDamager()).getShooter() instanceof Player) {
          attacker = (Player) ((Projectile) event.getDamager()).getShooter();
        } else {
          return;
        }
      } else {
        return;
      }

      final World world = attacker.getWorld();
      final Localisation localisation = plugin.getLocalisation();
      if (PVPConfigUtils.getPlayerStatus(attacker, world, plugin)) {
        if (PVPConfigUtils.getPlayerStatus(attackedPlayer, world, plugin)) {
          LastPVPActionTimeConfigUtils.update(attacker, world, plugin);
          if (DebugConfigUtils.getDebugEnabled(plugin)) {
            attacker.sendMessage(
                localisation.get(
                    LocalisationEntry.DEBUG_ATTACKED_PLAYER,
                    new Object[] {attackedPlayer.getDisplayName(), event.getDamage()}));
            attackedPlayer.sendMessage(
                localisation.get(
                    LocalisationEntry.DEBUG_ATTACKED_BY_PLAYER,
                    new Object[] {attacker.getDisplayName(), event.getDamage()}));
          }
        } else {
          event.setCancelled(true);
          attacker.sendMessage(
              localisation.get(
                  LocalisationEntry.MSG_ATTACK_CANCELLED_PLAYER_DOES_NOT_HAVE_PVP_ENABLED,
                  new Object[] {attackedPlayer.getDisplayName()}));
        }
      } else {
        event.setCancelled(true);
        attacker.sendMessage(
            localisation.get(LocalisationEntry.MSG_ATTACK_CANCELLED_PVP_NOT_ENABLED));
      }

      // Stop arrows bouncing back, possibly hitting you.
      if ((event.isCancelled()) && (event.getDamager() instanceof Projectile)) {
        ((Projectile) event.getDamager()).setBounce(false);
      }
    }
  }
Ejemplo n.º 4
0
 public static void global_no_mana_damaged(
     Player pl, final Plugin plugin, final EntityDamageByEntityEvent event) {
   event.setDamage(event.getDamage() * 2D);
   if (pl.isSneaking()) {
     pl.sendMessage(THRPlugin.thrpre + ChatColor.RED + pl.getName() + "貴方は霊力再生モードの為非常に柔いです!");
   }
 }
Ejemplo n.º 5
0
  @EventHandler(priority = EventPriority.HIGH)
  public void onEDamageByE(EntityDamageByEntityEvent event) {
    // if (event.getEntity() instanceof Player) {
    /*	Player Damagee = (Player) event.getEntity();
    String damager = event.getDamager().toString();
    Damagee.
    Bukkit.broadcastMessage("entity "+ Damagee);
    Bukkit.broadcastMessage("damager "+ damager);*/

    if (event.getDamager() instanceof Player) {
      Player p = (Player) event.getDamager();
      // int dmg = event.getDamage();
      double cRate = plugin.critRate.get(p.getName().toLowerCase());
      double random = ((double) Math.random() * 100);

      if (cRate > 0) {
        if (random <= cRate) {
          int oldmg = event.getDamage();
          int newdmg = oldmg * 2;
          event.setDamage(newdmg);
          p.sendMessage(ChatColor.AQUA + "Critical!");
          Location loc = p.getLocation();
          p.playEffect(loc, Effect.BLAZE_SHOOT, 0);
        }
      }
    }

    /*
    Player p = (Player) event.getDamager();
    String player = p.getName();
    Bukkit.broadcastMessage("name "+ player);*/

    // }

  }
Ejemplo n.º 6
0
 private boolean causePain(Player player, LivingEntity target, float power) {
   if (target.isDead()) return false;
   double dam = damage * power;
   if (target instanceof Player && checkPlugins && player != null) {
     // handle the event myself so I can detect cancellation properly
     EntityDamageByEntityEvent event =
         new EntityDamageByEntityEvent(player, target, damageType, dam);
     Bukkit.getServer().getPluginManager().callEvent(event);
     if (event.isCancelled()) {
       return false;
     }
     dam = event.getDamage();
     target.setLastDamageCause(event);
   }
   if (ignoreArmor) {
     double health = target.getHealth();
     if (health > target.getMaxHealth()) health = target.getMaxHealth();
     health = health - dam;
     if (health < 0) health = 0;
     if (health > target.getMaxHealth()) health = target.getMaxHealth();
     if (health == 0 && player != null) {
       MagicSpells.getVolatileCodeHandler().setKiller(target, player);
     }
     target.setHealth(health);
     target.playEffect(EntityEffect.HURT);
   } else {
     target.damage(dam, player);
   }
   if (player != null) {
     playSpellEffects(player, target);
   } else {
     playSpellEffects(EffectPosition.TARGET, target);
   }
   return true;
 }
Ejemplo n.º 7
0
 @EventHandler
 public void onDamageByEntity(EntityDamageByEntityEvent event) {
   if (dmgBuff.containsKey(event.getDamager())) {
     DmgBoost boost = dmgBuff.get(event.getDamager());
     if (boost.expires < HungergamesApi.getHungergames().currentTime)
       dmgBuff.remove(event.getDamager());
     else event.setDamage(event.getDamage() + boost.extraDamage);
   }
 }
Ejemplo n.º 8
0
  /**
   * Check EntityDamageByEntityEvent events.
   *
   * @param event The event to check
   */
  @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
  public void onEntityDeath(EntityDamageByEntityEvent event) {
    if (event.getDamage() == 0 || event.getEntity().isDead()) {
      return;
    }

    if (event.getEntity() instanceof LivingEntity) {
      combatChecks(event);
    }
  }
Ejemplo n.º 9
0
  public static void unarmedBonus(Player attacker, EntityDamageByEntityEvent event) {
    int bonus = 3;

    // Add 1 DMG for every 50 skill levels
    bonus += Users.getProfile(attacker).getSkillLevel(SkillType.UNARMED) / 50;

    if (bonus > 8) bonus = 8;

    event.setDamage(event.getDamage() + bonus);
  }
Ejemplo n.º 10
0
 @EventHandler
 public void onArrowDamage(EntityDamageByEntityEvent e) {
   if (!Api.allowsPVP(e.getEntity())) return;
   if (!Api.allowsPVP(e.getDamager())) return;
   if (e.getDamager() instanceof Arrow) {
     if (e.getEntity() instanceof LivingEntity) {
       LivingEntity en = (LivingEntity) e.getEntity();
       Projectile arrow = (Projectile) e.getDamager();
       if (Arrow.containsKey(arrow)) {
         if (Api.isFriendly(P.get(e.getDamager()), e.getEntity())) {
           if (Enchant.get(arrow).equalsIgnoreCase("Doctor")) {
             if (Api.isEnchantmentEnabled("Doctor")) {
               int heal = 2 + Api.getPower(Arrow.get(arrow) + "", Api.getEnchName("Doctor"));
               if (en.getHealth() + heal < en.getMaxHealth()) {
                 en.setHealth(en.getHealth() + heal);
               }
               if (en.getHealth() + heal >= en.getMaxHealth()) {
                 en.setHealth(en.getMaxHealth());
               }
             }
           }
         }
         if (!Api.isFriendly(P.get(arrow), e.getEntity())) {
           if (Enchant.get(arrow).equalsIgnoreCase("IceFreeze")) {
             if (Api.isEnchantmentEnabled("IceFreeze")) {
               if (Api.randomPicker(5)) {
                 en.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 5 * 20, 1));
               }
             }
           }
           if (Enchant.get(arrow).equalsIgnoreCase("Piercing")) {
             if (Api.isEnchantmentEnabled("Piercing")) {
               if (Api.randomPicker(
                   20 - Api.getPower(Arrow.get(arrow) + "", Api.getEnchName("Piercing")))) {
                 e.setDamage(e.getDamage() * 2);
               }
             }
           }
           if (Enchant.get(arrow).equalsIgnoreCase("Venom")) {
             if (Api.isEnchantmentEnabled("Venom")) {
               if (Api.randomPicker(10)) {
                 en.addPotionEffect(
                     new PotionEffect(
                         PotionEffectType.POISON,
                         2 * 20,
                         Api.getPower(Arrow.get(arrow) + "", Api.getEnchName("Venom")) - 1));
               }
             }
           }
         }
       }
     }
   }
   return;
 }
Ejemplo n.º 11
0
  @EventHandler
  public void fenceDefense(EntityDamageByEntityEvent event) {

    if (event.getEntity() instanceof Player) {

      Player player = (Player) event.getEntity();

      if (isIn(player, 1)) {

        if (player.getItemInHand().getType() == Material.FENCE) {

          if (event.getCause() == DamageCause.ENTITY_ATTACK
              || checkProjectile(event.getDamager(), event.getCause())) {

            event.setDamage(event.getDamage() - (event.getDamage() / 3));
          }
        }
      }
    }
  }
Ejemplo n.º 12
0
  /**
   * Apply bonus to Unarmed damage.
   *
   * @param PPa Profile of the attacking player
   * @param event The event to modify
   */
  public static void unarmedBonus(PlayerProfile PPa, EntityDamageByEntityEvent event) {
    final int MAX_BONUS = 8;
    int bonus = 3;

    bonus += PPa.getSkillLevel(SkillType.UNARMED) / 50; // Add 1 DMG for every 50 skill levels

    if (bonus > MAX_BONUS) {
      bonus = MAX_BONUS;
    }

    event.setDamage(event.getDamage() + bonus);
  }
Ejemplo n.º 13
0
 @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
 public void onDamage(EntityDamageByEntityEvent e) {
   double damage = e.getDamage();
   if (e.getDamager() instanceof Player) {
     damage = playerDamager(e, damage);
   } else if (e.getDamager() instanceof Projectile) {
     damage = projectileDamager(e, damage);
   }
   if (e.getEntity() instanceof Player) {
     damage = playerHit(e, damage);
   }
   e.setDamage(damage);
 }
Ejemplo n.º 14
0
 @EventHandler
 public void onHit(EntityDamageByEntityEvent e) {
   if (((e.getEntity() instanceof Player)) && ((e.getDamager() instanceof Player))) {
     Player entity = (Player) e.getEntity();
     Entity damager = (Player) e.getDamager();
     if (getRemaining(entity) > 0L) {
       Double damage = Double.valueOf(e.getDamage() * 0.3D);
       e.setDamage(e.getDamage() + damage.doubleValue());
     }
   }
   if (((e.getEntity() instanceof Player)) && ((e.getDamager() instanceof Arrow))) {
     Player entity = (Player) e.getEntity();
     Entity damager = (Player) ((Arrow) e.getDamager()).getShooter();
     if (((damager instanceof Player)) && (getRemaining(entity) > 0L)) {
       if (((UUID) ArcherClass.tagged.get(entity.getUniqueId())).equals(damager.getUniqueId())) {
         setCooldown(entity, entity.getUniqueId());
       }
       Double damage = Double.valueOf(e.getDamage() * 0.3D);
       e.setDamage(e.getDamage() + damage.doubleValue());
     }
   }
 }
Ejemplo n.º 15
0
 @SuppressWarnings("deprecation")
 public static void damage(LivingEntity damager, LivingEntity damagee, double damage) {
   if (damager instanceof Player) {
     Player p = (Player) damager;
     if (!(p.isOnline())) return;
   }
   EntityDamageByEntityEvent event =
       new EntityDamageByEntityEvent(damager, damagee, DamageCause.ENTITY_ATTACK, damage);
   Bukkit.getServer().getPluginManager().callEvent(event);
   if (event.isCancelled()) return;
   if (event.getDamage() != damage) damage = event.getDamage();
   if (damage <= 1) {
     damagee.damage(1, damager);
   } else if (damage >= damagee.getHealth()) {
     damagee.setHealth(1);
     damagee.damage(200, damager);
   } else {
     double damageChanged = damage - 1;
     damagee.damage(damageChanged);
     damagee.damage(3, damager);
   }
 }
  @EventHandler
  public void onEntityDamagebyEntity(EntityDamageByEntityEvent event) {
    if (event.getEntity() instanceof Zombie) {
      if (event.getDamager() instanceof Player) {
        event.setDamage(event.getDamage() * getDamage(((Player) event.getDamager())) / 2);
      }
    }
    if (event.getEntity() instanceof Giant) {
      if ((event.getCause().equals(DamageCause.FIRE_TICK)
          || event.getCause().equals(DamageCause.FIRE)
          || event.getCause().equals(DamageCause.LIGHTNING))) {
        event.setCancelled(true);
        event.getEntity().setFireTicks(0);
      }
      event.setDamage(event.getDamage() / 4);
    }
    if (event.getEntity() instanceof Player) {
      if (event.getDamager() instanceof Zombie) {

        event.setDamage(event.getDamage() * getDamage(((Player) event.getEntity())));
      }
    }
  }
Ejemplo n.º 17
0
 @EventHandler
 public void onDamage(EntityDamageByEntityEvent event) {
   if (event.getEntity() instanceof Player == false
       || GameManager.INSTANCE.getSession((Player) event.getEntity()) == null) return;
   if (event.getDamager() instanceof Zombie) {
     event.setDamage(
         (int) (Configs.Config.ZOMBIE_DAMAGE_MULTIPLIER.getGlobalDouble() * event.getDamage()));
   } else if (event.getDamager() instanceof Player) {
     Player p = (Player) event.getDamager();
     if (p.getItemInHand().getType().equals(Material.PAPER)) {
       event.setCancelled(true);
       bandage.put(p.getName(), ((Player) event.getEntity()).getName());
       GeneralUtils.subtractItemInHand(p);
     }
   }
 }
Ejemplo n.º 18
0
 private double projectileDamager(EntityDamageByEntityEvent e, double damage) {
   Projectile entity = (Projectile) e.getDamager();
   if (rpgProjectiles.contains(entity.getEntityId())) {
     RPGItem rItem = ItemManager.getItemById(rpgProjectiles.get(entity.getEntityId()));
     if (rItem == null) return damage;
     damage =
         rItem.getDamageMin() != rItem.getDamageMax()
             ? (rItem.getDamageMin() + random.nextInt(rItem.getDamageMax() - rItem.getDamageMin()))
             : rItem.getDamageMin();
     if (e.getEntity() instanceof LivingEntity) {
       LivingEntity le = (LivingEntity) e.getEntity();
       rItem.hit((Player) entity.getShooter(), le, e.getDamage());
     }
   }
   return damage;
 }
Ejemplo n.º 19
0
  @Override
  public boolean onDamageOther(final EntityDamageByEntityEvent e, Player p, int level) {
    if (e.getEntity().getLocation().getDirection().dot(e.getDamager().getLocation().getDirection())
        > 0.0D) {
      e.setDamage(e.getDamage() * level);

      p.sendMessage("Backstab!");

      if (e.getEntity() instanceof Player) {
        ((Player) e.getEntity()).sendMessage("You were backstabbed!");
      }

      return true;
    }
    return false;
  }
Ejemplo n.º 20
0
  // Game ending & freezing/unfreezing logic
  @EventHandler(priority = EventPriority.HIGHEST)
  public void checkDeath(EntityDamageByEntityEvent e) {
    Entity entity = e.getEntity();
    Player p;
    if (entity instanceof Player) {
      p = (Player) entity;
    } else {
      return;
    }

    if (!((p.getHealth() - e.getDamage())
        <= 0)) { // This is not wrong.
                 // http://forums.bukkit.org/threads/oops-i-didnt-break-your-plugins-ambiguous-gethealth.156975/
      return;
      // If he is not going to die.
    }

    if (plugin.wsplayersHM.containsValue(p)) {
      // p.sendMessage("testdead");
      if (isRedTeam(p)) {
        // if player isn't frozen, freeze him. If he is, unfreeze him.
        if (!isFrozenRed(p)) {
          // p.sendMessage("testdead");
          plugin.frozenred.add(p.getName());
        } else {
          plugin.frozenred.remove(p);
        }
        if (plugin.frozengreen.size() == plugin.wsgreen.values().size()) {
          //  end the game...
          Bukkit.broadcastMessage(ChatColor.GREEN + "The RED team has won the game!");
          return;
        }
      } else if (isGreenTeam(p)) {
        if (!isFrozenGreen(p)) {
          plugin.frozengreen.add(p.getName());
        }
        if (plugin.frozenred.size() == plugin.wsred.values().size()) {
          //  end the game...
          Bukkit.broadcastMessage(ChatColor.GREEN + "The GREEN team has won the game!");
          return;
        }
      } else {
        return;
      }
    }
  }
Ejemplo n.º 21
0
 @EventHandler
 public void EntityDamagebyPlayer(EntityDamageByEntityEvent event) {
   if (event.getDamager() instanceof Player) {
     Player player = (Player) event.getDamager();
     UUID id = player.getUniqueId();
     double damagestart = event.getDamage();
     if (!(hasSkill(id))) {
       return;
     }
     ItemStack item = player.getItemInHand();
     for (Material m : weapons) {
       if (item.getType().equals(m)) {
         Double dmg = UserManager.getUser(id).getUserSkillClass().getLevel(this) * damage;
         event.setDamage(DamageModifier.BASE, damagestart + dmg);
       }
     }
   }
 }
Ejemplo n.º 22
0
  @SuppressWarnings("deprecation")
  private double playerDamager(EntityDamageByEntityEvent e, double damage) {
    Player player = (Player) e.getDamager();
    ItemStack item = player.getItemInHand();
    if (item.getType() == Material.BOW
        || item.getType() == Material.SNOW_BALL
        || item.getType() == Material.EGG
        || item.getType() == Material.POTION) return damage;

    RPGItem rItem = ItemManager.toRPGItem(item);
    if (rItem == null) return damage;
    if (!WorldGuard.canPvP(player.getLocation()) && !rItem.ignoreWorldGuard) return damage;
    if (rItem.getHasPermission() == true && player.hasPermission(rItem.getPermission()) == false) {
      damage = 0;
      e.setCancelled(true);
      player.sendMessage(
          ChatColor.RED
              + String.format(
                  Locale.get("message.error.permission", Locale.getPlayerLocale(player))));
    }
    damage =
        rItem.getDamageMin() != rItem.getDamageMax()
            ? (rItem.getDamageMin() + random.nextInt(rItem.getDamageMax() - rItem.getDamageMin()))
            : rItem.getDamageMin();
    if (e.getEntity() instanceof LivingEntity) {
      LivingEntity le = (LivingEntity) e.getEntity();
      rItem.hit(player, le, e.getDamage());
    }
    RPGMetadata meta = RPGItem.getMetadata(item);
    if (rItem.getMaxDurability() != -1) {
      int durability =
          meta.containsKey(RPGMetadata.DURABILITY)
              ? ((Number) meta.get(RPGMetadata.DURABILITY)).intValue()
              : rItem.getMaxDurability();
      durability--;
      if (durability <= 0) {
        player.setItemInHand(null);
      }
      meta.put(RPGMetadata.DURABILITY, Integer.valueOf(durability));
    }
    RPGItem.updateItem(item, Locale.getPlayerLocale(player), meta);
    player.updateInventory();
    return damage;
  }
Ejemplo n.º 23
0
 @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
 public void onEntityDamage(EntityDamageByEntityEvent event) {
   if (this.lastDamageEvent.get() == event) { // We're already in the midst of the original event.
     return;
   }
   Entity damagee = getVehicleEntity(event.getEntity());
   if (damagee != null) {
     event.setCancelled(true);
     this.lastDamageEvent =
         new WeakReference<>(
             new EntityDamageByEntityEvent(
                 event.getDamager(), damagee, event.getCause(), event.getDamage()));
     this.npcManager
         .getOwner()
         .getServer()
         .getPluginManager()
         .callEvent(this.lastDamageEvent.get());
   }
 }
Ejemplo n.º 24
0
  public void a(EntityWeatherStorm entityweatherstorm) {
    // CraftBukkit start
    int damage = 5;
    EntityDamageByEntityEvent event =
        new EntityDamageByEntityEvent(
            entityweatherstorm.getBukkitEntity(), getBukkitEntity(), DamageCause.LIGHTNING, damage);
    Bukkit.getServer().getPluginManager().callEvent(event);
    damage = event.getDamage();

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

    this.a(damage);
    // CraftBukkit end

    ++this.fireTicks;
    if (this.fireTicks == 0) {
      this.fireTicks = 300;
    }
  }
Ejemplo n.º 25
0
 /**
  * Cancels left clicks on disabled items
  *
  * @param event event details
  */
 @EventHandler(priority = EventPriority.LOWEST)
 public void onAttack(EntityDamageByEntityEvent event) {
   if (event.getDamager() instanceof Player) {
     Player player = (Player) event.getDamager();
     if (InventoryTask.cannotUse(SkillAPI.getPlayerData(player), player.getItemInHand())) {
       SkillAPI.getLanguage().sendMessage(ErrorNodes.CANNOT_USE, player, FilterType.COLOR);
       event.setCancelled(true);
     }
   }
   if (event.getEntity() instanceof Player
       && VersionManager.isVersionAtLeast(VersionManager.V1_9_0)) {
     Player player = (Player) event.getEntity();
     if (event.getDamage(EntityDamageEvent.DamageModifier.BLOCKING) < 0
         && InventoryTask.cannotUse(
             SkillAPI.getPlayerData(player), player.getInventory().getItemInMainHand())) {
       SkillAPI.getLanguage()
           .sendMessage(ErrorNodes.CANNOT_USE, event.getEntity(), FilterType.COLOR);
       event.setDamage(EntityDamageEvent.DamageModifier.BLOCKING, 0);
     }
   }
 }
Ejemplo n.º 26
0
  // Create damage logs
  @EventHandler(priority = EventPriority.MONITOR)
  public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
    if (!(event.getEntity() instanceof Player)) return;
    Player player = (Player) event.getEntity();

    Player damager = null;
    if (event.getDamager() instanceof Player) {
      damager = (Player) event.getDamager();
    } else if (event.getDamager() instanceof Wolf) {
      Wolf wolf = (Wolf) event.getDamager();
      if (wolf.getOwner() instanceof Player) damager = (Player) wolf.getOwner();
    } else if (event.getDamager() instanceof Arrow) {
      Arrow arrow = (Arrow) event.getDamager();
      if (!(arrow.getShooter() instanceof Player)) return;

      damager = (Player) arrow.getShooter();
    }

    if (damager == null || damager == player) return;

    recordDamage(player, damager, event.getDamage());
  }
Ejemplo n.º 27
0
  public static void counterAttackChecks(EntityDamageByEntityEvent event) {
    // Don't want to counter attack arrows
    if (event.getDamager() instanceof Projectile) return;

    if (event instanceof EntityDamageByEntityEvent) {
      Entity damager = ((EntityDamageByEntityEvent) event).getDamager();
      if (event.getEntity() instanceof Player) {
        Player damaged = (Player) event.getEntity();
        PlayerProfile PPd = Users.getProfile(damaged);
        if (Utils.isSword(damaged.getItemInHand())
            && mcPermissions.skillPermission(SkillType.SWORDS, damaged)) {
          if (Math.random() * 2000 <= Math.min(PPd.getSkillLevel(SkillType.SWORDS), 600)) {
            Combat.dealDamage(damaged, damager, event.getDamage() / 2);
            damaged.sendMessage(ChatColor.GREEN + "**COUNTER-ATTACKED**");
            if (damager instanceof Player) {
              ((Player) damager).sendMessage(ChatColor.DARK_RED + "Hit with counterattack!");
            }
          }
        }
      }
    }
  }
Ejemplo n.º 28
0
  public boolean bleed() {
    if (target == null || damager == null || target.isDead()) return false;
    if (damager instanceof Player && !Bukkit.getOfflinePlayer(damager.getUniqueId()).isOnline()) {
      return false;
    }

    EntityDamageByEntityEvent e =
        new EntityDamageByEntityEvent(damager, target, EntityDamageEvent.DamageCause.CUSTOM, 1);

    Bukkit.getPluginManager().callEvent(e);

    if (WGUtil.canGetDamage(target) && !e.isCancelled()) {
      target.damage(e.getDamage());
      target.setLastDamageCause(e);
      if (target instanceof Player) {
        target.sendMessage(ChatColor.DARK_RED + "You are bleeding..");
      }
    }
    EffectUtil.playParticle(target, Effect.CRIT);

    duration--;

    return duration > 0;
  }
Ejemplo n.º 29
0
  @Override
  public void onDefense(EntityDamageByEntityEvent event) {
    double damage = event.getDamage();

    damage -= this.defense;
    if (damage < 0.5) {
      damage = 0.0;

      Player player = null;
      if (event.getDamager() instanceof Arrow) {
        Arrow arrow = (Arrow) event.getDamager();
        if (arrow.getShooter() instanceof Player) {
          player = (Player) arrow.getShooter();
        }
      } else if (event.getDamager() instanceof Player) {
        player = (Player) event.getDamager();
      }

      if (player != null) {
        CivMessage.send(player, CivColor.LightGray + "Our attack was ineffective");
      }
    }
    event.setDamage(damage);
  }
Ejemplo n.º 30
0
  public void w_() {
    super.w_();
    if (this.lastPitch == 0.0F && this.lastYaw == 0.0F) {
      float f = MathHelper.a(this.motX * this.motX + this.motZ * this.motZ);

      this.lastYaw =
          this.yaw = (float) (Math.atan2(this.motX, this.motZ) * 180.0D / 3.1415927410125732D);
      this.lastPitch =
          this.pitch = (float) (Math.atan2(this.motY, (double) f) * 180.0D / 3.1415927410125732D);
    }

    int i = this.world.getTypeId(this.e, this.f, this.g);

    if (i > 0) {
      Block.byId[i].updateShape(this.world, this.e, this.f, this.g);
      AxisAlignedBB axisalignedbb = Block.byId[i].e(this.world, this.e, this.f, this.g);

      if (axisalignedbb != null && axisalignedbb.a(Vec3D.create(this.locX, this.locY, this.locZ))) {
        this.inGround = true;
      }
    }

    if (this.shake > 0) {
      --this.shake;
    }

    if (this.inGround) {
      i = this.world.getTypeId(this.e, this.f, this.g);
      int j = this.world.getData(this.e, this.f, this.g);

      if (i == this.h && j == this.i) {
        ++this.k;
        if (this.k == 1200) {
          this.die();
        }
      } else {
        this.inGround = false;
        this.motX *= (double) (this.random.nextFloat() * 0.2F);
        this.motY *= (double) (this.random.nextFloat() * 0.2F);
        this.motZ *= (double) (this.random.nextFloat() * 0.2F);
        this.k = 0;
        this.l = 0;
      }
    } else {
      ++this.l;
      Vec3D vec3d = Vec3D.create(this.locX, this.locY, this.locZ);
      Vec3D vec3d1 =
          Vec3D.create(this.locX + this.motX, this.locY + this.motY, this.locZ + this.motZ);
      MovingObjectPosition movingobjectposition = this.world.rayTrace(vec3d, vec3d1, false, true);

      vec3d = Vec3D.create(this.locX, this.locY, this.locZ);
      vec3d1 = Vec3D.create(this.locX + this.motX, this.locY + this.motY, this.locZ + this.motZ);
      if (movingobjectposition != null) {
        vec3d1 =
            Vec3D.create(
                movingobjectposition.f.a, movingobjectposition.f.b, movingobjectposition.f.c);
      }

      Entity entity = null;
      List list =
          this.world.b(
              (Entity) this,
              this.boundingBox.a(this.motX, this.motY, this.motZ).b(1.0D, 1.0D, 1.0D));
      double d0 = 0.0D;

      int k;
      float f1;

      for (k = 0; k < list.size(); ++k) {
        Entity entity1 = (Entity) list.get(k);

        if (entity1.e_() && (entity1 != this.shooter || this.l >= 5)) {
          f1 = 0.3F;
          AxisAlignedBB axisalignedbb1 =
              entity1.boundingBox.b((double) f1, (double) f1, (double) f1);
          MovingObjectPosition movingobjectposition1 = axisalignedbb1.a(vec3d, vec3d1);

          if (movingobjectposition1 != null) {
            double d1 = vec3d.b(movingobjectposition1.f);

            if (d1 < d0 || d0 == 0.0D) {
              entity = entity1;
              d0 = d1;
            }
          }
        }
      }

      if (entity != null) {
        movingobjectposition = new MovingObjectPosition(entity);
      }

      float f2;

      if (movingobjectposition != null) {
        // CraftBukkit start
        ProjectileHitEvent phe = new ProjectileHitEvent((Projectile) this.getBukkitEntity());
        this.world.getServer().getPluginManager().callEvent(phe);
        // CraftBukkit end
        if (movingobjectposition.entity != null) {
          f2 = MathHelper.a(this.motX * this.motX + this.motY * this.motY + this.motZ * this.motZ);
          int l = (int) Math.ceil((double) f2 * 2.0D);

          if (this.d) {
            l += this.random.nextInt(l / 2 + 2);
          }

          DamageSource damagesource = null;

          if (this.shooter == null) {
            damagesource = DamageSource.arrow(this, this);
          } else {
            damagesource = DamageSource.arrow(this, this.shooter);
          }

          // CraftBukkit start
          boolean stick;
          if (entity instanceof EntityLiving) {

            org.bukkit.entity.Entity damagee = movingobjectposition.entity.getBukkitEntity();
            Projectile projectile = (Projectile) this.getBukkitEntity();

            EntityDamageByEntityEvent event =
                new EntityDamageByEntityEvent(
                    projectile, damagee, EntityDamageEvent.DamageCause.PROJECTILE, l);
            Bukkit.getPluginManager().callEvent(event);

            if (event.isCancelled()) {
              stick = !projectile.doesBounce();
            } else {
              // this function returns if the arrow should stick in or not, i.e. !bounce
              stick = movingobjectposition.entity.damageEntity(damagesource, event.getDamage());
            }
          } else {
            stick = movingobjectposition.entity.damageEntity(damagesource, l);
          }
          if (stick) {
            // CraftBukkit end
            if (movingobjectposition.entity instanceof EntityLiving) {
              ++((EntityLiving) movingobjectposition.entity).aH;
            }

            this.world.makeSound(
                this, "random.bowhit", 1.0F, 1.2F / (this.random.nextFloat() * 0.2F + 0.9F));
            this.die();
          } else {
            this.motX *= -0.10000000149011612D;
            this.motY *= -0.10000000149011612D;
            this.motZ *= -0.10000000149011612D;
            this.yaw += 180.0F;
            this.lastYaw += 180.0F;
            this.l = 0;
          }
        } else {
          this.e = movingobjectposition.b;
          this.f = movingobjectposition.c;
          this.g = movingobjectposition.d;
          this.h = this.world.getTypeId(this.e, this.f, this.g);
          this.i = this.world.getData(this.e, this.f, this.g);
          this.motX = (double) ((float) (movingobjectposition.f.a - this.locX));
          this.motY = (double) ((float) (movingobjectposition.f.b - this.locY));
          this.motZ = (double) ((float) (movingobjectposition.f.c - this.locZ));
          f2 = MathHelper.a(this.motX * this.motX + this.motY * this.motY + this.motZ * this.motZ);
          this.locX -= this.motX / (double) f2 * 0.05000000074505806D;
          this.locY -= this.motY / (double) f2 * 0.05000000074505806D;
          this.locZ -= this.motZ / (double) f2 * 0.05000000074505806D;
          this.world.makeSound(
              this, "random.bowhit", 1.0F, 1.2F / (this.random.nextFloat() * 0.2F + 0.9F));
          this.inGround = true;
          this.shake = 7;
          this.d = false;
        }
      }

      if (this.d) {
        for (k = 0; k < 4; ++k) {
          this.world.a(
              "crit",
              this.locX + this.motX * (double) k / 4.0D,
              this.locY + this.motY * (double) k / 4.0D,
              this.locZ + this.motZ * (double) k / 4.0D,
              -this.motX,
              -this.motY + 0.2D,
              -this.motZ);
        }
      }

      this.locX += this.motX;
      this.locY += this.motY;
      this.locZ += this.motZ;
      f2 = MathHelper.a(this.motX * this.motX + this.motZ * this.motZ);
      this.yaw = (float) (Math.atan2(this.motX, this.motZ) * 180.0D / 3.1415927410125732D);

      for (this.pitch = (float) (Math.atan2(this.motY, (double) f2) * 180.0D / 3.1415927410125732D);
          this.pitch - this.lastPitch < -180.0F;
          this.lastPitch -= 360.0F) {;
      }

      while (this.pitch - this.lastPitch >= 180.0F) {
        this.lastPitch += 360.0F;
      }

      while (this.yaw - this.lastYaw < -180.0F) {
        this.lastYaw -= 360.0F;
      }

      while (this.yaw - this.lastYaw >= 180.0F) {
        this.lastYaw += 360.0F;
      }

      this.pitch = this.lastPitch + (this.pitch - this.lastPitch) * 0.2F;
      this.yaw = this.lastYaw + (this.yaw - this.lastYaw) * 0.2F;
      float f3 = 0.99F;

      f1 = 0.05F;
      if (this.az()) {
        for (int i1 = 0; i1 < 4; ++i1) {
          float f4 = 0.25F;

          this.world.a(
              "bubble",
              this.locX - this.motX * (double) f4,
              this.locY - this.motY * (double) f4,
              this.locZ - this.motZ * (double) f4,
              this.motX,
              this.motY,
              this.motZ);
        }

        f3 = 0.8F;
      }

      this.motX *= (double) f3;
      this.motY *= (double) f3;
      this.motZ *= (double) f3;
      this.motY -= (double) f1;
      this.setPosition(this.locX, this.locY, this.locZ);
    }
  }