[1.8] Using server json instead of the clients?

[HappyKiller1O1]

So, after creating my working json in the config directory, I would like to send an update to the client (if joining a server) with the server's information from the json, rather than the clients (so basically, tell the client that the server json must be used for this information). I am not quite sure how to go about this, and if anyone could point be in the correct direction, I would be very grateful.

[Choonster]

You'll need to send a packet to the client containing the server's settings. Forge's Read the Docs site has a section on networking here, you'll want to use the Simple Network Implementation.

[HappyKiller1O1]

I should explain a bit more: I need to know how exactly I would gather that information to send. What event would I use? Can I simply check if the world is not remote and that will get the server json? Just so you know, as I should of mentioned in my post; I understand networking, and use Simple Network Implementation.

[Choonster]

Subscribe to

FMLNetworkEvent.ServerConnectionFromClientEvent

to be notified on the server when a client connects. All subclasses of

FMLNetworkEvent

are fired on a Netty thread, so you need to schedule a task on the main thread using the appropriate

IThreadListener

like you do for message handlers*.

 

This will give you an

INetHandlerPlayServer

from the

FMLNetworkEvent#handler

field which you can cast to

NetHandlerPlayServer

to get the player from the

NetHandlerPlayServer#playerEntity

field. You can then send whatever data you need to this player.

 

You'll probably want to subscribe to

FMLServerStartingEvent

(this is a state event handled by an

@Mod.EventHandler

method in your

@Mod

class) and repopulate the data from the JSON if it's an integrated server. This is because the client and integrated server are two threads running in the same JVM, they share an instance of your

@Mod

class and anything created in it. For this same reason, it's probably not necessary to handle

FMLNetworkEvent.ServerConnectionFromClientEvent

in the integrated server.

 

* I'm not entirely sure whether or not it's safe to use a

SimpleNetworkWrapper

from a Netty thread.

[HappyKiller1O1]

So, I would be creating an IThreadListener in the event? And, do I have to create the json on the server, or by creating in the config, will it already do it?

[Ernio]

Bruh... Before stating a question, just think about it for a while.

 

You need your client to have access to server-set configuration. Configuration is NOTHING more than data - good as ANY. It could be whole damn book or a goddamn dinosaur model - you don't care - it's all data. How do you synchronize data? You send it. How? Packets.

 

Now the question is - do you want to send .json file and load it on client (same way server does it) or maybe you want to send data itself (alredy parsed by server).

 

In any case - you just need to pack it all to packet and send it. In 1.8+ (or even earlier) packets server->client doen't even care about size (auto-splitted) - so that's a big plus, but back on track:

I do belive you want to send that Map of item weights. Simple (clear) way would be to pack a Map into NBT and send it. Then read it on client and put it is the place that data normally would be. So yeah - just make a packet that sends NBTTagCompound to some player, and on receiver  client - just read it.

Simple design:

NBTTagCompound is nothing less/more than a MAP.

compound.setInteger( KEY, VALUE ) - can be literally used to literally encode a MAP.

on client you just grab that NBTTagCompound and do compound.keySet() - on which you iterate and recreate a java Map from it.

 

Where are all your problems coming from?

 

BTW:

So, I would be creating an IThreadListener in the event? And, do I have to create the json on the server, or by creating in the config, will it already do it?

What?

 

You just send that packet with PlayerJoinedEvent (from server) or as suggested before - with other methods.

 

PS. I belive you have my Skype so you can always call if you need (even) more help.

[HappyKiller1O1]

Sorry about that Ernio, I made this thread last night at about 2 A.M. just to push me in the right direction. Anyway, I never thought about creating a map to be read from for the values. This is considering every time I look up the values, I search through the json. I will try what you're saying, but I would like to ask: for client side, would it be more efficient to write the json, then add those values to a map that is read from? Rather than parsing the json every time I need to look an item up? I'm guessing it would be, I'd just like your opinion.

 

And, sorry about my question to Choonster. Didn't seem to understand his answer too well.

 

And finally, thank you for the offer with Skyping you. I think I have it from here, nothing too big that I'd need more help with as of now.

[Ernio]

Too much "sorrying" and thanking. (especially the 1st one).

 

Anyway - yeah, you should most definitely read json once and put its proper contents (not every user-written stuff is "proper", 1stcheck if entry exists in item/block registry, if not - make some print warning) to actual Java Map. As stated before - map can be easily encoded to NBT (some may say that you should write straight to buffer, but that won't save you lots, still - "cutting middlemen" is often better) and then recreated on client.

 

 

[HappyKiller1O1]

Sorry about that. Anyway, I've remade it to only read everything once. My question is, is the config path different for a server? Or can I just check if the world is not remote, and load everything from the same path?

[coolAlias]

Sorry about that. Anyway, I've remade it to only read everything once. My question is, is the config path different for a server? Or can I just check if the world is not remote, and load everything from the same path?

The config path itself isn't different, but the config file that is sitting on the server cannot be read from the client, as it is usually on a different computer. You have to write every value you want to sync to the packet / byte buffer, then read it back in from that buffer on the other side and set the values in the config instance that already exists.

 

In very very rough pseudo-code:

// YourPacket#write:
buffer.writeInt(map.size());
for (each entry in your map) {
  buffer.writeString(key);
  buffer.writeString(value);
}

// YourPacket#read:
map = new Map();
int n = buffer.readInt(); // this is the number of entries
for (i = 0; i < n; ++i) {
  map.put(buffer.readString(), buffer.readString());
}
YourMod.config.map = map; // overrwrite the previously existing map entirely

That's just one way to do it, of course, but the key point is that both the server and the client have independent copies of the Config file which they read in independently, and you want to overwrite certain values on the client's version with those from the server.

 

Keep in mind that the only reason to sync Config values to the clients is if those values are actually used on the client side, such as for rendering in the GUI. Generally, this is not the case, but it sounds like you'd like to display the weight values, so in that case you should sync those values, but probably not anything else.

[HappyKiller1O1]

The only reason why I need to, is because I want the server owner to be able to change weight values, if wanted, for any item. So, I have it set up where I made a public, static Map in my ModReference class. I use that map to write the values of the json to, and read for the client to display. With that, all I would need to do is create the packet, register it on Server side only, and use that static Map (which should be on both sides I believe) to get the new values over, correct?

[coolAlias]

The config file on the server, which the server owner would modify, is the only one that matters as far as most anything is concerned. Encumbrance should only matter on the server side, and thus the server config is the only thing that is important.

 

You can't (well, shouldn't) use the server values to actually overwrite any config / .json file on the client side; you only use it to overwrite the values in memory. Also, you don't use the map to write the .json file, you use the .json file to create the map (except, perhaps, for the very first time).

 

Basically, the config (.json) file that the client reads in should be completely irrelevant as the whole point is you read the file into memory, and those values will be replaced by the ones sent from the server. The only exception is single player, in which the same file is read by both the integrated server and the client, so sending a packet makes no difference (but also won't hurt anything).

[Draco18s]

By the way, sending the json file is perfectly acceptable: it had already been serialized and you've already got the code that deserializes it and stores it in a map. Why the conversion to a separate serialized data type?