วีดีโอ

👍

Merki

Je fais la correction à la rentrée... et même un peu plus (teaser 😜)

Merci à toi aussi

Bonjour, les instructions sont différentes entre les 2 types de processeurs, mais surtout, l'adressage mémoire fonctionne complètement autrement. Il est préférable de trouver des tutoriels x86 (ou mieux, x64 pour maintenant, autant apprendre sur ce qu'il y a de plus récent !)

@RetroProgrammation-fq1cv merci

de rien 👌

Faut pas exagérer ! Mais merci quand même 😘

Avec plaisir 😘

grazie

you're welcone 👍

Prego 👌

euhhh... Tu peux me mettre le code qui te donne les 0 et les 7 ?

@@RetroProgrammation-fq1cv Oui, voici : START_TEST_JOYSTICK ldy PRA ; port A du joystick $DC00 ; ************************************************* ; * UP Afficher des zéros à l'écran * ; ************************************************* tya and #%00000001 bne SUITE1 lda #48 ; caractère 0 jsr FILL_SCREEN SUITE1 ; ************************************************* ; * LEFT Afficher des 7 à l'écran * ; ************************************************* tya and #%00000100 bne SUITE2 lda #55 ; caractère 7 jsr FILL_SCREEN SUITE2 jmp START_TEST_JOYSTICK

@@RetroProgrammation-fq1cv Tiens, c'est curieux, je t'avais mis une réponse vers 14H00, et celle-ci ainsi que tout le code a disparu ...

OK... Alors, en fait, lorsque tu appuie sur tes 2 touches UP + LEFT, dans ton code, tu commences par tester UP sans regarder LEFT, et donc tu traites UP avec ton JSR et tu reviens pour tester LEFT ... sans UP et ainsi tu traites pour LEFT et tu reviens pour traiter la suite. Ce qu'il convient de faire est plutôt de tester les combinaisons. Si elles apparaissent, tu les traites et, surtout, tu sors de tout autre traitement pour recommencer ta boucle. Donc commencer par 2 directions + fire, puis les doubles directions, puis les simples directions avec fire, et enfin les simple direction et fire tout seul.

Bien compris. Je m’en étais sorti avec une méthode qui vaut ce qu’elle vaut : une variable appelée trois boutons et activée à 1 lorsque trois boutons sont appuyés et une variable appelée deux boutons et activée à 1 lorsque deux boutons sont activés. Si l’on passe dans le test d’un seul bouton appuyé et que ces 2 variables sont à 1, le test est ignoré. De même si l’on passe dans le test de l’appui de 2 boutons et que la variable 3 boutons est activée, ce test est ignoré. En fin les variables sont remises à 0 lors du relâchement de tout appui de plusieurs touches.

Je me pose la question de compléter cette vidéo en rajoutant un peu d'assembleur pour accélérer les affichages... Ou alors rajouter une nouvelle playlist BASIC + ASM ...

@@RetroProgrammation-fq1cv merci pour cette belle réussite, c'est jouable en l'état, si dans l'année qui arrive vous avez un peu de temps pour ajouter une partie en assembleur je serai à l'écoute de la suite.

J'ai fait un live le 23/12/2024 pour ajouter de l'assembleur : th-cam.com/users/livewTOa5wpOyWs

Merci 😘 Je n'ai jamais fait de Z80, je suis passé du MOS 6510 au Intel 8086

Tout à fait 🎉 C'est pas super compliqué 😜

Sans doute ! Je n'utilise ni l'un ni l'autre !

Bien joué... Mission complémentaire, réduire la taille du code ;)

Hello Une macro est plutôt un script qui peut prendre un nombre variable de paramètres (0 à n) et qui va remplacer l'endroit où elle sera appelée par son propre contenu modifié via les paramètres. Soit le macro suivante : .macro IncrementeCouleurBordure()[ inc $d020 } .macro DisplayChar(x,y,char,color)[ lda #char sta (1024+x+y*40) lda #color sta (55296+x+y*40) } si dans mon code je mets ceci : main:{ :IncrementeCouleurBordure() :DisplayChar(20,12,160,7) :IncrementeCouleurBordure() rts } à la compilation, kick assembler lira et compilera ceci : main:{ inc $d020 lda #160 sta 1524 lda #7 sta 55796 inc $d020 rts }

Bien compris, merci !

Je t'en prie 👌

C'est super que tu y soit arrivé 👍

@@RetroProgrammation-fq1cv Merci, mais j'en ai bavé !

