; **** Les Puces 41 : jeu complet : Encerclement *****
; ******* Copyright Igor Barzilai - mars 2002 ********
;
; Voici le code source entier
; les point-virgules sont pour les commentaires
; qui ne sont pas pris en compte par l'assembleur.
; Pas de tabulation, certains assembleurs les refusent

    include vcs2600.h
    org $F000

; ************ DECLARATION DES ETIQUETTES ************
; ***** DES ADRESSES MEMOIRE POUR LES VARIABLES ******

Video     = 128       ; Adresse la mémoire vidéo
Vid2      = Video -5  ; sert de pointeur pour la vidéo
Vid       = Video     ; Sert de pointeur pour dessiner

Posx      = 254       ; Position X du pixel à dessiner
Posy      = 252       ; Position Y du pixel à dessiner
Dir       = 250       ; Direction du joueur
Score0    = 248       ; Score du joueur

Tmp       = 247       ; Variable temporaire
Ligne     = 247       ; Adresse de la ligne du pixel
                      ; à dessiner
Bitchange = 246       ; Bit à dessiner
Valjoy    = 245       ; Valeur du joystick

Compteur1 = 244       ; Compteur de ralentissement
Etat      = 243       ; Etat du jeu: 0 = jeu
                      ;              1 = fin de manche
                      ;              2 = fin de partie

; ***************** LIGNES DE BYTE *******************

Chiffre
    BYTE. %00011100
    BYTE. %00010100
    BYTE. %00010100
    BYTE. %00010100
    BYTE. %00011100

    BYTE. %00000100
    BYTE. %00000100
    BYTE. %00000100
    BYTE. %00000100
    BYTE. %00000100

    BYTE. %00011100
    BYTE. %00010000
    BYTE. %00011100
    BYTE. %00000100
    BYTE. %00011100

    BYTE. %00011100
    BYTE. %00000100
    BYTE. %00001100
    BYTE. %00000100
    BYTE. %00011100

    BYTE. %00000100
    BYTE. %00000100
    BYTE. %00011100
    BYTE. %00010100
    BYTE. %00010100

    BYTE. %00011100
    BYTE. %00000100
    BYTE. %00011100
    BYTE. %00010000
    BYTE. %00011100

    BYTE. %00011100
    BYTE. %00010100
    BYTE. %00011100
    BYTE. %00010000

    BYTE. %00010000

    BYTE. %00000100
    BYTE. %00000100
    BYTE. %00000100
    BYTE. %00000100
    BYTE. %00011100

    BYTE. %00011100
    BYTE. %00010100
    BYTE. %00011100
    BYTE. %00010100
    BYTE. %00011100

    BYTE. %00000100
    BYTE. %00000100
    BYTE. %00011100
    BYTE. %00010100
    BYTE. %00011100

Mult5
    BYTE. 0,5,10,15,20,25,30,35,40,45,50,55,60,65,70
    BYTE. 75,80,85,90,95,100,105,110,115,120,125,130
    BYTE. 135,140,145,150,155,160,165,170,175,180,185
    BYTE. 190,195,200,205,210,215,220,225,230,235

Tableoctet
    BYTE. 0,0,0,0
    BYTE. 1,1,1,1,1,1,1,1
    BYTE. 2,2,2,2,2,2,2,2
    BYTE. 0,0,0,0
    BYTE. 3,3,3,3,3,3,3,3
    BYTE. 4,4,4,4,4,4,4,4

Tablebit
    BYTE. 16,32,64,128
    BYTE. 128,64,32,16,8,4,2,1
    BYTE. 1,2,4,8,16,32,64,128
    BYTE. 1,2,4,8
    BYTE. 128,64,32,16,8,4,2,1
    BYTE. 1,2,4,8,16,32,64,128

Dirx
    BYTE. 0,0,0,0,255,0,0,0,1,0,0,0,0,0,0,0
Diry
    BYTE. 0,1,255,0,0,0,0,0,0,0,0,0,0,0,0,0

; ************** ZONE D'INITIALIZATION ***************
           
Start
    SEI             ; Ne modifiez rien à ces
    CLD             ; lignes car elles
    LDX #255        ; initialisent le système
    TXS             ; 
    LDA #0          ; 
B1                  ; 
    STA 0,X         ; effacement de la RAM
    DEX             ; 
    BNE B1          ; 
    LDA #1          ; On est en fin de manche
    STA Etat        ; pour initialiser l'écran

