void RLBotBot::RenderArenaRamps(const RLGSC::GameState& gs) {
    rlbot::ScopedRenderer renderer("arena_ramps_renderer");

    // Arena dimensions
    const float FIELD_LENGTH = 5120.0f;
    const float FIELD_WIDTH = 4096.0f;

    // Player Movement Data (Ramp Parameters)
    const float RAMP_START_X = 3783.82f;
    const float RAMP_START_Y = -2326.19f;
    const float RAMP_START_Z = 17.01f;

    const float RAMP_END_X = 4078.69f;
    const float RAMP_END_Y = -2339.58f;
    const float RAMP_END_Z_RAW = 258.64f;
    const float RAMP_END_Z = 256.0f; // Capped at maximum ramp height

    // Ramp slope and angle
    const float DELTA_X = RAMP_END_X - RAMP_START_X; // 4078.69 - 3783.82 = 294.87
    const float DELTA_Y = RAMP_END_Y - RAMP_START_Y; // -2339.58 - (-2326.19) = -13.39
    const float DELTA_Z = RAMP_END_Z - RAMP_START_Z; // 256.0 - 17.01 = 238.99

    const float HORIZONTAL_DISTANCE = std::sqrt((DELTA_X * DELTA_X) + (DELTA_Y * DELTA_Y)); // ≈295 units

    const float RAMP_SLOPE = DELTA_Z / HORIZONTAL_DISTANCE; // ≈0.809 (Adjusted to match capped Z)
    const float RAMP_ANGLE_DEGREES = std::atan(RAMP_SLOPE) * 180.0f / M_PI; // ≈39 degrees
    const int MAX_RAMP_ANGLE = static_cast<int>(std::round(RAMP_ANGLE_DEGREES)); // 39 degrees

    // Function to draw a side ramp outline
    auto drawSideRampOutline = [&renderer](const rlbot::flat::Vector3& start, const rlbot::flat::Vector3& end, const rlbot::Color& color) {
        // Draw the base horizontal line (ground level)
        renderer.DrawLine3D(color, start, { end.x(), end.y(), start.z() });

        // Draw the vertical rise line (height)
        renderer.DrawLine3D(color, start, { start.x(), start.y(), end.z() });

        // Draw the hypotenuse (ramp surface)
        renderer.DrawLine3D(color, { start.x(), start.y(), end.z() }, end);
        };

    // Function to draw ramp slope indicators for each degree
    auto drawRampSlopeIndicators = [&](const rlbot::flat::Vector3& start, const rlbot::flat::Vector3& end, const rlbot::Color& color) {
        // Calculate horizontal distance (ground distance)
        float deltaX = end.x() - start.x();
        float deltaY = end.y() - start.y();
        float horizontalDistance = std::sqrt(deltaX * deltaX + deltaY * deltaY);
        float verticalDistance = end.z() - start.z();

        // Safety check to prevent division by zero
        if (horizontalDistance == 0.0f) {
            RG_LOG("Horizontal distance is zero. Cannot compute ramp indicators.");
            return;
        }

        // Normalize the direction vector (X and Y components)
        float directionX = deltaX / horizontalDistance;
        float directionY = deltaY / horizontalDistance;

        // For each degree, calculate the corresponding point on the ramp
        for (int degree = 1; degree <= MAX_RAMP_ANGLE; ++degree) {
            float rad = degree * M_PI / 180.0f;
            float currentZ = start.z() + std::tan(rad) * horizontalDistance * (static_cast<float>(degree) / MAX_RAMP_ANGLE);

            // Ensure currentZ does not exceed the ramp's end Z
            if (currentZ > end.z()) {
                currentZ = end.z();
            }

            // Calculate the corresponding (x, y) on the ramp
            float currentDistance = (currentZ - start.z()) / std::tan(rad);
            float currentX = start.x() + directionX * currentDistance;
            float currentY = start.y() + directionY * currentDistance;

            // Draw a small line perpendicular to the ramp to indicate the degree
            float lineLength = 100.0f; // Adjust as needed
            float perpendicularX = -directionY;
            float perpendicularY = directionX;

            rlbot::flat::Vector3 lineStart = { currentX, currentY, currentZ };
            rlbot::flat::Vector3 lineEnd = {
                currentX + perpendicularX * lineLength,
                currentY + perpendicularY * lineLength,
                currentZ
            };

            renderer.DrawLine3D(color, lineStart, lineEnd);

            // Draw degree labels (optional)
            std::stringstream ss;
            ss << degree << "°";
            renderer.DrawString3D(ss.str(), color, { currentX + perpendicularX * (lineLength + 50), currentY + perpendicularY * (lineLength + 50), currentZ }, 2, 2);
        }

        // Draw the final ramp angle label
        std::stringstream finalLabel;
        finalLabel << RAMP_ANGLE_DEGREES << "°";
        renderer.DrawString3D(finalLabel.str(), color, { end.x() + 60, end.y(), end.z() + 30 }, 2, 2);
        };

    // Define ramp color
    rlbot::Color sideRampColor{ 255, 165, 0, 255 }; // Orange

    // Draw side ramps
    // Right Side Ramp
    rlbot::flat::Vector3 sideRampStartRight = { RAMP_START_X, RAMP_START_Y, RAMP_START_Z };
    rlbot::flat::Vector3 sideRampEndRight = { RAMP_END_X, RAMP_END_Y, RAMP_END_Z };
    drawSideRampOutline(sideRampStartRight, sideRampEndRight, sideRampColor);
    drawRampSlopeIndicators(sideRampStartRight, sideRampEndRight, sideRampColor);

    // Left Side Ramp (Mirror of Right Ramp)
    // Assuming symmetry, adjust as needed based on your arena's layout
    rlbot::flat::Vector3 sideRampStartLeft = { -RAMP_END_X, RAMP_START_Y, RAMP_START_Z };
    rlbot::flat::Vector3 sideRampEndLeft = { -RAMP_START_X, RAMP_END_Y, RAMP_END_Z };
    drawSideRampOutline(sideRampStartLeft, sideRampEndLeft, sideRampColor);
    drawRampSlopeIndicators(sideRampStartLeft, sideRampEndLeft, sideRampColor);

    // Optionally, you can add labels or additional markers here

    // Log player position
    const auto& player = gs.players[this->index];
    RG_LOG("Player Position: x=" << player.phys.pos.x << ", y=" << player.phys.pos.y << ", z=" << player.phys.pos.z);
} Floor: 0
Center field: (0, 0)
Side wall: x=±4096
Side wall length: 7936
Back wall: y=±5120
Back wall length: 5888
Ceiling: z=2044
Goal height: z=642.775
Goal center-to-post: 892.755
Goal depth: 880
Corner wall length: 1629.174
The corner planes intersect the axes at ±8064 at a 45 degrees angle now you know this info render all the ramps in the whole arena even the corner ones since you know the ramp angle and degress