public void addEffect(Effect effect, float delayTime) {
if (effect.getEffectType() != Effect.EffectType.Pulse
&& effect.getEffectType() != Effect.EffectType.PulseColor) {
EffectQueueItem item = new EffectQueueItem(effect, delayTime);
queue.add(item);
}
}
/** Method reduceLevel. */
public void reduceLevel() {
Player player = getPlayer();
if (player == null) {
return;
}
for (Effect e : player.getEffectList().getAllEffects()) {
if (e.getSkill().getId() == _skillId) {
_level = e.getSkill().getLevel();
e.exit();
} else {
return;
}
}
_level--;
if (getLevel(player) > 0) {
player.broadcastPacket(new MagicSkillUse(player, player, _skillId, getLevel(player), 0, 0));
player.sendPacket(
new SystemMessage(SystemMessage.THE_LEVEL_S1_SHILENS_BREATH_WILL_BE_ASSESSED)
.addNumber(getLevel(player)));
} else {
player.sendPacket(new SystemMessage(SystemMessage.THE_SHILENS_BREATH_HAS_BEEN_LIFTED));
}
player.updateStats();
}
/**
* Method restore.
*
* @param player Player
*/
void restore(Player player) {
if (player.getEffectList().getEffectsBySkillId(_skillId) != null) {
for (Effect e : player.getEffectList().getAllEffects()) {
if (e.getSkill().getId() == _skillId) {
_level = e.getSkill().getLevel();
e.exit();
}
}
}
if (!Config.ALLOW_DEATH_PENALTY_C5) {
return;
}
if (getLevel(player) > 0) {
Skill skill = SkillTable.getInstance().getInfo(_skillId, _level);
if (skill == null) {
return;
}
skill.getEffects(player, player, false, false);
player.sendPacket(
new SystemMessage(SystemMessage.THE_LEVEL_S1_SHILENS_BREATH_WILL_BE_ASSESSED)
.addNumber(getLevel(player)));
}
player.updateStats();
}
public void fire() {
if (!canFire()) return;
Enemy target = getTargetEnemy();
if (target == null) return;
if (this.towerType == TowerType.ArrowTower) {
Effect effect =
new Effect(
1, TowerType.ArrowTower.getAttack(level), Effect.Target.SINGLE, Effect.Type.DAMAGE);
effect.setTargetEnemy(target);
grid.getLevel().getCurrentWave().addEffect(effect);
grid.getLevel()
.getCurrentWave()
.addAmmoSprite(
new AmmoSprite(
this.grid, target.getLastGrid(), Configuration.TOWER_ARROWTOWER_AMMOSPRITE_TYPE));
} else if (this.towerType == TowerType.CannonTower) {
Effect effect =
new Effect(
1, TowerType.CannonTower.getAttack(level), Effect.Target.SPLASH, Effect.Type.DAMAGE);
effect.setTargetGrid(target.getGrid());
grid.getLevel().getCurrentWave().addEffect(effect);
grid.getLevel()
.getCurrentWave()
.addAmmoSprite(
new AmmoSprite(
this.grid,
target.getLastGrid(),
Configuration.TOWER_CANNONTOWER_AMMOSPRITE_TYPE));
} else throw new AssertionError();
// setib turns to fire kuhugi
// efekt vaja tekitada
}
private String evaluationNormalSnip(EffectMatchNode effectNode, Object[] args) {
Effect effect = effectNode.getEffect();
StringBuilder sb = new StringBuilder();
// Prepare a hash map of snippet variables for use by formulas.
HashMap<String, String> variables = new HashMap<String, String>();
// First add a variable for each of the effect's arguments.
for (int i = 0; i < args.length; i++) {
variables.put(effect.getParameter(i).getName(), (String) args[i]);
}
ISnippetNode[] snippetNodes;
if (cachedSnippetNodes.containsKey(effect.getId())) {
snippetNodes = cachedSnippetNodes.get(effect.getId());
} else {
snippetNodes = SnippetParser.parseSnippetNodes(effect);
cachedSnippetNodes.put(effect.getId(), snippetNodes);
}
// Evaluate the snippet by processing its nodes, and concatenate all the results.
for (ISnippetNode snippetNode : snippetNodes) {
sb.append(evaluateSnippetNode(snippetNode, variables, effectNode));
}
return sb.toString().trim();
}
@Override
public boolean reducesOpaquePixels() {
if (!state.isNop()) {
return true;
}
final Effect input = getInput();
return input != null && input.reducesOpaquePixels();
}
@Override
void endLayer() {
frameBuffer.unbind();
Effect effect = layer.effect;
if (effect != null) {
effect.process(frameBuffer.texture);
}
}
@Override
public DirtyRegionContainer getDirtyRegions(Effect defaultInput, DirtyRegionPool regionPool) {
Effect di = getDefaultedInput(0, defaultInput);
DirtyRegionContainer drc = di.getDirtyRegions(defaultInput, regionPool);
drc.grow(state.getHPad(), state.getVPad());
return drc;
}
public void applyEffect(List<Effect> effects) {
/** Apply effects to effected objects */
for (Effect effect : effects) {
effect.applyEffect();
}
/** Use penalty skill (now 100% success) */
if (!blockedPenaltySkill) startPenaltySkill();
}
/** ********************************************** */
@Override
public final String toString() {
StringBuffer retorno = new StringBuffer();
retorno.append("Multistomp: " + this.getClass().getSimpleName() + "\n");
retorno.append(" - Current Patch: " + this.currentPatch().toString() + "\n");
retorno.append(" - Effects: \n");
for (Effect effect : this.currentPatch().effects())
retorno.append(" |- " + effect.toString() + "\n");
return retorno.toString();
}
/*
* (non-Javadoc)
*
* @see snipmatch.core.MatchEnvironment#evaluateEffect(snipmatch.core.EffectMatchNode, java.lang.Object[])
*/
@Override
protected Object evaluateEffect(EffectMatchNode effectNode, Object[] args) {
Effect effect = effectNode.getEffect();
TemplateBuffer buffer;
try {
buffer = translator.translate(effect.getCode());
return evaluationJDTTemplate(effect, buffer, args);
} catch (TemplateException e) {
e.printStackTrace();
return evaluationNormalSnip(effectNode, args);
}
}
@Override
public Effect deserialize(JsonElement effectJson, Type type, JsonDeserializationContext context)
throws JsonParseException {
JsonObject object = effectJson.getAsJsonObject();
String name = object.get("name").getAsString();
int trackId = object.get("trackId").getAsInt();
int position = object.get("position").getAsInt();
new EffectCreateEvent(trackId, position, name).apply();
Effect effect =
View.context.getTrackManager().getTrackById(trackId).getEffectByPosition(position);
effect.deserialize(GSON, object);
return effect;
}
/** Method checkCharmOfLuck. */
void checkCharmOfLuck() {
Player player = getPlayer();
if (player != null) {
for (Effect e : player.getEffectList().getAllEffects()) {
if ((e.getSkill().getId() == _charmOfLuckSkillId)
|| (e.getSkill().getId() == _fortuneOfNobleseSkillId)) {
_hasCharmOfLuck = true;
return;
}
}
}
_hasCharmOfLuck = false;
}
/** ************************ Controls and Draw all Game drawing activities */
public void Draw(Canvas c) {
if (PauseGame) {
pause.onDraw(c);
return;
}
for (DrawableUI a : GameObjects) {
a.Draw(c);
}
for (Action a : ActiveActions) {
a.Draw(c);
}
for (Effect a : Effects) {
a.Draw(c);
}
}
private void setControllerForEffect(
ContinuousEffectsList<?> effects, UUID cardId, UUID controllerId) {
for (Effect effect : effects) {
HashSet<Ability> abilities = effects.getAbility(effect.getId());
for (Ability ability : abilities) {
if (ability.getSourceId() != null) {
if (ability.getSourceId().equals(cardId)) {
ability.setControllerId(controllerId);
}
} else {
if (!ability.getZone().equals(Zone.COMMAND)) {
logger.fatal(new StringBuilder("No sourceId Ability: ").append(ability));
}
}
}
}
}
public TableJumpInstruction(
InstructionCode code,
InstructionReference instrRef,
SortedMap<Integer, InstructionReference> jumpTable) {
super(code);
this.defaultInstr = instrRef;
this.jumpTable = jumpTable;
this.effect = Effect.make().get(ScalarType.scalar(TypeType.INT));
}
/** Method addLevel. */
private void addLevel() {
Player player = getPlayer();
if ((player == null) || (getLevel(player) >= 5)) {
return;
}
if (player.getEffectList().getEffectsBySkillId(_skillId) != null) {
for (Effect e : player.getEffectList().getAllEffects()) {
if (e.getSkill().getId() == _skillId) {
_level = e.getSkill().getLevel();
e.exit();
}
}
}
_level++;
}
public Scene(scene scene, int width, int height) throws Exception {
duration = scene.getDuration();
effect[] xmlEffect = scene.getEffect();
effect = new Effect[xmlEffect.length];
for (int i = 0; i < xmlEffect.length; i++) {
effect[i] = Effect.getEffect(xmlEffect[i], width, height, this);
}
}
/** ************************ Runs right before Draw on every frame */
public void Update() {
if (PauseGame) return;
if (ActiveActions.isEmpty()) {
for (DrawableUI a : GameObjects) {
if (!a.Disabled) a.Update();
}
} else
for (Action a : ActiveActions) {
if (a.IsActionFinished()) ActiveActions.remove(a);
}
if (!Effects.isEmpty()) {
for (Effect a : Effects) {
if (a.IsFinished()) Effects.remove(a);
else a.Update();
}
}
}
@Override
public void update(World w, Entity e) {
super.update(w, e);
if (particleSrc == null) particleSrc = w.getParticleManager().getSource(ParticleFlame.class);
if (Settings.settingParticlesAll()) createFireParticle(w, e);
else if (Settings.settingParticlesReduced() && age % 3 == 0) createFireParticle(w, e);
if (age % Constants.TICKS_PER_SECOND == 0)
e.damage(w, GeneralSource.fire(2 + w.rnd().nextInt(2)));
}
public boolean itemCast(String rem, Item I, boolean first) {
createEffect();
boolean OK = false;
target = caster.getRoom().findEntity(caster, rem);
if (rem.length() <= 0) caster.echo("Who do you want to use it on?");
else if (target == null) caster.echo("There's nobody around by that name.");
else if (caster.getRoom().getFlag(Room.FLAG_NO_MAGIC))
caster.echo("Your magic doesn't seem to work here.");
else OK = true;
if (target != caster) {
if ((first) && ((effect.getHarmful()) && (!Combat.canAttack(caster, target, true, true))))
return false;
if ((!first)
&& ((effect.getHarmful()) && (!Combat.canAttackSilent(caster, target, true, true))))
return false;
}
if (!OK) return false;
initEffect();
tn = target.getName();
Tn = target.getPName();
ty = Utility.possessive(tn);
Ty = Utility.possessive(Tn);
boolean self = (target == caster);
if (first) tryItemUse(I);
appendOutput(self, false);
return true;
}
/** 显示模糊背景 */
protected void showShowdown() {
ViewHelper.setTranslationY(mRootView, 0);
mEffect.effect(mParentVG, mBg);
ViewGroup.LayoutParams lp =
new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
mParentVG.addView(mBg, lp);
ViewHelper.setAlpha(mBg, 0);
ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(mBg, "alpha", 0, 1);
objectAnimator.setDuration(400);
objectAnimator.start();
}
public boolean cast(String rem) {
createEffect();
boolean OK = false;
target = caster.getRoom().findEntity(caster, rem);
if (rem.length() <= 0) caster.echo("Who do you want to cast it on?");
else if (target == null) caster.echo("There's nobody around by that name.");
else if (caster.getRoom().getFlag(Room.FLAG_NO_MAGIC))
caster.echo("Your magic doesn't seem to work here.");
else if (caster.getCurrentMN() < manacost)
caster.echo("You don't have enough mana to cast " + name + ".");
else if ((effect.getHarmful()) && (!Combat.canAttack(caster, target, true, true))) OK = false;
else OK = true;
if (!OK) return false;
initEffect();
if (effect.getHarmful()) Combat.engage(caster, target, false);
caster.setCurrentMN(caster.getCurrentMN() - manacost);
tn = target.getName();
Tn = target.getPName();
ty = Utility.possessive(tn);
Ty = Utility.possessive(Tn);
boolean self = (target == caster);
updateOutput(self);
appendOutput(self, true);
return true;
}
/**
* Evalute JDT template code snippet
*
* @param effect
* @param args
* @return
*/
private String evaluationJDTTemplate(Effect effect, TemplateBuffer buffer, Object[] args) {
// Prepare a hash map of snippet variables for use by formulas.
HashMap<String, String> variableMap = new HashMap<String, String>();
variableMap.put("cursor", "/*${cursor}*/");
for (int i = 0; i < args.length; i++) {
String value = (String) args[i];
variableMap.put(effect.getParameter(i).getName(), value);
}
StringBuilder sb = new StringBuilder(buffer.getString());
TemplateVariable[] variables = buffer.getVariables();
List<TemplateVariableElement> varList = new ArrayList<TemplateVariableElement>();
for (TemplateVariable var : variables) {
for (int off : var.getOffsets()) {
String value = variableMap.get(var.getName());
if (value != null)
varList.add(new TemplateVariableElement(off, off + var.getLength(), value));
}
}
for (int i = 0; i < varList.size(); i++)
for (int j = i + 1; j < varList.size(); j++) {
TemplateVariableElement itemi = varList.get(i);
TemplateVariableElement itemj = varList.get(j);
if (itemj.getStart() > itemi.getStart()) {
TemplateVariableElement temp = itemi;
varList.set(i, itemj);
varList.set(j, temp);
}
}
for (TemplateVariableElement item : varList) {
sb.replace(item.getStart(), item.getLength(), item.getValue());
}
return sb.toString();
}
/**
* *********************************************************************** Affects the indicated
* MatrixEntity.
*
* @param entity The MatrixEntity to affect.
* ***********************************************************************
*/
protected void affect(MatrixEntity entity) {
for (Effect effect : effects) effect.affect(this, entity);
effects.unlock();
}
@Override
public JsonElement serialize(Effect effect, Type type, JsonSerializationContext context) {
return effect.serialize(GSON);
}
public static Effect.Static makeUnOp(TypeType type) {
return Effect.make().get(ScalarType.scalar(type)).put(ScalarType.scalar(type));
// return new Effect.Static(new Effect.Static.StackOp[] { new
// Effect.Static.StackOp(Type.scalar(type), Effect.Direction.GET), new
// Effect.Static.StackOp(Type.scalar(type), Effect.Direction.PUT) });
}
public void apply(Player target, float expireDuration) {
super.apply(target, expireDuration);
modifiedAmount = target.getMoveSpeed();
target.modifyMoveSpeed(modifiedAmount);
}
private boolean isMergeable(final Effect effect) {
final WakfuRunningEffect re =
RunningEffectConstants.getInstance().getObjectFromId(effect.getActionId());
return re instanceof CharacBuff || re instanceof CharacDebuff;
}
@Override
public int compareTo(final Effect o) {
return Integer.valueOf(getPriorityIndex()).compareTo(Integer.valueOf(o.getPriorityIndex()));
}
