flutter-rimworld-modman/lib/modloader.dart

import 'dart:io';
import 'package:xml/xml.dart';

const root = r'C:/Users/Administrator/Seafile/Games-Rimworld';
const modsRoot = '$root/294100';
const configRoot = '$root/AppData/RimWorld by Ludeon Studios/Config';
const configPath = '$configRoot/ModsConfig.xml';

class Mod {
  final String name; // ModMetaData.name
  final String id; // ModMetaData.packageId
  final String path; // figure it out
  final List<String> versions; // ModMetaData.supportedVersions
  final String description; // ModMetaData.description
  final List<String>
  hardDependencies; // ModMetaData.modDependencies - this is a li with packageId, displayName, steamWorkshopUrl and downloadUrl
  final List<String> softDependencies; // ModMetaData.loadAfter
  final List<String> incompatabilities; // ModMetaData.incompatibleWith
  final bool
  enabled; // ConfigFile.mods.firstWhere((mod) => mod.id == id).enabled

  Mod({
    required this.name,
    required this.id,
    required this.path,
    required this.versions,
    required this.description,
    required this.hardDependencies,
    required this.softDependencies,
    required this.incompatabilities,
    required this.enabled,
  });

  static Mod fromDirectory(String path) {
    final directory = Directory(path);
    final aboutFile = File('$path/About/About.xml');
    final aboutXml = XmlDocument.parse(aboutFile.readAsStringSync());
    final metadata = aboutXml.findElements('ModMetaData').first;
    final name = metadata.findElements('name').first.innerText;
    final id = metadata.findElements('packageId').first.innerText.toLowerCase();
    final versions =
        metadata
            .findElements('supportedVersions')
            .first
            .findElements('li')
            .map((e) => e.innerText)
            .toList();
    final description = metadata.findElements('description').first.innerText;
    final hardDependencies =
        metadata
            .findElements('modDependenciesByVersion')
            .last
            .findElements('li')
            .map((e) => e.findElements('packageId').first.innerText.toLowerCase())
            .toList();
    final softDependencies =
        metadata
            .findElements('loadAfter')
            .first
            .findElements('li')
            .map((e) => e.innerText.toLowerCase())
            .toList();
    final incompatabilities =
        metadata
            .findElements('incompatibleWith')
            .first
            .findElements('li')
            .map((e) => e.innerText.toLowerCase())
            .toList();

    return Mod(
      name: name,
      id: id,
      path: path,
      versions: versions,
      description: description,
      hardDependencies: hardDependencies,
      softDependencies: softDependencies,
      incompatabilities: incompatabilities,
      enabled: false,
    );
  }
}

class ModList {
  final String path;
  List<Mod> mods = [];

  ModList({required this.path});

  void load() {
    final directory = Directory(path);
    print('Loading configuration from: $path');

    if (directory.existsSync()) {
      final List<FileSystemEntity> entities = directory.listSync();
      final List<String> modDirectories =
          entities.whereType<Directory>().map((dir) => dir.path).toList();

      print('Found ${modDirectories.length} mod directories:');
      for (final modDir in modDirectories) {
        try {
          final mod = Mod.fromDirectory(modDir);
          mods.add(mod);
          print(
            'Loaded mod: ${mod.name} (ID: ${mod.id}) from directory: $modDir. '
            'Description: ${mod.description}, '
            'Hard Dependencies: ${mod.hardDependencies.join(', ')}, '
            'Soft Dependencies: ${mod.softDependencies.join(', ')}, '
            'Incompatibilities: ${mod.incompatabilities.join(', ')}',
          );
          print('Current total mods loaded: ${mods.length}');
        } catch (e) {
          print('Error loading mod from directory: $modDir');
          print('Error: $e');
        }
      }
    } else {
      print('Mods root directory does not exist: $modsRoot');
    }
  }
}

class ConfigFile {
  final String path;
  List<Mod> mods;

  ConfigFile({required this.path, this.mods = const []});

  void load() {
    final file = File(path);
    print('Loading configuration from: $path');

    final xmlString = file.readAsStringSync();
    print('XML content read successfully.');

    final xmlDocument = XmlDocument.parse(xmlString);
    print('XML document parsed successfully.');

    final modConfigData = xmlDocument.findElements("ModsConfigData").first;
    print('Found ModsConfigData element.');

    final modsElement = modConfigData.findElements("activeMods").first;
    print('Found activeMods element.');

    final mods = modsElement.findElements("li");
    print('Found ${mods.length} active mods.');

    for (final mod in mods) {
      print('Mod found: ${mod.innerText}');
    }
  }
}