// Public Methods
protected override void Update(long timePassed)
{
if (BoonStack.Count > 0 && timePassed > 0)
{
_lastSrcRemoves.Clear();
var toAdd = new BoonSimulationItemIntensity(BoonStack);
if (GenerationSimulation.Count > 0)
{
BoonSimulationItem last = GenerationSimulation.Last();
if (last.End > toAdd.Start)
{
last.SetEnd(toAdd.Start);
}
}
GenerationSimulation.Add(toAdd);
long diff = Math.Min(BoonStack.Min(x => x.BoonDuration), timePassed);
long leftOver = timePassed - diff;
// Subtract from each
for (int i = BoonStack.Count - 1; i >= 0; i--)
{
var item = new BoonStackItem(BoonStack[i], diff, diff);
BoonStack[i] = item;
if (item.BoonDuration == 0)
{
_lastSrcRemoves.Add(item.SeedSrc);
}
}
BoonStack.RemoveAll(x => x.BoonDuration == 0);
Update(leftOver);
}
}
// Public Methods
public override void update(long time_passed)
{
if (boon_stack.Count > 0)
{
var toAdd = new BoonSimulationItemDuration(boon_stack[0]);
if (simulation.Count > 0)
{
var last = simulation.Last();
if (last.getEnd() > toAdd.getStart())
{
last.setEnd(toAdd.getStart());
}
}
simulation.Add(toAdd);
boon_stack[0] = new BoonStackItem(boon_stack[0], time_passed, -time_passed);
long diff = time_passed - Math.Abs(Math.Min(boon_stack[0].boon_duration, 0));
for (int i = 1; i < boon_stack.Count; i++)
{
boon_stack[i] = new BoonStackItem(boon_stack[i], diff, 0);
}
if (boon_stack[0].boon_duration <= 0)
{
// Spend leftover time
long leftover = Math.Abs(boon_stack[0].boon_duration);
boon_stack.RemoveAt(0);
update(leftover);
}
}
}
// Public Methods
public void add(long boon_duration, ushort srcinstid, long start, long overstack)
{
var toAdd = new BoonStackItem(start, boon_duration, srcinstid, overstack);
// Find empty slot
if (!isFull())
{
boon_stack.Add(toAdd);
sort();
}
// Replace lowest value
else
{
int index = boon_stack.Count - 1;
if (boon_stack[index].boon_duration < boon_duration)
{
// added overwritten value as a overstack
long overstackValue = boon_stack[index].overstack + boon_stack[index].boon_duration;
ushort srcValue = boon_stack[index].src;
for (int i = simulation.Count - 1; i >= 0; i--)
{
if (simulation[i].addOverstack(srcValue, overstackValue))
{
break;
}
}
boon_stack[index] = toAdd;
sort();
}
}
}
// Public Methods
protected override void Update(long timePassed)
{
if (BoonStack.Count > 0)
{
var toAdd = new BoonSimulationItemDuration(BoonStack[0]);
if (GenerationSimulation.Count > 0)
{
var last = GenerationSimulation.Last();
if (last.End > toAdd.Start)
{
last.SetEnd(toAdd.Start);
}
}
GenerationSimulation.Add(toAdd);
BoonStack[0] = new BoonStackItem(BoonStack[0], timePassed, timePassed);
long diff = timePassed - Math.Abs(Math.Min(BoonStack[0].BoonDuration, 0));
for (int i = 1; i < BoonStack.Count; i++)
{
BoonStack[i] = new BoonStackItem(BoonStack[i], diff, 0);
}
if (BoonStack[0].BoonDuration <= 0)
{
// Spend leftover time
long leftover = Math.Abs(BoonStack[0].BoonDuration);
BoonStack.RemoveAt(0);
Update(leftover);
}
}
}
public BoonSimulationItemDuration(BoonStackItem other) : base(other.Start, other.BoonDuration)
{
_src = other.Src;
_seedSrc = other.SeedSrc;
_applicationTime = other.ApplicationTime;
_seedTime = other.SeedTime;
}
public override bool StackEffect(ParsedLog log, BoonStackItem stackItem, List <BoonStackItem> stacks, List <BoonSimulationItemWasted> wastes)
{
if (stacks.Count <= 1)
{
throw new InvalidOperationException("Queue logic based must have a >1 capacity");
}
BoonStackItem first = stacks[0];
stacks.RemoveAt(0);
BoonStackItem minItem = stacks.MinBy(x => x.TotalBoonDuration());
if (minItem.TotalBoonDuration() >= stackItem.TotalBoonDuration())
{
stacks.Insert(0, first);
return(false);
}
wastes.Add(new BoonSimulationItemWasted(minItem.Src, minItem.BoonDuration, minItem.Start, minItem.ApplicationTime));
if (minItem.Extensions.Count > 0)
{
foreach ((ushort src, long value, long time) in minItem.Extensions)
{
wastes.Add(new BoonSimulationItemWasted(src, value, minItem.Start, time));
}
}
stacks[stacks.IndexOf(minItem)] = stackItem;
stacks.Insert(0, first);
Sort(log, stacks);
return(true);
}
// Public Methods
public override void update(long time_passed)
{
if (boon_stack.Count > 0)
{
var toAdd = new BoonSimulationItemIntensity(boon_stack);
if (simulation.Count > 0)
{
BoonSimulationItem last = simulation.Last();
if (last.getEnd() > toAdd.getStart())
{
last.setEnd(toAdd.getStart());
}
}
simulation.Add(toAdd);
// Subtract from each
for (int i = boon_stack.Count - 1; i >= 0; i--)
{
var item = new BoonStackItem(boon_stack[i], time_passed, -time_passed);
if (item.boon_duration <= 0)
{
boon_stack.RemoveAt(i);
}
else
{
boon_stack[i] = item;
}
}
}
}
public override bool StackEffect(ParsedLog log, BoonStackItem stackItem, List <BoonStackItem> stacks, List <BoonSimulationItemWasted> wastes)
{
if (stacks.Count == 0)
{
return(false);
}
BoonStackItem stack = stacks[0];
if (stack.TotalBoonDuration() < stackItem.TotalBoonDuration())
{
wastes.Add(new BoonSimulationItemWasted(stack.Src, stack.BoonDuration, stack.Start));
if (stack.Extensions.Count > 0)
{
foreach ((AgentItem src, long value) in stack.Extensions)
{
wastes.Add(new BoonSimulationItemWasted(src, value, stack.Start));
}
}
stacks[0] = stackItem;
Sort(log, stacks);
return(true);
}
else
{
return(false);
}
}
public BoonStackItem(BoonStackItem other, long start_shift, long duration_shift)
{
this.start = Math.Max(other.start + start_shift, 0);
this.boon_duration = other.boon_duration + duration_shift;
// if duration shift > 0 this means the boon ticked, aka already in simulation, we remove the overstack
this.overstack = duration_shift > 0 ? 0 : other.overstack;
this.src = other.src;
}
public override bool StackEffect(ParsedLog log, BoonStackItem stackItem, List <BoonStackItem> stacks, List <BoonSimulationOverstackItem> overstacks)
{
if (stacks.Count == 0)
{
return(false);
}
BoonStackItem stack = stacks[0];
overstacks.Add(new BoonSimulationOverstackItem(stack.Src, stack.BoonDuration, stack.Start));
stacks[0] = stackItem;
return(true);
}
public override bool StackEffect(ParsedLog log, BoonSimulator.BoonStackItem stackItem, List <BoonSimulator.BoonStackItem> stacks, List <BoonSimulationOverstackItem> overstacks)
{
for (int i = 0; i < stacks.Count; i++)
{
if (stacks[i].BoonDuration < stackItem.BoonDuration)
{
BoonStackItem stack = stacks[i];
overstacks.Add(new BoonSimulationOverstackItem(stack.Src, stack.BoonDuration, stack.Start));
stacks[i] = stackItem;
Sort(log, stacks);
return(true);
}
}
return(false);
}
public override bool StackEffect(ParsedLog log, BoonStackItem stackItem, List <BoonStackItem> stacks, List <BoonSimulationItemWasted> wastes)
{
if (stacks.Count == 0)
{
return(false);
}
BoonStackItem stack = stacks[0];
wastes.Add(new BoonSimulationItemWasted(stack.Src, stack.BoonDuration, stack.Start, stack.ApplicationTime));
if (stack.Extensions.Count > 0)
{
foreach ((ushort src, long value, long time) in stack.Extensions)
{
wastes.Add(new BoonSimulationItemWasted(src, value, stack.Start, time));
}
}
stacks[0] = stackItem;
return(true);
}
private void Remove(ushort provokedBy, long boonDuration, long start, ParseEnum.BuffRemove removeType)
{
if (GenerationSimulation.Count > 0)
{
BoonSimulationItem last = GenerationSimulation.Last();
if (last.End > start)
{
last.SetEnd(start);
}
}
switch (removeType)
{
case ParseEnum.BuffRemove.All:
foreach (BoonStackItem stackItem in BoonStack)
{
OverstackSimulationResult.Add(new BoonSimulationOverstackItem(stackItem.Src, stackItem.BoonDuration, start));
CleanseSimulationResult.Add(new BoonSimulationCleanseItem(provokedBy, stackItem.BoonDuration, start));
}
BoonStack.Clear();
break;
case ParseEnum.BuffRemove.Single:
case ParseEnum.BuffRemove.Manual:
for (int i = 0; i < BoonStack.Count; i++)
{
BoonStackItem stackItem = BoonStack[i];
if (Math.Abs(boonDuration - stackItem.BoonDuration) < 10)
{
OverstackSimulationResult.Add(new BoonSimulationOverstackItem(stackItem.Src, stackItem.BoonDuration, start));
CleanseSimulationResult.Add(new BoonSimulationCleanseItem(provokedBy, stackItem.BoonDuration, start));
BoonStack.RemoveAt(i);
break;
}
}
break;
default:
break;
}
_logic.Sort(_log, BoonStack);
Update(0);
}
private void Add(long boonDuration, ushort srcinstid, long start)
{
var toAdd = new BoonStackItem(start, boonDuration, srcinstid);
// Find empty slot
if (BoonStack.Count < _capacity)
{
BoonStack.Add(toAdd);
_logic.Sort(_log, BoonStack);
}
// Replace lowest value
else
{
bool found = _logic.StackEffect(_log, toAdd, BoonStack, OverstackSimulationResult);
if (!found)
{
OverstackSimulationResult.Add(new BoonSimulationOverstackItem(srcinstid, boonDuration, start));
}
}
}
public override bool StackEffect(ParsedLog log, BoonStackItem stackItem, List <BoonStackItem> stacks, List <BoonSimulationOverstackItem> overstacks)
{
if (stacks.Count <= 1)
{
throw new InvalidOperationException("Queue logic based must have a >1 capacity");
}
BoonStackItem first = stacks[0];
stacks.RemoveAt(0);
BoonStackItem minItem = stacks.MinBy(x => x.BoonDuration);
if (minItem.BoonDuration >= stackItem.BoonDuration)
{
return(false);
}
overstacks.Add(new BoonSimulationOverstackItem(minItem.Src, minItem.BoonDuration, minItem.Start));
stacks[stacks.IndexOf(minItem)] = stackItem;
stacks.Insert(0, first);
Sort(log, stacks);
return(true);
}
// Public Methods
protected override void Update(long timePassed)
{
if (BoonStack.Count > 0 && timePassed > 0)
{
_lastSrcRemove = 0;
var toAdd = new BoonSimulationItemDuration(BoonStack[0]);
if (GenerationSimulation.Count > 0)
{
var last = GenerationSimulation.Last();
if (last.End > toAdd.Start)
{
last.SetEnd(toAdd.Start);
}
}
GenerationSimulation.Add(toAdd);
long timeDiff = BoonStack[0].BoonDuration - timePassed;
long diff = 0;
long leftOver = 0;
if (timeDiff < 0)
{
diff = BoonStack[0].BoonDuration;
leftOver = timePassed - diff;
}
else
{
diff = timePassed;
}
BoonStack[0] = new BoonStackItem(BoonStack[0], diff, diff);
for (int i = 1; i < BoonStack.Count; i++)
{
BoonStack[i] = new BoonStackItem(BoonStack[i], diff, 0);
}
if (BoonStack[0].BoonDuration == 0)
{
_lastSrcRemove = BoonStack[0].SeedSrc;
BoonStack.RemoveAt(0);
}
Update(leftOver);
}
}
// Public Methods
protected override void Update(long timePassed)
{
if (BoonStack.Count > 0)
{
var toAdd = new BoonSimulationItemIntensity(BoonStack);
if (GenerationSimulation.Count > 0)
{
BoonSimulationItem last = GenerationSimulation.Last();
if (last.End > toAdd.Start)
{
last.SetEnd(toAdd.Start);
}
}
GenerationSimulation.Add(toAdd);
// Subtract from each
for (int i = BoonStack.Count - 1; i >= 0; i--)
{
var item = new BoonStackItem(BoonStack[i], timePassed, timePassed);
BoonStack[i] = item;
}
BoonStack.RemoveAll(x => x.BoonDuration < 1);
}
}
public override void Extend(long extension, long oldValue, ushort src, long start)
{
if ((BoonStack.Count > 0 && oldValue > 0) || BoonStack.Count == Capacity)
{
BoonStackItem minItem = BoonStack.MinBy(x => Math.Abs(x.TotalBoonDuration() - oldValue));
if (minItem != null)
{
minItem.Extend(extension, src, start);
}
}
else
{
if (_lastSrcRemoves.Count > 0)
{
Add(oldValue + extension, src, _lastSrcRemoves.First(), start);
_lastSrcRemoves.RemoveAt(0);
}
else
{
Add(oldValue + extension, src, src, start);
}
}
}
public abstract bool StackEffect(ParsedLog log, BoonStackItem stackItem, List <BoonStackItem> stacks, List <BoonSimulationOverstackItem> overstacks);
public int Compare(BoonStackItem x, BoonStackItem y)
{
return(-GetHealing(x).CompareTo(GetHealing(y)));
}
private uint GetHealing(BoonStackItem stack)
{
return(stack.SeedSrc.Healing);
}
public abstract bool StackEffect(ParsedLog log, BoonStackItem stackItem, List <BoonStackItem> stacks, List <BoonSimulationItemWasted> wastes);
private uint GetHealing(BoonStackItem stack)
{
AgentItem agent = _log.AgentData.GetAgentByInstID(stack.SeedSrc, _log.FightData.ToLogSpace(stack.SeedTime));
return(agent.Healing);
}
public BoonSimulationItemDuration(BoonStackItem other) : base(other.start, other.boon_duration)
{
this.src = other.src;
this.overstack = other.overstack;
}
public BoonSimulationItemDuration(BoonStackItem other) : base(other.Start, other.BoonDuration)
{
_src = other.Src;
}
public BoonSimulationItemDuration(BoonStackItem other) : base(other.Start, other.BoonDuration)
{
_src = other.Src;
_seedSrc = other.SeedSrc;
_isExtension = other.IsExtension;
}
public BoonStackItem(BoonStackItem other, long startShift, long durationShift)
{
Start = other.Start + startShift;
BoonDuration = other.BoonDuration - durationShift;
Src = other.Src;
}
