Come dovrebbe essere implementato un circuito o un sistema di alimentazione (come la pietra rossa in Minecraft)

Voglio implementare un sistema di alimentazione come il sistema redstone in Minecraft.

Ho n fonti di alimentazione e m cavi. Se scollego la fonte di alimentazione o un cavo, il circuito dovrebbe spegnersi.

Come posso evitare le cerchie? Se ogni cavo con lo stato "on" alimenta i cavi vicini, posso creare cerchi infiniti in cui non è coinvolta alcuna fonte di alimentazione (vedi immagine). Inoltre il sito è che funziona in T = m

Potrei inviare la scarica di energia attraverso il grafico a partire da ogni fonte di alimentazione e in ogni chiamata di aggiornamento spengo ogni cavo. Il problema è che funziona in T = n * m.

Esiste una buona pratica? In Minecraft il sistema di pietra rossa era molto lento, quindi penso di aver trascurato qualcosa.

EDIT: il sistema dovrebbe funzionare senza un decadimento basato sulla distanza.

Propagazione ricorsiva. Ad esempio, hai una lampada collegata da oggetti cavo N a una batteria. La lampada chiede all'ennesimo cavo se è alimentata (questo è il cavo collegato direttamente alla lampada). L'ennesimo cavo chiede quindi al cavo N-1 se è alimentato e così via. Ogni volta che viene chiesto a un oggetto se è alimentato o meno, imposta una lastEvaluatedvariabile sul tempo di frame corrente. La ricorsione finisce in fondo su un nodo finale, come una batteria, o quando raggiunge un oggetto che è già stato valutato in quel frame (questo evita la ricorsione infinita). Queste propagazioni si verificano solo quando il sistema cambia. Le modifiche includono l'aggiunta / rimozione di parti o interruttori da attivare.

Non vi è alcuna riduzione della distanza o restrizioni simili con questo sistema. L'ho usato per creare un simulatore di gate logici e funziona per vari esempi logici come un flip-flop.

In Minecraft c'è un decadimento basato sulla distanza con una distanza di decadimento molto breve (intervallo di 16 blocchi).

Cosa ti serve un test di connettività tra grafici .

Un modo per farlo sarebbe prendere ripetutamente ogni fronte e combinare i nodi collegati e in un singolo nodo. Dopo che tutti i bordi sono stati eliminati, verrà visualizzato un nodo per ciascuna rete. Quindi inviare il potere è banale.

Un blocco alimentato ha diverse connessioni input / output, ma a un punto iniziale non sappiamo quando è input o output.

Ogni blocco ha una "Tensione" che è l'energia che arriva ad esso meno il perso / usato.

Un blocco alimentato fornirà energia a tutti i blocchi circostanti e ogni blocco prende come input la tensione più alta dai blocchi circostanti. Potresti anche complicare il sistema definendo un'intensità, ma rimarrò con la tensione solo per semplicità.

Ogni volta che viene eseguita una modifica al circuito, aggiungendo / rimuovendo blocchi o dal circuito stesso, la modifica deve essere propagata a tutto il circuito fino alla stabilità.

Ti suggerirei di progettare un'interfaccia per qualsiasi oggetto alimentato (cubo in MC):

class PowerInterface
{
protected:
    std::vector<shared_ptr<PowerInterface>> sibling;

    double energy=0;
    bool   isActive = false;

    virtual void propagate(double inEnergy) = 0;

    virtual void addSibling(shared_ptr<PowerInterface> newSibling) = 0;
    virtual void removeSibling( shared_ptr<PowerInterface> remSibling) =0;
};

Supponendo quindi di implementare addSibling e removeSibling, la parte più importante è la funzione di propagazione:

void PoweredCube::propagate( double inEnergy ) 
{
    // Define the behaviour
    energy = inEnergy-1.0; // Normal device
    energy = inEnergy-0.1; // Normal cable
    energy = 10.0;         // Normal source of power.

    if (energy<0.0)
    { 
        energy = 0.0;
        isActive = false;
        // No energy, so do not propagate anymore
        return;
    }
    isActive = true;

    // Propagate
    for (auto &s: sibling)
    {
        // Only propagate to sibling with less energy. 
        if (energy > s->energy) s->propagate( energy);
    }
}

Come soluzione ricorsiva, ogni blocco dovrebbe ridurre un po 'l'energia, non aumentarla mai. La fonte di energia può impostare un valore fisso, ma non aumentare mai in base agli input. Questo non dovrebbe essere un problema poiché tutti i sistemi "reali" funzionano in questo modo.