示例#1
0
 public PathNode(GameWorld.Terrain _weight, Vector3 _worldPos, int _X, int _Y)
 {
     weight        = _weight;
     worldPosition = _worldPos;
     gridX         = _X;
     gridY         = _Y;
 }
示例#2
0
    private float getFOWBoundsDistance()
    {
        GameWorld.Terrain currentTerrain = gameWorld.getTerrainAtPoint(transform.position);
        float             distance       = boundEntity.fovDistance[currentTerrain];

        if (gameWorld.isNight)
        {
            distance *= boundEntity.nightFOVModifier;
        }
        return(distance);
    }
示例#3
0
文件: FOV.cs 项目: xxzoltanxx/NewGame
    private Vector3[] getFOWBoundsPolygon(bool isNight)
    {
        Vector2 currentPosition = transform.position;

        pointsFOWBOUNDS[0]   = transform.InverseTransformPoint(currentPosition);
        pointsFOWBOUNDS[0].z = 0;
        Vector2 startAngleDir = new Vector2(0.01f, 0);
        int     i             = 1;

        GameWorld.Terrain currentTerrain = gameWorld.getTerrainAtPoint(currentPosition);
        if (currentTerrain == GameWorld.Terrain.Forest)
        {
            boundEntity.SetHidden(true);
        }
        else
        {
            boundEntity.SetHidden(false);
        }
        float distance = boundEntity.fovDistance[currentTerrain];

        if (isNight)
        {
            distance *= boundEntity.nightFOVModifier;
        }
        for (float angle = 0; angle <= 360; angle += 4)
        {
            Vector2 angleDir = startAngleDir.Rotate(angle);
            //GameWorld.Terrain currentTerrain = gameWorld.getTerrainAtPoint(currentPosition + angleDir);
            Vector2 angleDirIncreased = new Vector2(distance * Mathf.Cos(Mathf.Deg2Rad * angle), distance * Mathf.Sin(Mathf.Deg2Rad * angle));
            Vector2 endPosition       = currentPosition + angleDirIncreased;
            //for (float dist = 0; dist < distance - 0.01f; dist = dist + terrainStep)

            /*{
             *  //Vector2 angleDirIncreased = angleDir + new Vector2(dist * Mathf.Cos(Mathf.Deg2Rad * angle), dist * Mathf.Sin( Mathf.Deg2Rad * angle));
             *  //endPosition = currentPosition + angleDirIncreased;
             *  GameWorld.Terrain newTerrain = gameWorld.getTerrainAtPoint(endPosition);
             *  if (newTerrain != currentTerrain)
             *  {
             *      //currentTerrain = newTerrain;
             *      //distance = boundEntity.fovDistance[newTerrain];
             *      distance = boundEntity.fovDistance[currentTerrain];
             *  }
             * }*/

            endPosition        = transform.InverseTransformPoint(endPosition);
            pointsFOWBOUNDS[i] = endPosition;
            ++i;
        }
        return(pointsFOWBOUNDS);
    }
示例#4
0
    public void CreateGrid()
    {
        mesh         = world.GetComponent <WorldMesh>();
        generator    = world.GetComponent <WorldGenerator>();
        nodeDiameter = mesh.tileSize.x;
        nodeRadius   = nodeDiameter / 2.0f;
        gridSizeX    = generator.width;
        gridSizeY    = generator.height;
        grid         = new PathNode[gridSizeX, gridSizeY];
        Vector3 worldBottomLeft = transform.position - Vector3.right * mesh.totalSize.x / 2 - Vector3.up * mesh.totalSize.y / 2;

        for (int x = 0; x < gridSizeX; ++x)
        {
            for (int y = 0; y < gridSizeY; ++y)
            {
                Vector3           worldPoint = worldBottomLeft + Vector3.right * (x * nodeDiameter + nodeRadius) + Vector3.up * (y * nodeDiameter + nodeRadius);
                GameWorld.Terrain terrain    = world.getTerrainAtPoint(worldPoint);
                grid[x, y] = new PathNode(terrain, worldPoint, x, y);
            }
        }
    }
