void BuildPathFromChunk(ChunkBuilder chunk)
{
//we take into consideration all the stone tiles that have at least 2 empty blocks above
//z
for (int z = 0; z < chunk.GetWorldXZ(); z++)
{
//y
for (int y = 0; y < chunk.GetWorldY(); y++)
{
for (int x = 0; x < chunk.GetWorldXZ(); x++)
{
//x
if (chunk.GetVoxelNameAtPosition(x, y, z) == "Stone")
{
if (chunk.GetVoxelNameAtPosition(x, y + 1, z) == "NULL" && chunk.GetVoxelNameAtPosition(x, y + 2, z) == "NULL")
{
//we add the chunk's position to the voxel's position in the chunk, plus the offset from the corner of the block to the center
Vector3 actualPosition = chunk.gameObject.transform.position + new Vector3(x, y + 1, z) + new Vector3(.5f, .5f, .5f);
m_waypoints.Add(actualPosition);
}
}
}
}
}
}
void Start()
{
//create the new chunk
GameObject newChunk = new GameObject();
newChunk.name = "Chunk at: " + 0 + " : " + 0;
newChunk.AddComponent <ChunkBuilder>();
newChunk.AddComponent <MeshGenerator>();
if (Application.loadedLevel == 4) //we only add the network view if necessary
{
newChunk.AddComponent <NetworkView>();
}
//customise the new chunk
ChunkBuilder cb = newChunk.GetComponent <ChunkBuilder>();
cb.m_world = this;
cb.m_chunkSize = m_chunkSize;
cb.m_chunkHeight = m_chunkHeight;
m_chunk = cb;
//cb.GenerateChunk();
//place player in the middle of it
if (GameObject.FindWithTag("Player"))
{
GameObject.FindWithTag("Player").transform.position = transform.position + new Vector3(m_chunkSize / 2, 7, m_chunkSize / 2);
}
//CreateWorld(m_chunks);
}
static void process_unpacked_tree(ChunkBuilder chb, IEnumerable <string> dirs, Regex r)
{
foreach (var dd in dirs)
{
Console.WriteLine("Scan " + dd);
foreach (string dirn in Directory.GetDirectories(dd))
{
var pdirn = Path.GetFileName(dirn);
Console.WriteLine("Opening " + pdirn);
if (!pdirn.StartsWith("jg2"))
{
continue;
}
pdirn += ".pp";
foreach (var f in Directory.GetFiles(dirn))
{
uint size = (uint)new System.IO.FileInfo(f).Length;
var plain = Path.GetFileName(f);
if (r.Match(plain).Success)
{
chb.AddChunkFile(new ChunkFile(new DirEntry(Path.GetFileName(f), f), pdirn, size));
}
}
}
}
}
static void process_generic_tree(ChunkBuilder chb, String basedir)
{
foreach (string subdir in Directory.GetDirectories(basedir))
{
var subdirname = Path.GetFileName(subdir);
Console.WriteLine(subdirname);
if (subdirname.StartsWith("jg2") || subdirname == "base")
{
subdirname += ".pp";
foreach (var f in Directory.GetFiles(subdir))
{
uint size = (uint)new System.IO.FileInfo(f).Length;
var plain = Path.GetFileName(f);
chb.AddChunkFile(new ChunkFile(new DirEntry(Path.GetFileName(f), f), subdirname, size));
}
}
else
{
foreach (var file in Directory.GetFiles(subdir, "*.*", SearchOption.AllDirectories))
{
var fn = file.Substring(subdir.Length + 1).Replace("\\", "/");
var fi = new System.IO.FileInfo(file);
if ((fi.Attributes & FileAttributes.Directory) == FileAttributes.Directory)
{
continue;
}
uint size = (uint)fi.Length;
chb.AddChunkFile(new ChunkFile(new DirEntry(fn, file), subdirname, size));
}
}
}
}
private void Update()
{
// Move all chunks towards the player
foreach (var chunk in ActiveChunks)
{
var currentPosition = chunk.transform.position;
currentPosition.z += -TurtleState.Instance.CurrentSpeed * GameTime.DeltaTime;
chunk.transform.position = currentPosition;
}
// Destroy the first chunk if it's out of bounds
var firstChunk = ActiveChunks.Peek();
if (firstChunk.transform.position.z > MinZ - ChunkSize.y)
{
return;
}
Destroy(ActiveChunks.Dequeue().gameObject);
// Spawn new chunk at the end
var lastChunkPosition = lastChunk.transform.position;
var newChunk = Instantiate(ChunkPrefab, new Vector3(0, 0, ChunkSize.y) + lastChunkPosition, Quaternion.identity, transform);
newChunk.BuildChunk();
ActiveChunks.Enqueue(newChunk);
lastChunk = newChunk;
}
// simply return contents of the file (if applicable applying its own compression)
// idx and off are values where the file will be stored at - so the callee
// better write it down to talk about it later via meta()
//
// if the file wishes to flush current chunk it is in, it can return true
public void GetData(ChunkBuilder cb, Stream os)
{
cb.FlushOnOverflow((int)orig_size, MAXSIZE, os);
cb.lastf = this;
ushort chp = cb.chpos;
chpos = chp;
chunk_idx = cb.idx;
chunk_off = (uint)cb.buffer.Length;
if (chpos == 0)
{
Debug.Assert(chunk_off == 0);
}
var src = pp.CreateReadStream();
if (naked)
{
var wav = new byte[orig_size];
src.Read(wav, 0, (int)orig_size);
encodeWavToOpus(wav, cb.buffer);
//encodeWavToFLAC(wav, cb.buffer);
}
else
{
src.CopyTo(cb.buffer);
}
}
static void process_pp_files(ChunkBuilder chb, IEnumerable <string> dirs, Regex r)
{
foreach (var dd in dirs)
{
foreach (string fn in Directory.GetFiles(dd, "*.pp"))
{
Console.Write("Opening " + fn);
if (fn.EndsWith("base.pp"))
{
continue;
}
ppParser pp = new ppParser(fn);
int nmatch = 0;
foreach (ppSubfile file in pp.Subfiles)
{
//Console.WriteLine(ext);
if (r.Match(file.Name).Success)
{
chb.AddChunkFile(new ChunkFile(file, Path.GetFileName(file.ppPath), file.size));
nmatch++;
}
}
Console.WriteLine("..." + nmatch + " files matched");
//if (nfm-- == 0) break;
}
}
}
void BuildPathFromChunk(ChunkBuilder chunk)
{
//we take into consideration all the stone tiles that have at least 2 empty blocks above
//z
for (int z = 0; z < chunk.GetWorldXZ(); z++)
{
//y
for (int y = 0; y < chunk.GetWorldY(); y++)
{
for (int x = 0; x < chunk.GetWorldXZ(); x++)
{
//x
if (chunk.GetVoxelNameAtPosition(x,y,z) == "Stone")
{
if (chunk.GetVoxelNameAtPosition(x, y + 1, z) == "NULL" && chunk.GetVoxelNameAtPosition(x, y + 2, z) == "NULL")
{
//we add the chunk's position to the voxel's position in the chunk, plus the offset from the corner of the block to the center
Vector3 actualPosition = chunk.gameObject.transform.position + new Vector3(x, y + 1, z) + new Vector3 (.5f, .5f, .5f);
m_waypoints.Add(actualPosition);
}
}
}
}
}
}
private void BuildLighting()
{
if (filter.sharedMesh != null)
{
ChunkBuilder.BuildChunkLighting(filter.sharedMesh, chunk);
}
}
public static void LogDirty(ChunkBuilder dirtyBuilder)
{
if (!_dirtyBuilders.ContainsKey(dirtyBuilder.Position))
{
_dirtyBuilders.Add(dirtyBuilder.Position, dirtyBuilder);
}
}
public Stack <Vector3> BreadthFirstSearch(Vector3 start, Vector3 end, ChunkBuilder chunk, bool checkForDirt)
{
Stack <Vector3> waypoints = new Stack <Vector3>();
Dictionary <Vector3, Vector3> visitedParent = new Dictionary <Vector3, Vector3>();
Queue <Vector3> q = new Queue <Vector3>();
bool found = false;
Vector3 current = start;
q.Enqueue(start);
while (q.Count > 0 && !found)
{
current = q.Dequeue();
if (current != end)
{
// our adjacent nodes are x+1, x-1, z+1 and z-1
List <Vector3> neighbourList = new List <Vector3>();
neighbourList.Add(current + new Vector3(1, 0, 0)); // x+1
neighbourList.Add(current + new Vector3(-1, 0, 0)); // x-1
neighbourList.Add(current + new Vector3(0, 0, 1)); // z+1
neighbourList.Add(current + new Vector3(0, 0, -1)); // z-1
foreach (Vector3 n in neighbourList)
{
// check if n is within the terrain array range
if ((n.x >= 0 && n.x < chunk.m_chunkSize) && n.z >= 0 && n.z < chunk.m_chunkSize)
{
// check if we can traverse over this
if (IsTraversable(n, chunk.m_terrainArray, checkForDirt))
{
// check if node is already processed
if (!visitedParent.ContainsKey(n))
{
visitedParent[n] = current;
q.Enqueue(n);
}
}
}
}
}
else
{
found = true;
}
}
// solution was found, so we can build a path of waypoints
if (found)
{
while (current != start)
{
waypoints.Push(current + m_offset);
current = visitedParent[current];
}
waypoints.Push(start + m_offset);
}
return(waypoints);
}
public RoomBuilder(ChunkBuilder chunkBuilder)
: base(chunkBuilder)
{
_size = Chance.Range(2, 7);
_centerpoint = new IntVector2(Chance.Range(_chunkBuilder.BottomLeftCorner.X, _chunkBuilder.TopRightCorner.X),
Chance.Range(_chunkBuilder.BottomLeftCorner.Y, _chunkBuilder.TopRightCorner.Y));
Rebuild();
}
public async Task <Chunk> GenerateChunkAsync(int cx, int cz, World world, Chunk chunk = null)
{
if (chunk is null)
{
chunk = new Chunk(cx, cz);
}
// Sanity check
if (chunk.isGenerated)
{
return(chunk);
}
// Build terrain map for this chunk
var terrainHeightmap = new double[16, 16];
var rockHeightmap = new double[16, 16];
var bedrockHeightmap = new double[16, 16];
for (int bx = 0; bx < 16; bx++)
{
for (int bz = 0; bz < 16; bz++)
{
int worldX = bx + (cx << 4);
int worldZ = bz + (cz << 4);
terrainHeightmap[bx, bz] = terrainGen.GetValue(worldX, worldZ);
//chunk.Heightmaps[ChunkData.HeightmapType.MotionBlocking].Set(bx, bz, (int)terrainHeightmap[bx, bz]);
//chunk.Heightmaps[ChunkData.HeightmapType.OceanFloor].Set(bx, bz, (int)terrainHeightmap[bx, bz]);
rockHeightmap[bx, bz] = terrainGen.GetValue(worldX, worldZ) - 5;
bedrockHeightmap[bx, bz] = -30; // noiseGen.Bedrock(worldX, worldZ) + 1;
// Determine Biome
if (bx % 4 == 0 && bz % 4 == 0) // Biomes are in 4x4x4 blocks. Do a 2D array for now and just copy it vertically.
{
var b = ChunkBiome.GetBiome(worldX, worldZ, terrainGen);
for (int y = -64; y < 320; y += 4)
{
chunk.SetBiome(bx, y, bz, b);
}
}
}
}
ChunkBuilder.FillChunk(chunk, terrainHeightmap, bedrockHeightmap);
ChunkBuilder.CarveCaves(terrainGen, chunk, terrainHeightmap, bedrockHeightmap);
await OverworldDecorator.DecorateAsync(chunk, terrainHeightmap, terrainGen, world);
for (int bx = 0; bx < 16; bx++)
{
for (int bz = 0; bz < 16; bz++)
{
chunk.Heightmaps[ChunkData.HeightmapType.MotionBlocking].Set(bx, bz, (int)terrainHeightmap[bx, bz]);
}
}
chunk.isGenerated = true;
return(chunk);
}
public WorldGeneration(World world, WorldGenerator worldGenerator, Camera camera, Player player, ChunkBuilder chunkBuilder, DiagnosticsService diagnosticsService)
{
_world = world;
_worldGenerator = worldGenerator;
_camera = camera;
_player = player;
_chunkBuilder = chunkBuilder;
_diagnosticsService = diagnosticsService;
}
public MonsterDenBuilder(ChunkBuilder chunkBuilder)
: base(chunkBuilder)
{
_centerpoint = new IntVector2(Chance.Range(_chunkBuilder.BottomLeftCorner.X, _chunkBuilder.TopRightCorner.X),
Chance.Range(_chunkBuilder.BottomLeftCorner.Y, _chunkBuilder.TopRightCorner.Y));
_radius = Chance.Range(8, 20);
OnSpaceBuilderChanged.Raise(this);
}
public override void Construct(ChunkBuilder builder)
{
for (int x = 0; x < 10; x++)
{
for (int y = 0; y < 10; y++)
{
builder.BuildFloor(x, y);
}
}
}
private void RebuildChunks()
{
ActiveChunks = new Queue <ChunkBuilder>();
for (var z = MinZ + SkipChunks * ChunkSize.y; z < MaxZ + SkipChunks * ChunkSize.y; z += ChunkSize.y)
{
var chunk = Instantiate(ChunkPrefab, new Vector3(0, 0, z), Quaternion.identity, transform);
chunk.BuildChunk();
ActiveChunks.Enqueue(chunk);
lastChunk = chunk;
}
}
public ShaftBuilder(ChunkBuilder chunkBuilder)
: base(chunkBuilder)
{
_width = Chance.Range(1, 10);
_height = Chance.Range(_width + 1, 100);
var startingPoint = new IntVector2(Chance.Range(chunkBuilder.BottomLeftCorner.X, chunkBuilder.TopRightCorner.X),
Chance.Range(chunkBuilder.BottomLeftCorner.Y, chunkBuilder.TopRightCorner.Y));
SetStartingPoint(startingPoint, Enum <ShaftAlignment> .Random);
}
public CorridorBuilder(ChunkBuilder chunkBuilder)
: base(chunkBuilder)
{
_height = Chance.Range(1, 10);
_length = Chance.Range(_length + 1, 100);
var startingPoint = new IntVector2(Chance.Range(_chunkBuilder.BottomLeftCorner.X, _chunkBuilder.TopRightCorner.X),
Chance.Range(_chunkBuilder.BottomLeftCorner.Y, _chunkBuilder.TopRightCorner.Y));
SetStartingPoint(startingPoint, Enum <CorridorAlignment> .Random);
}
private SpaceBuilder RandomlySelect(ChunkBuilder cBuilder)
{
var spaceBuilder = Activator.CreateInstance(_allowedSpaces.RandomItem(), cBuilder) as SpaceBuilder;
if (Chance.OneIn(4))
{
spaceBuilder.AddModifier(ModifierTypes.Cavernous);
}
return(spaceBuilder);
}
private void Build()
{
filter.sharedMesh = ChunkBuilder.BuildChunk(filter.sharedMesh, chunk);
if (filter.sharedMesh == null)
{
Destroy(gameObject);
return;
}
GetComponent <Renderer>().sharedMaterials = blockSet.GetMaterials(filter.sharedMesh.subMeshCount);
}
private void LabelBuilderCreationOrder(ChunkBuilder builder, int creationOrder)
{
var _loadOrderStyle = new GUIStyle()
{
alignment = TextAnchor.MiddleCenter,
fontSize = 25
};
var centerpoint = GeometryTools.CenterOfRectangle(builder.TopRightCorner, builder.BottomLeftCorner);
Handles.Label(centerpoint, creationOrder.ToString(), _loadOrderStyle);
}
public void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(gameObject);
}
else
{
_instance = this;
_chunk = Instantiate(chunkPrefab);
}
}
public void BuildSingleChunk()
{
// Arrange
var maxChunkSize = 100;
var tokenValue = "<xml>small<xml>";
var paramToken = new ParamValue(ParamValue.Param.token, tokenValue);
var chunkBuilder = new ChunkBuilder(maxChunkSize);
// Act
var remaining = chunkBuilder.Append(paramToken);
var actual = chunkBuilder.GetValue();
// Assert
Assert.IsNull(remaining);
Assert.AreEqual($"{ParamValue.Param.token}=\"{tokenValue}\"", actual);
}
public override void Construct(ChunkBuilder builder)
{
for (int x = 0; x < 10; x++)
{
for (int y = 0; y < 10; y++)
{
if (x == 5 || y == 5)
{
builder.BuildFloor(x, y);
}
else
{
builder.BuildWall(x, y);
}
}
}
}
static void process_textures(ChunkBuilder chb, String bdir, Regex r)
{
foreach (var f in Directory.GetFiles(bdir, "*.*", SearchOption.AllDirectories))
{
var fn = f.Substring(bdir.Length + 1).Replace("\\", "/");
var fi = new System.IO.FileInfo(f);
if ((fi.Attributes & FileAttributes.Directory) == FileAttributes.Directory)
{
continue;
}
uint size = (uint)fi.Length;
if (r.Match(fn).Success)
{
chb.AddChunkFile(new ChunkFile(new DirEntry(fn, f), "texture", size));
}
}
}
public void ExceedChunkSize()
{
// Arrange
var tokenValue = "123456";
var maxChunkSize = 10;
var paramToken = new ParamValue(ParamValue.Param.token, tokenValue);
var chunkBuilder = new ChunkBuilder(maxChunkSize);
// Act
var remaining = chunkBuilder.Append(paramToken);
var actual = chunkBuilder.GetValue();
// Assert
Assert.AreEqual($"{ParamValue.Param.token}=\"12\"", actual);
Assert.NotNull(remaining);
Assert.AreEqual(ParamValue.Param.token, remaining.Key);
Assert.AreEqual("3456", remaining.Value);
}
private static void Build(BuilderController builderController)
{
var dbChunk = new DbChunk(Settings.Current.Building.BuilderConnectionString);
int? chunkId = null;
while (true)
{
try
{
builderController.RefreshState();
if (builderController.Builder.State == BuilderState.Stopping)
break;
if (builderController.Builder.State == BuilderState.Stopped)
break;
if (builderController.Builder.State == BuilderState.Error)
break;
if (builderController.Builder.State == BuilderState.Unknown || builderController.Builder.State == BuilderState.Idle)
continue;
chunkId = dbChunk.TakeChunk(Settings.Current.Building.Id.Value);
if (!chunkId.HasValue) break;
var builder = new ChunkBuilder(new ChunkData { Id = chunkId.Value }, GetBuilderType(Settings.Current.Building.Vendor));
var loaded_chunk = builder.Load();
var built_chunk = loaded_chunk.Build();
var task = built_chunk.Save();
tasks.Add(task);
}
catch (Exception e)
{
if (chunkId.HasValue)
Logger.WriteError(chunkId, e);
else
Logger.Write(null, Settings.Current.Building.Id.Value, null, LogMessageTypes.Error, Logger.CreateExceptionString(e));
builderController.UpdateState(BuilderState.Error);
}
}
}
IEnumerator RenderChunk()
{
//Debug.Log ("Rendering chunk...");
bool isDone = false;
ChunkMeshObject cmo = null;
Thread t = new Thread(() => {
cmo = ChunkBuilder.BuildChunk(this);
isDone = true;
});
t.Start();
while (!isDone)
{
yield return(null);
}
Mesh m = new Mesh();
m.name = "ChunkMesh-" + x + "-" + y;
m.vertices = cmo.verts.ToArray();
m.triangles = cmo.tris.ToArray();
m.uv = cmo.uvs.ToArray();
m.RecalculateBounds();
m.RecalculateNormals();
m.RecalculateTangents();
if (GetComponent <MeshFilter> () == null)
{
this.gameObject.AddComponent <MeshFilter> ().mesh = m;
this.gameObject.AddComponent <MeshRenderer> ().material = World.instance.material;
}
else
{
GetComponent <MeshFilter> ().mesh = m;
}
//Debug.Log ("Chunk " + x + "," + y + " renderered");
}
bool PickEmptyBlock(out Vector3 v, float dist)
{
v = new Vector3();
Ray ray = Camera.main.ScreenPointToRay(new
Vector3(Screen.width / 2, Screen.height / 2, 0));
RaycastHit hit;
if (Physics.Raycast(ray, out hit, dist))
{
//see above
m_activeChunk = hit.collider.GetComponent <MeshGenerator>().m_parent;
// offset towards centre of the neighbouring block
v = hit.point + hit.normal / 2;
// round down to get the index of the empty
v.x = Mathf.Floor(v.x - m_activeChunk.transform.position.x);
v.y = Mathf.Floor(v.y - m_activeChunk.transform.position.y);
v.z = Mathf.Floor(v.z - m_activeChunk.transform.position.z);
return(true);
}
return(false);
}
private void CreateChunkInstance()
{
_Chunk = GameObject.Instantiate(ChunkBuilder.GetChunkLOD(this._Lod));
_Chunk.SetActive(true);
_Chunk.transform.parent = this._Parent;
_Chunk.isStatic = true;
_Chunk.transform.localPosition = _LocalPosition;
_Chunk.transform.localRotation = Quaternion.identity;
MeshFilter filter = _Chunk.GetComponent <MeshFilter>();
Mesh newMesh = UpdateMesh(filter.mesh);
filter.mesh = newMesh;
if (_Lod <= 3)
{
MeshCollider col = _Chunk.GetComponent <MeshCollider>();
col.enabled = true;
col.sharedMesh = newMesh;
}
}
bool PickThisBlock(out Vector3 v, out ChunkBuilder voxelChunkScript, float dist)
{
v = new Vector3();
voxelChunkScript = null;
RaycastHit hit;
if (Physics.Raycast(transform.position, Vector3.down, out hit, dist))
{
// check if the target we hit has a VoxelChunk script
voxelChunkScript = hit.collider.gameObject.GetComponent<ChunkBuilder>();
if (voxelChunkScript != null)
{
// offset toward centre of the block hit
v = hit.point - hit.normal / 2;
// round down to get the index of the block hit
v.x = Mathf.Floor(v.x);
v.y = Mathf.Floor(v.y);
v.z = Mathf.Floor(v.z);
return true;
}
}
return false;
}
public override Chunk GenerateChunk(int cx, int cz)
{
var chunk = new Chunk(cx, cz);
// Build terrain map for this chunk
var terrainHeightmap = new double[16, 16];
var rockHeightmap = new double[16, 16];
var bedrockHeightmap = new double[16, 16];
for (int bx = 0; bx < 16; bx++)
{
for (int bz = 0; bz < 16; bz++)
{
int worldX = bx + (cx << 4);
int worldZ = bz + (cz << 4);
terrainHeightmap[bx, bz] = noiseGen.Terrain(worldX, worldZ);
rockHeightmap[bx, bz] = noiseGen.Underground(worldX, worldZ) + terrainHeightmap[bx, bz] - 5;
bedrockHeightmap[bx, bz] = noiseGen.Bedrock(worldX, worldZ) + 1;
// Determine Biome
if (bx % 4 == 0 && bz % 4 == 0) // Biomes are in 4x4x4 blocks. Do a 2D array for now and just copy it vertically.
{
var b = ChunkBiome.GetBiome(worldX, worldZ, noiseGen);
for (int y = 0; y < 256; y += 4)
{
chunk.BiomeContainer.SetBiome(bx, y, bz, b);
}
}
}
}
ChunkBuilder.FillChunk(chunk, terrainHeightmap, rockHeightmap, bedrockHeightmap);
OverworldDecorator.Decorate(chunk, terrainHeightmap, noiseGen);
GenerateCoal(chunk, rockHeightmap);
ChunkBuilder.CarveCaves(noiseGen, chunk, rockHeightmap, bedrockHeightmap);
return(chunk);
}
public Stack<Vector3> BreadthFirstSearch(Vector3 start, Vector3 end, ChunkBuilder chunk, bool checkForDirt)
{
Stack<Vector3> waypoints = new Stack<Vector3>();
Dictionary<Vector3, Vector3> visitedParent = new Dictionary<Vector3, Vector3>();
Queue<Vector3> q = new Queue<Vector3>();
bool found = false;
Vector3 current = start;
q.Enqueue(start);
while (q.Count > 0 && !found)
{
current = q.Dequeue();
if (current != end)
{
// our adjacent nodes are x+1, x-1, z+1 and z-1
List<Vector3> neighbourList = new List<Vector3>();
neighbourList.Add(current + new Vector3(1, 0, 0)); // x+1
neighbourList.Add(current + new Vector3(-1, 0, 0)); // x-1
neighbourList.Add(current + new Vector3(0, 0, 1)); // z+1
neighbourList.Add(current + new Vector3(0, 0, -1)); // z-1
foreach (Vector3 n in neighbourList)
{
// check if n is within the terrain array range
if ((n.x >= 0 && n.x < chunk.m_chunkSize) && n.z >= 0 && n.z < chunk.m_chunkSize)
{
// check if we can traverse over this
if (IsTraversable(n, chunk.m_terrainArray, checkForDirt))
{
// check if node is already processed
if (!visitedParent.ContainsKey(n))
{
visitedParent[n] = current;
q.Enqueue(n);
}
}
}
}
}
else
{
found = true;
}
}
// solution was found, so we can build a path of waypoints
if (found)
{
while (current != start)
{
waypoints.Push(current + m_offset);
current = visitedParent[current];
}
waypoints.Push(start + m_offset);
}
public OptumPersonBuilder(ChunkBuilder chunkBuilder)
: base(chunkBuilder)
{
}
public DrugEraPersonBuilder(ChunkBuilder chunkBuilder)
: base(chunkBuilder)
{
}
void Start()
{
//create the new chunk
GameObject newChunk = new GameObject();
newChunk.name = "Chunk at: " + 0 + " : " + 0;
newChunk.AddComponent<ChunkBuilder>();
newChunk.AddComponent<MeshGenerator>();
if (Application.loadedLevel == 4) //we only add the network view if necessary
{
newChunk.AddComponent<NetworkView>();
}
//customise the new chunk
ChunkBuilder cb = newChunk.GetComponent<ChunkBuilder>();
cb.m_world = this;
cb.m_chunkSize = m_chunkSize;
cb.m_chunkHeight = m_chunkHeight;
m_chunk = cb;
//cb.GenerateChunk();
//place player in the middle of it
if (GameObject.FindWithTag("Player"))
{
GameObject.FindWithTag("Player").transform.position = transform.position + new Vector3(m_chunkSize / 2, 7, m_chunkSize/ 2);
}
//CreateWorld(m_chunks);
}
public NhanesPersonBuilder(ChunkBuilder chunkBuilder)
: base(chunkBuilder)
{
}
