// 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; }