Esempio n. 1
0
    public override void PlaceAttribute(EditorMazeTile tile)
    {
        if (tile.TileMainMaterial.GetType() != typeof(WaterMainMaterial))
        {
            Logger.Log("TODO: Check if this works. Bridge can also be placed on any tile with a coastline");
            return;
        }

        EditorMazeTileAttributePlacer tileAttributePlacer  = new EditorMazeTileAttributePlacer(tile);
        MazeTileAttributeRemover      tileAttributeRemover = new MazeTileAttributeRemover(tile);

        BridgePiece bridgePiece = (BridgePiece)tile.GetAttributes().FirstOrDefault(attribute => (attribute is BridgePiece));

        if (bridgePiece == null)
        {
            tileAttributePlacer.PlaceBridgePiece(BridgePieceDirection.Horizontal);
        }
        else if (bridgePiece.BridgePieceDirection == BridgePieceDirection.Horizontal)
        {
            tileAttributeRemover.RemoveBridgePiece();
            tileAttributePlacer.PlaceBridgePiece(BridgePieceDirection.Vertical);
        }
        else
        {
            tileAttributeRemover.RemoveBridgePiece();
        }
    }
Esempio n. 2
0
    public bool ValidateTarget(TargetLocation targetLocation)
    {
        if (GameManager.Instance.CurrentGameLevel.TilesByLocation.TryGetValue(targetLocation.TargetGridLocation, out Tile targetTile))
        {
            ObjectDirection direction = targetLocation.TargetDirection;

            if (targetTile.Walkable)
            {
                Tile        currentTile = GameManager.Instance.CurrentGameLevel.TilesByLocation[CurrentGridLocation];
                BridgePiece bridgePieceOnCurrentTile = currentTile.TryGetBridgePiece();
                BridgePiece bridgePieceOnTarget      = targetTile.TryGetBridgePiece(); // optimisation: keep bridge locations of the level in a separate list, so we don't have to go over all the tiles in the level

                // there are no bridges involved
                if (bridgePieceOnCurrentTile == null && bridgePieceOnTarget == null)
                {
                    return(true);
                }

                // Make sure we go in the correct bridge direction
                if (bridgePieceOnCurrentTile && bridgePieceOnTarget)
                {
                    if (bridgePieceOnCurrentTile.BridgePieceDirection == BridgePieceDirection.Horizontal &&
                        bridgePieceOnTarget.BridgePieceDirection == BridgePieceDirection.Horizontal &&
                        (direction == ObjectDirection.Left || direction == ObjectDirection.Right))
                    {
                        return(true);
                    }

                    if (bridgePieceOnCurrentTile.BridgePieceDirection == BridgePieceDirection.Vertical &&
                        bridgePieceOnTarget.BridgePieceDirection == BridgePieceDirection.Vertical &&
                        (direction == ObjectDirection.Up || direction == ObjectDirection.Down))
                    {
                        return(true);
                    }

                    return(false);
                }

                if ((bridgePieceOnCurrentTile?.BridgePieceDirection == BridgePieceDirection.Horizontal ||
                     bridgePieceOnTarget?.BridgePieceDirection == BridgePieceDirection.Horizontal) &&
                    (direction == ObjectDirection.Left || direction == ObjectDirection.Right))
                {
                    return(true);
                }

                if ((bridgePieceOnCurrentTile?.BridgePieceDirection == BridgePieceDirection.Vertical ||
                     bridgePieceOnTarget?.BridgePieceDirection == BridgePieceDirection.Vertical) &&
                    (direction == ObjectDirection.Up || direction == ObjectDirection.Down))
                {
                    return(true);
                }
                return(false);
            }
        }
        return(false);
    }
