System Dialogów v2

#include <iostream>
#include <string>
#include <vector>
#include <functional>

class DialogueOption {
public:
    std::string text; // na razie bez W
    int nextDialogueID;
    std::function < bool() > conditions;
    std::function < void() > actions;
};

class Dialogue {
public:
    int id;
    std::string text; // na razie bez W
    std::vector < DialogueOption > options;
    std::function < void() > actions;
};

// Zarządzanie pamięcią jest poza zakresem przykładu
std::vector < Dialogue * > g_dialogues;
Dialogue * createDialogue()
{
    auto d = new Dialogue;
    d->id = g_dialogues.size() + 1;
    g_dialogues.push_back( d );
    return d;
}

bool parse()
{
    std::string line;
    Dialogue * dialogue = nullptr;
    std::vector < Dialogue * > stack;
    std::vector < std::pair < Dialogue *, Dialogue * >> fix;
   
    while( std::getline( std::cin, line ) )
    {
        size_t tabs = line.find_first_not_of( "\t" );
        if( tabs == std::string::npos )
             continue; // pusta linia - ignoruj
       
        // Aktualna linia jest mniej wcięta niż poprzednia. Przywróć stan do dialogu na poziomie wynikającym z wcięcia
        while( tabs < stack.size() )
        {
            // Brak opcji w aktualnie zamykanym dialogu - skopiuj opcje z dialogu nadrzędnego na koniec parsowania
            if( dialogue->options.empty() )
                 fix.emplace_back( dialogue, stack.back() );
           
            dialogue = stack.back();
            stack.pop_back();
        }
       
        if( line[ tabs ] == '-' )
        {
            if( tabs != stack.size() || !dialogue )
                 return false; // Opcja nie może być inaczej wcięta i musi byc pod jakimś dialogiem
           
            DialogueOption opt;
            opt.text = line.substr( tabs + 1 );
            opt.nextDialogueID = 0; // na razie nieznane
            dialogue->options.push_back( opt );
        }
        else
        {
            if( tabs == stack.size() )
            {
                if( dialogue )
                     return false; // druga definicja tego samego dialogu
               
            }
            else
            if( tabs == stack.size() + 1 )
            {
                // dialog poziom niżej. Zapisz aktualny na stosie żeby można było do niego wrócić
                stack.push_back( dialogue );
            }
            else
                 return false; // zbyt głębokie wcięcie
           
            dialogue = createDialogue();
            dialogue->text = line.substr( tabs );
           
            if( !stack.empty() )
            {
                auto & options = stack.back()->options;
                if( options.empty() )
                     return false; // Brak opcji do połączenia dialogu
               
                options.back().nextDialogueID = dialogue->id;
            }
        }
    }
   
    // Parsowana gramatyka nie ma jawnych zamknięć, więc potencjalnie są otwarte dialogi
    if( dialogue )
    while( !stack.empty() )
    {
        // Brak opcji w aktualnie zamykanym dialogu - skopiuj opcje z dialogu nadrzędnego na koniec parsowania
        if( dialogue->options.empty() )
             fix.emplace_back( dialogue, stack.back() );
       
        dialogue = stack.back();
        stack.pop_back();
    }
   
    for( auto & f: fix )
         f.first->options = f.second->options;
   
    return true;
}

int main()
{
    if( !parse() )
         std::cout << "Blad parsowania\n";
   
    for( auto * d: g_dialogues )
    {
        std::cout << d->id << ": " << d->text << '\n';
        for( auto & opt: d->options )
             std::cout << "\t" << opt.nextDialogueID << ", " << opt.text << '\n';
       
        std::cout << '\n';
    }
}

#include <iostream>
#include <string>
#include <vector>
#include <functional>
#include <fstream>
#include <conio.h>
using namespace std;

class DialogueOption {
public:
    std::string text; // na razie bez W
    int nextDialogueID;
    std::function < bool() > conditions; // warunki, które muszą być spełnione by dialog się wyświetlił
    std::function < void() > actions; // akcje, które zostaną wywołane gdy dialog zostanie wybrany
};

class Dialogue {
public:
    int id;
    std::string text; // na razie bez W
    std::vector < DialogueOption > options;
    std::function < void() > actions; // akcje, które zostaną wywołane gdy dialog zostanie wybrany
   
