Dado, de cualquier manera y orden,

• dimensiones (en el orden que desee)

• una probabilidad (en cualquier formato que desee)

• número de iteraciones (puede elegir contar el estado inicial o no)

realice una de las siguientes acciones:

• animar o

• dar salida a cada paso de, o

• devolver una lista de estados de

un cielo lleno de espacios de esas dimensiones.

Para cada iteración:

• cada personaje del cielo tiene la probabilidad dada de convertirse en un *

• Sin embargo, los ocho personajes que rodean a cualquiera se *convierten
  \ | /
-      -
/ | \, si no se convierten en estrellas,

• si un personaje está dentro del rango de dos *s, conviértalo en unX

Ejemplo

El cielo de 7 × 22 (marco solo para claridad, no muestre el marco)

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

podría con 1% de probabilidad convertirse

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

y el siguiente paso

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

y entonces

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

y

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

y así

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

ES6, 520 496 bytes

Recorte y todo lo demás debería funcionar ahora.

(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 animación!

Guardado 24 bytes gracias a la sugerencia de Zacharý.

Solución anterior, 478 bytes (con error de recorte)

Creo que tengo todas las reglas correctas, sin embargo, la solución tiene un problema de recorte donde todo lo que sale a la derecha / izquierda se envuelve alrededor de una línea más abajo / más arriba en el lado opuesto.

(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}

Ver viejo.

APL (Dyalog) , 65 caracteres o 71 bytes *

Solicita dimensiones (filas, columnas), luego iteraciones (sin contar el estado inicial), luego probabilidad (como n en ¹⁄ ₙ ).

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

Pruébalo en línea!

⎕⍴'' pronta para la entrada y el uso que para r eshape una cadena vacía, el relleno con espacios según sea necesario

⊢ ceder eso

… ⍣⎕ Solicitar entrada y aplicar la siguiente función en el anterior ( ⍵ ) que muchas veces:

 ... {... } deriva una función utilizando la siguiente función como operando ( ⍺⍺ ), de la siguiente manera:

  ⎕←⍵ imprime el argumento

  ⍺⍺ aplicar la siguiente función:

   … ⌺3 3 Aplique la siguiente función en el vecindario 3 × 3 Moore de cada elemento:

    ⎕{… } Obtenga entrada y úsela como operando ( ⍺⍺ ) para derivar una nueva función

     ?⍺⍺ entero aleatorio entre los primeros ⍺⍺ enteros

     1= Booleano si es igual a uno

     : si es verdad:

      '*' devolver una estrella

     ⋄ más:

      ,⍵ desentrañar (aplastar) el argumento (el barrio de Moore)

      4⌽ gírelo cíclicamente cuatro pasos hacia la izquierda

      1↓ soltar un elemento (el centro original)

      '*'= Lista booleana donde es igual a una estrella

      b← almacenar eso como b

      +/ suma que

      2≤ Booleano si dos o más

      : si es verdad:

       'X' devolver una X

      ⋄ más:

       b/'-/|\\|/-' usa la b para filtrar la cadena

       ⊃ elige el primero, si no hay ninguno, elige el prototipo (un espacio)

^{* Para ejecutar en Dyalog Classic, simplemente reemplácelo ⌺con⎕U233A} .