MainLoop            ; 
    LDA #2          ; Ne changez rien à ces
    STA WSYNC       ; lignes car elles
    STA WSYNC       ; initialisent l'affichage
    STA WSYNC       ; 
    STA VSYNC       ; 
    STA WSYNC       ; 
    STA WSYNC       ; 
    LDX #53         ; 
    STX TIM64T      ;  
    LDA #0          ; 
    STA WSYNC       ; 
    STA VSYNC       ; 

    LDA Etat        ; Si l'état n'est pas 1
    CMP #1          ; c'est à dire pas fin de manche
    BNE Pasinit     ; alors n'itialise pas

; ***** INTIALISE LES JOUEURS AVANT UNE MANCHE *******
Initialisation      ; Initialise avant chaque manche

    LDA #2          ; Initialise...
    STA Posx        ; la position X du joueur0
    LDA #37         ; Initialise...
    STA Posx+1      ; la position x du joueur1
    LDA #10         ; Initialise...
    STA Posy        ; la position y du joueur 0
    STA Posy+1      ; et celle du joueur 1
    LDA #8          ; Initialise...
    STA Dir         ; la direction du joueur0
    LDA #4          ; Initialise...
    STA Dir+1       ; la direction du joueur1

; *************** INITIALISE L'ECRAN *****************


    LDA #255        ; 
    STA Video       ; Créé une ligne en bas
    STA Video+1     ; 
    STA Video+2     ; 
    STA Video+3     ; 
    STA Video+4     ; 
    STA Video+114   ; Créé une ligne en haut
    STA Video+113   ;
    STA Video+112   ; 
    STA Video+111   ; 
    STA Video+110   ; 
    LDX #104        ; Créé les deux lignes latérales
Initscreen          ; 
    LDA #128        ; 
    STA Video+5,X   ; Ligne de droite
    LDA #16         ; 
    STA Video+1,X   ; Ligne de gauche
    LDA #0          ; 
    STA Video+2,X   ; L'intérieur du rectangle
    STA Video+3,X   ; est vidé
    STA Video+4,X   ; 
    DEX             ; 
    DEX             ; 
    DEX             ; 
    DEX             ; 
    DEX             ; 
    CPX #255        ;  
    BNE Initscreen  ; 
    LDA #0          ; 
    STA Etat        ; 
Pasinit             ; 

DrawScreen          ; 
    LDA INTIM       ; Termine la phase de Vertical Blank
    BNE DrawScreen  ; 
    STA WSYNC       ; 
    STA VBLANK      ; 

; ************* DEBUT D'AFFICHAGE ********************

; ************* AFFICHAGE SCORES *********************

    LDA #2          ; Cette valeur définit 
    STA CTRLPF      ; playfield aux couleurs Sprites
    LDA #40         ; Met de l'orange 
    STA COLUP0      ; pour le score du joueur 0
    LDA #216        ; Met du vert
    STA COLUP1      ; pour le score du joueur 1

    LDY #5          ; Nombre de lignes pour le score

Bouclescore         ; Etiquette pour la boucle
                    ; d'affichage des scores
    LDX Score0      ; Met le Score0 dans X
    LDA Mult5,X     ; Charge Mult5+X dans A
    STA Tmp         ; Le stocke dans une variable
    TYA             ; Transfert Y (n° de ligne) dans A
    CLC             ; (Obligatoire avant un ADC)
    ADC Tmp         ; ajoute Tmp au registre A
    TAX             ; Transfert A dans X
    LDA Chiffre-1,X ; A = Adresse (Chiffre-1 + X)
    STA WSYNC       ; Fin de la ligne
    STA PF1         ; Met A dans PF1

    LDX Score0+1      ; Met le Score1 dans X
    LDA Mult5,X     ; Charge Mult5+X dans A
    STA Tmp         ; Le stocke dans une variable
    TYA             ; Transfert Y (n° de ligne) dans A
    CLC             ; (Obligatoire avant un ADC)
    ADC Tmp         ; ajoute Tmp au registre A
    TAX             ; Transfert A dans X
    LDA Chiffre-1,X ; A = Adresse (Chiffre-1 + X)
    NOP             ; Cette attente donne le temps au
    NOP             ; balayage écran d'afficher
    NOP             ; le Score0. A présent on peut
                    ; afficher le score1
    STA PF1         ; Met A dans PF1
    DEY             ; 
    BNE Bouclescore ; 

