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);