001    /*
002     * The FML Forge Mod Loader suite. Copyright (C) 2012 cpw
003     *
004     * 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
005     * Software Foundation; either version 2.1 of the License, or any later version.
006     *
007     * 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
008     * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
009     *
010     * 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
011     * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
012     */
013    package net.minecraft.src;
014    
015    import static cpw.mods.fml.common.Side.CLIENT;
016    
017    import java.util.Map;
018    import java.util.Random;
019    
020    import net.minecraft.client.Minecraft;
021    import net.minecraft.server.MinecraftServer;
022    import cpw.mods.fml.client.FMLClientHandler;
023    import cpw.mods.fml.common.FMLLog;
024    import cpw.mods.fml.common.TickType;
025    import cpw.mods.fml.common.asm.SideOnly;
026    
027    public abstract class BaseMod implements cpw.mods.fml.common.modloader.BaseModProxy
028    {
029        // CALLBACK MECHANISMS
030    
031        public final boolean doTickInGame(TickType tick, boolean tickEnd, Object... data)
032        {
033            Minecraft mc = FMLClientHandler.instance().getClient();
034            boolean hasWorld = mc.theWorld != null;
035            // World and render ticks
036            if (tickEnd && ( tick==TickType.RENDER || tick==TickType.CLIENT ) && hasWorld) {
037                return onTickInGame((Float) data[0], mc);
038            }
039            return true;
040        }
041    
042        public final boolean doTickInGUI(TickType tick, boolean tickEnd, Object... data)
043        {
044            Minecraft mc = FMLClientHandler.instance().getClient();
045    
046            boolean hasWorld = mc.theWorld != null;
047    
048            if (tickEnd && ( tick==TickType.RENDER || ( tick==TickType.CLIENT && hasWorld))) {
049                return onTickInGUI((Float) data[0], mc, mc.currentScreen);
050            }
051            return true;
052        }
053    
054       /*
055        public final void onRenderHarvest(Map renderers)
056        {
057            addRenderer((Map<Class<? extends Entity>,Render>)renderers);
058        }
059    
060        public final void onRegisterAnimations()
061        {
062            registerAnimation(FMLClientHandler.instance().getClient());
063        }
064    
065        @Override
066        public final void onCrafting(Object... craftingParameters)
067        {
068            takenFromCrafting((EntityPlayer)craftingParameters[0], (ItemStack)craftingParameters[1], (IInventory)craftingParameters[2]);
069        }
070    
071        @Override
072        public final void onSmelting(Object... smeltingParameters)
073        {
074            takenFromFurnace((EntityPlayer)smeltingParameters[0], (ItemStack)smeltingParameters[1]);
075        }
076    
077        @Override
078        public final boolean dispense(double x, double y, double z, int xVelocity, int zVelocity, Object... data)
079        {
080            return dispenseEntity((World)data[0], x, y, z, xVelocity, zVelocity, (ItemStack)data[1]);
081        }
082    
083        @Override
084        public final boolean onChat(Object... data)
085        {
086            receiveChatPacket(((Packet3Chat)data[0]).message);
087            return true;
088        }
089    
090    
091        @Override
092        public final void onServerLogin(Object handler) {
093            serverConnect((NetClientHandler) handler);
094        }
095    
096        public final void onServerLogout() {
097            serverDisconnect();
098        }
099    
100        @Override
101        public final void onPlayerLogin(Object player)
102        {
103            onClientLogin((EntityPlayer) player);
104        }
105    
106        @Override
107        public final void onPlayerLogout(Object player)
108        {
109            onClientLogout((EntityPlayer)player);
110        }
111    
112        @Override
113        public final void onPlayerChangedDimension(Object player)
114        {
115            onClientDimensionChanged((EntityPlayer)player);
116        }
117    
118        @Override
119        public final void onPacket250Packet(Object... data)
120        {
121            receiveCustomPacket((Packet250CustomPayload)data[0]);
122        }
123    
124        @Override
125        public final void notifyPickup(Object... pickupData)
126        {
127            EntityItem item = (EntityItem) pickupData[0];
128            EntityPlayer player = (EntityPlayer) pickupData[1];
129            onItemPickup(player, item.item);
130        }
131    
132        @Override
133        public final void generate(Random random, int chunkX, int chunkZ, Object... additionalData)
134        {
135            World w = (World) additionalData[0];
136            IChunkProvider cp = (IChunkProvider) additionalData[1];
137    
138            if (cp instanceof ChunkProviderGenerate)
139            {
140                generateSurface(w, random, chunkX << 4, chunkZ << 4);
141            }
142            else if (cp instanceof ChunkProviderHell)
143            {
144                generateNether(w, random, chunkX << 4, chunkZ << 4);
145            }
146        }
147    
148        @Override
149        public final boolean handleCommand(String command, Object... data)
150        {
151            return false;
152        }
153    
154        */
155        // BASEMOD API
156        /**
157         * Override if you wish to provide a fuel item for the furnace and return the fuel value of the item
158         *
159         * @param id
160         * @param metadata
161         */
162        public int addFuel(int id, int metadata)
163        {
164            return 0;
165        }
166    
167        @SideOnly(CLIENT)
168        public void addRenderer(Map<Class<? extends Entity>, Render> renderers)
169        {
170        }
171    
172        /**
173         * Override if you wish to perform some action other than just dispensing the item from the dispenser
174         *
175         * @param world
176         * @param x
177         * @param y
178         * @param z
179         * @param xVel
180         * @param zVel
181         * @param item
182         */
183        @Override
184        public int dispenseEntity(World world, ItemStack item, Random rnd, int x, int y, int z, int xVel, int zVel, double entX, double entY, double entZ)
185        {
186            return -1;
187        }
188    
189        /**
190         * Override if you wish to generate Nether (Hell biome) blocks
191         *
192         * @param world
193         * @param random
194         * @param chunkX
195         * @param chunkZ
196         */
197        public void generateNether(World world, Random random, int chunkX, int chunkZ)
198        {
199        }
200    
201        /**
202         * Override if you wish to generate Overworld (not hell or the end) blocks
203         *
204         * @param world
205         * @param random
206         * @param chunkX
207         * @param chunkZ
208         */
209        public void generateSurface(World world, Random random, int chunkX, int chunkZ)
210        {
211        }
212    
213        /**
214         * Callback to return a gui screen to display
215         * @param player
216         * @param containerID
217         * @param x
218         * @param y
219         * @param z
220         */
221        @SideOnly(CLIENT)
222        public GuiContainer getContainerGUI(EntityClientPlayerMP player, int containerID, int x, int y, int z)
223        {
224            return null;
225        }
226    
227        /**
228         * Return the name of your mod. Defaults to the class name
229         */
230        public String getName()
231        {
232            return getClass().getSimpleName();
233        }
234    
235        /**
236         * Get your mod priorities
237         */
238        public String getPriorities()
239        {
240            return "";
241        }
242    
243        /**
244         * Return the version of your mod
245         */
246        public abstract String getVersion();
247    
248        @SideOnly(CLIENT)
249        public void keyboardEvent(KeyBinding event)
250        {
251    
252        }
253    
254        /**
255         * Load your mod
256         */
257        public abstract void load();
258    
259        /**
260         * Finish loading your mod
261         */
262        public void modsLoaded()
263        {
264        }
265    
266        /**
267         * Handle item pickup
268         *
269         * @param player
270         * @param item
271         */
272        public void onItemPickup(EntityPlayer player, ItemStack item)
273        {
274        }
275    
276        /**
277         * Ticked every game tick if you have subscribed to tick events through {@link ModLoader#setInGameHook(BaseMod, boolean, boolean)}
278         *
279         * @param time the rendering subtick time (0.0-1.0)
280         * @param minecraftInstance the client
281         * @return true to continue receiving ticks
282         */
283        @SideOnly(CLIENT)
284        public boolean onTickInGame(float time, Minecraft minecraftInstance)
285        {
286            return false;
287        }
288    
289        public boolean onTickInGame(MinecraftServer minecraftServer)
290        {
291            return false;
292        }
293    
294        @SideOnly(CLIENT)
295        public boolean onTickInGUI(float tick, Minecraft game, GuiScreen gui)
296        {
297            return false;
298        }
299    
300        /**
301         * Only implemented on the client side
302         * {@link #serverChat(NetServerHandler, String)}
303         *
304         * @param text
305         */
306        @Override
307        public void clientChat(String text)
308        {
309        }
310    
311        /**
312         * Called when a client connects
313         * @param handler
314         */
315        @SideOnly(CLIENT)
316        public void clientConnect(NetClientHandler handler)
317        {
318    
319        }
320    
321        /**
322         * Called when the client disconnects
323         * @param handler
324         */
325        @SideOnly(CLIENT)
326        public void clientDisconnect(NetClientHandler handler)
327        {
328    
329        }
330        /**
331         * Called client side to receive a custom payload for this mod
332         *
333         * @param packet
334         */
335        @Override
336        public void receiveCustomPacket(Packet250CustomPayload packet)
337        {
338        }
339    
340        @SideOnly(CLIENT)
341        public void registerAnimation(Minecraft game)
342        {
343    
344        }
345    
346        @SideOnly(CLIENT)
347        public void renderInvBlock(RenderBlocks renderer, Block block, int metadata, int modelID)
348        {
349    
350        }
351    
352        @SideOnly(CLIENT)
353        public boolean renderWorldBlock(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, Block block, int modelID)
354        {
355            return false;
356    
357        }
358    
359        @Override
360        public void serverConnect(NetHandler handler) {
361    
362        }
363    
364        @Override
365        public void serverCustomPayload(NetServerHandler handler, Packet250CustomPayload packet)
366        {
367    
368        }
369    
370        @Override
371        public void serverDisconnect() {
372    
373        }
374        /**
375         * Called when someone crafts an item from a crafting table
376         *
377         * @param player
378         * @param item
379         * @param matrix
380         */
381        public void takenFromCrafting(EntityPlayer player, ItemStack item, IInventory matrix)
382        {
383        }
384    
385        /**
386         * Called when someone takes a smelted item from a furnace
387         *
388         * @param player
389         * @param item
390         */
391        public void takenFromFurnace(EntityPlayer player, ItemStack item)
392        {
393        }
394    
395        /**
396         * The identifier string for the mod- used in client<->server negotiation
397         */
398        @Override
399        public String toString()
400        {
401            return getName() + " " + getVersion();
402        }
403    
404        /**
405         * Called when a chat message is received. Return true to stop further processing
406         */
407        @Override
408        public void serverChat(NetServerHandler source, String message)
409        {
410        }
411        /**
412         * Called when a new client logs in.
413         *
414         * @param player
415         */
416        @Override
417        public void onClientLogin(EntityPlayer player)
418        {
419        }
420    
421        /**
422         * Called when a client logs out of the server.
423         */
424        @Override
425        public void onClientLogout(INetworkManager mgr)
426        {
427    
428        }
429    
430        /**
431         * Spawn the entity of the supplied type, if it is your mod's
432         */
433        @SideOnly(CLIENT)
434        public Entity spawnEntity(int entityId, World world, double scaledX, double scaledY, double scaledZ)
435        {
436            return null;
437        }
438    
439        public void clientCustomPayload(NetClientHandler handler, Packet250CustomPayload packet)
440        {
441    
442        }
443    
444    }