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 void addToSurfaceExposedColumnIfNotContains(LightColumn col)
{
if (!surfaceExposedColumns.Contains(col))
{
surfaceExposedColumns.Add(col);
}
}
// 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);
}
}
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 addColumnAt(LightColumn newlcolm, int x, int z)
{
DiscreteDomainRangeList <LightColumn> lcolms = this[x, z];
lcolms.Add(newlcolm);
this[x, z] = lcolms;
}
private LightColumn lightestNeightbor(SimpleRange colRange, PTwo co)
{
LightColumn lightest = null;
List <LightColumn> neighbors = m_lightColumnMap.lightColumnsAdjacentToAndFlushWithSimpleRangeAndPoint(colRange, co);
if (neighbors.Count == 0)
{
return(null);
}
lightest = neighbors[0];
//CONSIDER: could be a little faster if we iterated over directions ourselves here...
for (int i = 1; i < neighbors.Count; ++i)
{
LightColumn neicol = neighbors[i];
if (neicol.lightLevel > lightest.lightLevel)
{
lightest = neicol;
}
}
return(lightest);
}
private void addDebugColumnIfNoiseCoZIsNeg(LightColumn col, int handyI)
{
if (this.m_noisePatch.coord.z < 0)
{
int handyInt = handyI;
ChunkManager.debugLinesAssistant.addColumn(col.toColumnDebug(), handyInt, this.m_noisePatch.coord);
}
}
private bool columnContains(LightColumn lcol, int y)
{
if (lcol == null)
{
return(false);
}
return(lcol.contains(y));
}
public void addReplaceColumn(LightColumn col)
{
DiscreteDomainRangeList <LightColumn> cols = this[col.coord];
cols.RemoveWithRangeEqualTo(col.range);
cols.Add(col);
this[col.coord] = cols;
}
private void updateColumnAt(LightColumn lightcol, PTwo coord, LightColumn influencerColumn, Quad withinBounds)
{
if (!withinBounds.contains(coord))
{
return;
}
bool tookInfluence = false;
if (influencerColumn == null)
{
// addColumnIfNoiseCoordOO(lightcol); //DBG
lightcol.setLightLevelToMax();
tookInfluence = true;
}
else
{
tookInfluence = lightcol.takeInfluenceFromColumn(influencerColumn);
// if (tookInfluence) //DEBUG!!!
// {
// this.addDebugColumnIfNoiseCoZIsNeg(lightcol, 4);
// this.addDebugColumnIfNoiseCoZIsNeg(influencerColumn, 1);
// }
}
if (!tookInfluence)
{
return;
}
List <LightColumn> adjacentNeighbors = m_lightColumnMap.lightColumnsAdjacentToAndFlushWith(lightcol);
if (adjacentNeighbors == null)
{
return;
}
for (int i = 0; i < adjacentNeighbors.Count; ++i)
{
LightColumn adjNeighbor = adjacentNeighbors[i];
//TEST WANT
updateColumnAt(adjNeighbor, adjNeighbor.coord, lightcol, withinBounds);
}
// touch any connected columns below this light col
// then check this column done on check list
// foreach(LightColumn belowCol in m_lightColumnMap[coord].toList() )
// {
// if (belowCol.Equals(lightcol))
// continue;
// foreach(LightColumn adjCol in adjacentNeighbors) {
// belowCol.takeInfluenceFromColumn(adjCol);
// if (belowCol.lightLevel >= lightcol.lightLevel - Window.UNIT_FALL_OFF_BYTE * 2)
// break;
// }
// }
// columnDoneCheckList[coord.s,coord.t] = true;
}
//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);
}
}
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 void clearSurfaceExposedListAt(int x, int z)
{
//TODO make faster collection? another lightColumnMap maybe?
for (int i = 0; i < surfaceExposedColumns.Count; ++i)
{
LightColumn col = surfaceExposedColumns[i];
if (col.coord.s == x && col.coord.t == z)
{
surfaceExposedColumns.RemoveAt(i);
--i;
}
}
}
private void updateColumnsWithHigherHighestSurface(List <Range1D> heightRanges, Coord pRelCoord, SurroundingSurfaceValues ssvs, bool shouldPropagateLight)
{
b.bug("update w higher highest surf");
int x = pRelCoord.x, y = pRelCoord.y, z = pRelCoord.z;
SimpleRange justCoveredColumn = new SimpleRange(y, 1);
Range1D highest = heightRanges[heightRanges.Count - 1];
LightColumn newlico = null;
int lowestSurroundingSurface = ssvs.lowestValue();
if (highest.range == 1)
{
AssertUtil.Assert(heightRanges.Count > 1, "what we just 'covered' bedrock?");
Range1D secondHighest = heightRanges[heightRanges.Count - 2];
justCoveredColumn = new SimpleRange(secondHighest.extent(), y + 1 - secondHighest.extent()); //(extent - start)
//new column
SimpleRange newColRange = justCoveredColumn;
newColRange.range--;
newlico = new LightColumn(PTwo.PTwoXZFromCoord(pRelCoord), 0, newColRange);
m_lightColumnMap.addColumnAt(newlico, x, z);
if (newColRange.extent() > lowestSurroundingSurface)
{
newlico.lightLevel = Window.LIGHT_LEVEL_MAX_BYTE;
surfaceExposedColumns.Add(newlico);
}
}
List <LightColumn> adjColsFlushToJustCovered = m_lightColumnMap.lightColumnsAdjacentToAndFlushWithSimpleRangeAndPoint(justCoveredColumn, new PTwo(x, z));
foreach (LightColumn adjcol in adjColsFlushToJustCovered)
{
//adj cols could still be above
if (adjcol.extent() <= y)
{
//get surrounding surface for these?
SurroundingSurfaceValues assvs = m_noisePatch.surfaceValuesSurrounding(adjcol.coord);
if (adjcol.extent() <= assvs.lowestValue())
{
surfaceExposedColumns.Remove(adjcol);
adjcol.lightLevel = 0;
// put back?
}
}
}
resetAndUpdateColumnsWithin(LightDomainAround(x, z));
}
public float lightValueAtPatchRelativeCoord(Coord relCo)
{
LightColumn lilc = m_lightColumnMap.columnContaining(relCo);
if (lilc == null)
{
return(0f); // Window.LIGHT_LEVEL_MAX; //TEST// 0f;
}
// addColumnIfNoiseCoordOO(lilc); //DBG
// if (lilc.lightLevel > 17f)
// this.addDebugColumnIfNoiseCoZIsNeg(lilc, (int)(lilc.lightLevel / 3f));
return((float)lilc.lightLevel); //WANT
}
public void replaceColumnsWithHeightRanges(List <Range1D> heightRanges, int x, int z, SurroundingSurfaceValues ssvs)
{
int countAt = m_lightColumnMap.countAt(x, z);
if (countAt > 0)
{
//clobber columns here.
m_lightColumnMap.clearColumnsAt(x, z);
clearSurfaceExposedListAt(x, z);
}
//add new discons
int lowestSurroundingSurfaceHeight = ssvs.lowestValue();
ssvs.debugAssertLowestNonNegFound(); //DBG
// AssertUtil.Assert(lowestSurroundingSurfaceHeight > 0, "weird. lowest sur value is: " + lowestSurroundingSurfaceHeight);
// AssertUtil.Assert(NoiseCoord.Equal(this.debugOrigNoiseCoord, m_noisePatch.coord ), "not equal? nco "
// + m_noisePatch.coord.toString() + " and orig??" + debugOrigNoiseCoord.toString()); //fails
List <SimpleRange> discons = discontinuitiesFromHeightRanges(heightRanges);
int light = 0;
LightColumn col = null;
bool exposedLightColumn = false;
int countDisCon = discons.Count; //DBG
foreach (SimpleRange discon in discons)
{
exposedLightColumn = discon.extent() > lowestSurroundingSurfaceHeight;
light = 0; // discon.extent() > lowestSurroundingSurfaceHeight ? (int) Window.LIGHT_LEVEL_MAX_BYTE : 0;
col = new LightColumn(new PTwo(x, z), (byte)light, discon);
if (exposedLightColumn)
{
//DBG
// if (countDisCon > 1) {
// bugIf0Neg1( " discon extent: " + discon.extent() + " lowest Sur Height: " + lowestSurroundingSurfaceHeight + " x: " + x + " z: " + z);
// }
surfaceExposedColumns.Add(col);
// this.addDebugColumnIfNoiseCoZIsNeg(col, 4);
}
m_lightColumnMap.addColumnAt(col, x, z);
}
}
private LightSetup GetLightSetup(ILightSetupPlugin plugin)
{
LightSetup lightSetup = new LightSetup();
if (plugin.Lights != null && plugin.Lights.Any())
{
//convert back to 2d array for setup
lightSetup.LightRows = new List <LightRow>();
lightSetup.NumberOfRows = plugin.Lights.Max(l => l.Top);
lightSetup.NumberOfColumns = plugin.Lights.Max(l => l.Left);
for (int row = 0; row <= lightSetup.NumberOfRows; row++)
{
LightRow lightRow = new LightRow();
lightRow.RowIndex = row;
lightRow.LightColumns = new List <LightColumn>();
for (int column = 0; column <= lightSetup.NumberOfColumns; column++)
{
LightColumn lightColumn = new LightColumn();
lightColumn.ColumnIndex = column;
if (column == 0 || column == lightSetup.NumberOfColumns ||
row == 0 || row == lightSetup.NumberOfRows)
{
Light light = (from l in plugin.Lights
where l.Top == row &&
l.Left == column
select l).FirstOrDefault();
if (light != null)
{
lightColumn.Id = light.Id.ToString();
lightColumn.Index = light.Index.ToString();
lightColumn.Enabled = !string.IsNullOrEmpty(lightColumn.Id);
}
}
else
{
lightColumn.Enabled = false;
}
lightRow.LightColumns.Add(lightColumn);
}
lightSetup.LightRows.Add(lightRow);
}
}
return(lightSetup);
}
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);
}
}
// 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);
}
}
}
}
}
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 updateColumnOrLightestNeighbor(LightColumn col)
{
if (col != null)
{
LightColumn lightestN = lightestNeighbor(col);
if (lightestN != null)
{
if (lightestN.lightLevel > col.lightLevel)
{
updateColumnAt(col, col.coord, lightestN, LightDomainAround(col.coord));
}
else
{
updateColumnAt(lightestN, lightestN.coord, col, LightDomainAround(lightestN.coord));
}
}
else
{
col.lightLevel = 0;
}
m_lightColumnMap.addReplaceColumn(col);
}
}
public List <LightColumn> lightColumnsAdjacentToAndFlushWith(LightColumn colm)
{
return(lightColumnsAdjacentToAndFlushWithSimpleRangeAndPoint(colm.range, colm.coord));
}
private PluginProperty[] GetPluginProperties(object plugin)
{
List <PluginProperty> pluginProperties = new List <PluginProperty>();
if (plugin == null)
{
return(pluginProperties.ToArray());
}
Type pluginObjectType = plugin.GetType();
foreach (System.Reflection.PropertyInfo objectProperty in pluginObjectType.GetProperties())
{
PluginProperty pluginProperty = new PluginProperty();
bool exclude = false;
bool dataMember = false;
if (!objectProperty.CanWrite)
{
continue;
}
pluginProperty.Name = objectProperty.Name;
pluginProperty.Value = objectProperty.GetValue(plugin, null);
Type propertyType = objectProperty.PropertyType;
if (propertyType == typeof(string))
{
pluginProperty.Type = "text";
}
else if (propertyType == typeof(int))
{
pluginProperty.Type = "number";
}
else if (propertyType == typeof(bool))
{
pluginProperty.Type = "boolean";
}
else if (propertyType == typeof(List <Core.Light>))
{
pluginProperty.Type = "lights";
string[] colourClasses = new string[] { "btn-primary", "btn-success", "btn-info", "btn-warning", "btn-danger" };
int colourPosition = 0;
List <Core.Light> lights = pluginProperty.Value as List <Core.Light>;
LightSetup lightSetup = new LightSetup();
if (lights != null && lights.Any())
{
//convert back to 2d array for setup
lightSetup.LightRows = new List <LightRow>();
int numberOfRows = lights.Max(l => l.Top);
int numberOfColumns = lights.Max(l => l.Left);
for (int row = 0; row <= numberOfRows; row++)
{
LightRow lightRow = new LightRow();
lightRow.RowIndex = row;
lightRow.LightColumns = new List <LightColumn>();
for (int column = 0; column <= numberOfColumns; column++)
{
LightColumn lightColumn = new LightColumn();
lightColumn.ColumnIndex = column;
if (column == 0 || column == numberOfColumns ||
row == 0 || row == numberOfRows)
{
Light light = (from l in lights
where l.Top == row &&
l.Left == column
select l).FirstOrDefault();
if (light != null)
{
lightColumn.Id = light.Id.ToString();
lightColumn.Index = light.Index.ToString();
lightColumn.ColourClass = colourClasses[colourPosition++];
lightColumn.Enabled = !string.IsNullOrEmpty(lightColumn.Id);
if (lightColumn.Id == "1")
{
lightSetup.FirstColumnIndex = column;
lightSetup.FirstRowIndex = row;
}
}
else
{
lightColumn.ColourClass = colourClasses[colourPosition++];
}
}
else
{
lightColumn.ColourClass = "disabled";
lightColumn.Enabled = false;
}
if (colourPosition >= colourClasses.Length)
{
colourPosition = 0;
}
lightRow.LightColumns.Add(lightColumn);
}
lightSetup.LightRows.Add(lightRow);
}
}
pluginProperty.Value = lightSetup;
}
foreach (System.Attribute attr in objectProperty.GetCustomAttributes(true))
{
if ((attr as DisplayAttribute) != null)
{
DisplayAttribute displayName = (DisplayAttribute)attr;
pluginProperty.DisplayName = displayName.Name;
pluginProperty.Description = displayName.Description;
}
else if ((attr as RangeAttribute) != null)
{
RangeAttribute range = (RangeAttribute)attr;
pluginProperty.MinValue = range.Minimum as int?;
pluginProperty.MaxValue = range.Maximum as int?;
}
else if ((attr as RequiredAttribute) != null)
{
RequiredAttribute required = (RequiredAttribute)attr;
pluginProperty.Required = required.AllowEmptyStrings;
}
else if ((attr as DataMemberAttribute) != null)
{
dataMember = true;
}
else if ((attr as KeyAttribute) != null)
{
exclude = true;
break;
}
else if ((attr as ConfigLookupAttribute) != null)
{
ConfigLookupAttribute lookup = (ConfigLookupAttribute)attr;
pluginProperty.Type = "lookup";
PropertyInfo optionsProperty = pluginObjectType.GetProperty(lookup.RetrieveValuesFrom);
IEnumerable <object> options = optionsProperty.GetValue(plugin, null) as IEnumerable <object>;
List <SelectOption> parsedOptions = new List <SelectOption>();
if (options.Any())
{
foreach (object option in options)
{
LookupItem lookupItem = option as LookupItem;
LookupItemString lookupItemString = option as LookupItemString;
SelectOption pluginOption = new SelectOption();
if (lookupItem != null)
{
pluginOption.Id = lookupItem.Id;
pluginOption.Name = lookupItem.Name;
}
else if (lookupItemString != null)
{
pluginOption.Id = lookupItemString.Id;
pluginOption.Name = lookupItemString.Name;
}
else
{
pluginOption.Id = option;
pluginOption.Name = option.ToString();
}
parsedOptions.Add(pluginOption);
}
}
pluginProperty.Options = parsedOptions;
}
}
if (dataMember && !exclude)
{
if (pluginProperty.Type == "lookup" && pluginProperty.Value != null)
{
var currentValue = (from o in pluginProperty.Options
where o.Id.ToString() == pluginProperty.Value.ToString()
select o).FirstOrDefault();
if (currentValue == null)
{
List <SelectOption> options = pluginProperty.Options as List <SelectOption>;
options.Add(new SelectOption()
{
Id = pluginProperty.Value,
Name = "Invalid! " + pluginProperty.Value.ToString()
});
pluginProperty.Options = options;
}
}
pluginProperties.Add(pluginProperty);
}
}
return(pluginProperties.ToArray());
}
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));
}
}
private LightColumn lightestNeighbor(LightColumn col)
{
return(lightestNeightbor(col.range, col.coord));
}