    Dialogue( int id, string text ) {
        this->id = id;
        this->text = text;
    }
};

// Zarządzanie pamięcią jest poza zakresem przykładu
std::vector < Dialogue * > dialogues;

bool parse()
{
    std::string line;
    Dialogue * dialogue = nullptr;
    std::vector < Dialogue * > stack;
    std::vector < std::pair < Dialogue *, Dialogue * >> fix;
   
    std::ifstream file;
    file.open( "dial.txt" );
   
    if( !file )
         std::cout << "file open failed\n";
   
    while( getline( file, line ) )
    {
        size_t tabs = line.find_first_not_of( "\t" );
        if( tabs == std::string::npos )
             continue; // pusta linia - ignoruj
       
        // Aktualna linia jest mniej wciêta ni¿ poprzednia. Przywróæ stan do dialogu na poziomie wynikaj¹cym z wciêcia
        while( tabs < stack.size() )
        {
            // Brak opcji w aktualnie zamykanym dialogu - skopiuj opcje z dialogu nadrzêdnego na koniec parsowania
            if( dialogue->options.empty() )
                 fix.emplace_back( dialogue, stack.back() );
           
            dialogue = stack.back();
            stack.pop_back();
        }
       
        if( line[ tabs ] == '-' )
        {
            if( tabs != stack.size() || !dialogue ) {
                file.close();
                std::cout << "Opcja nie moze byc inaczej wcieta i musi byc pod jakimœ dialogiem\n";
                return false;
            }
           
           
            DialogueOption opt;
            opt.text = line.substr( tabs + 1 );
            opt.nextDialogueID = 0; // na razie dialog jest dialogiem głównym
            dialogue->options.push_back( opt );
        }
        else
        {
            if( tabs == stack.size() )
            {
                if( dialogue ) {
                    file.close();
                    std::cout << "druga definicja tego samego dialogu\n";
                    return false;
                }
               
               
            }
            else
            if( tabs == stack.size() + 1 )
            {
                // dialog poziom nizej. Zapisz aktualny na stosie zeby mozna bylo do niego wrócic
                stack.push_back( dialogue );
            }
            else {
                file.close();
                std::cout << "zbyt glebokie wciecie\n";
                return false;
            }
           
            dialogue = new Dialogue( dialogues.size(), line.substr( tabs ) );
            dialogues.push_back( dialogue );
           
            if( !stack.empty() )
            {
                auto & options = stack.back()->options;
                if( options.empty() ) {
                    file.close();
                    std::cout << "Brak opcji do polaczenia dialogu\n";
                    return false;
                }
               
               
                options.back().nextDialogueID = dialogue->id;
            }
        }
    }
    file.close();
   
    // Parsowana gramatyka nie ma jawnych zamkniec, wiec potencjalnie sa otwarte dialogi
    if( dialogue )
    while( !stack.empty() )
    {
        // Brak opcji w aktualnie zamykanym dialogu - skopiuj opcje z dialogu nadrzednego na koniec parsowania
        if( dialogue->options.empty() )
             fix.emplace_back( dialogue, stack.back() );
       
        dialogue = stack.back();
        stack.pop_back();
    }
   
    for( auto & f: fix )
         f.first->options = f.second->options;
   
    return true;
}

Dialogue * getDialogue( int id ) {
   
    for( auto * d: dialogues ) {
        if( d->id == id )
             return d;
       
    }
   
    std::cout << "dialog " << id << " not exists\n";
    return nullptr;
}

int main()
{
    if( !parse() )
         std::cout << "error load dialogues\n";
   
    /*
    for( auto * d: dialogues)
    {
        std::cout << d->id << ": " << d->text << '\n';
        for( auto & opt: d->options )
             std::cout << "\t" << opt.nextDialogueID << ", " << opt.text << '\n';
       
        std::cout << '\n';
    }
    */
   
    int dialogueID = 0;
    while( dialogueID != - 1 ) {
       
        Dialogue * dial = getDialogue( dialogueID );
        if( dial->actions )
             dial->actions();
       
        std::cout << dial->text << "\n";
       
        for( auto & d: dial->options ) {
            if( !d.conditions ||( d.conditions && d.conditions() ) )
                 std::cout << d.nextDialogueID << " " << d.text << "\n";
           
        }
       
       
        cin >> dialogueID;
        cout << "\n";
    }
}