@Override
public PostCastAction castSpell(Player player, SpellCastState state, float power, String[] args) {
if (state == SpellCastState.NORMAL) {
Block block = null;
if (targeted) {
block = getTargetedBlock(player, power);
} else {
block = player.getLocation().subtract(0, 1, 0).getBlock();
}
if (block != null) {
SpellTargetLocationEvent event =
new SpellTargetLocationEvent(this, player, block.getLocation(), power);
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled()) {
block = null;
} else {
block = event.getTargetLocation().getBlock();
power = event.getPower();
}
}
if (block != null) {
boolean farmed = farm(block, Math.round(radius * power));
if (!farmed) return noTarget(player);
playSpellEffects(EffectPosition.CASTER, player);
if (targeted) {
playSpellEffects(EffectPosition.TARGET, block.getLocation());
}
} else {
return noTarget(player);
}
}
return PostCastAction.HANDLE_NORMALLY;
}
public boolean apply(SpellTargetLocationEvent event) {
Player player = event.getCaster();
boolean check = condition.check(player, event.getTargetLocation());
if (check == false && type == ModifierType.REQUIRED) {
event.setCancelled(true);
return false;
} else if (check == true && type == ModifierType.DENIED) {
event.setCancelled(true);
return false;
} else if (check == true && type == ModifierType.STOP) {
return false;
} else if (check == false && type == ModifierType.CONTINUE) {
return false;
} else if (check == true && (type == ModifierType.CAST || type == ModifierType.CAST_INSTEAD)) {
Spell spell = MagicSpells.getSpellByInternalName(modifierVar);
if (spell != null && spell instanceof TargetedLocationSpell) {
((TargetedLocationSpell) spell)
.castAtLocation(event.getCaster(), event.getTargetLocation(), 1F);
if (type == ModifierType.CAST_INSTEAD) {
event.setCancelled(true);
}
}
}
return true;
}
private boolean activateSpells(
Player caster, LivingEntity target, Location location, float basePower) {
SpellCastState state = getCastState(caster);
MagicSpells.debug(
3,
"Activating passive spell '"
+ name
+ "' for player "
+ caster.getName()
+ " (state: "
+ state
+ ")");
if (!disabled
&& (chance >= .999 || random.nextFloat() <= chance)
&& state == SpellCastState.NORMAL) {
disabled = true;
SpellCastEvent event =
new SpellCastEvent(
this,
caster,
SpellCastState.NORMAL,
basePower,
null,
this.cooldown,
this.reagents.clone(),
0);
Bukkit.getPluginManager().callEvent(event);
if (!event.isCancelled() && event.getSpellCastState() == SpellCastState.NORMAL) {
if (event.haveReagentsChanged() && !hasReagents(caster, event.getReagents())) {
disabled = false;
return false;
}
setCooldown(caster, event.getCooldown());
basePower = event.getPower();
for (Spell spell : spells) {
MagicSpells.debug(3, " Casting spell effect '" + spell.getName() + "'");
if (castWithoutTarget) {
MagicSpells.debug(3, " Casting without target");
spell.castSpell(caster, SpellCastState.NORMAL, basePower, null);
playSpellEffects(EffectPosition.CASTER, caster);
} else if (spell instanceof TargetedEntitySpell
&& target != null
&& !isNonTargetedExternal(spell)) {
MagicSpells.debug(3, " Casting at entity");
SpellTargetEvent targetEvent = new SpellTargetEvent(this, caster, target, basePower);
Bukkit.getPluginManager().callEvent(targetEvent);
if (!targetEvent.isCancelled()) {
target = targetEvent.getTarget();
((TargetedEntitySpell) spell).castAtEntity(caster, target, targetEvent.getPower());
playSpellEffects(caster, target);
} else {
MagicSpells.debug(3, " Target cancelled (TE)");
}
} else if (spell instanceof TargetedLocationSpell
&& (location != null || target != null)) {
MagicSpells.debug(3, " Casting at location");
Location loc = null;
if (location != null) {
loc = location;
} else if (target != null) {
loc = target.getLocation();
}
if (loc != null) {
SpellTargetLocationEvent targetEvent =
new SpellTargetLocationEvent(this, caster, loc, basePower);
Bukkit.getPluginManager().callEvent(targetEvent);
if (!targetEvent.isCancelled()) {
loc = targetEvent.getTargetLocation();
((TargetedLocationSpell) spell).castAtLocation(caster, loc, targetEvent.getPower());
playSpellEffects(caster, loc);
} else {
MagicSpells.debug(3, " Target cancelled (TL)");
}
}
} else {
MagicSpells.debug(3, " Casting normally");
float power = basePower;
if (target != null) {
SpellTargetEvent targetEvent = new SpellTargetEvent(this, caster, target, power);
Bukkit.getPluginManager().callEvent(targetEvent);
if (!targetEvent.isCancelled()) {
power = targetEvent.getPower();
} else {
MagicSpells.debug(3, " Target cancelled (UE)");
continue;
}
} else if (location != null) {
SpellTargetLocationEvent targetEvent =
new SpellTargetLocationEvent(this, caster, location, basePower);
Bukkit.getPluginManager().callEvent(targetEvent);
if (!targetEvent.isCancelled()) {
power = targetEvent.getPower();
} else {
MagicSpells.debug(3, " Target cancelled (UL)");
continue;
}
}
spell.castSpell(caster, SpellCastState.NORMAL, power, null);
playSpellEffects(EffectPosition.CASTER, caster);
}
}
removeReagents(caster, event.getReagents());
sendMessage(caster, strCastSelf);
SpellCastedEvent event2 =
new SpellCastedEvent(
this,
caster,
SpellCastState.NORMAL,
basePower,
null,
event.getCooldown(),
event.getReagents(),
PostCastAction.HANDLE_NORMALLY);
Bukkit.getPluginManager().callEvent(event2);
disabled = false;
return true;
} else {
MagicSpells.debug(3, " Passive spell canceled");
disabled = false;
return false;
}
} else if (state != SpellCastState.NORMAL && sendFailureMessages) {
if (state == SpellCastState.ON_COOLDOWN) {
MagicSpells.sendMessage(
caster, formatMessage(strOnCooldown, "%c", Math.round(getCooldown(caster)) + ""));
} else if (state == SpellCastState.MISSING_REAGENTS) {
MagicSpells.sendMessage(caster, strMissingReagents);
if (MagicSpells.showStrCostOnMissingReagents() && strCost != null && !strCost.isEmpty()) {
MagicSpells.sendMessage(caster, " (" + strCost + ")");
}
}
}
return false;
}