Como um circuito ou sistema de energia (como redstone no Minecraft) deve ser implementado

Eu quero implementar um sistema de energia como o sistema redstone em minecraft.

Eu tenho n fontes de energia e m cabos. Se eu desconectar a fonte de alimentação ou um cabo, o circuito deve desligar.

Como evito círculos? Se cada cabo com o status "ligado" alimenta os cabos próximos, posso criar círculos infinitos onde não há fonte de energia envolvida (veja a imagem). Além disso, o site é executado em T = m

Eu poderia enviar energia através do gráfico, iniciando em todas as fontes de energia e em cada chamada de atualização eu desligava todos os cabos. O problema é que ele roda em T = n * m.

Existe uma prática recomendada? No Minecraft, o sistema redstone era muito lento, então acho que esqueci alguma coisa.

EDIT: O sistema deve funcionar sem uma deterioração baseada na distância.

Propagação recursiva. Por exemplo, você tem uma lâmpada conectada por N objetos do cabo a uma bateria. A lâmpada pergunta ao Nésimo cabo se está ligada (este é o cabo conectado diretamente à lâmpada). O cabo Nésimo pergunta ao cabo N-1 se está ligado e assim por diante. Cada vez que um objeto é perguntado se está energizado ou não, ele define uma lastEvaluatedvariável para o tempo de quadro atual. A recursão atinge um nó final, como uma bateria, ou quando atinge um objeto que já foi avaliado nesse quadro (isso evita a recursão infinita). Essas propagações ocorrem apenas quando o sistema é alterado. As alterações incluem adicionar / remover peças ou interruptores que estão sendo alternados.

Não há decaimento de distância ou restrições semelhantes neste sistema. Eu o usei para criar um simulador de portão lógico e funciona para vários exemplos de lógica, como um flip-flop.

Em minecraft, há um decaimento baseado na distância com uma distância muito curta (16 blocos de alcance).

O que você precisa é um teste de conectividade entre gráficos .

Uma maneira de fazer isso seria pegar repetidamente cada extremidade e combinar os nós conectados e em um único nó. Depois que todas as arestas desaparecerem, você terminará com um nó para cada rede. Então enviar energia é trivial.

Um bloco energizado possui várias conexões de entrada / saída, mas, no ponto inicial, não sabemos quando é entrada ou saída.

Cada bloco possui uma "Voltagem", que é a energia que chega a ele menos os perdidos / usados.

Um bloco energizado fornecerá energia a todos os blocos circundantes e cada bloco terá como entrada a tensão mais alta dos blocos circundantes. Você também pode complicar o sistema definindo uma intensidade, mas ficarei com a tensão apenas por simplicidade.

Toda vez que uma alteração é realizada no circuito, adicionando / removendo blocos, ou pelo próprio circuito, a alteração precisa ser propagada para todo o circuito até a estabilidade.

Eu sugiro que você crie uma interface para qualquer objeto energizado (cubo no 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;
};

Portanto, supondo que você implemente os addSibling e removeSibling, a parte mais importante é a função de propagação:

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);
    }
}

Como solução recursiva, cada bloco deve reduzir um pouco a energia, nunca aumentá-la. A fonte de energia pode definir um valor fixo, mas nunca aumenta com base nas entradas. Isso não deve ser um problema, pois todo sistema "real" funciona dessa maneira.