001    /*
002     * The FML Forge Mod Loader suite.
003     * Copyright (C) 2012 cpw
004     *
005     * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or any later version.
007     *
008     * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
009     * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
010     *
011     * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
012     * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
013     */
014    
015    package cpw.mods.fml.common.modloader;
016    
017    import java.util.EnumSet;
018    import java.util.HashMap;
019    import java.util.Map;
020    import java.util.concurrent.Callable;
021    
022    import com.google.common.collect.ArrayListMultimap;
023    import com.google.common.collect.ListMultimap;
024    import com.google.common.collect.Maps;
025    
026    import net.minecraft.src.BaseMod;
027    import net.minecraft.src.Container;
028    import net.minecraft.src.Entity;
029    import net.minecraft.src.EntityDragon;
030    import net.minecraft.src.EntityPlayer;
031    import net.minecraft.src.IAnimals;
032    import net.minecraft.src.ICommand;
033    import net.minecraft.src.TradeEntry;
034    import cpw.mods.fml.common.FMLCommonHandler;
035    import cpw.mods.fml.common.ICraftingHandler;
036    import cpw.mods.fml.common.IDispenseHandler;
037    import cpw.mods.fml.common.IDispenserHandler;
038    import cpw.mods.fml.common.IFuelHandler;
039    import cpw.mods.fml.common.IPickupNotifier;
040    import cpw.mods.fml.common.IWorldGenerator;
041    import cpw.mods.fml.common.Loader;
042    import cpw.mods.fml.common.TickType;
043    import cpw.mods.fml.common.network.IChatListener;
044    import cpw.mods.fml.common.network.IConnectionHandler;
045    import cpw.mods.fml.common.network.IGuiHandler;
046    import cpw.mods.fml.common.network.IPacketHandler;
047    import cpw.mods.fml.common.network.NetworkRegistry;
048    import cpw.mods.fml.common.registry.EntityRegistry;
049    import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
050    import cpw.mods.fml.common.registry.VillagerRegistry.IVillageTradeHandler;
051    import cpw.mods.fml.common.registry.VillagerRegistry;
052    
053    /**
054     * @author cpw
055     *
056     */
057    @SuppressWarnings("deprecation")
058    public class ModLoaderHelper
059    {
060        public static IModLoaderSidedHelper sidedHelper;
061    
062        private static Map<Integer, ModLoaderGuiHelper> guiHelpers = Maps.newHashMap();
063    
064        public static void updateStandardTicks(BaseModProxy mod, boolean enable, boolean useClock)
065        {
066            ModLoaderModContainer mlmc = (ModLoaderModContainer) Loader.instance().activeModContainer();
067            BaseModTicker ticker = mlmc.getGameTickHandler();
068            EnumSet<TickType> ticks = ticker.ticks();
069            // If we're enabled we get render ticks
070            if (enable && !useClock) {
071                ticks.add(TickType.RENDER);
072            } else {
073                ticks.remove(TickType.RENDER);
074            }
075            // If we're enabled but we want clock ticks, or we're server side we get game ticks
076            if (enable && (useClock || FMLCommonHandler.instance().getSide().isServer())) {
077                ticks.add(TickType.CLIENT);
078                ticks.add(TickType.WORLDLOAD);
079            } else {
080                ticks.remove(TickType.CLIENT);
081                ticks.remove(TickType.WORLDLOAD);
082            }
083        }
084    
085        public static void updateGUITicks(BaseModProxy mod, boolean enable, boolean useClock)
086        {
087            ModLoaderModContainer mlmc = (ModLoaderModContainer) Loader.instance().activeModContainer();
088            EnumSet<TickType> ticks = mlmc.getGUITickHandler().ticks();
089            // If we're enabled and we don't want clock ticks we get render ticks
090            if (enable && !useClock) {
091                ticks.add(TickType.RENDER);
092            } else {
093                ticks.remove(TickType.RENDER);
094            }
095            // If we're enabled but we want clock ticks, or we're server side we get world ticks
096            if (enable && useClock) {
097                ticks.add(TickType.CLIENT);
098                ticks.add(TickType.WORLDLOAD);
099            } else {
100                ticks.remove(TickType.CLIENT);
101                ticks.remove(TickType.WORLDLOAD);
102            }
103        }
104    
105        public static IPacketHandler buildPacketHandlerFor(BaseModProxy mod)
106        {
107            return new ModLoaderPacketHandler(mod);
108        }
109    
110        public static IWorldGenerator buildWorldGenHelper(BaseModProxy mod)
111        {
112            return new ModLoaderWorldGenerator(mod);
113        }
114    
115        public static IFuelHandler buildFuelHelper(BaseModProxy mod)
116        {
117            return new ModLoaderFuelHelper(mod);
118        }
119    
120        public static ICraftingHandler buildCraftingHelper(BaseModProxy mod)
121        {
122            return new ModLoaderCraftingHelper(mod);
123        }
124    
125        public static void finishModLoading(ModLoaderModContainer mc)
126        {
127            if (sidedHelper != null)
128            {
129                sidedHelper.finishModLoading(mc);
130            }
131        }
132    
133        public static IConnectionHandler buildConnectionHelper(BaseModProxy mod)
134        {
135            return new ModLoaderConnectionHandler(mod);
136        }
137    
138        public static IPickupNotifier buildPickupHelper(BaseModProxy mod)
139        {
140            return new ModLoaderPickupNotifier(mod);
141        }
142    
143        public static void buildGuiHelper(BaseModProxy mod, int id)
144        {
145            ModLoaderGuiHelper handler = new ModLoaderGuiHelper(mod, id);
146            guiHelpers.put(id, handler);
147            NetworkRegistry.instance().registerGuiHandler(mod, handler);
148        }
149    
150        public static void openGui(int id, EntityPlayer player, Container container, int x, int y, int z)
151        {
152            ModLoaderGuiHelper helper = guiHelpers.get(id);
153            helper.injectContainer(container);
154            player.openGui(helper.getMod(), id, player.worldObj, x, y, z);
155        }
156    
157        public static Object getClientSideGui(BaseModProxy mod, EntityPlayer player, int ID, int x, int y, int z)
158        {
159            if (sidedHelper != null)
160            {
161                return sidedHelper.getClientGui(mod, player, ID, x, y, z);
162            }
163            return null;
164        }
165    
166        public static IDispenserHandler buildDispenseHelper(BaseModProxy mod)
167        {
168            return new ModLoaderDispenseHelper(mod);
169        }
170    
171    
172        public static void buildEntityTracker(BaseModProxy mod, Class<? extends Entity> entityClass, int entityTypeId, int updateRange, int updateInterval,
173                boolean sendVelocityInfo)
174        {
175            EntityRegistration er = EntityRegistry.registerModLoaderEntity(mod, entityClass, entityTypeId, updateRange, updateInterval, sendVelocityInfo);
176            er.setCustomSpawning(new ModLoaderEntitySpawnCallback(mod, er), EntityDragon.class.isAssignableFrom(entityClass) || IAnimals.class.isAssignableFrom(entityClass));
177        }
178    
179        private static ModLoaderVillageTradeHandler[] tradeHelpers = new ModLoaderVillageTradeHandler[6];
180    
181        public static void registerTrade(int profession, TradeEntry entry)
182        {
183            assert profession < tradeHelpers.length : "The profession is out of bounds";
184            if (tradeHelpers[profession] == null)
185            {
186                tradeHelpers[profession] = new ModLoaderVillageTradeHandler();
187                VillagerRegistry.instance().registerVillageTradeHandler(profession, tradeHelpers[profession]);
188            }
189    
190            tradeHelpers[profession].addTrade(entry);
191        }
192    
193        public static void addCommand(ICommand command)
194        {
195            ModLoaderModContainer mlmc = (ModLoaderModContainer) Loader.instance().activeModContainer();
196            if (mlmc!=null)
197            {
198                mlmc.addServerCommand(command);
199            }
200        }
201    
202        public static IChatListener buildChatListener(BaseModProxy mod)
203        {
204            return new ModLoaderChatListener(mod);
205        }
206    }