示例#5
0
    // Update is called once per frame
    void Update()
    {
        Vector2  currentPos = transform.position;
        PathNode node       = grid.NodeFromWorldPoint(currentPos);

        if (node != currentTile)
        {
            node.entitiesCurrentlyOnTile.Add(gameObject);
            if (node.entitiesCurrentlyOnTile.Count > 1)
            {
                foreach (GameObject obj in node.entitiesCurrentlyOnTile)
                {
                    if (!obj.GetComponent <Entity>().isPlayer)
                    {
                        node.battling = true;
                        BattleState state = new BattleState(boundEntity, obj.GetComponent <Entity>(), gameManager, node);
                        battleEntryScreen.Open(transform.position, boundEntity.soldierAmount, obj.GetComponent <Entity>().soldierAmount, state);
                        gameManager.currentBattleState = state;
                        gameManager.openMenuLockActions(transform.position);
                    }
                }
            }
            if (currentTile != null)
            {
                currentTile.entitiesCurrentlyOnTile.Remove(gameObject);
            }
            currentTile = node;
        }

        if (gameManager.playerCheckpoint && gameManager.playerCheckpointUpdated)
        {
            line.GetComponent <CurveLineRenderer>().ClearVertices();
            if (pathNodes != null)
            {
                pathNodes.Clear();
            }
            Vector2 sameZ       = gameManager.playerCheckpoint.transform.position;
            Vector2 sameZPlayer = transform.position;
            if (Vector2.Distance(sameZ, sameZPlayer) > distanceToEnablePathfinding)
            {
                pathNodes = grid.FindPath(sameZPlayer, sameZ, boundEntity);
                pathNodes[pathNodes.Count - 1]      = sameZ;
                currentPathNodeIndex                = 0;
                gameManager.playerCheckpointUpdated = false;
            }
            else if (!sameZ.FuzzyEquals(sameZPlayer, 0.01f))
            {
                Vector3 direction = gameManager.playerCheckpoint.transform.position - transform.position;
                direction.z = 0;
                direction.Normalize();

                GameWorld.Terrain currentTerrain   = grid.NodeFromWorldPoint(transform.position).weight;
                float             movementModifier = boundEntity.terrainModifiers[currentTerrain];

                Vector3 newPosition = transform.position + direction * movementModifier * gameManager.timeMultiplier * Time.deltaTime;
                transform.position = newPosition;
            }
            else
            {
                GameObject.Destroy(gameManager.playerCheckpoint);
            }
        }
        else if (gameManager.playerCheckpoint && !gameManager.playerCheckpointUpdated)
        {
            Vector3 checkpointPosition = pathNodes[currentPathNodeIndex];
            Vector2 sameZEnd           = gameManager.playerCheckpoint.transform.position;
            Vector2 sameZCheckpoint    = checkpointPosition;
            Vector2 sameZPlayer        = transform.position;
            linePosition.Clear();
            linePosition.Add(new Vector3(sameZPlayer.x, sameZPlayer.y, lineZ));
            line.GetComponent <CurveLineRenderer>().ClearVertices();
            for (int i = currentPathNodeIndex; i < pathNodes.Count; ++i)
            {
                linePosition.Add(new Vector3(pathNodes[i].x, pathNodes[i].y, lineZ));
            }
            line.GetComponent <CurveLineRenderer>().SetVertices(linePosition);
            if (!sameZCheckpoint.FuzzyEquals(sameZPlayer, 0.025f))
            {
                Vector2 direction2D = sameZCheckpoint - sameZPlayer;
                Vector3 direction   = direction2D;
                direction.Normalize();

                GameWorld.Terrain currentTerrain   = grid.NodeFromWorldPoint(transform.position).weight;
                float             movementModifier = boundEntity.terrainModifiers[currentTerrain] * boundEntity.pace * boundEntity.speed;;

                Vector3 newPosition = transform.position + direction * movementModifier * gameManager.timeMultiplier * Time.deltaTime;
                transform.position = newPosition;
            }
            else
            {
                transform.position = new Vector3(sameZCheckpoint.x, sameZCheckpoint.y, transform.position.z);
                if (currentPathNodeIndex + 1 <= pathNodes.Count - 1)
                {
                    ++currentPathNodeIndex;
                }
                else
                {
                    gameManager.playerCheckpointUpdated = true;
                }
            }
        }
    }
