// private static bool getAlreadyDone(bool[,] colDoneCheckList, PTwo co) // { // AssertUtil.Assert(! (co.area() >= colDoneCheckList.GetLength(0) * colDoneCheckList.GetLength(1)), "problems with col done checklist out of bounds:" + // "" + co.toString() + " check list length: " + colDoneCheckList.Length); // // return colDoneCheckList[co.s, co.t]; // } // // private static void setTrueAlreadyDone(ref bool[,] colDoneCheckList, PTwo co) // { // AssertUtil.Assert(! (co.area() >= colDoneCheckList.GetLength(0) * colDoneCheckList.GetLength(1)), "problems with col done checklist out of bounds:" + // "" + co.toString() + " check list length: " + colDoneCheckList.Length); // // colDoneCheckList[co.s, co.t] = true; // } #region debug void addColumnIfNoiseCoordOO(LightColumn lcol) { if (NoiseCoord.Equal(this.m_noisePatch.coord, new NoiseCoord(0, 0))) { ChunkManager.debugLinesAssistant.addColumn(lcol.toColumnDebug(), this.debugTimeDrewDebugColm++, m_noisePatch.coord); } }
static void drawDebugLinesForNoisePatch(NoiseCoord nco, Color col, int offset) { Coord woco = worldCoordForNoiseCoord(nco) + offset; Coord dims = new Coord(ChunkManager.CHUNKLENGTH * NoisePatch.CHUNKDIMENSION, ChunkManager.CHUNKHEIGHT, ChunkManager.CHUNKLENGTH * NoisePatch.CHUNKDIMENSION) - 3; drawDebugCube(woco, dims, col); }
public NoisePatch noisePatchAtNoiseCoord(NoiseCoord nco) { if (!m_noisePatches.ContainsKey(nco)) { return(null); } return(noisePatches [nco]); }
public bool noisePatchAtNoiseCoordHasBuiltOrIsBuildingCurrently(NoiseCoord nco) { if (!m_noisePatches.ContainsKey(nco)) { return(false); } return(m_noisePatches[nco].hasStarted || m_noisePatches[nco].IsDone); }
public bool noisePatchAtNoiseCoordHasBuiltAtleastOnce(NoiseCoord nco) { if (!m_noisePatches.ContainsKey(nco)) { return(false); } return(!m_noisePatches[nco].hasStarted && noisePatches[nco].IsDone); }
public NoisePatch noisePatchAtWorldCoord(Coord woco) { NoiseCoord nco = noiseCoordForWorldCoord(woco); if (!m_noisePatches.ContainsKey(nco)) { return(null); } return(noisePatches [nco]); }
public static void drawDebugQuad(Quad quad, Color col) { Coord start = CoordUtil.WorldCoordFromNoiseCoord(NoiseCoord.NoiseCoordWithPTwo(quad.origin)); Coord outer = CoordUtil.WorldCoordFromNoiseCoord(NoiseCoord.NoiseCoordWithPTwo(quad.extent())); //lower box debugLine(start, new Coord(start.x, start.y, outer.z), col); debugLine(start, new Coord(outer.x, start.y, start.z), col); debugLine(new Coord(outer.x, start.y, outer.z), new Coord(start.x, start.y, outer.z), col); debugLine(new Coord(outer.x, start.y, outer.z), new Coord(outer.x, start.y, start.z), col); }
public void GenerateAltAtNoiseCoord(NoiseCoord _noiseCoord) { float left = (float)_noiseCoord.x * 2.0f; float right = left + 2.0f; float top = (float)_noiseCoord.z * 2.0f; float bottom = top + 2.0f; this.m_altNoiseMap.GeneratePlanar( left, right, top, bottom); }
public static bool NoiseCoordWithinTestLimits(NoiseCoord nco) { if (TestRunner.RunGameOnlyNoisPatchesWithinWorldLimits) { int xstart, zstart, xend, zend; xstart = TestRunner.WorldLimits.start.x; xend = TestRunner.WorldLimits.outerLimit().x; zstart = TestRunner.WorldLimits.start.z; zend = TestRunner.WorldLimits.outerLimit().z; return(xstart < nco.x && xend > nco.x && zstart < nco.z && zend > nco.z); } return(true); }
public static List <Coord> WorldRelativeChunkCoordsWithinNoiseCoord(NoiseCoord nco) { Coord chCoOrigin = WorldRelativeChunkCoordForNoiseCoord(nco); List <Coord> result = new List <Coord>(); for (int i = 0; i < NoisePatch.CHUNKDIMENSION; ++i) { for (int j = 0; j < NoisePatch.CHUNKDIMENSION; ++j) { result.Add(chCoOrigin + new Coord(i, 0, j)); } } return(result); }
//get the light columns at any woco that exists... public DiscreteDomainRangeList <LightColumn> lightColumnsAtWoco(int x, int z, NoiseCoord _noiseCoord) { Coord woconoco = CoordUtil.WorldCoordFromNoiseCoord(_noiseCoord); NoiseCoord nco = CoordUtil.NoiseCoordForWorldCoord(new Coord(x, 0, z) + woconoco); NoisePatch npatch = m_chunkManager.blocks.noisePatchAtNoiseCoord(nco); if (npatch == null) { return(null); } Coord pRelCo = CoordUtil.PatchRelativeBlockCoordForWorldBlockCoord(new Coord(x, 0, z)); // noisepatch return lightcol map at rel co return(npatch.lightColumnsAt(PTwo.PTwoXZFromCoord(pRelCo))); }
public void addNoisePatchAt(NoiseCoord nco, NoisePatch _npatch) { m_noisePatches.Add(nco, _npatch); //domain limits if (Quad.Equal(this.domain, Quad.theErsatzNullQuad())) { //first time domain = new Quad(new PTwo(nco.x, nco.z), PTwo.PTwoOne()); } else { domain = domain.expandedToContainPoint(new PTwo(nco.x, nco.z)); } ChunkManager.debugLinesAssistant.debugQuad = domain; }
private void enlargeDomain() { foreach (KeyValuePair <NoiseCoord, NoisePatch> keyVal in m_noisePatches) { NoiseCoord nco = keyVal.Key; if (domain.isErsatzNull()) { domain = Quad.UnitQuadWithPoint(PTwo.PTwoXZFromNoiseCoord(nco)); } else { domain.expandedToContainPoint(PTwo.PTwoXZFromNoiseCoord(nco)); } } //debug ChunkManager.debugLinesAssistant.debugQuad = domain; }
public bool noisePatchAtCoordIsReady(NoiseCoord nco) { #if NEW_PATCH_READY if (noisePatchAtNoiseCoordHasBuiltAtleastOnce(nco)) { return(m_noisePatches[nco].neighborsHaveAllBuiltAtLeastOnce); } return(false); #endif if (!m_noisePatches.ContainsKey(nco)) { return(false); } #if NEW_PATCH_READY #else return(noisePatches[nco].generatedBlockAlready); #endif }
public Block this[Coord woco] { get { NoiseCoord nco = noiseCoordForWorldCoord(woco); if (!m_noisePatches.ContainsKey(nco)) { return(null); } NoisePatch np = m_noisePatches [nco]; return(np.blockAtWorldBlockCoord(woco)); } set { NoisePatch np = m_noisePatches [noiseCoordForWorldCoord(woco)]; np.setBlockAtWorldCoord(value, woco); } }
public void addColumn(Column column, int handyInt, NoiseCoord nco) { int index = columns.IndexOf(column); if (index >= 0) { Column col = columns[index]; col.handyInteger = handyInt; // column.handyInteger; col.noiseCoord = nco; columns[index] = col; } else { column.noiseCoord = nco; column.handyInteger = handyInt; columns.Add(column); } // if (!columns.Contains(column)) // columns.Add(column); }
public void destroyPatchAt(NoiseCoord nco) { if (m_noisePatches.ContainsKey(nco)) { NoisePatch npToDestroy = m_noisePatches[nco]; if (npToDestroy.hasStarted || !npToDestroy.IsDone) { return; } bool destroyed = m_noisePatches.Remove(nco); if (!destroyed) { throw new Exception("failed to destroy..." + nco.toString()); } } else { b.bug("we don't have the key: " + nco.toString()); } }
public static void drawDebugCubesForAllCreatedNoisePatches(NoiseCoord currentTargetedForCreationNoiseCo, Dictionary <NoiseCoord, NoisePatch> noisePatchDictionary) { if (!noisePatchDictionary.ContainsKey(currentTargetedForCreationNoiseCo)) { return; } // current to be created n patch NoisePatch curTargeted = noisePatchDictionary[currentTargetedForCreationNoiseCo]; // Color tarCol = curTargeted.generatedBlockAlready ? Color.gray : Color.yellow; Color tarCol = curTargeted.IsDone ? Color.gray : Color.yellow; tarCol = curTargeted.hasStarted ? new Color(.3f, 1f, .9f, 1f) : tarCol; //TODO: create a coroutine for getting rid of noisepatches that are far away? drawDebugLinesForNoisePatch(currentTargetedForCreationNoiseCo, tarCol); foreach (KeyValuePair <NoiseCoord, NoisePatch> npatch in noisePatchDictionary) { NoiseCoord nco = npatch.Key; if (NoiseCoord.Equal(nco, currentTargetedForCreationNoiseCo)) { continue; } NoisePatch np = npatch.Value; Color col = np.hasStarted ? Color.magenta : Color.cyan; if (np.IsDone) { col = Color.green; } drawDebugLinesForNoisePatch(nco, col); } }
public static Coord WorldCoordFromNoiseCoord(NoiseCoord nCo) { return(new Coord(nCo.x, 0, nCo.z) * NoisePatch.patchDimensions); }
public bool Equals(Column other) { return(this.range.start == other.range.start && this.range.range == other.range.range && PTwo.Equal(this.xz, other.xz) && NoiseCoord.Equal(this.noiseCoord, other.noiseCoord)); }
public void startTrackingDiscontinuityWithRanges(List <Range1D> heightRangesAtCoord, PTwo patchRelCoord, NoiseCoord noiseCoord) { //check whether there's discontinuity here }
static Coord worldCoordForNoiseCoord(NoiseCoord nco) { int blocksPerPatch = (int)(NoisePatch.CHUNKDIMENSION * ChunkManager.CHUNKLENGTH); return(new Coord(nco * blocksPerPatch)); }
// TODO: rewrite to return just one far away nco? public List <NoiseCoord> furthestNoiseCoords() { List <NoiseCoord> result = new List <NoiseCoord>(); if (domain.dimensions.s < 3 || domain.dimensions.t < 3) { return(result); } List <PTwo> pCoords = CoordUtil.PointsJustInsideBorderOfQuad(this.domain); NoiseCoord nco; foreach (PTwo point in pCoords) { nco = NoiseCoord.NoiseCoordWithPTwo(point); if (m_noisePatches.ContainsKey(nco)) { result.Add(nco); } } if (result.Count == 0) { //trim domain.origin += new PTwo(1); domain.dimensions -= new PTwo(1); } return(result); //// *********** //// *********** //// *********** //// *********** NoiseCoord xnudge = new NoiseCoord(1, 0); NoiseCoord znudge = new NoiseCoord(0, 1); //mins (traverse min edge of domain on the z and x sides until we find a coord contained in noisePatches) if (m_noisePatches.ContainsKey(NoiseCoord.NoiseCoordWithPTwo(domain.origin))) { result.Add(NoiseCoord.NoiseCoordWithPTwo(domain.origin)); } else { // xmin z NoiseCoord xminz = NoiseCoord.NoiseCoordWithPTwo(domain.origin); while (xminz.z < domain.extent().t) { xminz += znudge; if (m_noisePatches.ContainsKey(xminz)) { result.Add(xminz); break; } if (xminz.z == domain.extent().t - 1) { domain.origin.s++; domain.dimensions.s--; } } NoiseCoord zminx = NoiseCoord.NoiseCoordWithPTwo(domain.origin); while (zminx.x < domain.extent().s) { zminx += xnudge; if (m_noisePatches.ContainsKey(zminx)) { result.Add(zminx); break; } if (zminx.x == domain.extent().s - 1) { domain.origin.t++; domain.dimensions.t--; } } } //maxes NoiseCoord extentCoord = NoiseCoord.NoiseCoordWithPTwo(domain.extent()); if (m_noisePatches.ContainsKey(extentCoord)) { result.Add(extentCoord); } else { NoiseCoord xmaxz = extentCoord; while (xmaxz.z >= domain.origin.t) { xmaxz -= znudge; if (m_noisePatches.ContainsKey(xmaxz)) { result.Add(xmaxz); break; } if (xmaxz.z == domain.origin.t) { domain.dimensions.s--; } } NoiseCoord zmaxx = extentCoord; while (zmaxx.x >= domain.origin.s) { zmaxx -= xnudge; if (m_noisePatches.ContainsKey(zmaxx)) { result.Add(zmaxx); break; } if (zmaxx.x == domain.origin.s) { domain.dimensions.t--; } } } return(result); }
static void drawDebugLinesForNoisePatch(NoiseCoord nco, Color col) { drawDebugLinesForNoisePatch(nco, col, 3); }
public Coord(NoiseCoord nco) { x = nco.x; y = 0; z = nco.z; }
public static Coord WorldCoordFromNoiseCoordAndPatchRelativeOffset(NoiseCoord nco, Coord offset) { return(CoordUtil.WorldCoordFromNoiseCoord(nco) + offset); }
public static Coord WorldRelativeChunkCoordForNoiseCoord(NoiseCoord nco) { return(new Coord(nco.x * NoisePatch.CHUNKDIMENSION, 0, nco.z * NoisePatch.CHUNKDIMENSION)); }
public LightColumnCalculator(NoisePatch npatch) { m_noisePatch = npatch; debugOrigNoiseCoord = m_noisePatch.coord; this.m_lightColumnMap = new LightColumnMap(this); }
public static PTwo PTwoXZFromNoiseCoord(NoiseCoord nco) { return(new PTwo(nco.x, nco.z)); }
/* * Clients use this to: * update the window map to reflect changed * height ranges which were (potentially) already set (but possibly no longer valid) in windows * */ public void updateWindowsWithHeightRanges(List <Range1D> heightRanges, int x, int z, SurroundingSurfaceValues ssvs) { // m_lightColumnCalculator.updateWindowsWithHeightRangesAndUpdateLight(heightRanges, x, z, ssvs, -1, false); return; //reset column clearColumnAt(x, z); // re-add ranges for (int j = 1; j < heightRanges.Count; ++j) { addDiscontinuityWith(heightRanges[j], heightRanges[j - 1], x, z, ssvs, true, true); } if (windows[x] == null) { return; } //WINDOW MAINTENANCE List <Window> wins = windows[x]; Window win = null; //TRIM EDGES for (int i = 0; i < wins.Count; ++i) { win = wins[i]; win.assertSpansAreSaneDebug("bfr trim domain"); //DBG // trim edges of windows if needed // at extent if (win.trimDomain()) { // check whether we should remove the window if (win.spanRange <= 0) { wins.RemoveAt(i); --i; } } } for (int i = 0; i < wins.Count; ++i) { // split windows at z if needed win = wins[i]; if (win.spanContainsZ(z)) { List <Window> posSideWindows = win.splitAtZ(z); if (posSideWindows != null) { int count = 0; foreach (Window posSideWin in posSideWindows) //MAX COUNT: 2 { posSideWin.assertSpansAreSaneDebug("pos side win "); //DBG count++; wins.Insert(i + count, posSideWin); } i += count; } win.assertSpansAreSaneDebug("after done splitting win (wMAP)"); //DBG } } //DEBUG if (NoiseCoord.Equal(this.m_noisePatch.coord, new NoiseCoord(0, 0))) { debugAllWindowHeightColumns(); } }