; ****************** LIGNE ESPACEMENT ****************
    LDA #0          ; On prépare l'effacement de PF1
    STA WSYNC       ; Attend la fin de la ligne
    STA PF1         ; Efface PF1
    STA WSYNC       ; Saute une ligne
    STA WSYNC       ; Saute une ligne


; ****************** AFFICHAGE ECRAN DE JEU **********

    LDA #136        ; On met du bleu
    STA COLUPF      ; dans le playfield
    LDA #0          ; Cette valeur 
    STA CTRLPF      ; Playfield disymétrique

    LDY #115        ; Compteur de lignes graphiques
                    ; (anciennement 120)
BoucleY             ; 
    LDX #7          ; Compteur de lignes écran
BoucleX             ; début de la boucle d'affichage
    STA WSYNC       ; Attend la fin du balayage

                    ; PARTIE GAUCHE DE L'ECRAN
    LDA Vid2,Y      ; Charge l'octet de la ligne
    STA PF0         ; registre de Playfield PF0
    LDA Vid2+1,Y    ; Charge l'octet de la ligne + 1
    STA PF1         ; le registre de Playfield PF1
    LDA Vid2+2,Y    ; Charge l'octet de la ligne + 2
    STA PF2         ; le registre de Playfield PF2

                    ; PARTIE DROITE DE L'ECRAN
    LDA Vid2,Y      ; Charge l'octet de la ligne
    ASL             ; mais décale quatre fois
    ASL             ; les bits vers la gauche
    ASL             ; pour décaler les bits 0123
    ASL             ; vers 4567
    STA PF0         ; le registre de Playfield PF0
    LDA Vid2+3,Y    ; Charge l'octet de la ligne + 3
    STA PF1         ; le registre de Playfield PF1
    LDA Vid2+4,Y    ; Charge l'octet de la ligne + 4
    STA PF2         ; le registre de Playfield PF2

                    ; FIN DES BOUCLE
    DEX             ; Décrémente X
    BNE BoucleX     ; Si différent de 0 alors boucle
    DEY             ; sinon décrémente Y de 5
    DEY             ; 
    DEY             ; 
    DEY             ; 
    DEY             ; 
    BNE BoucleY     ; Si Y est différent de 0, boucle
 
; ************ FIN DE L'AFFICHAGE ECRAN **************

    STA WSYNC       ; Attend la fin la dernière ligne
    LDA #0          ; puis met à 0 : 
    STA COLUPF      ; la couleur du playfield,
    STA PF0         ; et les trois 
    STA PF1         ; registres
    STA PF2         ; graphiques du Playfield.


; ****************** JOYSTICK ************************

; *********** SYSTEME DE RALENTISSEMENT **************

    LDA Etat        ; Si l'état 
    CMP #2          ; n'est pas la fin d'une partie
    BNE Joue        ; alors on joue !
    JMP Overscan    ; Sinon, saute la phase de jeu.
Joue                ; 
    INC Compteur1   ; Incrémente le compteur
    BEQ Joystik     ; Tant qu'il n'a pas atteint 0

    JMP Pasjoy      ; 
Joystik             ; 
    LDA #248        ; sinon, met 248

    STA Compteur1   ; pour le réinitialiser
                    ; Donc, lorsque le compteur a
                    ; atteint 0, on effectue un test
                    ; de déplacement au joystick

    LDX #0          ; Initialise X à 0
Bouclejoy           ; On va tester les deux joysticks

; ************** TEST DU JOYSTICK ********************

    LDA SWCHA       ; Valeur des deux Joysticks
    CPX #0          ; On teste le joueur 0 ou 1
    BEQ Testjoy     ; Ne modifie pas le contenu
    LSR             ; Modifie le contenu : 
    LSR             ; Décale 4 fois à droite
    LSR             ; 
    LSR             ; 

Testjoy   
    STA Valjoy      ; Place la valeur dans Valjoy

Joy_droite          ; 
    LDA Valjoy      ; Charge la valeur du joystick
    AND #8          ; filtre le bit 3
    CMP #0          ; on compare ce résultat avec 0
    BNE Joy_gauche  ; S'il n'est pas égal à 0
    LDA #8          ; 
    STA Dir,X       ; 

Joy_gauche
    LDA Valjoy      ; Charge la valeur du joystick
    AND #4          ; on filtre le bit 2
    CMP #0          ; on compare ce résultat avec 0
    BNE Joy_bas     ; S'il n'est pas égal à 0
    LDA #4          ; 
    STA Dir,X       ; 

