Dependency Graphs

[tool4ever]

This implements the algorithm I've outlined in #5642 :)

• tweaked StaticEffect so it can undo single layers only
• add test that would fail on master

To handle more cases generateStaticAbilityResult will need additional logic for the other layers.
But just comparing the affected objects should already support quite a lot.

Closes #4680
Closes #1850
Closes #4108
Closes #4841
Closes #6669

[Hanmac]

final Comparator<StaticAbility> comp = (a, b) -> ComparisonChain.start()
                .compareTrueFirst(a.isCharacteristicDefining(), b.isCharacteristicDefining())
                .compare(a.getHostCard().getLayerTimestamp(), b.getHostCard().getLayerTimestamp())
                .result();
        staticAbilities.sort(comp);

maybe remove this, and separate them inside the layers loop?

[tool4ever]

I think right now I do need them pre-sorted once, so I can always start checking from the earliest

[tool4ever]

@Hanmac
we could define the comp as Static class field though
maybe better for performance instead of always creating it each time?

[Hanmac]

@Hanmac we could define the comp as Static class field though maybe better for performance instead of always creating it each time?

Look what I meant:
#5642 (comment)

I think filtering the list for CDA first would help

[tool4ever]

Feel free and try to tweak it 🤔

I tested the sub-issues and easier ones work now, those have been linked for closing

[Hanmac]

@tool4ever should we add more test cases?

[tool4ever]

@Hanmac
last test updated to prove loop detection works based on
https://apps.magicjudges.org/forum/topic/11405/

[tool4ever]

Performance seems ok for average AI games:

It should be O(n*(n-1)) for the amount of statics. The logic shortcut I added probably helps...

[Hanmac]

Performance seems ok for average AI games:

It should be O(n*(n-1)) for the amount of statics. The logic shortcut I added probably helps...

What does the rest of show? I mean should part is the most used one and should be optimized?

[tool4ever]

Here's one from a BO5 4 player game with random decks:

We can still expect a lesser improvement if I refactor the players do be handled in their own loop. Just need to do more research if they even need dependency checking, so that's another follow-up which can be handled soon after this survives a few snapshots. 🤞

[Hanmac]

with rest i mean, what is above? what code (not related to this MR) takes the most amount of power?

[tool4ever]

That's a bit harder to tell recently because the AI timeout stuff creates so many threads.
Aggregating their calls in VisualVM requires some trickery I'm still trying to figure out.

But here's a Top10 of Hotspots:

If there's another quick-win I haven't found it this way yet.

[Hanmac]

@tool4ever i think you can move the Comperator into a Const if you want

but i still think removing the CDA first from the list and then sorting by timestamp / dependency later separate might be better?

[tool4ever]

There's no benefit from multiple sort calls since CDA need timestamp order too and this will also make sure they get applied first anyway.

I'm already skipping them for dependency order right now until a case for it gets supported.

➡️ Comparator extracted and converted to native Java

[Hanmac]

i haven't found an example for CDA dependency yet, because they can only affect itself, it needs to be something on the same card, or gained something via copy layers

The Full dependency is only in effect when the TreeTable are replaced with LinkedHashMap
and for that to work correct, we need to update the Pump and Animate effects

[tool4ever]

Indeed more work / PR will still remain...

Luckily with such effects:

• they're immutable so removal can't be caused in this way
• affect Card.IsRemembered or EffectSource so that's fixed too
• which only leaves the somewhat rarer third case

But is anything else needed here?
Let's please merge to fix what's already possible and worry about the rest step by step :)

[Hanmac]

i think this is good for now?

We just need to update the other effects soonish