示例#6
0
    public PatrolStatus TickMovement(float dt)
    {
        Vector2  currentPos = transform.position;
        PathNode node       = grid.NodeFromWorldPoint(currentPos);

        if (node != currentTile)
        {
            node.entitiesCurrentlyOnTile.Add(gameObject);
            if (node.entitiesCurrentlyOnTile.Count > 1)
            {
                foreach (GameObject obj in node.entitiesCurrentlyOnTile)
                {
                    if (obj.GetComponent <Entity>().isPlayer&& !node.battling)
                    {
                        BattleState state = new BattleState(obj.GetComponent <Entity>(), boundEntity, gameManager, node);
                        battleEntryScreen.Open(transform.position, boundEntity.soldierAmount, obj.GetComponent <Entity>().soldierAmount, state);
                        gameManager.currentBattleState = state;
                        gameManager.openMenuLockActions(transform.position);
                        node.battling = true;
                    }
                }
            }
            if (currentTile != null)
            {
                currentTile.entitiesCurrentlyOnTile.Remove(gameObject);
            }
            currentTile = node;
        }
        if (!usingPathfinding)
        {
            Vector2 sameZcheckpoint = currentCheckpoint;
            Vector2 sameZ           = transform.position;
            if (Vector2.Distance(sameZ, sameZcheckpoint) > distanceToEnablePathfinding)
            {
                pathNodes = grid.FindPath(sameZ, sameZcheckpoint, boundEntity);
                pathNodes[pathNodes.Count - 1] = sameZcheckpoint;
                currentPathNodeIndex           = 0;
                usingPathfinding = true;
                return(PatrolStatus.Ongoing);
            }
            else if (!sameZ.FuzzyEquals(sameZcheckpoint, 0.01f))
            {
                Vector3 direction = sameZcheckpoint - sameZ;
                direction.z = 0;
                direction.Normalize();

                GameWorld.Terrain currentTerrain = grid.NodeFromWorldPoint(transform.position).weight;
                if (currentTerrain == GameWorld.Terrain.Forest)
                {
                    GetComponent <Entity>().SetHidden(true);
                }
                else
                {
                    GetComponent <Entity>().SetHidden(false);
                }
                float movementModifier = boundEntity.terrainModifiers[currentTerrain] * boundEntity.pace * boundEntity.speed;

                Vector3 newPosition = transform.position + direction * movementModifier * gameManager.timeMultiplier * Time.deltaTime;
                transform.position = newPosition;
                return(PatrolStatus.Ongoing);
            }
            else
            {
                //REACHED THE DESTINATION
                return(PatrolStatus.Finished);
            }
        }
        else if (usingPathfinding)
        {
            Vector3 checkpointPosition = pathNodes[currentPathNodeIndex];
            Vector2 sameZEnd           = currentCheckpoint;
            Vector2 sameZCheckpoint    = checkpointPosition;
            Vector2 sameZPlayer        = transform.position;
            if (!sameZCheckpoint.FuzzyEquals(sameZPlayer, 0.025f))
            {
                Vector2 direction2D = sameZCheckpoint - sameZPlayer;
                Vector3 direction   = direction2D;
                direction.Normalize();

                GameWorld.Terrain currentTerrain = grid.NodeFromWorldPoint(transform.position).weight;
                if (currentTerrain == GameWorld.Terrain.Forest)
                {
                    GetComponent <Entity>().SetHidden(true);
                }
                else
                {
                    GetComponent <Entity>().SetHidden(false);
                }
                float movementModifier = boundEntity.terrainModifiers[currentTerrain] * boundEntity.pace * boundEntity.speed;

                Vector3 newPosition = transform.position + direction * movementModifier * gameManager.timeMultiplier * Time.deltaTime;
                transform.position = newPosition;
            }
            else
            {
                transform.position = new Vector3(sameZCheckpoint.x, sameZCheckpoint.y, transform.position.z);
                if (currentPathNodeIndex + 1 <= pathNodes.Count - 1)
                {
                    ++currentPathNodeIndex;
                }
                else
                {
                    usingPathfinding = false;
                }
            }
        }
        return(PatrolStatus.Ongoing);
    }