Exemple #1
0
        void ComputeRouteMatrix(TERRAIN_CAPABILITY terrainCapability, float minAltitude, float maxAltitude)
        {
            bool computeMatrix = false;
            byte thisMatrix    = 1;

            // prepare matrix
            if (earthRouteMatrix == null)
            {
                earthRouteMatrix   = new byte[EARTH_ROUTE_SPACE_WIDTH * EARTH_ROUTE_SPACE_HEIGHT];
                computedMatrixBits = 0;
            }

            // prepare water mask data
            bool checkWater = terrainCapability != TERRAIN_CAPABILITY.Any;

            if (checkWater)
            {
                computeMatrix = CheckRouteWaterMask();
            }

            // check elevation data if needed
            bool checkElevation = minAltitude > 0f || maxAltitude < 1.0f;

            if (checkElevation)
            {
                if (viewportElevationPoints == null)
                {
                    Debug.LogError("Viewport needs to be initialized before calling using Path Finding functions.");
                    return;
                }
                if (minAltitude != earthRouteMatrixWithElevationMinAltitude || maxAltitude != earthRouteMatrixWithElevationMaxAltitude)
                {
                    computeMatrix = true;
                    earthRouteMatrixWithElevationMinAltitude = minAltitude;
                    earthRouteMatrixWithElevationMaxAltitude = maxAltitude;
                }
            }
            else
            {
                if (terrainCapability == TERRAIN_CAPABILITY.OnlyGround)
                {
                    thisMatrix = 2;
                }
                else
                {
                    thisMatrix = 4; // water
                }
                if ((computedMatrixBits & thisMatrix) == 0)
                {
                    computeMatrix       = true;
                    computedMatrixBits |= thisMatrix;   // mark computedMatrixBits
                }
            }

            // Compute route
            if (computeMatrix)
            {
                int   jj_waterMask = 0, kk_waterMask;
                int   jj_terrainElevation = 0, kk_terrainElevation;
                bool  dry = false;
                float elev = 0;
                for (int j = 0; j < EARTH_ROUTE_SPACE_HEIGHT; j++)
                {
                    int jj = j * EARTH_ROUTE_SPACE_WIDTH;
                    if (checkWater)
                    {
                        jj_waterMask = (int)((j * (float)earthWaterMaskHeight / EARTH_ROUTE_SPACE_HEIGHT)) * earthWaterMaskWidth;
                    }
                    if (checkElevation)
                    {
                        jj_terrainElevation = ((int)(j * (float)heightmapTextureHeight / EARTH_ROUTE_SPACE_HEIGHT)) * heightmapTextureWidth;
                    }
                    for (int k = 0; k < EARTH_ROUTE_SPACE_WIDTH; k++)
                    {
                        bool setBit = false;
                        // Check altitude
                        if (checkElevation)
                        {
                            kk_terrainElevation = (int)(k * (float)heightmapTextureWidth / EARTH_ROUTE_SPACE_WIDTH);
                            elev = viewportElevationPoints[jj_terrainElevation + kk_terrainElevation];
                        }
                        if (elev >= minAltitude && elev <= maxAltitude)
                        {
                            if (checkWater)
                            {
                                kk_waterMask = (int)(k * (float)earthWaterMaskWidth / EARTH_ROUTE_SPACE_WIDTH);
                                dry          = !earthWaterMask.GetBit(jj_waterMask + kk_waterMask);
                            }
                            if (terrainCapability == TERRAIN_CAPABILITY.Any ||
                                terrainCapability == TERRAIN_CAPABILITY.OnlyGround && dry ||
                                terrainCapability == TERRAIN_CAPABILITY.OnlyWater && !dry)
                            {
                                setBit = true;
                            }
                        }
                        if (setBit)     // set navigation bit
                        {
                            earthRouteMatrix[jj + k] |= thisMatrix;
                        }
                        else            // clear navigation bit
                        {
                            earthRouteMatrix[jj + k] &= (byte)(byte.MaxValue ^ thisMatrix);
                        }
                    }
                }
            }

            if (finder == null)
            {
                if (_customRouteMatrix == null || !_pathFindingEnableCustomRouteMatrix)
                {
                    PathFindingCustomRouteMatrixReset();
                }
                finder = new PathFinderFast(earthRouteMatrix, thisMatrix, EARTH_ROUTE_SPACE_WIDTH, EARTH_ROUTE_SPACE_HEIGHT, _customRouteMatrix);
            }
            else
            {
                if (computeMatrix || thisMatrix != lastMatrix)
                {
                    lastMatrix = thisMatrix;
                    finder.SetCalcMatrix(earthRouteMatrix, thisMatrix);
                }
            }
        }