Esempio n. 3
0
    public bool ValidateForBridge(PathNode currentNode, PathNode targetNode, ObjectDirection direction)
    {
        Tile targetTile  = targetNode.Tile;
        Tile currentTile = currentNode.Tile;

        if (targetTile.Walkable)
        {
            BridgePiece bridgePieceOnCurrentTile = currentTile.TryGetBridgePiece();
            BridgePiece bridgePieceOnTarget      = targetTile.TryGetBridgePiece(); // optimisation: keep bridge locations of the level in a separate list, so we don't have to go over all the tiles in the level

            // there are no bridges involved
            if (bridgePieceOnCurrentTile == null && bridgePieceOnTarget == null)
            {
                return(true);
            }

            // Make sure we go in the correct bridge direction
            if (bridgePieceOnCurrentTile && bridgePieceOnTarget)
            {
                if (bridgePieceOnCurrentTile.BridgePieceDirection == BridgePieceDirection.Horizontal &&
                    bridgePieceOnTarget.BridgePieceDirection == BridgePieceDirection.Horizontal &&
                    (direction == ObjectDirection.Left || direction == ObjectDirection.Right))
                {
                    return(true);
                }

                if (bridgePieceOnCurrentTile.BridgePieceDirection == BridgePieceDirection.Vertical &&
                    bridgePieceOnTarget.BridgePieceDirection == BridgePieceDirection.Vertical &&
                    (direction == ObjectDirection.Up || direction == ObjectDirection.Down))
                {
                    return(true);
                }

                return(false);
            }

            if ((bridgePieceOnCurrentTile?.BridgePieceDirection == BridgePieceDirection.Horizontal ||
                 bridgePieceOnTarget?.BridgePieceDirection == BridgePieceDirection.Horizontal) &&
                (direction == ObjectDirection.Left || direction == ObjectDirection.Right))
            {
                return(true);
            }

            if ((bridgePieceOnCurrentTile?.BridgePieceDirection == BridgePieceDirection.Vertical ||
                 bridgePieceOnTarget?.BridgePieceDirection == BridgePieceDirection.Vertical) &&
                (direction == ObjectDirection.Up || direction == ObjectDirection.Down))
            {
                return(true);
            }
            return(false);
        }
        return(false);
    }
Esempio n. 4
0
    private void ConnectBridgeEdgesToTheirBridgePieces()
    {
        for (int i = 0; i < Tiles.Count; i++)
        {
            InGameMazeTile    tile        = Tiles[i] as InGameMazeTile;
            List <BridgeEdge> bridgeEdges = tile.GetBridgeEdges();
            for (int j = 0; j < bridgeEdges.Count; j++)
            {
                Direction      edgeSide      = bridgeEdges[j].EdgeSide;
                InGameMazeTile neighbourTile = null;

                switch (edgeSide)
                {
                case Direction.Up:
                    neighbourTile = tile.Neighbours[ObjectDirection.Up] as InGameMazeTile;
                    break;

                case Direction.Right:
                    neighbourTile = tile.Neighbours[ObjectDirection.Right] as InGameMazeTile;
                    break;

                case Direction.Down:
                    neighbourTile = tile.Neighbours[ObjectDirection.Down] as InGameMazeTile;
                    break;

                case Direction.Left:
                    neighbourTile = tile.Neighbours[ObjectDirection.Left] as InGameMazeTile;
                    break;

                default:
                    break;
                }

                if (neighbourTile)
                {
                    BridgePiece bridgePiece = neighbourTile.TryGetBridgePiece();
                    if (bridgePiece == null)
                    {
                        Logger.Error($"Expected but could not find bridge piece at {neighbourTile.GridLocation.X}, {neighbourTile.GridLocation.Y}.");
                        return;
                    }
                    bridgeEdges[j].WithBridgePieceConnection(bridgePiece);
                }
            }
        }
    }
    public void PlaceBridgePiece(BridgeType bridgeType, BridgePieceDirection bridgePieceDirection)
    {
        BridgePiece bridgePiece = (BridgePiece)InstantiateTileAttributeGO <BridgePiece>();

        bridgePiece.WithBridgeType(bridgeType);
        bridgePiece.WithBridgePieceDirection(bridgePieceDirection);
        bridgePiece.SetSprite();

        Tile.SetWalkable(true);
        Tile.TryMakeMarkable(false);
        Tile.AddAttribute(bridgePiece);

        TileWater tileWater = Tile.TryGetTileWater();

        if (tileWater)
        {
            tileWater.SetWalkabilityForBridge(bridgePieceDirection);
        }
    }
    public void RemoveBridgePiece(BridgePiece bridgePieceAttribute = null)
    {
        if (bridgePieceAttribute == null)
        {
            bridgePieceAttribute = (BridgePiece)_tile.GetAttributes().FirstOrDefault(attribute => attribute is BridgePiece);
        }

        if (bridgePieceAttribute == null)
        {
            return;
        }

        bridgePieceAttribute.RemoveObsoleteBridgeEdges();

        _tile.RemoveAttribute(bridgePieceAttribute);
        bridgePieceAttribute.Remove();

        //Update path connections of neighbours
        foreach (KeyValuePair <ObjectDirection, Tile> neighbour in _tile.Neighbours)
        {
            if (!neighbour.Value)
            {
                continue;
            }

            TilePath mazeTilePathOnNeighbour = neighbour.Value.TryGetTilePath();

            if (mazeTilePathOnNeighbour == null)
            {
                continue;
            }

            int oldConnectionScoreOnNeighbour = mazeTilePathOnNeighbour.ConnectionScore;
            TileConnectionScoreInfo mazeTilePathConnectionScoreOnNeighbourInfo = NeighbourTileCalculator.MapNeighbourPathsOfTile(neighbour.Value, mazeTilePathOnNeighbour.TilePathType);

            //update connection score on neighbour
            mazeTilePathOnNeighbour.WithConnectionScoreInfo(mazeTilePathConnectionScoreOnNeighbourInfo);
        }
    }
