public void Expand_One_Tile(clsBooleanMap Source)
{
int X = 0;
int Y = 0;
SizeCopy(Source);
for ( Y = 0; Y <= ValueData.Size.Y - 1; Y++ )
{
for ( X = 0; X <= Source.ValueData.Size.X - 1; X++ )
{
if ( Source.ValueData.Value[Y, X] )
{
ValueData.Value[Y, X] = true;
if ( Y > 0 )
{
if ( X > 0 )
{
ValueData.Value[Y - 1, X - 1] = true;
}
ValueData.Value[Y - 1, X] = true;
if ( X < Source.ValueData.Size.X - 1 )
{
ValueData.Value[Y - 1, X + 1] = true;
}
}
if ( X > 0 )
{
ValueData.Value[Y, X - 1] = true;
}
ValueData.Value[Y, X] = true;
if ( X < ValueData.Size.X - 1 )
{
ValueData.Value[Y, X + 1] = true;
}
if ( Y < ValueData.Size.Y - 1 )
{
if ( X > 0 )
{
ValueData.Value[Y + 1, X - 1] = true;
}
ValueData.Value[Y + 1, X] = true;
if ( X < ValueData.Size.X - 1 )
{
ValueData.Value[Y + 1, X + 1] = true;
}
}
}
}
}
}
public void Copy(clsBooleanMap Source)
{
int X = 0;
int Y = 0;
SizeCopy(Source);
for ( Y = 0; Y <= Source.ValueData.Size.Y - 1; Y++ )
{
for ( X = 0; X <= Source.ValueData.Size.X - 1; X++ )
{
ValueData.Value[Y, X] = Source.ValueData.Value[Y, X];
}
}
}
public void Combine(clsBooleanMap Source, clsBooleanMap Insert)
{
int X = 0;
int Y = 0;
SizeCopy(Source);
for ( Y = 0; Y <= Source.ValueData.Size.Y - 1; Y++ )
{
for ( X = 0; X <= Source.ValueData.Size.X - 1; X++ )
{
if ( Insert.ValueData.Value[Y, X] )
{
ValueData.Value[Y, X] = true;
}
else
{
ValueData.Value[Y, X] = Source.ValueData.Value[Y, X];
}
}
}
}
public void Within(clsBooleanMap Interior, clsBooleanMap Exterior)
{
int Y = 0;
int X = 0;
bool Flag = default(bool);
SizeCopy(Interior);
for ( Y = 0; Y <= Interior.ValueData.Size.Y - 1; Y++ )
{
for ( X = 0; X <= Interior.ValueData.Size.X - 1; X++ )
{
if ( Interior.ValueData.Value[Y, X] )
{
Flag = false;
if ( Y > 0 )
{
if ( X > 0 )
{
if ( !Exterior.ValueData.Value[Y - 1, X - 1] )
{
Flag = true;
}
}
if ( !Exterior.ValueData.Value[Y - 1, X] )
{
Flag = true;
}
if ( X < Interior.ValueData.Size.X - 1 )
{
if ( !Exterior.ValueData.Value[Y - 1, X + 1] )
{
Flag = true;
}
}
}
if ( X > 0 )
{
if ( !Exterior.ValueData.Value[Y, X - 1] )
{
Flag = true;
}
}
if ( !Exterior.ValueData.Value[Y, X] )
{
Flag = true;
}
if ( X < Interior.ValueData.Size.X - 1 )
{
if ( !Exterior.ValueData.Value[Y, X + 1] )
{
Flag = true;
}
}
if ( Y < Interior.ValueData.Size.Y - 1 )
{
if ( X > 0 )
{
if ( !Exterior.ValueData.Value[Y + 1, X - 1] )
{
Flag = true;
}
}
if ( !Exterior.ValueData.Value[Y + 1, X] )
{
Flag = true;
}
if ( X < Interior.ValueData.Size.X - 1 )
{
if ( !Exterior.ValueData.Value[Y + 1, X + 1] )
{
Flag = true;
}
}
}
ValueData.Value[Y, X] = !Flag;
}
}
}
}
public void SizeCopy(clsBooleanMap Source)
{
ValueData.Size.X = Source.ValueData.Size.X;
ValueData.Size.Y = Source.ValueData.Size.Y;
ValueData.Value = new bool[ValueData.Size.Y, ValueData.Size.X];
}
public void Remove(clsBooleanMap Source, clsBooleanMap Remove)
{
int X = 0;
int Y = 0;
SizeCopy(Source);
for ( Y = 0; Y <= Source.ValueData.Size.Y - 1; Y++ )
{
for ( X = 0; X <= Source.ValueData.Size.X - 1; X++ )
{
if ( Remove.ValueData.Value[Y, X] )
{
ValueData.Value[Y, X] = false;
}
else
{
ValueData.Value[Y, X] = Source.ValueData.Value[Y, X];
}
}
}
}
public clsBooleanMap GetWaterMap()
{
clsBooleanMap ReturnResult = new clsBooleanMap();
float BestDist = 0;
bool BestIsWater = default(bool);
sXY_int Pos = new sXY_int();
float Dist = 0;
int B = 0;
int C = 0;
sXY_int XY_int = new sXY_int();
int X = 0;
int Y = 0;
ReturnResult.Blank(Map.Terrain.TileSize.X + 1, Map.Terrain.TileSize.Y + 1);
for ( Y = 0; Y <= Map.Terrain.TileSize.Y; Y++ )
{
for ( X = 0; X <= Map.Terrain.TileSize.X; X++ )
{
BestDist = float.MaxValue;
Pos = new sXY_int(X * App.TerrainGridSpacing, Y * App.TerrainGridSpacing);
for ( B = 0; B <= ConnectionCount - 1; B++ )
{
//If Not (Connections(B).PassageNodeA.IsOnBorder Or Connections(B).PassageNodeB.IsOnBorder) Then
if ( Connections[B].PassageNodeA.IsWater == Connections[B].PassageNodeB.IsWater )
{
//only do this if the waters are the same
//this is to make sure nodes that are connected are actually connected as water
XY_int = MathUtil.PointGetClosestPosOnLine(Connections[B].PassageNodeA.Pos, Connections[B].PassageNodeB.Pos, Pos);
Dist = Convert.ToSingle((XY_int - Pos).ToDoubles().GetMagnitude());
if ( Dist < BestDist )
{
BestDist = Dist;
if ( (Pos - Connections[B].PassageNodeA.Pos).ToDoubles().GetMagnitude() <=
(Pos - Connections[B].PassageNodeB.Pos).ToDoubles().GetMagnitude() )
{
BestIsWater = Connections[B].PassageNodeA.IsWater;
}
else
{
BestIsWater = Connections[B].PassageNodeB.IsWater;
}
}
}
}
for ( C = 0; C <= PassageNodeCount - 1; C++ )
{
for ( B = 0; B <= SymmetryBlockCount - 1; B++ )
{
Dist = Convert.ToSingle((Pos - PassageNodes[B, C].Pos).ToDoubles().GetMagnitude());
if ( Dist < BestDist )
{
BestDist = Dist;
BestIsWater = PassageNodes[B, C].IsWater;
}
}
}
ReturnResult.ValueData.Value[Y, X] = BestIsWater;
}
}
return ReturnResult;
}
private clsResult FinishTextures()
{
clsResult ReturnResult = new clsResult("");
if ( cbxMasterTexture.Checked )
{
switch ( cboTileset.SelectedIndex )
{
case 0:
Generator.GenerateTileset = DefaultGenerator.Generator_TilesetArizona;
DefaultGenerator.TerrainStyle_Arizona.Watermap = Generator.GetWaterMap();
DefaultGenerator.TerrainStyle_Arizona.LevelCount = Generator.LevelCount;
Generator.Map.GenerateMasterTerrain(DefaultGenerator.TerrainStyle_Arizona);
DefaultGenerator.TerrainStyle_Arizona.Watermap = null;
break;
case 1:
Generator.GenerateTileset = DefaultGenerator.Generator_TilesetUrban;
DefaultGenerator.TerrainStyle_Urban.Watermap = Generator.GetWaterMap();
DefaultGenerator.TerrainStyle_Urban.LevelCount = Generator.LevelCount;
Generator.Map.GenerateMasterTerrain(DefaultGenerator.TerrainStyle_Urban);
DefaultGenerator.TerrainStyle_Urban.Watermap = null;
break;
case 2:
Generator.GenerateTileset = DefaultGenerator.Generator_TilesetRockies;
DefaultGenerator.TerrainStyle_Rockies.Watermap = Generator.GetWaterMap();
DefaultGenerator.TerrainStyle_Rockies.LevelCount = Generator.LevelCount;
Generator.Map.GenerateMasterTerrain(DefaultGenerator.TerrainStyle_Rockies);
DefaultGenerator.TerrainStyle_Rockies.Watermap = null;
break;
default:
ReturnResult.ProblemAdd("Error: bad tileset selection.");
btnGenerateLayout.Enabled = true;
return ReturnResult;
}
Generator.Map.TileType_Reset();
Generator.Map.SetPainterToDefaults();
}
else
{
switch ( cboTileset.SelectedIndex )
{
case 0:
Generator.Map.Tileset = App.Tileset_Arizona;
Generator.GenerateTileset = DefaultGenerator.Generator_TilesetArizona;
break;
case 1:
Generator.Map.Tileset = App.Tileset_Urban;
Generator.GenerateTileset = DefaultGenerator.Generator_TilesetUrban;
break;
case 2:
Generator.Map.Tileset = App.Tileset_Rockies;
Generator.GenerateTileset = DefaultGenerator.Generator_TilesetRockies;
break;
default:
ReturnResult.ProblemAdd("Error: bad tileset selection.");
btnGenerateLayout.Enabled = true;
return ReturnResult;
}
Generator.Map.TileType_Reset();
Generator.Map.SetPainterToDefaults();
double CliffAngle = Math.Atan(255.0D * Generator.Map.HeightMultiplier / (2.0D * (Generator.LevelCount - 1.0D) * App.TerrainGridSpacing)) -
MathUtil.RadOf1Deg;
clsBrush tmpBrush = new clsBrush((Math.Max(Generator.Map.Terrain.TileSize.X, Generator.Map.Terrain.TileSize.Y)) * 1.1D, clsBrush.enumShape.Square);
clsMap.clsApplyCliff ApplyCliff = new clsMap.clsApplyCliff();
ApplyCliff.Map = Generator.Map;
ApplyCliff.Angle = CliffAngle;
ApplyCliff.SetTris = true;
clsBrush.sPosNum Alignments = new clsBrush.sPosNum();
Alignments.Normal = new sXY_int((int)(Conversion.Int(Generator.Map.Terrain.TileSize.X / 2.0D)),
(int)(Conversion.Int(Generator.Map.Terrain.TileSize.Y / 2.0D)));
Alignments.Alignment = Alignments.Normal;
tmpBrush.PerformActionMapTiles(ApplyCliff, Alignments);
bool[] RevertSlope = null;
bool[] RevertHeight = null;
clsBooleanMap WaterMap = new clsBooleanMap();
clsBooleanMap bmTemp = new clsBooleanMap();
int A = 0;
WaterMap = Generator.GetWaterMap();
RevertSlope = new bool[Generator.GenerateTileset.OldTextureLayers.LayerCount];
RevertHeight = new bool[Generator.GenerateTileset.OldTextureLayers.LayerCount];
for ( A = 0; A <= Generator.GenerateTileset.OldTextureLayers.LayerCount - 1; A++ )
{
App.sLayerList.clsLayer with_2 = Generator.GenerateTileset.OldTextureLayers.Layers[A];
with_2.Terrainmap = Generator.Map.GenerateTerrainMap(with_2.Scale, with_2.Density);
if ( with_2.SlopeMax < 0.0F )
{
with_2.SlopeMax = (float)(CliffAngle - MathUtil.RadOf1Deg);
if ( with_2.HeightMax < 0.0F )
{
with_2.HeightMax = 255.0F;
bmTemp.Within(with_2.Terrainmap, WaterMap);
with_2.Terrainmap.ValueData = bmTemp.ValueData;
bmTemp.ValueData = new clsBooleanMap.clsValueData();
RevertHeight[A] = true;
}
RevertSlope[A] = true;
}
}
Generator.Map.MapTexturer(Generator.GenerateTileset.OldTextureLayers);
for ( A = 0; A <= Generator.GenerateTileset.OldTextureLayers.LayerCount - 1; A++ )
{
App.sLayerList.clsLayer with_3 = Generator.GenerateTileset.OldTextureLayers.Layers[A];
with_3.Terrainmap = null;
if ( RevertSlope[A] )
{
with_3.SlopeMax = -1.0F;
}
if ( RevertHeight[A] )
{
with_3.HeightMax = -1.0F;
}
}
}
Generator.Map.LevelWater();
Generator.Map.WaterTriCorrection();
Generator.Map.SectorGraphicsChanges.SetAllChanged();
Generator.Map.SectorUnitHeightsChanges.SetAllChanged();
Generator.Map.Update();
Generator.Map.UndoStepCreate("Generated Textures");
if ( Generator.Map == _Owner.MainMap )
{
Program.frmMainInstance.PainterTerrains_Refresh(-1, -1);
Program.frmMainInstance.MainMapTilesetChanged();
}
return ReturnResult;
}
