Conway's Game Of Life

[retepsnikrep]

I incorporated all those ideas and it is now running at over 13hz v 3hz before. Well done Team!

The Colour Array is only 8 elements and holds the colour of any adjacent cells to the one being tested.



Which of these two is technically quickest? Both seem to work well but I haven't got timing set up yet.

  Temp = Counter // 32

  If Temp = 0 THEN
    lefedge = 1
  ENDIF

  IF Temp = 31 THEN
    rigedge = 1
  ENDIF

or

Temp = Counter & 65504
If Temp = 0 THEN
lefedge = 1
ENDIF


IF Temp = 31 THEN
rigedge = 1
ENDIF

Here we have it at 13hz..

[richard]

hmm i think i got that the wrong way round
try Temp = Counter & 31

the bitwise and is faster than a // which uses a divide

i wonder about led/LedNew arrays as byte . a cell is either dead or not dead a bit can store that info

[HenrikOlsson]

Great that it all still works!
I timed it and Richards is a quite a bit quicker. On my test setup it went from 67 to 48ms which is not surprising since, generally speaking, anything involving division is a killer.
I also found that I had missed one AND statement, replaced that with nested IFs and I'm now measuring 44.7ms

[retepsnikrep]

That all works and I changed the AND statements.
Maybe 15hz now but I need to do some proper timing.

I wonder about led/LedNew arrays as byte . a cell is either dead or not dead a bit can store that info

The arrays also store LED RGB colour and brightness information so one bit is not sufficient.
The colour of a new cell is dependent on the adjacent three populated cells that spawn it.

[HenrikOlsson]

From 3 to 15 frames per second in a couple of hours, I call that improvement.
At one place (at least) you first do IF LED[Counter] = 0 and then a couple of lines further down you do IF LED[Counter] > 0 which seems a bit of a wate since you already know if it IS 0 and if it's not it's got to be > 0 (since it can't be negative in case you're not using LONGs). There's also Population = Population + 1 in 8 places, can you move that outside each of the IF/THEN statements and only have ONE of them? That likely won't increase performance but will save space (if that matter at all).

We're probably talking microseconds here but since it all executes 1024 times per frame it does add up.

Anyhow, nice job and keep those updates and videos coming!

[retepsnikrep]

From 3 to 15 frames per second in a couple of hours, I call that improvement!

Thanks to all who have contributed so far.

I will post the complete code and circuit schematic etc when I have it finished and we can't eek out any more speed.

I tweaked if LED[Counter] = 0 and that gives another HZ I think.

Code space is not an issue. RAM Might be later.

[richard]

last time i played with "life" i never found a way to detect a stable repetitive cycling pattern.
are you determining if boring stuck patterns ensue ?

[retepsnikrep]

last time i played with "life" i never found a way to detect a stable repetitive cycling pattern.
are you determining if boring stuck patterns ensue ?

Currently i'm using three things.

1) A simple maximum number of generations reset limit (500). That catches everything.

2) A simple live cell counter. If it's zero then it resets.

3) A pseudo checksum which seem to work quite well.

A word variable to which the address of every populated cell is added, it may overflow many times, and after all 1024 cells have been generated/examined you end up with a number.
It also calculates the checksum for the next generation and if it matches the previous generation then it probably means we have a stuck pattern and resets.

I've been testing this for thousands of patterns and generations now and it works well.
It only falls back on the hard generation limit with huge repeating patterns that cycle over several generations.
It detects small oscillators and stuck patterns etc quite well.

I appreciate it is possible for two patterns to have the same checksum but the odds must be very very small.

Cross post with Richard LOL!! Basically what I'm doing but I'm not quite as clever as the 'Life' experts.

[retepsnikrep]

For the big evaluation routine we currently have this giving about 15hz

'----------------------- Also creating a newled data array to be displayed on next generation -------------

FOR counter = 0 TO 1023

	population = 0 :topedge	= 0 :botedge = 0 :lefedge = 0 :rigedge = 0

'Grid Edge Detection
	
	IF counter < 32 THEN botedge = 1

	IF counter > 991 THEN topedge = 1
	
'*******************************************************************************	  	
	
    TempCount = Counter & 31
    If TempCount = 0 THEN
    lefedge = 1
    ENDIF


    IF TempCount = 31 THEN
    rigedge = 1
    ENDIF	
	
'*******************************************************************************		

'Grid Evaluation	 


CntPlus33 = Counter + 33
CntPlus32 = Counter + 32
CntPlus31 = Counter + 31
CntPlus1 = Counter +1

CntMinus33 = Counter - 33
CntMinus32 = Counter - 32
CntMinus31 = Counter - 31
CntMinus1 = Counter - 1	        	
	
	IF led[CntMinus1] > 0 THEN
      IF counter > 0 THEN
	    Colour[population] = led[CntMinus1]
		population = population + 1
	  ENDIF
	ENDIF
	
	IF led[CntPlus1] > 0 THEN
      IF counter < 1023 THEN
	    Colour[population] = led[CntPlus1]
		population = population + 1  		
       ENDIF
    ENDIF
	
	IF botedge = 0 THEN
		IF led [CntMinus31] > 0 THEN
		    Colour[population] = led[CntMinus31]
			population = population + 1			
		ENDIF
		IF led [CntMinus32] > 0 THEN
		    Colour[population] = led[CntMinus32]  
			population = population + 1
		ENDIF
		IF  rigedge = 0 then
            if led [CntMinus33] > 0 THEN
		    Colour[population] = led[CntMinus33]
			population = population + 1
			endif
		ENDIF
	ENDIF
	
	IF topedge = 0 THEN
		IF led [CntPlus31] > 0 THEN
		    Colour[population] = led[CntPlus31]
			population = population + 1
		ENDIF
		IF led [CntPlus32] > 0 THEN
		    Colour[population] = led[CntPlus32]
			population = population + 1
		ENDIF
		IF  rigedge = 0 then 
            if led [CntPlus33] > 0 THEN 
		    Colour[population] = led[CntPlus33]
			population = population + 1
			endif
		ENDIF
	ENDIF       

    lednew[counter] = led[counter]
	
	IF led[counter] = 0 THEN
		IF population = 3 THEN
		
		    if Colour[0] = Colour[1] then
		    lednew[counter] = Colour[0]
		    
		    elseif Colour[0] = Colour[2] then
            lednew[counter] = Colour[0]
            
            elseif Colour[1] = Colour[2] then
            lednew[counter] = Colour[1]
            
    	    endif   	
			
		ENDIF
	else   	
		IF population > 3 OR population < 2 THEN
			lednew[counter] = 0
		ENDIF
			
	ENDIF

NEXT counter

[HenrikOlsson]

This shaved another 4ms off here, instead of:

IF population > 3 OR population < 2 THEN
  lednew[counter] = 0
ENDIF

Do:

IF Population > 3 THEN LEDNew[Counter] = 0
IF Population < 2 THEN LEDNew[Counter] = 0

We're trading readabillity for performance here...