Peut-être, mais tu y es arrivé, et c'est ça le plus important !

C'est marrant que tu demandes ça, je vais les aborder dans le prochain tuto !

@RetroProgrammation-fq1cv je prends ma retraite en janvier (55 balais) et je compte bien faire de la programmation pour maintenir en forme le cerveau et m'éclater. Encore un grand grand bravo le gone 🤙🤙. Super tes cours. Ton format court et précis me rappele les fiches de cours de mes années d'étudiant 🤭

La vidéo avec les macros est sortie aujourd'hui 😜 Le format court avec des exercices d'application, y a rien de mieux pour apprendre !

@RetroProgrammation-fq1cv écoute j'ai pas su voir la video sur les macros...🤔😬

C'est le cours n°8 sur l'assembleur... J'ai abordé les bases des macros sur kickassembler après la correction de l'exercice.

Tu es sur la bonne piste :)

Hello Effectivement, je n'ai pas compté le RTS car il ne fait pas partie de la routine en soi... Et si tu compte le RTS à 6 cycles, tu dois également compter le JSR qui va l'appeler, à 6 cycles également.

Je t'en prie ! Merci à toi également pour les encouragements !

Tu peux poser le code complet ? Ce sera plus facile à lire pour tout le monde 😜

Oui, pas de problème. J’essaie de faire ça rapidement.

Merki :p

@@RetroProgrammation-fq1cv ldx #32 ldy #0 lda #48 VSUP10 cpx #22 beq SOUSTRAIRE bcc AFFICHAGE bcs AFFICHAGE SOUSTRAIRE ;sec sbc #57 AFFICHAGE sta MEMORY_SCREEN,y iny iny clc adc #1 dex cpx #17 bcs VSUP10 rts

Ca fonctionne effectivement car tu testes X et s'il est égal tu rediriges vers SOUSTRAIRE, puis s'il est inférieur ou supérieur tu rediriges vers AFFICHAGE... C'est une manière compliquée d'écrire ça (ci-dessous) mais ça a l'avantage d'utiliser BCS et BCC: VSUP10 cpx #22 beq SOUSTRAIRE bne AFFICHAGE SOUSTRAIRE ou encore plus court... VSUP10 cpx #22 bne AFFICHAGE SOUSTRAIRE

C'est une solution parmi tant d'autres... Bien joué. Mais peux-tu faire sans utiliser bne ou beq (à part pour la boucle bien sur) ?

@@RetroProgrammation-fq1cv Je vais essayer. ça fait bien travailler les méninges tes petits exercices !

J'ai trouvé : J'ai remplacé le BNE AFFICHER dans la boucle LOOPX3 par un CMP #58 ( valeur que prend l'accumulateur avant de faire la soustraction ) + un bcc AFFICHER ( pour une seule fois le carry sera activé ). Lors du deuxième passage pour afficher le B en hexadécimal, mon CMP #58 va mettre le carry à zéro et on ne fera plus la soustraction ainsi que pour les lettres suivantes.

C'est fait pour ! Y a rien de tel pour apprendre et comprendre que de pratiquer !

Bien joué... C'est une solution, pas celle que je proposerai, mais c'en est une.

Effectivement... je me suis trompé ! Je vais rajouter un texte de sous-titrage pour alerter !

Un grand merci ! C'est vrai que c'était un casse-tête la place sur ces machines. J'ai souvent été limité lorsque j'écrivais des jeux en BASIC. Le 1541 et l'assembleur m'a un peu libéré... Mais il fallait toujours économiser le moindre octet à l'époque 😁

Merci beaucoup 👍 Je n'ai jamais utilisé TMPx, mais je sais que c'est ce qu'utilise monos. Pour ma part, je préfère kickassembler qui permet énormément de choses.

Merci pour ton soutien ! Moi aussi j'aurai bien aimé en savoir autant à l'époque... Par contre, j'aurai sans doute eu une autre carrière, donc pas de regrets, que de bons souvenirs 😜

Merci à toi 😊

Effectivement c'est un oubli de ma part, je l'ai signalé par un petit texte à l'écran au moment du montage. Le fonctionnement est identique car nous avons le cpx #0 qui vérifie que x est bien à 0... donc la remise à 0 du registre X n'est pas nécessaire dans cet exemple particulier! Par contre, cet oubli accélère l'exécution du code car nous évitons ainsi 255 fois la remise à 0 du registre X, ce qui nous fait gagner 510 cycles processeur (environ 517ns ... car 1 seconde = 985248 cycles pour plus d'info sur ce nombre, tu peux aller voir cette vidéo th-cam.com/video/y-Qtz_88DTY/w-d-xo.html mais on est dans de l'assembleur bien avancé !)

