public void saveAll()
{
if (!isServer)
{
Debug.LogError("trying to save the world but i'm not the server!");
return;
}
if (!Directory.Exists(savePath))
{
Directory.CreateDirectory(savePath);
}
List <Chunk> toSave = new List <Chunk>(loadedChunks.Values.Count + saveBuffer.Values.Count);
foreach (var chunk in loadedChunks.Values)
{
toSave.Add(chunk);
}
foreach (var chunk in saveBuffer.Values)
{
if (!toSave.Contains(chunk))
{
toSave.Add(chunk);
}
}
foreach (var chunk in toSave)
{
ChunkSerializer.writeChunkToFile(chunk);
}
}
/// <summary>
/// Save the current chunk in a file
/// </summary>
public void Save()
{
string filename = InfoToFileName(position, trength, seed, threshold, size, noiseScale);
byte[] serialized = ChunkSerializer.Serialize(this);
File.WriteAllBytes(@"save\" + filename, serialized);
}
//if called from a client and the client has to request the chunk, return null
public Chunk getChunk(Vector3Int chunkCoords)
{
if (!chunkInBounds(chunkCoords))
{
return(null);
}
if (loadedChunks.TryGetValue(chunkCoords, out Chunk chunk))
{
if (chunk.valid)
{
return(chunk);
}
else
{
return(null);
}
}
if (isServer)
{
if ((chunk = ChunkSerializer.readChunk(chunkCoords)) != null)
{
loadedChunks.TryAdd(chunkCoords, chunk);
return(chunk);
}
else
{
return(null);
}
}
else
{
WorldManager.singleton.SendRequestChunk(chunkCoords);
return(null);
}
}
//returns true if the chunk successfully loaded (so it needs to be meshed)
public bool loadChunkFromFile(Vector3Int coords)
{
if (!isServer)
{
Debug.LogError("loading chunk from file but i'm not the server!");
return(false);
}
if (!chunkInBounds(coords))
{
return(false);
}
if (loadedChunks.ContainsKey(coords))
{
Debug.Log("loading already loaded chunk");
return(false);
}
else
{
Chunk read = ChunkSerializer.readChunk(coords);
if (read != null)
{
loadedChunks.TryAdd(coords, read);
}
}
return(false);
}
public void Save(string outputFile)
{
string?directory;
if (File.Exists(outputFile) && File.GetAttributes(outputFile).HasFlag(FileAttributes.Directory))
{
directory = outputFile;
}
else
{
directory = Path.GetDirectoryName(outputFile);
}
if (directory == null)
{
return;
}
EngineSerializer engineSerializer = new EngineSerializer();
engineSerializer.Save(this, directory);
GameplaySerializer gameplaySerializer = new GameplaySerializer();
gameplaySerializer.Save(this, directory);
for (int i = 0; i < terrainChunks.Count; i++)
{
ChunkSerializer chunkSerializer = new ChunkSerializer();
chunkSerializer.Save(this, directory, i);
}
}
//client requests block update to server
public static void setBlock(Position pos, Block block)
{
Field message = new Field();
message.addField("pos").setCoordinates(pos);
message.addField("block").setBytes(ChunkSerializer.serializeBlock(block));
send(TCPMessageID.SET_BLOCK, message);
}
void setBlock(Field message)
{
Position pos = message.getField("pos").getCoordinates();
lock (BlockThread.actionLock)
{
pos.getChunk().setBlock(pos, ChunkSerializer.deserializeBlock(message.getField("block").getBytes(), true));
}
}
public ChunkData(Region region, NBTContent chunk)
{
containingRegion = region;
sourceNBT = chunk;
ChunkSerializer.ReadBlocksFromNBT(this, chunk.dataVersion);
RecalculateSectionRange();
ReadEntitiesAndTileEntitiesFromNBT(chunk.contents);
ReadBiomesFromNBT(chunk);
}
public static void WriteChunk(this NetOutgoingMessage message, Chunk chunk)
{
message.Write(chunk.X);
message.Write(chunk.Y);
message.Write(chunk.Z);
var chunkSerializer = new ChunkSerializer();
message.WriteBytesWithCompression(chunkSerializer.ToByteArray(chunk));
}
void LoadChunkFromDisk(Int3 pos)
{
var savePath = WorldSavePath;
using (var file = File.OpenRead(savePath + pos.ToString())) {
using (var reader = new BinaryReader(file)) {
var data = ChunkSerializer.Deserialize(reader);
Task.Factory.StartNew(() => { UnpackChunk(pos, data); });
}
}
}
public static Chunk ReadChunk(this NetIncomingMessage message)
{
var x = message.ReadInt32();
var y = message.ReadInt32();
var z = message.ReadInt32();
var bytes = message.ReadBytesWithCompression();
var chunkSerializer = new ChunkSerializer();
return(chunkSerializer.FromByteArray(x, y, z, bytes));
}
public void Save(ChunkSerializer serializer)
{
serializer.BeginChunk(SOLID_SIMULATION_ID);
for (int y = 0; y < m_layers.Length; ++y)
{
var layer = m_layers[y];
serializer.Write(layer);
}
serializer.EndChunk();
}
public void Serialize(NetworkWriter writer)
{
writer.WriteBoolean(willFulfill);
writer.WriteInt32(chunkPos.x);
writer.WriteInt32(chunkPos.y);
writer.WriteInt32(chunkPos.z);
writer.WriteBoolean(chunk != null);
if (chunk != null)
{
ChunkSerializer.writeChunkToNetwork(chunk, writer);
}
}
public override void ProcessMessage(byte[] rawCommand)
{
base.ProcessMessage(rawCommand);
using (var str = new MemoryStream(rawCommand)) {
using (var reader = new BinaryReader(str)) {
var data = ChunkSerializer.Deserialize(reader);
EventManager.Fire(new OnClientReceiveChunk()
{
Data = data
});
}
}
}
private void saveToolStripMenuItem_Click(object sender, EventArgs e)
{
if (chunkNameBox.Text.Length == 0)
{
MessageBox.Show("Please enter a name for the Chunk", "No Chunk Name", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
SaveFileDialog save = new SaveFileDialog();
save.Filter = "FrostTree Chunk Format|*.ftc";
save.Title = "Save a Chunk";
save.ShowDialog();
if (save.FileName != "")
{
System.IO.FileStream fs = (System.IO.FileStream)save.OpenFile();
switch (save.FilterIndex)
{
case 1:
Chunk c = new Chunk();
c.Name = chunkNameBox.Text;
c.tilemap = new int[Program.RoomHeight * Program.RoomWidth];
for (int i = 0; i < Program.room.GetLength(0); i++)
{
for (int j = 0; j < Program.room.GetLength(0); j++)
{
c.tilemap[(j * Program.RoomHeight) + i] = Program.room[i, j];
}
}
List <Chunk.ChunkAttribute> attribList = new List <Chunk.ChunkAttribute>();
foreach (ListViewItem lvi in listView1.Items)
{
Chunk.ChunkAttribute ca = new Chunk.ChunkAttribute();
ca.AttributeName = lvi.Text;
attribList.Add(ca);
}
c.Attributes = attribList.ToArray();
ChunkSerializer.WriteChunk(fs, c);
break;
}
fs.Close();
}
}
void SendChunkToClient(PlayerChunkLoadState state, ChunkData data, Int3 index)
{
state.SentChunks.Add(index);
var blockCount = (data.Height + 1) * 16 * 16;
using (var str = new MemoryStream(_chunkSendBuffer)) {
using (var writer = new BinaryWriter(str)) {
var count = ChunkSerializer.Serialize(data, writer, true);
var dst = new byte[count];
System.Array.Copy(_chunkSendBuffer, dst, count);
ServerController.Instance.SendRawNetMessage(state.Client, ServerPacketID.ChunkInit, dst, false);
}
}
}
//server updates a block to client
private static void updateBlock(Field message)
{
if (ServerNetworkManager.isServer())
{
return;
}
Position pos = message.getField("pos").getCoordinates();
Block block = ChunkSerializer.deserializeBlock(message.getField("block").getBytes(), false);
if (pos.getChunk() != null)
{
MainThread.runAction(() => pos.getChunk().setBlock(pos, block));
}
}
public void deserialize(byte[] data, int length)
{
if (blocks == null)
{
blocks = new Block[size, size, size];
}
lock (blocks)
{
//Profiler.BeginSample("Loading chunks");
blocksModified = ChunkSerializer.deserializeBlocks(blocks, data, length, ServerNetworkManager.isServer());
deserialized = true;
untouchedChunk = length == 0;
finishInitialization();
}
}
public void Save(ChunkSerializer serializer)
{
serializer.BeginChunk(LIQUID_SIMULATION_ID);
serializer.Write(m_min_dirty_cell_per_layer);
serializer.Write(m_max_dirty_cell_per_layer);
for (int y = 0; y < m_layers.Length; ++y)
{
var layer = m_layers[y];
serializer.Write(layer);
}
serializer.EndChunk();
}
public static void updateBlock(Position pos, Block block)
{
if (!isHosting)
{
return;
}
Field message = new Field();
message.addField("pos").setCoordinates(pos);
message.addField("block").setBytes(ChunkSerializer.serializeBlock(block));
foreach (Client c in clients)
{
c.send(TCPMessageID.UPDATE_BLOCK, message);
}
}
public void Deserialize(NetworkReader reader)
{
willFulfill = reader.ReadBoolean();
chunkPos.x = reader.ReadInt32();
chunkPos.y = reader.ReadInt32();
chunkPos.z = reader.ReadInt32();
if (reader.ReadBoolean())
{
chunk = ChunkSerializer.readChunk(reader);
}
else
{
chunk = null;
}
}
public static void Load(VoxelTerrain terrain)
{
foreach (var file in Directory.GetFiles(LevelPath(terrain.LevelName), "*.chunk"))
{
Debug.Log("Related files: " + file);
Vector3 chunkPosition;
if (!ChunkSerializer.GetChunkPosition(file, out chunkPosition))
{
return;
}
var chunk = terrain.GetChunk((int)chunkPosition.x, (int)chunkPosition.y, (int)chunkPosition.z);
ChunkSerializer.Deserialize(chunk, file);
}
}
public bool LoadTerrain(string fullname)
{
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Open(fullname, FileMode.Open);
ChunkSerializer cs = (ChunkSerializer)bf.Deserialize(file);
file.Close();
if (mainChunk == null)
{
GameObject g = new GameObject("chunk");
mainChunk = g.AddComponent <Chunk>();
}
mainChunk.LoadChunkData(cs);
FollowingCamera.main.WeNeedUpdate();
return(true);
}
void SaveChunkToDisk(Int3 pos, ChunkData data)
{
var savePath = WorldSavePath;
try {
using (var file = File.Create(savePath + pos.ToString())) {
using (var chunkWriter = new BinaryWriter(file)) {
ChunkSerializer.Serialize(data, chunkWriter, true);
}
}
} catch (Exception e) {
UnityEngine.Debug.LogError(e.ToString());
_chunkSaveQueue.Enqueue(new KeyValuePair <Int3, ChunkData>(pos, data)); //Если по какой-то причине не получилось сохраниться на диск, то возвращаем чанк в конец очереди.
}
_saveData.ChunkLibrary.Add(pos);
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
Stream st = null;
OpenFileDialog open = new OpenFileDialog();
open.Filter = "FrostTree Chunk Format|*.ftc";
open.Title = "Load a Chunk";
open.RestoreDirectory = true;
if (open.ShowDialog() == DialogResult.OK)
{
try
{
if ((st = open.OpenFile()) != null)
{
using (st)
{
Chunk c = ChunkSerializer.ReadChunk(st);
clearGUI();
chunkNameBox.Text = c.Name;
foreach (Chunk.ChunkAttribute attr in c.Attributes)
{
listView1.Items.Add(attr.AttributeName);
}
listView1.Invalidate();
for (int i = 0; i < Program.room.GetLength(0); i++)
{
for (int j = 0; j < Program.room.GetLength(0); j++)
{
Program.room[i, j] = c.tilemap[(j * Program.RoomHeight) + i];
}
}
}
}
}
catch (Exception ex)
{
MessageBox.Show("Could not read Chunk from disk. Original error: \n" + ex.Message);
}
}
}
public Chunk GetChunk(int x, int y, int z)
{
var worldX = Mathf.Floor(x / 8f);
var worldY = Mathf.Floor(y / 8f);
var worldZ = Mathf.Floor(z / 8f);
var pos = new Vector3(worldX * 8f, worldY * 8f, worldZ * 8f);
Chunk chunk;
if (!Chunks.TryGetValue(pos, out chunk))
{
var chunkObj = new GameObject();
chunkObj.transform.parent = transform;
chunkObj.name = "chunk_" + worldX + "_" + worldY + "_" + worldZ;
Chunks[pos] = chunk = chunkObj.AddComponent <Chunk>();
chunk.ChunkPosition = pos;
chunk.Parent = this;
chunk.transform.position = pos;
var chunkRender = chunkObj.AddComponent <ChunkRender>();
}
if (!chunk.Loaded)
{
chunk.ChunkPosition = pos;
chunk.Parent = this;
chunk.transform.position = pos;
chunk.Loaded = true;
var filename = string.Format("{0}.{1}.{2}.chunk", pos.x, pos.y, pos.z);
var filepath = Path.Combine(VoxelLoader.LevelPath(LevelName), filename);
if (File.Exists(filepath))
{
Debug.Log("Chunk not loaded, pulling from: " + filepath);
ChunkSerializer.Deserialize(chunk, filepath);
}
else
{
Debug.Log("Skipping load chunk as file does not exist: " + filepath);
}
}
return(chunk);
}
/// <summary>
/// Attempt to load this chunk from a file
/// </summary>
public static Chunk TryLoadFromFile(Vector3Int pos, float trength, long seed, float threshold, ComputeShader compute, MonoBehaviour generator, MeshGenModel.Visualizer visualizer, int size = 16, float noiseScale = 1f)
{
if (!Directory.Exists(@"save\"))
{
Directory.CreateDirectory(@"save\");
}
string filename = InfoToFileName(pos, trength, seed, threshold, size, noiseScale);
if (File.Exists(@"save\" + filename))
{
return(ChunkSerializer.Deserialize(File.ReadAllBytes(@"save\" + filename), compute, generator, visualizer));
}
else
{
return(new Chunk(pos, trength, seed, threshold, compute, generator, visualizer, size, noiseScale));
}
}
public byte[] CreateSaveData()
{
var chunk_serializer = new ChunkSerializer();
m_solid_simulation.Save(chunk_serializer);
m_liquid_simulation.Save(chunk_serializer);
chunk_serializer.Finalize(out var data, out int data_length);
var compressed_stream = new MemoryStream();
using (var dstream = new DeflateStream(compressed_stream, System.IO.Compression.CompressionLevel.Fastest))
{
dstream.Write(data, 0, data_length);
dstream.Close();
return(compressed_stream.ToArray());
}
}
public static void Save(VoxelTerrain terrain, bool onlyDirty)
{
var baseFolder = LevelPath(terrain.LevelName);
Directory.CreateDirectory(baseFolder);
foreach (var chunk in terrain.Chunks.Values)
{
if (onlyDirty && !chunk.IsDataDirty)
{
continue;
}
var pos = chunk.ChunkPosition;
var filename = Path.Combine(baseFolder, string.Format("{0}.{1}.{2}.chunk", pos.x, pos.y, pos.z));
Debug.Log("Saving chunk: " + filename);
ChunkSerializer.Serialize(chunk, filename);
chunk.IsDataDirty = false;
}
}
public World(string savePath, string name, GameObject explosionParticles, bool isServer)
{
if (isServer)
{
this.savePath = savePath;
ChunkSerializer.updateWorldInfo(new WorldInfo {
fileName = name, lastPlayed = System.DateTime.Now
});
if (!Directory.Exists(savePath))
{
Directory.CreateDirectory(savePath);
}
ChunkSerializer.savePath = savePath;
players = new Dictionary <NetworkConnection, Entity>();
}
explosionParticlesPool = Pool <GameObject> .createEntityPool(explosionParticles, this);
infinite = true;
this.isServer = isServer;
}