Joy_bas
    LDA Valjoy      ; Charge la valeur du joystick
    AND #2          ; on filtre le bit 1
    CMP #0          ; on compare ce résultat avec 0 
    BNE Joy_haut    ; S'il n'est pas égal à 0
    LDA #2          ; 
    STA Dir,X       ; 

Joy_haut
    LDA Valjoy      ; Charge la valeur du joystick
    AND #1          ; on filtre le bit 0
    CMP #0          ; on compare ce résultat avec 0
    BNE Joy_dep     ; S'il n'est pas égal à 0
    LDA #1          ; 
    STA Dir,X       ; 


;** DEPLACE LE JOUEUR EN FONCTION DE DIR (Direction)
Joy_dep  
    LDA Dir,X       ; Charge la direction du joueur
    TAY             ; transfert dans Y
    LDA Dirx,Y      ; Charge l'incrément X à appliquer
    CLC             ; 
    ADC Posx,X      ; Y ajoute la position X actuelle
    STA Posx,X      ; Sauve la nouvelle position X
    LDA Diry,Y      ; Charge l'incrément Y à appliquer
    CLC             ; 
    ADC Posy,X      ; Y ajoute la position Y actuelle
    STA Posy,X      ; Sauve la nouvelle position Y

; *************** DESSINE LE PIXEL *******************

    LDA Posy,X      ; Charge la position Y
    TAY             ; transfert A vers le registre Y
    LDA Mult5,Y     ; contenu de l'adresse Mult5+Posy
    STA Ligne       ; et le sauve dans Ligne
    LDA Posx,X      ; 
    TAY             ; transfert A vers le registre Y
    LDA Tableoctet,Y ; A = Tableoctet+Posx
	            ; A=adresse de l'octet de la ligne
    CLC             ; obligatoire avant un ADC
    ADC Ligne       ; On ajoute l'adresse de la ligne
    STA Ligne       ; Sauve dans ligne

    LDA Posx,X      ; On cherche le bit à changer
    TAY             ; 
    LDA Tablebit,Y  ; fonction de la pos X du pixel
                    ; Il récupère le bit concerné
    STA Bitchange   ; et le sauvegarde dans Bitchange

; ******* TEST SI LE PIXEL EXISTE DEJA (COLLISION) ***
    LDY Ligne       ; 
    LDA Vid,Y       ; octet de la mémoire vidéo
    AND Bitchange   ; Filtre le bit du pixel observé
    BEQ Dessine     ; S'il est égal à 0 alors

; il y a collision : on donne un point à l'adversaire

    TXA             ; Récupère le N°du joueur (0 ou 1)
    CLC             ; 
    ADC #1          ; Y ajoute 1
    AND #1          ; Filtre le bit pour avoir 0 ou 1
    TAY             ; Transfert dans Y
    LDA Score0,Y    ; Score du joueur adverse
    CLC             ; 
    ADC #1          ; Y ajoute 1
    STA Score0,Y    ; Et sauve le score adverse
    LDA #1          ; On met l'état à 1
    STA Etat        ; (fin dde manche)

;********* DESSINE LE PIXEL **************************
Dessine             ; 
    LDA Vid,Y       ; octet de la mémoire vidéo
    EOR Bitchange   ; Si le bit est 0 il devient 1
    STA Vid,Y       ; Replace l'octet de la mémoire
                    ; vidéo, modifié      
Pasinv              ; 
Paspresse           ; 
    INX             ; 
    CPX #2          ; 
    BEQ Overscan    ; 
    JMP Bouclejoy   ; 
Pasjoy              ; 
    LDA Score0      ; 
    CMP #9          ; 
    BEQ Fin         ; 
    LDA Score0+1    ; 
    CMP #9          ; 
    BEQ Fin         ; 
    JMP Overscan    ; 
Fin                 ; 
    LDA #2          ; 
    STA Etat        ; 
    
Overscan            ; 
    LDX #34         ; 36 lignes d'overscan
Boucle4             ; Etiquette
    STA WSYNC       ; Attend la fin de la ligne
    DEX             ; Décrémente X
    CPX #0          ; Si X est différent à 0
    BNE Boucle4     ; On branche à Boucle4
    JMP MainLoop    ; Saute à Mainloop

    org $FFFC       ; Ces trois lignes servent à
    .word Start     ; adresse
    .word Start     ; du commencement le programme