c'est ça :)

Bonjour @bond5174 , Alors l'effacement de l'écran peut se faire de plein de façons différentes. Les offsets à utiliser pour ta boucle sont 0, 256, 512 et 768 (tu rajoutes 256 à chaque fois). Cependant, ta méthode va poser un problème si tu remplis de 1792 à 2047 car tu vas bien remplir la partie d'écran entre 1792 et 2023 avec le caractère ''espace'', mais aussi la zone mémoire 2024 à 2047. Or, cette zone contient les informations relatives aux sprites (entre 2040 et 2047), ce qui peut être gênant si ton code les utilise. Tu peux le faire en une seule boucle de 250 valeurs (l'écran fait 1000 octets, donc le plus simple est d'utiliser 4 x 250). Après, libre à toi de faire autant de boucles que tu le souhaite. Si l'objectif est de travailler avec des lignes, prend un multiple de 40 (par paquet de 6 lignes, ça te donne : offsets 0, 240, 480,720 et la dernière ligne ne sera pas affectée... et tant mieux puisque tu y as recopié la ligne d'entête pour qu'elle y soit affichée). Je te propose de regarder la solution que je propose dans le cours N°4, et on se retrouve dans les commentaires de celle-ci pour en discuter si tu le souhaites.

@@RetroProgrammation-fq1cv Merci d'avoir corrigé mon erreur. Je regarde la vidéo suivante...

Bon visionnage

J'essai de faire des exercices pratiques dans toutes les vidéos de la formation, soit pendant la vidéo, soit en fin de vidéo pour la suivante... C'est super si ce format te plait !

Ca fait beaucoup de chouettes idées... Déjà, il faudrait que je trouve le temps d'avancer sur le projet pour terminer au moins tout ce que j'avais prévu... Les tirs de DCA alignées à la hauteur de l'appareil, des avions ennemis, tout ça sans ralentir le jeu... J'ai encore beaucoup de boulot :p Mais je garde en mémoire ces idées pour la suite ^_^

@@RetroProgrammation-fq1cv Merci pour la réponse, je vais suivre votre projet, votre contenu et riche et très bien commenté, j'ai découvert par vos vidéos le mystère de l'assembleur qui demande une rigueur et une documentation importante, premier contact avec mon c64 les demomakers et Tubular Bells qui associe musique et graphisme épuré ........... des lignes et des lignes th-cam.com/video/zJ53UEddDQQ/w-d-xo.html

Si tu es musicien et/ou que tu souhaites faire de la musique sur C64, je te conseille GoatTracker... et pour démarrer, tu peux suivre ce tuto (en anglais, mais pas très difficile à comprendre) : th-cam.com/video/SCivUoOjhm8/w-d-xo.html&ab_channel=richmondmike1978

Bonjour, merci à toi 😜 Non, il n'y a pas de BasicUpstart ... en fait il faut lire le 2 en anglais, ce qui fait ''to'' pour avoir au final la phrase "Basic upstart to" suivi du label xxx où doit commencer la partie assembleur ce qui en français pourrait se traduire par Le Basic lance le début à xxx Mais il est possible d'écrire un upstart personnalisé. J'ai fait une vidéo ici... Mais c'est un peu plus chaud que les tutos de cette série ;) : studio.th-cam.com/users/videokM71Ew3ryRY/edit

Merci pour ton soutien !👍 Non non, il n'est pas nécessaire de connaître le Basic... C'est pour cette raison que l'exercice est basé sur un morceau de code tout simple. J'ai surtout fait ça pour monter qu'il est possible de convertir un programme Basic en assembleur et montrer la grosse différence de vitesse d'exécution qu'il en résulte. Beaucoup de gens qui aiment le c64 ont déjà fait un peu de Basic sur la machine, c'est pour cette raison également que j'ai pris ce petit exemple. Et la solution sera visible dans la prochaine vidéo... Mais bon, je confirme que ton code en python est correct, mais il est moins lisible pour un néophyte et moins proche en terme de déroulé de ce qu'on va faire en assembleur.

Merci à vous C'est le but recherché. Rester simple, pour apprendre tranquillement, avec des exemples simples (pas toujours optimaux, mais permettant de mettre en application ce qui a été vu), et j'invite surtout à manipuler pour apprendre !

