public sXYZ_int LNDPos_From_MapPos(sXY_int Horizontal)
{
sXYZ_int Result = new sXYZ_int();
Result.X = Horizontal.X - (int)(Terrain.TileSize.X * App.TerrainGridSpacing / 2.0D);
Result.Z = ((int)(Terrain.TileSize.Y * App.TerrainGridSpacing / 2.0D)) - Horizontal.Y;
Result.Y = (int)(GetTerrainHeight(Horizontal));
return Result;
}
public clsMap(sXY_int TileSize)
{
frmMainLink = new ConnectedListLink<clsMap, frmMain>(this);
Gateways = new ConnectedList<clsGateway, clsMap>(this);
Initialize();
TerrainBlank(TileSize);
TileType_Reset();
}
public void SideVChanged(sXY_int Num)
{
if ( Num.X > 0 )
{
TileChanged(new sXY_int(Num.X - 1, Num.Y));
}
if ( Num.X < Map.Terrain.TileSize.X )
{
TileChanged(Num);
}
}
public void SideHChanged(sXY_int Num)
{
if ( Num.Y > 0 )
{
TileChanged(new sXY_int(Num.X, Num.Y - 1));
}
if ( Num.Y < Map.Terrain.TileSize.Y )
{
TileChanged(Num);
}
}
public static sIntersectPos GetLinesIntersectBetween(sXY_int A1, sXY_int A2, sXY_int B1, sXY_int B2)
{
sIntersectPos 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)
{
sXY_int PosA = new sXY_int();
sXY_int PosB = new sXY_int();
int A = 0;
int Altitude = Unit.Pos.Altitude - ViewInfo.ViewPos.Y;
GetFootprintTileRangeClamped(Unit.Pos.Horizontal, Unit.Type.get_GetFootprintSelected(Unit.Rotation), PosA, PosB);
A = PosA.Y;
PosA.X = (int)((PosA.X + 0.125D) * App.TerrainGridSpacing - ViewInfo.ViewPos.X);
PosA.Y = (int)((PosB.Y + 0.875D) * - App.TerrainGridSpacing - ViewInfo.ViewPos.Z);
PosB.X = (int)((PosB.X + 0.875D) * App.TerrainGridSpacing - ViewInfo.ViewPos.X);
PosB.Y = (int)((A + 0.125D) * - App.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)));
}
private void OpenGL_KeyDown(object sender, PreviewKeyDownEventArgs e)
{
clsMap Map = MainMap;
if ( Map == null )
{
return;
}
Matrix3DMath.Matrix3D matrixA = new Matrix3DMath.Matrix3D();
clsViewInfo.clsMouseOver.clsOverTerrain MouseOverTerrain = Map.ViewInfo.GetMouseOverTerrain();
App.IsViewKeyDown.Keys[(int)e.KeyCode] = true;
foreach ( Option<KeyboardControl> control in KeyboardManager.OptionsKeyboardControls.Options )
{
((KeyboardControl)(KeyboardManager.KeyboardProfile.get_Value(control))).KeysChanged(App.IsViewKeyDown);
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.Undo) )
{
string Message = "";
if ( Map.UndoPosition > 0 )
{
Message = "Undid: " + Map.Undos[Map.UndoPosition - 1].Name;
clsMap.clsMessage MapMessage = new clsMap.clsMessage();
MapMessage.Text = Message;
Map.Messages.Add(MapMessage);
Map.UndoPerform();
DrawViewLater();
}
else
{
Message = "Nothing to undo";
}
DisplayUndoMessage(Message);
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.Redo) )
{
string Message = "";
if ( Map.UndoPosition < Map.Undos.Count )
{
Message = "Redid: " + Map.Undos[Map.UndoPosition].Name;
clsMap.clsMessage MapMessage = new clsMap.clsMessage();
MapMessage.Text = Message;
Map.Messages.Add(MapMessage);
Map.RedoPerform();
DrawViewLater();
}
else
{
Message = "Nothing to redo";
}
DisplayUndoMessage(Message);
}
if ( App.IsViewKeyDown.Keys[(int)Keys.ControlKey] )
{
if ( e.KeyCode == Keys.D1 )
{
App.VisionRadius_2E = 6;
}
else if ( e.KeyCode == Keys.D2 )
{
App.VisionRadius_2E = 7;
}
else if ( e.KeyCode == Keys.D3 )
{
App.VisionRadius_2E = 8;
}
else if ( e.KeyCode == Keys.D4 )
{
App.VisionRadius_2E = 9;
}
else if ( e.KeyCode == Keys.D5 )
{
App.VisionRadius_2E = 10;
}
else if ( e.KeyCode == Keys.D6 )
{
App.VisionRadius_2E = 11;
}
else if ( e.KeyCode == Keys.D7 )
{
App.VisionRadius_2E = 12;
}
else if ( e.KeyCode == Keys.D8 )
{
App.VisionRadius_2E = 13;
}
else if ( e.KeyCode == Keys.D9 )
{
App.VisionRadius_2E = 14;
}
else if ( e.KeyCode == Keys.D0 )
{
App.VisionRadius_2E = 15;
}
App.VisionRadius_2E_Changed();
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.ViewMoveType) )
{
if ( App.ViewMoveType == App.enumView_Move_Type.Free )
{
App.ViewMoveType = App.enumView_Move_Type.RTS;
}
else if ( App.ViewMoveType == App.enumView_Move_Type.RTS )
{
App.ViewMoveType = App.enumView_Move_Type.Free;
}
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.ViewRotateType) )
{
App.RTSOrbit = !App.RTSOrbit;
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.ViewReset) )
{
Map.ViewInfo.FOV_Multiplier_Set(SettingsManager.Settings.FOVDefault);
if ( App.ViewMoveType == App.enumView_Move_Type.Free )
{
Matrix3DMath.MatrixSetToXAngle(matrixA, Math.Atan(2.0D));
Map.ViewInfo.ViewAngleSet_Rotate(matrixA);
}
else if ( App.ViewMoveType == App.enumView_Move_Type.RTS )
{
Matrix3DMath.MatrixSetToXAngle(matrixA, Math.Atan(2.0D));
Map.ViewInfo.ViewAngleSet_Rotate(matrixA);
}
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.ViewTextures) )
{
App.Draw_TileTextures = !App.Draw_TileTextures;
DrawViewLater();
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.ViewWireframe) )
{
App.Draw_TileWireframe = !App.Draw_TileWireframe;
DrawViewLater();
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.ViewUnits) )
{
App.Draw_Units = !App.Draw_Units;
int X = 0;
int Y = 0;
sXY_int SectorNum = new sXY_int();
clsMap.clsUnit Unit = default(clsMap.clsUnit);
clsMap.clsUnitSectorConnection Connection = default(clsMap.clsUnitSectorConnection);
for ( Y = 0; Y <= Map.SectorCount.Y - 1; Y++ )
{
for ( X = 0; X <= Map.SectorCount.X - 1; X++ )
{
foreach ( clsMap.clsUnitSectorConnection tempLoopVar_Connection in Map.Sectors[X, Y].Units )
{
Connection = tempLoopVar_Connection;
Unit = Connection.Unit;
if ( Unit.Type.Type == clsUnitType.enumType.PlayerStructure )
{
if ( ((clsStructureType)Unit.Type).StructureBasePlate != null )
{
SectorNum.X = X;
SectorNum.Y = Y;
Map.SectorGraphicsChanges.Changed(SectorNum);
break;
}
}
}
}
}
Map.Update();
DrawViewLater();
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.ViewScriptMarkers) )
{
App.Draw_ScriptMarkers = !App.Draw_ScriptMarkers;
DrawViewLater();
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.ViewLighting) )
{
if ( App.Draw_Lighting == App.enumDrawLighting.Off )
{
App.Draw_Lighting = App.enumDrawLighting.Half;
}
else if ( App.Draw_Lighting == App.enumDrawLighting.Half )
{
App.Draw_Lighting = App.enumDrawLighting.Normal;
}
else if ( App.Draw_Lighting == App.enumDrawLighting.Normal )
{
App.Draw_Lighting = App.enumDrawLighting.Off;
}
DrawViewLater();
}
if ( modTools.Tool == modTools.Tools.TextureBrush )
{
if ( MouseOverTerrain != null )
{
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.Clockwise) )
{
Map.ViewInfo.Apply_Texture_Clockwise();
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.CounterClockwise) )
{
Map.ViewInfo.Apply_Texture_CounterClockwise();
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.TextureFlip) )
{
Map.ViewInfo.Apply_Texture_FlipX();
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.TriFlip) )
{
Map.ViewInfo.Apply_Tri_Flip();
}
}
}
if ( modTools.Tool == modTools.Tools.ObjectSelect )
{
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.UnitDelete) )
{
if ( Map.SelectedUnits.Count > 0 )
{
clsMap.clsUnit Unit = default(clsMap.clsUnit);
foreach ( clsMap.clsUnit tempLoopVar_Unit in Map.SelectedUnits.GetItemsAsSimpleList() )
{
Unit = tempLoopVar_Unit;
Map.UnitRemoveStoreChange(Unit.MapLink.ArrayPosition);
}
Program.frmMainInstance.SelectedObject_Changed();
Map.UndoStepCreate("Object Deleted");
Map.Update();
Map.MinimapMakeLater();
DrawViewLater();
}
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.UnitMove) )
{
if ( MouseOverTerrain != null )
{
if ( Map.SelectedUnits.Count > 0 )
{
Position.XY_dbl Centre = App.CalcUnitsCentrePos(Map.SelectedUnits.GetItemsAsSimpleList());
sXY_int Offset = new sXY_int();
Offset.X = ((int)(Math.Round(Convert.ToDouble((MouseOverTerrain.Pos.Horizontal.X - Centre.X) / App.TerrainGridSpacing)))) *
App.TerrainGridSpacing;
Offset.Y = ((int)(Math.Round(Convert.ToDouble((MouseOverTerrain.Pos.Horizontal.Y - Centre.Y) / App.TerrainGridSpacing)))) *
App.TerrainGridSpacing;
clsMap.clsObjectPosOffset ObjectPosOffset = new clsMap.clsObjectPosOffset();
ObjectPosOffset.Map = Map;
ObjectPosOffset.Offset = Offset;
Map.SelectedUnitsAction(ObjectPosOffset);
Map.UndoStepCreate("Objects Moved");
Map.Update();
Map.MinimapMakeLater();
Program.frmMainInstance.SelectedObject_Changed();
DrawViewLater();
}
}
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.Clockwise) )
{
clsMap.clsObjectRotationOffset ObjectRotationOffset = new clsMap.clsObjectRotationOffset();
ObjectRotationOffset.Map = Map;
ObjectRotationOffset.Offset = -90;
Map.SelectedUnitsAction(ObjectRotationOffset);
Map.Update();
Program.frmMainInstance.SelectedObject_Changed();
Map.UndoStepCreate("Object Rotated");
DrawViewLater();
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.CounterClockwise) )
{
clsMap.clsObjectRotationOffset ObjectRotationOffset = new clsMap.clsObjectRotationOffset();
ObjectRotationOffset.Map = Map;
ObjectRotationOffset.Offset = 90;
Map.SelectedUnitsAction(ObjectRotationOffset);
Map.Update();
Program.frmMainInstance.SelectedObject_Changed();
Map.UndoStepCreate("Object Rotated");
DrawViewLater();
}
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.Deselect) )
{
modTools.Tool = modTools.Tools.ObjectSelect;
DrawViewLater();
}
if ( KeyboardManager.KeyboardProfile.Active(KeyboardManager.PreviousTool) )
{
modTools.Tool = modTools.PreviousTool;
DrawViewLater();
}
}
public int GetVertexAltitude(sXY_int VertexNum)
{
return Terrain.Vertices[VertexNum.X, VertexNum.Y].Height * HeightMultiplier;
}
public clsMap(clsMap MapToCopy, sXY_int Offset, sXY_int Area)
{
frmMainLink = new ConnectedListLink<clsMap, frmMain>(this);
Gateways = new ConnectedList<clsGateway, clsMap>(this);
int EndX = 0;
int EndY = 0;
int X = 0;
int Y = 0;
Initialize();
//make some map data for selection
EndX = Math.Min(MapToCopy.Terrain.TileSize.X - Offset.X, Area.X);
EndY = Math.Min(MapToCopy.Terrain.TileSize.Y - Offset.Y, Area.Y);
Terrain = new clsTerrain(Area);
for ( Y = 0; Y <= Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= Terrain.TileSize.X - 1; X++ )
{
Terrain.Tiles[X, Y].Texture.TextureNum = -1;
}
}
for ( Y = 0; Y <= EndY; Y++ )
{
for ( X = 0; X <= EndX; X++ )
{
Terrain.Vertices[X, Y].Height = MapToCopy.Terrain.Vertices[Offset.X + X, Offset.Y + Y].Height;
Terrain.Vertices[X, Y].Terrain = MapToCopy.Terrain.Vertices[Offset.X + X, Offset.Y + Y].Terrain;
}
}
for ( Y = 0; Y <= EndY - 1; Y++ )
{
for ( X = 0; X <= EndX - 1; X++ )
{
Terrain.Tiles[X, Y].Copy(MapToCopy.Terrain.Tiles[Offset.X + X, Offset.Y + Y]);
}
}
for ( Y = 0; Y <= EndY; Y++ )
{
for ( X = 0; X <= EndX - 1; X++ )
{
Terrain.SideH[X, Y].Road = MapToCopy.Terrain.SideH[Offset.X + X, Offset.Y + Y].Road;
}
}
for ( Y = 0; Y <= EndY - 1; Y++ )
{
for ( X = 0; X <= EndX; X++ )
{
Terrain.SideV[X, Y].Road = MapToCopy.Terrain.SideV[Offset.X + X, Offset.Y + Y].Road;
}
}
SectorCount.X = (int)(Math.Ceiling((double)(Area.X / Constants.SectorTileSize)));
SectorCount.Y = (int)(Math.Ceiling((double)(Area.Y / Constants.SectorTileSize)));
Sectors = new clsSector[SectorCount.X, SectorCount.Y];
for ( Y = 0; Y <= SectorCount.Y - 1; Y++ )
{
for ( X = 0; X <= SectorCount.X - 1; X++ )
{
Sectors[X, Y] = new clsSector(new sXY_int(X, Y));
}
}
sXY_int PosDif = new sXY_int();
clsUnitAdd NewUnitAdd = new clsUnitAdd();
NewUnitAdd.Map = this;
clsUnit NewUnit = default(clsUnit);
clsGateway Gateway = default(clsGateway);
foreach ( clsGateway tempLoopVar_Gateway in MapToCopy.Gateways )
{
Gateway = tempLoopVar_Gateway;
GatewayCreate(new sXY_int(Gateway.PosA.X - Offset.X, Gateway.PosA.Y - Offset.Y),
new sXY_int(Gateway.PosB.X - Offset.X, Gateway.PosB.Y - Offset.Y));
}
PosDif.X = - Offset.X * App.TerrainGridSpacing;
PosDif.Y = - Offset.Y * App.TerrainGridSpacing;
clsUnit Unit = default(clsUnit);
sXY_int NewPos = new sXY_int();
foreach ( clsUnit tempLoopVar_Unit in MapToCopy.Units )
{
Unit = tempLoopVar_Unit;
NewPos = Unit.Pos.Horizontal + PosDif;
if ( PosIsOnMap(NewPos) )
{
NewUnit = new clsUnit(Unit, this);
NewUnit.Pos.Horizontal = NewPos;
NewUnitAdd.NewUnit = NewUnit;
NewUnitAdd.Label = Unit.Label;
NewUnitAdd.Perform();
}
}
}
public App.sWorldPos GetTileOffsetRotatedWorldPos(sXY_int Tile, sXY_int TileOffsetToRotate)
{
App.sWorldPos Result = new App.sWorldPos();
sXY_int RotatedOffset = new sXY_int();
RotatedOffset = TileUtil.GetTileRotatedOffset(Terrain.Tiles[Tile.X, Tile.Y].Texture.Orientation, TileOffsetToRotate);
Result.Horizontal.X = Tile.X * App.TerrainGridSpacing + RotatedOffset.X;
Result.Horizontal.Y = Tile.Y * App.TerrainGridSpacing + RotatedOffset.Y;
Result.Altitude = (int)(GetTerrainHeight(Result.Horizontal));
return Result;
}
public double GetTerrainHeight(sXY_int Horizontal)
{
int X1 = 0;
int X2 = 0;
int Y1 = 0;
int Y2 = 0;
double InTileX = 0;
double InTileZ = 0;
int XG = 0;
int YG = 0;
double GradientX = 0;
double GradientY = 0;
double Offset = 0;
double RatioX = 0;
double RatioY = 0;
XG = Conversion.Int(Horizontal.X / App.TerrainGridSpacing);
YG = (int)(Conversion.Int(Horizontal.Y / App.TerrainGridSpacing));
InTileX = MathUtil.Clamp_dbl(Horizontal.X / App.TerrainGridSpacing - XG, 0.0D, 1.0D);
InTileZ = MathUtil.Clamp_dbl(Horizontal.Y / App.TerrainGridSpacing - YG, 0.0D, 1.0D);
X1 = MathUtil.Clamp_int(XG, 0, Terrain.TileSize.X - 1);
Y1 = MathUtil.Clamp_int(YG, 0, Terrain.TileSize.Y - 1);
X2 = MathUtil.Clamp_int(XG + 1, 0, Terrain.TileSize.X);
Y2 = MathUtil.Clamp_int(YG + 1, 0, Terrain.TileSize.Y);
if ( Terrain.Tiles[X1, Y1].Tri )
{
if ( InTileZ <= 1.0D - InTileX )
{
Offset = Terrain.Vertices[X1, Y1].Height;
GradientX = Convert.ToDouble(Terrain.Vertices[X2, Y1].Height - Offset);
GradientY = Convert.ToDouble(Terrain.Vertices[X1, Y2].Height - Offset);
RatioX = InTileX;
RatioY = InTileZ;
}
else
{
Offset = Terrain.Vertices[X2, Y2].Height;
GradientX = Convert.ToDouble(Terrain.Vertices[X1, Y2].Height - Offset);
GradientY = Convert.ToDouble(Terrain.Vertices[X2, Y1].Height - Offset);
RatioX = 1.0D - InTileX;
RatioY = 1.0D - InTileZ;
}
}
else
{
if ( InTileZ <= InTileX )
{
Offset = Terrain.Vertices[X2, Y1].Height;
GradientX = Convert.ToDouble(Terrain.Vertices[X1, Y1].Height - Offset);
GradientY = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height - Offset);
RatioX = 1.0D - InTileX;
RatioY = InTileZ;
}
else
{
Offset = Terrain.Vertices[X1, Y2].Height;
GradientX = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height - Offset);
GradientY = Convert.ToDouble(Terrain.Vertices[X1, Y1].Height - Offset);
RatioX = InTileX;
RatioY = 1.0D - InTileZ;
}
}
return (Offset + GradientX * RatioX + GradientY * RatioY) * HeightMultiplier;
}
public clsTerrain(sXY_int 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];
int X = 0;
int 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 clsSector(sXY_int NewPos)
{
Units = new ConnectedList<clsUnitSectorConnection, clsSector>(this);
Pos = NewPos;
}
public clsMinimapTexture(sXY_int Size)
{
this.Size = Size;
InlinePixels = new sRGBA_sng[Size.X * Size.Y];
}
protected void TerrainBlank(sXY_int TileSize)
{
int X = 0;
int Y = 0;
Terrain = new clsTerrain(TileSize);
SectorCount.X = (int)(Math.Ceiling((double)(Terrain.TileSize.X / Constants.SectorTileSize)));
SectorCount.Y = (int)(Math.Ceiling((double)(Terrain.TileSize.Y / Constants.SectorTileSize)));
Sectors = new clsSector[SectorCount.X, SectorCount.Y];
for ( Y = 0; Y <= SectorCount.Y - 1; Y++ )
{
for ( X = 0; X <= SectorCount.X - 1; X++ )
{
Sectors[X, Y] = new clsSector(new sXY_int(X, Y));
}
}
}
public sXY_int GetPosVertexNum(sXY_int Horizontal)
{
sXY_int Result = new sXY_int();
Result.X = (int)(Math.Round((double)(Horizontal.X / App.TerrainGridSpacing)));
Result.Y = (int)(Math.Round((double)(Horizontal.Y / App.TerrainGridSpacing)));
return Result;
}
public sXY_int GetSectorNumClamped(sXY_int SectorNum)
{
sXY_int Result = new sXY_int();
Result.X = MathUtil.Clamp_int(SectorNum.X, 0, SectorCount.X - 1);
Result.Y = MathUtil.Clamp_int(SectorNum.Y, 0, SectorCount.Y - 1);
return Result;
}
public void DrawTileOrientation(sXY_int Tile)
{
TileOrientation TileOrientation;
sXY_int UnrotatedPos = new sXY_int();
App.sWorldPos Vertex0 = new App.sWorldPos();
App.sWorldPos Vertex1 = new App.sWorldPos();
App.sWorldPos Vertex2 = new App.sWorldPos();
TileOrientation = Terrain.Tiles[Tile.X, Tile.Y].Texture.Orientation;
UnrotatedPos.X = 32;
UnrotatedPos.Y = 32;
Vertex0 = GetTileOffsetRotatedWorldPos(Tile, UnrotatedPos);
UnrotatedPos.X = 64;
UnrotatedPos.Y = 32;
Vertex1 = GetTileOffsetRotatedWorldPos(Tile, UnrotatedPos);
UnrotatedPos.X = 64;
UnrotatedPos.Y = 64;
Vertex2 = GetTileOffsetRotatedWorldPos(Tile, UnrotatedPos);
GL.Vertex3(Vertex0.Horizontal.X, Vertex0.Altitude, Vertex0.Horizontal.Y);
GL.Vertex3(Vertex1.Horizontal.X, Vertex1.Altitude, Vertex1.Horizontal.Y);
GL.Vertex3(Vertex2.Horizontal.X, Vertex2.Altitude, Vertex2.Horizontal.Y);
}
public double GetTerrainSlopeAngle(sXY_int Horizontal)
{
int X1 = 0;
int X2 = 0;
int Y1 = 0;
int Y2 = 0;
double InTileX = 0;
double InTileZ = 0;
int XG = 0;
int YG = 0;
double GradientX = 0;
double GradientY = 0;
double Offset = 0;
Position.XYZ_dbl XYZ_dbl = default(Position.XYZ_dbl);
Position.XYZ_dbl XYZ_dbl2 = default(Position.XYZ_dbl);
Position.XYZ_dbl XYZ_dbl3 = default(Position.XYZ_dbl);
Angles.AnglePY AnglePY = default(Angles.AnglePY);
XG = Conversion.Int(Horizontal.X / App.TerrainGridSpacing);
YG = (int)(Conversion.Int(Horizontal.Y / App.TerrainGridSpacing));
InTileX = MathUtil.Clamp_dbl(Horizontal.X / App.TerrainGridSpacing - XG, 0.0D, 1.0D);
InTileZ = MathUtil.Clamp_dbl(Horizontal.Y / App.TerrainGridSpacing - YG, 0.0D, 1.0D);
X1 = MathUtil.Clamp_int(XG, 0, Terrain.TileSize.X - 1);
Y1 = MathUtil.Clamp_int(YG, 0, Terrain.TileSize.Y - 1);
X2 = MathUtil.Clamp_int(XG + 1, 0, Terrain.TileSize.X);
Y2 = MathUtil.Clamp_int(YG + 1, 0, Terrain.TileSize.Y);
if ( Terrain.Tiles[X1, Y1].Tri )
{
if ( InTileZ <= 1.0D - InTileX )
{
Offset = Terrain.Vertices[X1, Y1].Height;
GradientX = Convert.ToDouble(Terrain.Vertices[X2, Y1].Height - Offset);
GradientY = Convert.ToDouble(Terrain.Vertices[X1, Y2].Height - Offset);
}
else
{
Offset = Terrain.Vertices[X2, Y2].Height;
GradientX = Convert.ToDouble(Terrain.Vertices[X1, Y2].Height - Offset);
GradientY = Convert.ToDouble(Terrain.Vertices[X2, Y1].Height - Offset);
}
}
else
{
if ( InTileZ <= InTileX )
{
Offset = Terrain.Vertices[X2, Y1].Height;
GradientX = Convert.ToDouble(Terrain.Vertices[X1, Y1].Height - Offset);
GradientY = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height - Offset);
}
else
{
Offset = Terrain.Vertices[X1, Y2].Height;
GradientX = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height - Offset);
GradientY = Convert.ToDouble(Terrain.Vertices[X1, Y1].Height - Offset);
}
}
XYZ_dbl.X = App.TerrainGridSpacing;
XYZ_dbl.Y = GradientX * HeightMultiplier;
XYZ_dbl.Z = 0.0D;
XYZ_dbl2.X = 0.0D;
XYZ_dbl2.Y = GradientY * HeightMultiplier;
XYZ_dbl2.Z = App.TerrainGridSpacing;
Matrix3DMath.VectorCrossProduct(XYZ_dbl, XYZ_dbl2, ref XYZ_dbl3);
if ( XYZ_dbl3.X != 0.0D | XYZ_dbl3.Z != 0.0D )
{
Matrix3DMath.VectorToPY(XYZ_dbl3, ref AnglePY);
return MathUtil.RadOf90Deg - Math.Abs(AnglePY.Pitch);
}
else
{
return 0.0D;
}
}
public clsGateway GatewayCreate(sXY_int PosA, sXY_int PosB)
{
if ( PosA.X >= 0 & PosA.X < Terrain.TileSize.X &
PosA.Y >= 0 & PosA.Y < Terrain.TileSize.Y &
PosB.X >= 0 & PosB.X < Terrain.TileSize.X &
PosB.Y >= 0 & PosB.Y < Terrain.TileSize.Y ) //is on map
{
if ( PosA.X == PosB.X | PosA.Y == PosB.Y ) //is straight
{
clsGateway Gateway = new clsGateway();
Gateway.PosA = PosA;
Gateway.PosB = PosB;
Gateway.MapLink.Connect(Gateways);
return Gateway;
}
else
{
return null;
}
}
else
{
return null;
}
}
public bool GetTerrainTri(sXY_int Horizontal)
{
int X1 = 0;
int Y1 = 0;
double InTileX = 0;
double InTileZ = 0;
int XG = 0;
int YG = 0;
XG = (int)(Conversion.Int(Horizontal.X / App.TerrainGridSpacing));
YG = Conversion.Int(Horizontal.Y / App.TerrainGridSpacing);
InTileX = MathUtil.Clamp_dbl(Horizontal.X / App.TerrainGridSpacing - XG, 0.0D, 1.0D);
InTileZ = MathUtil.Clamp_dbl(Horizontal.Y / App.TerrainGridSpacing - YG, 0.0D, 1.0D);
X1 = MathUtil.Clamp_int(XG, 0, Terrain.TileSize.X - 1);
Y1 = MathUtil.Clamp_int(YG, 0, Terrain.TileSize.Y - 1);
if ( Terrain.Tiles[X1, Y1].Tri )
{
if ( InTileZ <= 1.0D - InTileX )
{
return false;
}
else
{
return true;
}
}
else
{
if ( InTileZ <= InTileX )
{
return true;
}
else
{
return false;
}
}
}
public clsGateway GatewayCreateStoreChange(sXY_int PosA, sXY_int PosB)
{
clsGateway Gateway = default(clsGateway);
Gateway = GatewayCreate(PosA, PosB);
clsGatewayChange GatewayChange = new clsGatewayChange();
GatewayChange.Type = clsGatewayChange.enumType.Added;
GatewayChange.Gateway = Gateway;
GatewayChanges.Add(GatewayChange);
return Gateway;
}
public sXY_int GetTileSectorNum(sXY_int Tile)
{
sXY_int Result = new sXY_int();
Result.X = Conversion.Int(Tile.X / Constants.SectorTileSize);
Result.Y = Conversion.Int(Tile.Y / Constants.SectorTileSize);
return Result;
}
public void GetFootprintTileRange(sXY_int Horizontal, sXY_int Footprint, sXY_int ResultStart, sXY_int ResultFinish)
{
int Remainder = 0;
sXY_int Centre = GetPosTileNum(Horizontal);
int Half = 0;
Half = Math.DivRem(Footprint.X, 2, out Remainder);
ResultStart.X = Centre.X - Half;
ResultFinish.X = ResultStart.X + Footprint.X - 1;
Half = Math.DivRem(Footprint.Y, 2, out Remainder);
ResultStart.Y = Centre.Y - Half;
ResultFinish.Y = ResultStart.Y + Footprint.Y - 1;
}
public void GetTileSectorRange(sXY_int StartTile, sXY_int FinishTile, ref sXY_int ResultSectorStart,
ref sXY_int ResultSectorFinish)
{
ResultSectorStart = GetTileSectorNum(StartTile);
ResultSectorFinish = GetTileSectorNum(FinishTile);
ResultSectorStart.X = MathUtil.Clamp_int(ResultSectorStart.X, 0, SectorCount.X - 1);
ResultSectorStart.Y = MathUtil.Clamp_int(ResultSectorStart.Y, 0, SectorCount.Y - 1);
ResultSectorFinish.X = MathUtil.Clamp_int(ResultSectorFinish.X, 0, SectorCount.X - 1);
ResultSectorFinish.Y = MathUtil.Clamp_int(ResultSectorFinish.Y, 0, SectorCount.Y - 1);
}
public void GetFootprintTileRangeClamped(sXY_int Horizontal, sXY_int Footprint, sXY_int ResultStart, sXY_int ResultFinish)
{
int Remainder = 0;
sXY_int Centre = GetPosTileNum(Horizontal);
int Half = 0;
Half = Math.DivRem(Footprint.X, 2, out Remainder);
ResultStart.X = MathUtil.Clamp_int(Centre.X - Half, 0, Terrain.TileSize.X - 1);
ResultFinish.X = MathUtil.Clamp_int(ResultStart.X + Footprint.X - 1, 0, Terrain.TileSize.X - 1);
Half = Math.DivRem(Footprint.Y, 2, out Remainder);
ResultStart.Y = MathUtil.Clamp_int(Centre.Y - Half, 0, Terrain.TileSize.Y - 1);
ResultFinish.Y = MathUtil.Clamp_int(ResultStart.Y + Footprint.Y - 1, 0, Terrain.TileSize.Y - 1);
}
public void MapInsert(clsMap MapToInsert, sXY_int Offset, sXY_int Area, bool InsertHeights, bool InsertTextures, bool InsertUnits,
bool DeleteUnits, bool InsertGateways, bool DeleteGateways)
{
sXY_int Finish = new sXY_int();
int X = 0;
int Y = 0;
sXY_int SectorStart = new sXY_int();
sXY_int SectorFinish = new sXY_int();
sXY_int AreaAdjusted = new sXY_int();
sXY_int SectorNum = new sXY_int();
Finish.X = Math.Min(Offset.X + Math.Min(Area.X, MapToInsert.Terrain.TileSize.X), Terrain.TileSize.X);
Finish.Y = Math.Min(Offset.Y + Math.Min(Area.Y, MapToInsert.Terrain.TileSize.Y), Terrain.TileSize.Y);
AreaAdjusted.X = Finish.X - Offset.X;
AreaAdjusted.Y = Finish.Y - Offset.Y;
GetTileSectorRange(new sXY_int(Offset.X - 1, Offset.Y - 1), Finish, ref SectorStart, ref SectorFinish);
for ( Y = SectorStart.Y; Y <= SectorFinish.Y; Y++ )
{
SectorNum.Y = Y;
for ( X = SectorStart.X; X <= SectorFinish.X; X++ )
{
SectorNum.X = X;
SectorGraphicsChanges.Changed(SectorNum);
SectorUnitHeightsChanges.Changed(SectorNum);
SectorTerrainUndoChanges.Changed(SectorNum);
}
}
if ( InsertHeights )
{
for ( Y = 0; Y <= AreaAdjusted.Y; Y++ )
{
for ( X = 0; X <= AreaAdjusted.X; X++ )
{
Terrain.Vertices[Offset.X + X, Offset.Y + Y].Height = MapToInsert.Terrain.Vertices[X, Y].Height;
}
}
for ( Y = 0; Y <= AreaAdjusted.Y - 1; Y++ )
{
for ( X = 0; X <= AreaAdjusted.X - 1; X++ )
{
Terrain.Tiles[Offset.X + X, Offset.Y + Y].Tri = MapToInsert.Terrain.Tiles[X, Y].Tri;
}
}
}
if ( InsertTextures )
{
for ( Y = 0; Y <= AreaAdjusted.Y; Y++ )
{
for ( X = 0; X <= AreaAdjusted.X; X++ )
{
Terrain.Vertices[Offset.X + X, Offset.Y + Y].Terrain = MapToInsert.Terrain.Vertices[X, Y].Terrain;
}
}
bool TriDirection = default(bool);
for ( Y = 0; Y <= AreaAdjusted.Y - 1; Y++ )
{
for ( X = 0; X <= AreaAdjusted.X - 1; X++ )
{
TriDirection = Terrain.Tiles[Offset.X + X, Offset.Y + Y].Tri;
Terrain.Tiles[Offset.X + X, Offset.Y + Y].Copy(MapToInsert.Terrain.Tiles[X, Y]);
Terrain.Tiles[Offset.X + X, Offset.Y + Y].Tri = TriDirection;
}
}
for ( Y = 0; Y <= AreaAdjusted.Y; Y++ )
{
for ( X = 0; X <= AreaAdjusted.X - 1; X++ )
{
Terrain.SideH[Offset.X + X, Offset.Y + Y].Road = MapToInsert.Terrain.SideH[X, Y].Road;
}
}
for ( Y = 0; Y <= AreaAdjusted.Y - 1; Y++ )
{
for ( X = 0; X <= AreaAdjusted.X; X++ )
{
Terrain.SideV[Offset.X + X, Offset.Y + Y].Road = MapToInsert.Terrain.SideV[X, Y].Road;
}
}
}
sXY_int LastTile = new sXY_int();
LastTile = Finish;
LastTile.X--;
LastTile.Y--;
if ( DeleteGateways )
{
int A = 0;
A = 0;
while ( A < Gateways.Count )
{
if ( Gateways[A].PosA.IsInRange(Offset, LastTile) || Gateways[A].PosB.IsInRange(Offset, LastTile) )
{
GatewayRemoveStoreChange(A);
}
else
{
A++;
}
}
}
if ( InsertGateways )
{
sXY_int GateStart = new sXY_int();
sXY_int GateFinish = new sXY_int();
clsGateway Gateway = default(clsGateway);
foreach ( clsGateway tempLoopVar_Gateway in MapToInsert.Gateways )
{
Gateway = tempLoopVar_Gateway;
GateStart.X = Offset.X + Gateway.PosA.X;
GateStart.Y = Offset.Y + Gateway.PosA.Y;
GateFinish.X = Offset.X + Gateway.PosB.X;
GateFinish.Y = Offset.Y + Gateway.PosB.Y;
if ( GateStart.IsInRange(Offset, LastTile) || GateFinish.IsInRange(Offset, LastTile) )
{
GatewayCreateStoreChange(GateStart, GateFinish);
}
}
}
if ( DeleteUnits )
{
SimpleList<clsUnit> UnitsToDelete = new SimpleList<clsUnit>();
int UnitToDeleteCount = 0;
clsUnit Unit = default(clsUnit);
for ( Y = SectorStart.Y; Y <= SectorFinish.Y; Y++ )
{
for ( X = SectorStart.X; X <= SectorFinish.X; X++ )
{
clsUnitSectorConnection Connection = default(clsUnitSectorConnection);
foreach ( clsUnitSectorConnection tempLoopVar_Connection in Sectors[X, Y].Units )
{
Connection = tempLoopVar_Connection;
Unit = Connection.Unit;
if ( App.PosIsWithinTileArea(Unit.Pos.Horizontal, Offset, Finish) )
{
UnitsToDelete.Add(Unit);
}
}
}
}
foreach ( clsUnit tempLoopVar_Unit in UnitsToDelete )
{
Unit = tempLoopVar_Unit;
if ( Unit.MapLink.IsConnected ) //units may be in the list multiple times and already be deleted
{
UnitRemoveStoreChange(Unit.MapLink.ArrayPosition);
}
}
}
if ( InsertUnits )
{
sXY_int PosDif = new sXY_int();
clsUnit NewUnit = default(clsUnit);
clsUnit Unit = default(clsUnit);
sXY_int ZeroPos = new sXY_int(0, 0);
clsUnitAdd UnitAdd = new clsUnitAdd();
UnitAdd.Map = this;
UnitAdd.StoreChange = true;
PosDif.X = Offset.X * App.TerrainGridSpacing;
PosDif.Y = Offset.Y * App.TerrainGridSpacing;
foreach ( clsUnit tempLoopVar_Unit in MapToInsert.Units )
{
Unit = tempLoopVar_Unit;
if ( App.PosIsWithinTileArea(Unit.Pos.Horizontal, ZeroPos, AreaAdjusted) )
{
NewUnit = new clsUnit(Unit, this);
NewUnit.Pos.Horizontal.X += PosDif.X;
NewUnit.Pos.Horizontal.Y += PosDif.Y;
UnitAdd.NewUnit = NewUnit;
UnitAdd.Label = Unit.Label;
UnitAdd.Perform();
}
}
}
SectorsUpdateGraphics();
SectorsUpdateUnitHeights();
MinimapMakeLater();
}
public sXY_int GetPosSectorNum(sXY_int Horizontal)
{
sXY_int Result = new sXY_int();
Result = GetTileSectorNum(GetPosTileNum(Horizontal));
return Result;
}
private void SelectUnits(sXY_int VertexA, sXY_int VertexB)
{
clsMap Map = MainMap;
clsViewInfo.clsMouseOver.clsOverTerrain MouseOverTerrain = Map.ViewInfo.GetMouseOverTerrain();
sXY_int SectorNum = new sXY_int();
clsMap.clsUnit Unit = default(clsMap.clsUnit);
sXY_int SectorStart = new sXY_int();
sXY_int SectorFinish = new sXY_int();
sXY_int StartPos = new sXY_int();
sXY_int FinishPos = new sXY_int();
sXY_int StartVertex = new sXY_int();
sXY_int FinishVertex = new sXY_int();
if ( Math.Abs(VertexA.X - VertexB.X) <= 1 &&
Math.Abs(VertexA.Y - VertexB.Y) <= 1 &&
MouseOverTerrain != null )
{
if ( MouseOverTerrain.Units.Count > 0 )
{
if ( MouseOverTerrain.Units.Count == 1 )
{
Unit = MouseOverTerrain.Units[0];
if ( Unit.MapSelectedUnitLink.IsConnected )
{
Unit.MapDeselect();
}
else
{
Unit.MapSelect();
}
}
else
{
ListSelectBegin(false);
}
}
}
else
{
MathUtil.ReorderXY(VertexA, VertexB, StartVertex, FinishVertex);
StartPos.X = StartVertex.X * App.TerrainGridSpacing;
StartPos.Y = StartVertex.Y * App.TerrainGridSpacing;
FinishPos.X = FinishVertex.X * App.TerrainGridSpacing;
FinishPos.Y = FinishVertex.Y * App.TerrainGridSpacing;
SectorStart.X = Math.Min(Conversion.Int(StartVertex.X / Constants.SectorTileSize), Map.SectorCount.X - 1);
SectorStart.Y = Math.Min((int)(Conversion.Int(StartVertex.Y / Constants.SectorTileSize)), Map.SectorCount.Y - 1);
SectorFinish.X = Math.Min(Conversion.Int(FinishVertex.X / Constants.SectorTileSize), Map.SectorCount.X - 1);
SectorFinish.Y = Math.Min(Conversion.Int(FinishVertex.Y / Constants.SectorTileSize), Map.SectorCount.Y - 1);
for ( SectorNum.Y = SectorStart.Y; SectorNum.Y <= SectorFinish.Y; SectorNum.Y++ )
{
for ( SectorNum.X = SectorStart.X; SectorNum.X <= SectorFinish.X; SectorNum.X++ )
{
clsMap.clsUnitSectorConnection Connection = default(clsMap.clsUnitSectorConnection);
foreach ( clsMap.clsUnitSectorConnection tempLoopVar_Connection in Map.Sectors[SectorNum.X, SectorNum.Y].Units )
{
Connection = tempLoopVar_Connection;
Unit = Connection.Unit;
if ( Unit.Pos.Horizontal.X >= StartPos.X & Unit.Pos.Horizontal.Y >= StartPos.Y &
Unit.Pos.Horizontal.X <= FinishPos.X & Unit.Pos.Horizontal.Y <= FinishPos.Y )
{
if ( !Unit.MapSelectedUnitLink.IsConnected )
{
Unit.MapSelect();
}
}
}
}
}
}
Program.frmMainInstance.SelectedObject_Changed();
DrawViewLater();
}
public sXY_int GetPosTileNum(sXY_int Horizontal)
{
sXY_int Result = new sXY_int();
Result.X = (int)(Conversion.Int(Horizontal.X / App.TerrainGridSpacing));
Result.Y = Conversion.Int(Horizontal.Y / App.TerrainGridSpacing);
return Result;
}