From 1ca54772c18454a745ed0a529808e5e992979323 Mon Sep 17 00:00:00 2001 From: Alex Emelyanov Date: Wed, 12 Jun 2024 16:32:54 +0300 Subject: [PATCH 1/3] Initial work on storing in the db --- build.gradle | 1 + .../java/sonar/fluxnetworks/FluxConfig.java | 50 +++ .../api/network/NetworkMember.java | 24 +- .../sonar/fluxnetworks/api/utils/Coord4D.java | 43 ++- .../common/connection/FluxLiteConnector.java | 115 +++++-- .../common/data/FluxNetworkData.java | 74 ++-- .../common/data/TagConstants.java | 48 +++ .../fluxnetworks/common/data/TagUtils.java | 132 ++++++++ .../common/data/codecs/ChunkPosCodec.java | 48 +++ .../data/codecs/FluxConnectorCodec.java | 121 +++++++ .../common/data/codecs/FluxNetworkCodec.java | 119 +++++++ .../data/codecs/FluxNetworkCodecProvider.java | 18 + .../data/codecs/FluxNetworkDataCodec.java | 97 ++++++ .../codecs/FluxNetworkDataCodecProvider.java | 17 + .../data/codecs/NetworkMemberCodec.java | 58 ++++ .../codecs/NetworkMemberCodecProvider.java | 18 + .../common/data/dto/ChunkPosDTO.java | 77 +++++ .../common/data/dto/FluxConnectorDTO.java | 316 ++++++++++++++++++ .../common/data/dto/FluxNetworkDTO.java | 175 ++++++++++ .../common/data/dto/FluxNetworkDataDTO.java | 167 +++++++++ .../common/data/dto/NBTCompatibleDTO.java | 35 ++ .../common/data/dto/NetworkMemberDTO.java | 82 +++++ .../tileentity/energy/TileIC2Energy.java | 1 + 23 files changed, 1763 insertions(+), 73 deletions(-) create mode 100644 src/main/java/sonar/fluxnetworks/common/data/TagConstants.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/TagUtils.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/codecs/ChunkPosCodec.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/codecs/FluxConnectorCodec.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodec.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodecProvider.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodec.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodecProvider.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/codecs/NetworkMemberCodec.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/codecs/NetworkMemberCodecProvider.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/dto/ChunkPosDTO.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/dto/FluxConnectorDTO.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDTO.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDataDTO.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/dto/NBTCompatibleDTO.java create mode 100644 src/main/java/sonar/fluxnetworks/common/data/dto/NetworkMemberDTO.java diff --git a/build.gradle b/build.gradle index 4b75e5d2..bf638fca 100644 --- a/build.gradle +++ b/build.gradle @@ -96,6 +96,7 @@ dependencies { implementation fg.deobf("mcjty.theoneprobe:TheOneProbe-1.12:${top_version}") + implementation group: 'org.mongodb', name: 'mongodb-driver-sync', version: '3.12.10' implementation fg.deobf("li.cil.oc:OpenComputers:MC${minecraft_version}-1.7.5.213:api") implementation fg.deobf("curse.maven:baubles-227083:2518667") diff --git a/src/main/java/sonar/fluxnetworks/FluxConfig.java b/src/main/java/sonar/fluxnetworks/FluxConfig.java index 5ccfb624..a144a11e 100644 --- a/src/main/java/sonar/fluxnetworks/FluxConfig.java +++ b/src/main/java/sonar/fluxnetworks/FluxConfig.java @@ -1,12 +1,30 @@ package sonar.fluxnetworks; +import com.mongodb.MongoClientSettings; +import com.mongodb.client.MongoClient; +import com.mongodb.client.MongoClients; +import com.mongodb.client.MongoCollection; +import com.mongodb.client.MongoDatabase; import net.minecraftforge.common.ForgeChunkManager; import net.minecraftforge.common.config.Configuration; import net.minecraftforge.common.config.Property; +import org.bson.Document; +import org.bson.codecs.UuidCodec; +import org.bson.codecs.configuration.CodecRegistries; +import org.bson.codecs.configuration.CodecRegistry; +import sonar.fluxnetworks.common.data.dto.FluxNetworkDataDTO; +import sonar.fluxnetworks.common.data.codecs.ChunkPosCodec; +import sonar.fluxnetworks.common.data.codecs.FluxConnectorCodec; +import sonar.fluxnetworks.common.data.codecs.FluxNetworkCodecProvider; +import sonar.fluxnetworks.common.data.codecs.FluxNetworkDataCodecProvider; +import sonar.fluxnetworks.common.data.codecs.NetworkMemberCodecProvider; import sonar.fluxnetworks.common.handler.ItemEnergyHandler; import sonar.fluxnetworks.common.handler.TileEntityHandler; import java.io.File; +import java.util.UUID; + +import static sonar.fluxnetworks.common.data.TagConstants.INDEX_FIELD; public class FluxConfig { @@ -17,12 +35,21 @@ public class FluxConfig { public static final String ENERGY = "energy"; public static final String NETWORKS = "networks"; public static final String BLACKLIST = "blacklists"; + public static final String DATABASE = "database"; + + public static MongoCollection MONGO_COLLECTION; public static boolean enableButtonSound, enableOneProbeBasicInfo, enableOneProbeAdvancedInfo, enableOneProbeSneaking; public static boolean enableFluxRecipe, enableOldRecipe, enableChunkLoading, enableSuperAdmin; public static int defaultLimit, basicCapacity, basicTransfer, herculeanCapacity, herculeanTransfer, gargantuanCapacity, gargantuanTransfer; public static int maximumPerPlayer, superAdminRequiredPermission; public static String[] blockBlacklistStrings, itemBlackListStrings; + public static UUID MONGO_SERVER_ID; + private static MongoClient MONGO_CLIENT; + private static MongoDatabase MONGO_DB; + private static String MONGO_URL; + private static String MONGO_DB_NAME; + private static String MONGO_COLLECTION_NAME; public static void init(File file) { config = new Configuration(new File(file.getPath(), "flux_networks.cfg")); @@ -31,6 +58,23 @@ public static void init(File file) { verifyAndReadBlacklist(); config.save(); generateFluxChunkConfig(); + connectToDB(); + } + + private static void connectToDB(){ + MONGO_CLIENT = MongoClients.create(MONGO_URL); + ChunkPosCodec chunkPosCodec = new ChunkPosCodec(); + UuidCodec uuidCodec = new UuidCodec(); + FluxConnectorCodec fluxConnectorCodec = new FluxConnectorCodec(); + CodecRegistry codecRegistry = CodecRegistries.fromRegistries(CodecRegistries.fromRegistries( + CodecRegistries.fromCodecs(chunkPosCodec, uuidCodec, fluxConnectorCodec), + CodecRegistries.fromProviders(new FluxNetworkCodecProvider(), new FluxNetworkDataCodecProvider(), new NetworkMemberCodecProvider()), + MongoClientSettings.getDefaultCodecRegistry())); + MONGO_DB = MONGO_CLIENT.getDatabase(MONGO_DB_NAME); + MONGO_COLLECTION = MONGO_DB.getCollection(MONGO_COLLECTION_NAME, FluxNetworkDataDTO.class).withCodecRegistry(codecRegistry); + if (MONGO_COLLECTION.countDocuments(new Document(INDEX_FIELD, MONGO_SERVER_ID)) < 1) { + MONGO_COLLECTION.insertOne(new FluxNetworkDataDTO(MONGO_SERVER_ID)); + } } public static void verifyAndReadBlacklist() { @@ -85,6 +129,7 @@ public static void generateFluxChunkConfig() { } public static void read() { + defaultLimit = config.getInt("Default Transfer Limit", ENERGY, 800000, 0, Integer.MAX_VALUE, "The default transfer limit of a flux connector"); basicCapacity = config.getInt("Basic Storage Capacity", ENERGY, 1000000, 0, Integer.MAX_VALUE, ""); @@ -102,6 +147,11 @@ public static void read() { enableOldRecipe = config.getBoolean("Enable Old Recipe", GENERAL, false, "Enables redstone being turned into Flux when dropped in fire. (Need \"Enable Flux Recipe\" = true, so the default recipe can't be disabled if turns this on)"); enableChunkLoading = config.getBoolean("Allow Flux Chunk Loading", GENERAL, true, "Allows flux tiles to work as chunk loaders"); + MONGO_URL = config.getString("Url to connect to mongo instance", DATABASE, "mongodb://localhost:27017", ""); + MONGO_DB_NAME = config.getString("Mongo database name", DATABASE, "local", ""); + MONGO_COLLECTION_NAME = config.getString("Mongo collection name", DATABASE, "networks", ""); + MONGO_SERVER_ID = UUID.fromString(config.getString("Unique server id for multi-server features", DATABASE, UUID.randomUUID().toString(), "Do not change this value unless you want to lose all network data!")); + enableButtonSound = config.getBoolean("Enable GUI Button Sound", CLIENT, true, "Enable navigation buttons sound when pressing it"); enableOneProbeBasicInfo = config.getBoolean("Enable Basic One Probe Info", CLIENT, true, "Displays: Network Name, Live Transfer Rate & Internal Buffer"); enableOneProbeAdvancedInfo = config.getBoolean("Enable Advanced One Probe Info", CLIENT, true, "Displays: Transfer Limit & Priority etc"); diff --git a/src/main/java/sonar/fluxnetworks/api/network/NetworkMember.java b/src/main/java/sonar/fluxnetworks/api/network/NetworkMember.java index 7a0a78de..63bc4827 100644 --- a/src/main/java/sonar/fluxnetworks/api/network/NetworkMember.java +++ b/src/main/java/sonar/fluxnetworks/api/network/NetworkMember.java @@ -6,9 +6,14 @@ import net.minecraft.server.MinecraftServer; import net.minecraft.server.management.PlayerProfileCache; import net.minecraftforge.fml.common.FMLCommonHandler; +import sonar.fluxnetworks.common.data.dto.NetworkMemberDTO; import java.util.UUID; +import static sonar.fluxnetworks.common.data.TagConstants.CACHED_NAME; +import static sonar.fluxnetworks.common.data.TagConstants.PLAYER_ACCESS; +import static sonar.fluxnetworks.common.data.TagConstants.PLAYER_UUID; + public class NetworkMember { private UUID playerUUID; @@ -22,6 +27,12 @@ public NetworkMember(NBTTagCompound nbt) { readNetworkNBT(nbt); } + public NetworkMember(NetworkMemberDTO networkMemberDTO) { + this.playerUUID = networkMemberDTO.getPlayerUUID(); + this.cachedName = networkMemberDTO.getCachedName(); + this.accessPermission = AccessLevel.values()[networkMemberDTO.getPlayerAccess()]; + } + public static NetworkMember createNetworkMember(EntityPlayer player, AccessLevel permissionLevel) { NetworkMember t = new NetworkMember(); GameProfile profile = player.getGameProfile(); @@ -72,15 +83,16 @@ public void setAccessPermission(AccessLevel accessPermission) { } public void readNetworkNBT(NBTTagCompound nbt) { - playerUUID = nbt.getUniqueId("playerUUID"); - cachedName = nbt.getString("cachedName"); - accessPermission = AccessLevel.values()[nbt.getByte("playerAccess")]; + playerUUID = nbt.getUniqueId(PLAYER_UUID); + cachedName = nbt.getString(CACHED_NAME); + accessPermission = AccessLevel.values()[nbt.getByte(PLAYER_ACCESS)]; } public NBTTagCompound writeNetworkNBT(NBTTagCompound nbt) { - nbt.setUniqueId("playerUUID", playerUUID); - nbt.setString("cachedName", cachedName); - nbt.setByte("playerAccess", (byte) accessPermission.ordinal()); + + nbt.setUniqueId(PLAYER_UUID, playerUUID); + nbt.setString(CACHED_NAME, cachedName); + nbt.setByte(PLAYER_ACCESS, (byte) accessPermission.ordinal()); return nbt; } } diff --git a/src/main/java/sonar/fluxnetworks/api/utils/Coord4D.java b/src/main/java/sonar/fluxnetworks/api/utils/Coord4D.java index 675ff4db..17d7e557 100644 --- a/src/main/java/sonar/fluxnetworks/api/utils/Coord4D.java +++ b/src/main/java/sonar/fluxnetworks/api/utils/Coord4D.java @@ -4,11 +4,24 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.math.BlockPos; +import sonar.fluxnetworks.common.data.dto.FluxConnectorDTO; + +import static sonar.fluxnetworks.common.data.TagConstants.DIMENSION; +import static sonar.fluxnetworks.common.data.TagConstants.X; +import static sonar.fluxnetworks.common.data.TagConstants.Y; +import static sonar.fluxnetworks.common.data.TagConstants.Z; public class Coord4D { private int x, y, z, dimension; + public Coord4D(int x, int y, int z, int dimension) { + this.x = x; + this.y = y; + this.z = z; + this.dimension = dimension; + } + public Coord4D(NBTTagCompound tag) { read(tag); } @@ -25,18 +38,32 @@ public Coord4D(ByteBuf buf) { } public NBTTagCompound write(NBTTagCompound tag) { - tag.setInteger("x", x); - tag.setInteger("y", y); - tag.setInteger("z", z); - tag.setInteger("dimension", dimension); + tag.setInteger(X, x); + tag.setInteger(Y, y); + tag.setInteger(Z, z); + tag.setInteger(DIMENSION, dimension); return tag; } + public void write(FluxConnectorDTO dto) { + dto.setX(x); + dto.setY(y); + dto.setZ(z); + dto.setDimension(dimension); + } + public void read(NBTTagCompound tag) { - x = tag.getInteger("x"); - y = tag.getInteger("y"); - z = tag.getInteger("z"); - dimension = tag.getInteger("dimension"); + x = tag.getInteger(X); + y = tag.getInteger(Y); + z = tag.getInteger(Z); + dimension = tag.getInteger(DIMENSION); + } + + public void read(FluxConnectorDTO dto) { + x = dto.getX(); + y = dto.getY(); + z = dto.getZ(); + dimension = dto.getDimension(); } public void write(ByteBuf buf) { diff --git a/src/main/java/sonar/fluxnetworks/common/connection/FluxLiteConnector.java b/src/main/java/sonar/fluxnetworks/common/connection/FluxLiteConnector.java index 3c26efad..63e6cf63 100644 --- a/src/main/java/sonar/fluxnetworks/common/connection/FluxLiteConnector.java +++ b/src/main/java/sonar/fluxnetworks/common/connection/FluxLiteConnector.java @@ -2,17 +2,34 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.JsonToNBT; +import net.minecraft.nbt.NBTException; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.world.World; +import sonar.fluxnetworks.FluxNetworks; import sonar.fluxnetworks.api.network.ConnectionType; import sonar.fluxnetworks.api.network.IFluxNetwork; import sonar.fluxnetworks.api.network.ITransferHandler; import sonar.fluxnetworks.api.tiles.IFluxConnector; import sonar.fluxnetworks.api.utils.Coord4D; import sonar.fluxnetworks.api.utils.NBTType; +import sonar.fluxnetworks.common.data.dto.FluxConnectorDTO; import java.util.UUID; +import static sonar.fluxnetworks.common.data.TagConstants.BUFFER; +import static sonar.fluxnetworks.common.data.TagConstants.CHANGE; +import static sonar.fluxnetworks.common.data.TagConstants.D_LIMIT; +import static sonar.fluxnetworks.common.data.TagConstants.FOLDER_ID; +import static sonar.fluxnetworks.common.data.TagConstants.FORCED_CHUNK; +import static sonar.fluxnetworks.common.data.TagConstants.IS_CHUNK_LOADED; +import static sonar.fluxnetworks.common.data.TagConstants.LIMIT; +import static sonar.fluxnetworks.common.data.TagConstants.NAME; +import static sonar.fluxnetworks.common.data.TagConstants.N_ID; +import static sonar.fluxnetworks.common.data.TagConstants.PRIORITY; +import static sonar.fluxnetworks.common.data.TagConstants.SURGE; +import static sonar.fluxnetworks.common.data.TagConstants.TYPE; + public class FluxLiteConnector implements IFluxConnector { public int networkID; @@ -49,24 +66,50 @@ public FluxLiteConnector(IFluxConnector tile) { this.stack = tile.getDisplayStack(); } + public FluxLiteConnector(FluxConnectorDTO dto) { + this.networkID = dto.getN_id(); + this.priority = dto.getPriority(); + this.connectionType = ConnectionType.values()[dto.getType()]; + this.limit = dto.getLimit(); + this.coord4D = new Coord4D(dto.getX(), dto.getY(), dto.getZ(), dto.getDimension()); + this.folderID = dto.getFolder_id(); + this.customName = dto.getName(); + this.surgeMode = dto.getSurge(); + this.disableLimit = dto.getDisableLimit(); + this.isChunkLoaded = dto.getChunkLoaded(); + this.buffer = dto.getBuffer(); + this.change = dto.getChange(); + this.chunkLoading = dto.getForcedChunk(); + if (dto.getTag() != null && !dto.getTag().isEmpty()) { + try { + new ItemStack(JsonToNBT.getTagFromJson(dto.getTag())); + } catch (NBTException e) { + this.stack = ItemStack.EMPTY; + FluxNetworks.logger.error(e.getMessage()); + } + } else { + this.stack = ItemStack.EMPTY; + } + } + public FluxLiteConnector(NBTTagCompound tag) { readCustomNBT(tag, NBTType.ALL_SAVE); } public static NBTTagCompound writeCustomNBT(IFluxConnector tile, NBTTagCompound tag) { tile.getCoords().write(tag); - tag.setInteger("type", tile.getConnectionType().ordinal()); - tag.setInteger("n_id", tile.getNetworkID()); - tag.setInteger("priority", tile.getRawPriority()); - tag.setInteger("folder_id", tile.getFolderID()); - tag.setLong("limit", tile.getRawLimit()); - tag.setString("name", tile.getCustomName()); - tag.setBoolean("dLimit", tile.getDisableLimit()); - tag.setBoolean("surge", tile.getSurgeMode()); - tag.setBoolean("isChunkLoaded", tile.isChunkLoaded()); - tag.setLong("buffer", tile.getTransferBuffer()); - tag.setLong("change", tile.getTransferChange()); - tag.setBoolean("forcedChunk", tile.isForcedLoading()); + tag.setInteger(TYPE, tile.getConnectionType().ordinal()); + tag.setInteger(N_ID, tile.getNetworkID()); + tag.setInteger(PRIORITY, tile.getRawPriority()); + tag.setInteger(FOLDER_ID, tile.getFolderID()); + tag.setLong(LIMIT, tile.getRawLimit()); + tag.setString(NAME, tile.getCustomName()); + tag.setBoolean(D_LIMIT, tile.getDisableLimit()); + tag.setBoolean(SURGE, tile.getSurgeMode()); + tag.setBoolean(IS_CHUNK_LOADED, tile.isChunkLoaded()); + tag.setLong(BUFFER, tile.getTransferBuffer()); + tag.setLong(CHANGE, tile.getTransferChange()); + tag.setBoolean(FORCED_CHUNK, tile.isForcedLoading()); tile.getDisplayStack().writeToNBT(tag); return tag; } @@ -74,18 +117,18 @@ public static NBTTagCompound writeCustomNBT(IFluxConnector tile, NBTTagCompound @Override public NBTTagCompound writeCustomNBT(NBTTagCompound tag, NBTType type) { coord4D.write(tag); - tag.setInteger("type", connectionType.ordinal()); - tag.setInteger("n_id", networkID); - tag.setInteger("priority", priority); - tag.setInteger("folder_id", folderID); - tag.setLong("limit", limit); - tag.setString("name", customName); - tag.setBoolean("dLimit", disableLimit); - tag.setBoolean("surge", surgeMode); - tag.setBoolean("isChunkLoaded", isChunkLoaded); - tag.setLong("buffer", buffer); - tag.setLong("change", change); - tag.setBoolean("forcedChunk", chunkLoading); + tag.setInteger(TYPE, connectionType.ordinal()); + tag.setInteger(N_ID, networkID); + tag.setInteger(PRIORITY, priority); + tag.setInteger(FOLDER_ID, folderID); + tag.setLong(LIMIT, limit); + tag.setString(NAME, customName); + tag.setBoolean(D_LIMIT, disableLimit); + tag.setBoolean(SURGE, surgeMode); + tag.setBoolean(IS_CHUNK_LOADED, isChunkLoaded); + tag.setLong(BUFFER, buffer); + tag.setLong(CHANGE, change); + tag.setBoolean(FORCED_CHUNK, chunkLoading); stack.writeToNBT(tag); return tag; } @@ -93,18 +136,18 @@ public NBTTagCompound writeCustomNBT(NBTTagCompound tag, NBTType type) { @Override public void readCustomNBT(NBTTagCompound tag, NBTType type) { coord4D = new Coord4D(tag); - connectionType = ConnectionType.values()[tag.getInteger("type")]; - networkID = tag.getInteger("n_id"); - priority = tag.getInteger("priority"); - folderID = tag.getInteger("folder_id"); - limit = tag.getLong("limit"); - customName = tag.getString("name"); - disableLimit = tag.getBoolean("dLimit"); - surgeMode = tag.getBoolean("surge"); - isChunkLoaded = tag.getBoolean("isChunkLoaded"); - buffer = tag.getLong("buffer"); - change = tag.getLong("change"); - chunkLoading = tag.getBoolean("forcedChunk"); + connectionType = ConnectionType.values()[tag.getInteger(TYPE)]; + networkID = tag.getInteger(N_ID); + priority = tag.getInteger(PRIORITY); + folderID = tag.getInteger(FOLDER_ID); + limit = tag.getLong(LIMIT); + customName = tag.getString(NAME); + disableLimit = tag.getBoolean(D_LIMIT); + surgeMode = tag.getBoolean(SURGE); + isChunkLoaded = tag.getBoolean(IS_CHUNK_LOADED); + buffer = tag.getLong(BUFFER); + change = tag.getLong(CHANGE); + chunkLoading = tag.getBoolean(FORCED_CHUNK); stack = new ItemStack(tag); } diff --git a/src/main/java/sonar/fluxnetworks/common/data/FluxNetworkData.java b/src/main/java/sonar/fluxnetworks/common/data/FluxNetworkData.java index 8d6ebca6..39f1164c 100644 --- a/src/main/java/sonar/fluxnetworks/common/data/FluxNetworkData.java +++ b/src/main/java/sonar/fluxnetworks/common/data/FluxNetworkData.java @@ -1,6 +1,7 @@ package sonar.fluxnetworks.common.data; import com.google.common.collect.Lists; +import com.mongodb.BasicDBObject; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.nbt.NBTTagCompound; @@ -14,7 +15,12 @@ import net.minecraftforge.fml.common.FMLCommonHandler; import org.apache.commons.io.FileUtils; import sonar.fluxnetworks.FluxNetworks; -import sonar.fluxnetworks.api.network.*; +import sonar.fluxnetworks.api.network.AccessLevel; +import sonar.fluxnetworks.api.network.IFluxNetwork; +import sonar.fluxnetworks.api.network.ISuperAdmin; +import sonar.fluxnetworks.api.network.NetworkMember; +import sonar.fluxnetworks.api.network.NetworkSettings; +import sonar.fluxnetworks.api.network.SecurityType; import sonar.fluxnetworks.api.tiles.IFluxConnector; import sonar.fluxnetworks.api.utils.Capabilities; import sonar.fluxnetworks.api.utils.EnergyType; @@ -23,6 +29,7 @@ import sonar.fluxnetworks.common.connection.FluxNetworkBase; import sonar.fluxnetworks.common.connection.FluxNetworkCache; import sonar.fluxnetworks.common.connection.FluxNetworkServer; +import sonar.fluxnetworks.common.data.dto.FluxNetworkDataDTO; import sonar.fluxnetworks.common.handler.PacketHandler; import sonar.fluxnetworks.common.network.PacketNetworkUpdate; @@ -34,6 +41,12 @@ import java.util.List; import java.util.Map; +import static sonar.fluxnetworks.FluxConfig.MONGO_COLLECTION; +import static sonar.fluxnetworks.FluxConfig.MONGO_SERVER_ID; +import static sonar.fluxnetworks.common.data.TagConstants.INDEX_FIELD; +import static sonar.fluxnetworks.common.data.TagConstants.X; +import static sonar.fluxnetworks.common.data.TagConstants.Z; + /** * Save network data to local. Only on server side */ @@ -98,28 +111,35 @@ public static FluxNetworkData get() { } private static void loadData() { - World world = DimensionManager.getWorld(0); - - MapStorage mapStorage = world.getMapStorage(); - FluxNetworkData savedData = (FluxNetworkData) mapStorage.getOrLoadData(FluxNetworkData.class, NETWORK_DATA); - - if (savedData == null) { - File oldFile = new File(world.getSaveHandler().getWorldDirectory(), "data/sonar.flux.networks.configurations.dat"); - if (oldFile.exists()) { - //oldFile.renameTo(new File(oldFile.getParent(), FluxNetworkData.NETWORK_DATA + ".dat")); - try { - FileUtils.copyFile(oldFile, new File(oldFile.getParent(), FluxNetworkData.NETWORK_DATA + ".dat")); - } catch (IOException e) { - e.printStackTrace(); + FluxNetworkDataDTO fluxNetworkDataDTO = MONGO_COLLECTION.find(new BasicDBObject(INDEX_FIELD, MONGO_SERVER_ID)).first(); + FluxNetworkData savedData; + if (fluxNetworkDataDTO != null && !fluxNetworkDataDTO.isEmpty()) { + savedData = fluxNetworkDataDTO.getFluxNetworkData(); + } else { + World world = DimensionManager.getWorld(0); + + MapStorage mapStorage = world.getMapStorage(); + savedData = (FluxNetworkData) mapStorage.getOrLoadData(FluxNetworkData.class, NETWORK_DATA); + + if (savedData == null) { + File oldFile = new File(world.getSaveHandler().getWorldDirectory(), "data/sonar.flux.networks.configurations.dat"); + if (oldFile.exists()) { + //oldFile.renameTo(new File(oldFile.getParent(), FluxNetworkData.NETWORK_DATA + ".dat")); + try { + FileUtils.copyFile(oldFile, new File(oldFile.getParent(), FluxNetworkData.NETWORK_DATA + ".dat")); + } catch (IOException e) { + e.printStackTrace(); + } + FluxNetworks.logger.info("Old FluxNetworkData found"); + savedData = (FluxNetworkData) mapStorage.getOrLoadData(FluxNetworkData.class, NETWORK_DATA); + } else { + savedData = new FluxNetworkData(NETWORK_DATA); + mapStorage.setData(NETWORK_DATA, savedData); + FluxNetworks.logger.info("No FluxNetworkData found"); } - FluxNetworks.logger.info("Old FluxNetworkData found"); - savedData = (FluxNetworkData) mapStorage.getOrLoadData(FluxNetworkData.class, NETWORK_DATA); - } else { - savedData = new FluxNetworkData(NETWORK_DATA); - mapStorage.setData(NETWORK_DATA, savedData); - FluxNetworks.logger.info("No FluxNetworkData found"); } } + data = savedData; FluxNetworks.logger.info("FluxNetworkData has been successfully loaded"); } @@ -170,9 +190,17 @@ public NBTTagCompound writeToNBT(NBTTagCompound compound) { NBTTagCompound tag = new NBTTagCompound(); loadedChunks.forEach((dim, pos) -> writeChunks(dim, pos, tag)); compound.setTag(LOADED_CHUNKS, tag); + save(compound); return compound; } + private void save(NBTTagCompound nbt) { + FluxNetworkDataDTO networkDataDTO = FluxNetworkDataDTO.fromNBT(nbt); + if (networkDataDTO != null) { + MONGO_COLLECTION.findOneAndReplace(new BasicDBObject(INDEX_FIELD, networkDataDTO.getServerID()), networkDataDTO); + } + } + public static void readPlayers(IFluxNetwork network, @Nonnull NBTTagCompound nbt) { if (!nbt.hasKey(PLAYER_LIST)) { return; @@ -273,7 +301,7 @@ private void readChunks(NBTTagCompound nbt) { List pos = loadedChunks.computeIfAbsent(Integer.valueOf(key), l -> new ArrayList<>()); for (int i = 0; i < list.tagCount(); i++) { NBTTagCompound tag = list.getCompoundTagAt(i); - pos.add(new ChunkPos(tag.getInteger("x"), tag.getInteger("z"))); + pos.add(new ChunkPos(tag.getInteger(X), tag.getInteger(Z))); } } } @@ -283,8 +311,8 @@ private NBTTagCompound writeChunks(int dim, List pos, NBTTagCompound n NBTTagList list = new NBTTagList(); pos.forEach(p -> { NBTTagCompound t = new NBTTagCompound(); - t.setInteger("x", p.x); - t.setInteger("z", p.z); + t.setInteger(X, p.x); + t.setInteger(Z, p.z); list.appendTag(t); }); nbt.setTag(String.valueOf(dim), list); diff --git a/src/main/java/sonar/fluxnetworks/common/data/TagConstants.java b/src/main/java/sonar/fluxnetworks/common/data/TagConstants.java new file mode 100644 index 00000000..0990ff18 --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/TagConstants.java @@ -0,0 +1,48 @@ +package sonar.fluxnetworks.common.data; + +public class TagConstants { + + public static final String INDEX_FIELD = "_id"; + + public static final String X = "x"; + public static final String Y = "y"; + public static final String Z = "z"; + public static final String DIMENSION = "dimension"; + + public static final String TYPE = "type"; + public static final String N_ID = "n_id"; + public static final String PRIORITY = "priority"; + public static final String FOLDER_ID = "folder_id"; + public static final String LIMIT = "limit"; + public static final String NAME = "name"; + public static final String SURGE = "surge"; + public static final String D_LIMIT = "dLimit"; + public static final String IS_CHUNK_LOADED = "isChunkLoaded"; + public static final String BUFFER = "buffer"; + public static final String CHANGE = "change"; + public static final String FORCED_CHUNK = "forcedChunk"; + + public static final String ID = "id"; + public static final String COUNT = "Count"; + public static final String DAMAGE = "Damage"; + public static final String TAG = "tag"; + + public static final String UNIQUE_ID = "uniqueID"; + public static final String NETWORKS = "networks"; + public static final String LOADED_CHUNKS = "loadedChunks"; + + public static final String NETWORK_ID = "networkID"; + public static final String NETWORK_NAME = "networkName"; + public static final String OWNER_UUID = "ownerUUID"; + public static final String NETWORK_SECURITY = "networkSecurity"; + public static final String NETWORK_PASSWORD = "networkPassword"; + public static final String NETWORK_COLOR = "networkColor"; + public static final String NETWORK_ENERGY = "networkEnergy"; + public static final String WIRELESS_MODE = "wirelessMode"; + public static final String PLAYER_LIST = "playerList"; + public static final String UNLOADED = "unloaded"; + + public static final String PLAYER_UUID = "playerUUID"; + public static final String CACHED_NAME = "cachedName"; + public static final String PLAYER_ACCESS = "playerAccess"; +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/TagUtils.java b/src/main/java/sonar/fluxnetworks/common/data/TagUtils.java new file mode 100644 index 00000000..ffdd860c --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/TagUtils.java @@ -0,0 +1,132 @@ +package sonar.fluxnetworks.common.data; + +import net.minecraft.nbt.JsonToNBT; +import net.minecraft.nbt.NBTException; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import sonar.fluxnetworks.FluxNetworks; +import sonar.fluxnetworks.common.data.dto.ChunkPosDTO; +import sonar.fluxnetworks.common.data.dto.FluxConnectorDTO; +import sonar.fluxnetworks.common.data.dto.FluxNetworkDTO; +import sonar.fluxnetworks.common.data.dto.NBTCompatibleDTO; +import sonar.fluxnetworks.common.data.dto.NetworkMemberDTO; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +public class TagUtils { + public static Long longOrNull(NBTTagCompound tag, String key) { + return tag.hasKey(key) ? tag.getLong(key) : null; + } + + public static Integer intOrNull(NBTTagCompound tag, String key) { + return tag.hasKey(key) ? tag.getInteger(key) : null; + } + + public static Boolean booleanOrNull(NBTTagCompound tag, String key) { + return tag.hasKey(key) ? tag.getBoolean(key) : null; + } + + public static String stringOrNull(NBTTagCompound tag, String key) { + return tag.hasKey(key) ? tag.getString(key) : null; + } + + public static Byte byteOrNull(NBTTagCompound tag, String key) { + return tag.hasKey(key) ? tag.getByte(key) : null; + } + + public static Short shortOrNull(NBTTagCompound tag, String key) { + return tag.hasKey(key) ? tag.getShort(key) : null; + } + + public static List playerListOrNull(NBTTagCompound tag, String key) { + List dtoList = new ArrayList<>(); + if (tag.hasKey(key)) { + NBTTagList nbtTagList = tag.getTagList(key, 10); + for (int i = 0; i < nbtTagList.tagCount(); i++) { + dtoList.add(NetworkMemberDTO.fromNBT(nbtTagList.getCompoundTagAt(i))); + } + } + return dtoList.isEmpty() ? null : dtoList; + } + + public static List fluxConnectorListOrNull(NBTTagCompound tag, String key) { + List dtoList = new ArrayList<>(); + if (tag.hasKey(key)) { + NBTTagList nbtTagList = tag.getTagList(key, 10); + for (int i = 0; i < nbtTagList.tagCount(); i++) { + dtoList.add(FluxConnectorDTO.fromNBT(nbtTagList.getCompoundTagAt(i))); + } + } + return dtoList.isEmpty() ? null : dtoList; + } + + public static List fluxNetworkListOrNull(NBTTagCompound tag, String key) { + List dtoList = new ArrayList<>(); + if (tag.hasKey(key)) { + NBTTagList nbtTagList = tag.getTagList(key, 10); + for (int i = 0; i < nbtTagList.tagCount(); i++) { + dtoList.add(FluxNetworkDTO.fromNBT(nbtTagList.getCompoundTagAt(i))); + } + } + return dtoList.isEmpty() ? null : dtoList; + } + + public static List chunkPosListOrNull(NBTTagCompound tag, String key) { + List dtoList = new ArrayList<>(); + if (tag.hasKey(key)) { + NBTTagList nbtTagList = tag.getTagList(key, 10); + for (int i = 0; i < nbtTagList.tagCount(); i++) { + dtoList.add(ChunkPosDTO.fromNBT(nbtTagList.getCompoundTagAt(i))); + } + } + return dtoList.isEmpty() ? null : dtoList; + } + + + public static UUID uuidOrNull(NBTTagCompound tag, String key) { + return tag.hasKey(key + "Least") && tag.hasKey(key + "Most")? tag.getUniqueId(key) : null; + } + + public static void fillNBT(NBTTagCompound tag, String key, T value) { + if (value != null) { + if (value instanceof UUID) { + tag.setUniqueId(key, (UUID) value); + } else if (value instanceof Integer) { + tag.setInteger(key, (Integer) value); + } else if (value instanceof Long) { + tag.setLong(key, (Long) value); + } else if (value instanceof String) { + tag.setString(key, (String) value); + } else if (value instanceof Byte) { + tag.setByte(key, (Byte) value); + } else if (value instanceof Short) { + tag.setShort(key, (Short) value); + } else if (value instanceof Boolean) { + tag.setBoolean(key, (Boolean) value); + } + } + } + + public static void parseNBTFromString(NBTTagCompound tag, String key, String value) { + if (value != null && !value.isEmpty()) { + try { + tag.setTag(key, JsonToNBT.getTagFromJson(value)); + } catch (NBTException e) { + FluxNetworks.logger.error(e.getMessage()); + } + } + } + + static > void fillNBT(NBTTagCompound tag, String key, List value) { + if (value != null) { + NBTTagList nbtTagList = new NBTTagList(); + for (T dto : value) { + nbtTagList.appendTag(dto.toNBT()); + } + tag.setTag(key, nbtTagList); + } + } + +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/codecs/ChunkPosCodec.java b/src/main/java/sonar/fluxnetworks/common/data/codecs/ChunkPosCodec.java new file mode 100644 index 00000000..f8282945 --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/codecs/ChunkPosCodec.java @@ -0,0 +1,48 @@ +package sonar.fluxnetworks.common.data.codecs; + +import org.bson.BsonReader; +import org.bson.BsonType; +import org.bson.BsonWriter; +import org.bson.codecs.Codec; +import org.bson.codecs.DecoderContext; +import org.bson.codecs.EncoderContext; +import sonar.fluxnetworks.common.data.dto.ChunkPosDTO; + +import static sonar.fluxnetworks.common.data.TagConstants.DIMENSION; +import static sonar.fluxnetworks.common.data.TagConstants.X; +import static sonar.fluxnetworks.common.data.TagConstants.Z; + +public class ChunkPosCodec implements Codec { + + @Override + public ChunkPosDTO decode(BsonReader reader, DecoderContext decoderContext) { + ChunkPosDTO chunkPosDTO = new ChunkPosDTO(); + reader.readStartDocument(); + while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) { + String s = reader.readName(); + if (s.equals(X)) { + chunkPosDTO.setX(reader.readInt32()); + } else if (s.equals(Z)) { + chunkPosDTO.setZ(reader.readInt32()); + } else if (s.equals(DIMENSION)) { + chunkPosDTO.setDimension(reader.readInt32()); + } + } + reader.readEndDocument(); + return chunkPosDTO; + } + + @Override + public void encode(BsonWriter writer, ChunkPosDTO value, EncoderContext encoderContext) { + writer.writeStartDocument(); + writer.writeInt32(X, value.getX()); + writer.writeInt32(Z, value.getZ()); + writer.writeInt32(DIMENSION, value.getDimension()); + writer.writeEndDocument(); + } + + @Override + public Class getEncoderClass() { + return ChunkPosDTO.class; + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxConnectorCodec.java b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxConnectorCodec.java new file mode 100644 index 00000000..3a50e4a5 --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxConnectorCodec.java @@ -0,0 +1,121 @@ +package sonar.fluxnetworks.common.data.codecs; + +import org.bson.BsonReader; +import org.bson.BsonType; +import org.bson.BsonWriter; +import org.bson.codecs.Codec; +import org.bson.codecs.DecoderContext; +import org.bson.codecs.EncoderContext; +import sonar.fluxnetworks.common.data.dto.FluxConnectorDTO; + +import static sonar.fluxnetworks.common.data.TagConstants.BUFFER; +import static sonar.fluxnetworks.common.data.TagConstants.CHANGE; +import static sonar.fluxnetworks.common.data.TagConstants.COUNT; +import static sonar.fluxnetworks.common.data.TagConstants.DAMAGE; +import static sonar.fluxnetworks.common.data.TagConstants.DIMENSION; +import static sonar.fluxnetworks.common.data.TagConstants.D_LIMIT; +import static sonar.fluxnetworks.common.data.TagConstants.FOLDER_ID; +import static sonar.fluxnetworks.common.data.TagConstants.FORCED_CHUNK; +import static sonar.fluxnetworks.common.data.TagConstants.ID; +import static sonar.fluxnetworks.common.data.TagConstants.IS_CHUNK_LOADED; +import static sonar.fluxnetworks.common.data.TagConstants.LIMIT; +import static sonar.fluxnetworks.common.data.TagConstants.NAME; +import static sonar.fluxnetworks.common.data.TagConstants.N_ID; +import static sonar.fluxnetworks.common.data.TagConstants.PRIORITY; +import static sonar.fluxnetworks.common.data.TagConstants.SURGE; +import static sonar.fluxnetworks.common.data.TagConstants.TAG; +import static sonar.fluxnetworks.common.data.TagConstants.TYPE; +import static sonar.fluxnetworks.common.data.TagConstants.X; +import static sonar.fluxnetworks.common.data.TagConstants.Y; +import static sonar.fluxnetworks.common.data.TagConstants.Z; + +public class FluxConnectorCodec implements Codec { + @Override + public FluxConnectorDTO decode(BsonReader reader, DecoderContext decoderContext) { + FluxConnectorDTO connector = new FluxConnectorDTO(); + reader.readStartDocument(); + while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) { + String name = reader.readName(); + if (name.equals(TYPE)) { + connector.setType(reader.readInt32()); + } else if (name.equals(N_ID)) { + connector.setN_id(reader.readInt32()); + } else if (name.equals(PRIORITY)) { + connector.setPriority(reader.readInt32()); + } else if (name.equals(FOLDER_ID)) { + connector.setFolder_id(reader.readInt32()); + } else if (name.equals(LIMIT)) { + connector.setLimit(reader.readInt64()); + } else if (name.equals(NAME)) { + connector.setName(reader.readString()); + } else if (name.equals(SURGE)) { + connector.setSurge(reader.readBoolean()); + } else if (name.equals(D_LIMIT)) { + connector.setDisableLimit(reader.readBoolean()); + } else if (name.equals(IS_CHUNK_LOADED)) { + connector.setChunkLoaded(reader.readBoolean()); + } else if (name.equals(BUFFER)) { + connector.setBuffer(reader.readInt64()); + } else if (name.equals(CHANGE)) { + connector.setChange(reader.readInt64()); + } else if (name.equals(FORCED_CHUNK)) { + connector.setForcedChunk(reader.readBoolean()); + } + else if (name.equals(X)) { + connector.setX(reader.readInt32()); + } else if (name.equals(Y)) { + connector.setY(reader.readInt32()); + } else if (name.equals(Z)) { + connector.setZ(reader.readInt32()); + } else if (name.equals(DIMENSION)) { + connector.setDimension(reader.readInt32()); + } + else if (name.equals(ID)) { + connector.setId(reader.readString()); + } else if (name.equals(COUNT)) { + connector.setCount((byte) reader.readInt32()); + } else if (name.equals(DAMAGE)) { + connector.setDamage((short) reader.readInt32()); + } else if (name.equals(TAG)) { + connector.setTag(reader.readString()); + } + } + reader.readEndDocument(); + return connector; + } + + @Override + public void encode(BsonWriter writer, FluxConnectorDTO value, EncoderContext encoderContext) { + writer.writeStartDocument(); + + writer.writeInt32(TYPE, value.getType()); + writer.writeInt32(N_ID, value.getN_id()); + writer.writeInt32(PRIORITY, value.getPriority()); + writer.writeInt32(FOLDER_ID, value.getFolder_id()); + writer.writeInt64(LIMIT, value.getLimit()); + writer.writeString(NAME, value.getName()); + writer.writeBoolean(SURGE, value.getSurge()); + writer.writeBoolean(D_LIMIT, value.getDisableLimit()); + writer.writeBoolean(IS_CHUNK_LOADED, value.getChunkLoaded()); + writer.writeInt64(BUFFER, value.getBuffer()); + writer.writeInt64(CHANGE, value.getChange()); + writer.writeBoolean(FORCED_CHUNK, value.getForcedChunk()); + + writer.writeInt32(X, value.getX()); + writer.writeInt32(Y, value.getY()); + writer.writeInt32(Z, value.getZ()); + writer.writeInt32(DIMENSION, value.getDimension()); + + writer.writeString(ID, value.getId()); + writer.writeInt32(COUNT, value.getCount()); + writer.writeInt32(DAMAGE, value.getDamage()); + writer.writeString(TAG, value.getTag()); + + writer.writeEndDocument(); + } + + @Override + public Class getEncoderClass() { + return FluxConnectorDTO.class; + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodec.java b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodec.java new file mode 100644 index 00000000..90184cc3 --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodec.java @@ -0,0 +1,119 @@ +package sonar.fluxnetworks.common.data.codecs; + +import org.bson.BsonReader; +import org.bson.BsonType; +import org.bson.BsonWriter; +import org.bson.codecs.Codec; +import org.bson.codecs.DecoderContext; +import org.bson.codecs.EncoderContext; +import org.bson.codecs.configuration.CodecRegistry; +import sonar.fluxnetworks.common.data.dto.FluxConnectorDTO; +import sonar.fluxnetworks.common.data.dto.FluxNetworkDTO; +import sonar.fluxnetworks.common.data.dto.NetworkMemberDTO; + +import java.util.ArrayList; +import java.util.UUID; + +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_COLOR; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_ENERGY; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_ID; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_NAME; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_PASSWORD; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_SECURITY; +import static sonar.fluxnetworks.common.data.TagConstants.OWNER_UUID; +import static sonar.fluxnetworks.common.data.TagConstants.PLAYER_LIST; +import static sonar.fluxnetworks.common.data.TagConstants.UNLOADED; +import static sonar.fluxnetworks.common.data.TagConstants.WIRELESS_MODE; + +public class FluxNetworkCodec implements Codec{ + + Codec uuidCodec; + Codec fluxConnectorCodec; + Codec networkMemberCodec; + + public FluxNetworkCodec(CodecRegistry registry) { + this.uuidCodec = registry.get(UUID.class); + this.fluxConnectorCodec = registry.get(FluxConnectorDTO.class); + this.networkMemberCodec = registry.get(NetworkMemberDTO.class); + } + + @Override + public FluxNetworkDTO decode(BsonReader reader, DecoderContext decoderContext) { + FluxNetworkDTO fluxNetworkDTO = new FluxNetworkDTO(); + reader.readStartDocument(); + while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) { + String name = reader.readName(); + if (name.equals(NETWORK_ID)) { + fluxNetworkDTO.setNetworkID(reader.readInt32()); + } else if (name.equals(NETWORK_NAME)) { + fluxNetworkDTO.setNetworkName(reader.readString()); + } else if (name.equals(OWNER_UUID)) { + fluxNetworkDTO.setOwnerUUID(uuidCodec.decode(reader, decoderContext)); + } else if (name.equals(NETWORK_SECURITY)) { + fluxNetworkDTO.setNetworkSecurity(reader.readInt32()); + } else if (name.equals(NETWORK_PASSWORD)) { + fluxNetworkDTO.setNetworkPassword(reader.readString()); + } else if (name.equals(NETWORK_COLOR)) { + fluxNetworkDTO.setNetworkColor(reader.readInt32()); + } else if (name.equals(NETWORK_ENERGY)) { + fluxNetworkDTO.setNetworkEnergy(reader.readInt32()); + } else if (name.equals(WIRELESS_MODE)) { + fluxNetworkDTO.setWirelessMode(reader.readInt32()); + } else if (name.equals(PLAYER_LIST)) { + reader.readStartArray(); + fluxNetworkDTO.setPlayerList(new ArrayList<>()); + while (reader.readBsonType() == BsonType.DOCUMENT) { + fluxNetworkDTO.getPlayerList() + .add(decoderContext.decodeWithChildContext(networkMemberCodec, reader)); + } + reader.readEndArray(); + } else if (name.equals(UNLOADED)) { + reader.readStartArray(); + fluxNetworkDTO.setUnloaded(new ArrayList<>()); + while (reader.readBsonType() == BsonType.DOCUMENT) { + fluxNetworkDTO.getUnloaded() + .add(decoderContext.decodeWithChildContext(fluxConnectorCodec, reader)); + } + reader.readEndArray(); + } + } + reader.readEndDocument(); + return fluxNetworkDTO; + } + + @Override + public void encode(BsonWriter writer, FluxNetworkDTO value, EncoderContext encoderContext) { + writer.writeStartDocument(); + writer.writeInt32(NETWORK_ID, value.getNetworkID()); + writer.writeString(NETWORK_NAME, value.getNetworkName()); + writer.writeName(OWNER_UUID); + uuidCodec.encode(writer, value.getOwnerUUID(), encoderContext); + writer.writeInt32(NETWORK_SECURITY, value.getNetworkSecurity()); + writer.writeString(NETWORK_PASSWORD, value.getNetworkPassword()); + writer.writeInt32(NETWORK_COLOR, value.getNetworkColor()); + writer.writeInt32(NETWORK_ENERGY, value.getNetworkEnergy()); + writer.writeInt32(WIRELESS_MODE, value.getWirelessMode()); + if (value.getPlayerList() != null && !value.getPlayerList().isEmpty()) { + writer.writeName(PLAYER_LIST); + writer.writeStartArray(); + for (NetworkMemberDTO networkMember : value.getPlayerList()) { + networkMemberCodec.encode(writer, networkMember, encoderContext); + } + writer.writeEndArray(); + } + if (value.getUnloaded() != null && !value.getUnloaded().isEmpty()) { + writer.writeName(UNLOADED); + writer.writeStartArray(); + for (FluxConnectorDTO connector : value.getUnloaded()) { + fluxConnectorCodec.encode(writer, connector, encoderContext); + } + writer.writeEndArray(); + } + writer.writeEndDocument(); + } + + @Override + public Class getEncoderClass() { + return FluxNetworkDTO.class; + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodecProvider.java b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodecProvider.java new file mode 100644 index 00000000..ab08d63b --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodecProvider.java @@ -0,0 +1,18 @@ +package sonar.fluxnetworks.common.data.codecs; + +import org.bson.codecs.Codec; +import org.bson.codecs.configuration.CodecProvider; +import org.bson.codecs.configuration.CodecRegistry; +import sonar.fluxnetworks.common.data.dto.FluxNetworkDTO; + +public class FluxNetworkCodecProvider implements CodecProvider { + + @Override + @SuppressWarnings("unchecked") + public Codec get(Class aClass, CodecRegistry registry) { + if (aClass == FluxNetworkDTO.class) { + return (Codec) new FluxNetworkCodec(registry); + } + return null; + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodec.java b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodec.java new file mode 100644 index 00000000..66e56aca --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodec.java @@ -0,0 +1,97 @@ +package sonar.fluxnetworks.common.data.codecs; + +import org.bson.BsonReader; +import org.bson.BsonType; +import org.bson.BsonWriter; +import org.bson.codecs.Codec; +import org.bson.codecs.DecoderContext; +import org.bson.codecs.EncoderContext; +import org.bson.codecs.configuration.CodecRegistry; +import sonar.fluxnetworks.common.data.dto.ChunkPosDTO; +import sonar.fluxnetworks.common.data.dto.FluxNetworkDTO; +import sonar.fluxnetworks.common.data.dto.FluxNetworkDataDTO; + +import java.util.ArrayList; +import java.util.UUID; + +import static sonar.fluxnetworks.common.data.TagConstants.INDEX_FIELD; +import static sonar.fluxnetworks.common.data.TagConstants.LOADED_CHUNKS; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORKS; +import static sonar.fluxnetworks.common.data.TagConstants.UNIQUE_ID; + +public class FluxNetworkDataCodec implements Codec{ + + Codec fluxNetworkCodec; + Codec chunkPosCodec; + Codec uuidCodec; + + public FluxNetworkDataCodec(CodecRegistry registry) { + this.fluxNetworkCodec = registry.get(FluxNetworkDTO.class); + this.chunkPosCodec = registry.get(ChunkPosDTO.class); + this.uuidCodec = registry.get(UUID.class); + } + + @Override + public FluxNetworkDataDTO decode(BsonReader reader, DecoderContext decoderContext) { + FluxNetworkDataDTO fluxNetworkDataDTO = new FluxNetworkDataDTO(); + reader.readStartDocument(); + while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) { + String name = reader.readName(); + if (name.equals(UNIQUE_ID)) { + fluxNetworkDataDTO.setUniqueId(reader.readInt32()); + } else if (name.equals(NETWORKS)) { + reader.readStartArray(); + fluxNetworkDataDTO.setNetworks(new ArrayList<>()); + while (reader.readBsonType() == BsonType.DOCUMENT) { + fluxNetworkDataDTO.getNetworks() + .add(decoderContext.decodeWithChildContext(fluxNetworkCodec, reader)); + } + reader.readEndArray(); + } else if (name.equals(LOADED_CHUNKS)) { + reader.readStartArray(); + fluxNetworkDataDTO.setLoadedChunks(new ArrayList<>()); + while (reader.readBsonType() == BsonType.DOCUMENT) { + fluxNetworkDataDTO.getLoadedChunks() + .add(decoderContext.decodeWithChildContext(chunkPosCodec, reader)); + } + reader.readEndArray(); + } else if (name.equals(INDEX_FIELD)){ + uuidCodec.decode(reader, decoderContext); + } + } + reader.readEndDocument(); + return fluxNetworkDataDTO; + } + + @Override + public void encode(BsonWriter writer, FluxNetworkDataDTO value, EncoderContext encoderContext) { + writer.writeStartDocument(); + writer.writeName(INDEX_FIELD); + uuidCodec.encode(writer, value.getServerID(), encoderContext); + if (value.getUniqueId() != null) { + writer.writeInt32(UNIQUE_ID, value.getUniqueId()); + } + if (value.getNetworks() != null && !value.getNetworks().isEmpty()) { + writer.writeName(NETWORKS); + writer.writeStartArray(); + for (FluxNetworkDTO network : value.getNetworks()) { + fluxNetworkCodec.encode(writer, network, encoderContext); + } + writer.writeEndArray(); + } + if (value.getLoadedChunks() != null && !value.getLoadedChunks().isEmpty()) { + writer.writeName(LOADED_CHUNKS); + writer.writeStartArray(); + for (ChunkPosDTO chunkPos : value.getLoadedChunks()) { + chunkPosCodec.encode(writer, chunkPos, encoderContext); + } + writer.writeEndArray(); + } + writer.writeEndDocument(); + } + + @Override + public Class getEncoderClass() { + return FluxNetworkDataDTO.class; + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodecProvider.java b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodecProvider.java new file mode 100644 index 00000000..e298aa76 --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodecProvider.java @@ -0,0 +1,17 @@ +package sonar.fluxnetworks.common.data.codecs; + +import org.bson.codecs.Codec; +import org.bson.codecs.configuration.CodecProvider; +import org.bson.codecs.configuration.CodecRegistry; +import sonar.fluxnetworks.common.data.dto.FluxNetworkDataDTO; + +public class FluxNetworkDataCodecProvider implements CodecProvider { + @Override + @SuppressWarnings("unchecked") + public Codec get(Class aClass, CodecRegistry registry) { + if (aClass == FluxNetworkDataDTO.class) { + return (Codec) new FluxNetworkDataCodec(registry); + } + return null; + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/codecs/NetworkMemberCodec.java b/src/main/java/sonar/fluxnetworks/common/data/codecs/NetworkMemberCodec.java new file mode 100644 index 00000000..08fcc3c9 --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/codecs/NetworkMemberCodec.java @@ -0,0 +1,58 @@ +package sonar.fluxnetworks.common.data.codecs; + +import org.bson.BsonReader; +import org.bson.BsonType; +import org.bson.BsonWriter; +import org.bson.codecs.Codec; +import org.bson.codecs.DecoderContext; +import org.bson.codecs.EncoderContext; +import org.bson.codecs.configuration.CodecRegistry; +import sonar.fluxnetworks.common.data.dto.NetworkMemberDTO; + +import java.util.UUID; + +import static sonar.fluxnetworks.common.data.TagConstants.CACHED_NAME; +import static sonar.fluxnetworks.common.data.TagConstants.PLAYER_ACCESS; +import static sonar.fluxnetworks.common.data.TagConstants.PLAYER_UUID; + +public class NetworkMemberCodec implements Codec { + + Codec uuidCodec; + + public NetworkMemberCodec(CodecRegistry registry) { + this.uuidCodec = registry.get(UUID.class); + } + + @Override + public NetworkMemberDTO decode(BsonReader reader, DecoderContext decoderContext) { + NetworkMemberDTO networkMember = new NetworkMemberDTO(); + reader.readStartDocument(); + while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) { + String name = reader.readName(); + if (name.equals(PLAYER_UUID)) { + networkMember.setPlayerUUID(uuidCodec.decode(reader, decoderContext)); + } else if (name.equals(CACHED_NAME)) { + networkMember.setCachedName(reader.readString()); + } else if (name.equals(PLAYER_ACCESS)) { + networkMember.setPlayerAccess((byte) reader.readInt32()); + } + } + reader.readEndDocument(); + return networkMember; + } + + @Override + public void encode(BsonWriter writer, NetworkMemberDTO value, EncoderContext encoderContext) { + writer.writeStartDocument(); + writer.writeName(PLAYER_UUID); + uuidCodec.encode(writer, value.getPlayerUUID(), encoderContext); + writer.writeString(CACHED_NAME, value.getCachedName()); + writer.writeInt32(PLAYER_ACCESS, value.getPlayerAccess()); + writer.writeEndDocument(); + } + + @Override + public Class getEncoderClass() { + return NetworkMemberDTO.class; + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/codecs/NetworkMemberCodecProvider.java b/src/main/java/sonar/fluxnetworks/common/data/codecs/NetworkMemberCodecProvider.java new file mode 100644 index 00000000..f686ad2b --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/codecs/NetworkMemberCodecProvider.java @@ -0,0 +1,18 @@ +package sonar.fluxnetworks.common.data.codecs; + +import org.bson.codecs.Codec; +import org.bson.codecs.configuration.CodecProvider; +import org.bson.codecs.configuration.CodecRegistry; +import sonar.fluxnetworks.common.data.dto.NetworkMemberDTO; + +public class NetworkMemberCodecProvider implements CodecProvider { + + @Override + @SuppressWarnings("unchecked") + public Codec get(Class aClass, CodecRegistry registry) { + if (aClass == NetworkMemberDTO.class) { + return (Codec) new NetworkMemberCodec(registry); + } + return null; + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/dto/ChunkPosDTO.java b/src/main/java/sonar/fluxnetworks/common/data/dto/ChunkPosDTO.java new file mode 100644 index 00000000..93b3d4e9 --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/dto/ChunkPosDTO.java @@ -0,0 +1,77 @@ +package sonar.fluxnetworks.common.data.dto; + +import net.minecraft.nbt.NBTTagCompound; +import sonar.fluxnetworks.common.data.TagUtils; + +import java.util.Objects; + +import static sonar.fluxnetworks.common.data.TagConstants.X; +import static sonar.fluxnetworks.common.data.TagConstants.Z; + +public class ChunkPosDTO extends NBTCompatibleDTO { + private static final ChunkPosDTO EMPTY = new ChunkPosDTO(); + + Integer x; + Integer z; + Integer dimension; + + public static ChunkPosDTO fromNBT(NBTTagCompound tag, int dimension) { + ChunkPosDTO dto = new ChunkPosDTO(); + dto.x = TagUtils.intOrNull(tag, X); + dto.z = TagUtils.intOrNull(tag, Z); + dto.dimension = dimension; + return dto.isEmpty() ? null : dto; + } + + public NBTTagCompound toNBT() { + NBTTagCompound tag = new NBTTagCompound(); + TagUtils.fillNBT(tag, X, this.x); + TagUtils.fillNBT(tag, Z, this.z); + return tag; + } + + public boolean isEmpty() { + return this.equals(EMPTY); + } + + public Integer getX() { + return x; + } + + public void setX(Integer x) { + this.x = x; + } + + public Integer getZ() { + return z; + } + + public void setZ(Integer z) { + this.z = z; + } + + public Integer getDimension() { + return dimension; + } + + public void setDimension(Integer dimension) { + this.dimension = dimension; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof ChunkPosDTO)) { + return false; + } + ChunkPosDTO that = (ChunkPosDTO) o; + return Objects.equals(x, that.x) && Objects.equals(z, that.z) && Objects.equals(dimension, that.dimension); + } + + @Override + public int hashCode() { + return Objects.hash(x, z, dimension); + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/dto/FluxConnectorDTO.java b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxConnectorDTO.java new file mode 100644 index 00000000..d00f8e6c --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxConnectorDTO.java @@ -0,0 +1,316 @@ +package sonar.fluxnetworks.common.data.dto; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import sonar.fluxnetworks.common.data.TagUtils; + +import java.util.Objects; + +import static sonar.fluxnetworks.common.data.TagConstants.BUFFER; +import static sonar.fluxnetworks.common.data.TagConstants.CHANGE; +import static sonar.fluxnetworks.common.data.TagConstants.COUNT; +import static sonar.fluxnetworks.common.data.TagConstants.DAMAGE; +import static sonar.fluxnetworks.common.data.TagConstants.DIMENSION; +import static sonar.fluxnetworks.common.data.TagConstants.D_LIMIT; +import static sonar.fluxnetworks.common.data.TagConstants.FOLDER_ID; +import static sonar.fluxnetworks.common.data.TagConstants.FORCED_CHUNK; +import static sonar.fluxnetworks.common.data.TagConstants.ID; +import static sonar.fluxnetworks.common.data.TagConstants.IS_CHUNK_LOADED; +import static sonar.fluxnetworks.common.data.TagConstants.LIMIT; +import static sonar.fluxnetworks.common.data.TagConstants.NAME; +import static sonar.fluxnetworks.common.data.TagConstants.N_ID; +import static sonar.fluxnetworks.common.data.TagConstants.PRIORITY; +import static sonar.fluxnetworks.common.data.TagConstants.SURGE; +import static sonar.fluxnetworks.common.data.TagConstants.TAG; +import static sonar.fluxnetworks.common.data.TagConstants.TYPE; +import static sonar.fluxnetworks.common.data.TagConstants.X; +import static sonar.fluxnetworks.common.data.TagConstants.Y; +import static sonar.fluxnetworks.common.data.TagConstants.Z; + +public class FluxConnectorDTO extends NBTCompatibleDTO { + private static final FluxConnectorDTO EMPTY = new FluxConnectorDTO(); + + Integer type; + Integer n_id; + Integer priority; + Integer folder_id; + Long limit; + String name; + Boolean surge; + Boolean disableLimit; + Boolean isChunkLoaded; + Long buffer; + Long change; + Boolean forcedChunk; + + Integer x; + Integer y; + Integer z; + Integer dimension; + + String id; + Byte Count; + Short Damage; + String tag; + + public void fillWithItemStackNBT(ItemStack stack) { + NBTTagCompound tag = new NBTTagCompound(); + stack.writeToNBT(tag); + } + + public static FluxConnectorDTO fromNBT(NBTTagCompound tag) { + FluxConnectorDTO dto = new FluxConnectorDTO(); + dto.type = TagUtils.intOrNull(tag, TYPE); + dto.n_id = TagUtils.intOrNull(tag, N_ID); + dto.priority = TagUtils.intOrNull(tag, PRIORITY); + dto.folder_id = TagUtils.intOrNull(tag, FOLDER_ID); + dto.limit = TagUtils.longOrNull(tag, LIMIT); + dto.name = TagUtils.stringOrNull(tag, NAME); + dto.disableLimit = TagUtils.booleanOrNull(tag, D_LIMIT); + dto.surge = TagUtils.booleanOrNull(tag, SURGE); + dto.isChunkLoaded = TagUtils.booleanOrNull(tag, IS_CHUNK_LOADED); + dto.buffer = TagUtils.longOrNull(tag, BUFFER); + dto.change = TagUtils.longOrNull(tag, CHANGE); + dto.forcedChunk = TagUtils.booleanOrNull(tag, FORCED_CHUNK); + + dto.x = TagUtils.intOrNull(tag, X); + dto.y = TagUtils.intOrNull(tag, Y); + dto.z = TagUtils.intOrNull(tag, Z); + dto.dimension = TagUtils.intOrNull(tag, DIMENSION); + + dto.id = TagUtils.stringOrNull(tag, ID); + dto.Count = TagUtils.byteOrNull(tag, COUNT); + dto.Damage = TagUtils.shortOrNull(tag, DAMAGE); + dto.tag = tag.getCompoundTag(TAG).toString(); + return dto.isEmpty() ? null : dto; + } + + public NBTTagCompound toNBT() { + NBTTagCompound tag = new NBTTagCompound(); + TagUtils.fillNBT(tag, TYPE, type); + TagUtils.fillNBT(tag, N_ID, n_id); + TagUtils.fillNBT(tag, PRIORITY, priority); + TagUtils.fillNBT(tag, FOLDER_ID, folder_id); + TagUtils.fillNBT(tag, LIMIT, limit); + TagUtils.fillNBT(tag, NAME, name); + TagUtils.fillNBT(tag, SURGE, surge); + TagUtils.fillNBT(tag, D_LIMIT, disableLimit); + TagUtils.fillNBT(tag, IS_CHUNK_LOADED, isChunkLoaded); + TagUtils.fillNBT(tag, BUFFER, buffer); + TagUtils.fillNBT(tag, CHANGE, change); + TagUtils.fillNBT(tag, FORCED_CHUNK, forcedChunk); + + TagUtils.fillNBT(tag, X, x); + TagUtils.fillNBT(tag, Y, y); + TagUtils.fillNBT(tag, Z, z); + TagUtils.fillNBT(tag, DIMENSION, dimension); + + TagUtils.fillNBT(tag, ID, id); + TagUtils.fillNBT(tag, COUNT, Count); + TagUtils.fillNBT(tag, DAMAGE, Damage); + TagUtils.parseNBTFromString(tag, TAG, this.tag); + return tag; + + + } + + public boolean isEmpty() { + return this.equals(EMPTY); + } + + public Integer getType() { + return type; + } + + public void setType(Integer type) { + this.type = type; + } + + public Integer getN_id() { + return n_id; + } + + public void setN_id(Integer n_id) { + this.n_id = n_id; + } + + public Integer getPriority() { + return priority; + } + + public void setPriority(Integer priority) { + this.priority = priority; + } + + public Integer getFolder_id() { + return folder_id; + } + + public void setFolder_id(Integer folder_id) { + this.folder_id = folder_id; + } + + public Long getLimit() { + return limit; + } + + public void setLimit(Long limit) { + this.limit = limit; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Boolean getSurge() { + return surge; + } + + public void setSurge(Boolean surge) { + this.surge = surge; + } + + public Boolean getChunkLoaded() { + return isChunkLoaded; + } + + public void setChunkLoaded(Boolean chunkLoaded) { + isChunkLoaded = chunkLoaded; + } + + public Long getBuffer() { + return buffer; + } + + public void setBuffer(Long buffer) { + this.buffer = buffer; + } + + public Long getChange() { + return change; + } + + public void setChange(Long change) { + this.change = change; + } + + public Boolean getForcedChunk() { + return forcedChunk; + } + + public void setForcedChunk(Boolean forcedChunk) { + this.forcedChunk = forcedChunk; + } + + public Integer getX() { + return x; + } + + public void setX(Integer x) { + this.x = x; + } + + public Integer getY() { + return y; + } + + public void setY(Integer y) { + this.y = y; + } + + public Integer getZ() { + return z; + } + + public void setZ(Integer z) { + this.z = z; + } + + public Integer getDimension() { + return dimension; + } + + public void setDimension(Integer dimension) { + this.dimension = dimension; + } + + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public Byte getCount() { + return Count; + } + + public void setCount(Byte count) { + this.Count = count; + } + + public Short getDamage() { + return Damage; + } + + public void setDamage(Short damage) { + this.Damage = damage; + } + + public Boolean getDisableLimit() { + return disableLimit; + } + + public void setDisableLimit(Boolean disableLimit) { + this.disableLimit = disableLimit; + } + + public String getTag() { + return tag; + } + + public void setTag(String tag) { + this.tag = tag; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof FluxConnectorDTO)) { + return false; + } + FluxConnectorDTO that = (FluxConnectorDTO) o; + return Objects.equals(type, that.type) + && Objects.equals(n_id, that.n_id) + && Objects.equals(priority, that.priority) + && Objects.equals(folder_id, that.folder_id) + && Objects.equals(limit, that.limit) + && Objects.equals(name, that.name) + && Objects.equals(surge, that.surge) + && Objects.equals(isChunkLoaded, that.isChunkLoaded) + && Objects.equals(buffer, that.buffer) + && Objects.equals(change, that.change) + && Objects.equals(forcedChunk, that.forcedChunk) + && Objects.equals(x, that.x) + && Objects.equals(y, that.y) + && Objects.equals(z, that.z) + && Objects.equals(dimension, that.dimension) + && Objects.equals(id, that.id) + && Objects.equals(Count, that.Count) + && Objects.equals(Damage, that.Damage) + && Objects.equals(tag, that.tag); + } + + @Override + public int hashCode() { + return Objects.hash(type, n_id, priority, folder_id, limit, name, surge, isChunkLoaded, buffer, change, + forcedChunk, x, y, z, dimension, id, Count, Damage, tag); + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDTO.java b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDTO.java new file mode 100644 index 00000000..e62c9977 --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDTO.java @@ -0,0 +1,175 @@ +package sonar.fluxnetworks.common.data.dto; + +import net.minecraft.nbt.NBTTagCompound; +import sonar.fluxnetworks.common.data.TagUtils; + +import java.util.List; +import java.util.Objects; +import java.util.UUID; + +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_COLOR; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_ENERGY; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_ID; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_NAME; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_PASSWORD; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORK_SECURITY; +import static sonar.fluxnetworks.common.data.TagConstants.OWNER_UUID; +import static sonar.fluxnetworks.common.data.TagConstants.PLAYER_LIST; +import static sonar.fluxnetworks.common.data.TagConstants.UNLOADED; +import static sonar.fluxnetworks.common.data.TagConstants.WIRELESS_MODE; + +public class FluxNetworkDTO extends NBTCompatibleDTO { + private static final FluxNetworkDTO EMPTY = new FluxNetworkDTO(); + + Integer networkID; + String networkName; + UUID ownerUUID; + Integer networkSecurity; + String networkPassword; + Integer networkColor; + Integer networkEnergy; + Integer wirelessMode; + List playerList; + List unloaded; + + public static FluxNetworkDTO fromNBT(NBTTagCompound tag) { + FluxNetworkDTO dto = new FluxNetworkDTO(); + dto.networkID = TagUtils.intOrNull(tag, NETWORK_ID); + dto.networkName = TagUtils.stringOrNull(tag, NETWORK_NAME); + dto.ownerUUID = TagUtils.uuidOrNull(tag, OWNER_UUID); + dto.networkSecurity = TagUtils.intOrNull(tag, NETWORK_SECURITY); + dto.networkPassword = TagUtils.stringOrNull(tag, NETWORK_PASSWORD); + dto.networkColor = TagUtils.intOrNull(tag, NETWORK_COLOR); + dto.networkEnergy =TagUtils.intOrNull(tag, NETWORK_ENERGY); + dto.wirelessMode = TagUtils.intOrNull(tag, WIRELESS_MODE); + dto.playerList = TagUtils.playerListOrNull(tag, PLAYER_LIST); + dto.unloaded = TagUtils.fluxConnectorListOrNull(tag, UNLOADED); + return dto.isEmpty() ? null : dto; + } + + public NBTTagCompound toNBT() { + NBTTagCompound tag = new NBTTagCompound(); + TagUtils.fillNBT(tag, NETWORK_ID, this.networkID); + TagUtils.fillNBT(tag, NETWORK_NAME, this.networkName); + TagUtils.fillNBT(tag, OWNER_UUID, this.ownerUUID); + TagUtils.fillNBT(tag, NETWORK_SECURITY, this.networkSecurity); + TagUtils.fillNBT(tag, NETWORK_PASSWORD, this.networkPassword); + TagUtils.fillNBT(tag, NETWORK_COLOR, this.networkColor); + TagUtils.fillNBT(tag, NETWORK_ENERGY, this.networkEnergy); + TagUtils.fillNBT(tag, WIRELESS_MODE, this.wirelessMode); + TagUtils.fillNBT(tag, PLAYER_LIST, this.playerList); + TagUtils.fillNBT(tag, UNLOADED, this.unloaded); + return tag; + } + + public boolean isEmpty() { + return this.equals(EMPTY); + } + + public Integer getNetworkID() { + return networkID; + } + + public void setNetworkID(Integer networkID) { + this.networkID = networkID; + } + + public String getNetworkName() { + return networkName; + } + + public void setNetworkName(String networkName) { + this.networkName = networkName; + } + + public UUID getOwnerUUID() { + return ownerUUID; + } + + public void setOwnerUUID(UUID ownerUUID) { + this.ownerUUID = ownerUUID; + } + + public Integer getNetworkSecurity() { + return networkSecurity; + } + + public void setNetworkSecurity(Integer networkSecurity) { + this.networkSecurity = networkSecurity; + } + + public String getNetworkPassword() { + return networkPassword; + } + + public void setNetworkPassword(String networkPassword) { + this.networkPassword = networkPassword; + } + + public Integer getNetworkColor() { + return networkColor; + } + + public void setNetworkColor(Integer networkColor) { + this.networkColor = networkColor; + } + + public Integer getNetworkEnergy() { + return networkEnergy; + } + + public void setNetworkEnergy(Integer networkEnergy) { + this.networkEnergy = networkEnergy; + } + + public Integer getWirelessMode() { + return wirelessMode; + } + + public void setWirelessMode(Integer wirelessMode) { + this.wirelessMode = wirelessMode; + } + + public List getPlayerList() { + return playerList; + } + + public void setPlayerList(List playerList) { + this.playerList = playerList; + } + + public List getUnloaded() { + return unloaded; + } + + public void setUnloaded(List unloaded) { + this.unloaded = unloaded; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof FluxNetworkDTO)) { + return false; + } + FluxNetworkDTO that = (FluxNetworkDTO) o; + return Objects.equals(networkID, that.networkID) + && Objects.equals(networkName, that.networkName) + && Objects.equals(ownerUUID, that.ownerUUID) + && Objects.equals(networkSecurity, that.networkSecurity) + && Objects.equals(networkPassword, that.networkPassword) + && Objects.equals(networkColor, that.networkColor) + && Objects.equals(networkEnergy, that.networkEnergy) + && Objects.equals(wirelessMode, that.wirelessMode) + && Objects.equals(playerList, that.playerList) + && Objects.equals(unloaded, that.unloaded); + } + + @Override + public int hashCode() { + return Objects.hash(networkID, networkName, ownerUUID, networkSecurity, networkPassword, networkColor, + networkEnergy, wirelessMode, playerList, unloaded); + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDataDTO.java b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDataDTO.java new file mode 100644 index 00000000..d8c91357 --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDataDTO.java @@ -0,0 +1,167 @@ +package sonar.fluxnetworks.common.data.dto; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.math.ChunkPos; +import sonar.fluxnetworks.FluxNetworks; +import sonar.fluxnetworks.api.network.IFluxNetwork; +import sonar.fluxnetworks.api.network.NetworkMember; +import sonar.fluxnetworks.api.network.NetworkSettings; +import sonar.fluxnetworks.api.network.SecurityType; +import sonar.fluxnetworks.api.tiles.IFluxConnector; +import sonar.fluxnetworks.api.utils.EnergyType; +import sonar.fluxnetworks.common.connection.FluxLiteConnector; +import sonar.fluxnetworks.common.connection.FluxNetworkServer; +import sonar.fluxnetworks.common.data.FluxNetworkData; +import sonar.fluxnetworks.common.data.TagUtils; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.UUID; + +import static sonar.fluxnetworks.FluxConfig.MONGO_SERVER_ID; +import static sonar.fluxnetworks.common.data.TagConstants.LOADED_CHUNKS; +import static sonar.fluxnetworks.common.data.TagConstants.NETWORKS; +import static sonar.fluxnetworks.common.data.TagConstants.UNIQUE_ID; + +public class FluxNetworkDataDTO { + private static FluxNetworkDataDTO EMPTY = new FluxNetworkDataDTO(); + + List networks; + List loadedChunks; + Integer uniqueId; + UUID serverID; + + public FluxNetworkDataDTO() {} + + public FluxNetworkDataDTO(UUID serverID) { + this.serverID = serverID; + } + + public static FluxNetworkDataDTO fromNBT(NBTTagCompound tag) { + FluxNetworkDataDTO dto = new FluxNetworkDataDTO(); + dto.uniqueId = TagUtils.intOrNull(tag, UNIQUE_ID); + dto.networks = TagUtils.fluxNetworkListOrNull(tag, NETWORKS); + dto.loadedChunks = TagUtils.chunkPosListOrNull(tag, LOADED_CHUNKS); + dto.serverID = MONGO_SERVER_ID; + return dto.isEmpty() ? null : dto; + } + + public NBTTagCompound toNBT() { + NBTTagCompound tag = new NBTTagCompound(); + tag.setInteger(UNIQUE_ID, uniqueId); + TagUtils.fillNBT(tag, NETWORKS, networks); + TagUtils.fillNBT(tag, LOADED_CHUNKS, loadedChunks); + return tag; + } + + public boolean isEmpty() { + return this.equals(EMPTY); + } + + public FluxNetworkData getFluxNetworkData() { + FluxNetworkData data = new FluxNetworkData(); + data.networks = getNetworkMap(); + data.loadedChunks = getLoadedChunksMap(); + data.uniqueID = getUniqueId(); + return data; + } + + public Map getNetworkMap() { + Map map = new HashMap<>(); + if (networks != null) { + for (FluxNetworkDTO dto : networks) { + FluxNetworkServer fluxNetwork = new FluxNetworkServer( + dto.networkID, + dto.networkName, + SecurityType.values()[dto.networkSecurity], + dto.networkColor, + dto.ownerUUID, + EnergyType.values()[dto.networkEnergy], + dto.networkPassword + ); + fluxNetwork.network_wireless.setValue(dto.wirelessMode); + if (dto.playerList != null && !dto.playerList.isEmpty()) { + List playerList = new ArrayList<>(); + for (NetworkMemberDTO networkMemberDTO : dto.playerList) { + playerList.add(new NetworkMember(networkMemberDTO)); + } + fluxNetwork.setSetting(NetworkSettings.NETWORK_PLAYERS, playerList); + } + + if (dto.unloaded != null && !dto.unloaded.isEmpty()) { + List unloaded = new ArrayList<>(); + for (FluxConnectorDTO fluxConnectorDTO : dto.unloaded) { + unloaded.add(new FluxLiteConnector(fluxConnectorDTO)); + } + fluxNetwork.setSetting(NetworkSettings.ALL_CONNECTORS, unloaded); + } + + map.put(dto.networkID, fluxNetwork); + } + } + return map; + } + + public Map> getLoadedChunksMap() { + Map> map = new HashMap<>(); + if (loadedChunks != null) { + for (ChunkPosDTO chunkPosDTO : loadedChunks) { + if (!map.containsKey(chunkPosDTO.dimension)) { + map.put(chunkPosDTO.dimension, new ArrayList<>()); + } + map.get(chunkPosDTO.dimension).add(new ChunkPos(chunkPosDTO.x, chunkPosDTO.z)); + } + } + return map; + } + + public List getNetworks() { + return networks; + } + + public void setNetworks(List networks) { + this.networks = networks; + } + + public Integer getUniqueId() { + return uniqueId; + } + + public void setUniqueId(Integer uniqueId) { + this.uniqueId = uniqueId; + } + + public List getLoadedChunks() { + return loadedChunks; + } + + public void setLoadedChunks(List loadedChunks) { + this.loadedChunks = loadedChunks; + } + + public UUID getServerID() { + return serverID; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof FluxNetworkDataDTO)) { + return false; + } + FluxNetworkDataDTO that = (FluxNetworkDataDTO) o; + return Objects.equals(networks, that.networks) + && Objects.equals(loadedChunks, that.loadedChunks) + && Objects.equals(uniqueId, that.uniqueId); + } + + @Override + public int hashCode() { + return Objects.hash(networks, loadedChunks, uniqueId); + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/dto/NBTCompatibleDTO.java b/src/main/java/sonar/fluxnetworks/common/data/dto/NBTCompatibleDTO.java new file mode 100644 index 00000000..ee2fe7d6 --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/dto/NBTCompatibleDTO.java @@ -0,0 +1,35 @@ +package sonar.fluxnetworks.common.data.dto; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; + +import java.util.ArrayList; +import java.util.List; + +public abstract class NBTCompatibleDTO { + public static T fromNBT(NBTTagCompound tag) { + return null; + } + + public abstract NBTTagCompound toNBT(); + + static List fromNBTList(NBTTagCompound tag, String key) { + List dtoList = new ArrayList<>(); + if (tag.hasKey(key)) { + NBTTagList nbtTagList = tag.getTagList(key, 10); + for (int i = 0; i < nbtTagList.tagCount(); i++) { + dtoList.add(fromNBT(nbtTagList.getCompoundTagAt(i))); + } + } + return dtoList.isEmpty() ? null : dtoList; + } + + static void fillNBT(NBTTagCompound tag, String key, List> value) { + if (value != null) { + NBTTagList nbtTagList = new NBTTagList(); + for (NBTCompatibleDTO dto : value) { + nbtTagList.appendTag(dto.toNBT()); + } + } + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/data/dto/NetworkMemberDTO.java b/src/main/java/sonar/fluxnetworks/common/data/dto/NetworkMemberDTO.java new file mode 100644 index 00000000..3769a4f4 --- /dev/null +++ b/src/main/java/sonar/fluxnetworks/common/data/dto/NetworkMemberDTO.java @@ -0,0 +1,82 @@ +package sonar.fluxnetworks.common.data.dto; + +import net.minecraft.nbt.NBTTagCompound; +import sonar.fluxnetworks.common.data.TagUtils; + +import java.util.Objects; +import java.util.UUID; + +import static sonar.fluxnetworks.common.data.TagConstants.CACHED_NAME; +import static sonar.fluxnetworks.common.data.TagConstants.PLAYER_ACCESS; +import static sonar.fluxnetworks.common.data.TagConstants.PLAYER_UUID; + +public class NetworkMemberDTO extends NBTCompatibleDTO { + private static final NetworkMemberDTO EMPTY = new NetworkMemberDTO(); + + UUID playerUUID; + String cachedName; + Byte playerAccess; + + public static NetworkMemberDTO fromNBT(NBTTagCompound tag) { + NetworkMemberDTO dto = new NetworkMemberDTO(); + dto.playerUUID = tag.getUniqueId(PLAYER_UUID); + dto.cachedName = tag.getString(CACHED_NAME); + dto.playerAccess = tag.getByte(PLAYER_ACCESS); + return dto.isEmpty() ? null : dto; + } + + public NBTTagCompound toNBT() { + NBTTagCompound tag = new NBTTagCompound(); + TagUtils.fillNBT(tag, PLAYER_UUID, playerUUID); + TagUtils.fillNBT(tag, CACHED_NAME, cachedName); + TagUtils.fillNBT(tag, PLAYER_ACCESS, playerAccess); + return tag; + } + + public boolean isEmpty() { + return this.equals(EMPTY); + } + + public UUID getPlayerUUID() { + return playerUUID; + } + + public void setPlayerUUID(UUID playerUUID) { + this.playerUUID = playerUUID; + } + + public String getCachedName() { + return cachedName; + } + + public void setCachedName(String cachedName) { + this.cachedName = cachedName; + } + + public Byte getPlayerAccess() { + return playerAccess; + } + + public void setPlayerAccess(Byte playerAccess) { + this.playerAccess = playerAccess; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof NetworkMemberDTO)) { + return false; + } + NetworkMemberDTO that = (NetworkMemberDTO) o; + return Objects.equals(playerUUID, that.playerUUID) + && Objects.equals(cachedName, that.cachedName) + && Objects.equals(playerAccess, that.playerAccess); + } + + @Override + public int hashCode() { + return Objects.hash(playerUUID, cachedName, playerAccess); + } +} diff --git a/src/main/java/sonar/fluxnetworks/common/tileentity/energy/TileIC2Energy.java b/src/main/java/sonar/fluxnetworks/common/tileentity/energy/TileIC2Energy.java index 088bbbe2..932fcf0d 100644 --- a/src/main/java/sonar/fluxnetworks/common/tileentity/energy/TileIC2Energy.java +++ b/src/main/java/sonar/fluxnetworks/common/tileentity/energy/TileIC2Energy.java @@ -52,6 +52,7 @@ public void onChunkUnload() { } @Override + @Optional.Method(modid = "ic2") public void update() { super.update(); if (!IC2Connected) { From cb7f2fdb6c60d4606c6537de55b8349eb33a629a Mon Sep 17 00:00:00 2001 From: Alex Emelyanov Date: Wed, 12 Jun 2024 20:43:02 +0300 Subject: [PATCH 2/3] Initial work on storing in the db --- .../java/sonar/fluxnetworks/common/data/TagUtils.java | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/main/java/sonar/fluxnetworks/common/data/TagUtils.java b/src/main/java/sonar/fluxnetworks/common/data/TagUtils.java index ffdd860c..4c4ab789 100644 --- a/src/main/java/sonar/fluxnetworks/common/data/TagUtils.java +++ b/src/main/java/sonar/fluxnetworks/common/data/TagUtils.java @@ -76,10 +76,13 @@ public static List fluxNetworkListOrNull(NBTTagCompound tag, Str public static List chunkPosListOrNull(NBTTagCompound tag, String key) { List dtoList = new ArrayList<>(); if (tag.hasKey(key)) { - NBTTagList nbtTagList = tag.getTagList(key, 10); - for (int i = 0; i < nbtTagList.tagCount(); i++) { - dtoList.add(ChunkPosDTO.fromNBT(nbtTagList.getCompoundTagAt(i))); - } + NBTTagCompound chunksTag = tag.getCompoundTag(key); + chunksTag.getKeySet().forEach(dim -> { + NBTTagList nbtTagList = chunksTag.getTagList(dim, 10); + for (int i = 0; i < nbtTagList.tagCount(); i++) { + dtoList.add(ChunkPosDTO.fromNBT(nbtTagList.getCompoundTagAt(i), Integer.parseInt(dim))); + } + }); } return dtoList.isEmpty() ? null : dtoList; } From 9e41cb9040ff6fd082344c5c164f8ea21fd84fda Mon Sep 17 00:00:00 2001 From: Dertiende <47276572+Dertiende@users.noreply.github.com> Date: Sat, 21 Sep 2024 17:01:27 +0300 Subject: [PATCH 3/3] Cast network id to long for storing server id --- .../api/network/IFluxNetwork.java | 2 +- .../api/network/INetworkConnector.java | 2 +- .../api/network/NetworkSettings.java | 2 +- .../api/utils/FluxConfigurationType.java | 4 +- .../fluxnetworks/client/ClientProxy.java | 2 +- .../fluxnetworks/client/FluxColorHandler.java | 22 +-- .../client/gui/GuiFluxConfiguratorHome.java | 4 +- .../client/gui/basic/GuiFluxCore.java | 2 +- .../fluxnetworks/common/CommonProxy.java | 10 +- .../common/connection/FluxLiteConnector.java | 10 +- .../common/connection/FluxNetworkBase.java | 8 +- .../common/connection/FluxNetworkCache.java | 16 +- .../common/connection/FluxNetworkServer.java | 2 +- .../common/data/FluxNetworkData.java | 14 +- .../data/codecs/FluxConnectorCodec.java | 4 +- .../common/data/codecs/FluxNetworkCodec.java | 4 +- .../data/codecs/FluxNetworkDataCodec.java | 4 +- .../common/data/dto/FluxConnectorDTO.java | 8 +- .../common/data/dto/FluxNetworkDTO.java | 8 +- .../common/data/dto/FluxNetworkDataDTO.java | 16 +- .../common/item/ItemAdminConfigurator.java | 2 +- .../common/item/ItemConfigurator.java | 10 +- .../common/network/PacketBatchEditing.java | 8 +- .../common/network/PacketColorCache.java | 8 +- .../common/network/PacketColorRequest.java | 12 +- .../network/PacketConnectionUpdate.java | 8 +- .../PacketConnectionUpdateRequest.java | 8 +- .../common/network/PacketGeneralHandler.java | 173 +++++++++--------- .../common/network/PacketNetworkUpdate.java | 15 +- .../network/PacketNetworkUpdateRequest.java | 10 +- .../network/PacketPermissionRequest.java | 8 +- .../network/PacketSetConfiguratorNetwork.java | 10 +- .../common/network/PacketTileHandler.java | 6 +- .../common/registry/RegistryRecipes.java | 7 +- .../common/tileentity/TileFluxCore.java | 12 +- .../common/tileentity/TileFluxStorage.java | 2 +- 36 files changed, 232 insertions(+), 211 deletions(-) diff --git a/src/main/java/sonar/fluxnetworks/api/network/IFluxNetwork.java b/src/main/java/sonar/fluxnetworks/api/network/IFluxNetwork.java index 88e5b180..ec5ad047 100644 --- a/src/main/java/sonar/fluxnetworks/api/network/IFluxNetwork.java +++ b/src/main/java/sonar/fluxnetworks/api/network/IFluxNetwork.java @@ -12,7 +12,7 @@ public interface IFluxNetwork { - default int getNetworkID() { + default long getNetworkID() { return getSetting(NetworkSettings.NETWORK_ID); } diff --git a/src/main/java/sonar/fluxnetworks/api/network/INetworkConnector.java b/src/main/java/sonar/fluxnetworks/api/network/INetworkConnector.java index f8d32943..40fd6289 100644 --- a/src/main/java/sonar/fluxnetworks/api/network/INetworkConnector.java +++ b/src/main/java/sonar/fluxnetworks/api/network/INetworkConnector.java @@ -5,7 +5,7 @@ ///refers to anything which can be connected to a specific network, flux tiles & configurators public interface INetworkConnector { - int getNetworkID(); + long getNetworkID(); IFluxNetwork getNetwork(); diff --git a/src/main/java/sonar/fluxnetworks/api/network/NetworkSettings.java b/src/main/java/sonar/fluxnetworks/api/network/NetworkSettings.java index df40fd29..820e638b 100644 --- a/src/main/java/sonar/fluxnetworks/api/network/NetworkSettings.java +++ b/src/main/java/sonar/fluxnetworks/api/network/NetworkSettings.java @@ -12,7 +12,7 @@ ///TODO remove common references public class NetworkSettings { - public static final NetworkSettings NETWORK_ID = new NetworkSettings<>(s -> s.network_id); + public static final NetworkSettings NETWORK_ID = new NetworkSettings<>(s -> s.network_id); public static final NetworkSettings NETWORK_NAME = new NetworkSettings<>(s -> s.network_name); public static final NetworkSettings NETWORK_SECURITY = new NetworkSettings<>(s -> s.network_security); public static final NetworkSettings NETWORK_PASSWORD = new NetworkSettings<>(s -> s.network_password); diff --git a/src/main/java/sonar/fluxnetworks/api/utils/FluxConfigurationType.java b/src/main/java/sonar/fluxnetworks/api/utils/FluxConfigurationType.java index b6540b9e..6b593e0a 100644 --- a/src/main/java/sonar/fluxnetworks/api/utils/FluxConfigurationType.java +++ b/src/main/java/sonar/fluxnetworks/api/utils/FluxConfigurationType.java @@ -35,12 +35,12 @@ public String getNBTName() { public static void copyNetwork(NBTTagCompound nbt, String key, TileFluxCore tile) { if (!tile.getNetwork().isInvalid() && tile.getNetworkID() != -1) { - nbt.setInteger(key, tile.getNetworkID()); + nbt.setLong(key, tile.getNetworkID()); } } public static void pasteNetwork(NBTTagCompound nbt, String key, TileFluxCore tile) { - int storedID = nbt.getInteger(key); + long storedID = nbt.getLong(key); if (storedID != -1) { IFluxNetwork newNetwork = FluxNetworkCache.instance.getNetwork(storedID); tile.getNetwork().queueConnectionRemoval(tile, false); diff --git a/src/main/java/sonar/fluxnetworks/client/ClientProxy.java b/src/main/java/sonar/fluxnetworks/client/ClientProxy.java index be31d8ee..9232dfa9 100644 --- a/src/main/java/sonar/fluxnetworks/client/ClientProxy.java +++ b/src/main/java/sonar/fluxnetworks/client/ClientProxy.java @@ -117,7 +117,7 @@ public void setFeedback(EnumFeedbackInfo info, boolean operation) { } @Override - public void receiveColorCache(Map> cache) { + public void receiveColorCache(Map> cache) { FluxColorHandler.receiveCache(cache); } diff --git a/src/main/java/sonar/fluxnetworks/client/FluxColorHandler.java b/src/main/java/sonar/fluxnetworks/client/FluxColorHandler.java index 6cd28306..e2d050cc 100644 --- a/src/main/java/sonar/fluxnetworks/client/FluxColorHandler.java +++ b/src/main/java/sonar/fluxnetworks/client/FluxColorHandler.java @@ -38,10 +38,10 @@ public class FluxColorHandler implements IBlockColor, IItemColor { public static final int DEFAULT_COLOR = FluxUtils.getIntFromColor(41, 94, 138); public static final int NO_NETWORK_COLOR = FluxUtils.getIntFromColor(178, 178, 178); - public static final Map colorCache = new HashMap<>(); - public static final Map nameCache = new HashMap<>(); - private static final List requests = new ArrayList<>(); - private static final List sent_requests = new ArrayList<>(); + public static final Map colorCache = new HashMap<>(); + public static final Map nameCache = new HashMap<>(); + private static final List requests = new ArrayList<>(); + private static final List sent_requests = new ArrayList<>(); public static void reset() { colorCache.clear(); @@ -49,25 +49,25 @@ public static void reset() { requests.clear(); } - public static void loadColorCache(int id, int color) { + public static void loadColorCache(long id, int color) { if (id != -1) { colorCache.put(id, color); } } - public static void loadNameCache(int id, String name) { + public static void loadNameCache(long id, String name) { if (id != -1) { nameCache.put(id, name); } } - public static void placeRequest(int id) { + public static void placeRequest(long id) { if (id != -1 && !requests.contains(id) && !sent_requests.contains(id)) { requests.add(id); } } - public static int getOrRequestNetworkColor(int id) { + public static int getOrRequestNetworkColor(long id) { if (id == -1) { return NO_NETWORK_COLOR; } @@ -79,7 +79,7 @@ public static int getOrRequestNetworkColor(int id) { return NO_NETWORK_COLOR; } - public static String getOrRequestNetworkName(int id) { + public static String getOrRequestNetworkName(long id) { if (id == -1) { return "NONE"; } @@ -105,7 +105,7 @@ public static void sendRequests() { } } - public static void receiveCache(Map> cache) { + public static void receiveCache(Map> cache) { cache.forEach((ID, DETAILS) -> { loadColorCache(ID, DETAILS.getFirst()); loadNameCache(ID, DETAILS.getSecond()); @@ -160,7 +160,7 @@ public static int colorMultiplierForConfigurator(ItemStack stack, int tintIndex) } NBTTagCompound tag = stack.getSubCompound(FluxUtils.CONFIGS_TAG); if (tag != null) { - return getOrRequestNetworkColor(tag.getInteger(FluxConfigurationType.NETWORK.getNBTName())); + return getOrRequestNetworkColor(tag.getLong(FluxConfigurationType.NETWORK.getNBTName())); } return NO_NETWORK_COLOR; } diff --git a/src/main/java/sonar/fluxnetworks/client/gui/GuiFluxConfiguratorHome.java b/src/main/java/sonar/fluxnetworks/client/gui/GuiFluxConfiguratorHome.java index 6a082a9d..0ad7a83d 100644 --- a/src/main/java/sonar/fluxnetworks/client/gui/GuiFluxConfiguratorHome.java +++ b/src/main/java/sonar/fluxnetworks/client/gui/GuiFluxConfiguratorHome.java @@ -131,7 +131,7 @@ public void onButtonClicked(GuiButtonCore button, int mouseX, int mouseY, int mo if (button == apply) { ///send changes to server. NBTTagCompound tag = new NBTTagCompound(); - tag.setInteger(FluxConfigurationType.NETWORK.getNBTName(), network.getNetworkID()); + tag.setLong(FluxConfigurationType.NETWORK.getNBTName(), network.getNetworkID()); tag.setInteger(FluxConfigurationType.PRIORITY.getNBTName(), stackPriority); tag.setLong(FluxConfigurationType.TRANSFER.getNBTName(), stackLimit); tag.setBoolean(FluxConfigurationType.PRIORITY_SETTING.getNBTName(), stackSurgeMode); @@ -169,7 +169,7 @@ public void onSettingsChanged() { apply.clickable = true; } else { apply.clickable = - network.getNetworkID() != configTag.getInteger(FluxConfigurationType.NETWORK.getNBTName()) || + network.getNetworkID() != configTag.getLong(FluxConfigurationType.NETWORK.getNBTName()) || stackPriority != configTag.getInteger(FluxConfigurationType.PRIORITY.getNBTName()) || stackLimit != configTag.getLong(FluxConfigurationType.TRANSFER.getNBTName()) || stackSurgeMode != configTag.getBoolean(FluxConfigurationType.PRIORITY_SETTING.getNBTName()) || diff --git a/src/main/java/sonar/fluxnetworks/client/gui/basic/GuiFluxCore.java b/src/main/java/sonar/fluxnetworks/client/gui/basic/GuiFluxCore.java index a2e890bf..63db1374 100644 --- a/src/main/java/sonar/fluxnetworks/client/gui/basic/GuiFluxCore.java +++ b/src/main/java/sonar/fluxnetworks/client/gui/basic/GuiFluxCore.java @@ -179,7 +179,7 @@ protected List getFluxInfo(IFluxConnector flux) { public void onSuperAdminChanged() { } - public void setConnectedNetwork(int networkID, String password) { + public void setConnectedNetwork(long networkID, String password) { if (connector instanceof IFluxConnector) { PacketHandler.network.sendToServer(new PacketTile.TileMessage(PacketTileType.SET_NETWORK, PacketTileHandler.getSetNetworkPacket(networkID, password), ((IFluxConnector) connector).getCoords().getPos(), ((IFluxConnector) connector).getCoords().getDimension())); } diff --git a/src/main/java/sonar/fluxnetworks/common/CommonProxy.java b/src/main/java/sonar/fluxnetworks/common/CommonProxy.java index f66aa6a7..c15e27fd 100644 --- a/src/main/java/sonar/fluxnetworks/common/CommonProxy.java +++ b/src/main/java/sonar/fluxnetworks/common/CommonProxy.java @@ -65,7 +65,7 @@ public class CommonProxy { public boolean baublesLoaded; public boolean ocLoaded; - public int admin_viewing_network_id = -1; + public long admin_viewing_network_id = -1; public boolean detailed_network_view; public IFluxNetwork admin_viewing_network = FluxNetworkInvalid.instance; @@ -192,7 +192,11 @@ public void onServerTick(TickEvent.ServerTickEvent event) { public void onPlayerJoined(PlayerEvent.PlayerLoggedInEvent event) { EntityPlayer player = event.player; if (!player.world.isRemote) { - PacketHandler.network.sendTo(new PacketNetworkUpdate.NetworkUpdateMessage(new ArrayList<>(FluxNetworkCache.instance.getAllNetworks()), NBTType.NETWORK_GENERAL), (EntityPlayerMP) player); + PacketNetworkUpdate.NetworkUpdateMessage networkUpdateMessage = + new PacketNetworkUpdate.NetworkUpdateMessage( + FluxNetworkCache.instance.getAllNetworksAsList(), NBTType.NETWORK_GENERAL + ); + PacketHandler.network.sendTo(networkUpdateMessage, (EntityPlayerMP) player); PacketHandler.network.sendTo(new PacketSuperAdmin.SuperAdminMessage(DefaultSuperAdmin.isPlayerSuperAdmin(player)), (EntityPlayerMP) player); } } @@ -218,7 +222,7 @@ public EnumFeedbackInfo getFeedback(boolean operation) { public void setFeedback(EnumFeedbackInfo info, boolean operation) { } - public void receiveColorCache(Map> cache) { + public void receiveColorCache(Map> cache) { } public EntityPlayer getPlayer(MessageContext ctx) { diff --git a/src/main/java/sonar/fluxnetworks/common/connection/FluxLiteConnector.java b/src/main/java/sonar/fluxnetworks/common/connection/FluxLiteConnector.java index 63e6cf63..081f2f18 100644 --- a/src/main/java/sonar/fluxnetworks/common/connection/FluxLiteConnector.java +++ b/src/main/java/sonar/fluxnetworks/common/connection/FluxLiteConnector.java @@ -32,7 +32,7 @@ public class FluxLiteConnector implements IFluxConnector { - public int networkID; + public long networkID; public int priority; public UUID playerUUID; public ConnectionType connectionType; @@ -99,7 +99,7 @@ public FluxLiteConnector(NBTTagCompound tag) { public static NBTTagCompound writeCustomNBT(IFluxConnector tile, NBTTagCompound tag) { tile.getCoords().write(tag); tag.setInteger(TYPE, tile.getConnectionType().ordinal()); - tag.setInteger(N_ID, tile.getNetworkID()); + tag.setLong(N_ID, tile.getNetworkID()); tag.setInteger(PRIORITY, tile.getRawPriority()); tag.setInteger(FOLDER_ID, tile.getFolderID()); tag.setLong(LIMIT, tile.getRawLimit()); @@ -118,7 +118,7 @@ public static NBTTagCompound writeCustomNBT(IFluxConnector tile, NBTTagCompound public NBTTagCompound writeCustomNBT(NBTTagCompound tag, NBTType type) { coord4D.write(tag); tag.setInteger(TYPE, connectionType.ordinal()); - tag.setInteger(N_ID, networkID); + tag.setLong(N_ID, networkID); tag.setInteger(PRIORITY, priority); tag.setInteger(FOLDER_ID, folderID); tag.setLong(LIMIT, limit); @@ -137,7 +137,7 @@ public NBTTagCompound writeCustomNBT(NBTTagCompound tag, NBTType type) { public void readCustomNBT(NBTTagCompound tag, NBTType type) { coord4D = new Coord4D(tag); connectionType = ConnectionType.values()[tag.getInteger(TYPE)]; - networkID = tag.getInteger(N_ID); + networkID = tag.getLong(N_ID); priority = tag.getInteger(PRIORITY); folderID = tag.getInteger(FOLDER_ID); limit = tag.getLong(LIMIT); @@ -152,7 +152,7 @@ public void readCustomNBT(NBTTagCompound tag, NBTType type) { } @Override - public int getNetworkID() { + public long getNetworkID() { return networkID; } diff --git a/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkBase.java b/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkBase.java index ff7685ba..d06a37ab 100644 --- a/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkBase.java +++ b/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkBase.java @@ -15,7 +15,7 @@ public abstract class FluxNetworkBase implements IFluxNetwork { - public ICustomValue network_id = new CustomValue<>(); + public ICustomValue network_id = new CustomValue<>(); public ICustomValue network_name = new CustomValue<>(); public ICustomValue network_owner = new CustomValue<>(); public ICustomValue network_security = new CustomValue<>(); @@ -31,7 +31,7 @@ public abstract class FluxNetworkBase implements IFluxNetwork { public FluxNetworkBase() { } - public FluxNetworkBase(int id, String name, SecurityType security, int color, UUID owner, EnergyType energy, String password) { + public FluxNetworkBase(long id, String name, SecurityType security, int color, UUID owner, EnergyType energy, String password) { network_id.setValue(id); network_name.setValue(name); network_security.setValue(security); @@ -54,7 +54,7 @@ public void setSetting(NetworkSettings settings, T value) { @Override public void readNetworkNBT(NBTTagCompound nbt, NBTType type) { if (type == NBTType.NETWORK_GENERAL || type == NBTType.ALL_SAVE) { - network_id.setValue(nbt.getInteger(FluxNetworkData.NETWORK_ID)); + network_id.setValue(nbt.getLong(FluxNetworkData.NETWORK_ID)); network_name.setValue(nbt.getString(FluxNetworkData.NETWORK_NAME)); network_owner.setValue(nbt.getUniqueId(FluxNetworkData.OWNER_UUID)); network_security.setValue(SecurityType.values()[nbt.getInteger(FluxNetworkData.SECURITY_TYPE)]); @@ -84,7 +84,7 @@ public void readNetworkNBT(NBTTagCompound nbt, NBTType type) { @Override public void writeNetworkNBT(NBTTagCompound nbt, NBTType type) { if (type == NBTType.NETWORK_GENERAL || type == NBTType.ALL_SAVE) { - nbt.setInteger(FluxNetworkData.NETWORK_ID, network_id.getValue()); + nbt.setLong(FluxNetworkData.NETWORK_ID, network_id.getValue()); nbt.setString(FluxNetworkData.NETWORK_NAME, network_name.getValue()); nbt.setUniqueId(FluxNetworkData.OWNER_UUID, network_owner.getValue()); nbt.setInteger(FluxNetworkData.SECURITY_TYPE, network_security.getValue().ordinal()); diff --git a/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkCache.java b/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkCache.java index fc1e6e42..029b9583 100644 --- a/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkCache.java +++ b/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkCache.java @@ -23,7 +23,7 @@ public class FluxNetworkCache { /** * Client Cache **/ - public Map networks = new HashMap<>(); + public Map networks = new HashMap<>(); public boolean superAdminClient = false; public void clearNetworks() { @@ -55,14 +55,14 @@ public IFluxNetwork createdNetwork(EntityPlayer player, String name, int color, return network; } - private int getUniqueID() { + private Long getUniqueID() { return FluxNetworkData.get().uniqueID++; } /** * Client Only **/ - public void updateClientFromPacket(Map serverSideNetworks, NBTType type) { + public void updateClientFromPacket(Map serverSideNetworks, NBTType type) { serverSideNetworks.forEach((i, n) -> { IFluxNetwork network = networks.get(i); if (type == NBTType.NETWORK_CLEAR) { @@ -81,7 +81,7 @@ public void updateClientFromPacket(Map serverSideNetwor }); } - public void updateClientConnections(int networkID, List tags) { + public void updateClientConnections(long networkID, List tags) { IFluxNetwork network = networks.get(networkID); if (network != null) { List connectors = network.getSetting(NetworkSettings.ALL_CONNECTORS); @@ -95,7 +95,7 @@ public void updateClientConnections(int networkID, List tags) { /** * Server Only **/ - public IFluxNetwork getNetwork(int id) { + public IFluxNetwork getNetwork(long id) { return FluxNetworkData.get().networks.getOrDefault(id, FluxNetworkInvalid.instance); } @@ -106,10 +106,14 @@ public Collection getAllNetworks() { return FluxNetworkData.get().networks.values(); } + public List getAllNetworksAsList() { + return new ArrayList<>(FluxNetworkData.get().networks.values()); + } + /** * Client Only **/ - public IFluxNetwork getClientNetwork(int id) { + public IFluxNetwork getClientNetwork(long id) { return networks.getOrDefault(id, FluxNetworkInvalid.instance); } diff --git a/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkServer.java b/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkServer.java index 23b0bb0b..6881cc5e 100644 --- a/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkServer.java +++ b/src/main/java/sonar/fluxnetworks/common/connection/FluxNetworkServer.java @@ -40,7 +40,7 @@ public FluxNetworkServer() { super(); } - public FluxNetworkServer(int id, String name, SecurityType security, int color, UUID owner, EnergyType energy, String password) { + public FluxNetworkServer(Long id, String name, SecurityType security, int color, UUID owner, EnergyType energy, String password) { super(id, name, security, color, owner, energy, password); } diff --git a/src/main/java/sonar/fluxnetworks/common/data/FluxNetworkData.java b/src/main/java/sonar/fluxnetworks/common/data/FluxNetworkData.java index 39f1164c..7fae6ca0 100644 --- a/src/main/java/sonar/fluxnetworks/common/data/FluxNetworkData.java +++ b/src/main/java/sonar/fluxnetworks/common/data/FluxNetworkData.java @@ -78,10 +78,10 @@ public class FluxNetworkData extends WorldSavedData { public static String OLD_NETWORK_COLOR = "colour"; public static String OLD_NETWORK_ACCESS = "access"; - public Map networks = new HashMap<>(); + public Map networks = new HashMap<>(); public Map> loadedChunks = new HashMap<>(); // Forced Chunks - public int uniqueID = 1; + public long uniqueID = 1; public FluxNetworkData(String name) { super(name); @@ -146,18 +146,18 @@ private static void loadData() { public void addNetwork(IFluxNetwork network) { networks.putIfAbsent(network.getNetworkID(), network); - PacketHandler.network.sendToAll(new PacketNetworkUpdate.NetworkUpdateMessage(Lists.newArrayList(network), NBTType.NETWORK_GENERAL)); + PacketHandler.network.sendToAll(new PacketNetworkUpdate.NetworkUpdateMessage(network, NBTType.NETWORK_GENERAL)); } public void removeNetwork(IFluxNetwork network) { - PacketHandler.network.sendToAll(new PacketNetworkUpdate.NetworkUpdateMessage(Lists.newArrayList(network), NBTType.NETWORK_CLEAR)); + PacketHandler.network.sendToAll(new PacketNetworkUpdate.NetworkUpdateMessage(network, NBTType.NETWORK_CLEAR)); network.onRemoved(); networks.remove(network.getNetworkID()); } @Override public void readFromNBT(NBTTagCompound nbt) { - uniqueID = nbt.getInteger(UNIQUE_ID); + uniqueID = nbt.getLong(UNIQUE_ID); if (nbt.hasKey(NETWORKS)) { NBTTagList list = nbt.getTagList(NETWORKS, Constants.NBT.TAG_COMPOUND); for (int i = 0; i < list.tagCount(); i++) { @@ -177,7 +177,7 @@ public void readFromNBT(NBTTagCompound nbt) { @Override public NBTTagCompound writeToNBT(NBTTagCompound compound) { - compound.setInteger(UNIQUE_ID, uniqueID); + compound.setLong(UNIQUE_ID, uniqueID); NBTTagList list = new NBTTagList(); for (IFluxNetwork network : FluxNetworkCache.instance.getAllNetworks()) { @@ -321,7 +321,7 @@ private NBTTagCompound writeChunks(int dim, List pos, NBTTagCompound n } private static void readOldData(FluxNetworkBase network, NBTTagCompound nbt) { - network.network_id.setValue(nbt.getInteger(FluxNetworkData.OLD_NETWORK_ID)); + network.network_id.setValue(nbt.getLong(FluxNetworkData.OLD_NETWORK_ID)); network.network_name.setValue(nbt.getString(FluxNetworkData.OLD_NETWORK_NAME)); NBTTagCompound color = nbt.getCompoundTag(FluxNetworkData.OLD_NETWORK_COLOR); network.network_color.setValue(color.getInteger("red") << 16 | color.getInteger("green") << 8 | color.getInteger("blue")); diff --git a/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxConnectorCodec.java b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxConnectorCodec.java index 3a50e4a5..9a4193e0 100644 --- a/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxConnectorCodec.java +++ b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxConnectorCodec.java @@ -39,7 +39,7 @@ public FluxConnectorDTO decode(BsonReader reader, DecoderContext decoderContext) if (name.equals(TYPE)) { connector.setType(reader.readInt32()); } else if (name.equals(N_ID)) { - connector.setN_id(reader.readInt32()); + connector.setN_id(reader.readInt64()); } else if (name.equals(PRIORITY)) { connector.setPriority(reader.readInt32()); } else if (name.equals(FOLDER_ID)) { @@ -89,7 +89,7 @@ public void encode(BsonWriter writer, FluxConnectorDTO value, EncoderContext enc writer.writeStartDocument(); writer.writeInt32(TYPE, value.getType()); - writer.writeInt32(N_ID, value.getN_id()); + writer.writeInt64(N_ID, value.getN_id()); writer.writeInt32(PRIORITY, value.getPriority()); writer.writeInt32(FOLDER_ID, value.getFolder_id()); writer.writeInt64(LIMIT, value.getLimit()); diff --git a/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodec.java b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodec.java index 90184cc3..33039b5d 100644 --- a/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodec.java +++ b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkCodec.java @@ -44,7 +44,7 @@ public FluxNetworkDTO decode(BsonReader reader, DecoderContext decoderContext) { while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) { String name = reader.readName(); if (name.equals(NETWORK_ID)) { - fluxNetworkDTO.setNetworkID(reader.readInt32()); + fluxNetworkDTO.setNetworkID(reader.readInt64()); } else if (name.equals(NETWORK_NAME)) { fluxNetworkDTO.setNetworkName(reader.readString()); } else if (name.equals(OWNER_UUID)) { @@ -84,7 +84,7 @@ public FluxNetworkDTO decode(BsonReader reader, DecoderContext decoderContext) { @Override public void encode(BsonWriter writer, FluxNetworkDTO value, EncoderContext encoderContext) { writer.writeStartDocument(); - writer.writeInt32(NETWORK_ID, value.getNetworkID()); + writer.writeInt64(NETWORK_ID, value.getNetworkID()); writer.writeString(NETWORK_NAME, value.getNetworkName()); writer.writeName(OWNER_UUID); uuidCodec.encode(writer, value.getOwnerUUID(), encoderContext); diff --git a/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodec.java b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodec.java index 66e56aca..ddd610e5 100644 --- a/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodec.java +++ b/src/main/java/sonar/fluxnetworks/common/data/codecs/FluxNetworkDataCodec.java @@ -38,7 +38,7 @@ public FluxNetworkDataDTO decode(BsonReader reader, DecoderContext decoderContex while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) { String name = reader.readName(); if (name.equals(UNIQUE_ID)) { - fluxNetworkDataDTO.setUniqueId(reader.readInt32()); + fluxNetworkDataDTO.setUniqueId(reader.readInt64()); } else if (name.equals(NETWORKS)) { reader.readStartArray(); fluxNetworkDataDTO.setNetworks(new ArrayList<>()); @@ -69,7 +69,7 @@ public void encode(BsonWriter writer, FluxNetworkDataDTO value, EncoderContext e writer.writeName(INDEX_FIELD); uuidCodec.encode(writer, value.getServerID(), encoderContext); if (value.getUniqueId() != null) { - writer.writeInt32(UNIQUE_ID, value.getUniqueId()); + writer.writeInt64(UNIQUE_ID, value.getUniqueId()); } if (value.getNetworks() != null && !value.getNetworks().isEmpty()) { writer.writeName(NETWORKS); diff --git a/src/main/java/sonar/fluxnetworks/common/data/dto/FluxConnectorDTO.java b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxConnectorDTO.java index d00f8e6c..d26c1e7f 100644 --- a/src/main/java/sonar/fluxnetworks/common/data/dto/FluxConnectorDTO.java +++ b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxConnectorDTO.java @@ -31,7 +31,7 @@ public class FluxConnectorDTO extends NBTCompatibleDTO { private static final FluxConnectorDTO EMPTY = new FluxConnectorDTO(); Integer type; - Integer n_id; + Long n_id; Integer priority; Integer folder_id; Long limit; @@ -61,7 +61,7 @@ public void fillWithItemStackNBT(ItemStack stack) { public static FluxConnectorDTO fromNBT(NBTTagCompound tag) { FluxConnectorDTO dto = new FluxConnectorDTO(); dto.type = TagUtils.intOrNull(tag, TYPE); - dto.n_id = TagUtils.intOrNull(tag, N_ID); + dto.n_id = TagUtils.longOrNull(tag, N_ID); dto.priority = TagUtils.intOrNull(tag, PRIORITY); dto.folder_id = TagUtils.intOrNull(tag, FOLDER_ID); dto.limit = TagUtils.longOrNull(tag, LIMIT); @@ -126,11 +126,11 @@ public void setType(Integer type) { this.type = type; } - public Integer getN_id() { + public Long getN_id() { return n_id; } - public void setN_id(Integer n_id) { + public void setN_id(Long n_id) { this.n_id = n_id; } diff --git a/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDTO.java b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDTO.java index e62c9977..76a7d9ed 100644 --- a/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDTO.java +++ b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDTO.java @@ -21,7 +21,7 @@ public class FluxNetworkDTO extends NBTCompatibleDTO { private static final FluxNetworkDTO EMPTY = new FluxNetworkDTO(); - Integer networkID; + Long networkID; String networkName; UUID ownerUUID; Integer networkSecurity; @@ -34,7 +34,7 @@ public class FluxNetworkDTO extends NBTCompatibleDTO { public static FluxNetworkDTO fromNBT(NBTTagCompound tag) { FluxNetworkDTO dto = new FluxNetworkDTO(); - dto.networkID = TagUtils.intOrNull(tag, NETWORK_ID); + dto.networkID = TagUtils.longOrNull(tag, NETWORK_ID); dto.networkName = TagUtils.stringOrNull(tag, NETWORK_NAME); dto.ownerUUID = TagUtils.uuidOrNull(tag, OWNER_UUID); dto.networkSecurity = TagUtils.intOrNull(tag, NETWORK_SECURITY); @@ -66,11 +66,11 @@ public boolean isEmpty() { return this.equals(EMPTY); } - public Integer getNetworkID() { + public Long getNetworkID() { return networkID; } - public void setNetworkID(Integer networkID) { + public void setNetworkID(Long networkID) { this.networkID = networkID; } diff --git a/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDataDTO.java b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDataDTO.java index d8c91357..f6aa8f6c 100644 --- a/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDataDTO.java +++ b/src/main/java/sonar/fluxnetworks/common/data/dto/FluxNetworkDataDTO.java @@ -27,12 +27,12 @@ import static sonar.fluxnetworks.common.data.TagConstants.UNIQUE_ID; public class FluxNetworkDataDTO { - private static FluxNetworkDataDTO EMPTY = new FluxNetworkDataDTO(); + private static final FluxNetworkDataDTO EMPTY = new FluxNetworkDataDTO(); List networks; List loadedChunks; - Integer uniqueId; UUID serverID; + Long uniqueId; public FluxNetworkDataDTO() {} @@ -42,7 +42,7 @@ public FluxNetworkDataDTO(UUID serverID) { public static FluxNetworkDataDTO fromNBT(NBTTagCompound tag) { FluxNetworkDataDTO dto = new FluxNetworkDataDTO(); - dto.uniqueId = TagUtils.intOrNull(tag, UNIQUE_ID); + dto.uniqueId = TagUtils.longOrNull(tag, UNIQUE_ID); dto.networks = TagUtils.fluxNetworkListOrNull(tag, NETWORKS); dto.loadedChunks = TagUtils.chunkPosListOrNull(tag, LOADED_CHUNKS); dto.serverID = MONGO_SERVER_ID; @@ -51,7 +51,7 @@ public static FluxNetworkDataDTO fromNBT(NBTTagCompound tag) { public NBTTagCompound toNBT() { NBTTagCompound tag = new NBTTagCompound(); - tag.setInteger(UNIQUE_ID, uniqueId); + tag.setLong(UNIQUE_ID, uniqueId); TagUtils.fillNBT(tag, NETWORKS, networks); TagUtils.fillNBT(tag, LOADED_CHUNKS, loadedChunks); return tag; @@ -69,8 +69,8 @@ public FluxNetworkData getFluxNetworkData() { return data; } - public Map getNetworkMap() { - Map map = new HashMap<>(); + public Map getNetworkMap() { + Map map = new HashMap<>(); if (networks != null) { for (FluxNetworkDTO dto : networks) { FluxNetworkServer fluxNetwork = new FluxNetworkServer( @@ -126,11 +126,11 @@ public void setNetworks(List networks) { this.networks = networks; } - public Integer getUniqueId() { + public Long getUniqueId() { return uniqueId; } - public void setUniqueId(Integer uniqueId) { + public void setUniqueId(Long uniqueId) { this.uniqueId = uniqueId; } diff --git a/src/main/java/sonar/fluxnetworks/common/item/ItemAdminConfigurator.java b/src/main/java/sonar/fluxnetworks/common/item/ItemAdminConfigurator.java index 52753dbc..58239ce9 100644 --- a/src/main/java/sonar/fluxnetworks/common/item/ItemAdminConfigurator.java +++ b/src/main/java/sonar/fluxnetworks/common/item/ItemAdminConfigurator.java @@ -40,7 +40,7 @@ public static INetworkConnector getAdminConnector() { public static class AdminConnector implements INetworkConnector { @Override - public int getNetworkID() { + public long getNetworkID() { return FluxNetworks.proxy.admin_viewing_network_id; } diff --git a/src/main/java/sonar/fluxnetworks/common/item/ItemConfigurator.java b/src/main/java/sonar/fluxnetworks/common/item/ItemConfigurator.java index 5756946a..3b35546b 100644 --- a/src/main/java/sonar/fluxnetworks/common/item/ItemConfigurator.java +++ b/src/main/java/sonar/fluxnetworks/common/item/ItemConfigurator.java @@ -81,7 +81,7 @@ public ActionResult onItemRightClick(World worldIn, EntityPlayer play public void addInformation(ItemStack stack, @Nullable World worldIn, List tooltip, ITooltipFlag flagIn) { NBTTagCompound tag = stack.getSubCompound(FluxUtils.CONFIGS_TAG); if (tag != null) { - tooltip.add(FluxTranslate.NETWORK_FULL_NAME.t() + ": " + TextFormatting.WHITE + FluxColorHandler.getOrRequestNetworkName(tag.getInteger(FluxConfigurationType.NETWORK.getNBTName()))); + tooltip.add(FluxTranslate.NETWORK_FULL_NAME.t() + ": " + TextFormatting.WHITE + FluxColorHandler.getOrRequestNetworkName(tag.getLong(FluxConfigurationType.NETWORK.getNBTName()))); } super.addInformation(stack, worldIn, tooltip, flagIn); } @@ -89,17 +89,17 @@ public void addInformation(ItemStack stack, @Nullable World worldIn, List coord4DS = new ArrayList<>(); public NBTTagCompound tag; public boolean[] editions = new boolean[7]; @@ -118,7 +118,7 @@ public static class BatchEditingMessage implements IMessage { public BatchEditingMessage() { } - public BatchEditingMessage(int networkID, List coord4DS, NBTTagCompound tag, boolean[] editions) { + public BatchEditingMessage(long networkID, List coord4DS, NBTTagCompound tag, boolean[] editions) { this.networkID = networkID; this.coord4DS = coord4DS; this.tag = tag; @@ -127,7 +127,7 @@ public BatchEditingMessage(int networkID, List coord4DS, NBTTagCompound @Override public void fromBytes(ByteBuf buf) { - networkID = buf.readInt(); + networkID = buf.readLong(); for (int i = 0; i < 7; i++) { editions[i] = buf.readBoolean(); } @@ -140,7 +140,7 @@ public void fromBytes(ByteBuf buf) { @Override public void toBytes(ByteBuf buf) { - buf.writeInt(networkID); + buf.writeLong(networkID); for (Boolean b : editions) { buf.writeBoolean(b); } diff --git a/src/main/java/sonar/fluxnetworks/common/network/PacketColorCache.java b/src/main/java/sonar/fluxnetworks/common/network/PacketColorCache.java index e416168c..c1e8043c 100644 --- a/src/main/java/sonar/fluxnetworks/common/network/PacketColorCache.java +++ b/src/main/java/sonar/fluxnetworks/common/network/PacketColorCache.java @@ -21,12 +21,12 @@ public IMessage onMessage(ColorCacheMessage message, MessageContext ctx) { public static class ColorCacheMessage implements IMessage { - public Map> cache; + public Map> cache; public ColorCacheMessage() { } - public ColorCacheMessage(Map> cache) { + public ColorCacheMessage(Map> cache) { this.cache = cache; } @@ -35,7 +35,7 @@ public void fromBytes(ByteBuf buf) { cache = new HashMap<>(); int size = buf.readInt(); for (int i = 0; i < size; i++) { - int id = buf.readInt(); + long id = buf.readLong(); int colour = buf.readInt(); String name = ByteBufUtils.readUTF8String(buf); cache.put(id, new Tuple<>(colour, name)); @@ -46,7 +46,7 @@ public void fromBytes(ByteBuf buf) { public void toBytes(ByteBuf buf) { buf.writeInt(cache.size()); cache.forEach((ID, DETAILS) -> { - buf.writeInt(ID); + buf.writeLong(ID); buf.writeInt(DETAILS.getFirst()); ByteBufUtils.writeUTF8String(buf, DETAILS.getSecond()); }); diff --git a/src/main/java/sonar/fluxnetworks/common/network/PacketColorRequest.java b/src/main/java/sonar/fluxnetworks/common/network/PacketColorRequest.java index 7d40a491..a383e78a 100644 --- a/src/main/java/sonar/fluxnetworks/common/network/PacketColorRequest.java +++ b/src/main/java/sonar/fluxnetworks/common/network/PacketColorRequest.java @@ -18,9 +18,9 @@ public class PacketColorRequest implements IMessageHandler> cache = new HashMap<>(); + Map> cache = new HashMap<>(); if (!message.requests.isEmpty()) { - for (int id : message.requests) { + for (long id : message.requests) { IFluxNetwork network = FluxNetworkCache.instance.getNetwork(id); cache.put(id, new Tuple<>(network.getSetting(NetworkSettings.NETWORK_COLOR) | 0xff000000, network.isInvalid() ? "NONE" : network.getSetting(NetworkSettings.NETWORK_NAME))); } // More than one @@ -31,12 +31,12 @@ public IMessage onMessage(ColorRequestMessage message, MessageContext ctx) { public static class ColorRequestMessage implements IMessage { - List requests; + List requests; public ColorRequestMessage() { } - public ColorRequestMessage(List requests) { + public ColorRequestMessage(List requests) { this.requests = requests; } @@ -45,14 +45,14 @@ public void fromBytes(ByteBuf buf) { requests = new ArrayList<>(); int size = buf.readInt(); for (int i = 0; i < size; i++) { - requests.add(buf.readInt()); + requests.add(buf.readLong()); } } @Override public void toBytes(ByteBuf buf) { buf.writeInt(requests.size()); - requests.forEach(buf::writeInt); + requests.forEach(buf::writeLong); } } } diff --git a/src/main/java/sonar/fluxnetworks/common/network/PacketConnectionUpdate.java b/src/main/java/sonar/fluxnetworks/common/network/PacketConnectionUpdate.java index 4be27f16..a7e899a2 100644 --- a/src/main/java/sonar/fluxnetworks/common/network/PacketConnectionUpdate.java +++ b/src/main/java/sonar/fluxnetworks/common/network/PacketConnectionUpdate.java @@ -25,20 +25,20 @@ public IMessage onMessage(NetworkConnectionMessage message, MessageContext ctx) public static class NetworkConnectionMessage implements IMessage { - public int networkID; + public long networkID; public List tags = new ArrayList<>(); public NetworkConnectionMessage() { } - public NetworkConnectionMessage(int networkID, List tags) { + public NetworkConnectionMessage(long networkID, List tags) { this.networkID = networkID; this.tags = tags; } @Override public void fromBytes(ByteBuf buf) { - networkID = buf.readInt(); + networkID = buf.readLong(); int size = buf.readInt(); for (int i = 0; i < size; i++) { tags.add(ByteBufUtils.readTag(buf)); @@ -47,7 +47,7 @@ public void fromBytes(ByteBuf buf) { @Override public void toBytes(ByteBuf buf) { - buf.writeInt(networkID); + buf.writeLong(networkID); buf.writeInt(tags.size()); tags.forEach(t -> ByteBufUtils.writeTag(buf, t)); } diff --git a/src/main/java/sonar/fluxnetworks/common/network/PacketConnectionUpdateRequest.java b/src/main/java/sonar/fluxnetworks/common/network/PacketConnectionUpdateRequest.java index ebca0fb5..76521c84 100644 --- a/src/main/java/sonar/fluxnetworks/common/network/PacketConnectionUpdateRequest.java +++ b/src/main/java/sonar/fluxnetworks/common/network/PacketConnectionUpdateRequest.java @@ -37,21 +37,21 @@ public IMessage onMessage(ConnectionRequestMessage message, MessageContext ctx) public static class ConnectionRequestMessage implements IMessage { - public int networkID; + public long networkID; public List coords = new ArrayList<>(); public ConnectionRequestMessage() { } - public ConnectionRequestMessage(int networkID, List coords) { + public ConnectionRequestMessage(long networkID, List coords) { this.networkID = networkID; this.coords = coords; } @Override public void fromBytes(ByteBuf buf) { - networkID = buf.readInt(); + networkID = buf.readLong(); int size = buf.readInt(); for (int i = 0; i < size; i++) { coords.add(new Coord4D(buf)); @@ -60,7 +60,7 @@ public void fromBytes(ByteBuf buf) { @Override public void toBytes(ByteBuf buf) { - buf.writeInt(networkID); + buf.writeLong(networkID); buf.writeInt(coords.size()); coords.forEach(c -> c.write(buf)); } diff --git a/src/main/java/sonar/fluxnetworks/common/network/PacketGeneralHandler.java b/src/main/java/sonar/fluxnetworks/common/network/PacketGeneralHandler.java index 02f992b0..9172f6b4 100644 --- a/src/main/java/sonar/fluxnetworks/common/network/PacketGeneralHandler.java +++ b/src/main/java/sonar/fluxnetworks/common/network/PacketGeneralHandler.java @@ -50,9 +50,9 @@ public static IMessage handleCreateNetworkPacket(EntityPlayer player, NBTTagComp return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.NO_SPACE); } - public static NBTTagCompound getNetworkEditPacket(int networkID, String networkName, int color, SecurityType security, EnergyType energy, String password) { + public static NBTTagCompound getNetworkEditPacket(long networkID, String networkName, int color, SecurityType security, EnergyType energy, String password) { NBTTagCompound tag = new NBTTagCompound(); - tag.setInteger(FluxNetworkData.NETWORK_ID, networkID); + tag.setLong(FluxNetworkData.NETWORK_ID, networkID); tag.setString(FluxNetworkData.NETWORK_NAME, networkName); tag.setInteger(FluxNetworkData.NETWORK_COLOR, color); tag.setInteger(FluxNetworkData.SECURITY_TYPE, security.ordinal()); @@ -62,7 +62,7 @@ public static NBTTagCompound getNetworkEditPacket(int networkID, String networkN } public static IMessage handleNetworkEditPacket(EntityPlayer player, NBTTagCompound tag) { - int networkID = tag.getInteger(FluxNetworkData.NETWORK_ID); + long networkID = tag.getLong(FluxNetworkData.NETWORK_ID); String newName = tag.getString(FluxNetworkData.NETWORK_NAME); int color = tag.getInteger(FluxNetworkData.NETWORK_COLOR); SecurityType security = SecurityType.values()[tag.getInteger(FluxNetworkData.SECURITY_TYPE)]; @@ -87,14 +87,15 @@ public static IMessage handleNetworkEditPacket(EntityPlayer player, NBTTagCompou list.forEach(fluxConnector -> fluxConnector.connect(network)); // update color data } if (needPacket) { - @SuppressWarnings("unchecked") HashMap> cache = new HashMap(); + @SuppressWarnings("unchecked") HashMap> cache = new HashMap(); cache.put(networkID, new Tuple<>(network.getSetting(NetworkSettings.NETWORK_COLOR) | 0xff000000, network.getSetting(NetworkSettings.NETWORK_NAME))); PacketHandler.network.sendToAll(new PacketColorCache.ColorCacheMessage(cache)); } network.setSetting(NetworkSettings.NETWORK_SECURITY, security); network.setSetting(NetworkSettings.NETWORK_ENERGY, energy); network.setSetting(NetworkSettings.NETWORK_PASSWORD, password); - PacketHandler.network.sendToAll(new PacketNetworkUpdate.NetworkUpdateMessage(Lists.newArrayList(network), NBTType.NETWORK_GENERAL)); + PacketHandler.network.sendToAll( + new PacketNetworkUpdate.NetworkUpdateMessage(network, NBTType.NETWORK_GENERAL)); return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.SUCCESS_2); } else { return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.NO_ADMIN); @@ -103,14 +104,14 @@ public static IMessage handleNetworkEditPacket(EntityPlayer player, NBTTagCompou return null; } - public static NBTTagCompound getDeleteNetworkPacket(int networkID) { + public static NBTTagCompound getDeleteNetworkPacket(long networkID) { NBTTagCompound tag = new NBTTagCompound(); - tag.setInteger(FluxNetworkData.NETWORK_ID, networkID); + tag.setLong(FluxNetworkData.NETWORK_ID, networkID); return tag; } public static IMessage handleDeleteNetworkPacket(EntityPlayer player, NBTTagCompound nbtTag) { - int id = nbtTag.getInteger(FluxNetworkData.NETWORK_ID); + long id = nbtTag.getLong(FluxNetworkData.NETWORK_ID); IFluxNetwork toDelete = FluxNetworkCache.instance.getNetwork(id); if (!toDelete.isInvalid()) { if (toDelete.getMemberPermission(player).canDelete()) { @@ -124,23 +125,23 @@ public static IMessage handleDeleteNetworkPacket(EntityPlayer player, NBTTagComp } @Deprecated - public static NBTTagCompound getAddMemberPacket(int networkID, String playerName) { + public static NBTTagCompound getAddMemberPacket(long networkID, String playerName) { NBTTagCompound tag = new NBTTagCompound(); - tag.setInteger(FluxNetworkData.NETWORK_ID, networkID); + tag.setLong(FluxNetworkData.NETWORK_ID, networkID); tag.setString("playerName", playerName); return tag; } @Deprecated public static IMessage handleAddMemberPacket(EntityPlayer player, NBTTagCompound packetTag) { - int networkID = packetTag.getInteger(FluxNetworkData.NETWORK_ID); + long networkID = packetTag.getLong(FluxNetworkData.NETWORK_ID); String playerName = packetTag.getString("playerName"); IFluxNetwork network = FluxNetworkCache.instance.getNetwork(networkID); if (!network.isInvalid()) { if (network.getMemberPermission(player).canEdit()) { network.addNewMember(playerName); - return new PacketNetworkUpdate.NetworkUpdateMessage(Lists.newArrayList(network), NBTType.NETWORK_PLAYERS); + return new PacketNetworkUpdate.NetworkUpdateMessage(network, NBTType.NETWORK_PLAYERS); } else { return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.NO_ADMIN); } @@ -149,23 +150,23 @@ public static IMessage handleAddMemberPacket(EntityPlayer player, NBTTagCompound } @Deprecated - public static NBTTagCompound getRemoveMemberPacket(int networkID, UUID playerRemoved) { + public static NBTTagCompound getRemoveMemberPacket(long networkID, UUID playerRemoved) { NBTTagCompound tag = new NBTTagCompound(); - tag.setInteger(FluxNetworkData.NETWORK_ID, networkID); + tag.setLong(FluxNetworkData.NETWORK_ID, networkID); tag.setUniqueId("playerRemoved", playerRemoved); return tag; } @Deprecated public static IMessage handleRemoveMemberPacket(EntityPlayer player, NBTTagCompound packetTag) { - int networkID = packetTag.getInteger(FluxNetworkData.NETWORK_ID); + long networkID = packetTag.getLong(FluxNetworkData.NETWORK_ID); UUID playerRemoved = packetTag.getUniqueId("playerRemoved"); IFluxNetwork network = FluxNetworkCache.instance.getNetwork(networkID); if (!network.isInvalid()) { if (network.getMemberPermission(player).canEdit()) { network.removeMember(playerRemoved); - return new PacketNetworkUpdate.NetworkUpdateMessage(Lists.newArrayList(network), NBTType.NETWORK_PLAYERS); + return new PacketNetworkUpdate.NetworkUpdateMessage(network, NBTType.NETWORK_PLAYERS); } else { return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.NO_ADMIN); } @@ -173,102 +174,104 @@ public static IMessage handleRemoveMemberPacket(EntityPlayer player, NBTTagCompo return null; } - public static NBTTagCompound getChangePermissionPacket(int networkID, UUID playerChanged, int type) { + public static NBTTagCompound getChangePermissionPacket(long networkID, UUID playerChanged, int type) { NBTTagCompound tag = new NBTTagCompound(); - tag.setInteger(FluxNetworkData.NETWORK_ID, networkID); + tag.setLong(FluxNetworkData.NETWORK_ID, networkID); tag.setUniqueId("playerChanged", playerChanged); tag.setInteger("t", type); return tag; } public static IMessage handleChangePermissionPacket(EntityPlayer player, NBTTagCompound packetTag) { - int networkID = packetTag.getInteger(FluxNetworkData.NETWORK_ID); + long networkID = packetTag.getLong(FluxNetworkData.NETWORK_ID); UUID playerChanged = packetTag.getUniqueId("playerChanged"); int type = packetTag.getInteger("t"); - if (playerChanged != null) { + if (playerChanged == null) { + return null; + } /*if (EntityPlayer.getUUID(player.getGameProfile()).equals(playerChanged)) { //don't allow editing of their own permissions... return null; }*/ - IFluxNetwork network = FluxNetworkCache.instance.getNetwork(networkID); - if (!network.isInvalid()) { - if (network.getMemberPermission(player).canEdit()) { - // Create new member - if (type == 0) { - EntityPlayer player1 = FMLCommonHandler.instance().getMinecraftServerInstance().getPlayerList().getPlayerByUUID(playerChanged); - //noinspection ConstantConditions - if (player1 != null) { - NetworkMember newMember = NetworkMember.createNetworkMember(player1, AccessLevel.USER); - network.getSetting(NetworkSettings.NETWORK_PLAYERS).add(newMember); - PacketHandler.network.sendTo(new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.SUCCESS), (EntityPlayerMP) player); - return new PacketNetworkUpdate.NetworkUpdateMessage(Lists.newArrayList(network), NBTType.NETWORK_PLAYERS); - } - return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.INVALID_USER); - } else { - Optional settings = network.getValidMember(playerChanged); - if (settings.isPresent()) { - NetworkMember p = settings.get(); - if (type == 1) { - p.setAccessPermission(AccessLevel.ADMIN); - } else if (type == 2) { - p.setAccessPermission(AccessLevel.USER); - } else if (type == 3) { - network.getSetting(NetworkSettings.NETWORK_PLAYERS).remove(p); - } else if (type == 4) { - /*network.getSetting(NetworkSettings.NETWORK_PLAYERS).stream() - .filter(f -> f.getAccessPermission().canDelete()).findFirst().ifPresent(s -> s.setAccessPermission(AccessPermission.USER));*/ - network.getSetting(NetworkSettings.NETWORK_PLAYERS).removeIf(f -> f.getAccessPermission().canDelete()); - network.setSetting(NetworkSettings.NETWORK_OWNER, playerChanged); - p.setAccessPermission(AccessLevel.OWNER); - } - PacketHandler.network.sendTo(new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.SUCCESS), (EntityPlayerMP) player); - return new PacketNetworkUpdate.NetworkUpdateMessage(Lists.newArrayList(network), NBTType.NETWORK_PLAYERS); - } else if (type == 4) { - EntityPlayer player1 = FMLCommonHandler.instance().getMinecraftServerInstance().getPlayerList().getPlayerByUUID(playerChanged); - //noinspection ConstantConditions - if (player1 != null) { - /*network.getSetting(NetworkSettings.NETWORK_PLAYERS).stream() - .filter(f -> f.getAccessPermission().canDelete()).findFirst().ifPresent(s -> s.setAccessPermission(AccessPermission.USER));*/ - network.getSetting(NetworkSettings.NETWORK_PLAYERS).removeIf(f -> f.getAccessPermission().canDelete()); - NetworkMember newMember = NetworkMember.createNetworkMember(player1, AccessLevel.OWNER); - network.getSetting(NetworkSettings.NETWORK_PLAYERS).add(newMember); - network.setSetting(NetworkSettings.NETWORK_OWNER, playerChanged); - PacketHandler.network.sendTo(new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.SUCCESS), (EntityPlayerMP) player); - return new PacketNetworkUpdate.NetworkUpdateMessage(Lists.newArrayList(network), NBTType.NETWORK_PLAYERS); - } - return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.INVALID_USER); - } - return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.INVALID_USER); - } - } else { - return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.NO_ADMIN); + IFluxNetwork network = FluxNetworkCache.instance.getNetwork(networkID); + if (network.isInvalid()) { + return null; + } + if (!network.getMemberPermission(player).canEdit()) { + return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.NO_ADMIN); + } + // Create new member + if (type == 0) { + EntityPlayer player1 = FMLCommonHandler.instance().getMinecraftServerInstance().getPlayerList().getPlayerByUUID(playerChanged); + //noinspection ConstantConditions + if (player1 == null) { + return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.INVALID_USER); + } + NetworkMember newMember = NetworkMember.createNetworkMember(player1, AccessLevel.USER); + network.getSetting(NetworkSettings.NETWORK_PLAYERS).add(newMember); + PacketHandler.network.sendTo(new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.SUCCESS), (EntityPlayerMP) player); + return new PacketNetworkUpdate.NetworkUpdateMessage(network, NBTType.NETWORK_PLAYERS); + } else { + Optional settings = network.getValidMember(playerChanged); + if (settings.isPresent()) { + NetworkMember p = settings.get(); + if (type == 1) { + p.setAccessPermission(AccessLevel.ADMIN); + } else if (type == 2) { + p.setAccessPermission(AccessLevel.USER); + } else if (type == 3) { + network.getSetting(NetworkSettings.NETWORK_PLAYERS).remove(p); + } else if (type == 4) { + /*network.getSetting(NetworkSettings.NETWORK_PLAYERS).stream() + .filter(f -> f.getAccessPermission().canDelete()).findFirst().ifPresent(s -> s.setAccessPermission(AccessPermission.USER));*/ + network.getSetting(NetworkSettings.NETWORK_PLAYERS).removeIf(f -> f.getAccessPermission().canDelete()); + network.setSetting(NetworkSettings.NETWORK_OWNER, playerChanged); + p.setAccessPermission(AccessLevel.OWNER); + } + PacketHandler.network.sendTo(new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.SUCCESS), (EntityPlayerMP) player); + return new PacketNetworkUpdate.NetworkUpdateMessage(network, NBTType.NETWORK_PLAYERS); + } else if (type == 4) { + EntityPlayer player1 = FMLCommonHandler.instance().getMinecraftServerInstance().getPlayerList().getPlayerByUUID(playerChanged); + //noinspection ConstantConditions + if (player1 == null) { + return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.INVALID_USER); } + /*network.getSetting(NetworkSettings.NETWORK_PLAYERS).stream() + .filter(f -> f.getAccessPermission().canDelete()).findFirst().ifPresent(s -> s.setAccessPermission(AccessPermission.USER));*/ + network.getSetting(NetworkSettings.NETWORK_PLAYERS).removeIf(f -> f.getAccessPermission().canDelete()); + NetworkMember newMember = NetworkMember.createNetworkMember(player1, AccessLevel.OWNER); + network.getSetting(NetworkSettings.NETWORK_PLAYERS).add(newMember); + network.setSetting(NetworkSettings.NETWORK_OWNER, playerChanged); + PacketHandler.network.sendTo(new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.SUCCESS), (EntityPlayerMP) player); + return new PacketNetworkUpdate.NetworkUpdateMessage(network, NBTType.NETWORK_PLAYERS); } + return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.INVALID_USER); } - return null; } - public static NBTTagCompound getChangeWirelessPacket(int networkID, int wirelessMode) { + public static NBTTagCompound getChangeWirelessPacket(long networkID, int wirelessMode) { NBTTagCompound tag = new NBTTagCompound(); - tag.setInteger(FluxNetworkData.NETWORK_ID, networkID); + tag.setLong(FluxNetworkData.NETWORK_ID, networkID); tag.setInteger(FluxNetworkData.WIRELESS_MODE, wirelessMode); return tag; } public static IMessage handleChangeWirelessPacket(EntityPlayer player, NBTTagCompound packetTag) { - int networkID = packetTag.getInteger(FluxNetworkData.NETWORK_ID); + long networkID = packetTag.getLong(FluxNetworkData.NETWORK_ID); int wireless = packetTag.getInteger(FluxNetworkData.WIRELESS_MODE); IFluxNetwork network = FluxNetworkCache.instance.getNetwork(networkID); - if (!network.isInvalid()) { - if (network.getMemberPermission(player).canEdit()) { - network.setSetting(NetworkSettings.NETWORK_WIRELESS, wireless); - PacketHandler.network.sendTo(new PacketNetworkUpdate.NetworkUpdateMessage(Lists.newArrayList(network), NBTType.NETWORK_GENERAL), (EntityPlayerMP) player); - return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.SUCCESS); - } else { - return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.NO_ADMIN); - } + if (network.isInvalid()) { + return null; } - return null; + if (!network.getMemberPermission(player).canEdit()) { + return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.NO_ADMIN); + } + network.setSetting(NetworkSettings.NETWORK_WIRELESS, wireless); + PacketHandler.network.sendTo( + new PacketNetworkUpdate.NetworkUpdateMessage(network, NBTType.NETWORK_GENERAL), + (EntityPlayerMP) player + ); + return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.SUCCESS); } } diff --git a/src/main/java/sonar/fluxnetworks/common/network/PacketNetworkUpdate.java b/src/main/java/sonar/fluxnetworks/common/network/PacketNetworkUpdate.java index 6c5e00f8..815323f8 100644 --- a/src/main/java/sonar/fluxnetworks/common/network/PacketNetworkUpdate.java +++ b/src/main/java/sonar/fluxnetworks/common/network/PacketNetworkUpdate.java @@ -29,7 +29,7 @@ public IMessage onMessage(NetworkUpdateMessage message, MessageContext ctx) { public static class NetworkUpdateMessage implements IMessage { - public Map updatedNetworks = new HashMap<>(); + public Map updatedNetworks = new HashMap<>(); public NBTType type; public NetworkUpdateMessage() { @@ -46,12 +46,21 @@ public NetworkUpdateMessage(List toSend, NBTType type) { }); } + public NetworkUpdateMessage(IFluxNetwork toSend, NBTType type) { + this.type = type; + NBTTagCompound tag = new NBTTagCompound(); + toSend.writeNetworkNBT(tag, type); + if (!tag.isEmpty()) { + updatedNetworks.put(toSend.getNetworkID(), tag); + } + } + @Override public void fromBytes(ByteBuf buf) { type = NBTType.values()[buf.readInt()]; int size = buf.readInt(); for (int i = 0; i < size; i++) { - updatedNetworks.put(buf.readInt(), ByteBufUtils.readTag(buf)); + updatedNetworks.put(buf.readLong(), ByteBufUtils.readTag(buf)); } } @@ -60,7 +69,7 @@ public void toBytes(ByteBuf buf) { buf.writeInt(type.ordinal()); buf.writeInt(updatedNetworks.size()); updatedNetworks.forEach((i, n) -> { - buf.writeInt(i); + buf.writeLong(i); ByteBufUtils.writeTag(buf, n); }); } diff --git a/src/main/java/sonar/fluxnetworks/common/network/PacketNetworkUpdateRequest.java b/src/main/java/sonar/fluxnetworks/common/network/PacketNetworkUpdateRequest.java index 9b631429..868829fc 100644 --- a/src/main/java/sonar/fluxnetworks/common/network/PacketNetworkUpdateRequest.java +++ b/src/main/java/sonar/fluxnetworks/common/network/PacketNetworkUpdateRequest.java @@ -17,7 +17,7 @@ public class PacketNetworkUpdateRequest implements IMessageHandler networks = Lists.newArrayList(); - for (Integer i : message.networks) { + for (Long i : message.networks) { IFluxNetwork network = FluxNetworkCache.instance.getNetwork(i); if (!network.isInvalid()) { networks.add(network); @@ -31,13 +31,13 @@ public IMessage onMessage(UpdateRequestMessage message, MessageContext ctx) { public static class UpdateRequestMessage implements IMessage { - public List networks = Lists.newArrayList(); + public List networks = Lists.newArrayList(); public NBTType type; public UpdateRequestMessage() { } - public UpdateRequestMessage(int networkID, NBTType type) { + public UpdateRequestMessage(long networkID, NBTType type) { this.networks.add(networkID); this.type = type; } @@ -51,7 +51,7 @@ public UpdateRequestMessage(List networks, NBTType type) { public void fromBytes(ByteBuf buf) { int size = buf.readInt(); for (int i = 0; i < size; i++) { - networks.add(buf.readInt()); + networks.add(buf.readLong()); } type = NBTType.values()[buf.readInt()]; } @@ -60,7 +60,7 @@ public void fromBytes(ByteBuf buf) { public void toBytes(ByteBuf buf) { buf.writeInt(networks.size()); - networks.forEach(buf::writeInt); + networks.forEach(buf::writeLong); buf.writeInt(type.ordinal()); } } diff --git a/src/main/java/sonar/fluxnetworks/common/network/PacketPermissionRequest.java b/src/main/java/sonar/fluxnetworks/common/network/PacketPermissionRequest.java index edc1fc36..e3fc02d0 100644 --- a/src/main/java/sonar/fluxnetworks/common/network/PacketPermissionRequest.java +++ b/src/main/java/sonar/fluxnetworks/common/network/PacketPermissionRequest.java @@ -24,26 +24,26 @@ public IMessage onMessage(PermissionRequestMessage message, MessageContext ctx) public static class PermissionRequestMessage implements IMessage { - public int networkID; + public long networkID; public UUID uuid; public PermissionRequestMessage() { } - public PermissionRequestMessage(int networkID, UUID uuid) { + public PermissionRequestMessage(long networkID, UUID uuid) { this.networkID = networkID; this.uuid = uuid; } @Override public void fromBytes(ByteBuf buf) { - networkID = buf.readInt(); + networkID = buf.readLong(); uuid = new UUID(buf.readLong(), buf.readLong()); } @Override public void toBytes(ByteBuf buf) { - buf.writeInt(networkID); + buf.writeLong(networkID); buf.writeLong(uuid.getMostSignificantBits()); buf.writeLong(uuid.getLeastSignificantBits()); } diff --git a/src/main/java/sonar/fluxnetworks/common/network/PacketSetConfiguratorNetwork.java b/src/main/java/sonar/fluxnetworks/common/network/PacketSetConfiguratorNetwork.java index db05e483..d9ee57c8 100644 --- a/src/main/java/sonar/fluxnetworks/common/network/PacketSetConfiguratorNetwork.java +++ b/src/main/java/sonar/fluxnetworks/common/network/PacketSetConfiguratorNetwork.java @@ -36,7 +36,7 @@ public IMessage onMessage(SetConfiguratorNetworkMessage message, MessageContext ItemStack stack = player.getHeldItemMainhand(); if (stack.getItem() instanceof ItemConfigurator) { NBTTagCompound configs = stack.getOrCreateSubCompound(FluxUtils.CONFIGS_TAG); - configs.setInteger(FluxConfigurationType.NETWORK.getNBTName(), message.id); + configs.setLong(FluxConfigurationType.NETWORK.getNBTName(), message.id); } return new PacketFeedback.FeedbackMessage(EnumFeedbackInfo.SUCCESS); } @@ -45,26 +45,26 @@ public IMessage onMessage(SetConfiguratorNetworkMessage message, MessageContext public static class SetConfiguratorNetworkMessage implements IMessage { - public int id; + public long id; public String password; public SetConfiguratorNetworkMessage() { } - public SetConfiguratorNetworkMessage(int id, String password) { + public SetConfiguratorNetworkMessage(long id, String password) { this.id = id; this.password = password; } @Override public void fromBytes(ByteBuf buf) { - id = buf.readInt(); + id = buf.readLong(); password = ByteBufUtils.readUTF8String(buf); } @Override public void toBytes(ByteBuf buf) { - buf.writeInt(id); + buf.writeLong(id); ByteBufUtils.writeUTF8String(buf, password); } } diff --git a/src/main/java/sonar/fluxnetworks/common/network/PacketTileHandler.java b/src/main/java/sonar/fluxnetworks/common/network/PacketTileHandler.java index f05906cc..f1657bdd 100644 --- a/src/main/java/sonar/fluxnetworks/common/network/PacketTileHandler.java +++ b/src/main/java/sonar/fluxnetworks/common/network/PacketTileHandler.java @@ -16,15 +16,15 @@ public class PacketTileHandler { - public static NBTTagCompound getSetNetworkPacket(int id, String password) { + public static NBTTagCompound getSetNetworkPacket(long id, String password) { NBTTagCompound tag = new NBTTagCompound(); - tag.setInteger(FluxNetworkData.NETWORK_ID, id); + tag.setLong(FluxNetworkData.NETWORK_ID, id); tag.setString(FluxNetworkData.NETWORK_PASSWORD, password); return tag; } public static IMessage handleSetNetworkPacket(TileFluxCore tile, EntityPlayer player, NBTTagCompound tag) { - int id = tag.getInteger(FluxNetworkData.NETWORK_ID); + long id = tag.getLong(FluxNetworkData.NETWORK_ID); String pass = tag.getString(FluxNetworkData.NETWORK_PASSWORD); if (tile.getNetworkID() == id) { return null; diff --git a/src/main/java/sonar/fluxnetworks/common/registry/RegistryRecipes.java b/src/main/java/sonar/fluxnetworks/common/registry/RegistryRecipes.java index 80848d1e..134515cd 100644 --- a/src/main/java/sonar/fluxnetworks/common/registry/RegistryRecipes.java +++ b/src/main/java/sonar/fluxnetworks/common/registry/RegistryRecipes.java @@ -76,14 +76,15 @@ public FluxStorageRecipe(@Nonnull ItemStack result, Object... recipe) { @Nonnull @Override public ItemStack getCraftingResult(@Nonnull InventoryCrafting crafting) { - int energyTotal = 0, networkID = 0; + int energyTotal = 0; + long networkID = 0; boolean firstFound = false; for (int i = 0; i < crafting.getSizeInventory(); i++) { ItemStack stack = crafting.getStackInSlot(i); NBTTagCompound subTag = stack.getSubCompound(FluxUtils.FLUX_DATA); if (subTag != null) { if (!firstFound) { - networkID = subTag.getInteger(FluxNetworkData.NETWORK_ID); + networkID = subTag.getLong(FluxNetworkData.NETWORK_ID); firstFound = true; } energyTotal += subTag.getLong("energy"); @@ -92,7 +93,7 @@ public ItemStack getCraftingResult(@Nonnull InventoryCrafting crafting) { if (firstFound) { ItemStack stack = output.copy(); NBTTagCompound subTag = stack.getOrCreateSubCompound(FluxUtils.FLUX_DATA); - subTag.setInteger(FluxNetworkData.NETWORK_ID, networkID); + subTag.setLong(FluxNetworkData.NETWORK_ID, networkID); subTag.setLong("energy", energyTotal); return stack; } diff --git a/src/main/java/sonar/fluxnetworks/common/tileentity/TileFluxCore.java b/src/main/java/sonar/fluxnetworks/common/tileentity/TileFluxCore.java index 207824fc..d4d2a320 100644 --- a/src/main/java/sonar/fluxnetworks/common/tileentity/TileFluxCore.java +++ b/src/main/java/sonar/fluxnetworks/common/tileentity/TileFluxCore.java @@ -42,7 +42,7 @@ public abstract class TileFluxCore extends TileEntity implements IFluxConnector, public HashSet playerUsing = new HashSet<>(); public String customName = ""; - public int networkID = -1; + public long networkID = -1; public UUID playerUUID = FluxUtils.UUID_DEFAULT; public int color = -1; public int folderID = -1; @@ -132,7 +132,7 @@ public IFluxNetwork getNetwork() { } @Override - public int getNetworkID() { + public long getNetworkID() { return networkID; } @@ -182,7 +182,7 @@ public NBTTagCompound writeCustomNBT(NBTTagCompound tag, NBTType type) { tag.setLong("1", limit); tag.setBoolean("2", disableLimit); tag.setBoolean("3", surgeMode); - tag.setInteger("4", networkID); + tag.setLong("4", networkID); tag.setUniqueId("5", playerUUID); tag.setString("6", customName); tag.setInteger("7", color); @@ -198,7 +198,7 @@ public NBTTagCompound writeCustomNBT(NBTTagCompound tag, NBTType type) { tag.setLong(ItemFluxConnector.LIMIT, limit); tag.setBoolean(ItemFluxConnector.DISABLE_LIMIT, disableLimit); tag.setBoolean(ItemFluxConnector.SURGE_MODE, surgeMode); - tag.setInteger(FluxNetworkData.NETWORK_ID, networkID); + tag.setLong(FluxNetworkData.NETWORK_ID, networkID); tag.setString(ItemFluxConnector.CUSTOM_NAME, customName); tag.setInteger(NetworkFolder.FOLDER_ID, folderID); } @@ -229,8 +229,8 @@ public void readCustomNBT(NBTTagCompound tag, NBTType type) { limit = (l = tag.getLong(ItemFluxConnector.LIMIT)) > 0 ? l : limit; disableLimit = tag.getBoolean(ItemFluxConnector.DISABLE_LIMIT); surgeMode = tag.getBoolean(ItemFluxConnector.SURGE_MODE); - int i; - networkID = (i = tag.getInteger(FluxNetworkData.NETWORK_ID)) > 0 ? i : networkID; + long i; + networkID = (i = tag.getLong(FluxNetworkData.NETWORK_ID)) > 0 ? i : networkID; String name; customName = (name = tag.getString(ItemFluxConnector.CUSTOM_NAME)).isEmpty() ? customName : name; folderID = tag.getInteger(NetworkFolder.FOLDER_ID); diff --git a/src/main/java/sonar/fluxnetworks/common/tileentity/TileFluxStorage.java b/src/main/java/sonar/fluxnetworks/common/tileentity/TileFluxStorage.java index b5819b19..02c0e1c2 100644 --- a/src/main/java/sonar/fluxnetworks/common/tileentity/TileFluxStorage.java +++ b/src/main/java/sonar/fluxnetworks/common/tileentity/TileFluxStorage.java @@ -116,7 +116,7 @@ public ItemStack writeStorageToDisplayStack(ItemStack stack) { NBTTagCompound subTag = new NBTTagCompound(); subTag.setLong("energy", getTransferBuffer()); - subTag.setInteger(FluxNetworkData.NETWORK_ID, networkID); + subTag.setLong(FluxNetworkData.NETWORK_ID, networkID); tag.setTag(FluxUtils.FLUX_DATA, subTag); tag.setBoolean(FluxUtils.GUI_COLOR, true);