Salut ! La vidéo 4 sera terminée demain normalement ;) Pour ce qui est de ton code, si tu veux faire du dex, la solution est plus simple... PRINT: ldx #$06 loop: lda COUCOU - 1,x sta COUCOU_START - 1,x dex bne loop rts En fait, tu commence par 6 jusque 1 (donc tu retranches 1 à la position mémoire de COUCOU et COUCOU_START) et lorsque le dex va mettre X à 0, le flag ZERO (on n'a pas encore vu les flags, donc éventuellement tu aurais pu mettre cpx #$00) sera activé et donc BNE ne sera plus appliqué (il s'appuie sur le flag ZERO pour le branchement) Du coup, c'est également plus court comme code, et plus rapide, mais moins intuitif pour débuter une formation à l'assembleur.

@@RetroProgrammation-fq1cv Cool on peut rajouter un deuxième offset avec + et - sur l'adresse avant la virgule c'est noté 😎 Du coup je n'ai plus besoin des 3 autres .const que j'avais ajouté pour atteindre toutes les cases de l'écran dans mon CLEAR_SCREEN.

Attention, le -1 que j'ajoute, ce n'est pas un paramètre à l'instruction !!! Quand j'écris lda MEM - 1 si MEM = $4000, le compilateur va comprendre et compiler lda $3FFF C'est un peu comme si j'avais écrit (MEM - 1) entre parenthèses... et donc le seul offset utilisé par l'instruction lda (ou sta) c'est le "x" qui lui peut varier, alors que MEM - 1 est une constante.

@@RetroProgrammation-fq1cv ok merci pour la précision; en gros si j'ai bien compris ça va réécrire le code avec la bonne vleur en dur donc les pseudos opérations doivent être faites avec des valeurs constantes

C'est bien ça

Hello, Merci, j'essai d'être simple et clair dans mes explication et d'avancer tranquillement pour ne pas noyer dans des tonnes d'instructions ! Désolé, je suis sur windows ! Mais normalement, Vice est identique sur les deux systèmes ! Qu'est-ce que tu entends par segmentation ?

@@RetroProgrammation-fq1cv J'aurai du dire Memory Map (du jeu) à 0:45 dans ton terminal on peut lire Default-segment: suivi des trois blocs Basic, Basic End et Unnamed. Je cherchais un moyen de générer ces lignes mais j'ai trouvé il suffisait d'ajouter le flag -showmem quand on compile avec KickAss

OK :) rien à voir avec le code assembleur du coup ni VICE... Amuse-toi bien ;)

Avec plaisir

You can have subtitles translated to English. It works great.

What do you mean ? You want me to add english subtitles ? Or automatic's are ok ?

@@RetroProgrammation-fq1cv Oh please disregard my comment. I thought I was responding to someone saying you should translate it to English and I just wanted to say that anyone can follow you with the automatic subtitles with translation. Alli is good. :) And thx again for making this series for c64.

OK. Thanks for your return

Totalement d'accord. Merci pour ton soutien 😜

Merci

Merci ❤️ Effectivement, l'assembleur n'est pas un langage difficile, car il n'a que très peu d'instructions. Ce qu'il faut ensuite apprendre, c'est l'algorithmie ... Je ne sais pas encore si je vais m'aventurer sur ce terrain d'ailleurs. Pour le moment, le langage. On verra après !

@@RetroProgrammation-fq1cv J'avoue que si tu te lances sur l'algoritmie ce serait formidable car c'est effectivement çà qui permet d'écrire de bons programmes. Surtout sur un 6510 et les limitations inhérentes au 8bits, il y a pas mal de choses à apprendre :)

On verra ...Ca sera même sans doute en continuité avec les cours d'assembleur et peut-être même au fur et à mesure avec des exemples et des exercices !

Merci à toi ❤️ C'est pareil pour tout le monde je pense... Moi aussi j'ai eu du mal dans les années 80 à faire de l'assembleur, surtout que les outils étaient plutôt compliqués à prendre en main à l'époque ! J'en ai fait pas mal malgré tout. J'avais fait un clone de pacman et un clone de jungle hunt avec un mélange de BASIC et d'assembleur, mais j'ai arrêté ensuite pour poursuivre mes études, et ne me suis remis à la programmation du commodore qu'il y a 3 ou 4 ans... C'est ma Madeleine 😜 !

Merci à toi 👍

Sans doute parce que pour une fois je n'ai pris un rythme soutenu 😁