[1.12] how do you check if a mod is loaded?

[TheGoldenProof]

I know how to check if a mod is loaded, Loader.isModLoaded(), but if I want to run code with classes from the mod, I can't if the mod isn't there. 

 

Here's what I have right now that checks if the mod is loaded:

Spoiler

@EventHandler
public static void PostInit(FMLPostInitializationEvent event) {
	simpleRPGLoaded = Loader.isModLoaded("simplerpg");
	info(simpleRPGLoaded ?
			"SimpleRPG's player level will be used as Object Control Authority. This can be disabled in config.":
			"SimpleRPG is not loaded. Minecraft's player level will be used instead.");
}

 

and here's where I use it:

Spoiler

EntityPlayerMP p = (EntityPlayerMP)(entity);
int level;
if (ObjectPriorities.simpleRPGLoaded && ConfigFile.general.useSimpleRPG) {
	try {
		IRpgPlayer rpg = (IRpgPlayer) p.getCapability(RpgPlayerProvider.RPG_PLAYER_CAP, (EnumFacing) null);
		level = rpg.getLevel();
	} catch (Error e) {}
} else {
	level = p.experienceLevel;
}

 

But it wont work because the "IRpgPlayer" and "RpgPlayerProvider" classes don't exist when the mod isn't loaded, so it causes a compiler error ("Unresolved Compilation Problems"), so technically the try-catch doesnt do anything because the problem is before it figures that out.

 

I know that this is possible because so many other mods have cross-mod compatibility.

[diesieben07]

When compiling, the other mod must be present on the classpath.

To ensure your code can work at runtime without the other mod present, do something similar to @SidedProxy, like this:

 

interface OtherModInterop {

  // interface for interop with other mod here
  // note that the method signatures cannot use classes from the other mod

}

class OtherModInteropImpl implements OtherModInterop {

  // implementation for when other mod is present, can use classes from other mod

}

class OtherModDummyInterop implements OtherModInterop {

  // implementation for when other mod is not present

}

// in pre-init, etc.:
OtherModInterop interop;
if (Loader.isModLoaded("...")) {
  // use reflection to avoid loading the class if other mod is not present
  interop = Class.forName("...OtherModInteropImpl").asSubclass(OtherModInterop.class).newInstance();
} else {
  interop = new OtherModDummyInterop();
}

 

Now you can interface with the other mod from anywhere, since the question of "is it present or not" is abstracted away into two implementation classes.

Edited December 2, 2018 by diesieben07