Dado, de qualquer maneira e ordem,

• dimensões (na ordem que você desejar)

• uma probabilidade (no formato que você quiser)

• número de iterações (você pode optar por contar ou não o estado inicial)

fazer um dos seguintes:

• animar ou

• produzir cada etapa de, ou

• retornar uma lista de estados de

um céu cheio de espaços dessas dimensões.

Para cada iteração:

• todo personagem do céu tem a probabilidade de se tornar um *

• os oito caracteres que cercam qualquer um *se tornam
  \ | /
-      -
/ | \, se não se tornarem estrelas, no entanto,

• se um personagem estiver dentro do intervalo de dois *s, faça dele umX

Exemplo

O céu 7 × 22 (quadro apenas para maior clareza - não produza o quadro)

┌──────────────────────┐
│                      │
│                      │
│                      │
│                      │
│                      │
│                      │
│                      │
└──────────────────────┘

poderia com 1% de probabilidade tornar-se

┌──────────────────────┐
│  *                   │
│                      │
│                      │
│                      │
│                      │
│           *          │
│                      │
└──────────────────────┘

e o próximo passo

┌──────────────────────┐
│ - - *                │
│ /|\                  │
│          *           │
│                      │
│          \|/         │
│          - -         │
│          /|\         │
└──────────────────────┘

e depois

┌──────────────────────┐
│    - -               │
│    /|\  \|/          │
│         - -          │
│         /|\          │
│                      │
│      * *             │
│                      │
└──────────────────────┘

e

┌──────────────────────┐
│                      │
│                      │
│                      │
│                      │
│     \|X|/            │
│     - X -            │
│     /|X|\          * │
└──────────────────────┘

e assim por diante

┌──────────────────────┐
│                      │
│                      │
│                      │
│                   *  │
│                      │
│                   \|/│
│                   - -│
└──────────────────────┘

ES6, 520 496 bytes

Recorte e tudo o mais deve funcionar agora.

(w,h,p,i,r=0,s=($=>{while(++r<i)for(j=0,_=$[r]=[],z=$[r-1]||[];j<w*h;){k=j+1,l='*',c=0
n=(j%w&&z[j-1]==l&&++c)|(k%w&&z[k]==l&&++c)?'-':' '
n=(z[j-w]==l&&++c)|(z[j+w]==l&&++c)?'|':n
n=(j%w&&z[j-w-1]==l&&++c)|(k%w&&z[k+w]==l&&++c)?'\\':n
n=(k%w&&z[k-w]==l&&++c)|(j%w&&z[j+w-1]==l&&++c)?'/':n
_[j++]=Math.random()<p?l:c>1?'X':n}})(x=[])||x)=>{c=document.body.children[0],r=0;while(++r<i)setTimeout((k=0)=>{for(r++,c.innerHTML='';k<h;)c.innerHTML+=s[r].slice(k*w,++k*w).join('')+'\n'},90*r);r=0}

Ver animação!

Economizou 24 bytes graças à dica de Zacharý.

Solução antiga, 478 bytes (com bug de recorte)

Acho que consegui todas as regras corretas, no entanto, a solução tem um problema de recorte, onde tudo que sai da direita / esquerda envolve uma linha mais abaixo / mais no lado oposto.

(w,h,p,i,r=0,s=($=>{while(++r<i)for(j=0,_=$[r]=[],z=$[r-1]||[];j<w*h;){c=0
n=(z[j-1]=='*'&&++c)|(z[j+1]=='*'&&++c)?'-':' '
n=(z[j-w]=='*'&&++c)|(z[j+w]=='*'&&++c)?'|':n
n=(z[j-w-1]=='*'&&++c)|(z[j+w+1]=='*'&&++c)?'\\':n
n=(z[j-w+1]=='*'&&++c)|(z[j+w-1]=='*'&&++c)?'/':n
_[j++]=Math.random()<p?'*':c>1?'X':n}})(x=[])||x)=>{c=document.body.children[0],r=0;while(++r<i)setTimeout((k=0)=>{for(r++,c.innerHTML='';k<h;)c.innerHTML+=s[r].slice(k*w,++k*w).join('')+'\n'},90*r);r=0}

Vista antiga.

APL (Dyalog) , 65 caracteres ou 71 bytes *

Solicita dimensões (linhas, colunas), depois iterações (sem contar o estado inicial) e, em seguida, probabilidade (como n em ¹⁄ ₙ ).

⎕{1=?⍺⍺:'*'⋄2≤+/b←'*'=1↓4⌽,⍵:'X'⋄⊃b/'-/|\\|/-'}⌺3 3{⍺⍺⎕←⍵}⍣⎕⊢⎕⍴''

Experimente online!

⎕⍴'' pronta para uso de entrada e que, para r eshape uma cadeia vazia, preenchimento com espaços conforme necessário

⊢ produzir isso

… Solicite a⍣⎕  entrada e aplique a seguinte função acima ( ⍵ ) várias vezes:

 ... {... } derivar uma função usando a função abaixo como operando ( ⍺⍺ ), como segue:

  ⎕←⍵ imprima o argumento

  ⍺⍺ aplique a seguinte função:

   … ⌺3 3 Aplique a seguinte função no bairro Moore 3 × 3 de cada elemento:

    ⎕{… } Obtenha entrada e use-a como operando ( ⍺⍺ ) para derivar uma nova função

     ?⍺⍺ número inteiro aleatório entre os primeiros ⍺⍺ números inteiros

     1= Booleano se igual a um

     : se for verdade:

      '*' devolver uma estrela

     ⋄ outro:

      ,⍵ percorrer (achatar) o argumento (o bairro de Moore)

      4⌽ gire ciclicamente quatro etapas para a esquerda

      1↓ solte um elemento (o centro original)

      '*'= Lista booleana onde igual a uma estrela

      b← armazene isso como b

      +/ soma isso

      2≤ Booleano se dois ou superior

      : se for verdade:

       'X' retornar um X

      ⋄ outro:

       b/'-/|\\|/-' use b para filtrar a string

       ⊃ escolha o primeiro, se não houver, escolha o protótipo (um espaço)

^{* Para executar no Dyalog Classic, basta substituir ⌺por⎕U233A} .