[SFML] Dialog box

potrzebuje funkcji która jako argument pobiera tekst i wyświetla ten tekst na prostokątnym tle.

Stworzenie dialog boxa w SFML z możliwością wyświetlania dłuższego tekstu można osiągnąć poprzez podzielenie go na mniejsze fragmenty, tak aby nie wychodziły poza obszar okna. Trzeba zająć się kilkoma rzeczami:

1. **Podzielenie Tekstu:** Rozdzielenie tekstu na linie o odpowiedniej długości tak, aby każda linia mieściła się w obrębie boxa.
2. **Renderowanie Tekstu:** Upewnij się, że tekst jest poprawnie wyświetlany linia po linii.
3. **Box:** Stworzenie prostokątnego boxa i wyświetlenie w nim tekstu.

Poniżej znajdziesz przykładowy kod w C++, używający SFML, który ilustruje takie podejście:

```cpp
#include <SFML/Graphics.hpp>
#include <string>
#include <vector>
#include <sstream>

// Funkcja dzieląca tekst na linie o odpowiedniej szerokości
std::vector<std::string> wrapText(const std::string& text, sf::Font& font, unsigned int fontSize, float maxWidth) {
    std::vector<std::string> wrappedText;
    std::istringstream wordsStream(text);
    std::string word;
    std::string currentLine;

    while (wordsStream >> word) {
        std::string testLine = currentLine.empty() ? word : currentLine + " " + word;
        sf::Text testText(testLine, font, fontSize);
        if (testText.getGlobalBounds().width > maxWidth) {
            wrappedText.push_back(currentLine);
            currentLine = word;
        } else {
            currentLine = testLine;
        }
    }

    if (!currentLine.empty()) {
        wrappedText.push_back(currentLine);
    }

    return wrappedText;
}

int main() {
    sf::RenderWindow window(sf::VideoMode(800, 600), "Dialog Box Example");

    sf::Font font;
    if (!font.loadFromFile("arial.ttf")) {
        return -1; // Upewnij się, że masz odpowiednią czcionkę
    }

    std::string text = "This is an example of a dialog box that wraps text automatically "
                       "based on the width of the dialog box.";

    unsigned int fontSize = 24;
    float boxWidth = 600;

    // Dzielimy tekst na linie
    std::vector<std::string> wrappedText = wrapText(text, font, fontSize, boxWidth);

    // Tworzymy tekst do wyświetlenia linia po linii
    std::vector<sf::Text> textLines;
    float yPosition = 50;
    for (const auto& line : wrappedText) {
        sf::Text textLine(line, font, fontSize);
        textLine.setPosition(100, yPosition);
        textLine.setFillColor(sf::Color::White);
        textLines.push_back(textLine);
        yPosition += fontSize + 5;
    }

    // Tworzymy prostokątny box
    sf::RectangleShape dialogBox(sf::Vector2f(boxWidth, yPosition - 50 + 20));
    dialogBox.setPosition(90, 40);
    dialogBox.setFillColor(sf::Color(0, 0, 0, 150));
    dialogBox.setOutlineColor(sf::Color::White);
    dialogBox.setOutlineThickness(2);

    // Pętla główna aplikacji
    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                window.close();
            }
        }

        window.clear();
        window.draw(dialogBox);
        for (const auto& textLine : textLines) {
            window.draw(textLine);
        }
        window.display();
    }

    return 0;
}
```

### Wyjaśnienie kodu
1. **Podział Tekstu:** Funkcja `wrapText` dzieli długi tekst na linie, które mieszczą się w określonej szerokości, korzystając z czcionki i rozmiaru tekstu.
2. **Wyświetlanie Tekstu:** Dzielone linie są umieszczane w obszarze okna poprzez ustawienie odpowiednich pozycji.
3. **Dialog Box:** Tworzony jest prostokątny box na podstawie wielkości zawartości.

W kodzie upewnij się, że ścieżka do czcionki jest poprawna, aby załadować ją do programu.