port mixin plugin to falsepatternlib

This commit is contained in:
FalsePattern committed 2022-04-17 21:11:33 +02:00
1 parent 1d0e0550fa
commit 31e4d39338
8 files changed
+84 -324

No files matched your search

@@ -2,5 +2,9 @@ package com.falsepattern.endlessids;
import cpw.mods.fml.common.Mod;
@Mod(modid = Tags.MODID, name = Tags.MODNAME, version = Tags.VERSION)
@Mod(modid = Tags.MODID,
version = Tags.VERSION,
name = Tags.MODNAME,
acceptedMinecraftVersions = "[1.7.10]",
dependencies = "required-after:falsepatternlib@[0.5.0,);")
public class EndlessIDs {}
@@ -1,62 +0,0 @@
package com.falsepattern.endlessids.mixin.plugin;
import cpw.mods.fml.common.Loader;
import cpw.mods.fml.common.ModClassLoader;
import net.minecraft.launchwrapper.LaunchClassLoader;
import sun.misc.URLClassPath;
import java.io.File;
import java.lang.reflect.Field;
import java.nio.file.Path;
/**
* Backport from spongemixins 1.3
*/
public final class MinecraftURLClassPath {
/**
* Utility to manipulate the minecraft URL ClassPath
*/
private static final Field modClassLoaderField;
private static final Field loaderinstanceField;
private static final Field mainClassLoaderField;
private static final Field ucpField;
private static final ModClassLoader modClassLoader;
private static final LaunchClassLoader mainClassLoader;
private static final URLClassPath ucp;
static {
try {
modClassLoaderField = Loader.class.getDeclaredField("modClassLoader");
modClassLoaderField.setAccessible(true);
loaderinstanceField = Loader.class.getDeclaredField("instance");
loaderinstanceField.setAccessible(true);
mainClassLoaderField = ModClassLoader.class.getDeclaredField("mainClassLoader");
mainClassLoaderField.setAccessible(true);
ucpField = LaunchClassLoader.class.getSuperclass().getDeclaredField("ucp");
ucpField.setAccessible(true);
Object loader = loaderinstanceField.get(null);
modClassLoader = (ModClassLoader)modClassLoaderField.get(loader);
mainClassLoader = (LaunchClassLoader)mainClassLoaderField.get(modClassLoader);
ucp = (URLClassPath)ucpField.get(mainClassLoader);
} catch (NoSuchFieldException | IllegalAccessException e) {
throw new RuntimeException(e.getMessage());
}
}
/**
* Adds a Jar to the Minecraft URL ClassPath
* - Needed when using mixins on classes outside of Minecraft or other coremods
*/
public static void addJar(File pathToJar) throws Exception {
ucp.addURL(pathToJar.toURI().toURL());
}
private MinecraftURLClassPath() {
}
}
@@ -1,127 +1,70 @@
package com.falsepattern.endlessids.mixin.plugin;
import com.falsepattern.endlessids.IEConfig;
import cpw.mods.fml.relauncher.FMLLaunchHandler;
import com.falsepattern.lib.mixin.IMixin;
import com.falsepattern.lib.mixin.ITargetedMod;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Supplier;
import java.util.function.Predicate;
public enum Mixin {
import static com.falsepattern.lib.mixin.IMixin.PredicateHelpers.*;
@RequiredArgsConstructor
public enum Mixin implements IMixin {
//region Minecraft
//region common
//region storage
AnvilChunkLoaderMixin(builder(Side.COMMON).mixin("vanilla.storage.AnvilChunkLoaderMixin")),
ExtendedBlockStorageMixin(builder(Side.COMMON).mixin("vanilla.storage.ExtendedBlockStorageMixin")),
ItemStackMixin(builder(Side.COMMON).mixin("vanilla.storage.ItemStackMixin")),
AnvilChunkLoaderMixin(Side.COMMON, always(), "vanilla.storage.AnvilChunkLoaderMixin"),
ExtendedBlockStorageMixin(Side.COMMON, always(), "vanilla.storage.ExtendedBlockStorageMixin"),
ItemStackMixin(Side.COMMON, always(), "vanilla.storage.ItemStackMixin"),
//endregion storage
//region networking
PacketBufferMixin(builder(Side.COMMON).mixin("vanilla.networking.PacketBufferMixin")),
PlayerControllerMPMixin(builder(Side.COMMON).mixin("vanilla.networking.PlayerControllerMPMixin")),
S21PacketChunkDataMixin(builder(Side.COMMON).mixin("vanilla.networking.S21PacketChunkDataMixin")),
S22PacketMultiBlockChangeMixin(builder(Side.COMMON).mixin("vanilla.networking.S22PacketMultiBlockChangeMixin")),
S24PacketBlockActionMixin(builder(Side.COMMON).mixin("vanilla.networking.S24PacketBlockActionMixin")),
S26PacketMapChunkBulkMixin(builder(Side.COMMON).mixin("vanilla.networking.S26PacketMapChunkBulkMixin")),
PacketBufferMixin(Side.COMMON, always(), "vanilla.networking.PacketBufferMixin"),
PlayerControllerMPMixin(Side.COMMON, always(), "vanilla.networking.PlayerControllerMPMixin"),
S21PacketChunkDataMixin(Side.COMMON, always(), "vanilla.networking.S21PacketChunkDataMixin"),
S22PacketMultiBlockChangeMixin(Side.COMMON, always(), "vanilla.networking.S22PacketMultiBlockChangeMixin"),
S24PacketBlockActionMixin(Side.COMMON, always(), "vanilla.networking.S24PacketBlockActionMixin"),
S26PacketMapChunkBulkMixin(Side.COMMON, always(), "vanilla.networking.S26PacketMapChunkBulkMixin"),
//endregion networking
//region misc
BlockFireMixin(builder(Side.COMMON).mixin("vanilla.misc.BlockFireMixin")),
DataWatcherMixin(builder(Side.COMMON).condition(() -> IEConfig.extendDataWatcher).mixin("vanilla.misc.DataWatcherMixin")),
ItemInWorldManagerMixin(builder(Side.COMMON).mixin("vanilla.misc.ItemInWorldManagerMixin")),
StatListMixin(builder(Side.COMMON).mixin("vanilla.misc.StatListMixin")),
WorldMixin(builder(Side.COMMON).mixin("vanilla.misc.WorldMixin")),
BlockFireMixin(Side.COMMON, always(), "vanilla.misc.BlockFireMixin"),
DataWatcherMixin(Side.COMMON, condition(() -> IEConfig.extendDataWatcher), "vanilla.misc.DataWatcherMixin"),
ItemInWorldManagerMixin(Side.COMMON, always(), "vanilla.misc.ItemInWorldManagerMixin"),
StatListMixin(Side.COMMON, always(), "vanilla.misc.StatListMixin"),
WorldMixin(Side.COMMON, always(), "vanilla.misc.WorldMixin"),
//endregion misc
//endregion common
//region client
ChunkMixin(builder(Side.CLIENT).mixin("vanilla.ChunkMixin")),
NetHandlerPlayClientMixin(builder(Side.CLIENT).mixin("vanilla.NetHandlerPlayClientMixin")),
RenderGlobalMixin(builder(Side.CLIENT).mixin("vanilla.RenderGlobalMixin")),
ChunkMixin(Side.CLIENT, always(), "vanilla.ChunkMixin"),
NetHandlerPlayClientMixin(Side.CLIENT, always(), "vanilla.NetHandlerPlayClientMixin"),
RenderGlobalMixin(Side.CLIENT, always(), "vanilla.RenderGlobalMixin"),
//endregion client
//endregion Minecraft
//region UBC->common
OreUBifierMixin(builder(Side.COMMON).target(TargetedMod.UBC).mixin("ubc.OreUBifierMixin")),
BiomeUndergroundDecoratorMixin(builder(Side.COMMON).target(TargetedMod.UBC).mixin("ubc.BiomeUndergroundDecoratorMixin")),
OreUBifierMixin(Side.COMMON, require(TargetedMod.UBC), "ubc.OreUBifierMixin"),
BiomeUndergroundDecoratorMixin(Side.COMMON, require(TargetedMod.UBC), "ubc.BiomeUndergroundDecoratorMixin"),
//endregion UBC->common
//region CoFHLib->common
CofhBlockHelperMixin(builder(Side.COMMON).target(TargetedMod.COFHLIB).mixin("cofhlib.BlockHelperMixin")),
CofhBlockHelperMixin(Side.COMMON, require(TargetedMod.COFHLIB), "cofhlib.BlockHelperMixin"),
//endregion CoFHLib->common
//region DragonAPI->common
BlockPropertiesMixin(builder(Side.COMMON).target(TargetedMod.DRAGONAPI).mixin("dragonapi.BlockPropertiesMixin")),
BlockPropertiesMixin(Side.COMMON, require(TargetedMod.DRAGONAPI), "dragonapi.BlockPropertiesMixin"),
//endregion DragonAPI->common
//region MFQM->common
MFQMMixin(builder(Side.COMMON).target(TargetedMod.MFQM).mixin("mfqm.MFQMMixin")),
MFQMDataWatcherMixin(builder(Side.COMMON).target(TargetedMod.MFQM).condition(() -> IEConfig.extendDataWatcher).mixin("mfqm.MFQMDataWatcherMixin")),
MFQMMixin(Side.COMMON, require(TargetedMod.MFQM), "mfqm.MFQMMixin"),
MFQMDataWatcherMixin(Side.COMMON, require(TargetedMod.MFQM).and(condition(() -> IEConfig.extendDataWatcher)), "mfqm.MFQMDataWatcherMixin"),
//endregion MFQM->common
//region WorldEdit->common
BaseBlockMixin(builder(Side.COMMON).target(TargetedMod.WORLDEDIT).mixin("worldedit.BaseBlockMixin")),
BaseBlockMixin(Side.COMMON, require(TargetedMod.WORLDEDIT), "worldedit.BaseBlockMixin"),
//endregion WorldEdit->common
;
public final String mixin;
public final Set<TargetedMod> targetedMods;
public final Set<TargetedMod> avoidedMods;
public final Set<Supplier<Boolean>> allowConditions;
@Getter
private final Side side;
Mixin(Builder builder) {
this.mixin = builder.mixin;
this.targetedMods = builder.targetedMods;
this.avoidedMods = builder.avoidedMods;
this.allowConditions = builder.allowConditions;
this.side = builder.side;
}
public boolean shouldLoad(List<TargetedMod> loadedMods) {
return (side == Side.COMMON
|| side == Side.SERVER && FMLLaunchHandler.side().isServer()
|| side == Side.CLIENT && FMLLaunchHandler.side().isClient())
&& loadedMods.containsAll(targetedMods)
&& avoidedMods.stream().noneMatch(loadedMods::contains)
&& allowConditions.stream().allMatch(Supplier::get);
}
@SuppressWarnings("SameParameterValue")
private static Builder builder(Side side) {
return new Builder(side);
}
private static class Builder {
public String mixin;
public Side side;
public final Set<TargetedMod> targetedMods = new HashSet<>();
public final Set<TargetedMod> avoidedMods = new HashSet<>();
public final Set<Supplier<Boolean>> allowConditions = new HashSet<>();
public Builder(Side side) {
this.side = side;
}
public Builder mixin(String mixinClass) {
mixin = side.name().toLowerCase() + "." + mixinClass;
return this;
}
public Builder target(TargetedMod mod) {
targetedMods.add(mod);
return this;
}
public Builder avoid(TargetedMod mod) {
avoidedMods.add(mod);
return this;
}
public Builder condition(Supplier<Boolean> cond) {
allowConditions.add(cond);
return this;
}
}
private enum Side {
COMMON,
CLIENT,
SERVER
}
@Getter
private final Predicate<List<ITargetedMod>> filter;
@Getter
private final String mixin;
}
@@ -1,138 +1,23 @@
package com.falsepattern.endlessids.mixin.plugin;
import com.falsepattern.endlessids.Tags;
import lombok.val;
import net.minecraft.launchwrapper.Launch;
import org.apache.logging.log4j.LogManager;
import com.falsepattern.lib.mixin.IMixin;
import com.falsepattern.lib.mixin.IMixinPlugin;
import com.falsepattern.lib.mixin.ITargetedMod;
import lombok.Getter;
import org.apache.logging.log4j.Logger;
import org.spongepowered.asm.lib.tree.ClassNode;
import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;
import org.spongepowered.asm.mixin.extensibility.IMixinInfo;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import static java.nio.file.Files.walk;
public class MixinPlugin implements IMixinConfigPlugin {
private static final Logger LOG = LogManager.getLogger(Tags.MODNAME + " Mixin Loader");
private static final Path MODS_DIRECTORY_PATH = new File(Launch.minecraftHome, "mods/").toPath();
public class MixinPlugin implements IMixinPlugin {
@Getter
private final Logger logger = IMixinPlugin.createLogger(Tags.MODNAME);
@Override
public void onLoad(String mixinPackage) {
public IMixin[] getMixinEnumValues() {
return Mixin.values();
}
@Override
public String getRefMapperConfig() {
return null;
}
@Override
public boolean shouldApplyMixin(String targetClassName, String mixinClassName) {
return true;
}
@Override
public void acceptTargets(Set<String> myTargets, Set<String> otherTargets) {
}
// This method return a List<String> of mixins. Every mixins in this list will be loaded.
@Override
public List<String> getMixins() {
val isDevelopmentEnvironment = (boolean) Launch.blackboard.get("fml.deobfuscatedEnvironment");
val loadedMods =
Arrays.stream(TargetedMod.values())
.filter(mod -> mod == TargetedMod.VANILLA
|| (mod.loadInDevelopment && isDevelopmentEnvironment)
|| loadJarOf(mod))
.collect(Collectors.toList());
for (TargetedMod mod : TargetedMod.values()) {
if(loadedMods.contains(mod)) {
LOG.info("Found " + mod.modName + "! Integrating now...");
}
else {
LOG.info("Could not find " + mod.modName + "! Skipping integration....");
}
}
val mixins = new ArrayList<String>();
for (val mixin : Mixin.values()) {
if (mixin.shouldLoad(loadedMods)) {
mixins.add(mixin.mixin);
LOG.info("Loading mixin: " + mixin.mixin);
}
}
return mixins;
}
private int grimoireDetected = -1;
private boolean loadJarOf(final TargetedMod mod) {
try {
val jar = findJarOf(mod);
if(jar == null) {
LOG.info("Jar not found for " + mod);
return false;
}
LOG.info("Attempting to add " + jar + " to the URL Class Path");
if (!jar.exists()) {
throw new FileNotFoundException(jar.toString());
}
if (grimoireDetected < 0) {
try {
Class.forName("io.github.crucible.grimoire.Grimoire", false, getClass().getClassLoader());
grimoireDetected = 1;
} catch (ClassNotFoundException ignored) {
grimoireDetected = 0;
}
}
if (grimoireDetected == 1) {
LOG.info("Not adding " + jar + " to the URL Class Path, because Grimoire breaks our utility class.");
} else {
MinecraftURLClassPath.addJar(jar);
}
return true;
}
catch (Exception e) {
e.printStackTrace();
return false;
}
}
public static File findJarOf(final TargetedMod mod) {
try {
return walk(MODS_DIRECTORY_PATH)
.filter(mod::isMatchingJar)
.map(Path::toFile)
.findFirst()
.orElse(null);
}
catch (IOException e) {
e.printStackTrace();
return null;
}
}
@Override
public void preApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) {
}
@Override
public void postApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) {
public ITargetedMod[] getTargetedModEnumValues() {
return TargetedMod.values();
}
}
@@ -1,47 +1,27 @@
package com.falsepattern.endlessids.mixin.plugin;
import com.google.common.io.Files;
import lombok.val;
import com.falsepattern.lib.mixin.ITargetedMod;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import java.nio.file.Path;
import java.util.function.Predicate;
public enum TargetedMod {
import static com.falsepattern.lib.mixin.ITargetedMod.PredicateHelpers.*;
VANILLA("Minecraft", "", "", true),
UBC("Underground Biomes Constructs", "undergroundbiomesconstructs-", "", false),
COFHLIB("CoFH Lib", "cofhlib-", "", false),
DRAGONAPI("DragonAPI", "dragonapi", "", false),
MFQM("More Fun Quicksand Mod", "morefunquicksandmod-", "", false),
WORLDEDIT("WorldEdit", "worldedit-", "", false),
@RequiredArgsConstructor
public enum TargetedMod implements ITargetedMod {
UBC("Underground Biomes Constructs", false, startsWith("undergroundbiomesconstructs-")),
COFHLIB("CoFH Lib", false, startsWith("cofhlib-")),
DRAGONAPI("DragonAPI", false, startsWith("dragonapi")),
MFQM("More Fun Quicksand Mod", false, startsWith("morefunquicksandmod-")),
WORLDEDIT("WorldEdit", false, startsWith("worldedit-")),
;
public final String modName;
public final String jarNamePrefixLowercase;
public final String jarNameContainsLowercase;
public final boolean loadInDevelopment;
TargetedMod(String modName, String jarNamePrefix, String jarNameContains, boolean loadInDevelopment) {
this.modName = modName;
this.jarNamePrefixLowercase = jarNamePrefix.toLowerCase();
this.jarNameContainsLowercase = jarNameContains.toLowerCase();
this.loadInDevelopment = loadInDevelopment;
}
@SuppressWarnings("UnstableApiUsage")
public boolean isMatchingJar(Path path) {
val pathString = path.toString();
val nameLowerCase = Files.getNameWithoutExtension(pathString).toLowerCase();
val fileExtension = Files.getFileExtension(pathString);
return "jar".equals(fileExtension) && nameLowerCase.startsWith(jarNamePrefixLowercase) && nameLowerCase.contains(jarNameContainsLowercase);
}
@Override
public String toString() {
return "TargetedMod{" +
"modName='" + modName + '\'' +
", jarNamePrefixLowercase='" + jarNamePrefixLowercase + '\'' +
'}';
}
@Getter
private final String modName;
@Getter
private final boolean loadInDevelopment;
@Getter
private final Predicate<String> condition;
}