private Buff findEqualBuff(Buff toAdd) {
for (Buff b : buffList) {
if (toAdd.getClass().equals(b.getClass())) {
return b;
}
}
return null;
}
private boolean isImmuneTo(Buff newBuff) {
for (Class<? extends Buff> buff : immunityList.keySet()) {
if (buff.isAssignableFrom(newBuff.getClass())) {
UpgradeType immuneType = immunityList.get(buff);
return immuneType.equals(UpgradeType.NULL) || immuneType.equals(newBuff.getType());
}
}
return false;
}
/**
* Advances time of buffs in myObject by increment 1
*
* @param myObject
*/
public void update(GameObject myObject) {
ArrayList<Buff> removeBuffer = new ArrayList<Buff>();
for (Buff buff : buffList) {
if (buff.timeLeft() <= 0) {
removeBuffer.add(buff);
}
buff.advanceTime(1, myObject);
}
for (Buff toRemove : removeBuffer) {
removeBuff(toRemove, myObject);
}
}
public void castSpell(Ability ability) {
if (ability.state != Ability.State.READY
&& ability.abilityStats.castType != Castable.CastType.TOGGLE) return;
if (ability.abilityStats.castType == Castable.CastType.ALIVETARGET) {
if (owner.selectedUnit == null
|| !Alive.class.isAssignableFrom(owner.selectedUnit.getClass())) return;
ability.setTarget((Alive) owner.selectedUnit);
}
try {
ability.activate();
} catch (SLEImproperInputException e) {
System.out.println("The hero was unable to cast the spell due to improper input");
e.printStackTrace();
}
for (Buff b : getBuffs())
if (b.activationTrigger == Buff.TriggerType.ONSPELLCAST) b.trigger(this);
}
public void receiveBuff(Buff toAdd, GameObject myObject) {
if (isImmuneTo(toAdd)) {
return;
}
Buff equalBuff = findEqualBuff(toAdd);
if (equalBuff == null) {
applyBuff(toAdd, myObject);
} else if (toAdd.isStrongerBuff(equalBuff)) {
removeBuff(equalBuff, myObject);
applyBuff(toAdd, myObject);
}
}
@Override
protected void write() {
Queue<Buff> buffs = fill(_buffer.length);
if (buffs != null) {
int offset = 0;
for (; ; ) {
Buff buff = buffs.poll();
if (buff == null) break;
int remaining = buff.remaining();
buff.getImmutably(_buffer, offset, remaining);
buff.recycle();
offset += remaining;
}
writeComplete();
}
}
@Override
void getBlock(URI uri, long tick) {
Buff duplicate = null;
synchronized (this) {
if (Debug.THREADS) ThreadAssert.resume(this, false);
int index = Tick.indexOf(_ticks, tick);
if (index >= 0) {
Buff buff = _buffs[index];
if (buff != null) {
duplicate = buff.duplicate();
if (Debug.THREADS) ThreadAssert.exchangeGive(duplicate, duplicate);
}
}
if (Debug.THREADS) ThreadAssert.suspend(this);
}
if (duplicate != null) {
Buff[] duplicates = new Buff[] {duplicate};
if (Debug.THREADS) {
ThreadAssert.exchangeTake(duplicate);
ThreadAssert.exchangeGive(duplicates, duplicate);
}
uri.onBlock(this, tick, duplicates, null, true, null, false, null);
if (Debug.THREADS) ThreadAssert.exchangeTake(duplicates);
duplicate.recycle();
}
}
@Test
public void should_getInstantDamageMessage_return_message_when_is_a_Instant_buff() {
assertThat(critial.getInstantDamageMessage(), is("发动了全力一击,"));
}
@Override
public void detach() {
target.paralysed = false;
if (target instanceof Hero) ((Hero) target).restoreHealth = false;
super.detach();
}
@Override
public void restoreFromBundle(Bundle bundle) {
super.restoreFromBundle(bundle);
level = bundle.getInt(LEVEL);
}
public void read(byte[] buffer, int length) {
if (resumeRead()) {
Buff buff = Buff.getOrCreate();
buff.position(Buff.getLargestUnsplitable());
byte[] temp = _randomSplitter.read(buffer, 0, length, buff.remaining());
buff.putImmutably(temp, 0, temp.length);
buff.limit(buff.position() + temp.length);
if (Debug.ENABLED && buff.remaining() == 0) buff.lock(buff.limit());
read(buff);
buff.recycle();
suspendRead();
}
}
@Test
public void should_getDelayDamageMessage_return_what_kind_of_damage() {
assertThat(critial.getDelayDamageMessage(), is(""));
}
@Override
public void storeInBundle(Bundle bundle) {
super.storeInBundle(bundle);
bundle.put(LEFT, left);
}
private void removeBuff(Buff b, GameObject myObject) {
buffList.remove(b);
b.unapply(myObject);
}
private void applyBuff(Buff b, GameObject myObject) {
b.apply(myObject);
buffList.add(b);
}
@Test
public void should_getBuffMessage_return_what_kind_of_buff() {
assertThat(critial.getBuffMessage(), is(""));
}
@Test
public void should_getDelayDamagePoint_return_how_many_damage_when_a_delayDamage_buff() {
assertThat(critial.getDelayDamagePoint(), is(0));
}
@Override
public void restoreFromBundle(Bundle bundle) {
super.restoreFromBundle(bundle);
left = bundle.getFloat(LEFT);
}
@Test
public void should_getCritialRate_return_3_when_is_a_critial_buff() {
assertThat(critial.getCritialRate(), is(3));
}
public void proc(Char enemy) {
if (Random.Int(2) == 0) Buff.affect(enemy, Burning.class).reignite(enemy);
enemy.sprite.emitter().burst(FlameParticle.FACTORY, 2);
}
@Override
void onBlock(URI uri, long tick, Buff[] buffs, long[] removals, boolean requested) {
int capacity = 0;
if (Debug.THREADS) ThreadAssert.exchangeTake(buffs);
for (int i = 0; i < buffs.length; i++) capacity += buffs[i].remaining();
Buff buff = Buff.createCustom(capacity, false);
if (Stats.ENABLED) Stats.Instance.MemoryBlocksCreated.incrementAndGet();
for (int i = 0; i < buffs.length; i++) {
buff.putImmutably(buffs[i]);
if (Debug.THREADS) ThreadAssert.exchangeGive(buffs, buffs[i]);
}
if (Debug.ENABLED) Debug.assertion(buff.remaining() == 0);
buff.position(0);
buff.mark();
List<Buff> recycle = null;
if (Debug.THREADS) ThreadAssert.exchangeGive(buff, buff);
synchronized (this) {
if (Debug.THREADS) {
ThreadAssert.resume(this, false);
ThreadAssert.exchangeTake(buff);
}
int index = Tick.indexOf(_ticks, tick);
if (index < 0) {
index = add(tick);
_buffs[index] = buff;
if (Stats.ENABLED) Stats.Instance.MemoryBlocksLive.incrementAndGet();
} else {
if (Debug.ENABLED) Debug.assertion(_buffs[index] != null);
recycle = new List<Buff>();
recycle.add(buff);
}
for (int i = 0; removals != null && i < removals.length; i++) {
if (!Tick.isNull(removals[i])) {
index = Tick.remove(_ticks, removals[i]);
if (index >= 0) {
if (recycle == null) recycle = new List<Buff>();
recycle.add(_buffs[index]);
_buffs[index] = null;
if (Stats.ENABLED) Stats.Instance.MemoryBlocksLive.decrementAndGet();
}
}
}
if (Debug.THREADS) {
for (int i = 0; recycle != null && i < recycle.size(); i++)
ThreadAssert.exchangeGive(recycle, recycle.get(i));
ThreadAssert.suspend(this);
}
}
if (!location().isCache()) {
uri.onAck(this, tick);
if (Stats.ENABLED) Stats.Instance.AckCreated.incrementAndGet();
}
if (recycle != null) {
if (Debug.THREADS) ThreadAssert.exchangeTake(recycle);
for (int i = 0; i < recycle.size(); i++) recycle.get(i).recycle();
}
}
@Override
public void storeInBundle(Bundle bundle) {
super.storeInBundle(bundle);
bundle.put(LEVEL, level);
}
