public ClientChunkGenerator(
IChunkSizePolicy chunkSizePolicy,
IAssetManagerProvider assetManagerProvider)
{
this.m_ChunkSizePolicy = chunkSizePolicy;
this.m_AssetManager = assetManagerProvider.GetAssetManager();
this.m_TextureAtlasAsset = this.m_AssetManager.Get<TextureAtlasAsset>("atlas");
this.m_Pipeline = new ThreadedTaskPipeline<ChunkGenerationRequest>();
var thread = new Thread(this.Run) { IsBackground = true, Priority = ThreadPriority.Highest };
thread.Start();
}
public PredeterminedChunkGeneratorAI(
IProfiler profiler,
IChunkSizePolicy chunkSizePolicy,
IDebugCubeRenderer debugCubeRenderer,
IPredeterminedChunkPositions predeterminedChunkPositions,
IClientChunkFactory clientChunkFactory)
{
this.m_Profiler = profiler;
this.m_ChunkSizePolicy = chunkSizePolicy;
this.m_DebugCubeRenderer = debugCubeRenderer;
this.m_PredeterminedChunkPositions = predeterminedChunkPositions;
this.m_ClientChunkFactory = clientChunkFactory;
this.ShowDebugInfo = "false";
}
public ServerChunkManager(
TychaiaServer server,
IChunkOctreeFactory chunkOctreeFactory,
IChunkGenerator chunkGenerator,
IChunkSizePolicy chunkSizePolicy)
{
this.m_Server = server;
this.m_ChunkOctreeFactory = chunkOctreeFactory;
this.m_ChunkGenerator = chunkGenerator;
this.m_ChunkSizePolicy = chunkSizePolicy;
this.m_RequestedChunks = new ConcurrentQueue<ChunkRequest>();
this.m_ChunkGenerator.InputDisconnect();
}
public DefaultChunkCompressor(IAssetManagerProvider assetManagerProvider, IChunkSizePolicy chunkSizePolicy)
{
this.m_AssetManagerProvider = assetManagerProvider;
this.m_ChunkSizePolicy = chunkSizePolicy;
this.m_ChunkCellArrayLength = this.m_ChunkSizePolicy.ChunkCellWidth * this.m_ChunkSizePolicy.ChunkCellHeight
* this.m_ChunkSizePolicy.ChunkCellDepth;
this.m_BlocksByName =
this.m_AssetManagerProvider.GetAssetManager()
.GetAll()
.OfType<BlockAsset>()
.ToDictionary(key => key.Name, value => value.BlockID);
this.m_BlocksByID =
this.m_AssetManagerProvider.GetAssetManager()
.GetAll()
.OfType<BlockAsset>()
.ToDictionary(key => key.BlockID, value => value.Name);
}
public ServerChunkGenerator(
IChunkSizePolicy chunkSizePolicy,
IAssetManagerProvider assetManagerProvider,
IGeneratorResolver generatorResolver,
IEdgePointCalculator edgePointCalculator,
IChunkConverter chunkConverter,
IChunkCompressor chunkCompressor)
{
this.m_ChunkSizePolicy = chunkSizePolicy;
this.m_EdgePointCalculator = edgePointCalculator;
this.m_AssetManager = assetManagerProvider.GetAssetManager();
this.m_ChunkCompressor = chunkCompressor;
this.m_ChunkConverter = chunkConverter;
this.m_GeneratorPipeline = new ThreadedTaskPipeline<ChunkGenerationRequest>();
this.m_ConverterPipeline = new ThreadedTaskPipeline<ChunkConversionRequest>(false);
this.m_CompressorPipeline = new ThreadedTaskPipeline<ChunkCompressionRequest>(false);
this.m_Generator = generatorResolver.GetGeneratorForGame();
this.m_Generator.SetSeed(10000);
new Thread(this.GeneratorRun)
{
IsBackground = true,
Priority = ThreadPriority.Highest
}.Start();
new Thread(this.ConverterRun)
{
IsBackground = true,
Priority = ThreadPriority.Highest
}.Start();
new Thread(this.CompressorRun)
{
IsBackground = true,
Priority = ThreadPriority.Highest
}.Start();
}
public TychaiaGameWorld(
IAssetManagerProvider assetManagerProvider,
I3DRenderUtilities threedRenderUtilities,
IFilteredFeatures filteredFeatures,
IChunkOctreeFactory chunkOctreeFactory,
IIsometricCameraFactory isometricCameraFactory,
IChunkSizePolicy chunkSizePolicy,
IChunkManagerEntityFactory chunkManagerEntityFactory,
IProfiler profiler,
IConsole console,
ILevelAPI levelAPI /* temporary */,
IGameUIFactory gameUIFactory,
I2DRenderUtilities twodRenderUtilities,
IClientNetworkAPI networkAPI,
IEntityFactory entityFactory,
IChunkConverter chunkConverter,
IChunkCompressor chunkCompressor,
IChunkGenerator chunkGenerator,
ITerrainSurfaceCalculator terrainSurfaceCalculator,
int uniqueClientIdentifier,
Action cleanup,
IViewportMode viewportMode)
{
this.m_3DRenderUtilities = threedRenderUtilities;
this.m_FilteredFeatures = filteredFeatures;
this.m_ChunkSizePolicy = chunkSizePolicy;
this.m_Profiler = profiler;
this.m_Console = console;
this.m_2DRenderUtilities = twodRenderUtilities;
this.m_NetworkAPI = networkAPI;
this.m_EntityFactory = entityFactory;
this.m_ChunkConverter = chunkConverter;
this.m_ChunkCompressor = chunkCompressor;
this.m_ChunkGenerator = chunkGenerator;
this.m_TerrainSurfaceCalculator = terrainSurfaceCalculator;
this.m_UniqueClientIdentifier = uniqueClientIdentifier;
this.m_AssetManagerProvider = assetManagerProvider;
this.m_Cleanup = cleanup;
this.Level = levelAPI.NewLevel("test");
this.m_ViewportMode = viewportMode;
this.m_DefaultFontAsset = this.m_AssetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
this.ChunkOctree = chunkOctreeFactory.CreateChunkOctree<ClientChunk>();
var chunk = new ClientChunk(0, 0, 0);
this.IsometricCamera = isometricCameraFactory.CreateIsometricCamera(this.ChunkOctree, chunk);
this.m_ChunkManagerEntity = chunkManagerEntityFactory.CreateChunkManagerEntity(this);
this.m_InventoryUIEntity = gameUIFactory.CreateInventoryUIEntity();
this.Entities = new List<IEntity> { this.m_ChunkManagerEntity, this.m_InventoryUIEntity };
// TODO: Move this somewhere better.
this.m_NetworkAPI.ListenForMessage(
"player update",
(client, data) =>
{
var playerState = InMemorySerializer.Deserialize<PlayerServerEntity.PlayerServerState>(data);
// Lookup the player entity for this unique client ID if we have one.
var player =
this.Entities.OfType<PlayerEntity>()
.FirstOrDefault(x => x.RuntimeData.UniqueClientIdentifier == playerState.UniqueClientID);
if (player == null)
{
// Need to create a new player entity.
player =
this.m_EntityFactory.CreatePlayerEntity(
new Player { UniqueClientIdentifier = playerState.UniqueClientID });
this.Entities.Add(player);
}
player.X = playerState.X;
player.Y = playerState.Y;
player.Z = playerState.Z;
});
// TODO: Move this somewhere better.
this.m_NetworkAPI.ListenForMessage(
"player leave",
(client, data) =>
{
var playerState = InMemorySerializer.Deserialize<PlayerServerEntity.PlayerServerState>(data);
// Lookup the player entity for this unique client ID if we have one.
var player =
this.Entities.OfType<PlayerEntity>()
.FirstOrDefault(x => x.RuntimeData.UniqueClientIdentifier == playerState.UniqueClientID);
// If we have a player entity, remove it from the world.
if (player != null)
{
this.Entities.Remove(player);
}
});
// TODO: Move this somewhere better.
this.m_NetworkAPI.ListenForMessage(
"chunk available",
(client, data) =>
{
var dataChunk = this.m_ChunkCompressor.Decompress(data);
var clientChunk = this.ChunkOctree.Get(dataChunk.X, dataChunk.Y, dataChunk.Z);
if (clientChunk == null)
{
clientChunk = new ClientChunk(dataChunk.X, dataChunk.Y, dataChunk.Z);
this.ChunkOctree.Set(clientChunk);
}
else if (clientChunk.Generated)
{
// TODO: We already have this chunk. The server shouldn't announce it to
// us because we've already had it sent before, but at the moment the server
// doesn't track this. We just ignore it for now (so we don't recompute
// graphics data).
Console.WriteLine("Chunk is marked as generated, will not reload from server");
return;
}
this.m_ChunkConverter.FromChunk(dataChunk, clientChunk);
this.m_ChunkGenerator.Generate(clientChunk);
});
}
private ServerChunk CreateServerChunk(
IChunkSizePolicy chunkSizePolicy,
long x,
long y,
long z,
Func<long, long, int> heightMapFunc)
{
var size = chunkSizePolicy.ChunkCellWidth * chunkSizePolicy.ChunkCellHeight * chunkSizePolicy.ChunkCellDepth;
var chunk = new ServerChunk(x, y, z) { Cells = new Cell[size] };
for (var xx = 0; xx < chunkSizePolicy.ChunkCellWidth; xx++)
{
for (var yy = 0; yy < chunkSizePolicy.ChunkCellHeight; yy++)
{
for (var zz = 0; zz < chunkSizePolicy.ChunkCellDepth; zz++)
{
var i = xx + (yy * chunkSizePolicy.ChunkCellWidth)
+ (zz * chunkSizePolicy.ChunkCellWidth * chunkSizePolicy.ChunkCellHeight);
chunk.Cells[i].HeightMap = heightMapFunc(xx, zz);
}
}
}
return chunk;
}
public PregenerateWorld(
IAssetManagerProvider assetManagerProvider,
I2DRenderUtilities twodRenderUtilites,
IChunkSizePolicy chunkSizePolicy,
IGenerationPlanner generationPlanner,
IGeneratorResolver generatorResolver,
ILevel level)
{
this.m_AssetManager = assetManagerProvider.GetAssetManager();
this.m_2DRenderUtilities = twodRenderUtilites;
this.m_ChunkSizePolicy = chunkSizePolicy;
this.m_GenerationPlanner = generationPlanner;
this.m_DefaultFont = this.m_AssetManager.Get<FontAsset>("font.Default");
this.m_Entities = new List<IEntity>();
this.m_Status = "Generating world...";
this.m_Level = level;
// Create plan and execute in a seperate thread.
var t = new Thread(() =>
{
var generator = generatorResolver.GetGeneratorForGame();
generator.SetSeed(10000);
var request = this.m_GenerationPlanner.CreateRequest(generator);
this.m_Level.ScanChunks();
for (var x = -1; x <= 1; x++)
for (var y = -1; y <= 1; y++)
for (var z = -1; z <= 1; z++)
{
if (this.m_Level.HasChunk(
x * this.m_ChunkSizePolicy.ChunkCellWidth * this.m_ChunkSizePolicy.CellVoxelWidth,
y * this.m_ChunkSizePolicy.ChunkCellHeight * this.m_ChunkSizePolicy.CellVoxelHeight,
z * this.m_ChunkSizePolicy.ChunkCellDepth * this.m_ChunkSizePolicy.CellVoxelDepth))
continue;
request.AddRegion(
x * this.m_ChunkSizePolicy.ChunkCellWidth,
z * this.m_ChunkSizePolicy.ChunkCellDepth,
y * this.m_ChunkSizePolicy.ChunkCellHeight,
this.m_ChunkSizePolicy.ChunkCellWidth,
this.m_ChunkSizePolicy.ChunkCellDepth,
this.m_ChunkSizePolicy.ChunkCellHeight);
}
for (var x = -10; x <= 10; x++)
for (var z = -10; z <= 10; z++)
{
if (this.m_Level.HasChunk(
x * this.m_ChunkSizePolicy.ChunkCellWidth * this.m_ChunkSizePolicy.CellVoxelWidth,
0,
z * this.m_ChunkSizePolicy.ChunkCellDepth * this.m_ChunkSizePolicy.CellVoxelDepth))
continue;
request.AddRegion(
x * this.m_ChunkSizePolicy.ChunkCellWidth,
z * this.m_ChunkSizePolicy.ChunkCellDepth,
0,
this.m_ChunkSizePolicy.ChunkCellWidth,
this.m_ChunkSizePolicy.ChunkCellDepth,
1);
}
request.Progress += (sender, e) => this.m_Status = "Generating world... " + e.Progress + "%";
request.RegionComplete += (sender, e) =>
{
var cells = new Cell[this.m_ChunkSizePolicy.ChunkCellWidth,
this.m_ChunkSizePolicy.ChunkCellHeight,
this.m_ChunkSizePolicy.ChunkCellDepth];
for (var x = 0; x < e.Region.GeneratedData.GetLength(0); x++)
for (var y = 0; y < e.Region.GeneratedData.GetLength(1); y++)
for (var z = 0; z < e.Region.GeneratedData.GetLength(2); z++)
cells[x, y, z] = e.Region.GeneratedData[x, y, z];
this.m_Level.SaveChunk(
e.Region.X * this.m_ChunkSizePolicy.CellVoxelWidth,
e.Region.Y * this.m_ChunkSizePolicy.CellVoxelHeight,
e.Region.Z * this.m_ChunkSizePolicy.CellVoxelDepth,
cells);
};
this.m_GenerationPlanner.Execute(request);
});
t.IsBackground = true;
t.Start();
}
public SimpleLevel(IChunkSizePolicy chunkSizePolicy, string path)
{
this.m_ChunkSizePolicy = chunkSizePolicy;
this.m_Path = path;
}
public DefaultPositionScaleTranslation(
IChunkSizePolicy chunkSizePolicy)
{
this.m_ChunkVoxelWidth = chunkSizePolicy.CellVoxelWidth * chunkSizePolicy.ChunkCellWidth;
}
