How do you detect snowflake collision?

Hmm, you could use a matrix (it uses indices the same as pixel coords or homescreen coordinates, so "Y" then "X").

This way, the program doesn't start to slow down as more snow flakes are added. Basically, just create an 8*16 matrix (it will be huge, being the size of a 128 element list). Then you can just check if a snow flake is already in a spot as if you were reading homescreen coordinates:
[A](Y,X

This might speed things up a bit (not sure).

Hmm, you could use a matrix (it uses indices the same as pixel coords or homescreen coordinates, so "Y" then "X").

This way, the program doesn't start to slow down as more snow flakes are added. Basically, just create an 8*16 matrix (it will be huge, being the size of a 128 element list). Then you can just check if a snow flake is already in a spot as if you were reading homescreen coordinates:

Code: [Select]

[A](Y,X

This might speed things up a bit (not sure).

You're right! Now, it will only take 128 iterations of a For( loop (plus a little bit extra time) to move and display the snowflakes, not to mention to extra size of a matrix!

Besides, I think it's pretty fast already.

What I do, in pseudocode:

:If a snowflake can move down,
:Then
::Erase the snowflake there.
::Change the snowflake coordinates to that spot.
::Calculate random direction between left, right, or staying put.
::If the snowflake can move there,
:::Change the snowflake coordinates to that spot.
::Draw the snowflake where it belongs.
:End

I haven't checked both your code, but does your programs run through a list of numbers, looping through it using a For loop? Because the fastest way would probably be to repeat code for each snowflake and use no For loop. It would be a brutal, size-inefficient and bruteforce approach, though (which I think I demonstrated in a TI-BASIC Phoenix clone once, and some people probably remember the infamous screen inverter by Netham45).

If 1=[A](1,1:Output(1,1+B,"M
If 1=[A](1,2:Output(1,2+B,"M
If 1=[A](1,3:Output(1,3+B,"M
If 1=[A](1,4:Output(1,4+B,"M
If 1=[A](1,5:Output(1,5+B,"M
If 1=[A](2,1:Output(2,1+B,"M
If 1=[A](2,2:Output(2,2+B,"M
If 1=[A](2,3:Output(2,3+B,"M
If 1=[A](2,4:Output(2,4+B,"M
If 1=[A](2,5:Output(2,5+B,"M
If 1=[A](3,1:Output(3,1+B,"M
If 1=[A](3,2:Output(3,2+B,"M
If 1=[A](3,3:Output(3,3+B,"M
If 1=[A](3,4:Output(3,4+B,"M
If 1=[A](3,5:Output(3,5+B,"M
Not that I really recommend doing this, but just in case someone really wanted to make his program as fast as possible at any cost.

Pretty neat little demo here.

Mine draws the flakes when they are newly added at the top of the screen, then it searches the matrix for snowflakes that can move down. It erases those ones and draws their new position.

Also, DJ_O, you didn't need the "1=" part of those If statements.

* Xeda112358 runs

The way I test for flakes that can move is I store the matrix rotated so that column 1 is the first row of snow flakes. Then each snow flake is represented by the column number it is in (so if it is homescreen column 6, it has a 6 in the matrix). My code is then:

Code: [Select]

Matr>list([A],8,L2 ;get the last row
For(A,7,1,-1
Matr>list([A],A,L1
L1*(L1 and not(L2→L3 ;This checks if anything in L1 can move down into L2
;"not(L2" leaves a 0 where there is already a flake, else 1 if empty
;Then "L1 and not(L2" leaves a 1 if there is a snowflake above an empty space
L1-Ans→L1 ;remove the snowflakes that can move down from L1
While max(L3
max(L3→B ;location of the snowflake furthest to the right
0→L3(Ans ;remove the snowflake from L3, the list of moveable flakes
0→[A](B,A ;remove it from the matrix
Output(A,B," ;Erase it
min(16,max(1,B+1-2int(2rand ;randomly move left/right
If L2(Ans ;check if the space is occupied
B
Ans→[A](Ans,A+1 ;write the snowflake to the new coordinate
Output(A+1,Ans,"*
End
L1→L2 ;now This row becomes the new lower row
End


Can you give me the full code?