A bit of Ritual cleanup

Slowly getting rid of these BlockStack references. Slowly moving towards
a proper "API" in our internals.

src/main/java/WayofTime/bloodmagic/ritual/RitualRegistry.java

@@ -0,0 +1,124 @@
+package WayofTime.bloodmagic.ritual;
+
+import WayofTime.bloodmagic.util.BMLog;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Lists;
+
+import javax.annotation.Nullable;
+import java.util.*;
+
+public class RitualRegistry {
+    public static final Map<Ritual, Boolean> enabledRituals = new HashMap<>();
+    private static final BiMap<String, Ritual> registry = HashBiMap.create();
+    private static final List<String> lookupList = new ArrayList<>();
+    /**
+     * Ordered list for actions that depend on the order that the rituals were
+     * registered in
+     */
+    private static final ArrayList<String> orderedIdList = new ArrayList<>();
+
+    private static boolean locked;
+
+    /**
+     * The safe way to register a new Ritual.
+     *
+     * @param ritual - The ritual to register.
+     * @param id     - The ID for the ritual. Cannot be duplicated.
+     */
+    public static void registerRitual(Ritual ritual, String id, boolean enabled) {
+        if (locked) {
+            BMLog.DEFAULT.error("This registry has been locked. Please register your ritual earlier.");
+            BMLog.DEFAULT.error("If you reflect this, I will hunt you down. - TehNut");
+            return;
+        }
+
+        if (ritual != null) {
+            if (registry.containsKey(id))
+                BMLog.DEFAULT.error("Duplicate ritual id: {}", id);
+            else {
+                registry.put(id, ritual);
+                enabledRituals.put(ritual, enabled);
+                orderedIdList.add(id);
+            }
+        }
+    }
+
+    public static void registerRitual(Ritual ritual, boolean enabled) {
+        registerRitual(ritual, ritual.getName(), enabled);
+    }
+
+    public static void registerRitual(Ritual ritual, String id) {
+        registerRitual(ritual, id, true);
+    }
+
+    public static void registerRitual(Ritual ritual) {
+        registerRitual(ritual, ritual.getName());
+    }
+
+    @Nullable
+    public static Ritual getRitualForId(String id) {
+        Ritual ritual = registry.get(id);
+        return ritual != null ? ritual.getNewCopy() : null;
+    }
+
+    public static String getIdForRitual(Ritual ritual) {
+        return registry.inverse().get(ritual);
+    }
+
+    public static boolean isMapEmpty() {
+        return registry.isEmpty();
+    }
+
+    public static int getMapSize() {
+        return registry.size();
+    }
+
+    public static boolean ritualEnabled(Ritual ritual) {
+        try {
+            return enabledRituals.get(ritual);
+        } catch (NullPointerException e) {
+            BMLog.DEFAULT.error("Invalid Ritual was called");
+            return false;
+        }
+    }
+
+    public static boolean ritualEnabled(String id) {
+        return ritualEnabled(getRitualForId(id));
+    }
+
+    public static BiMap<String, Ritual> getRegistry() {
+        return HashBiMap.create(registry);
+    }
+
+    public static Map<Ritual, Boolean> getEnabledMap() {
+        return new HashMap<>(enabledRituals);
+    }
+
+    public static ArrayList<String> getIds() {
+        return new ArrayList<>(lookupList);
+    }
+
+    public static ArrayList<String> getOrderedIds() {
+        return orderedIdList;
+    }
+
+    public static ArrayList<Ritual> getRituals() {
+        return new ArrayList<>(registry.values());
+    }
+
+    public static void orderLookupList() {
+        locked = true; // Lock registry so no no rituals can be registered
+        lookupList.clear(); // Make sure it's empty
+        lookupList.addAll(registry.keySet());
+        lookupList.sort((o1, o2) -> {
+            Ritual ritual1 = registry.get(o1);
+            Ritual ritual2 = registry.get(o2);
+            List<RitualComponent> first = Lists.newArrayList();
+            ritual1.gatherComponents(first);
+            List<RitualComponent> second = Lists.newArrayList();
+            ritual2.gatherComponents(second);
+            return first.size() > second.size() ? -1 : 0; // Put earlier if bigger
+        });
+    }
+}