public TileOrientation GetRotated(TileOrientation Orientation) { TileOrientation ReturnResult = new TileOrientation(); ReturnResult.SwitchedAxes = SwitchedAxes ^ Orientation.SwitchedAxes; if ( Orientation.SwitchedAxes ) { if ( Orientation.ResultXFlip ) { ReturnResult.ResultXFlip = !ResultYFlip; } else { ReturnResult.ResultXFlip = ResultYFlip; } if ( Orientation.ResultYFlip ) { ReturnResult.ResultYFlip = !ResultXFlip; } else { ReturnResult.ResultYFlip = ResultXFlip; } } else { if ( Orientation.ResultXFlip ) { ReturnResult.ResultXFlip = !ResultXFlip; } else { ReturnResult.ResultXFlip = ResultXFlip; } if ( Orientation.ResultYFlip ) { ReturnResult.ResultYFlip = !ResultYFlip; } else { ReturnResult.ResultYFlip = ResultYFlip; } } return ReturnResult; }
public TileDirection GetRotated(TileOrientation Orientation) { var returnResult = new TileDirection(); if ( Orientation.SwitchedAxes ) { if ( Orientation.ResultXFlip ) { returnResult.X = (byte)(2 - Y); } else { returnResult.X = Y; } if ( Orientation.ResultYFlip ) { returnResult.Y = (byte)(2 - X); } else { returnResult.Y = X; } } else { if ( Orientation.ResultXFlip ) { returnResult.X = (byte)(2 - X); } else { returnResult.X = X; } if ( Orientation.ResultYFlip ) { returnResult.Y = (byte)(2 - Y); } else { returnResult.Y = Y; } } return returnResult; }
public static ArrayTileOrientation ToArrayTileOrientation(this TileOrientation orientation) { ArrayTileOrientation arrayOrientation; switch (orientation) { case TileOrientation.TiltLeft: case TileOrientation.TiltRight: case TileOrientation.Flipped: arrayOrientation = ArrayTileOrientation.TopDown; break; case TileOrientation.Straight: case TileOrientation.DoubleTiltLeft: case TileOrientation.DoubleTiltRight: default: arrayOrientation = ArrayTileOrientation.BottomUp; break; } return(arrayOrientation); }
/// <summary> /// Checks if a tile can placed on the GameBoard, based on the tiles orientation, /// and another tile next to which the new tile should be placed /// </summary> /// <param name="tile">The tile which should be placed</param> /// <param name="otherName">The name of the other tile.</param> /// <param name="otherFace">The face of the other tile at which the new tile should be placed.</param> /// <returns>True, if the new tile can be placed, false if not.</returns> public bool CanPlaceTileOnGameBoard(string tileName, string otherName, TileFace?tileFace, TileFace?otherFace, out TriominoTile placableTile) { placableTile = null; // if it's the first tile it can always be placed. if (this.NumbTilesOnBoard == 0) { placableTile = new TriominoTile(tileName, TileOrientation.Straight, new Point(this.maxGameBoardSize / 2, this.maxGameBoardSize / 2)); return(true); } // otherFace and otherName can only be null if it's the first tile if (otherFace == null || otherName == null || otherName == string.Empty) { return(false); } Point otherTileGridCoordinates = this.GetTileCoordsByName(otherName); Point possibleNewGridCoordinates = this.GetTileGridPositionFromOtherTilePositionAndFace(otherTileGridCoordinates, otherFace.Value); if (possibleNewGridCoordinates.Y == -1 || possibleNewGridCoordinates.X == -1) { return(false); } TileOrientation tileOrientation = GameBoard.GetTileOrienationFromOtherTileOrientationAndFaces(this.GetTileFromGrid(otherTileGridCoordinates).Orientation, otherFace.Value, tileFace.Value); TriominoTile tile = new TriominoTile(tileName, tileOrientation, possibleNewGridCoordinates); // If Tile values can be placed it will be returned if (this.CheckValueGridAtTileGridPosition(tile)) { placableTile = tile; return(true); } return(false); }
public Tile(TileType typeIn, int xIn, int yIn, int totalWidthIn, int totalHeightIn, Random rand, TileCollision collision, int decoration = -1) { tileType = typeIn; size.X = size.Y = 16; position = new Vector2(xIn * size.X, yIn * size.Y); render = true; decorationValue = decoration; tileOrientation = TileOrientation.Regular; totalHeight = totalHeightIn; totalWidth = totalWidthIn; tileCollision = collision; if (tileType == TileType.Dirt) { hitsRequired = 1; if (rand.Next(1, 25) == 5) { //damage = rand.Next(1, 3); // health = damage * 30; } } else if (tileType == TileType.Metal) hitsRequired = 5; }
public void Rotate(TileOrientation Orientation, Util.ObjectRotateMode 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(Unit); foreach (var tempLoopVar_Unit in Units) { Unit = tempLoopVar_Unit; Unit.Sectors.Clear(); if (ObjectRotateMode == Util.ObjectRotateMode.All) { Unit.Rotation = (MathUtil.AngleClamp(MathUtil.RadOf360Deg - TileUtil.GetRotatedAngle(Orientation, MathUtil.AngleClamp(MathUtil.RadOf360Deg - Unit.Rotation * MathUtil.RadOf1Deg))) / MathUtil.RadOf1Deg).ToInt(); if (Unit.Rotation < 0) { Unit.Rotation += 360; } } else if (ObjectRotateMode == ObjectRotateMode.Walls) { if (Unit.TypeBase.Type == UnitType.PlayerStructure) { if (((StructureTypeBase)Unit.TypeBase).StructureType == StructureType.Wall) { Unit.Rotation = (MathUtil.AngleClamp(MathUtil.RadOf360Deg - TileUtil.GetRotatedAngle(Orientation, MathUtil.AngleClamp(MathUtil.RadOf360Deg - Unit.Rotation * MathUtil.RadOf1Deg))) / MathUtil.RadOf1Deg) .ToInt(); 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(Gateway); 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(); } }
/// <summary> /// Performs tile placement. /// </summary> /// <param name="color">Color of the player making the move.</param> /// <param name="scheme">Scheme of the tile.</param> /// <param name="coords">Coordinates of the tile.</param> /// <param name="orientation">Orientation of the tile.</param> private void PlaceTile(PlayerColor color, TileScheme scheme, Coords coords, TileOrientation orientation) { // Place the tile TileRectangle newRectangle = new TileRectangle(); newRectangle.SetLayout(scheme, orientation); Canvas.SetLeft(newRectangle, coords.X * 100); Canvas.SetTop(newRectangle, coords.Y * 100); newRectangle.Coords = coords; TilesCanvas.Children.Add(newRectangle); PlacedTiles.Add(coords, newRectangle); // Remove empty tile and create new if (EmptyTiles.ContainsKey(coords)) { TilesCanvas.Children.Remove(EmptyTiles[coords]); EmptyTiles.Remove(coords); } foreach (var or in new TileOrienationEnumerator()) { var neigh = coords.GetNeighbouringCoords(or); if (!PlacedTiles.ContainsKey(neigh) && !EmptyTiles.ContainsKey(neigh)) { var emptyTile = new EmptyTileRectangle(neigh); emptyTile.MouseClick += EmptyTile_MouseClick; EmptyTiles.Add(neigh, emptyTile); Canvas.SetLeft(emptyTile, neigh.X * 100); Canvas.SetTop(emptyTile, neigh.Y * 100); emptyTile.Visibility = Visibility.Collapsed; TilesCanvas.Children.Add(emptyTile); } PassMoveBtn.IsEnabled = true; } CurrentCoords = coords; // If player is on move if (CurrentOnMove == PlayerColor) { // Activate the tile to be clicked on (placing follower) newRectangle.RegionMouseEventEnabled = true; newRectangle.RegionMouseClick += PlacedTile_RegionMouseClick; // Deactivate empty tiles foreach (var et in EmptyTiles.Values) { et.MouseEventEnabled = false; et.Visibility = Visibility.Collapsed; } // Activate the tiles with followers foreach (var c in PlacedFollowerPositions) { PlacedTiles[c].FollowerMouseEventEnabled = true; } } }
public void SetImageElementToGrid() { SlideDirection slideDirection = TempProfile.SlideDirection.Value; TileOrientation orientaition = TempProfile.TileOrientation.Value; TileOrigin origin = TempProfile.TileOrigin.Value; TileImageStretch tileImageStretch = TempProfile.TileImageStretch.Value; int numofRow = MainGrid.RowDefinitions.Count; int numofCol = MainGrid.ColumnDefinitions.Count; // スライド方向から自動で配置を決定する場合 if (TempProfile.UseDefaultTileOrigin.Value) { switch (slideDirection) { default: case SlideDirection.Left: orientaition = TileOrientation.Vertical; origin = TileOrigin.TopLeft; break; case SlideDirection.Top: orientaition = TileOrientation.Horizontal; origin = TileOrigin.TopLeft; break; case SlideDirection.Right: orientaition = TileOrientation.Vertical; origin = TileOrigin.TopRight; break; case SlideDirection.Bottom: orientaition = TileOrientation.Horizontal; origin = TileOrigin.BottomRight; break; } } Action <int, int> setToGrid = (i, j) => { // Image Image image = new Image(); if (tileImageStretch == TileImageStretch.UniformToFill) { image.Stretch = Stretch.UniformToFill; image.HorizontalAlignment = HorizontalAlignment.Center; image.VerticalAlignment = VerticalAlignment.Center; } else if (tileImageStretch == TileImageStretch.Fill) { image.Stretch = Stretch.Fill; } // Border Border border = new Border(); border.Background = new SolidColorBrush(Colors.Transparent); // Border内部の空白をクリック時にヒットテスト可能にするため int tilePadding = TempProfile.TilePadding.Value; if (tilePadding != 0) { border.BorderThickness = new Thickness(tilePadding + 2); border.Margin = new Thickness(-2); // これと↑の-2は隣のGridとの境目を完全に消すため } border.BorderBrush = new SolidColorBrush(TempProfile.GridLineColor.Value); border.Child = image; // セット MainGrid.Children.Add(border); Grid.SetRow(border, i); Grid.SetColumn(border, j); }; if (orientaition == TileOrientation.Horizontal) { switch (origin) { default: case TileOrigin.TopLeft: for (int i = 0; i < numofRow; i++) { for (int j = 0; j < numofCol; j++) { setToGrid(i, j); } } break; case TileOrigin.TopRight: for (int i = 0; i < numofRow; i++) { for (int j = numofCol - 1; j >= 0; j--) { setToGrid(i, j); } } break; case TileOrigin.BottomRight: for (int i = numofRow - 1; i >= 0; i--) { for (int j = numofCol - 1; j >= 0; j--) { setToGrid(i, j); } } break; case TileOrigin.BottomLeft: for (int i = numofRow - 1; i >= 0; i--) { for (int j = 0; j < numofCol; j++) { setToGrid(i, j); } } break; } } else { switch (origin) { default: case TileOrigin.TopLeft: for (int i = 0; i < numofCol; i++) { for (int j = 0; j < numofRow; j++) { setToGrid(j, i); } } break; case TileOrigin.TopRight: for (int i = numofCol - 1; i >= 0; i--) { for (int j = 0; j < numofRow; j++) { setToGrid(j, i); } } break; case TileOrigin.BottomRight: for (int i = numofCol - 1; i >= 0; i--) { for (int j = numofRow - 1; j >= 0; j--) { setToGrid(j, i); } } break; case TileOrigin.BottomLeft: for (int i = 0; i < numofCol; i++) { for (int j = numofRow - 1; j >= 0; j--) { setToGrid(j, i); } } break; } } }
/// <summary> /// Tells player that tile is placed. /// </summary> /// <param name="color">Color of the player making the move.</param> /// <param name="tile">Scheme of tile that was placed.</param> /// <param name="coordinates">Coodrinates of the placed tile.</param> /// <param name="orientation">Orientation of the placed tile.</param> public void PlaceTile(PlayerColor color, TileScheme tile, Coords coordinates, TileOrientation orientation) { _Executor.PlaceTile(color, tile, coordinates, orientation); }
/// <summary> /// Determines the orientation of a Tile, which should be placed on the GameBoard, based on another /// tiles orientation, and the faces with which both tiles should be aligned towards each other. /// </summary> /// <param name="otherOrientation">Other tiles orientation.</param> /// <param name="otherFace">Other tiles face.</param> /// <param name="tileFace">New tiles face.</param> /// <returns>the orientation of the new tile.</returns> private TileOrientation GetTileOrienationFromOtherTileOrientationAndFaces(TileOrientation otherOrientation, TileFace otherFace, TileFace tileFace) { if ((otherOrientation == TileOrientation.Straight && otherFace == TileFace.Left && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.Straight && otherFace == TileFace.Right && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.Straight && otherFace == TileFace.Bottom && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.DoubleTiltLeft && otherFace == TileFace.Left && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.DoubleTiltLeft && otherFace == TileFace.Right && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.DoubleTiltLeft && otherFace == TileFace.Bottom && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.DoubleTiltRight && otherFace == TileFace.Left && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.DoubleTiltRight && otherFace == TileFace.Right && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.DoubleTiltRight && otherFace == TileFace.Bottom && tileFace == TileFace.Left)) { return TileOrientation.Flipped; } else if ((otherOrientation == TileOrientation.Straight && otherFace == TileFace.Left && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.Straight && otherFace == TileFace.Right && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.Straight && otherFace == TileFace.Bottom && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.DoubleTiltLeft && otherFace == TileFace.Left && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.DoubleTiltLeft && otherFace == TileFace.Right && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.DoubleTiltLeft && otherFace == TileFace.Bottom && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.DoubleTiltRight && otherFace == TileFace.Left && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.DoubleTiltRight && otherFace == TileFace.Right && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.DoubleTiltRight && otherFace == TileFace.Bottom && tileFace == TileFace.Right)) { return TileOrientation.TiltRight; } else if ((otherOrientation == TileOrientation.Straight && otherFace == TileFace.Left && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.Straight && otherFace == TileFace.Right && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.Straight && otherFace == TileFace.Bottom && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.DoubleTiltLeft && otherFace == TileFace.Left && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.DoubleTiltLeft && otherFace == TileFace.Right && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.DoubleTiltLeft && otherFace == TileFace.Bottom && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.DoubleTiltRight && otherFace == TileFace.Left && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.DoubleTiltRight && otherFace == TileFace.Right && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.DoubleTiltRight && otherFace == TileFace.Bottom && tileFace == TileFace.Bottom)) { return TileOrientation.TiltLeft; } else if ((otherOrientation == TileOrientation.TiltLeft && otherFace == TileFace.Left && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.TiltLeft && otherFace == TileFace.Right && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.TiltLeft && otherFace == TileFace.Bottom && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.Flipped && otherFace == TileFace.Left && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.Flipped && otherFace == TileFace.Right && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.Flipped && otherFace == TileFace.Bottom && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.TiltRight && otherFace == TileFace.Left && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.TiltRight && otherFace == TileFace.Right && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.TiltRight && otherFace == TileFace.Bottom && tileFace == TileFace.Left)) { return TileOrientation.DoubleTiltRight; } else if ((otherOrientation == TileOrientation.TiltLeft && otherFace == TileFace.Left && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.TiltLeft && otherFace == TileFace.Right && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.TiltLeft && otherFace == TileFace.Bottom && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.Flipped && otherFace == TileFace.Left && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.Flipped && otherFace == TileFace.Right && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.Flipped && otherFace == TileFace.Bottom && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.TiltRight && otherFace == TileFace.Left && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.TiltRight && otherFace == TileFace.Right && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.TiltRight && otherFace == TileFace.Bottom && tileFace == TileFace.Right)) { return TileOrientation.Straight; } else if((otherOrientation == TileOrientation.TiltLeft && otherFace == TileFace.Left && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.TiltLeft && otherFace == TileFace.Right && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.TiltLeft && otherFace == TileFace.Bottom && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.Flipped && otherFace == TileFace.Left && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.Flipped && otherFace == TileFace.Right && tileFace == TileFace.Bottom) || (otherOrientation == TileOrientation.Flipped && otherFace == TileFace.Bottom && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.TiltRight && otherFace == TileFace.Left && tileFace == TileFace.Left) || (otherOrientation == TileOrientation.TiltRight && otherFace == TileFace.Right && tileFace == TileFace.Right) || (otherOrientation == TileOrientation.TiltRight && otherFace == TileFace.Bottom && tileFace == TileFace.Bottom)) { return TileOrientation.DoubleTiltLeft; } throw new ArgumentException("The combination TileOrientation, TileFace, TileFace cannot be determined"); }
/// <summary> /// /// Adds a new Edge to this graph, if it isn't already part of it. /// </summary> /// <param name="vertex1">Vertex1 of the edge to be added.</param> /// <param name="vertex2">Vertex2 of the edge to be added.</param> /// <param name="vertex3">Vertex3 of the edge to be added.</param> /// <returns></returns> public HyperEdge AddEdge(Vertex vertex1, Vertex vertex2, Vertex vertex3 = null, TileOrientation tileOrientation = TileOrientation.None) { if (vertex1.EqualsOnEdgeBasis(vertex2) || vertex1.EqualsOnEdgeBasis(vertex3) || vertex2.EqualsOnEdgeBasis(vertex3)) { throw new ArgumentException("Vertices must not be equal."); } if (!this.HasVertex(vertex1.Value)) { throw new ArgumentException($"This graph does not conatin a vertex with value '{vertex1}'."); } if (!this.HasVertex(vertex2.Value)) { throw new ArgumentException($"This graph does not conatin a vertex with value '{vertex2}'."); } if (vertex3 != null && !this.HasVertex(vertex3.Value)) { throw new ArgumentException($"This graph does not conatin a vertex with value '{vertex3}'."); } Vertex v1 = Vertex.CreateFromVertex(this.Vertices.Where(v => v.Value.Equals(vertex1.Value)).First()); Vertex v2 = Vertex.CreateFromVertex(this.Vertices.Where(v => v.Value.Equals(vertex2.Value)).First()); Vertex v3 = vertex3 != null?Vertex.CreateFromVertex(this.Vertices.Where(v => v.Value.Equals(vertex3.Value)).First()) : null; HyperEdge edge = new HyperEdge(v1, v2, v3, tileOrientation); if (this.HasEdge(edge)) { throw new ArgumentException($"This Graph has already an edge '{edge}'."); } this.Edges.Add(edge); return(edge); }
/// <summary> /// Checks whether tile can be placed on given position. /// </summary> /// <param name="grid">Grid with all placed tiles.</param> /// <param name="tile">Scheme of the tile.</param> /// <param name="coords">Coordinates of the tile.</param> /// <param name="orientation">Orientation of the tile.</param> /// <param name="first">Is the tile first to be placed?</param> /// <exception cref="GameException">Exception describing the error.</exception> public static void CheckTilePlacement(Dictionary <Coords, TilePlacement> grid, TileScheme tile, Coords coords, TileOrientation orientation, bool first) { bool hasNeighbour = false; // Check all neighbours foreach (var or in new TileOrienationEnumerator()) { if (grid.TryGetValue(coords.GetNeighbouringCoords(or), out TilePlacement neighTile)) { hasNeighbour = true; // Retrieve IDs of regions on appropriate positions var thisSchemeOr = or.Derotate(orientation); var neighSchemeOr = or.Rotate(TileOrientation.S).Derotate(neighTile.Orientation); int thisRegionId = tile.GetRegionOnBorder(thisSchemeOr); int neighRegionId = neighTile.Scheme.GetRegionOnBorder(neighSchemeOr); // Check if region types are corresponding if (neighTile.Scheme.GetRegionType(neighRegionId) != tile.GetRegionType(thisRegionId)) { throw new WrongTileSurroundingsException(); } } } // If first tile has neighbour or not-first tile has not neighbour if (first == hasNeighbour) { throw new NoTileSurroundingsException(); } }
public void calculateOrientation(ref Tile[,,]tiles) { tileX = getTileCoords("X"); tileY = getTileCoords("Y"); int tmpY = grabY(-1); int tmpY2 = grabY(1); int tmpX = grabX(-1); int tmpX2 = grabX(1); if (tmpY == -1 || tmpY2 == -1) return; if (tmpX == -1 || tmpX2 == -1) return; if (tileX == 0) tileOrientation = TileOrientation.Single; if (tiles[1, grabY(-1), tileX].tileType != tileType) topMost = true; else topMost = false; if (tiles[1, grabY(1), tileX].tileType != tileType) bottomMost = true; else bottomMost = false; if (tiles[1, tileY, grabX(1)].tileType != tileType) rightMost = true; else rightMost = false; if (tileX > 0 && tiles[1, tileY, grabX(-1)].tileType != tileType) leftMost = true; else leftMost = false; if (topMost && !rightMost && !leftMost && !bottomMost) tileOrientation = TileOrientation.Top; else if (topMost && rightMost && !leftMost && !bottomMost) tileOrientation = TileOrientation.TopRight; else if (!topMost && rightMost && !leftMost && !bottomMost) tileOrientation = TileOrientation.Right; else if (!topMost && rightMost && !leftMost && bottomMost) tileOrientation = TileOrientation.BottomRight; else if (!topMost && !rightMost && !leftMost && bottomMost) tileOrientation = TileOrientation.Bottom; else if (!topMost && !rightMost && leftMost && bottomMost) tileOrientation = TileOrientation.BottomLeft; else if (!topMost && !rightMost && leftMost && !bottomMost) tileOrientation = TileOrientation.Left; else if (topMost && !rightMost && leftMost && !bottomMost) tileOrientation = TileOrientation.TopLeft; else if (topMost && !rightMost && !leftMost && bottomMost) tileOrientation = TileOrientation.TopBottom; else if (!topMost && rightMost && leftMost && !bottomMost) tileOrientation = TileOrientation.LeftRight; else if (!topMost && !rightMost && !leftMost && !bottomMost) tileOrientation = TileOrientation.Single; else if (topMost && !rightMost && leftMost && bottomMost) tileOrientation = TileOrientation.TopBottomLeft; else if (topMost && rightMost && !leftMost && bottomMost) tileOrientation = TileOrientation.TopBottomRight; else if (topMost && rightMost && leftMost && !bottomMost) tileOrientation = TileOrientation.TopLeftRight; else if (!topMost && rightMost && leftMost && bottomMost) tileOrientation = TileOrientation.BottomLeftRight; else tileOrientation = TileOrientation.Regular; }
protected void Executor_TilePlacedEvent(PlayerColor player, TileScheme tile, Coords coords, TileOrientation orientation) { Socket.SendToAll(new ServerResponse() { Type = ServerResponseType.TILE_PLACEMENT, Color = player, Coords = coords, Scheme = tile, Orientation = orientation }); }
public override void OnInspectorGUI() { EditorUtility.SetDirty(target); script = (TileOrientation)target; EditorGUILayout.PrefixLabel("Tile Mask"); for (int i = 0; i < 9; i++) { int rowIndex = i % 3; if (rowIndex == 0) { EditorGUILayout.BeginHorizontal(toggleMenuOptions); } if (i != 4) { script.tileMask[i] = EditorGUILayout.Toggle(script.tileMask[i]); } else { EditorGUILayout.Toggle(false); } if (rowIndex == 2) { EditorGUILayout.EndHorizontal(); } } EditorGUILayout.PrefixLabel("Floor Mask"); for (int i = 0; i < 9; i++) { int rowIndex = i % 3; if (rowIndex == 0) { EditorGUILayout.BeginHorizontal(toggleMenuOptions); } if (i != 4) { script.floorMask[i] = EditorGUILayout.Toggle(script.floorMask[i]); } else { EditorGUILayout.Toggle(false); } if (rowIndex == 2) { EditorGUILayout.EndHorizontal(); } } EditorGUILayout.PrefixLabel("Has inverse"); script.hasInverse = EditorGUILayout.Toggle(script.hasInverse); EditorGUILayout.LabelField("Tiles"); bool[] markedForDeletion = new bool[script.tiles.Length]; int index = 0; int marked = 0; foreach (GameObject prefab in script.tiles) { Object obj = EditorGUILayout.ObjectField(prefab, typeof(GameObject), false); if (obj == null) { markedForDeletion[index] = true; marked++; } index++; } if (marked != 0) { GameObject[] newTiles = new GameObject[script.tiles.Length - marked]; int ci = 0; for (int i = script.tiles.Length - 1; i >= 0; i--) { if (!markedForDeletion[i]) { newTiles[ci] = script.tiles[i]; ci++; } } script.tiles = newTiles; } EditorGUILayout.PrefixLabel("Add new tile"); script.addTile((GameObject)EditorGUILayout.ObjectField(null, typeof(GameObject), false)); }
public static void ProblemOne() { // load in all tiles into a List<Tile> (id, list of string representing picture) List <Tile> tiles = new List <Tile>(); Queue <string> input = new Queue <string>(File.ReadAllLines(Path.Combine(Environment.CurrentDirectory, "input", "day_20.txt")).ToList()); while (input.Count > 0) { // dequeue and get ID, create a new object var tileLine = input.Dequeue().Split("Tile "); int tileId = int.Parse(tileLine[1].TrimEnd(':')); // while next line not empty, build up the picture List <string> picture = new List <string>(); while (input.Count > 0 && !string.IsNullOrEmpty(input.Peek())) { picture.Add(input.Dequeue()); } // create the tile and add it to the list of tiles. tiles.Add(new Tile(tileId, picture)); // remove the spacer if (input.Count > 0) { input.Dequeue(); } } // determine size of output picture and store this data in a List<Tile> (square root of the number is the size of the big pic) int bigPictureSize = Convert.ToInt32(Math.Sqrt(tiles.Count)); List <Tile> foundTiles = new List <Tile>(); // start looking for matches... alter the second if it doesn't match List <Tile> outerLoop = tiles; for (int i = 0; i < outerLoop.Count; i++) { Tile first = outerLoop.ElementAt(i); for (int j = 0; j < tiles.Count; j++) { Tile second = tiles.ElementAt(j); if (first != second) { TileOrientation currentTileOrientation = 0; bool match = false; while (!match && Enum.IsDefined(typeof(TileOrientation), currentTileOrientation)) { match = TryMatch(first, second); try { currentTileOrientation++; switch (currentTileOrientation) { case TileOrientation.Rotate90: second.RotatePicture(); break; case TileOrientation.Rotate180: second.RotatePicture(); break; case TileOrientation.Rotate270: second.RotatePicture(); break; case TileOrientation.Flip: second.RotatePicture(); second.FlipPicture(); break; case TileOrientation.FlipAndRotate90: second.RotatePicture(); break; case TileOrientation.FlipAndRotate180: second.RotatePicture(); break; case TileOrientation.FlipAndRotate270: second.RotatePicture(); break; default: break; } } catch { } } if (match) { if (!foundTiles.Any(x => x.ID == first.ID)) { foundTiles.Add(first); } if (!foundTiles.Any(x => x.ID == second.ID)) { foundTiles.Add(second); } if (foundTiles.Count > 1) { outerLoop = foundTiles; } else { outerLoop = tiles; } } } } } // all tiles should be in the correct rotations now, let's go back through them and find other matches for (int i = 0; i < tiles.Count; i++) { Tile first = tiles.ElementAt(i); for (int j = 0; j < tiles.Count; j++) { Tile second = tiles.ElementAt(j); if (first != second) { TryMatch(first, second); } } } // after all have been "found", iterate through the found tiles to figure out the rest of the tiles it matches. int[,] bigPicture = ValidateBigPicture(bigPictureSize, tiles); // calculate the product (use a long) of the four tiles in the corners (those ones will be have null top/left, top/right, bottom/left, bottom/right values) long product = (long)bigPicture[0, 0] * (long)bigPicture[0, bigPictureSize - 1] * (long)bigPicture[bigPictureSize - 1, 0] * (long)bigPicture[bigPictureSize - 1, bigPictureSize - 1]; Console.WriteLine($"Product of corners: {product}"); }
/// <summary> /// Intantiates a new Object of this class. /// </summary> /// <param name="vertex1">vertex1</param> /// <param name="vertex2">vertex2</param> /// <param name="vertex3">vertex3 (can be null, if edge has only two vertices)</param> public HyperEdge(string vertex1, string vertex2, string vertex3 = null, TileOrientation orientation = TileOrientation.None) : this(new Vertex(vertex1), new Vertex(vertex2), (vertex3 != null) ? new Vertex(vertex3) : null, orientation) { }
private void Simulation_TilePlacedEvent(PlayerColor player, TileScheme scheme, Coords coords, TileOrientation orientation) { if (_Running) { _Serializer.Serialize(_Writer, new ServerResponse() { Type = ServerResponseType.TILE_PLACEMENT, Color = player, Scheme = scheme, Coords = coords, Orientation = orientation }); } }
/// <summary> /// Determines the incoming face of a edge for the next hexagon position. /// </summary> /// <param name="nextTileOrientation">The orientation of the edge for the new hexagon position.</param> /// <returns>Incoming face for new hexgon position.</returns> private TileFace GetIncomingFaceForNextHexagonPosition(TileOrientation nextTileOrientation) { return(this.GetIncomingFace(this.CalcNextPointerValue(this.Pointer), nextTileOrientation)); }
/// <summary> /// Gets tile orientation that was initial to given rotated angle. /// </summary> /// <param name="orientation">Orientation after rotation.</param> /// <param name="angle">Angle of rotation.</param> /// <returns>Orientation before rotation.</returns> public static TileOrientation Derotate(this TileOrientation orientation, TileOrientation angle) { return((TileOrientation)(((int)orientation + 4 - (int)angle) & 0b11)); }