665 lines
19 KiB
Dart
665 lines
19 KiB
Dart
import 'dart:io';
|
|
|
|
import 'package:rimworld_modman/logger.dart';
|
|
import 'package:rimworld_modman/mod.dart';
|
|
import 'package:xml/xml.dart';
|
|
|
|
class LoadOrder {
|
|
final List<String> loadOrder = [];
|
|
final List<String> errors = [];
|
|
|
|
LoadOrder();
|
|
|
|
bool get hasErrors => errors.isNotEmpty;
|
|
}
|
|
|
|
class ModList {
|
|
String configPath = '';
|
|
String modsPath = '';
|
|
// O(1) lookup
|
|
Map<String, bool> activeMods = {};
|
|
Map<String, Mod> mods = {};
|
|
|
|
ModList({this.configPath = '', this.modsPath = ''});
|
|
|
|
Stream<Mod> loadAvailable() async* {
|
|
final logger = Logger.instance;
|
|
final stopwatch = Stopwatch()..start();
|
|
|
|
final directory = Directory(modsPath);
|
|
|
|
if (!directory.existsSync()) {
|
|
logger.error('Error: Mods root directory does not exist: $modsPath');
|
|
return;
|
|
}
|
|
|
|
final List<FileSystemEntity> entities = directory.listSync();
|
|
// TODO: Count only the latest version of each mod and not all versions
|
|
final List<String> modDirectories =
|
|
entities.whereType<Directory>().map((dir) => dir.path).toList();
|
|
|
|
logger.info(
|
|
'Found ${modDirectories.length} mod directories (${stopwatch.elapsedMilliseconds}ms)',
|
|
);
|
|
|
|
for (final modDir in modDirectories) {
|
|
try {
|
|
final modStart = stopwatch.elapsedMilliseconds;
|
|
|
|
// Check if this directory contains a valid mod
|
|
final aboutFile = File('$modDir/About/About.xml');
|
|
if (!aboutFile.existsSync()) {
|
|
logger.warning('No About.xml found in directory: $modDir');
|
|
continue;
|
|
}
|
|
|
|
final mod = Mod.fromDirectory(modDir);
|
|
logger.info('Loaded mod from directory: ${mod.name} (ID: ${mod.id})');
|
|
|
|
if (mods.containsKey(mod.id)) {
|
|
logger.warning(
|
|
'Mod $mod.id already exists in mods list, overwriting',
|
|
);
|
|
final existingMod = mods[mod.id]!;
|
|
mods[mod.id] = Mod(
|
|
name: mod.name,
|
|
id: mod.id,
|
|
path: mod.path,
|
|
versions: mod.versions,
|
|
description: mod.description,
|
|
dependencies: mod.dependencies,
|
|
loadAfter: mod.loadAfter,
|
|
loadBefore: mod.loadBefore,
|
|
incompatibilities: mod.incompatibilities,
|
|
size: mod.size,
|
|
enabled: existingMod.enabled,
|
|
isBaseGame: existingMod.isBaseGame,
|
|
isExpansion: existingMod.isExpansion,
|
|
);
|
|
logger.info('Updated existing mod: ${mod.name} (ID: ${mod.id})');
|
|
} else {
|
|
mods[mod.id] = mod;
|
|
logger.info('Added new mod: ${mod.name} (ID: ${mod.id})');
|
|
}
|
|
|
|
final modTime = stopwatch.elapsedMilliseconds - modStart;
|
|
logger.info(
|
|
'Loaded mod from directory: ${mod.name} (ID: ${mod.id}) in $modTime ms',
|
|
);
|
|
yield mod;
|
|
} catch (e) {
|
|
logger.error('Error loading mod from directory: $modDir');
|
|
logger.error('Error: $e');
|
|
}
|
|
}
|
|
}
|
|
|
|
Stream<Mod> loadActive() async* {
|
|
final logger = Logger.instance;
|
|
final file = File(configPath);
|
|
logger.info('Loading configuration from: $configPath');
|
|
|
|
try {
|
|
final xmlString = file.readAsStringSync();
|
|
logger.info('XML content read successfully.');
|
|
|
|
final xmlDocument = XmlDocument.parse(xmlString);
|
|
logger.info('XML document parsed successfully.');
|
|
|
|
final modConfigData = xmlDocument.findElements("ModsConfigData").first;
|
|
logger.info('Found ModsConfigData element.');
|
|
|
|
final modsElement = modConfigData.findElements("activeMods").first;
|
|
logger.info('Found activeMods element.');
|
|
|
|
final modElements = modsElement.findElements("li");
|
|
logger.info('Found ${modElements.length} active mods.');
|
|
|
|
// Get the list of known expansions
|
|
final knownExpansionsElement =
|
|
modConfigData.findElements("knownExpansions").firstOrNull;
|
|
final knownExpansionIds =
|
|
knownExpansionsElement != null
|
|
? knownExpansionsElement
|
|
.findElements("li")
|
|
.map((e) => e.innerText.toLowerCase())
|
|
.toList()
|
|
: <String>[];
|
|
|
|
logger.info('Found ${knownExpansionIds.length} known expansions.');
|
|
|
|
// Clear and recreate the mods list
|
|
for (final modElement in modElements) {
|
|
final modId = modElement.innerText.toLowerCase();
|
|
|
|
// Check if this is a special Ludeon mod
|
|
final isBaseGame = modId == 'ludeon.rimworld';
|
|
final isExpansion =
|
|
!isBaseGame &&
|
|
modId.startsWith('ludeon.rimworld.') &&
|
|
knownExpansionIds.contains(modId);
|
|
|
|
final existingMod = mods[modId];
|
|
final mod = Mod(
|
|
name:
|
|
existingMod?.name ??
|
|
(isBaseGame
|
|
? "RimWorld"
|
|
: isExpansion
|
|
? "RimWorld ${_expansionNameFromId(modId)}"
|
|
: modId),
|
|
id: existingMod?.id ?? modId,
|
|
path: existingMod?.path ?? '',
|
|
versions: existingMod?.versions ?? [],
|
|
description:
|
|
existingMod?.description ??
|
|
(isBaseGame
|
|
? "RimWorld base game"
|
|
: isExpansion
|
|
? "RimWorld expansion"
|
|
: ""),
|
|
dependencies: existingMod?.dependencies ?? [],
|
|
loadAfter:
|
|
existingMod?.loadAfter ??
|
|
(isExpansion ? ['ludeon.rimworld'] : []),
|
|
loadBefore: existingMod?.loadBefore ?? [],
|
|
incompatibilities: existingMod?.incompatibilities ?? [],
|
|
enabled: existingMod?.enabled ?? false,
|
|
size: existingMod?.size ?? 0,
|
|
isBaseGame: isBaseGame,
|
|
isExpansion: isExpansion,
|
|
);
|
|
if (mods.containsKey(modId)) {
|
|
logger.warning('Mod $modId already exists in mods list, overwriting');
|
|
}
|
|
mods[modId] = mod;
|
|
setEnabled(modId, true);
|
|
yield mod;
|
|
}
|
|
|
|
logger.info('Loaded ${modElements.length} mods from config file.');
|
|
} catch (e) {
|
|
logger.error('Error loading configuration file: $e');
|
|
throw Exception('Failed to load config file: $e');
|
|
}
|
|
}
|
|
|
|
void setEnabled(String modId, bool enabled) {
|
|
if (mods.containsKey(modId)) {
|
|
mods[modId]!.enabled = enabled;
|
|
if (enabled) {
|
|
activeMods[modId] = true;
|
|
} else {
|
|
activeMods.remove(modId);
|
|
}
|
|
}
|
|
}
|
|
|
|
void enableAll() {
|
|
for (final mod in mods.values) {
|
|
setEnabled(mod.id, true);
|
|
}
|
|
}
|
|
|
|
void disableAll() {
|
|
for (final mod in mods.values) {
|
|
setEnabled(mod.id, false);
|
|
}
|
|
}
|
|
|
|
void enableMods(List<String> modIds) {
|
|
for (final modId in modIds) {
|
|
setEnabled(modId, true);
|
|
}
|
|
}
|
|
|
|
void disableMods(List<String> modIds) {
|
|
for (final modId in modIds) {
|
|
setEnabled(modId, false);
|
|
}
|
|
}
|
|
|
|
List<List<String>> checkIncompatibilities(List<String> activeModIds) {
|
|
List<List<String>> conflicts = [];
|
|
|
|
// Only check each pair once
|
|
for (final modId in activeModIds) {
|
|
final mod = mods[modId]!;
|
|
|
|
for (final incompId in mod.incompatibilities) {
|
|
// Only process if other mod is active and we haven't checked this pair yet
|
|
if (activeMods.containsKey(incompId)) {
|
|
conflicts.add([modId, incompId]);
|
|
}
|
|
}
|
|
}
|
|
return conflicts;
|
|
}
|
|
|
|
/// Generate a load order for active mods
|
|
LoadOrder generateLoadOrder([LoadOrder? loadOrder]) {
|
|
loadOrder ??= LoadOrder();
|
|
// Check for incompatibilities first
|
|
final conflicts = checkIncompatibilities(activeMods.keys.toList());
|
|
if (conflicts.isNotEmpty) {
|
|
for (final conflict in conflicts) {
|
|
loadOrder.errors.add(
|
|
"Incompatible mods selected: ${conflict[0]} and ${conflict[1]}",
|
|
);
|
|
}
|
|
}
|
|
|
|
// Check for missing dependencies
|
|
for (final modId in activeMods.keys) {
|
|
final mod = mods[modId]!;
|
|
for (final depId in mod.dependencies) {
|
|
if (!mods.containsKey(depId)) {
|
|
loadOrder.errors.add(
|
|
"Missing dependency: ${mod.name} requires mod with ID $depId",
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Reset all marks for topological sort
|
|
for (final mod in mods.values) {
|
|
mod.visited = false;
|
|
mod.mark = false;
|
|
mod.position = -1;
|
|
}
|
|
|
|
int position = 0;
|
|
|
|
// Topological sort
|
|
void visit(Mod mod, LoadOrder loadOrder) {
|
|
if (!mod.enabled) {
|
|
mod.visited = true;
|
|
return;
|
|
}
|
|
if (mod.mark) {
|
|
final cyclePath =
|
|
mods.values.where((m) => m.mark).map((m) => m.name).toList();
|
|
loadOrder.errors.add(
|
|
"Cyclic dependency detected: ${cyclePath.join(' -> ')}",
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (!mod.visited) {
|
|
mod.mark = true;
|
|
|
|
// Visit all dependencies
|
|
for (String depId in mod.dependencies) {
|
|
if (activeMods.containsKey(depId)) {
|
|
visit(mods[depId]!, loadOrder);
|
|
}
|
|
}
|
|
|
|
mod.mark = false;
|
|
mod.visited = true;
|
|
mod.position = position++;
|
|
loadOrder.loadOrder.add(mod.id);
|
|
}
|
|
}
|
|
|
|
// Visit all nodes
|
|
for (final mod in mods.values) {
|
|
if (!mod.visited) {
|
|
visit(mod, loadOrder);
|
|
}
|
|
}
|
|
|
|
// Optimize for soft constraints
|
|
_optimizeSoftConstraints(loadOrder: loadOrder);
|
|
for (final modId in loadOrder.loadOrder) {
|
|
final mod = mods[modId]!;
|
|
print(
|
|
'Mod ID: ${mod.id}, Name: ${mod.name}, Enabled: ${mod.enabled}, Size: ${mod.size}, Dependencies: ${mod.dependencies}, Load After: ${mod.loadAfter}, Load Before: ${mod.loadBefore}, Incompatibilities: ${mod.incompatibilities}',
|
|
);
|
|
}
|
|
return loadOrder;
|
|
}
|
|
|
|
/// Calculate how many soft constraints are satisfied
|
|
Map<String, int> _calculateSoftConstraintsScore(List<String> order) {
|
|
Map<String, int> positions = {};
|
|
for (int i = 0; i < order.length; i++) {
|
|
positions[order[i]] = i;
|
|
}
|
|
|
|
int satisfied = 0;
|
|
int total = 0;
|
|
|
|
for (String modId in order) {
|
|
Mod mod = mods[modId]!;
|
|
|
|
// Check "load before" preferences
|
|
for (String beforeId in mod.loadBefore) {
|
|
if (positions.containsKey(beforeId)) {
|
|
total++;
|
|
if (positions[modId]! < positions[beforeId]!) {
|
|
satisfied++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check "load after" preferences
|
|
for (String afterId in mod.loadAfter) {
|
|
if (positions.containsKey(afterId)) {
|
|
total++;
|
|
if (positions[modId]! > positions[afterId]!) {
|
|
satisfied++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return {'satisfied': satisfied, 'total': total};
|
|
}
|
|
|
|
/// Optimize for soft constraints using a greedy approach
|
|
LoadOrder _optimizeSoftConstraints({
|
|
int maxIterations = 5,
|
|
LoadOrder? loadOrder,
|
|
}) {
|
|
loadOrder ??= LoadOrder();
|
|
|
|
// First, ensure base game and expansions are at the beginning in the correct order
|
|
List<String> baseAndExpansions = [];
|
|
List<String> harmony = [];
|
|
List<String> otherMods = [];
|
|
|
|
// Separate mods into categories
|
|
for (final modId in loadOrder.loadOrder) {
|
|
final mod = mods[modId]!;
|
|
if (modId == 'brrainz.harmony') {
|
|
harmony.add(modId);
|
|
} else if (mod.isBaseGame) {
|
|
baseAndExpansions.add(modId);
|
|
} else if (mod.isExpansion) {
|
|
baseAndExpansions.add(modId);
|
|
} else {
|
|
otherMods.add(modId);
|
|
}
|
|
}
|
|
|
|
// Sort expansions to ensure correct order
|
|
baseAndExpansions.sort((a, b) {
|
|
final modA = mods[a]!;
|
|
final modB = mods[b]!;
|
|
|
|
// Base game always first
|
|
if (modA.isBaseGame) return -1;
|
|
if (modB.isBaseGame) return 1;
|
|
|
|
// Sort expansions alphabetically by ID (which should work for Ludeon expansions)
|
|
return a.compareTo(b);
|
|
});
|
|
|
|
// Combine the lists with harmony first, then base game and expansions, then other mods
|
|
loadOrder.loadOrder.clear();
|
|
loadOrder.loadOrder.addAll(harmony);
|
|
loadOrder.loadOrder.addAll(baseAndExpansions);
|
|
|
|
// Now apply the normal optimization for the remaining mods
|
|
List<String> remainingMods = otherMods;
|
|
|
|
Map<String, int> scoreInfo = _calculateSoftConstraintsScore(remainingMods);
|
|
int bestScore = scoreInfo['satisfied']!;
|
|
int total = scoreInfo['total']!;
|
|
|
|
if (total == 0 || bestScore == total) {
|
|
// All constraints satisfied or no constraints for remaining mods, sort by size where possible
|
|
_sortSizeWithinConstraints(loadOrder: loadOrder, modList: remainingMods);
|
|
loadOrder.loadOrder.addAll(remainingMods);
|
|
return loadOrder;
|
|
}
|
|
|
|
// Use a limited number of improvement passes for the remaining mods
|
|
for (int iteration = 0; iteration < maxIterations; iteration++) {
|
|
bool improved = false;
|
|
|
|
// Try moving each mod to improve score
|
|
for (int i = 0; i < remainingMods.length; i++) {
|
|
String modId = remainingMods[i];
|
|
Mod mod = mods[modId]!;
|
|
|
|
// Calculate current local score for this mod
|
|
Map<String, int> currentPositions = {};
|
|
for (int idx = 0; idx < remainingMods.length; idx++) {
|
|
currentPositions[remainingMods[idx]] = idx;
|
|
}
|
|
|
|
// Try moving this mod to different positions
|
|
for (int newPos = 0; newPos < remainingMods.length; newPos++) {
|
|
if (newPos == i) continue;
|
|
|
|
// Skip if move would break hard dependencies
|
|
bool skip = false;
|
|
if (newPos < i) {
|
|
// Moving earlier
|
|
// Check if any mod between newPos and i depends on this mod
|
|
for (int j = newPos; j < i; j++) {
|
|
String depModId = remainingMods[j];
|
|
if (mods[depModId]!.dependencies.contains(modId)) {
|
|
skip = true;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
// Moving later
|
|
// Check if this mod depends on any mod between i and newPos
|
|
for (int j = i + 1; j <= newPos; j++) {
|
|
String depModId = remainingMods[j];
|
|
if (mod.dependencies.contains(depModId)) {
|
|
skip = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (skip) continue;
|
|
|
|
// Create a new order with the mod moved
|
|
List<String> newOrder = List.from(remainingMods);
|
|
newOrder.removeAt(i);
|
|
newOrder.insert(newPos, modId);
|
|
|
|
// Calculate new score
|
|
Map<String, int> newScoreInfo = _calculateSoftConstraintsScore(
|
|
newOrder,
|
|
);
|
|
int newScore = newScoreInfo['satisfied']!;
|
|
|
|
if (newScore > bestScore) {
|
|
bestScore = newScore;
|
|
remainingMods.clear();
|
|
remainingMods.addAll(newOrder);
|
|
improved = true;
|
|
break; // Break inner loop, move to next mod
|
|
}
|
|
}
|
|
|
|
if (improved) break; // If improved, start a new iteration
|
|
}
|
|
|
|
if (!improved) break; // If no improvements in this pass, stop
|
|
}
|
|
|
|
// Sort by size where possible for the remaining mods
|
|
_sortSizeWithinConstraints(loadOrder: loadOrder, modList: remainingMods);
|
|
loadOrder.loadOrder.addAll(remainingMods);
|
|
|
|
return loadOrder;
|
|
}
|
|
|
|
/// Sort mods by size within compatible groups
|
|
LoadOrder _sortSizeWithinConstraints({
|
|
LoadOrder? loadOrder,
|
|
List<String>? modList,
|
|
}) {
|
|
loadOrder ??= LoadOrder();
|
|
List<String> modsToSort = modList ?? loadOrder.loadOrder;
|
|
|
|
// Find groups of mods that can be reordered without breaking constraints
|
|
List<List<String>> groups = [];
|
|
List<String> currentGroup = [];
|
|
|
|
for (int i = 0; i < modsToSort.length; i++) {
|
|
String modId = modsToSort[i];
|
|
Mod mod = mods[modId]!;
|
|
|
|
if (currentGroup.isEmpty) {
|
|
currentGroup.add(modId);
|
|
continue;
|
|
}
|
|
|
|
// Check if this mod can join the current group
|
|
bool canJoin = true;
|
|
for (String groupModId in currentGroup) {
|
|
Mod groupMod = mods[groupModId]!;
|
|
|
|
// Check hard dependencies
|
|
if (mod.dependencies.contains(groupModId) ||
|
|
groupMod.dependencies.contains(modId)) {
|
|
canJoin = false;
|
|
break;
|
|
}
|
|
|
|
// Check soft constraints
|
|
if (mod.loadAfter.contains(groupModId) ||
|
|
groupMod.loadBefore.contains(modId) ||
|
|
mod.loadBefore.contains(groupModId) ||
|
|
groupMod.loadAfter.contains(modId)) {
|
|
canJoin = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (canJoin) {
|
|
currentGroup.add(modId);
|
|
} else {
|
|
// Start a new group
|
|
if (currentGroup.isNotEmpty) {
|
|
groups.add(List.from(currentGroup));
|
|
currentGroup = [modId];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add the last group if not empty
|
|
if (currentGroup.isNotEmpty) {
|
|
groups.add(currentGroup);
|
|
}
|
|
|
|
// Sort each group by size
|
|
for (List<String> group in groups) {
|
|
if (group.length > 1) {
|
|
group.sort((a, b) => mods[b]!.size.compareTo(mods[a]!.size));
|
|
}
|
|
}
|
|
|
|
// Reconstruct the order
|
|
modsToSort.clear();
|
|
for (List<String> group in groups) {
|
|
modsToSort.addAll(group);
|
|
}
|
|
|
|
// If we were given the loadOrder directly, update it
|
|
if (modList == null) {
|
|
loadOrder.loadOrder.clear();
|
|
loadOrder.loadOrder.addAll(modsToSort);
|
|
}
|
|
|
|
return loadOrder;
|
|
}
|
|
|
|
LoadOrder loadDependencies(
|
|
String modId, [
|
|
LoadOrder? loadOrder,
|
|
List<String>? toEnable,
|
|
Map<String, bool>? seen,
|
|
List<String>? cyclePath,
|
|
]) {
|
|
final mod = mods[modId]!;
|
|
loadOrder ??= LoadOrder();
|
|
toEnable ??= <String>[];
|
|
seen ??= <String, bool>{};
|
|
cyclePath ??= <String>[];
|
|
|
|
// Add current mod to cycle path
|
|
cyclePath.add(modId);
|
|
|
|
for (final dep in mod.dependencies) {
|
|
if (!mods.containsKey(dep)) {
|
|
loadOrder.errors.add(
|
|
'Missing dependency: ${mod.name} requires mod with ID $dep',
|
|
);
|
|
continue;
|
|
}
|
|
final depMod = mods[dep]!;
|
|
if (seen[dep] == true) {
|
|
// Find the start of the cycle
|
|
int cycleStart = cyclePath.indexOf(dep);
|
|
if (cycleStart >= 0) {
|
|
// Extract the cycle part
|
|
List<String> cycleIds = [...cyclePath.sublist(cycleStart), modId];
|
|
loadOrder.errors.add(
|
|
'Cyclic dependency detected: ${cycleIds.join(' -> ')}',
|
|
);
|
|
} else {
|
|
loadOrder.errors.add('Cyclic dependency detected: $modId -> $dep');
|
|
}
|
|
continue;
|
|
}
|
|
seen[dep] = true;
|
|
toEnable.add(depMod.id);
|
|
loadDependencies(
|
|
depMod.id,
|
|
loadOrder,
|
|
toEnable,
|
|
seen,
|
|
List.from(cyclePath),
|
|
);
|
|
}
|
|
|
|
return loadOrder;
|
|
}
|
|
|
|
LoadOrder loadRequired([LoadOrder? loadOrder]) {
|
|
loadOrder ??= LoadOrder();
|
|
final toEnable = <String>[];
|
|
for (final modid in activeMods.keys) {
|
|
loadDependencies(modid, loadOrder, toEnable);
|
|
}
|
|
for (final modid in toEnable) {
|
|
setEnabled(modid, true);
|
|
}
|
|
return generateLoadOrder(loadOrder);
|
|
}
|
|
|
|
ModList copyWith({
|
|
String? configPath,
|
|
String? modsPath,
|
|
Map<String, Mod>? mods,
|
|
Map<String, bool>? activeMods,
|
|
}) {
|
|
final newModlist = ModList(
|
|
configPath: configPath ?? this.configPath,
|
|
modsPath: modsPath ?? this.modsPath,
|
|
);
|
|
newModlist.mods = Map.from(mods ?? this.mods);
|
|
newModlist.activeMods = Map.from(activeMods ?? this.activeMods);
|
|
return newModlist;
|
|
}
|
|
}
|
|
|
|
String _expansionNameFromId(String id) {
|
|
final parts = id.split('.');
|
|
if (parts.length < 3) return id;
|
|
|
|
final expansionPart = parts[2];
|
|
return expansionPart.substring(0, 1).toUpperCase() +
|
|
expansionPart.substring(1);
|
|
}
|