private void addChunksToSaveTransaction(SaveTransactionBuilder saveTransactionBuilder, ChunkProvider chunkProvider) { unloadedAndSavingChunkMap.clear(); /* * New entries might be added concurrently. By using putAll + clear to transfer entries we might loose new * ones added in between putAll and clear. Bz iterating we can make sure that all entires removed * from unloadedAndUnsavedChunkMap get added to unloadedAndSavingChunkMap. */ Iterator<Map.Entry<Vector3i, CompressedChunkBuilder>> unsavedEntryIterator = unloadedAndUnsavedChunkMap.entrySet().iterator(); while (unsavedEntryIterator.hasNext()) { Map.Entry<Vector3i, CompressedChunkBuilder> entry = unsavedEntryIterator.next(); unloadedAndSavingChunkMap.put(entry.getKey(), entry.getValue()); unsavedEntryIterator.remove(); } chunkProvider.getAllChunks().stream().filter(ManagedChunk::isReady).forEach(chunk -> { // If there is a newer undisposed version of the chunk,we don't need to save the disposed version: unloadedAndSavingChunkMap.remove(chunk.getPosition()); ChunkImpl chunkImpl = (ChunkImpl) chunk; // this storage manager can only work with ChunkImpls saveTransactionBuilder.addLoadedChunk(chunk.getPosition(), chunkImpl); }); for (Map.Entry<Vector3i, CompressedChunkBuilder> entry : unloadedAndSavingChunkMap.entrySet()) { saveTransactionBuilder.addUnloadedChunk(entry.getKey(), entry.getValue()); } }
private void addPlayersToSaveTransaction(SaveTransactionBuilder saveTransactionBuilder, NetworkSystem networkSystem) { unloadedAndSavingPlayerMap.clear(); /* * New entries might be added concurrently. By using putAll + clear to transfer entries we might loose new * ones added in between putAll and clear. By iterating we can make sure that all entities removed * from unloadedAndUnsavedPlayerMap get added to unloadedAndSavingPlayerMap. */ Iterator<Map.Entry<String, EntityData.PlayerStore>> unsavedEntryIterator = unloadedAndUnsavedPlayerMap.entrySet().iterator(); while (unsavedEntryIterator.hasNext()) { Map.Entry<String, EntityData.PlayerStore> entry = unsavedEntryIterator.next(); unloadedAndSavingPlayerMap.put(entry.getKey(), entry.getValue()); unsavedEntryIterator.remove(); } for (Client client : networkSystem.getPlayers()) { // If there is a newer undisposed version of the player,we don't need to save the disposed version: unloadedAndSavingPlayerMap.remove(client.getId()); EntityRef character = client.getEntity().getComponent(ClientComponent.class).character; saveTransactionBuilder.addLoadedPlayer(client.getId(), createPlayerStore(client, character)); } for (Map.Entry<String, EntityData.PlayerStore> entry : unloadedAndSavingPlayerMap.entrySet()) { saveTransactionBuilder.addUnloadedPlayer(entry.getKey(), entry.getValue()); } }
private SaveTransaction createSaveTransaction() { SaveTransactionBuilder saveTransactionBuilder = new SaveTransactionBuilder(privateEntityManager, entitySetDeltaRecorder, isStoreChunksInZips(), getStoragePathProvider(), worldDirectoryWriteLock, recordAndReplaySerializer, recordAndReplayUtils, recordAndReplayCurrentStatus); ChunkProvider chunkProvider = CoreRegistry.get(ChunkProvider.class); NetworkSystem networkSystem = CoreRegistry.get(NetworkSystem.class); addChunksToSaveTransaction(saveTransactionBuilder, chunkProvider); addPlayersToSaveTransaction(saveTransactionBuilder, networkSystem); addGlobalStoreBuilderToSaveTransaction(saveTransactionBuilder); addGameManifestToSaveTransaction(saveTransactionBuilder); return saveTransactionBuilder.build(); }
private void addGlobalStoreBuilderToSaveTransaction(SaveTransactionBuilder transactionBuilder) { GlobalStoreBuilder globalStoreBuilder = new GlobalStoreBuilder(getEntityManager(), getPrefabSerializer()); transactionBuilder.setGlobalStoreBuilder(globalStoreBuilder); }
saveTransactionBuilder.setGameManifest(gameManifest);