Conway's Game Of Life

[DarkerLine]

here's my code, this seems to not work as well as what did before, I must've missed some optimization. If anyone finds it please say so.

[alexrudd]

[Jutt]

Wouldn't it be smaller and faster to do this?

For(I,min(L_X)-1,1+max(L_X
For(J,min(L_Y)-1,1+max(L_Y


Also, I tested your program and it doesn't seem to simulate the real game of life.
did you use other rules?

[axcho]

Here's the life program I made. I know it is not extremely efficient. That's what lead to this topic in the first place. I doubt that any small-scale optimization could dramatically improve the speed, which is why I've been trying to come up with better ways of doing it. It simulates a 7x7 life grid bounded by OFF cells.

[DarkerLine]

[Jutt]

[Ray Kremer]

[axcho]

[DarkerLine]

Yes, I've realized that. I think I tested it on my 89 and thought that if the 89 has such a flaw the 83+ would too.
Updated:

[smileyguy597]

what do the underscors mean

[alexrudd]

We use them in conjunction with an L to stand for the little L thingy for lists.
L_1 = list one (small font is not working for me, don't ask.)

[Arcane Wizard]

[size=14] capital l works too.

[DarkerLine]

not in code blocks it doesn't.

Anyway, back on topic about programming the game of life. I think that all of us can program in the simple rules; the real question is how to store the data.

I. something fixed, like a matrix.

the easiest way to do this is to use the graph screen and pxl-Test. You will die of boredom if you check each of the 63*95 pixels each loop, so you should maybe keep track of the minimum and maximum X and Y of the shape. Something nice about this way is: pxl-Test(Y,X is a very fast way (comparatively) of checking if (X,Y) is filled.

But, you will need to store the next generation separate. To do this, you can use a matrix, NOT recommended, you can use two lists like in method II below, or use Pic variables to keep 2 copies of the graph screen.

If you do the last, it would be something like this:
StorePic 1 //before loop
ClrDraw
StorePic 2
RecallPic 1

//inside loop
If <the pixel should be on next generation>
Then
ClrDraw
RecallPic 2
pxl-On(Y,X
StorePic 2
ClrDraw
RecallPic 1
End

This is hard work, takes a lot of your time drawing, and is not recommended.

II. Keep track only of the coordinates of the ON cells.

The simplest way to do this is storing the x-coordinates to LX and the y-coordinates to LY. That way, you can draw the whole thing with Plot1(Scatter,X,Y,. and DispGraph (like my program).

Now is the question, how to choose which cells to check for being ON in the next generation. This method has to be both fast (so we don't waste too much time choosing) and effective (so we don't choose many cells we know are going to be OFF)

First of all, you can just check all the cells from min(LX)-1 to max(LX)+1 and min(LY)-1 to max(LY)+1. Good for compact shapes, not so good for something sparse that has a few cells over a large area.

You can do the same thing, but skip values of X such that min(LX-X)>1 (I am assuming you check cells first by X and then by Y). This solves the problem of a sparce shape with many gaps along the X-axis. If you want to do the same thing for the Y-axis, you should do it outside the loop.

min(L_X)-1->M
min(L_Y)-1->N
max(L_X)+1->O
max(L_Y)+1->P


seq(min(LX-X)<2),X,M,O->U
seq(min(LY-Y)<2),Y,N,P->V
For(X,M,O
If LU(X-M+1
Then
For(Y,N,P
If LV(Y-N+1
Then
<check (X,Y)>
End
End
End
End

Finally, you could go through the list itself and only check neighbors.

For(I,1,dim(LX
For(X,-1,1
For(Y,-1,1
<check (X+LX(I), Y+LY(I))>
End
End
End
Trouble with this is, there's no easy way to check for overlap (or maybe there is, but it will take more time than just checking the cell several times), and in a dense figure this will really make the difference.

Oh, and if you set up the screen right you can use pxl-Test( for checking the points.

[axcho]

Thanks for going through and explaining all that stuff, Sir Robin. That's a great way to use Plotsprites. I'll try out your program soon.

[Toksyuryel]

Well, unless you absolutely have to use smileys in your post, you don have to use a code block problem solved

[DarkerLine]

Hm, I wonder if you can easily check the density of the shape.

dim(LX)/(max(LX)-min(LX))/(max(LY)-min(LY
If Ans > /some threshold/
Then //the shape is dense, use one method
For(X,min(LX)-1,1+max(LX
For(Y,min(LY)-1,1+max(LY
sum(1=max(abs(LX-X,LY-Y
If 3=Ans or 3=Ans-max(LX=X and LY=Y
Then
S+1->S
X->LP(S
Y->LQ(S
End
End
End
Else //If the shape isn't dense, use another method
For(D,-1,1
LX+D->U
For(E,-1,1
LY+E->V
For(I,1,dim(LX
LU(I ->X
LV(I->Y
sum(1=max(abs(LX-X,LY-Y
If 3=Ans or 3=Ans-max(LX=X and LY=Y
Then
S+1->S
X->LP(S
Y->LQ(S
End
End
End
End
End

The tough part is figuring out a good threshold for D.

[axcho]

I tried out your (Sir Robin's) program a several weeks ago, but it didn't work because I didn't know how to set up the screen correctly. What code would you use to initialize the program?

[DarkerLine]

Just storing all x-coordinates to L_X and all y-coordinates to L_Y.

[BarrenSoul]

soo.... whats the final code we ended up with? I want to test teh speed vs mine

[DarkerLine]

The one in my last post, I think...