Minecraft Forums

package net.minecraft.src;

import cpw.mods.fml.common.network.NetworkMod;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.Init;
import cpw.mods.fml.common.Mod.PostInit;
import cpw.mods.fml.common.Mod.PreInit;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;

@Mod( modid = "ExampleMod", name="ExampleModsName", version="ExampleModVersion")

@Mod( modid = "UndeadPlus", name="Undead+", version="[1.4.7] v1.0.0")

@NetworkMod
(
clientSideRequired = true,
serverSideRequired = true,
channels = {"example_mod"},
packetHandler = ExampleModPacketHandler.class
)

package net.minecraft.src;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import net.minecraft.src.EntityClientPlayerMP;
import net.minecraft.src.EntityPlayerMP;
import net.minecraft.src.Packet250CustomPayload;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.Side;
import cpw.mods.fml.common.network.IPacketHandler;
import cpw.mods.fml.common.network.Player;
public class ExampleModPacketHandler implements IPacketHandler
{
@Override
public void onPacketData(INetworkManager manager, Packet250CustomPayload packet, Player player)
{
if (packet.channel.equals("GenericRandom"))
{
handleRandom(packet);
}
}
private void handleRandom(Packet250CustomPayload packet)
{
DataInputStream inputStream = new DataInputStream(new ByteArrayInputStream(packet.data));
int randomInt1;
int randomInt2;
try
{
randomInt1 = inputStream.readInt();
randomInt2 = inputStream.readInt();
} catch (IOException e) {
e.printStackTrace();
return;
}
System.out.println(randomInt1 + " " + randomInt2);
}
}

