Rework everything again
This commit is contained in:
@@ -31,9 +31,6 @@ class Mod {
|
||||
final bool isBaseGame; // Is this the base RimWorld game
|
||||
final bool isExpansion; // Is this a RimWorld expansion
|
||||
|
||||
int loadBeforeNotPlaced = 0;
|
||||
int loadAfterPlaced = 0;
|
||||
|
||||
Mod({
|
||||
required this.name,
|
||||
required this.id,
|
||||
|
||||
@@ -6,9 +6,12 @@ import 'package:rimworld_modman/mod.dart';
|
||||
import 'package:xml/xml.dart';
|
||||
|
||||
class LoadOrder {
|
||||
final List<Mod> order = [];
|
||||
List<Mod> order = [];
|
||||
final List<String> errors = [];
|
||||
List<String> get loadOrder => order.map((e) => e.id).toList();
|
||||
|
||||
List<String> get loadOrder {
|
||||
return order.map((mod) => mod.id).toList();
|
||||
}
|
||||
|
||||
LoadOrder();
|
||||
|
||||
@@ -251,150 +254,119 @@ class ModList {
|
||||
|
||||
LoadOrder generateLoadOrder([LoadOrder? loadOrder]) {
|
||||
loadOrder ??= LoadOrder();
|
||||
final modMap = {for (final m in activeMods.values) m.id: m};
|
||||
final errors = _validateIncompatibilities(modMap);
|
||||
if (errors.isNotEmpty) {
|
||||
loadOrder.errors.addAll(errors);
|
||||
}
|
||||
|
||||
// Hard dependency graph
|
||||
final inDegree = <String, int>{};
|
||||
final adjacency = <String, List<String>>{};
|
||||
|
||||
// Soft constraint reverse mappings
|
||||
final reverseLoadBefore = <String, List<Mod>>{};
|
||||
final reverseLoadAfter = <String, List<Mod>>{};
|
||||
|
||||
// Initialize data structures
|
||||
final logger = Logger.instance;
|
||||
for (final mod in activeMods.values) {
|
||||
mod.loadBeforeNotPlaced = mod.loadBefore.length;
|
||||
mod.loadAfterPlaced = 0;
|
||||
|
||||
reverseLoadBefore[mod.id] = [];
|
||||
reverseLoadAfter[mod.id] = [];
|
||||
inDegree[mod.id] = 0;
|
||||
adjacency[mod.id] = [];
|
||||
}
|
||||
|
||||
// Build dependency graph and reverse soft constraints
|
||||
for (final mod in activeMods.values) {
|
||||
for (final depId in mod.dependencies) {
|
||||
adjacency[depId]!.add(mod.id);
|
||||
inDegree[mod.id] = (inDegree[mod.id] ?? 0) + 1;
|
||||
}
|
||||
|
||||
for (final targetId in mod.loadBefore) {
|
||||
final target = modMap[targetId];
|
||||
if (target != null) {
|
||||
reverseLoadBefore[targetId]!.add(mod);
|
||||
}
|
||||
}
|
||||
|
||||
for (final targetId in mod.loadAfter) {
|
||||
final target = modMap[targetId];
|
||||
if (target != null) {
|
||||
reverseLoadAfter[targetId]!.add(mod);
|
||||
for (final incomp in mod.incompatibilities) {
|
||||
if (activeMods.containsKey(incomp)) {
|
||||
loadOrder.errors.add(
|
||||
'Incompatibility detected: ${mod.id} is incompatible with $incomp',
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
final heap = PriorityQueue<Mod>((a, b) {
|
||||
// 1. Base game first
|
||||
if (a.isBaseGame != b.isBaseGame) {
|
||||
return a.isBaseGame ? -1 : 1;
|
||||
}
|
||||
// 2. Expansions next
|
||||
if (a.isExpansion != b.isExpansion) {
|
||||
return a.isExpansion ? -1 : 1;
|
||||
}
|
||||
// 3. Soft constraints: Prioritize mods that need to be placed earlier
|
||||
final aUnmetBefore = a.loadBeforeNotPlaced;
|
||||
final bUnmetBefore = b.loadBeforeNotPlaced;
|
||||
if (aUnmetBefore != bUnmetBefore) {
|
||||
return bUnmetBefore.compareTo(aUnmetBefore); // Higher unmetBefore first
|
||||
}
|
||||
// If tied, deprioritize mods with more unmet `loadAfter`
|
||||
final aUnmetAfter = a.loadAfter.length - a.loadAfterPlaced;
|
||||
final bUnmetAfter = b.loadAfter.length - b.loadAfterPlaced;
|
||||
if (aUnmetAfter != bUnmetAfter) {
|
||||
return aUnmetAfter.compareTo(bUnmetAfter); // Lower unmetAfter first
|
||||
}
|
||||
// 4. Smaller size last
|
||||
loadOrder.order.addAll(activeMods.values.toList());
|
||||
|
||||
loadOrder.order.sort((a, b) {
|
||||
if (a.isBaseGame && !b.isBaseGame) return -1;
|
||||
if (!a.isBaseGame && b.isBaseGame) return 1;
|
||||
if (a.isExpansion && !b.isExpansion) return -1;
|
||||
if (!a.isExpansion && b.isExpansion) return 1;
|
||||
return b.size.compareTo(a.size);
|
||||
});
|
||||
|
||||
// Initialize heap with available mods
|
||||
for (final mod in activeMods.values) {
|
||||
if (inDegree[mod.id] == 0) {
|
||||
heap.add(mod);
|
||||
}
|
||||
Map<String, List<Mod>> relations = {};
|
||||
for (int i = loadOrder.order.length - 1; i >= 0; i--) {
|
||||
final mod = loadOrder!.order[i];
|
||||
logger.info('Processing mod: ${mod.id}');
|
||||
loadOrder = shuffleMod(mod, loadOrder, relations);
|
||||
}
|
||||
|
||||
while (heap.isNotEmpty) {
|
||||
final current = heap.removeFirst();
|
||||
loadOrder.order.add(current);
|
||||
|
||||
// Update dependents' in-degree
|
||||
for (final neighborId in adjacency[current.id]!) {
|
||||
inDegree[neighborId] = inDegree[neighborId]! - 1;
|
||||
if (inDegree[neighborId] == 0) {
|
||||
heap.add(modMap[neighborId]!);
|
||||
}
|
||||
}
|
||||
|
||||
// Update soft constraints
|
||||
_updateReverseConstraints(
|
||||
current,
|
||||
reverseLoadBefore,
|
||||
loadOrder,
|
||||
heap,
|
||||
(mod) => mod.loadBeforeNotPlaced--,
|
||||
);
|
||||
_updateReverseConstraints(
|
||||
current,
|
||||
reverseLoadAfter,
|
||||
loadOrder,
|
||||
heap,
|
||||
(mod) => mod.loadAfterPlaced++,
|
||||
);
|
||||
}
|
||||
|
||||
if (loadOrder.order.length != activeMods.length) {
|
||||
loadOrder.errors.add("Cyclic dependencies detected");
|
||||
}
|
||||
|
||||
return loadOrder;
|
||||
return loadOrder!;
|
||||
}
|
||||
|
||||
List<String> _validateIncompatibilities(Map<String, Mod> modMap) {
|
||||
final errors = <String>[];
|
||||
for (final mod in modMap.values) {
|
||||
for (final incompatibleId in mod.incompatibilities) {
|
||||
if (modMap.values.any((m) => m.id == incompatibleId)) {
|
||||
errors.add("Incompatible mods: ${mod.id} and $incompatibleId");
|
||||
}
|
||||
}
|
||||
}
|
||||
return errors;
|
||||
}
|
||||
|
||||
void _updateReverseConstraints(
|
||||
Mod current,
|
||||
Map<String, List<Mod>> reverseMap,
|
||||
// The point of relations and the recursive call is to handle the case where
|
||||
// A mod depends on a mod that depends on another mod
|
||||
// So we move our first mod A to after B
|
||||
// But then we move B after C and A is no longer guranteed to be after B
|
||||
// So we update it too just in case
|
||||
// To make sure we have A B C
|
||||
// Now it opens us to a stack overflow...
|
||||
LoadOrder shuffleMod(
|
||||
Mod mod,
|
||||
LoadOrder loadOrder,
|
||||
PriorityQueue<Mod> heap,
|
||||
void Function(Mod) update,
|
||||
) {
|
||||
reverseMap[current.id]?.forEach((affectedMod) {
|
||||
if (!loadOrder.order.contains(affectedMod)) {
|
||||
update(affectedMod);
|
||||
// If mod is already in heap, re-add to update position
|
||||
if (heap.contains(affectedMod)) {
|
||||
heap.remove(affectedMod);
|
||||
heap.add(affectedMod);
|
||||
}
|
||||
Map<String, List<Mod>> relations, [
|
||||
Map<String, bool>? seen,
|
||||
]) {
|
||||
final logger = Logger.instance;
|
||||
logger.info('Starting shuffleMod for mod: ${mod.id}');
|
||||
|
||||
// Prevent infinite loops
|
||||
seen ??= <String, bool>{};
|
||||
if (seen[mod.id] == true) {
|
||||
logger.info('Mod ${mod.id} has already been seen, skipping.');
|
||||
return loadOrder;
|
||||
}
|
||||
seen[mod.id] = true;
|
||||
logger.info('Marking mod ${mod.id} as seen.');
|
||||
|
||||
for (final dependency in mod.dependencies) {
|
||||
logger.info('Checking dependency: $dependency for mod ${mod.id}');
|
||||
final depMod = mods[dependency];
|
||||
if (depMod == null) {
|
||||
loadOrder.errors.add(
|
||||
'Missing dependency: ${mod.id} requires mod with ID $dependency',
|
||||
);
|
||||
logger.warning(
|
||||
'Missing dependency: ${mod.id} requires mod with ID $dependency',
|
||||
);
|
||||
continue;
|
||||
}
|
||||
});
|
||||
|
||||
if (loadOrder.order.indexOf(mod) < loadOrder.order.indexOf(depMod)) {
|
||||
logger.info('Reordering: ${mod.id} should come after ${depMod.id}');
|
||||
loadOrder.order.removeAt(loadOrder.order.indexOf(mod));
|
||||
loadOrder.order.insert(loadOrder.order.indexOf(depMod) + 1, mod);
|
||||
relations[mod.id] = [...relations[mod.id] ?? [], depMod];
|
||||
}
|
||||
}
|
||||
|
||||
for (final loadAfter in mod.loadAfter) {
|
||||
logger.info('Checking loadAfter: $loadAfter for mod ${mod.id}');
|
||||
final loadAfterMod = mods[loadAfter];
|
||||
if (loadAfterMod != null &&
|
||||
loadOrder.order.indexOf(mod) <
|
||||
loadOrder.order.indexOf(loadAfterMod)) {
|
||||
logger.info(
|
||||
'Reordering: ${mod.id} should come after ${loadAfterMod.id}',
|
||||
);
|
||||
loadOrder.order.removeAt(loadOrder.order.indexOf(mod));
|
||||
loadOrder.order.insert(loadOrder.order.indexOf(loadAfterMod) + 1, mod);
|
||||
relations[mod.id] = [...relations[mod.id] ?? [], loadAfterMod];
|
||||
}
|
||||
}
|
||||
|
||||
for (final loadBefore in mod.loadBefore) {
|
||||
logger.info('Checking loadBefore: $loadBefore for mod ${mod.id}');
|
||||
final loadBeforeMod = mods[loadBefore];
|
||||
if (loadBeforeMod != null &&
|
||||
loadOrder.order.indexOf(mod) >
|
||||
loadOrder.order.indexOf(loadBeforeMod)) {
|
||||
logger.info(
|
||||
'Reordering: ${mod.id} should come before ${loadBeforeMod.id}',
|
||||
);
|
||||
loadOrder.order.removeAt(loadOrder.order.indexOf(mod));
|
||||
loadOrder.order.insert(loadOrder.order.indexOf(loadBeforeMod), mod);
|
||||
relations[mod.id] = [...relations[mod.id] ?? [], loadBeforeMod];
|
||||
}
|
||||
}
|
||||
|
||||
for (final relatedMod in relations[mod.id] ?? []) {
|
||||
logger.info('Recursively shuffling related mod: ${relatedMod.id}');
|
||||
loadOrder = shuffleMod(relatedMod, loadOrder, relations, seen);
|
||||
}
|
||||
logger.info('Completed shuffleMod for mod: ${mod.id}');
|
||||
return loadOrder;
|
||||
}
|
||||
|
||||
LoadOrder loadDependencies(
|
||||
|
||||
Reference in New Issue
Block a user