Show me some fireworks!

Question

Given, in any way and order,

• dimensions (in whichever order you want)

• a probability (in whatever format you want)

• number of iterations (you may choose whether to count the initial state or not)

do one of the following:

• animate, or

• output each step of, or

• return a list of states of

a spaces-filled sky of those dimensions.

For each iteration:

• every sky character has the given probability of becoming a *

• the eight characters that surround any * become
  \ | /
-      -
/ | \, if they don't become stars, however,

• if a character is within range of two *s, make it an X

Example

The 7×22 sky (frame for clarity only – don't output the frame)

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

could with 1% probability become

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

and the next step

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

and then

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

and

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

and so on

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

Answer 1

ES6, 520 496 bytes

Clipping and everything else should work now.

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

View animation!

Saved 24 bytes thanks to Zacharý's tip.

Old solution, 478 bytes (with clipping bug)

I think I got all the rules correct, however the solution has a clipping problem where everything exiting right/left wraps around one line lower/higher on the opposite side.

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

View old.

Answer 2

APL (Dyalog), 65 chars or 71 bytes*

Prompts for dimensions (rows, columns), then for iterations (not counting initial state), then for probability (as n in ¹⁄ₙ).

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

Try it online!

⎕⍴'' prompt for input and use that to reshape an empty string, padding with spaces as needed

⊢ yield that

…⍣⎕ prompt for input and apply the following function on the above (⍵) that many times:

 …{…} derive a function using the below function as operand (⍺⍺), as follows:

  ⎕←⍵ print the argument

  ⍺⍺ apply the following function:

   …⌺3 3 apply the following function on each element's 3×3 Moore neighborhood:

    ⎕{…} get input and use it as operand (⍺⍺) to derive a new function

     ?⍺⍺ random integer among the first ⍺⍺ integers

     1= Boolean if equal to one

     : if true:

      '*' return a star

     ⋄ else:

      ,⍵ ravel (flatten) the argument (the Moore neighborhood)

      4⌽ rotate it cyclically four steps to the left

      1↓ drop one element (the original center)

      '*'= Boolean list where equal to a star

      b← store that as b

      +/ sum that

      2≤ Boolean if two or higher

      : if true:

       'X' return an X

      ⋄ else:

       b/'-/|\\|/-' use the b to to filter the string

       ⊃ pick the first one, if there are none, pick the prototype (a space)

---

^{* To run in Dyalog Classic, simply replace ⌺ with ⎕U233A} .