package micdoodle8.mods.galacticraft.api; import com.google.common.collect.Lists; import micdoodle8.mods.galacticraft.api.client.IGameScreen; import micdoodle8.mods.galacticraft.api.item.EnumExtendedInventorySlot; import micdoodle8.mods.galacticraft.api.recipe.INasaWorkbenchRecipe; import micdoodle8.mods.galacticraft.api.world.IGalacticraftWorldProvider; import micdoodle8.mods.galacticraft.api.world.ITeleportType; import micdoodle8.mods.galacticraft.api.world.SpaceStationType; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.util.ResourceLocation; import net.minecraft.world.WorldProvider; import net.minecraft.world.WorldProviderSurface; import net.minecraftforge.common.DimensionManager; import net.minecraftforge.fml.common.FMLLog; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class GalacticraftRegistry { private static Map<Class<? extends WorldProvider>, ITeleportType> teleportTypeMap = new HashMap<Class<? extends WorldProvider>, ITeleportType>(); private static List<SpaceStationType> spaceStations = new ArrayList<SpaceStationType>(); private static List<INasaWorkbenchRecipe> rocketBenchT1Recipes = new ArrayList<INasaWorkbenchRecipe>(); private static List<INasaWorkbenchRecipe> buggyBenchRecipes = new ArrayList<INasaWorkbenchRecipe>(); private static List<INasaWorkbenchRecipe> rocketBenchT2Recipes = new ArrayList<INasaWorkbenchRecipe>(); private static List<INasaWorkbenchRecipe> cargoRocketRecipes = new ArrayList<INasaWorkbenchRecipe>(); private static List<INasaWorkbenchRecipe> rocketBenchT3Recipes = new ArrayList<INasaWorkbenchRecipe>(); private static List<INasaWorkbenchRecipe> astroMinerRecipes = new ArrayList<INasaWorkbenchRecipe>(); private static Map<Class<? extends WorldProvider>, ResourceLocation> rocketGuiMap = new HashMap<Class<? extends WorldProvider>, ResourceLocation>(); private static Map<Integer, List<ItemStack>> dungeonLootMap = new HashMap<Integer, List<ItemStack>>(); private static List<Integer> worldProviderIDs = new ArrayList<Integer>(); private static List<IGameScreen> gameScreens = new ArrayList<IGameScreen>(); private static int maxScreenTypes; private static Map<Integer, List<Object>> gearMap = new HashMap<>(); private static Map<Integer, List<EnumExtendedInventorySlot>> gearSlotMap = new HashMap<>(); /** * Register a new Teleport type for the world provider passed * * @param clazz the world provider class that you wish to customize * teleportation for * @param type an ITeleportType-implemented class that will be used for the * provided world type */ public static void registerTeleportType(Class<? extends WorldProvider> clazz, ITeleportType type) { if (!GalacticraftRegistry.teleportTypeMap.containsKey(clazz)) { GalacticraftRegistry.teleportTypeMap.put(clazz, type); } } /** * Link a world provider to a gui texture. This texture will be shown on the * left-side of the screen while the player is in the rocket. * * @param clazz The World Provider class * @param rocketGui Resource Location for the gui texture */ public static void registerRocketGui(Class<? extends WorldProvider> clazz, ResourceLocation rocketGui) { if (!GalacticraftRegistry.rocketGuiMap.containsKey(clazz)) { GalacticraftRegistry.rocketGuiMap.put(clazz, rocketGui); } } /** * Add loot to the list of items that can possibly spawn in dungeon chests, * but it is guaranteed that one will always spawn * * @param tier Tier of dungeon chest to add loot to. For example Moon is 1 * and Mars is 2 * @param loot The itemstack to add to the possible list of items */ public static void addDungeonLoot(int tier, ItemStack loot) { List<ItemStack> dungeonStacks = null; if (GalacticraftRegistry.dungeonLootMap.containsKey(tier)) { dungeonStacks = GalacticraftRegistry.dungeonLootMap.get(tier); dungeonStacks.add(loot); } else { dungeonStacks = new ArrayList<ItemStack>(); dungeonStacks.add(loot); } GalacticraftRegistry.dungeonLootMap.put(tier, dungeonStacks); } public static void addT1RocketRecipe(INasaWorkbenchRecipe recipe) { GalacticraftRegistry.rocketBenchT1Recipes.add(recipe); } public static void addT2RocketRecipe(INasaWorkbenchRecipe recipe) { GalacticraftRegistry.rocketBenchT2Recipes.add(recipe); } public static void addT3RocketRecipe(INasaWorkbenchRecipe recipe) { GalacticraftRegistry.rocketBenchT3Recipes.add(recipe); } public static void addCargoRocketRecipe(INasaWorkbenchRecipe recipe) { GalacticraftRegistry.cargoRocketRecipes.add(recipe); } public static void addMoonBuggyRecipe(INasaWorkbenchRecipe recipe) { GalacticraftRegistry.buggyBenchRecipes.add(recipe); } public static void addAstroMinerRecipe(INasaWorkbenchRecipe recipe) { GalacticraftRegistry.astroMinerRecipes.add(recipe); } public static ITeleportType getTeleportTypeForDimension(Class<? extends WorldProvider> clazz) { if (!IGalacticraftWorldProvider.class.isAssignableFrom(clazz)) { clazz = WorldProviderSurface.class; } return GalacticraftRegistry.teleportTypeMap.get(clazz); } public static void registerSpaceStation(SpaceStationType type) { for (SpaceStationType type1 : GalacticraftRegistry.spaceStations) { if (type1.getWorldToOrbitID() == type.getWorldToOrbitID()) { throw new RuntimeException("Two space station types registered with the same home planet ID: " + type.getWorldToOrbitID()); } } GalacticraftRegistry.spaceStations.add(type); } public SpaceStationType getTypeFromPlanetID(int planetID) { return GalacticraftRegistry.spaceStations.get(planetID); } public static List<SpaceStationType> getSpaceStationData() { return GalacticraftRegistry.spaceStations; } public static List<INasaWorkbenchRecipe> getRocketT1Recipes() { return GalacticraftRegistry.rocketBenchT1Recipes; } public static List<INasaWorkbenchRecipe> getRocketT2Recipes() { return GalacticraftRegistry.rocketBenchT2Recipes; } public static List<INasaWorkbenchRecipe> getRocketT3Recipes() { return GalacticraftRegistry.rocketBenchT3Recipes; } public static List<INasaWorkbenchRecipe> getCargoRocketRecipes() { return GalacticraftRegistry.cargoRocketRecipes; } public static List<INasaWorkbenchRecipe> getBuggyBenchRecipes() { return GalacticraftRegistry.buggyBenchRecipes; } public static List<INasaWorkbenchRecipe> getAstroMinerRecipes() { return GalacticraftRegistry.astroMinerRecipes; } @SideOnly(Side.CLIENT) public static ResourceLocation getResouceLocationForDimension(Class<? extends WorldProvider> clazz) { if (!IGalacticraftWorldProvider.class.isAssignableFrom(clazz)) { clazz = WorldProviderSurface.class; } return GalacticraftRegistry.rocketGuiMap.get(clazz); } public static List<ItemStack> getDungeonLoot(int tier) { return GalacticraftRegistry.dungeonLootMap.get(tier); } /*** * Now returns a boolean to indicate whether registration of the WorldProvider type was successful. * (If it failed, you should probably set the CelestialBody as unreachable.) * * @param id * @param provider * @param keepLoaded * @return <boolean> success */ public static boolean registerProvider(int id, Class<? extends WorldProvider> provider, boolean keepLoaded, int defaultID) { boolean flag = DimensionManager.registerProviderType(id, provider, keepLoaded); if (flag) { GalacticraftRegistry.worldProviderIDs.add(id); return true; } else { GalacticraftRegistry.worldProviderIDs.add(defaultID); //Adding the 0 here preserves the order, important for network compatibility between GC versions FMLLog.severe("Could not register dimension " + id + " - does it clash with another mod? Change the ID in config."); return false; } } /** * You should now use GalacticraftRegistry.registerProvider(int id, Class<? extends WorldProvider> provider, boolean keepLoaded, int defaultID) * which returns a boolean indicating if the Provider was registered OK. * * @param id * @param provider * @param keepLoaded */ @Deprecated public static void registerProvider(int id, Class<? extends WorldProvider> provider, boolean keepLoaded) { GalacticraftRegistry.registerProvider(id, provider, keepLoaded, 0); } public static int getProviderID(int index) { return GalacticraftRegistry.worldProviderIDs.get(index); } /** * Register an IGameScreen so the Display Screen can access it * * @param screen The IGameScreen to be registered * @return The type ID assigned to this screen type */ public static int registerScreen(IGameScreen screen) { GalacticraftRegistry.gameScreens.add(screen); maxScreenTypes++; screen.setFrameSize(0.098F); return maxScreenTypes - 1; } public static int getMaxScreenTypes() { return maxScreenTypes; } public static IGameScreen getGameScreen(int type) { return GalacticraftRegistry.gameScreens.get(type); } /** * Adds a custom item for 'extended inventory' slots * * Gear IDs must be unique, and should be configurable for user convenience * * Please do not use values less than 100, to avoid conflicts with future Galacticraft core additions * * @param gearID Unique ID for this gear item, please use values greater than 100 * @param type Slot this item can be placed in * @param item Item to register, not metadata-sensitive */ public static void registerGear(int gearID, EnumExtendedInventorySlot type, Item item) { addGearObject(gearID, type, item); } /** * Adds a custom item for 'extended inventory' slots * * Gear IDs must be unique, and should be configurable for user convenience * * Please do not use values less than 100, to avoid conflicts with future Galacticraft core additions * * @param gearID Unique ID for this gear item, please use values greater than 100 * @param type Slot this item can be placed in * @param itemStack ItemStack to register, metadata-sensitive */ public static void registerGear(int gearID, EnumExtendedInventorySlot type, ItemStack itemStack) { addGearObject(gearID, type, itemStack); } private static void addGearObject(int gearID, EnumExtendedInventorySlot type, Object obj) { if (GalacticraftRegistry.gearMap.containsKey(gearID)) { if (!GalacticraftRegistry.gearMap.get(gearID).contains(obj)) { GalacticraftRegistry.gearMap.get(gearID).add(obj); } } else { List<Object> gear = Lists.newArrayList(); gear.add(obj); GalacticraftRegistry.gearMap.put(gearID, gear); } if (GalacticraftRegistry.gearSlotMap.containsKey(gearID)) { if (!GalacticraftRegistry.gearSlotMap.get(gearID).contains(type)) { GalacticraftRegistry.gearSlotMap.get(gearID).add(type); } } else { List<EnumExtendedInventorySlot> gearType = Lists.newArrayList(); gearType.add(type); GalacticraftRegistry.gearSlotMap.put(gearID, gearType); } } public static int findMatchingGearID(ItemStack stack, EnumExtendedInventorySlot slotType) { for (Map.Entry<Integer, List<Object>> entry : GalacticraftRegistry.gearMap.entrySet()) { List<EnumExtendedInventorySlot> slotType1 = getSlotType(entry.getKey()); List<Object> objectList = entry.getValue(); if (!slotType1.contains(slotType)) { continue; } for (Object o : objectList) { if (o instanceof Item) { if (stack.getItem() == o) { return entry.getKey(); } } else if (o instanceof ItemStack) { if (stack.getItem() == ((ItemStack) o).getItem() && stack.getItemDamage() == ((ItemStack) o).getItemDamage()) { return entry.getKey(); } } } } return -1; } public static List<EnumExtendedInventorySlot> getSlotType(int gearID) { return GalacticraftRegistry.gearSlotMap.get(gearID); } }