public class ModUndeadMainRegistry {

@PreInit
public void preInit(FMLPreInitializationEvent event)

@Init
public void init(FMLInitializationEvent event)

@PostInit
public void postInit(FMLPostInitializationEvent event)

package net.minecraft.src;
import cpw.mods.fml.common.network.NetworkMod;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.Init;
import cpw.mods.fml.common.Mod.PostInit;
import cpw.mods.fml.common.Mod.PreInit;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
@Mod( modid = "ExampleMod", name="ExampleModsName", version="ExampleModVersion")
@NetworkMod
(
clientSideRequired = true,
serverSideRequired = true,
channels = {"example_mod"},
packetHandler = ExampleModPacketHandler.class
)
public class ExampleMod
{
@PreInit
public void preInit(FMLPreInitializationEvent event)
{
}
@Init
public void init(FMLInitializationEvent event)
{
}
@PostInit
public void postInit(FMLPostInitializationEvent event)
{
}
}

package ghosrec35.mods.example.common;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.IMCCallback;
import cpw.mods.fml.common.Mod.Init;
import cpw.mods.fml.common.Mod.Instance;
import cpw.mods.fml.common.Mod.PostInit;
import cpw.mods.fml.common.Mod.PreInit;
import cpw.mods.fml.common.Mod.ServerStarted;
import cpw.mods.fml.common.Mod.ServerStarting;
import cpw.mods.fml.common.Mod.ServerStopping;
import cpw.mods.fml.common.SidedProxy;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLInterModComms;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.event.FMLServerStartedEvent;
import cpw.mods.fml.common.event.FMLServerStartingEvent;
import cpw.mods.fml.common.event.FMLServerStoppingEvent;
import cpw.mods.fml.common.network.NetworkMod;
import cpw.mods.fml.common.network.NetworkMod.SidedPacketHandler;
@Tutorial("Annotation Interfaces within Forge")
@Mod(modid = "Ghosrec35_ExampleMod", name = "ExampleMod", version = "1.0.0.0", dependencies = "after:UniversalElectricity")
@NetworkMod(clientSideRequired = true, serverSideRequired = false)
public class ExampleMod
{
@SidedProxy(clientSide = "ghosrec35.mods.examplemod.client.ClientProxy", serverSide = "ghosrec35.mods.examplemod.common.CommonProxy")
public static CommonProxy proxy;

@Instance("Ghosrec35_ExampleMod")
public ExampleMod instance;

@PreInit
public void loadPre(FMLPreInitializationEvent event)
{

}

@Init
public void load(FMLInitializationEvent event)
{

}

@PostInit
public void loadPost(FMLPostInitializationEvent event)
{

}

@ServerStarting
public void serverStarting(FMLServerStartingEvent event)
{

}

@ServerStarted
public void serverStarted(FMLServerStartedEvent event)
{

}

@ServerStopping
public void serverStopping(FMLServerStoppingEvent event)
{

}


@IMCCallback
public void interModComms(FMLInterModComms event)
{

}
}

• The @Mod annotation requires three parameters, modid which must be equivalent to a String, name which must be equivalent to a String, and version which must be equivalent to a String. Now this main mod file is able to contain other Annotation Interfaces located within the Mod.java located in the cpw.mods.fml.common package.
• The First of these methods introduced by the Mod.java is the @Instance annotation. This Annotation Interface Targets ElementTypes of the type Field, and so we annotate a public field of the type our mod file. This Annotation contains a value() of type String which is to be equivalent to your mod file's modid. This Annotation is then used to populate the field of which it annotates with the instance of your Mod File.
• The rest of the Annotations derived from the Mod.java do not require such a level of complexity.
• The first of these methods is the @PreInit Annotation which must Annotate a method with a parmeter of the type FMLPreInitializationEvent. This allows Forge ModLoader to perform two checks (The first being that this is the method designated for Pre-Initialization and the second being that the method again is designated for Pre-Initialization, but also that when invoked the method is able to retrieve information and perform tasks available from the instance of the PreInitEvent which is passed to the method upon its invocation.)
• The next Annotation is the @Init annotation which must Annotate a method with a parameter of the type FMLInitializationEvent. This Annotation works in the same way as @PreInit, except the method is invoked after the Pre Initialization methods of all mods are invoked. This allows for such things as configuration files to be created and for settings to be loaded and saved before other processes begin within the Mod. (Of course, any fields created and initialized will actually be run before the PreInit method as this occurs upon the loading of the Class itself.) The @Init method is run at the normal time of Block Registration, Recipe Registration, etc, to occur within Minecraft.
• The next Annotation is the @PostInit annotation interface, which must annotate a method with a parameter of FMLPostInitializationEvent. This method is invoked after both the @PreInit and @Init Annotated methods are invoked for each and every mod being loaded. These methods allow for easy manipulation of Minecraft and the many Blocks/Items/ and other things that have been introduced by your mod. This method is commonly called modsLoaded, as it occurs after all the mods have been loaded.
• The next Annotation is the @ServerStarting Annotation. This Annotation yet again annotates a method, but this Annotation must annotate a method with a parameter of the type FMLServerStartingEvent. This method allows for the Manipulation of the server while the server is in the process of initializing all its files.
• The next Annotation is the @ServerStarted Annotation, which annotates a method with a parameter of the type FMLServerStartedEvent. This method allows for easy manipulation of the Server after the server has been started, and is currently running.
• The next Annotation interface us the @ServerStopping annotation which annotates must annotate a method with a parameter of the type FMLServerStoppingEvent. This Annotation allows for the invocation of this method to allow for manipulation of the server while the server is stopping.
• The final Annotation I will be discussing is the @IMCCallback Annotation. This Annotation annotates a method with a parameter of the type FMLInterModComms. This allows your mod to send messages to other mods by the use of the Mods' modid and a key-value pairing. The next step is to move on to the NetworkMod annotation interface which continues on with much of the more complicated annotations.

@NetworkMod
(
clientSideRequired = true,
serverSideRequired = false,
channels = {"Channel"}
)

@NetworkMod
(
clientSideRequired = true,
serverSideRequired = false,
channels = {"Channel"},
packetHandler = PacketHandler.class
)

@NetworkMod
(
clientSideRequired = true,
serverSideRequired = false,
channels = {"Channel"},
packetHandler = PacketHandler.class,
connectionHandler = ConnectionHandler.class
)

@NetworkMod
(
clientSideRequired = true,
serverSideRequired = false,
channels = {"Channel"},
packetHandler = PacketHandler.class,
connectionHandler = ConnectionHandler.class,
tinyPacketHandler = TinyPacketHandler.class
)

@NetworkMod
(
clientSideRequired = true,
serverSideRequired = false,
connectionHandler = ConnectionHandler.class,
clientPacketHandlerSpec = @SidedPacketHandler
(
channels = {"ClientChannel1", "ClientChannel2"},
packetHandler = ClientPacketHandler.class
),
serverPacketHandlerSpec = @SidedPacketHandler
(
channels = {"ServerChannel1", "ServerChannel2"},
packetHandler = ServerPacketHandler.class
)
)

@SidedProxy(clientSide = "ghosrec35.mods.examplemod.client.ClientProxy", serverSide = "ghosrec35.mods.examplemod.common.CommonProxy")
public static CommonProxy proxy;

@SideOnly(Side.CLIENT)