automate cellulaire

voila, j'ai fais un automate cellulaire simulant le sable, avec deux regle, soit un pixels est libre en dessous s'y deplacer ou si un pixels est disponible a gauche+1 et a gauche+1 un pixels en dessous ou a droite+1 et a droite+1 un pixeks en dessous s'y deplacer, maleuresement, je suis obligee d'y ajouter deux regle en gros voila mon code comment l'optimiser ?

L est le nombre de pixels dont on s'occupe avec les coordonne de chaque pixels enregistrer dans la liste 1 et la liste 2

Code:


:for(Z,0,L-1
:!if px1-test({L1+Z},{L2+Z})
:{L2+Z}+1->{L2+Z}
:Goto A
:end
:
:if px1-test({L1+Z}+1,{L2+Z})=0 and (px1-test({L1+Z}-1,{L2+Z})=0) and (px1-test({L1+Z}+1,{L2+Z}+1)=0) and (px1-test({L1+Z}-1,{L2+Z}+1)=0
:Rand^2->r1=0?{L1+Z}-1->{L1+Z}
:r1=0?{L1+Z}+1->{L1+Z}
:Goto A
:end
:
:if px1-test({L1+Z}+1,{L2+Z}=0 and px1-test({L1+Z}+1,{L2+Z}+1)=0
:{L1+Z)+1->{L1+Z}
:Goto A
:end
:
:if px1-test({L1+Z}-1,{L2+Z}+1)=0 and (px1-test({L1+Z}-1,{L2+Z})=0
:{L1+Z}-1->{L1+Z}
:end
:
:Lbl A
:end
:
:return


voila mon moteur de l'automate, si quelqu’un a une idée pour le raccourcir parce que il est trop trop lourd.

Premières optimisations :

Code:


:for(Z,0,L-1
:!if pxl-test({L1+Z->I},{L2+Z->J})
:{J}++
:Goto A
:end
:
:!if pxl-test({I}+1,{J})+pxl-test({I}-1,{J})+pxl-test({I}+1,{J}+1)+px1-test({I}-1,{J}+1)
:Rand^2->r1??~1,1
:+{I}->{I}
:Goto A
:end
:
:!if px1-test({I}+1,{J})+px1-test({I}+1,{J}+1)
:{I)++
:Goto A
:end
:
:!if px1-test({I}-1,{J}+1)+px1-test({I}-1,{J}
:{I}--
:end
:
:Lbl A
:end
:
:return


c'est pas mal du tout je pense que on peut faire mieux

Deuxièmes optimisations :

Code:


:for(Z,0,L-1
:!if pxl-test({L1+Z->I},{L2+Z->J})
:{J}++
:Goto A
:End
:
:!if pxl-test({I}+1,{J})+pxl-test({I}-1,{J})
:Rand^2??~1,1
:+{I}->{I}
:End
:
:pxl-test({I},{J})??{J}++
:
:Lbl A
:end
:
:return


tu peut encore le faire

Troisièmes optimisations :

Code:

~1
for(L-1)
!If pxl-test({+1->Z+L1->I},{Z+L2->J})
{J}++
Goto A
End

!If pxl-test({I}+1,{J})*2+pxl-test({I}-1,{J})
Rand^2??~1,1
Else!If -1
1
Else
~1
End
+{I}->{I}

pxl-test({I},{J})??{J}++

Lbl A

Z
End

Return


voici mon code entier ne faite pas attention c'est un code de test, donc mal programmer et mal optimiser fait attention juste au moteur de l'automate

Code:


:.sable
:[FF81818181818181]→Pic0
:[00000000818181FF]
:
:
:0→X→Y→L→K+1→F
:Full
:Repeat getKey(15)
:ClrDraw
:Line(10,10,20,30
:Line(30,10,22,30
:Line(0,63,95,63
:Line(5,62,5,38
:Line(0,62,0,38
:Pt-On(60,55,8+Pic0
:Pt-On(50,55,8+Pic0
:Pt-On(35,30,8+Pic0
:Line(95,10,45,40
:
:
:sub(MAB
:sub(MAA
:Pt-Change(X,Y,Pic0
:K++
:DispGraph
:Pt-Change(X,Y,Pic0
:If getKey(1)
:Y++
:End
:If getKey(2)
:X--
:End
:If getKey(3)
:X++
:End
:If getKey(4)
:Y--
:End
:If (getKey(54) and (K^2=0)
:X+4→{L<sub>1</sub>+L}
:Y+4→{L<sub>2</sub>+L}
:L++
:End
:If getKey(53)
:0→L
:End
:
:End
:
:Lbl MAB
:For(Z,0,L
:Pxl-On({L<sub>1</sub>+Z},{L<sub>2</sub>+Z}
:End
:Return
:
:Lbl MAA
:‾1
:For(L-1)
:!If Pxl-Test({+1→Z+L<sub>1</sub>→I},{Z+L<sub>2</sub>→J}
:{J}++
:Goto A
:End
:
:!If Pxl-Test({I}+1,{J})*2+Pxl-Test({I}-1,{J}
:rand^2??‾1,1
:Else!If -1
:1
:Else
:‾1
:End
:+{I}→{I}
:Pxl-Test({I},{J})??{J}++
:Lbl A
:Z
:End
:Return
:
:Normal


Quatrième version :

Code:


:‾1
:For(L-1)
:!If Pxl-Test({+1→Z+L<sub>1</sub>→I},{Z+L<sub>2</sub>→J}
:{J}++
:Else
:!If Pxl-Test({I}+1,{J})*2+Pxl-Test({I}-1,{J}
:rand^2??‾1,1
:Else!If -1
:1
:Else
:‾1
:End
:+{I}→{I}
:Pxl-Test({I},{J})??{J}++
:End
:Z
:End
:Return


Plus de bug, et c'est je pense le maximum que je puisse faire.

Une question, c'est quoi la vague à la 1ère ligne de la 3ème optimisation de Kindermoumoute?

Merci d'avance
Sandro

Dans certains languages c'est la "complémentation à 1" qui sert entre autre à rendre négatif des nombres binaires dans certains systèmes.
Mais je me demande bien ce que cela fait ici.

c'est le - mais celui des négatif pas celui du moins, cependant, ton optimisation ne marche pas kindermoumoute, elle provoque un ram-clared

cinquieme optimisation : j'ai trouver une astuce mais je me suis beaucoup embrouiller j'ai pas eu encore le temps de le tester

Code:


:Lbl MAA
:‾1
:For(L-1)
:!if {+1→Z+L1*12+L6+8*(Z+L2→J)}^^re(Z^4)

:{J}++
:Else
:!if {{+1→Z+L1}+1*12+L6+8*({Z+L2}-1→J)}^^re(Z^4)
:rand^2??‾1,1
:Else!If -1
:1
:Else
:‾1
:End
:+{I}→{I}
:{{I}*12+L6+8*{J}}^^re(Z^4)??{J}++
:End
:Z
:End
:Return


pardon pour le double post je ne sais pas ce qu'il c'est passer

Le code bug, mais il restait bien plus optimisé car la commande pxt-test est beaucoup plus optimisée que le getbit. Le problème venait de la boucle. En effet une boucle faite avec une variable dedans modifie HL, donc ça ne marchait pas. Solution :

Code:


:0→Z
:For(L-1)
:!If Pxl-Test({Z+++L<sub>1</sub>→I},{Z+L<sub>2</sub>→J}
:{J}++
:Else
:!If Pxl-Test({I}+1,{J})*2+Pxl-Test({I}-1,{J}
:rand^2??‾1,1
:Else!If -1
:1
:Else
:‾1
:End
:+{I}→{I}
:Pxl-Test({I},{J})??{J}++
:End
:End
:Return


Et voilà, ça marche pour moi sans soucis. Après il ne faut pas oublier que de code ne gère pas le bas de l'écran, il faudra donc faire un sol pour que cela marche.

moi sa ne marche pas du tout ?? ram-clared a chaque fois je vais reinstaller l'os