Im new to the modding scene and so far have created the mod and it come up in minecraft and im curious about what proxys are and what are they used for.

Proxies are very important because they allow you to distinguish between the sides of your program.

 

There are parts that you might want to implement only on the client, like GUI Drawing, Rendering of items, keybindings etc.

 

Then there's things that you ONLY want to do on the server. Like sending a message to the player. It wouldn't make sense to have the client send a message to itself.

 

Then there's finally some stuff you might want to send to both, like when the player picks up an item. That way the client and server are perfectly in synch. 

 

I'm not sure what version you might be on. But in general you want to make a package with a ClientProxy, a ServerProxy class and  a commonproxy class.

 

Your proxy classes simply define where stuff goes. they have the same pre-init, postinit and init your main class should have: 

public class CommonProxy {

    public void preInit(FMLPreInitializationEvent e) {

    }

    public void init(FMLInitializationEvent e) {
    }


    public void postInit(FMLPostInitializationEvent e) {

    }
	
}

public class ServerProxy extends CommonProxy{
    @Override
    public void preInit(FMLPreInitializationEvent e) {
        super.preInit(e);
    }

    @Override
    public void init(FMLInitializationEvent e) {
        super.init(e);
    }

    @Override
    public void postInit(FMLPostInitializationEvent e) {
        super.postInit(e);
    }
}

(ClientProxy is the same but called Clientproxy)

 

Register these classes as proxies in your main class (Where your preinit, init etc. are registered) like so:

    @SidedProxy(clientSide="package.clientproxy", serverSide="package.serverproxy")
    public static CommonProxy proxy;

Since you already registered a static reference to your commonproxy and a bridge to your client and serverproxies by calling sidedproxy you can now call your commonproxy in the main methods. Add Main.proxy.preInit(e);  to your Main preInit method like such: 

    @EventHandler
    public void preInit(FMLPreInitializationEvent e) {
    	Main.proxy.preInit(e);

        }
    public static BarPacketHandler packetHandler;
    @EventHandler
    public void init(FMLInitializationEvent e) {
    	Main.proxy.init(e);
    }

    @EventHandler
    public void postInit(FMLPostInitializationEvent e) {
    	Main.proxy.postInit(e);
    }

 

 

 

Obviously these are all just basic, rough drafts that you'd have to adapt to your class. But if you know Java to any degree you should be able to figure out what I said (hopefully. English isn't my first language).

 

Now when you want a method in your client only, you add the registry/call to ClientProxy under the right place. CommonProxy will call everything that runs on both and ServerProxy runs on the server.

Thanks for the info. This really helps in my conquest for making mods. And your English is perfect.

 

 

when creating the methods it says they have to be static.

It's important to distinguish between physical sides and logical sides. Proxies handle physical sides, but they don't handle logical sides.

 

Client-only classes like GUIs, models and renderers can only be accessed on the physical client, but sending messages to players should happen on the logical server (not just the physical server).

 

Forge's documentation explains this in more detail here.

 

The common type of your proxies (the type of the @SidedProxy field) should be an interface rather than a class. There's no need for a common proxy class because proxies are only for sided code; common code belongs in your @Mod class and other common classes.