Improve missing mod dependency error screen (#4762)

This commit is contained in:
mezz authored and GitHub committed 2018-04-14 18:17:06 -07:00
1 parent fab45a32a8
commit a794f1daff
9 files changed
+214 -56

No files matched your search

@@ -231,8 +231,8 @@ public class Loader
private void sortModList()
{
FMLLog.log.trace("Verifying mod requirements are satisfied");
List<WrongMinecraftVersionException> wrongMinecraftExceptions = new ArrayList<WrongMinecraftVersionException>();
List<MissingModsException> missingModsExceptions = new ArrayList<MissingModsException>();
List<WrongMinecraftVersionException> wrongMinecraftExceptions = new ArrayList<>();
List<MissingModsException> missingModsExceptions = new ArrayList<>();
try
{
BiMap<String, ArtifactVersion> modVersions = HashBiMap.create();
@@ -253,39 +253,42 @@ public class Loader
continue;
}
Map<String,ArtifactVersion> names = Maps.uniqueIndex(mod.getRequirements(), ArtifactVersion::getLabel);
Set<ArtifactVersion> versionMissingMods = Sets.newHashSet();
Set<String> missingMods = Sets.difference(names.keySet(), modVersions.keySet());
if (!missingMods.isEmpty())
{
MissingModsException missingModsException = new MissingModsException(mod.getModId(), mod.getName());
FMLLog.log.fatal("The mod {} ({}) requires mods {} to be available", mod.getModId(), mod.getName(), missingMods);
for (String modid : missingMods)
{
versionMissingMods.add(names.get(modid));
ArtifactVersion acceptedVersion = names.get(modid);
ArtifactVersion currentVersion = modVersions.get(modid);
boolean required = mod.getRequirements().contains(acceptedVersion);
missingModsException.addMissingMod(acceptedVersion, currentVersion, required);
}
MissingModsException ret = new MissingModsException(versionMissingMods, mod.getModId(), mod.getName());
FMLLog.log.fatal(ret.getMessage());
missingModsExceptions.add(ret);
FMLLog.log.fatal(missingModsException.getMessage());
missingModsExceptions.add(missingModsException);
continue;
}
reqList.putAll(mod.getModId(), names.keySet());
ImmutableList<ArtifactVersion> allDeps = ImmutableList.<ArtifactVersion>builder().addAll(mod.getDependants()).addAll(mod.getDependencies()).build();
for (ArtifactVersion v : allDeps)
MissingModsException missingModsException = new MissingModsException(mod.getModId(), mod.getName());
for (ArtifactVersion acceptedVersion : allDeps)
{
if (modVersions.containsKey(v.getLabel()))
if (modVersions.containsKey(acceptedVersion.getLabel()))
{
if (!v.containsVersion(modVersions.get(v.getLabel())))
ArtifactVersion currentVersion = modVersions.get(acceptedVersion.getLabel());
if (!acceptedVersion.containsVersion(currentVersion))
{
versionMissingMods.add(v);
boolean required = mod.getRequirements().contains(acceptedVersion);
missingModsException.addMissingMod(acceptedVersion, currentVersion, required);
}
}
}
if (!versionMissingMods.isEmpty())
if (!missingModsException.getMissingModInfos().isEmpty())
{
FMLLog.log.fatal("The mod {} ({}) requires mod versions {} to be available", mod.getModId(), mod.getName(), versionMissingMods);
MissingModsException ret = new MissingModsException(versionMissingMods, mod.getModId(), mod.getName());
FMLLog.log.fatal(ret.toString());
missingModsExceptions.add(ret);
FMLLog.log.fatal(missingModsException.toString());
missingModsExceptions.add(missingModsException);
}
}
@@ -306,7 +309,7 @@ public class Loader
throw new MultipleModsErrored(wrongMinecraftExceptions, missingModsExceptions);
}
reverseDependencies = Multimaps.invertFrom(reqList, ArrayListMultimap.<String,String>create());
reverseDependencies = Multimaps.invertFrom(reqList, ArrayListMultimap.create());
ModSorter sorter = new ModSorter(getActiveModList(), namedMods);
try
@@ -19,36 +19,117 @@
package net.minecraftforge.fml.common;
import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import com.google.common.base.Preconditions;
import net.minecraftforge.fml.common.versioning.ArtifactVersion;
public class MissingModsException extends EnhancedRuntimeException
{
private static final long serialVersionUID = 1L;
private final String id;
private final String name;
/** @deprecated use {@link #getMissingModInfos()} */
@Deprecated // TODO remove in 1.13
public final Set<ArtifactVersion> missingMods;
private final List<MissingModInfo> missingModsInfos;
private final String modName;
public MissingModsException(String id, String name)
{
this(new HashSet<>(), id, name);
}
/**
* @deprecated use {@link #MissingModsException(String, String)}
*/
@Deprecated // TODO remove in 1.13
public MissingModsException(Set<ArtifactVersion> missingMods, String id, String name)
{
super(String.format("Mod %s (%s) requires %s", id, name, missingMods));
this.id = id;
this.name = name;
this.missingMods = missingMods;
this.missingModsInfos = new ArrayList<>();
for (ArtifactVersion artifactVersion : missingMods)
{
missingModsInfos.add(new MissingModInfo(artifactVersion, null, true));
}
this.modName = name;
}
@Override
public String getMessage()
{
Set<ArtifactVersion> missingMods = missingModsInfos.stream().map(MissingModInfo::getAcceptedVersion).collect(Collectors.toSet());
return String.format("Mod %s (%s) requires %s", id, name, missingMods);
}
public void addMissingMod(ArtifactVersion acceptedVersion, @Nullable ArtifactVersion currentVersion, boolean required)
{
MissingModInfo missingModInfo = new MissingModInfo(acceptedVersion, currentVersion, required);
this.missingModsInfos.add(missingModInfo);
this.missingMods.add(acceptedVersion);
}
public String getModName()
{
return modName;
}
public List<MissingModInfo> getMissingModInfos()
{
return Collections.unmodifiableList(this.missingModsInfos);
}
@Override
protected void printStackTrace(WrappedPrintStream stream)
{
stream.println("Missing Mods:");
for (ArtifactVersion v : missingMods)
for (MissingModInfo info : this.missingModsInfos)
{
stream.println(String.format("\t%s : %s", v.getLabel(), v.getRangeString()));
ArtifactVersion acceptedVersion = info.getAcceptedVersion();
ArtifactVersion currentVersion = info.getCurrentVersion();
String currentString = currentVersion != null ? currentVersion.getVersionString() : "missing";
stream.println(String.format("\t%s : need %s: have %s", acceptedVersion.getVersionString(), acceptedVersion.getRangeString(), currentString));
}
stream.println("");
}
public static class MissingModInfo
{
private final ArtifactVersion acceptedVersion;
@Nullable
private final ArtifactVersion currentVersion;
private final boolean required;
private MissingModInfo(ArtifactVersion acceptedVersion, @Nullable ArtifactVersion currentVersion, boolean required)
{
Preconditions.checkNotNull(acceptedVersion, "acceptedVersion");
this.acceptedVersion = acceptedVersion;
this.currentVersion = currentVersion;
this.required = required;
}
@Nullable
public ArtifactVersion getCurrentVersion()
{
return currentVersion;
}
public ArtifactVersion getAcceptedVersion()
{
return acceptedVersion;
}
public boolean isRequired()
{
return required;
}
}
}
@@ -21,13 +21,26 @@ package net.minecraftforge.fml.common;
import java.util.List;
public class MultipleModsErrored extends RuntimeException
public class MultipleModsErrored extends EnhancedRuntimeException
{
public final List<WrongMinecraftVersionException> wrongMinecraftExceptions;
public final List<MissingModsException>missingModsExceptions;
public final List<MissingModsException> missingModsExceptions;
public MultipleModsErrored(List<WrongMinecraftVersionException> wrongMinecraftExceptions, List<MissingModsException> missingModsExceptions)
{
this.wrongMinecraftExceptions = wrongMinecraftExceptions;
this.missingModsExceptions = missingModsExceptions;
}
@Override
protected void printStackTrace(WrappedPrintStream stream)
{
for (WrongMinecraftVersionException wrongMinecraftVersionException : this.wrongMinecraftExceptions)
{
wrongMinecraftVersionException.printStackTrace(stream);
}
for (MissingModsException missingModsException : this.missingModsExceptions)
{
missingModsException.printStackTrace(stream);
}
}
}
@@ -102,7 +102,11 @@ public class DefaultArtifactVersion implements ArtifactVersion
@Override
public String toString()
{
return label == null ? comparableVersion.toString() : label + ( unbounded ? "" : "@" + range);
if (label == null)
{
return getVersionString();
}
return label + (unbounded ? "" : "@" + range);
}
public VersionRange getRange()
@@ -478,7 +478,7 @@ public class VersionRange
{
if ( recommendedVersion != null )
{
return recommendedVersion.toString();
return recommendedVersion.getVersionString();
}
else
{