Esempio n. 7
0
    private ISerialisableTileAttribute CreateSerialisableTileAttribute(Tile tile, ITileAttribute tileAttribute)
    {
        if (tileAttribute.GetType() == typeof(TileObstacle))
        {
            TileObstacle tileObstacle = tileAttribute as TileObstacle;
            SerialisableTileObstacleAttribute serialisableTileObstacleAttribute =
                new SerialisableTileObstacleAttribute(
                    new TileConnectionScoreInfo(tileObstacle.ConnectionScore, tileObstacle.SpriteNumber));
            return(serialisableTileObstacleAttribute);
        }
        else if (tileAttribute.GetType() == typeof(PlayerExit))
        {
            PlayerExit playerExit = tileAttribute as PlayerExit;

            SerialisablePlayerExitAttribute serialisablePlayerExitAttribute = new SerialisablePlayerExitAttribute(
                new TileConnectionScoreInfo(playerExit.ConnectionScore, playerExit.SpriteNumber));
            return(serialisablePlayerExitAttribute);
        }
        else if (tileAttribute.GetType() == typeof(PlayerOnly))
        {
            SerialisablePlayerOnlyAttribute serialisablePlayerOnlyAttribute = new SerialisablePlayerOnlyAttribute();
            return(serialisablePlayerOnlyAttribute);
        }
        else if (tileAttribute.GetType() == typeof(PlayerSpawnpoint))
        {
            SerialisablePlayerSpawnpointAttribute serialisablePlayerSpawnpointAttribute = new SerialisablePlayerSpawnpointAttribute();
            return(serialisablePlayerSpawnpointAttribute);
        }
        else if (tileAttribute.GetType() == typeof(EnemySpawnpoint))
        {
            EnemySpawnpoint enemySpawnpoint = tileAttribute as EnemySpawnpoint;
            SerialisableEnemySpawnpointAttribute serialisableEnemySpawnpointAttribute = new SerialisableEnemySpawnpointAttribute(enemySpawnpoint.TileAreas);
            return(serialisableEnemySpawnpointAttribute);
        }
        else if (tileAttribute.GetType() == typeof(MazeLevelEntry))
        {
            MazeLevelEntry mazeLevelEntry = tileAttribute as MazeLevelEntry;
            SerialisableMazeLevelEntryAttribute serialisableMazeLevelEntryAttribute = new SerialisableMazeLevelEntryAttribute(mazeLevelEntry.MazeLevelName);
            return(serialisableMazeLevelEntryAttribute);
        }
        else if (tileAttribute.GetType() == typeof(BridgePiece))
        {
            BridgePiece          bridgePiece          = tileAttribute as BridgePiece;
            BridgePieceDirection bridgePieceDirection = bridgePiece.BridgePieceDirection;

            SerialisableBridgePieceAttribute serialisableBridgePieceAttribute = new SerialisableBridgePieceAttribute(bridgePieceDirection);
            return(serialisableBridgePieceAttribute);
        }
        else if (tileAttribute.GetType() == typeof(BridgeEdge))
        {
            BridgeEdge bridgeEdge = tileAttribute as BridgeEdge;

            SerialisableBridgeEdgeAttribute serialisableBridgeEdgeAttribute = new SerialisableBridgeEdgeAttribute(bridgeEdge.EdgeSide);
            return(serialisableBridgeEdgeAttribute);
        }
        else if (tileAttribute.GetType() == typeof(MusicInstrumentCase))
        {
            SerialisableMusicInstrumentCaseAttribute serialisableMusicInstrumentCaseAttribute = new SerialisableMusicInstrumentCaseAttribute();
            return(serialisableMusicInstrumentCaseAttribute);
        }
        else
        {
            Logger.Error($"Could not serialise the tile attribute {tileAttribute.GetType()}");
            return(null);
        }
    }
