public void removeColumnsAbove(int x, int y, int z) { DiscreteDomainRangeList <LightColumn> licoms = this[x, z]; licoms.RemoveStartAbove(y); this[x, z] = licoms; }
public void addColumnAt(LightColumn newlcolm, int x, int z) { DiscreteDomainRangeList <LightColumn> lcolms = this[x, z]; lcolms.Add(newlcolm); this[x, z] = lcolms; }
public void clearColumnsAt(int x, int z) { DiscreteDomainRangeList <LightColumn> lcolms = this[x, z]; lcolms.Clear(); this[x, z] = lcolms; }
public List <LightColumn> lightColumnsAdjacentToAndFlushWithSimpleRangeAndPoint(SimpleRange colmRange, PTwo coord) { // PTwo coord = colm.coord; List <LightColumn> result = new List <LightColumn>(); foreach (PTwo surroundingCo in DirectionUtil.SurroundingPTwoCoordsFromPTwo(coord)) { DiscreteDomainRangeList <LightColumn> adjRangeList = this.lightColumnListAtOrNull(surroundingCo.s, surroundingCo.t); if (adjRangeList == null) { continue; } for (int i = 0; i < adjRangeList.Count; ++i) { LightColumn adjLightColumn = adjRangeList[i]; OverlapState overlap = colmRange.overlapStateWith(adjLightColumn.range); if (OverLapUtil.OverlapExists(overlap)) { result.Add(adjLightColumn); } } } return(result); }
private List <LightColumn> columnsThatColumnJustConnectedWith(LightColumn colAtY, int y) { List <LightColumn> result = new List <LightColumn>(); bool colExtentMinusOneEqualY = colAtY.extent() - 1 == y; bool colStartEqualY = colAtY.startP == y; foreach (PTwo co in DirectionUtil.SurroundingPTwoCoordsFromPTwo(colAtY.coord)) { DiscreteDomainRangeList <LightColumn> licols = m_lightColumnMap[co]; LightColumn justConnected = null; if (colExtentMinusOneEqualY) { justConnected = licols.rangeWithStartEqual(y); } else if (colStartEqualY) { justConnected = licols.rangeWithExtentMinusOneEqual(y); } else { justConnected = licols.rangeWithStartAndExtentMinusOneEqual(y); } if (justConnected != null) { result.Add(justConnected); } } return(result); }
public void addReplaceColumn(LightColumn col) { DiscreteDomainRangeList <LightColumn> cols = this[col.coord]; cols.RemoveWithRangeEqualTo(col.range); cols.Add(col); this[col.coord] = cols; }
//COPY PASTE OF ABOVE FUNC.! private void updateSurfaceHeightsInDirection(Quad area, Direction dir) { // return; PTwo nudge = DirectionUtil.NudgeCoordForDirectionPTwo(dir); Axis axis = DirectionUtil.AxisForDirection(dir); PTwo startPoint = area.origin; if (DirectionUtil.IsPosDirection(dir)) { if (axis == Axis.X) { startPoint.t += area.dimensions.t; } else { startPoint.s += area.dimensions.s; } } PTwo iterNudge = PTwo.Abs(nudge).flipSAndT(); int length = axis == Axis.X ? area.dimensions.t : area.dimensions.s; PTwo cursorPoint = startPoint; List <LightColumn> needUpdateColumns = new List <LightColumn>(); for (int i = 0; i < length; ++i) { // DiscreteDomainRangeList<LightColumn> licols = m_lightColumnMap[cursorPoint + nudge]; // if (licols == null) // continue; DiscreteDomainRangeList <LightColumn> insideCols = m_lightColumnMap[cursorPoint]; if (insideCols == null) { continue; } int surfaceHeightJustBeyondBorder = this.m_noisePatch.highestPointAtPatchRelativeCoord(cursorPoint + nudge); for (int j = 0; j < insideCols.Count; ++j) { LightColumn insideCol = insideCols[j]; if (insideCol.heightIsBelowExtent(surfaceHeightJustBeyondBorder)) { addToSurfaceExposedColumnIfNotContains(insideCol); needUpdateColumns.Add(insideCol); } } cursorPoint += iterNudge; } foreach (LightColumn col in needUpdateColumns) { updateColumnAt(col, col.coord, null, PatchQuad); } }
public int countAt(int x, int z) { DiscreteDomainRangeList <LightColumn> cols = this.lightColumnListAtOrNull(x, z); if (cols == null) { return(0); } return(cols.Count); }
public LightColumn columnContaining(int x, int y, int z) { DiscreteDomainRangeList <LightColumn> cols = this.lightColumnListAtOrNull(x, z); if (cols == null) { return(null); } return(cols.rangeContaining(y)); }
private void updateRangeListAtXZ(List <Range1D> heightRanges, Coord pRelCoord, bool solidBlockRemoved, SurroundingSurfaceValues ssvs) { DiscreteDomainRangeList <LightColumn> liCols = m_lightColumnMap[pRelCoord.x, pRelCoord.z]; if (!solidBlockRemoved && heightRanges.Count <= 1) // equal zero would be down right silly. { return; } // y above highest extent? int highestDiscontinuity = liCols.highestExtent(); int lowestSurroundingLevel = ssvs.lowestValue(); //CASE WHERE A BLOCK IS ADDED TO THE TOP OF OR OVER TOP OF THE SURFACE if (pRelCoord.y > highestDiscontinuity && !solidBlockRemoved) { // Y MUST BE THE TOP BLOCK? int hRangeCount = heightRanges.Count; SimpleRange between = discontinuityBetween(heightRanges[hRangeCount - 2], heightRanges[hRangeCount - 1]); if (!between.isErsatzNull()) { AssertUtil.Assert(pRelCoord.y == between.extentMinusOne(), "confused. y is " + pRelCoord.y + " between range is " + between.toString()); int lightValue = pRelCoord.y >= lowestSurroundingLevel? (int)Window.LIGHT_LEVEL_MAX_BYTE : 0; LightColumn licol = new LightColumn(PTwo.PTwoXZFromCoord(pRelCoord), (byte)lightValue, between); liCols.Add(licol); return; // licol; } throw new Exception("don't want to be here. we think a block couldn't be placed vertically in between at this point"); } //TODO handle case where y is above surface, solid block removed // need to destroy some discon ranges (not incorporate y). Range1D highest = heightRanges[heightRanges.Count - 1]; if (pRelCoord.y > highest.extent()) { liCols.RemoveStartAbove(highest.extent()); } else { LightColumn newCol = liCols.Incorporate(pRelCoord.y, solidBlockRemoved); if (newCol != null) { newCol.coord = new PTwo(pRelCoord.x, pRelCoord.z); } // throw new Exception("lots of exceptions. we failed to incorp a solid block added."); } b.bug("we incorporated a pRelCOord: " + pRelCoord.toString() + "solid removed was: " + solidBlockRemoved); m_lightColumnMap[pRelCoord.x, pRelCoord.z] = liCols; }
private List <LightColumn> columnsAdjacentTo(Coord pco) { List <LightColumn> result = new List <LightColumn>(); foreach (Direction dir in DirectionUtil.TheDirectionsXZ()) { Coord adjCo = pco + DirectionUtil.NudgeCoordForDirection(dir); DiscreteDomainRangeList <LightColumn> adjLicols = m_lightColumnMap[pco.x, pco.z]; LightColumn lico = adjLicols.rangeContaining(pco.y); if (lico != null) { result.Add(lico); } } return(result); }
private void updateQuadBorderInDirection(Quad area, Direction dir) { PTwo nudge = DirectionUtil.NudgeCoordForDirectionPTwo(dir); Axis axis = DirectionUtil.AxisForDirection(dir); PTwo startPoint = area.origin; if (DirectionUtil.IsPosDirection(dir)) { if (axis == Axis.X) { startPoint.t += area.dimensions.t; } else { startPoint.s += area.dimensions.s; } } PTwo iterNudge = PTwo.Abs(nudge).flipSAndT(); int length = axis == Axis.X ? area.dimensions.t : area.dimensions.s; PTwo cursorPoint = startPoint; for (int i = 0; i < length; ++i) { DiscreteDomainRangeList <LightColumn> licols = m_lightColumnMap[cursorPoint + nudge]; if (licols == null) { continue; } DiscreteDomainRangeList <LightColumn> insideCols = m_lightColumnMap[cursorPoint]; if (insideCols == null) { continue; } for (int j = 0; j < licols.Count; ++j) { LightColumn outsideCol = licols[j]; for (int k = 0; k < insideCols.Count; ++k) { LightColumn insideCol = insideCols[k]; updateColumnAt(insideCol, insideCol.coord, outsideCol, area); } } cursorPoint += iterNudge; } }
private void updateColumnsSolidAddedBelowSurface(List <Range1D> heightRanges, Coord pRelCoord, SurroundingSurfaceValues ssvs, bool shouldPropagateLight) { b.bug("adding below surface"); int x = pRelCoord.x, y = pRelCoord.y, z = pRelCoord.z; DiscreteDomainRangeList <LightColumn> licols = m_lightColumnMap[x, z]; LightColumn prevColContainingY = licols.rangeContaining(y); AssertUtil.Assert(prevColContainingY != null, "confusing. how did we add a block not in the area of a light colm under the surface?"); List <LightColumn> columnsJustDisconnected = this.columnsThatColumnJustConnectedWith(prevColContainingY, y); LightColumn aboveSplit = licols.Incorporate(y, false); if (aboveSplit != null) { aboveSplit.coord = new PTwo(x, z); } LightColumn newBelow = licols.rangeContaining(y - 1); LightColumn newAbove = licols.rangeContaining(y + 1); if (newBelow == null && newAbove == null) // COLUMNS WERE CUT OFF? { b.bug("got both y above and below null"); // general reboot resetAndUpdateColumnsWithin(LightDomainAround(PTwo.PTwoXZFromCoord(pRelCoord))); return; } updateColumnOrLightestNeighbor(newBelow); updateColumnOrLightestNeighbor(newAbove); foreach (LightColumn colm in columnsJustDisconnected) { updateColumnOrLightestNeighbor(colm); } }
public DiscreteDomainRangeList <LightColumn> this[int x, int z] { get{ //check out of bounds and ask a singleton that will make for the ranges if (!NoisePatchDims.isIndexSafe(new PTwo(x, z))) { return(ChunkManager.lightColumnWorldMap.lightColumnsAtWoco(x, z, this.noiseCoord)); } DiscreteDomainRangeList <LightColumn> lcolms = m_lightColumns[x * NoisePatch.patchDimensions.x + z]; if (lcolms == null) { lcolms = new DiscreteDomainRangeList <LightColumn>(); m_lightColumns[x * NoisePatch.patchDimensions.x + z] = lcolms; } return(lcolms); } set { m_lightColumns[x * NoisePatch.patchDimensions.x + z] = value; } }
// this func. represnts our muddled strategy unfortuntly. private void checkSurfaceStatusAt(int newHeight, int xx, int zz, ref ChangeOfLightStatus lightChangeStatus, ref List <LightColumn> needUpdateCols) { foreach (PTwo neighborPoint in DirectionUtil.SurroundingPTwoCoordsFromPTwo(new PTwo(xx, zz))) { //inefficient? DiscreteDomainRangeList <LightColumn> lilcoms = m_lightColumnMap[neighborPoint]; b.bug("checking surface..."); if (lilcoms == null) { continue; } b.bug("not ull"); for (int i = 0; i < lilcoms.Count; ++i) { LightColumn lilc = lilcoms[i]; bool wasAboveSurface = surfaceExposedColumns.Contains(lilc); if (lilc.range.extent() > newHeight) { b.bug("extent was greater than new height"); if (!wasAboveSurface) { b.bug("added a column now surf exposed"); lightChangeStatus = ChangeOfLightStatus.LIGHTENED; surfaceExposedColumns.Add(lilc); needUpdateCols.Add(lilc); } } else { b.bug("below surface new height is: " + newHeight + "lilc range extent is: " + lilc.range.extent()); if (wasAboveSurface) { lightChangeStatus = ChangeOfLightStatus.DARKENED; needUpdateCols.Add(lilc); surfaceExposedColumns.Remove(lilc); } } } } }
private void resetLightColumnsWithin(Quad area) { SimpleRange srange = area.sSimpleRange(); SimpleRange trange = area.tSimpleRange(); ChunkManager.debugLinesAssistant.clearColumns(); //DBG for (int i = srange.start; i < srange.extent(); ++i) { for (int j = trange.start; j < trange.extent(); ++j) { DiscreteDomainRangeList <LightColumn> lilcoms = m_lightColumnMap[i, j]; if (lilcoms == null) { continue; } for (int k = 0; k < lilcoms.Count; ++k) { lilcoms[k].resetLightLevel(); //WANT } } } }
public List <LightColumn> lightColumnsAdjacentToAndAtleastPartiallyAbove(Coord coord) { List <LightColumn> result = new List <LightColumn>(); foreach (PTwo surroundingCo in DirectionUtil.SurroundingPTwoCoordsFromPTwo(PTwo.PTwoXZFromCoord(coord))) { DiscreteDomainRangeList <LightColumn> adjRangeList = this.lightColumnListAtOrNull(surroundingCo.s, surroundingCo.t); if (adjRangeList == null) { continue; } for (int i = 0; i < adjRangeList.Count; ++i) { LightColumn adjLightColumn = adjRangeList[i]; if (adjLightColumn.extent() > coord.y) { b.bug("actually added one"); result.Add(adjLightColumn); } } } return(result); }
private void updateWindowsWithHeightRangesSolidRemoved(List <Range1D> heightRanges, Coord pRelCoord, SurroundingSurfaceValues ssvs, bool shouldPropagateLight) { int x = pRelCoord.x, y = pRelCoord.y, z = pRelCoord.z; DiscreteDomainRangeList <LightColumn> liCols = m_lightColumnMap[x, z]; LightColumn colJustBelowYBeforeUpdate = liCols.rangeContaining(y - 1); //null if there wasn't Range1D highest = heightRanges[heightRanges.Count - 1]; int newSurfaceHeightExtentAtXZ = highest.extent(); if (colJustBelowYBeforeUpdate != null) { colJustBelowYBeforeUpdate = colJustBelowYBeforeUpdate.Copy(); // safe keeping } updateRangeListAtXZ(heightRanges, pRelCoord, true, ssvs); //case where y represents a removed top block // where either air or solid was underneath the // former top block if (newSurfaceHeightExtentAtXZ <= y) { //no column here anymore //surface was revealed. //add any adjacent blocks to exposed list // if they weren't on the list before // add them to need update list // our work is done...return (put the above in a function) b.bug("got new surf less than y"); Coord surfaceTopCoord = pRelCoord; if (newSurfaceHeightExtentAtXZ < y) { b.bug("is fully less than"); surfaceTopCoord.y = newSurfaceHeightExtentAtXZ; } foreach (LightColumn col in m_lightColumnMap.lightColumnsAdjacentToAndAtleastPartiallyAbove(surfaceTopCoord)) { b.bug("updating "); addToSurfaceExposedColumnIfNotContains(col); col.lightLevel = Window.LIGHT_LEVEL_MAX_BYTE; updateColumnAt(col, col.coord, null, LightDomainAround(col.coord)); } m_lightColumnMap[x, z] = liCols; return; } //REMAINING CASES: Y REMOVED FROM BELOW SURFACE int lowestSurroundingSurface = ssvs.lowestValue(); LightColumn colAtY = liCols.rangeContaining(y); AssertUtil.Assert(colAtY != null, "(remove block. didn't get a col at y in lc calc) y was: " + y); if (y > lowestSurroundingSurface) //just update it. anything new will update. anything not new won't. { //one way or another a newly exposed column here addToSurfaceExposedColumnIfNotContains(colAtY); updateColumnAt(colAtY, colAtY.coord, null, LightDomainAround(x, z)); return; } //REMAINING CASES: Y WAS BELOW THE SURFACE AND NOT EXPOSED BY ADJACENT SURFACE. List <LightColumn> justConnectedWithColumns = columnsThatColumnJustConnectedWith(colAtY, y); if (justConnectedWithColumns.Count == 0) { return; } LightColumn lightest = colAtY; bool atYIsLightest = true; foreach (LightColumn justConnectedCol in justConnectedWithColumns) { if (justConnectedCol.lightLevel > lightest.lightLevel) { lightest = justConnectedCol; atYIsLightest = false; } } if (atYIsLightest) { foreach (LightColumn adjCol in justConnectedWithColumns) { updateColumnAt(adjCol, adjCol.coord, colAtY, LightDomainAround(adjCol.coord)); } } else { updateColumnAt(colAtY, colAtY.coord, lightest, LightDomainAround(colAtY.coord)); } }