PureBasic

Dans sa macro :
... que produit l'opération « Page0 ! 2 » ?

... que représentent les chiffres après les trois constantes ?

Salut

le ! signifie XOR (OU exclusif), ainsi on compare les valeurs binaires des variables Page0 à Page3 à la valeur 2 (10 en binaire), et on affecte le résultat à Pagex.

Si Pagex vaut 2, un 2 XOR 2 correspond en binaire à 10 XOR 10, et dans un XOR il faut QU'UNE SEULE des valeurs soit vraie !!!

En binaire :
10 XOR 10 = 0
01 XOR 10 = 1
10 XOR 01 = 1
01 XOR 01 = 0

En Décimal :
2 XOR 2 = 0
1 XOR 2 = 1
2 XOR 1 = 1
1 XOR 1 = 0

Pour les constantes correspondent à des "numéros" de sprites, regardes plus loin dans le code source, tu verras des commandes CreateSprite(#constante).

Pour le XOR tu aurais pu faire une recherche dans la doc (chercher opérateurs).

En tout cas bienvenu dans le monde de PureBasic, mais si tu es en version Démo, attention, il y a quelques limitations.

Merci, TazNormand

J'avais vérifié dans l'Aide, ainsi que sur Google, me payant du code C++ et pourquoi pas du VB. Je savais ce qu'était le XOR, mais ignorais à quoi il servait en ce cas particulier. Y a-t-il une formule équivalente, faisant moins Assembleur ?

Il en va de même avec :
Un résultat en pixels est ANDé avec 1 ? Ensuite il y a une multiplication par 2 pour terminer l'addition ?

Ce « & 1» est la seule façon de faire ? il y a un équivalent dans les expressions qu'on apprend en débutant ?

J'ai vécu la version démo, effectivement limitée (pas d'API, par exemple). Que quelques jours seulement, le temps de réaliser que PureBasic valait l'aventure (je programme pour le seul plaisir d'apprendre, trouvant PB plus facile que DB Pro, par exemple).

Les opérations logiques font partie des bases de la programmation. C'est justement idéal pour un débutant. Quand tu fais un test simple, avec IF, il s'agit en fait d'une opération logique; tu dois donc si possible maîtriser cet aspect si tu veux progresser, au moins les 'ET', les 'OU' et les 'NOT'.
Dans l'exemple d'Ollivier, fort de son expérience, il évite des dizaines de comparaisons grâce à ces petits calculs. C'est vraiment très appréciable, c'est plus court, plus rapide, plus beau quoi

En effet, Djes, l'expression est juste : « fort de son expérience. » Ce qu'on a compris est une marche ajoutée à l'escalier.

Les non-matheux (dont je suis) qui rencontrent des sinus et des cosinus dans une formule sont bien perplexes. Le recours à l'Aide va-t-il aider ? J'ai trouvé la solution en bidouillant un code et la théorie est mieux expliquée dans un tuto sur la trigonométrie

« If we use this in a 2D program, there is one more thing that we must remember. In this example, a positive Y offset goes upwards, whereas in screen coordinates, a positive Y offset goes downwards. To correct this, we just do this:

X offset = Sin(Angle)*Radius
Y offset = -Cos(Angle)*Radius »

Ce qui correspond bien à ce que j'ai observé en jouant avec un code simulant l'orbite de planètes.

Dans le cas du Scrolling d'Ollivier, il y a quatre vérifications, Page0 - Page3, à la queue leu leu, l'opérande est 1 pour MoveLeft et MoveRight, et 2 pour Up et Down. Faute de commentaires, je reste dans le jus.

UseBuffer(-1) et If Tile <> -1. ???, que signifie ce « -1 » ?

Oui, c'est un tort de ne pas faire de commentaires, surtout sur des petites astuces comme ça, qui sont parfois dures à retrouver même pour l'auteur!
Je suppose qu'ollivier a initialisé son tableau avec des valeurs qui signifient pour lui "rien"; il a sûrement mis -1.

Les sinus et les cosinus font partie des joujous préférés des démomakers. On peut facilement bidouiller des paramètres pour faire de jolies courbes ou des déplacements. Il suffit de commencer doucement avec un petit objet que tu positionnes avec des variables x, y. Tu fais une petite boucle avec un x qui va de 0 à la largeur de l'écran, et pour y tu mets y = sin(x/100). En gros, le y dépend du x, et va donc onduler puisque tu lui fais suivre la courbe sinus... Avec pas mal d'expérimentations (et grâce à la compilation hyper rapide de pure c'est un plaisir!), on peut faire de chouettes choses!

Je ne t'en dis pas plus, à toi de découvrir

Pour les opérateurs logiques, cherche "algèbre booléenne" sur le net, tu trouveras certainement une explication à ton goût
Sinon on est là

J'ai ajouté à la Macro Display() Phaelax aussi m'était bien occulte au départ quand j'étais sous DB Pro, la conversion en PB m'a obligé à saisir un minimum, ce ne fut donc pas une vilaine décision. J'ai utilisé abondamment DrawText(), notant la réaction des variables, utilisant des graphes pour « visualiser » la magie mathématique et informatique.

0, 1, 2, 2 1, 0, 3, 3


2, 3, 0, 0 3, 2, 1, 1

Voilà ce que j'obtiens pour les quatre coins de l'écran, je verrai bien ce que j'en déduirai de tangible en jouant davantage avec son code. Une répétition de ce qu'il fallut faire avec Phaelax, avec des oh ! et des bah ! et parfois plus de mystères que ce qu'il y avait au départ. Soupir.

Oui, programmer est aussi une aventure.

(J'avais déjà rechercher « algèbre booléenne », c'est alors que j'étais tombé sur le tuto de trigonométrie.)

Salut Koganwel!

ça va être dur de faire des commentaires sur ce code. Il faut bien comprendre qu'un code fait sans commentaire, c'est comme dans du beurre, mais alors s'il faut lui rajouter des commentaires, des vrais commentaires pour être compris du maximum de monde, là ça prend 10 fois plus de temps.

Je pense que tu as compris le principe. C'est un scrolling statique. C'est important de le rappeler parce que, s'il doit y avoir des animations dans le décor, ça n'est plus ce système là qu'il est bon d'utiliser. Dans le cas d'animations dans le décor, autant redessiner en permanence l'ensemble des mosaïques. C'est plus simple, même si c'est plus coûteux en ressources CPU, et donc moins fluide.

Ou alors, vu qu'à l'inverse, quand les ressources sont économisées, le résultat visuel est meilleur, dans le cas de petites animations, on peut remettre à jour certaines mosaïques, mais ça demande un sacré coup d'oeil pour rechopper la position dans le code.

Je pense que le prochain code sera commenté, mais ça demande du temps, beaucoup de temps, vu que le but est d'expliquer, plus que d'exécuter. Aussi, la prochaine version utilisera les flottants plus que les entiers et la logique booléenne dont tu découvres la syntaxe.

Ollivier