Esempio n. 8
0
    public static TileConnectionScoreInfo MapNeighbourPathsOfTile(Tile tile, IPathType pathType)
    {
        Logger.Log($"---------Map neighbours of {tile.GridLocation.X},{tile.GridLocation.Y}--------");
        TileModifierConnectionInfo <TilePath> pathRight = new TileModifierConnectionInfo <TilePath>(Direction.Right);
        TileModifierConnectionInfo <TilePath> pathDown  = new TileModifierConnectionInfo <TilePath>(Direction.Down);
        TileModifierConnectionInfo <TilePath> pathLeft  = new TileModifierConnectionInfo <TilePath>(Direction.Left);
        TileModifierConnectionInfo <TilePath> pathUp    = new TileModifierConnectionInfo <TilePath>(Direction.Up);

        if (!EditorManager.InEditor)
        {
            Logger.Error("MapNeighbourPathsOfTile was not called from the editor");
            return(null);
        }

        foreach (KeyValuePair <ObjectDirection, Tile> neighbour in tile.Neighbours)
        {
            if (!neighbour.Value)
            {
                // if there is no tile as neighbour, it must mean it as the level edge. This counts as a connection.
                if (neighbour.Key == ObjectDirection.Right)
                {
                    pathRight.HasConnection = true;
                }
                else if (neighbour.Key == ObjectDirection.Down)
                {
                    pathDown.HasConnection = true;
                }
                else if (neighbour.Key == ObjectDirection.Left)
                {
                    pathLeft.HasConnection = true;
                }
                else if (neighbour.Key == ObjectDirection.Up)
                {
                    pathUp.HasConnection = true;
                }
                continue;
            }

            Logger.Warning($"Neighbour at {neighbour.Value.GridLocation.X},{neighbour.Value.GridLocation.Y} is {neighbour.Key} of {tile.GridLocation.X},{tile.GridLocation.Y}.");

            // Check if the neighbour has a connection which is a PATH or a BRIDGE
            TilePath tilePath = neighbour.Value.TryGetTilePath();
            if (tilePath == null || tilePath.TilePathType?.GetType() != pathType.GetType())
            {
                BridgePiece bridgePiece = neighbour.Value.TryGetBridgePiece();
                if (bridgePiece == null)
                {
                    continue;
                }

                bool hasBridgeConnection = false;

                if ((neighbour.Key == ObjectDirection.Right || neighbour.Key == ObjectDirection.Left) &&
                    bridgePiece.BridgePieceDirection == BridgePieceDirection.Horizontal)
                {
                    hasBridgeConnection = true;
                }
                else if ((neighbour.Key == ObjectDirection.Down || neighbour.Key == ObjectDirection.Up) &&
                         bridgePiece.BridgePieceDirection == BridgePieceDirection.Vertical)
                {
                    hasBridgeConnection = true;
                }

                if (hasBridgeConnection == false)
                {
                    continue;
                }
            }

            if (neighbour.Key == ObjectDirection.Right)
            {
                pathRight.HasConnection = true;
                pathRight.TileModifier  = tilePath;
            }
            else if (neighbour.Key == ObjectDirection.Down)
            {
                pathDown.HasConnection = true;
                pathDown.TileModifier  = tilePath;
            }
            else if (neighbour.Key == ObjectDirection.Left)
            {
                pathLeft.HasConnection = true;
                pathLeft.TileModifier  = tilePath;
            }
            else if (neighbour.Key == ObjectDirection.Up)
            {
                pathUp.HasConnection = true;
                pathUp.TileModifier  = tilePath;
            }
        }

        return(TileConnectionRegister.CalculateTileConnectionScore(pathRight, pathDown, pathLeft, pathUp));
    }