public clsTerrainUpdate(XYInt TileSize)
{
Vertices = new clsPointChanges(new XYInt(TileSize.X + 1, TileSize.Y + 1));
Tiles = new clsPointChanges(new XYInt(TileSize.X, TileSize.Y));
SidesH = new clsPointChanges(new XYInt(TileSize.X, TileSize.Y + 1));
SidesV = new clsPointChanges(new XYInt(TileSize.X + 1, TileSize.Y));
}
public MapViewControl(frmMain Owner)
{
_Owner = Owner;
GLSize = new XYInt(0, 0);
InitializeComponent();
ListSelect = new ContextMenuStrip();
ListSelect.ItemClicked += ListSelect_Click;
ListSelect.Closed += ListSelect_Close;
UndoMessageTimer = new Timer();
UndoMessageTimer.Tick += RemoveUndoMessage;
OpenGLControl = Program.OpenGL1;
pnlDraw.Controls.Add(OpenGLControl);
GLInitializeDelayTimer = new Timer();
GLInitializeDelayTimer.Interval = 50;
GLInitializeDelayTimer.Tick += GLInitialize;
GLInitializeDelayTimer.Enabled = true;
tmrDraw = new Timer();
tmrDraw.Tick += tmrDraw_Tick;
tmrDraw.Interval = 1;
tmrDrawDelay = new Timer();
tmrDrawDelay.Tick += tmrDrawDelay_Tick;
tmrDrawDelay.Interval = 30;
UndoMessageTimer.Interval = 4000;
}
public void SideVChanged(XYInt Num)
{
if ( Num.X > 0 )
{
TileChanged(new XYInt(Num.X - 1, Num.Y));
}
if ( Num.X < Map.Terrain.TileSize.X )
{
TileChanged(Num);
}
}
public void SideHChanged(XYInt Num)
{
if ( Num.Y > 0 )
{
TileChanged(new XYInt(Num.X, Num.Y - 1));
}
if ( Num.Y < Map.Terrain.TileSize.Y )
{
TileChanged(Num);
}
}
// Parses: 19136, 4288
public static XYInt FromString(string text)
{
var split = text.Split (new string[]{", "}, StringSplitOptions.None);
if (split.Count() != 2) {
throw new Exception(string.Format("\"{0}\" is not a valid XY Position.", text));
}
var result = new XYInt (Int32.Parse (split [0]),
Int32.Parse (split [1]));
return result;
}
private void ToolPerformSideV(XYInt SideNum)
{
Terrain = Map.Terrain;
if ( Terrain.SideV[SideNum.X, SideNum.Y].Road != null )
{
Terrain.SideV[SideNum.X, SideNum.Y].Road = null;
Map.AutoTextureChanges.SideVChanged(SideNum);
Map.SectorGraphicsChanges.SideVChanged(SideNum);
Map.SectorTerrainUndoChanges.SideVChanged(SideNum);
}
}
public clsInterfaceOptions()
{
//set to default
CompileName = "";
CompileMultiPlayers = 2.ToStringInvariant();
CompileMultiAuthor = "";
CompileMultiLicense = "";
AutoScrollLimits = true;
ScrollMin = new XYInt(0, 0);
ScrollMax.X = 0U;
ScrollMax.Y = 0U;
CampaignGameType = -1;
}
// Parses: 19136, 4288
public static XYInt FromString(string text)
{
var split = text.Split(new string[] { ", " }, StringSplitOptions.None);
if (split.Count() != 2)
{
throw new Exception(string.Format("\"{0}\" is not a valid XY Position.", text));
}
var result = new XYInt(Int32.Parse(split [0]),
Int32.Parse(split [1]));
return(result);
}
public static sIntersectPos GetLinesIntersectBetween(XYInt A1, XYInt A2, XYInt B1, XYInt B2)
{
var Result = new sIntersectPos();
if ( (A1.X == A2.X & A1.Y == A2.Y) || (B1.X == B2.X & B1.Y == B2.Y) )
{
Result.Exists = false;
}
else
{
double y1dif = 0;
double x1dif = 0;
double adifx = 0;
double adify = 0;
double bdifx = 0;
double bdify = 0;
double m = 0;
double ar = 0;
double br = 0;
y1dif = B1.Y - A1.Y;
x1dif = B1.X - A1.X;
adifx = A2.X - A1.X;
adify = A2.Y - A1.Y;
bdifx = B2.X - B1.X;
bdify = B2.Y - B1.Y;
m = adifx * bdify - adify * bdifx;
if ( m == 0.0D )
{
Result.Exists = false;
}
else
{
ar = (x1dif * bdify - y1dif * bdifx) / m;
br = (x1dif * adify - y1dif * adifx) / m;
if ( ar <= 0.0D | ar >= 1.0D | br <= 0.0D | br >= 1.0D )
{
Result.Exists = false;
}
else
{
Result.Pos.X = A1.X + (int)(ar * adifx);
Result.Pos.Y = A1.Y + (int)(ar * adify);
Result.Exists = true;
}
}
}
return Result;
}
public void DrawUnitRectangle(clsUnit Unit, int BorderInsideThickness, sRGBA_sng InsideColour, sRGBA_sng OutsideColour)
{
var PosA = new XYInt();
var PosB = new XYInt();
var A = 0;
var Altitude = Unit.Pos.Altitude - ViewInfo.ViewPos.Y;
GetFootprintTileRangeClamped(Unit.Pos.Horizontal, Unit.TypeBase.get_GetFootprintSelected(Unit.Rotation), ref PosA, ref PosB);
A = PosA.Y;
PosA.X = (int)((PosA.X + 0.125D) * Constants.TerrainGridSpacing - ViewInfo.ViewPos.X);
PosA.Y = (int)((PosB.Y + 0.875D) * - Constants.TerrainGridSpacing - ViewInfo.ViewPos.Z);
PosB.X = (int)((PosB.X + 0.875D) * Constants.TerrainGridSpacing - ViewInfo.ViewPos.X);
PosB.Y = (int)((A + 0.125D) * - Constants.TerrainGridSpacing - ViewInfo.ViewPos.Z);
GL.Color4(OutsideColour.Red, OutsideColour.Green, OutsideColour.Blue, OutsideColour.Alpha);
GL.Vertex3(PosB.X, Altitude, Convert.ToInt32(- PosA.Y));
GL.Vertex3(PosA.X, Altitude, Convert.ToInt32(- PosA.Y));
GL.Color4(InsideColour.Red, InsideColour.Green, InsideColour.Blue, InsideColour.Alpha);
GL.Vertex3(PosA.X + BorderInsideThickness, Altitude, Convert.ToInt32(- (PosA.Y + BorderInsideThickness)));
GL.Vertex3(PosB.X - BorderInsideThickness, Altitude, Convert.ToInt32(- (PosA.Y + BorderInsideThickness)));
GL.Color4(OutsideColour.Red, OutsideColour.Green, OutsideColour.Blue, OutsideColour.Alpha);
GL.Vertex3(PosA.X, Altitude, Convert.ToInt32(- PosA.Y));
GL.Vertex3(PosA.X, Altitude, Convert.ToInt32(- PosB.Y));
GL.Color4(InsideColour.Red, InsideColour.Green, InsideColour.Blue, InsideColour.Alpha);
GL.Vertex3(PosA.X + BorderInsideThickness, Altitude, Convert.ToInt32(- (PosB.Y - BorderInsideThickness)));
GL.Vertex3(PosA.X + BorderInsideThickness, Altitude, Convert.ToInt32(- (PosA.Y + BorderInsideThickness)));
GL.Color4(OutsideColour.Red, OutsideColour.Green, OutsideColour.Blue, OutsideColour.Alpha);
GL.Vertex3(PosB.X, Altitude, Convert.ToInt32(- PosB.Y));
GL.Vertex3(PosB.X, Altitude, Convert.ToInt32(- PosA.Y));
GL.Color4(InsideColour.Red, InsideColour.Green, InsideColour.Blue, InsideColour.Alpha);
GL.Vertex3(PosB.X - BorderInsideThickness, Altitude, - (PosA.Y + BorderInsideThickness));
GL.Vertex3(PosB.X - BorderInsideThickness, Altitude, - (PosB.Y - BorderInsideThickness));
GL.Color4(OutsideColour.Red, OutsideColour.Green, OutsideColour.Blue, OutsideColour.Alpha);
GL.Vertex3(PosA.X, Altitude, Convert.ToInt32(- PosB.Y));
GL.Vertex3(PosB.X, Altitude, Convert.ToInt32(- PosB.Y));
GL.Color4(InsideColour.Red, InsideColour.Green, InsideColour.Blue, InsideColour.Alpha);
GL.Vertex3(PosB.X - BorderInsideThickness, Altitude, - (PosB.Y - BorderInsideThickness));
GL.Vertex3(PosA.X + BorderInsideThickness, Altitude, Convert.ToInt32(- (PosB.Y - BorderInsideThickness)));
}
public clsTerrain(XYInt newSize)
{
TileSize = newSize;
Vertices = new Vertex[TileSize.X + 1, TileSize.Y + 1];
Tiles = new Tile[TileSize.X, TileSize.Y];
SideH = new Side[TileSize.X, TileSize.Y + 1];
SideV = new Side[TileSize.X + 1, TileSize.Y];
var X = 0;
var Y = 0;
for ( Y = 0; Y <= TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= TileSize.X - 1; X++ )
{
Tiles[X, Y].Texture.TextureNum = -1;
Tiles[X, Y].DownSide = TileUtil.None;
}
}
}
public clsMap()
{
SectorCount = new XYInt(0, 0);
Selected_Area_VertexA = new XYInt(0, 0);
Selected_Area_VertexB = new XYInt(0, 0);
frmMainLink = new ConnectedListLink<clsMap, frmMain>(this);
Sectors = new clsSector[0, 0];
ShadowSectors = new clsShadowSector[0, 0];
HeightMultiplier = 2;
_ReadyForUserInput = false;
ChangedSinceSave = false;
AutoSave = new clsAutoSave();
Painter = new Painter();
Tile_TypeNum = new byte[0];
Gateways = new ConnectedList<clsGateway, clsMap>(this);
Units = new ConnectedList<clsUnit, clsMap>(this);
UnitGroups = new ConnectedList<clsUnitGroup, clsMap>(this);
ScriptPositions = new ConnectedList<clsScriptPosition, clsMap>(this);
ScriptAreas = new ConnectedList<clsScriptArea, clsMap>(this);
Initialize();
}
public TextureViewControl(frmMain Owner)
{
_Owner = Owner;
TextureCount = new XYInt(0, 0);
GLSize = new XYInt(0, 0);
InitializeComponent();
OpenGLControl = Program.OpenGL2;
pnlDraw.Controls.Add(OpenGLControl);
GLInitializeDelayTimer = new Timer();
GLInitializeDelayTimer.Interval = 50;
GLInitializeDelayTimer.Tick += GLInitialize;
GLInitializeDelayTimer.Enabled = true;
tmrDraw = new Timer();
tmrDraw.Tick += tmrDraw_Tick;
tmrDraw.Interval = 1;
tmrDrawDelay = new Timer();
tmrDrawDelay.Tick += tmrDrawDelay_Tick;
tmrDrawDelay.Interval = 30;
}
public void Rotate(TileOrientation Orientation, enumObjectRotateMode ObjectRotateMode)
{
var X = 0;
var Y = 0;
var Pos = new XYInt(0, 0);
var RotatedPos = new XYInt();
var NewTerrainPosA = TileUtil.GetRotatedPos(Orientation, new XYInt(0, 0), Terrain.TileSize);
var NewTerrainPosB = TileUtil.GetRotatedPos(Orientation, Terrain.TileSize, Terrain.TileSize);
var VertexLimits = new XYInt(Math.Max(NewTerrainPosA.X, NewTerrainPosB.X), Math.Max(NewTerrainPosA.Y, NewTerrainPosB.Y));
var NewTerrain = new clsTerrain(VertexLimits);
var NewTileLimits = new XYInt(NewTerrain.TileSize.X - 1, NewTerrain.TileSize.Y - 1);
var NewSideHLimits = new XYInt(NewTerrain.TileSize.X - 1, NewTerrain.TileSize.Y);
var NewSideVLimits = new XYInt(NewTerrain.TileSize.X, NewTerrain.TileSize.Y - 1);
var OldTileLimits = new XYInt(Terrain.TileSize.X - 1, Terrain.TileSize.Y - 1);
var OldPosLimits = new XYInt(Terrain.TileSize.X * Constants.TerrainGridSpacing, Terrain.TileSize.Y * Constants.TerrainGridSpacing);
var ReverseOrientation = new TileOrientation();
var TriDirection = new TileDirection();
ReverseOrientation = Orientation;
ReverseOrientation.Reverse();
for ( Y = 0; Y <= NewTerrain.TileSize.Y; Y++ )
{
Pos.Y = Y;
for ( X = 0; X <= NewTerrain.TileSize.X; X++ )
{
Pos.X = X;
RotatedPos = TileUtil.GetRotatedPos(ReverseOrientation, Pos, VertexLimits);
NewTerrain.Vertices[X, Y].Height = Terrain.Vertices[RotatedPos.X, RotatedPos.Y].Height;
NewTerrain.Vertices[X, Y].Terrain = Terrain.Vertices[RotatedPos.X, RotatedPos.Y].Terrain;
}
}
for ( Y = 0; Y <= NewTerrain.TileSize.Y - 1; Y++ )
{
Pos.Y = Y;
for ( X = 0; X <= NewTerrain.TileSize.X - 1; X++ )
{
Pos.X = X;
RotatedPos = TileUtil.GetRotatedPos(ReverseOrientation, Pos, NewTileLimits);
NewTerrain.Tiles[X, Y].Texture = Terrain.Tiles[RotatedPos.X, RotatedPos.Y].Texture;
NewTerrain.Tiles[X, Y].Texture.Orientation = NewTerrain.Tiles[X, Y].Texture.Orientation.GetRotated(Orientation);
NewTerrain.Tiles[X, Y].DownSide = Terrain.Tiles[RotatedPos.X, RotatedPos.Y].DownSide;
NewTerrain.Tiles[X, Y].DownSide = NewTerrain.Tiles[X, Y].DownSide.GetRotated(Orientation);
if ( Terrain.Tiles[RotatedPos.X, RotatedPos.Y].Tri )
{
TriDirection = TileUtil.TopLeft;
}
else
{
TriDirection = TileUtil.TopRight;
}
TriDirection = TriDirection.GetRotated(Orientation);
NewTerrain.Tiles[X, Y].Tri =
Convert.ToBoolean(TileUtil.IdenticalTileDirections(TriDirection, TileUtil.TopLeft) ||
TileUtil.IdenticalTileDirections(TriDirection, TileUtil.BottomRight));
if ( Terrain.Tiles[RotatedPos.X, RotatedPos.Y].Tri )
{
if ( Terrain.Tiles[RotatedPos.X, RotatedPos.Y].TriTopLeftIsCliff )
{
TileUtil.RotateDirection(TileUtil.TopLeft, Orientation, ref TriDirection);
NewTerrain.Tiles[X, Y].TriCliffAddDirection(TriDirection);
}
if ( Terrain.Tiles[RotatedPos.X, RotatedPos.Y].TriBottomRightIsCliff )
{
TileUtil.RotateDirection(TileUtil.BottomRight, Orientation, ref TriDirection);
NewTerrain.Tiles[X, Y].TriCliffAddDirection(TriDirection);
}
}
else
{
if ( Terrain.Tiles[RotatedPos.X, RotatedPos.Y].TriTopRightIsCliff )
{
TileUtil.RotateDirection(TileUtil.TopRight, Orientation, ref TriDirection);
NewTerrain.Tiles[X, Y].TriCliffAddDirection(TriDirection);
}
if ( Terrain.Tiles[RotatedPos.X, RotatedPos.Y].TriBottomLeftIsCliff )
{
TileUtil.RotateDirection(TileUtil.BottomLeft, Orientation, ref TriDirection);
NewTerrain.Tiles[X, Y].TriCliffAddDirection(TriDirection);
}
}
NewTerrain.Tiles[X, Y].Terrain_IsCliff = Terrain.Tiles[RotatedPos.X, RotatedPos.Y].Terrain_IsCliff;
}
}
if ( Orientation.SwitchedAxes )
{
for ( Y = 0; Y <= NewTerrain.TileSize.Y; Y++ )
{
Pos.Y = Y;
for ( X = 0; X <= NewTerrain.TileSize.X - 1; X++ )
{
Pos.X = X;
RotatedPos = TileUtil.GetRotatedPos(ReverseOrientation, Pos, NewSideHLimits);
NewTerrain.SideH[X, Y].Road = Terrain.SideV[RotatedPos.X, RotatedPos.Y].Road;
}
}
for ( Y = 0; Y <= NewTerrain.TileSize.Y - 1; Y++ )
{
Pos.Y = Y;
for ( X = 0; X <= NewTerrain.TileSize.X; X++ )
{
Pos.X = X;
RotatedPos = TileUtil.GetRotatedPos(ReverseOrientation, Pos, NewSideVLimits);
NewTerrain.SideV[X, Y].Road = Terrain.SideH[RotatedPos.X, RotatedPos.Y].Road;
}
}
}
else
{
for ( Y = 0; Y <= NewTerrain.TileSize.Y; Y++ )
{
Pos.Y = Y;
for ( X = 0; X <= NewTerrain.TileSize.X - 1; X++ )
{
Pos.X = X;
RotatedPos = TileUtil.GetRotatedPos(ReverseOrientation, Pos, NewSideHLimits);
NewTerrain.SideH[X, Y].Road = Terrain.SideH[RotatedPos.X, RotatedPos.Y].Road;
}
}
for ( Y = 0; Y <= NewTerrain.TileSize.Y - 1; Y++ )
{
Pos.Y = Y;
for ( X = 0; X <= NewTerrain.TileSize.X; X++ )
{
Pos.X = X;
RotatedPos = TileUtil.GetRotatedPos(ReverseOrientation, Pos, NewSideVLimits);
NewTerrain.SideV[X, Y].Road = Terrain.SideV[RotatedPos.X, RotatedPos.Y].Road;
}
}
}
var Unit = default(clsUnit);
foreach ( var tempLoopVar_Unit in Units )
{
Unit = tempLoopVar_Unit;
Unit.Sectors.Clear();
if ( ObjectRotateMode == enumObjectRotateMode.All )
{
Unit.Rotation =
(int)
(MathUtil.AngleClamp(MathUtil.RadOf360Deg -
TileUtil.GetRotatedAngle(Orientation,
MathUtil.AngleClamp(MathUtil.RadOf360Deg - Unit.Rotation * MathUtil.RadOf1Deg))) / MathUtil.RadOf1Deg);
if ( Unit.Rotation < 0 )
{
Unit.Rotation += 360;
}
}
else if ( ObjectRotateMode == enumObjectRotateMode.Walls )
{
if ( Unit.TypeBase.Type == UnitType.PlayerStructure )
{
if ( ((StructureTypeBase)Unit.TypeBase).StructureType == StructureTypeBase.enumStructureType.Wall )
{
Unit.Rotation =
(int)
(MathUtil.AngleClamp(MathUtil.RadOf360Deg -
TileUtil.GetRotatedAngle(Orientation,
MathUtil.AngleClamp(MathUtil.RadOf360Deg - Unit.Rotation * MathUtil.RadOf1Deg))) / MathUtil.RadOf1Deg);
if ( Unit.Rotation < 0 )
{
Unit.Rotation += 360;
}
//If Unit.Rotation = 180 Then
// Unit.Rotation = 0
//ElseIf Unit.Rotation = 270 Then
// Unit.Rotation = 90
//End If
}
}
}
Unit.Pos.Horizontal = TileUtil.GetRotatedPos(Orientation, Unit.Pos.Horizontal, OldPosLimits);
}
var ZeroPos = new XYInt(0, 0);
var Position = 0;
foreach ( var tempLoopVar_Unit in Units.GetItemsAsSimpleList() )
{
Unit = tempLoopVar_Unit;
if ( !App.PosIsWithinTileArea(Unit.Pos.Horizontal, ZeroPos, NewTerrain.TileSize) )
{
Position = Unit.MapLink.ArrayPosition;
UnitRemove(Position);
}
}
Terrain = NewTerrain;
var Gateway = default(clsGateway);
foreach ( var tempLoopVar_Gateway in Gateways.GetItemsAsSimpleClassList() )
{
Gateway = tempLoopVar_Gateway;
GatewayCreate(TileUtil.GetRotatedPos(Orientation, Gateway.PosA, OldTileLimits),
TileUtil.GetRotatedPos(Orientation, Gateway.PosB, OldTileLimits));
Gateway.Deallocate();
}
if ( _ReadyForUserInput )
{
CancelUserInput();
InitializeUserInput();
}
}
public void MapTexturer(ref sLayerList LayerList)
{
var X = 0;
var Y = 0;
var A = 0;
Terrain[,] TerrainType = null;
float[,] Slope = null;
var tmpTerrain = default(Terrain);
var bmA = new BooleanMap();
var bmB = new BooleanMap();
var LayerNum = 0;
var LayerResult = new BooleanMap[LayerList.LayerCount];
double BestSlope = 0;
double CurrentSlope = 0;
var AllowSlope = default(bool);
var Pos = new XYInt();
TerrainType = new Terrain[Terrain.TileSize.X + 1, Terrain.TileSize.Y + 1];
Slope = new float[Terrain.TileSize.X, Terrain.TileSize.Y];
for ( Y = 0; Y <= Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X - 1; X++ )
{
//get slope
BestSlope = 0.0D;
Pos.X = (int)((X + 0.25D) * Constants.TerrainGridSpacing);
Pos.Y = (int)((Y + 0.25D) * Constants.TerrainGridSpacing);
CurrentSlope = GetTerrainSlopeAngle(Pos);
if ( CurrentSlope > BestSlope )
{
BestSlope = CurrentSlope;
}
Pos.X = (int)((X + 0.75D) * Constants.TerrainGridSpacing);
Pos.Y = (int)((Y + 0.25D) * Constants.TerrainGridSpacing);
CurrentSlope = GetTerrainSlopeAngle(Pos);
if ( CurrentSlope > BestSlope )
{
BestSlope = CurrentSlope;
}
Pos.X = (int)((X + 0.25D) * Constants.TerrainGridSpacing);
Pos.Y = (int)((Y + 0.75D) * Constants.TerrainGridSpacing);
CurrentSlope = GetTerrainSlopeAngle(Pos);
if ( CurrentSlope > BestSlope )
{
BestSlope = CurrentSlope;
}
Pos.X = (int)((X + 0.75D) * Constants.TerrainGridSpacing);
Pos.Y = (int)((Y + 0.75D) * Constants.TerrainGridSpacing);
CurrentSlope = GetTerrainSlopeAngle(Pos);
if ( CurrentSlope > BestSlope )
{
BestSlope = CurrentSlope;
}
Slope[X, Y] = (float)BestSlope;
}
}
for ( LayerNum = 0; LayerNum <= LayerList.LayerCount - 1; LayerNum++ )
{
tmpTerrain = LayerList.Layers[LayerNum].Terrain;
if ( tmpTerrain != null )
{
//do other layer constraints
LayerResult[LayerNum] = new BooleanMap();
LayerResult[LayerNum].Copy(LayerList.Layers[LayerNum].Terrainmap);
if ( LayerList.Layers[LayerNum].WithinLayer >= 0 )
{
if ( LayerList.Layers[LayerNum].WithinLayer < LayerNum )
{
bmA.Within(LayerResult[LayerNum], LayerResult[LayerList.Layers[LayerNum].WithinLayer]);
LayerResult[LayerNum].ValueData = bmA.ValueData;
bmA.ValueData = new BooleanMapDataValue();
}
}
for ( A = 0; A <= LayerNum - 1; A++ )
{
if ( LayerList.Layers[LayerNum].AvoidLayers[A] )
{
bmA.Expand_One_Tile(LayerResult[A]);
bmB.Remove(LayerResult[LayerNum], bmA);
LayerResult[LayerNum].ValueData = bmB.ValueData;
bmB.ValueData = new BooleanMapDataValue();
}
}
//do height and slope constraints
for ( Y = 0; Y <= Terrain.TileSize.Y; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X; X++ )
{
if ( LayerResult[LayerNum].ValueData.Value[Y, X] )
{
if ( Terrain.Vertices[X, Y].Height < LayerList.Layers[LayerNum].HeightMin
|| Terrain.Vertices[X, Y].Height > LayerList.Layers[LayerNum].HeightMax )
{
LayerResult[LayerNum].ValueData.Value[Y, X] = false;
}
if ( LayerResult[LayerNum].ValueData.Value[Y, X] )
{
AllowSlope = true;
if ( X > 0 )
{
if ( Y > 0 )
{
if ( Slope[X - 1, Y - 1] < LayerList.Layers[LayerNum].SlopeMin
|| Slope[X - 1, Y - 1] > LayerList.Layers[LayerNum].SlopeMax )
{
AllowSlope = false;
}
}
if ( Y < Terrain.TileSize.Y )
{
if ( Slope[X - 1, Y] < LayerList.Layers[LayerNum].SlopeMin
|| Slope[X - 1, Y] > LayerList.Layers[LayerNum].SlopeMax )
{
AllowSlope = false;
}
}
}
if ( X < Terrain.TileSize.X )
{
if ( Y > 0 )
{
if ( Slope[X, Y - 1] < LayerList.Layers[LayerNum].SlopeMin
|| Slope[X, Y - 1] > LayerList.Layers[LayerNum].SlopeMax )
{
AllowSlope = false;
}
}
if ( Y < Terrain.TileSize.Y )
{
if ( Slope[X, Y] < LayerList.Layers[LayerNum].SlopeMin
|| Slope[X, Y] > LayerList.Layers[LayerNum].SlopeMax )
{
AllowSlope = false;
}
}
}
if ( !AllowSlope )
{
LayerResult[LayerNum].ValueData.Value[Y, X] = false;
}
}
}
}
}
LayerResult[LayerNum].Remove_Diagonals();
for ( Y = 0; Y <= Terrain.TileSize.Y; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X; X++ )
{
if ( LayerResult[LayerNum].ValueData.Value[Y, X] )
{
TerrainType[X, Y] = tmpTerrain;
}
}
}
}
}
//set vertex terrain by terrain map
for ( Y = 0; Y <= Terrain.TileSize.Y; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X; X++ )
{
if ( TerrainType[X, Y] != null )
{
Terrain.Vertices[X, Y].Terrain = TerrainType[X, Y];
}
}
}
AutoTextureChanges.SetAllChanged();
UpdateAutoTextures();
}
public void GenerateMasterTerrain(ref sGenerateMasterTerrainArgs Args)
{
var X = 0;
var Y = 0;
var A = 0;
int[,] TerrainType = null;
float[,] Slope = null;
var TerrainNum = 0;
var bmA = new BooleanMap();
var Layer_Num = 0;
var LayerResult = new BooleanMap[Args.LayerCount];
var bmB = new BooleanMap();
double BestSlope = 0;
double CurrentSlope = 0;
var hmB = new clsHeightmap();
var hmC = new clsHeightmap();
double difA = 0;
double difB = 0;
var NewTri = default(bool);
var CliffSlope = Math.Atan(255.0D * Constants.DefaultHeightMultiplier / (2.0D * (Args.LevelCount - 1.0D) * Constants.TerrainGridSpacing)) -
MathUtil.RadOf1Deg; //divided by 2 due to the terrain height randomization
Tileset = Args.Tileset.Tileset;
for ( Y = 0; Y <= Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X - 1; X++ )
{
difA = Math.Abs((Terrain.Vertices[X + 1, Y + 1].Height) - Terrain.Vertices[X, Y].Height);
difB = Math.Abs((Terrain.Vertices[X, Y + 1].Height) - Terrain.Vertices[X + 1, Y].Height);
if ( difA == difB )
{
if ( App.Random.Next() >= 0.5F )
{
NewTri = false;
}
else
{
NewTri = true;
}
}
else if ( difA < difB )
{
NewTri = false;
}
else
{
NewTri = true;
}
if ( !(Terrain.Tiles[X, Y].Tri == NewTri) )
{
Terrain.Tiles[X, Y].Tri = NewTri;
}
}
}
for ( A = 0; A <= Args.LayerCount - 1; A++ )
{
Args.Layers[A].Terrainmap = new BooleanMap();
if ( Args.Layers[A].TerrainmapDensity == 1.0F )
{
Args.Layers[A].Terrainmap.ValueData.Value = new bool[Terrain.TileSize.Y, Terrain.TileSize.X];
Args.Layers[A].Terrainmap.ValueData.Size = Terrain.TileSize;
for ( Y = 0; Y <= Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X - 1; X++ )
{
Args.Layers[A].Terrainmap.ValueData.Value[Y, X] = true;
}
}
}
else
{
hmB.GenerateNewOfSize(Terrain.TileSize.Y, Terrain.TileSize.X, Convert.ToSingle(Args.Layers[A].TerrainmapScale), 1.0D);
hmC.Rescale(hmB, 0.0D, 1.0D);
Args.Layers[A].Terrainmap.Convert_Heightmap(hmC, (int)((1.0F - Args.Layers[A].TerrainmapDensity) / hmC.HeightScale));
}
}
var Pos = new XYInt();
TerrainType = new int[Terrain.TileSize.X, Terrain.TileSize.Y];
Slope = new float[Terrain.TileSize.X, Terrain.TileSize.Y];
for ( Y = 0; Y <= Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X - 1; X++ )
{
//get slope
BestSlope = 0.0D;
Pos.X = (int)((X + 0.25D) * Constants.TerrainGridSpacing);
Pos.Y = (int)((Y + 0.25D) * Constants.TerrainGridSpacing);
CurrentSlope = GetTerrainSlopeAngle(Pos);
if ( CurrentSlope > BestSlope )
{
BestSlope = CurrentSlope;
}
Pos.X = (int)((X + 0.75D) * Constants.TerrainGridSpacing);
Pos.Y = (int)((Y + 0.25D) * Constants.TerrainGridSpacing);
CurrentSlope = GetTerrainSlopeAngle(Pos);
if ( CurrentSlope > BestSlope )
{
BestSlope = CurrentSlope;
}
Pos.X = (int)((X + 0.25D) * Constants.TerrainGridSpacing);
Pos.Y = (int)((Y + 0.75D) * Constants.TerrainGridSpacing);
CurrentSlope = GetTerrainSlopeAngle(Pos);
if ( CurrentSlope > BestSlope )
{
BestSlope = CurrentSlope;
}
Pos.X = (int)((X + 0.75D) * Constants.TerrainGridSpacing);
Pos.Y = (int)((Y + 0.75D) * Constants.TerrainGridSpacing);
CurrentSlope = GetTerrainSlopeAngle(Pos);
if ( CurrentSlope > BestSlope )
{
BestSlope = CurrentSlope;
}
Slope[X, Y] = (float)BestSlope;
}
}
for ( Layer_Num = 0; Layer_Num <= Args.LayerCount - 1; Layer_Num++ )
{
TerrainNum = Args.Layers[Layer_Num].TileNum;
if ( TerrainNum >= 0 )
{
//do other layer constraints
LayerResult[Layer_Num] = new BooleanMap();
LayerResult[Layer_Num].Copy(Args.Layers[Layer_Num].Terrainmap);
if ( Args.Layers[Layer_Num].WithinLayer >= 0 )
{
if ( Args.Layers[Layer_Num].WithinLayer < Layer_Num )
{
bmA.Within(LayerResult[Layer_Num], LayerResult[Args.Layers[Layer_Num].WithinLayer]);
LayerResult[Layer_Num].ValueData = bmA.ValueData;
bmA.ValueData = new BooleanMapDataValue();
}
}
for ( A = 0; A <= Layer_Num - 1; A++ )
{
if ( Args.Layers[Layer_Num].AvoidLayers[A] )
{
bmA.Expand_One_Tile(LayerResult[A]);
bmB.Remove(LayerResult[Layer_Num], bmA);
LayerResult[Layer_Num].ValueData = bmB.ValueData;
bmB.ValueData = new BooleanMapDataValue();
}
}
//do height and slope constraints
for ( Y = 0; Y <= Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X - 1; X++ )
{
if ( LayerResult[Layer_Num].ValueData.Value[Y, X] )
{
if ( Terrain.Vertices[X, Y].Height < Args.Layers[Layer_Num].HeightMin
|| Terrain.Vertices[X, Y].Height > Args.Layers[Layer_Num].HeightMax )
{
LayerResult[Layer_Num].ValueData.Value[Y, X] = false;
}
if ( Args.Layers[Layer_Num].IsCliff )
{
if ( LayerResult[Layer_Num].ValueData.Value[Y, X] )
{
if ( Slope[X, Y] < CliffSlope )
{
LayerResult[Layer_Num].ValueData.Value[Y, X] = false;
}
}
}
}
}
}
for ( Y = 0; Y <= Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X - 1; X++ )
{
if ( LayerResult[Layer_Num].ValueData.Value[Y, X] )
{
TerrainType[X, Y] = TerrainNum;
}
}
}
}
}
//set water tiles
for ( Y = 0; Y <= Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X - 1; X++ )
{
if ( Args.Watermap.ValueData.Value[Y, X] )
{
if ( Slope[X, Y] < CliffSlope )
{
TerrainType[X, Y] = 17;
}
}
}
}
//set border tiles to cliffs
for ( Y = 0; Y <= Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= 2; X++ )
{
TerrainType[X, Y] = Args.Tileset.BorderTextureNum;
}
for ( X = Terrain.TileSize.X - 4; X <= Terrain.TileSize.X - 1; X++ )
{
TerrainType[X, Y] = Args.Tileset.BorderTextureNum;
}
}
for ( X = 3; X <= Terrain.TileSize.X - 5; X++ )
{
for ( Y = 0; Y <= 2; Y++ )
{
TerrainType[X, Y] = Args.Tileset.BorderTextureNum;
}
for ( Y = Terrain.TileSize.Y - 4; Y <= Terrain.TileSize.Y - 1; Y++ )
{
TerrainType[X, Y] = Args.Tileset.BorderTextureNum;
}
}
for ( Y = 0; Y <= Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X - 1; X++ )
{
Terrain.Tiles[X, Y].Texture.TextureNum = TerrainType[X, Y];
}
}
}
public INIObject()
{
Pos = new XYInt (0, 0);
}
private XYZInt lndPos_From_MapPos(XYInt Horizontal)
{
return new XYZInt(Horizontal.X - (int)(map.Terrain.TileSize.X * Constants.TerrainGridSpacing / 2.0D),
((int)(map.Terrain.TileSize.Y * Constants.TerrainGridSpacing / 2.0D)) - Horizontal.Y,
(int)(map.GetTerrainHeight(Horizontal)));
}
private void DrawView()
{
if ( !(DrawView_Enabled && IsGLInitialized) )
{
return;
}
if ( GraphicsContext.CurrentContext != OpenGLControl.Context )
{
OpenGLControl.MakeCurrent();
}
GL.Clear(ClearBufferMask.ColorBufferBit);
var Map = MainMap;
if ( Map == null )
{
GL.Flush();
OpenGLControl.SwapBuffers();
Refresh();
return;
}
var X = 0;
var Y = 0;
var Num = 0;
var XY_int = new XYInt();
var A = 0;
var Vertex0 = new XYDouble();
var Vertex1 = new XYDouble();
var Vertex2 = new XYDouble();
var UnrotatedPos = new XYDouble();
var TexCoord0 = new XYDouble();
var TexCoord1 = new XYDouble();
var TexCoord2 = new XYDouble();
var TexCoord3 = new XYDouble();
GL.MatrixMode(MatrixMode.Projection);
var temp_mat = Matrix4.CreateOrthographicOffCenter(0.0F, GLSize.X, GLSize.Y, 0.0F, -1.0F, 1.0F);
GL.LoadMatrix(ref temp_mat);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
if ( Map.Tileset != null )
{
TileUtil.GetTileRotatedTexCoords(App.TextureOrientation, ref TexCoord0, ref TexCoord1, ref TexCoord2, ref TexCoord3);
GL.Enable(EnableCap.Texture2D);
GL.Color4(0.0F, 0.0F, 0.0F, 1.0F);
for ( Y = 0; Y <= TextureCount.Y - 1; Y++ )
{
for ( X = 0; X <= TextureCount.X - 1; X++ )
{
Num = (TextureYOffset + Y) * TextureCount.X + X;
if ( Num >= Map.Tileset.TileCount )
{
goto EndOfTextures1;
}
A = Map.Tileset.Tiles[Num].TextureViewGlTextureNum;
GL.BindTexture(TextureTarget.Texture2D, A);
GL.TexEnv(TextureEnvTarget.TextureEnv, TextureEnvParameter.TextureEnvMode, (int)TextureEnvMode.Decal);
GL.Begin(BeginMode.Quads);
GL.TexCoord2(TexCoord0.X, TexCoord0.Y);
GL.Vertex2(X * 64, Y * 64); // Top Left
GL.TexCoord2(TexCoord1.X, TexCoord1.Y);
GL.Vertex2(X * 64 + 64, Y * 64); // Bottom Left
GL.TexCoord2(TexCoord3.X, TexCoord3.Y);
GL.Vertex2(X * 64 + 64, Y * 64 + 64); // Bottom right
GL.TexCoord2(TexCoord2.X, TexCoord2.Y);
GL.Vertex2(X * 64, Y * 64 + 64); // Top right
GL.End();
}
}
EndOfTextures1:
GL.Disable(EnableCap.Texture2D);
if ( DisplayTileTypes )
{
GL.Begin(BeginMode.Quads);
for ( Y = 0; Y <= TextureCount.Y - 1; Y++ )
{
for ( X = 0; X <= TextureCount.X - 1; X++ )
{
Num = (TextureYOffset + Y) * TextureCount.X + X;
if ( Num >= Map.Tileset.TileCount )
{
goto EndOfTextures2;
}
A = Map.Tile_TypeNum[Num];
GL.Color3(App.TileTypes[A].DisplayColour.Red, App.TileTypes[A].DisplayColour.Green, App.TileTypes[A].DisplayColour.Blue);
GL.Vertex2(X * 64 + 24, Y * 64 + 24);
GL.Vertex2(X * 64 + 24, Y * 64 + 40);
GL.Vertex2(X * 64 + 40, Y * 64 + 40);
GL.Vertex2(X * 64 + 40, Y * 64 + 24);
}
}
EndOfTextures2:
GL.End();
}
if ( App.DisplayTileOrientation )
{
GL.Disable(EnableCap.CullFace);
UnrotatedPos.X = 0.25F;
UnrotatedPos.Y = 0.25F;
Vertex0 = TileUtil.GetTileRotatedPos_sng(App.TextureOrientation, UnrotatedPos);
UnrotatedPos.X = 0.5F;
UnrotatedPos.Y = 0.25F;
Vertex1 = TileUtil.GetTileRotatedPos_sng(App.TextureOrientation, UnrotatedPos);
UnrotatedPos.X = 0.5F;
UnrotatedPos.Y = 0.5F;
Vertex2 = TileUtil.GetTileRotatedPos_sng(App.TextureOrientation, UnrotatedPos);
GL.Begin(BeginMode.Triangles);
GL.Color3(1.0F, 1.0F, 0.0F);
for ( Y = 0; Y <= TextureCount.Y - 1; Y++ )
{
for ( X = 0; X <= TextureCount.X - 1; X++ )
{
Num = (TextureYOffset + Y) * TextureCount.X + X;
if ( Num >= Map.Tileset.TileCount )
{
goto EndOfTextures3;
}
GL.Vertex2(X * 64 + Vertex0.X * 64, Y * 64 + Vertex0.Y * 64);
GL.Vertex2(X * 64 + Vertex2.X * 64, Y * 64 + Vertex2.Y * 64);
GL.Vertex2(X * 64 + Vertex1.X * 64, Y * 64 + Vertex1.Y * 64);
}
}
EndOfTextures3:
GL.End();
GL.Enable(EnableCap.CullFace);
}
if ( DisplayTileNumbers && App.UnitLabelFont != null ) //TextureViewFont IsNot Nothing Then
{
var TextLabel = default(clsTextLabel);
GL.Enable(EnableCap.Texture2D);
for ( Y = 0; Y <= TextureCount.Y - 1; Y++ )
{
for ( X = 0; X <= TextureCount.X - 1; X++ )
{
Num = (TextureYOffset + Y) * TextureCount.X + X;
if ( Num >= Map.Tileset.TileCount )
{
goto EndOfTextures4;
}
TextLabel = new clsTextLabel();
TextLabel.Text = Num.ToStringInvariant();
TextLabel.SizeY = 24.0F;
TextLabel.Colour.Red = 1.0F;
TextLabel.Colour.Green = 1.0F;
TextLabel.Colour.Blue = 0.0F;
TextLabel.Colour.Alpha = 1.0F;
TextLabel.Pos.X = X * 64;
TextLabel.Pos.Y = Y * 64;
TextLabel.TextFont = App.UnitLabelFont; //TextureViewFont
TextLabel.Draw();
}
}
EndOfTextures4:
GL.Disable(EnableCap.Texture2D);
}
if ( App.SelectedTextureNum >= 0 & TextureCount.X > 0 )
{
A = App.SelectedTextureNum - TextureYOffset * TextureCount.X;
XY_int.X = A - A / TextureCount.X * TextureCount.X;
XY_int.Y = A / TextureCount.X;
GL.Begin(BeginMode.LineLoop);
GL.Color3(1.0F, 1.0F, 0.0F);
GL.Vertex2(XY_int.X * 64, XY_int.Y * 64);
GL.Vertex2(XY_int.X * 64, XY_int.Y * 64.0D + 64);
GL.Vertex2(XY_int.X * 64 + 64, XY_int.Y * 64 + 64);
GL.Vertex2(XY_int.X * 64 + 64, XY_int.Y * 64);
GL.End();
}
}
GL.Flush();
OpenGLControl.SwapBuffers();
Refresh();
}
public XYInt get_GetFootprintNew(int Rotation)
{
//get initial footprint
var Result = new XYInt();
switch ( Type )
{
case UnitType.Feature:
Result = ((FeatureTypeBase)this).Footprint;
break;
case UnitType.PlayerStructure:
Result = ((StructureTypeBase)this).Footprint;
break;
default:
//return droid footprint
Result = new XYInt(1, 1);
return Result;
}
//switch footprint axes if not a droid
var Remainder = Convert.ToDouble((Rotation / 90.0D + 0.5D) % 2.0D);
if ( Remainder < 0.0D )
{
Remainder += 2.0D;
}
if ( Remainder >= 1.0D )
{
var X = Result.X;
Result.X = Result.Y;
Result.Y = X;
}
return Result;
}
public void VertexAndNormalsChanged(XYInt Num)
{
if ( Num.X > 1 )
{
if ( Num.Y > 0 )
{
TileChanged(new XYInt(Num.X - 2, Num.Y - 1));
}
if ( Num.Y < Terrain.TileSize.Y )
{
TileChanged(new XYInt(Num.X - 2, Num.Y));
}
}
if ( Num.X > 0 )
{
if ( Num.Y > 1 )
{
TileChanged(new XYInt(Num.X - 1, Num.Y - 2));
}
if ( Num.Y > 0 )
{
TileChanged(new XYInt(Num.X - 1, Num.Y - 1));
}
if ( Num.Y < Terrain.TileSize.Y )
{
TileChanged(new XYInt(Num.X - 1, Num.Y));
}
if ( Num.Y < Terrain.TileSize.Y - 1 )
{
TileChanged(new XYInt(Num.X - 1, Num.Y + 1));
}
}
if ( Num.X < Terrain.TileSize.X )
{
if ( Num.Y > 1 )
{
TileChanged(new XYInt(Num.X, Num.Y - 2));
}
if ( Num.Y > 0 )
{
TileChanged(new XYInt(Num.X, Num.Y - 1));
}
if ( Num.Y < Terrain.TileSize.Y )
{
TileChanged(Num);
}
if ( Num.Y < Terrain.TileSize.Y - 1 )
{
TileChanged(new XYInt(Num.X, Num.Y + 1));
}
}
if ( Num.X < Terrain.TileSize.X - 1 )
{
if ( Num.Y > 0 )
{
TileChanged(new XYInt(Num.X + 1, Num.Y - 1));
}
if ( Num.Y < Terrain.TileSize.Y )
{
TileChanged(new XYInt(Num.X + 1, Num.Y));
}
}
}
private void PerformAction(clsAction Action, sPosNum PosNum, XYInt LastValidNum)
{
int XNum = 0;
int X = 0;
int Y = 0;
XYInt Centre = new XYInt(0, 0);
if ( Action.Map == null )
{
Debugger.Break();
return;
}
Centre = GetPosNum(PosNum);
Action.Effect = 1.0D;
for ( Y = MathUtil.Clamp_int(Tiles.YMin + Centre.Y, 0, LastValidNum.Y) - Centre.Y;
Y <= MathUtil.Clamp_int(Tiles.YMax + Centre.Y, 0, LastValidNum.Y) - Centre.Y;
Y++ )
{
Action.PosNum.Y = Centre.Y + Y;
XNum = Y - Tiles.YMin;
for ( X = MathUtil.Clamp_int(Tiles.XMin[XNum] + Centre.X, 0, LastValidNum.X) - Centre.X;
X <= MathUtil.Clamp_int(Convert.ToInt32(Tiles.XMax[XNum] + Centre.X), 0, LastValidNum.X) - Centre.X;
X++ )
{
Action.PosNum.X = Centre.X + X;
if ( Action.UseEffect )
{
if ( Tiles.ResultRadius > 0.0D )
{
switch ( _Shape )
{
case enumShape.Circle:
if ( _Alignment )
{
Action.Effect =
Convert.ToDouble(1.0D -
(new XYDouble(Action.PosNum.X, Action.PosNum.Y) -
new XYDouble(Centre.X - 0.5D, Centre.Y - 0.5D)).GetMagnitude() /
(Tiles.ResultRadius + 0.5D));
}
else
{
Action.Effect = Convert.ToDouble(1.0D - (Centre - Action.PosNum).ToDoubles().GetMagnitude() / (Tiles.ResultRadius + 0.5D));
}
break;
case enumShape.Square:
if ( _Alignment )
{
Action.Effect = 1.0D -
Math.Max(Math.Abs(Action.PosNum.X - (Centre.X - 0.5D)), Math.Abs(Action.PosNum.Y - (Centre.Y - 0.5D))) /
(Tiles.ResultRadius + 0.5D);
}
else
{
Action.Effect = 1.0D -
Math.Max(Math.Abs(Action.PosNum.X - Centre.X), Math.Abs(Action.PosNum.Y - Centre.Y)) /
(Tiles.ResultRadius + 0.5D);
}
break;
}
}
}
Action.ActionPerform();
}
}
}
public bool IsInRange(XYInt Minimum, XYInt Maximum)
{
return(X >= Minimum.X & X <= Maximum.X
& Y >= Minimum.Y & Y <= Maximum.Y);
}
public FeatureTypeBase()
{
Footprint = new XYInt(0, 0);
FeatureType_ObjectDataLink = new ConnectedListLink<FeatureTypeBase, clsObjectData>(this);
Type = UnitType.Feature;
}
public clsMapTileChanges(clsMap Map, XYInt PointSize)
: base(PointSize)
{
this.Map = Map;
Terrain = Map.Terrain;
}
public void VertexChanged(XYInt Num)
{
if ( Num.X > 0 )
{
if ( Num.Y > 0 )
{
TileChanged(new XYInt(Num.X - 1, Num.Y - 1));
}
if ( Num.Y < Terrain.TileSize.Y )
{
TileChanged(new XYInt(Num.X - 1, Num.Y));
}
}
if ( Num.X < Terrain.TileSize.X )
{
if ( Num.Y > 0 )
{
TileChanged(new XYInt(Num.X, Num.Y - 1));
}
if ( Num.Y < Terrain.TileSize.Y )
{
TileChanged(Num);
}
}
}
public override void TileChanged(XYInt Num)
{
Changed(Num);
}
public void WaterTriCorrection()
{
if ( Tileset == null )
{
return;
}
var X = 0;
var Y = 0;
var TileNum = new XYInt();
for ( Y = 0; Y <= Terrain.TileSize.Y - 1; Y++ )
{
TileNum.Y = Y;
for ( X = 0; X <= Terrain.TileSize.X - 1; X++ )
{
TileNum.X = X;
if ( Terrain.Tiles[X, Y].Tri )
{
if ( Terrain.Tiles[X, Y].Texture.TextureNum >= 0 )
{
if ( Tileset.Tiles[Terrain.Tiles[X, Y].Texture.TextureNum].DefaultType == Constants.TileTypeNum_Water )
{
Terrain.Tiles[X, Y].Tri = false;
SectorGraphicsChanges.TileChanged(TileNum);
SectorTerrainUndoChanges.TileChanged(TileNum);
}
}
}
}
}
}
public clsMinimapTexture(XYInt Size)
{
this.Size = Size;
InlinePixels = new sRGBA_sng[Size.X * Size.Y];
}
public WorldPos(XYInt horizontal, int altitude)
{
Horizontal = horizontal;
Altitude = altitude;
}
public static XYInt Max(XYInt a, XYInt b)
{
return(new XYInt(Math.Max(a.X, b.X),
Math.Max(a.Y, b.Y)));
}
public clsResult Load(string path)
{
var returnResult =
new clsResult("Loading LND from \"{0}\"".Format2(path), false);
logger.Info("Loading LND from \"{0}\"".Format2(path));
try
{
var strTemp = "";
var strTemp2 = "";
var X = 0;
var Y = 0;
var A = 0;
var B = 0;
var Tile_Num = 0;
// SimpleList<string> LineData = default(SimpleList<string>);
var Line_Num = 0;
LNDTile[] LNDTile = null;
var LNDObjects = new SimpleList<LNDObject>();
var UnitAdd = new clsUnitAdd();
UnitAdd.Map = map;
var Reader = default(BinaryReader);
try
{
Reader = new BinaryReader(new FileStream(path, FileMode.Open), App.UTF8Encoding);
}
catch ( Exception ex )
{
returnResult.ProblemAdd(ex.Message);
return returnResult;
}
var LineData = IOUtil.BytesToLinesRemoveComments(Reader);
Reader.Close();
Array.Resize(ref LNDTile, LineData.Count);
var strTemp3 = "";
var GotTiles = default(bool);
var GotObjects = default(bool);
var GotGates = default(bool);
var GotTileTypes = default(bool);
var LNDTileType = new byte[0];
var ObjectText = new string[11];
var GateText = new string[4];
var TileTypeText = new string[256];
var LNDTileTypeCount = 0;
var LNDGates = new SimpleList<clsGateway>();
var Gateway = default(clsGateway);
var C = 0;
var D = 0;
var GotText = default(bool);
var FlipX = default(bool);
var FlipZ = default(bool);
byte Rotation = 0;
var NewTileSize = new XYInt();
double dblTemp = 0;
Line_Num = 0;
while ( Line_Num < LineData.Count )
{
strTemp = LineData[Line_Num];
A = strTemp.IndexOf("TileWidth ") + 1;
if ( A == 0 )
{
}
A = strTemp.IndexOf("TileHeight ") + 1;
if ( A == 0 )
{
}
A = strTemp.IndexOf("MapWidth ") + 1;
if ( A == 0 )
{
}
else
{
IOUtil.InvariantParse(strTemp.Substring(strTemp.Length - (strTemp.Length - (A + 8)), strTemp.Length - (A + 8)), ref NewTileSize.X);
goto LineDone;
}
A = strTemp.IndexOf("MapHeight ") + 1;
if ( A == 0 )
{
}
else
{
IOUtil.InvariantParse(strTemp.Substring(strTemp.Length - (strTemp.Length - (A + 9)), strTemp.Length - (A + 9)), ref NewTileSize.Y);
goto LineDone;
}
A = strTemp.IndexOf("Textures {") + 1;
if ( A == 0 )
{
}
else
{
Line_Num++;
strTemp = LineData[Line_Num];
strTemp2 = strTemp.ToLower();
if ( strTemp2.IndexOf("tertilesc1") + 1 > 0 )
{
map.Tileset = App.Tileset_Arizona;
}
if ( strTemp2.IndexOf("tertilesc2") + 1 > 0 )
{
map.Tileset = App.Tileset_Urban;
}
if ( strTemp2.IndexOf("tertilesc3") + 1 > 0 )
{
map.Tileset = App.Tileset_Rockies;
}
goto LineDone;
}
A = strTemp.IndexOf("Tiles {") + 1;
if ( A == 0 || GotTiles )
{
}
else
{
Line_Num++;
while ( Line_Num < LineData.Count )
{
strTemp = LineData[Line_Num];
A = strTemp.IndexOf("}") + 1;
if ( A == 0 )
{
A = strTemp.IndexOf("TID ") + 1;
if ( A == 0 )
{
returnResult.ProblemAdd("Tile ID missing");
return returnResult;
}
strTemp2 = strTemp.Substring(strTemp.Length - (strTemp.Length - A - 3), strTemp.Length - A - 3);
A = strTemp2.IndexOf(" ") + 1;
if ( A > 0 )
{
strTemp2 = strTemp2.Substring(0, A - 1);
}
var temp_Result = LNDTile[Tile_Num].TID;
IOUtil.InvariantParse(strTemp2, ref temp_Result);
A = strTemp.IndexOf("VF ") + 1;
if ( A == 0 )
{
returnResult.ProblemAdd("Tile VF missing");
return returnResult;
}
strTemp2 = strTemp.Substring(strTemp.Length - (strTemp.Length - A - 2), strTemp.Length - A - 2);
A = strTemp2.IndexOf(" ") + 1;
if ( A > 0 )
{
strTemp2 = strTemp2.Substring(0, A - 1);
}
var temp_Result2 = LNDTile[Tile_Num].VF;
IOUtil.InvariantParse(strTemp2, ref temp_Result2);
A = strTemp.IndexOf("TF ") + 1;
if ( A == 0 )
{
returnResult.ProblemAdd("Tile TF missing");
return returnResult;
}
strTemp2 = strTemp.Substring(strTemp.Length - (strTemp.Length - A - 2), strTemp.Length - A - 2);
A = strTemp2.IndexOf(" ") + 1;
if ( A > 0 )
{
strTemp2 = strTemp2.Substring(0, A - 1);
}
var temp_Result3 = LNDTile[Tile_Num].TF;
IOUtil.InvariantParse(strTemp2, ref temp_Result3);
A = strTemp.IndexOf(" F ") + 1;
if ( A == 0 )
{
returnResult.ProblemAdd("Tile flip missing");
return returnResult;
}
strTemp2 = strTemp.Substring(strTemp.Length - A - 2, strTemp.Length - A - 2);
A = strTemp2.IndexOf(" ");
if ( A > 0 )
{
strTemp2 = strTemp2.Substring(0, A);
}
var temp_Result4 = LNDTile[Tile_Num].F;
IOUtil.InvariantParse(strTemp2, ref temp_Result4);
A = strTemp.IndexOf(" VH ") + 1;
if ( A == 0 )
{
returnResult.ProblemAdd("Tile height is missing");
return returnResult;
}
strTemp3 = strTemp.Substring(strTemp.Length - (strTemp.Length - A - 3), strTemp.Length - A - 3);
for ( A = 0; A <= 2; A++ )
{
B = strTemp3.IndexOf(" ") + 1;
if ( B == 0 )
{
returnResult.ProblemAdd("A tile height value is missing");
return returnResult;
}
strTemp2 = strTemp3.Substring(0, B - 1);
strTemp3 = strTemp3.Substring(strTemp3.Length - (strTemp3.Length - B), strTemp3.Length - B);
if ( A == 0 )
{
var temp_Result5 = LNDTile[Tile_Num].Vertex0Height;
IOUtil.InvariantParse(strTemp2, ref temp_Result5);
}
else if ( A == 1 )
{
var temp_Result6 = LNDTile[Tile_Num].Vertex1Height;
IOUtil.InvariantParse(strTemp2, ref temp_Result6);
}
else if ( A == 2 )
{
var temp_Result7 = LNDTile[Tile_Num].Vertex2Height;
IOUtil.InvariantParse(strTemp2, ref temp_Result7);
}
}
var temp_Result8 = LNDTile[Tile_Num].Vertex3Height;
IOUtil.InvariantParse(strTemp3, ref temp_Result8);
Tile_Num++;
}
else
{
GotTiles = true;
goto LineDone;
}
Line_Num++;
}
GotTiles = true;
goto LineDone;
}
A = strTemp.IndexOf("Objects {") + 1;
if ( A == 0 || GotObjects )
{
}
else
{
Line_Num++;
while ( Line_Num < LineData.Count )
{
strTemp = LineData[Line_Num];
A = strTemp.IndexOf("}") + 1;
if ( A == 0 )
{
C = 0;
ObjectText[0] = "";
GotText = false;
for ( B = 0; B <= strTemp.Length - 1; B++ )
{
if ( strTemp[B] != ' ' && strTemp[B] != '\t' )
{
GotText = true;
ObjectText[C] += strTemp[B].ToString();
}
else
{
if ( GotText )
{
C++;
if ( C == 11 )
{
returnResult.ProblemAdd("Too many fields for an object, or a space at the end.");
return returnResult;
}
ObjectText[C] = "";
GotText = false;
}
}
}
var NewObject = new LNDObject();
IOUtil.InvariantParse(ObjectText[0], ref NewObject.ID);
IOUtil.InvariantParse(ObjectText[1], ref NewObject.TypeNum);
NewObject.Code = ObjectText[2].Substring(1, ObjectText[2].Length - 2); //remove quotes
IOUtil.InvariantParse(ObjectText[3], ref NewObject.PlayerNum);
NewObject.Name = ObjectText[4].Substring(1, ObjectText[4].Length - 2); //remove quotes
IOUtil.InvariantParse(ObjectText[5], ref NewObject.Pos.X);
IOUtil.InvariantParse(ObjectText[6], ref NewObject.Pos.Y);
IOUtil.InvariantParse(ObjectText[7], ref NewObject.Pos.Z);
if ( IOUtil.InvariantParse(ObjectText[8], ref dblTemp) )
{
NewObject.Rotation.X = (int)(MathUtil.Clamp_dbl(dblTemp, 0.0D, 359.0D));
}
if ( IOUtil.InvariantParse(ObjectText[9], ref dblTemp) )
{
NewObject.Rotation.Y = (int)(MathUtil.Clamp_dbl(dblTemp, 0.0D, 359.0D));
}
if ( IOUtil.InvariantParse(ObjectText[10], ref dblTemp) )
{
NewObject.Rotation.Z = (int)(MathUtil.Clamp_dbl(dblTemp, 0.0D, 359.0D));
}
LNDObjects.Add(NewObject);
}
else
{
GotObjects = true;
goto LineDone;
}
Line_Num++;
}
GotObjects = true;
goto LineDone;
}
A = strTemp.IndexOf("Gates {") + 1;
if ( A == 0 || GotGates )
{
}
else
{
Line_Num++;
while ( Line_Num < LineData.Count )
{
strTemp = LineData[Line_Num];
A = strTemp.IndexOf("}") + 1;
if ( A == 0 )
{
C = 0;
GateText[0] = "";
GotText = false;
for ( B = 0; B <= strTemp.Length - 1; B++ )
{
if ( strTemp[B] != ' ' && strTemp[B] != '\t' )
{
GotText = true;
GateText[C] += strTemp[B].ToString();
}
else
{
if ( GotText )
{
C++;
if ( C == 4 )
{
returnResult.ProblemAdd("Too many fields for a gateway, or a space at the end.");
return returnResult;
}
GateText[C] = "";
GotText = false;
}
}
}
Gateway = new clsGateway();
IOUtil.InvariantParse(GateText[0], ref Gateway.PosA.X);
Gateway.PosA.X = Math.Max(Gateway.PosA.X, 0);
IOUtil.InvariantParse(GateText[1], ref Gateway.PosA.Y);
Gateway.PosA.Y = Math.Max(Gateway.PosA.Y, 0);
IOUtil.InvariantParse(GateText[2], ref Gateway.PosB.X);
Gateway.PosB.X = Math.Max(Gateway.PosB.X, 0);
IOUtil.InvariantParse(GateText[3], ref Gateway.PosB.Y);
Gateway.PosB.Y = Math.Max(Gateway.PosB.Y, 0);
LNDGates.Add(Gateway);
}
else
{
GotGates = true;
goto LineDone;
}
Line_Num++;
}
GotGates = true;
goto LineDone;
}
A = strTemp.IndexOf("Tiles {") + 1;
if ( A == 0 || GotTileTypes || !GotTiles )
{
}
else
{
Line_Num++;
while ( Line_Num < LineData.Count )
{
strTemp = LineData[Line_Num];
A = strTemp.IndexOf("}") + 1;
if ( A == 0 )
{
C = 0;
TileTypeText[0] = "";
GotText = false;
for ( B = 0; B <= strTemp.Length - 1; B++ )
{
if ( strTemp[B] != ' ' && strTemp[B] != '\t' )
{
GotText = true;
TileTypeText[C] += strTemp[B].ToString();
}
else
{
if ( GotText )
{
C++;
if ( C == 256 )
{
returnResult.ProblemAdd("Too many fields for tile types.");
return returnResult;
}
TileTypeText[C] = "";
GotText = false;
}
}
}
if ( TileTypeText[C] == "" || TileTypeText[C] == " " )
{
C--;
}
for ( D = 0; D <= C; D++ )
{
Array.Resize(ref LNDTileType, LNDTileTypeCount + 1);
LNDTileType[LNDTileTypeCount] = Math.Min(byte.Parse(TileTypeText[D]), (byte)11);
LNDTileTypeCount++;
}
}
else
{
GotTileTypes = true;
goto LineDone;
}
Line_Num++;
}
GotTileTypes = true;
}
LineDone:
Line_Num++;
}
Array.Resize(ref LNDTile, Tile_Num);
map.SetPainterToDefaults();
if ( NewTileSize.X < 1 | NewTileSize.Y < 1 )
{
returnResult.ProblemAdd("The LND\'s terrain dimensions are missing or invalid.");
return returnResult;
}
map.TerrainBlank(NewTileSize);
map.TileType_Reset();
for ( Y = 0; Y <= map.Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= map.Terrain.TileSize.X - 1; X++ )
{
Tile_Num = Y * map.Terrain.TileSize.X + X;
//lnd uses different order! (3 = 2, 2 = 3), this program goes left to right, lnd goes clockwise around each tile
map.Terrain.Vertices[X, Y].Height = (byte)(LNDTile[Tile_Num].Vertex0Height);
}
}
for ( Y = 0; Y <= map.Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= map.Terrain.TileSize.X - 1; X++ )
{
Tile_Num = Y * map.Terrain.TileSize.X + X;
map.Terrain.Tiles[X, Y].Texture.TextureNum = LNDTile[Tile_Num].TID - 1;
//ignore higher values
A = Convert.ToInt32((LNDTile[Tile_Num].F / 64.0D));
LNDTile[Tile_Num].F = (short)(LNDTile[Tile_Num].F - A * 64);
A = (int)((LNDTile[Tile_Num].F / 16.0D));
LNDTile[Tile_Num].F = (short)(LNDTile[Tile_Num].F - A * 16);
if ( A < 0 | A > 3 )
{
returnResult.ProblemAdd("Invalid flip value.");
return returnResult;
}
Rotation = (byte)A;
A = (int)((LNDTile[Tile_Num].F / 8.0D));
LNDTile[Tile_Num].F -= (short)(A * 8);
FlipZ = A == 1;
A = (int)((LNDTile[Tile_Num].F / 4.0D));
LNDTile[Tile_Num].F -= (short)(A * 4);
FlipX = A == 1;
A = Convert.ToInt32((LNDTile[Tile_Num].F / 2.0D));
LNDTile[Tile_Num].F -= (short)(A * 2);
map.Terrain.Tiles[X, Y].Tri = A == 1;
//vf, tf, ignore
TileUtil.OldOrientation_To_TileOrientation(Rotation, FlipX, FlipZ, ref map.Terrain.Tiles[X, Y].Texture.Orientation);
}
}
var newUnit = default(clsUnit);
var xyzInt = new XYZInt(0, 0, 0);
var newTypeBase = default(UnitTypeBase);
UInt32 availableID = 0;
availableID = 1U;
foreach ( var currentObject in LNDObjects )
{
if ( currentObject.ID >= availableID )
{
availableID = currentObject.ID + 1U;
}
}
foreach ( var currentObject in LNDObjects )
{
switch ( currentObject.TypeNum )
{
case 0:
newTypeBase = App.ObjectData.FindOrCreateUnitType(currentObject.Code, UnitType.Feature, -1);
break;
case 1:
newTypeBase = App.ObjectData.FindOrCreateUnitType(currentObject.Code, UnitType.PlayerStructure, -1);
break;
case 2:
newTypeBase = App.ObjectData.FindOrCreateUnitType(currentObject.Code, UnitType.PlayerDroid, -1);
break;
default:
newTypeBase = null;
break;
}
if ( newTypeBase != null )
{
newUnit = new clsUnit();
newUnit.TypeBase = newTypeBase;
if ( currentObject.PlayerNum < 0 | currentObject.PlayerNum >= Constants.PlayerCountMax )
{
newUnit.UnitGroup = map.ScavengerUnitGroup;
}
else
{
newUnit.UnitGroup = map.UnitGroups[currentObject.PlayerNum];
}
xyzInt.X = (int)currentObject.Pos.X;
xyzInt.Y = (int)currentObject.Pos.Y;
xyzInt.Z = (int)currentObject.Pos.Z;
newUnit.Pos = mapPos_From_LNDPos(xyzInt);
newUnit.Rotation = currentObject.Rotation.Y;
if ( currentObject.ID == 0U )
{
currentObject.ID = availableID;
App.ZeroIDWarning(newUnit, currentObject.ID, returnResult);
}
UnitAdd.NewUnit = newUnit;
UnitAdd.ID = currentObject.ID;
UnitAdd.Perform();
App.ErrorIDChange(currentObject.ID, newUnit, "Load_LND");
if ( availableID == currentObject.ID )
{
availableID = newUnit.ID + 1U;
}
}
}
foreach ( var tempLoopVar_Gateway in LNDGates )
{
Gateway = tempLoopVar_Gateway;
map.GatewayCreate(Gateway.PosA, Gateway.PosB);
}
if ( map.Tileset != null )
{
for ( A = 0; A <= Math.Min(LNDTileTypeCount - 1, map.Tileset.TileCount) - 1; A++ )
{
map.Tile_TypeNum[A] = LNDTileType[A + 1]; //lnd value 0 is ignored
}
}
}
catch ( Exception ex )
{
returnResult.ProblemAdd(ex.Message);
return returnResult;
}
return returnResult;
}
public void ActionPerform()
{
var X = 0;
var Y = 0;
GL.Begin(BeginMode.LineStrip);
GL.Color4(Colour.Red, Colour.Green, Colour.Blue, Colour.Alpha);
StartTile.Y = StartXY.Y / Constants.TerrainGridSpacing;
FinishTile.Y = FinishXY.Y / Constants.TerrainGridSpacing;
LastXTile = StartXY.X / Constants.TerrainGridSpacing;
Horizontal = StartXY;
vertex.X = Horizontal.X;
vertex.Y = (int)(Map.GetTerrainHeight(Horizontal));
vertex.Z = Convert.ToInt32(- Horizontal.Y);
GL.Vertex3(vertex.X, vertex.Y, Convert.ToInt32(- vertex.Z));
if ( StartTile.Y + 1 <= FinishTile.Y )
{
for ( Y = StartTile.Y + 1; Y <= FinishTile.Y; Y++ )
{
TileEdgeStart.X = 0;
TileEdgeStart.Y = Y * Constants.TerrainGridSpacing;
TileEdgeFinish.X = Map.Terrain.TileSize.X * Constants.TerrainGridSpacing;
TileEdgeFinish.Y = Y * Constants.TerrainGridSpacing;
IntersectY = MathUtil.GetLinesIntersectBetween(StartXY, FinishXY, TileEdgeStart, TileEdgeFinish);
if ( IntersectY.Exists )
{
StartTile.X = LastXTile;
FinishTile.X = IntersectY.Pos.X / Constants.TerrainGridSpacing;
for ( X = StartTile.X + 1; X <= FinishTile.X; X++ )
{
TileEdgeStart.X = X * Constants.TerrainGridSpacing;
TileEdgeStart.Y = 0;
TileEdgeFinish.X = X * Constants.TerrainGridSpacing;
TileEdgeFinish.Y = Map.Terrain.TileSize.Y * Constants.TerrainGridSpacing;
IntersectX = MathUtil.GetLinesIntersectBetween(StartXY, FinishXY, TileEdgeStart, TileEdgeFinish);
if ( IntersectX.Exists )
{
Horizontal = IntersectX.Pos;
vertex.X = Horizontal.X;
vertex.Y = (int)(Map.GetTerrainHeight(Horizontal));
vertex.Z = Convert.ToInt32(- Horizontal.Y);
GL.Vertex3(vertex.X, vertex.Y, Convert.ToInt32(- vertex.Z));
}
}
LastXTile = FinishTile.X;
Horizontal = IntersectY.Pos;
vertex.X = Horizontal.X;
vertex.Y = (int)(Map.GetTerrainHeight(Horizontal));
vertex.Z = Convert.ToInt32(- Horizontal.Y);
GL.Vertex3(vertex.X, vertex.Y, Convert.ToInt32(- vertex.Z));
}
}
}
else
{
StartTile.X = LastXTile;
FinishTile.X = FinishXY.X / Constants.TerrainGridSpacing;
for ( X = StartTile.X + 1; X <= FinishTile.X; X++ )
{
TileEdgeStart.X = X * Constants.TerrainGridSpacing;
TileEdgeStart.Y = 0;
TileEdgeFinish.X = X * Constants.TerrainGridSpacing;
TileEdgeFinish.Y = Map.Terrain.TileSize.Y * Constants.TerrainGridSpacing;
IntersectX = MathUtil.GetLinesIntersectBetween(StartXY, FinishXY, TileEdgeStart, TileEdgeFinish);
if ( IntersectX.Exists )
{
Horizontal = IntersectX.Pos;
vertex.X = Horizontal.X;
vertex.Y = (int)(Map.GetTerrainHeight(Horizontal));
vertex.Z = Convert.ToInt32(- Horizontal.Y);
GL.Vertex3(vertex.X, vertex.Y, Convert.ToInt32(- vertex.Z));
}
}
}
Horizontal = FinishXY;
vertex.X = Horizontal.X;
vertex.Y = (int)(Map.GetTerrainHeight(Horizontal));
vertex.Z = Convert.ToInt32(- Horizontal.Y);
GL.Vertex3(vertex.X, vertex.Y, Convert.ToInt32(- vertex.Z));
GL.End();
}
public abstract void TileChanged(XYInt Num);