;----------------------------------------------
;      Donkey Kong for the ti82	  	)))))	
;	       v1.0b		       (((((
;	 by Olivier Carpentier	      ( 0 0 )
;       danielc@club-internet.fr	 I
;    http://www.mygale.org/05/nml/		
;	 Copyright (C) 1998
;----------------------------------------------
                              
;AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
;Sorry but the explanations are only in french.
;AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 
;Cette source est détaillée seulement en français.
;si vous en empruntez un morceau merci d'en indiquer
;l'origrine.
;Merci encore et toujours à Nicolas Hannebicque à qui 
;j'ai emprunté quelques routines et sans qui je pense 
;je ne programmerai pas en assembleur.
;Merci evidemment à Jimmy Märdell pour sa zshell online school
;et ses leçons ultra claires que vous pouvez vous procurer
;sur le site : http://www.mygale.org/05/nml/ (et voila,
;un coup de pub pour mon site au passage...)
 

#INCLUDE "ti82.h"
#INCLUDE "oldcall.h"

.org START_ADDR
.db "Donkey Kong v1.0b",0

;=============================================
;   définition des allocations mémoires
;=============================================

manx = TEXT_MEM			;abscisse du bonhomme
many = TEXT_MEM+1		;ordonnées "    "
ballex = TEXT_MEM+2		;abscisses de la balle
balley = TEXT_MEM+3		;ordonnées "   "  "
balle2x = TEXT_MEM+4		;pareil mais pour la 2eme balle
balle2y = TEXT_MEM+5
weapon = TEXT_MEM+8
moves = TEXT_MEM+10		;variable servant au mouvement du man(bonhomme en anglais)
vrball = TEXT_MEM+11		;variable servant à la direction de la boule
keys = TEXT_MEM+12		;variable des clefs
scr  = TEXT_MEM+14		;variable du score
lives = TEXT_MEM+17		;et oui, les vies!
hauteur = TEXT_MEM+19		;la hauteur du bonhomme sur l'écran
levels = TEXT_MEM+20		;explicite non?
dlay = TEXT_MEM+22		;varaible pour le temps 
flan = TEXT_MEM+25
tempair2 = TEXT_MEM+26		;pareil
temp = TEXT_MEM+28		;vr servant à savoir quand la balle touche le bonhomme
string = TEXT_MEM+32		;une variable servant pour le score
place_temp = TEXT_MEM+42	;variable pour le classement des  high-scores,12 octets

;=============================================
;        DEBUT DU PROGRAMME
;=============================================

prog_start:				;boucle pour afficher l'écran principal : superbe picture
					;thanks  Fed Lionetti for this picture 
	ROM_CALL(BUSY_OFF)	;efface le bitoniot qui clignote en haut à droite
	ld a,$8C
	out (2),a
	ROM_CALL(CLEARLCD)	;efface tout (texte)
	CALL_(CLRGBU)		;appelle de la routine pour effacer l'écran
	ld hl,intro			; on charge la picture d'intro en hl
	ld de,$88B8			; on indique la position (en haut à gauche)
	ld bc,72			; dit le nombre de bites à copier pour la pic (nombres de lignes*12)
	ldir				; copie
	ROM_CALL(DISP_GRAPH)	;et enfin l'affiche
	ld hl,intro2
	ld de,GRAPH_MEM+252
	ld bc,504
	ldir
	ROM_CALL(DISP_GRAPH)	
	call dgraphic2
	ld de,0
debut:
	inc de  
	ld hl,4000
        call CP_HL_DE		 	
	call z,dgraphic2	 
	ld hl,8000
	call CP_HL_DE
	call z,dgraphic1

	call GET_KEY
	cp $0F
	jp z,exit
	cp $36
	jp z,debut2
	jp debut
dgraphic2:
        ld hl,initial_pic  
	jr dgraphic
dgraphic1:
	ld hl,initial_pic2
	ld de,0
dgraphic:
	push de
	ld de,GRAPH_MEM+72  
        ld bc,180   
        ldir        
        ROM_CALL(DISP_GRAPH)
        pop de
	ret

debut2:
	call start_scroll
	xor a
	ld (keys),a
	ld hl,$0000
	ld (scr),hl
	ld hl,$0003
	ld (lives),hl
	ld bc,$2000	
	ld (dlay),bc		;on définit comme 2000 le temps de retard

initialisation:			;avant d'y aller on initialise toutes nos variables
	xor a
	ld (levels),a		;0 = le level où on est au départ
		
initialisation2:			;encore une initialisation mais partielle car elle n'initialise
	call level			;que les variables qui sont "standarts" et donc qui
	ld a,2			;resserviront pour tous les levels.
	ld (vrball),a
	ld a,1
	ld (moves),a		;on charge 1 dans le mouvement pour indiquer qu'on va à droite
	ld (tempair2),a
	ld a,40
	ld (many),a		;donne 47 pour l'ordonnée de notre bonhomme
	xor a			;et 0 pour son abscisse (xor a = ld a,0 mais en + rapide)
	ld (weapon),a
	ld (flan),a
	ld (manx),a
	ld (hauteur),a		;0 = hauteur du bonhomme dans le jeu au départ
	call putman_droite	;on appelle la routine pour afficher un homme qui va à droite
	ld a,36
	ld (balley),a	;on place l'ordonnée de la 1ere balle
	ld a,12
	ld (balle2y),a	; de la seconde
	ld a,84
	ld (ballex),a
	xor a			;on met 84 pour x de la 1ere balle
	ld (balle2x),a	;et 0 pour l'abscisse de la 2nde
	call putballetemp	;on affiche la 1ere balle
	call putballe2temp4	;on affiche la seconde

loop:				; c'est la boucle "get_key" du programme!					
	call score			;on appelle la routine pour afficher le score
	jp balle			;on affiche et dirige les balles
loop2:
	ld a,(flan)
	cp 1
	jp z,caro
	ld 	a,0ffh			;\
	out 	(1),a			; \
	ld 	a,0feh			;  \5 lignes pour utiliser les touches directions 
	out   (1),a			; /
	in 	a,(1)			;/
	cp	251			;si c'est la droite : on va à la routine "droite"
	jp 	z,droite		;
	cp 	253			;si c'est gauche : on va à la routine "gauche"
	jp 	z,gauche		;
	cp	247			;si c'est haut : on va à la routine "haut"
	jp	z,haut			;
	cp	254			;si c'est bas ?
	jp 	z,bas			;
	ld 	a,0ffh			;\
	out 	(1),a			; \
	ld 	a,0bfh			;  \5 lignes pour utiliser les touches au dessus des numéros
	out   (1),a			; /
	in 	a,(1)			;/
	cp 	223			;si c'est 2nd on va à la routine saut
	jp 	z,jump
	cp 	191			;si c'est MODE on va à la routine "Gamepause"
	jp 	z,gamepause		;
	ld 	a,0ffh			;\
	out 	(1),a			; \
	ld 	a,0fdh			;  \5 lignes pour utiliser les touches genre CLEAR ou ENTER
	out   (1),a			; /
	in 	a,(1)			;/
	cp 	191
	jp 	z,exit			;si c'est CLEAR on quitte
	jp loop			;on clos la boucle


;=========================================
;BOUCLE POUR DEPLACER LE BONHOMME A GAUCHE
;========================================= 
	
gauche:				;routine permettant de déplacer le bonhomme à gauche	
	ld a,(moves)	
	cp 1				;on compare la position de man à 1(droite) 
	jp z,gauche_prem		;si c'est égal c'est la premiere fois qu'on va à gauche 
	cp 2				; on compare à 2(gauche)
	jp z,gauche_toute		;si c'est égal on fonce à gauche
gauche_prem:			
	call putman_droite		;comme c'est la première fois qu'on va à gauche,on
	ld a,2				;efface le man dans sa position droite
	ld (moves),a			;et enfin on indique que maintenant le man va à gauche
	jp loop_gauche
gauche_toute:
	call putman_gauche		;on place le bonhomme et l'efface
loop_gauche:
	ld a,(hauteur)
	cp 1
	jp z,parici	
	cp 0
	jp z,parla
parla:
	ld a,(manx)
	cp 30
	jp z,descend_a_gauche
	cp 60
	jp z,descend_a_gauche
	cp 0
	jp z,stop1
	jp gauche_suite
descend_a_gauche:
	ld a,(many)
	inc a
	inc a
	ld (many),a
	jp gauche_suite
parici:
	ld a,(manx)
	cp 30
	jp z,monte_a_gauche
	cp 60
	jp z,monte_a_gauche
	cp 0
	jp z,stop1
	jp gauche_suite
monte_a_gauche:
	ld a,(many)
	sub 2
	ld (many),a
gauche_suite:
	ld a,(manx)
	call test_gauche
	call test_gauche
	call test_gauche
	call putman_marche_gauche
	ld a,1
	ld (flan),a 
	jp loop
caro1:
	call putman_marche_gauche
	call test_gauche
	call test_gauche
	call putman_gauche		;on affiche le man tourné vers la gauche
	jp loop				;on retourne à la boucle principale
stop1:
	call putman_gauche
	jp loop
test_gauche:
	call ultime_test
	ld h,a
	ld a,(manx)
	cp h
	jp z,mort
	dec a
	dec a
	ld (manx),a
	ret	
caro:
	xor a
	ld (flan),a
	ld a,(moves)
	cp 1
	jp z,caro2
	cp 2
	jp z,caro1
;===========================================================
;       A  DROITE
;===========================================================
droite:				;c'est la même chose que pour la gauche sauf qu'on incrémente l'abscisse
	ld a,(moves)
	cp 2
	jp z,droite_prem
	cp 1
	jp z,droite_toute	
droite_prem:
	call putman_gauche
	ld a,1
	ld (moves),a
	jp loop_droite
droite_toute:
	call putman_droite
loop_droite:
	ld a,(hauteur)
	cp 0
	jp z,parla2
	cp 1
	jp z,parici2
parici2:
	ld a,(manx)
	cp 20
	jp z,descend_a_droite
	cp 50
	jp z,descend_a_droite
	cp 70
	jp z,stop
	jp droite_suite
descend_a_droite:
	ld a,(many)
	inc a
	inc a
	ld (many),a
	ld a,(manx)
	jp droite_suite
parla2:
	ld a,(manx)
	cp 20
	jp z,monte_a_droite
	cp 50
	jp z,monte_a_droite
	cp 70
	jp z,stop
	jp droite_suite
monte_a_droite:
	ld a,(many)
	dec a
	dec a
	ld (many),a
	ld a,(manx)
droite_suite:	
	call test_droite
	call test_droite
	call test_droite
	call putman_marche_droite
	ld a,1
	ld (flan),a
	jp loop
caro2:
	call putman_marche_droite
	call test_droite
	call test_droite
	call putman_droite
	jp loop 
stop:
	call putman_droite
	jp loop
test_droite:
	call ultime_test
	ld h,a
	ld a,(manx)
	cp h
	jp z,mort
	inc a
	inc a
	ld (manx),a
	ret

ultime_test:
	ld a,(vrball)
	cp 1
	jp z,mett1
	cp 2
	jp z,mett2
mett1:
	ld a,(hauteur)
	cp 0
	jp z,met22
	cp 1
	jp z,met11
mett2:
	ld a,(hauteur)
	cp 0
	jp z,met11
	cp 1
	jp z,met22
met11:
	ld a,(ballex)
	ret
met22:
	ld a,(balle2x)
	ret
;=====================================
;  MONTER OU DESCENDRE UNE ECHELLE
;=====================================
haut:						;routine pour monter une echelle
	ld a,(levels)
	cp 2
	jp z,monte_echelles_devant_boss		;monter les échelles dans le dernier level
	ld a,(manx)
	cp 70
	jp z,monte_echelle_basse		;monter l'echelle basse (droite)
	cp 10
	jp z,monte_echelle_haute		;monter l'echelle haute (gauche)
	jp loop
monte_echelle_basse:
	ld a,(hauteur)
	cp 1
	jp z,loop
	call putman_droite
	ld a,1
	ld (hauteur),a
	ld a,16
	ld (many),a
	call putman_gauche
	ld a,2
	ld (moves),a
	ld a,(scr)	
	add a,2
	ld (scr),a
	jp loop
monte_echelle_haute:
	ld a,(hauteur)
	cp 0
	jp z,loop
	call putman_gauche
	xor a
	ld (hauteur),a
	ld a,(levels)
	inc a
	ld (levels),a
	ld a,(scr)
	add a,3
	ld (scr),a
	jp initialisation2
monte_echelles_devant_boss:
	ld a,(manx)
	cp 70
	jp z,monte_echelle_basse
	cp 30
	jp z,monte_last_echelle
	jp loop
monte_last_echelle:		;monter la derniere echelle devant le singe
	ld a,(hauteur)
	cp 0
	jp z,loop
	
key:				;quand on gagne une clef
	ld a,(scr)
	add a,20
	ld (scr),a		;on ajoute 10 au score
	call putman_gauche	;on efface le bonhomme
	ld a,32
	xor e
	ld bc,pic_key
	call SPRXOR
	ROM_CALL(DISP_GRAPH)	;on efface la clef
	xor a
	ld (many),a
	call putman_gauche	;on affiche le bonhomme en haut de l'echelle
	ld a,(keys)	
	inc a
	ld (keys),a			
	cp 3
	jp z,winner		;si on a 3 clefs on va à la routine "winner"
	set	3,(IY+05)
	ld hl,35*256+12
	ld (CURSOR_X),hl
	ld hl,msg_key
	ROM_CALL(D_ZM_STR)	;on affiche le message "you have a key"
	res	3,(IY+05)
	call pause		;pause
	ld a,(keys)
	cp 1
	jp z,vitesse2		;si on a 1 clef on accelère la boule
	cp 2
	jp z,vitesse3		;si on a 2 clefs, on accelere encore plus
		
bas:				;pour descendre les echelles,
	ld a,(hauteur)		;presque pareil que pour monter
	cp 1
	jp nz,loop
	ld a,(manx)
	cp 70
	jp z,bas_suite
	jp loop
bas_suite:
	ld a,(moves)
	cp 1
	jp z,bas_vers_droite
	call putman_gauche
	jp bas_bis_suite
bas_vers_droite:
	call putman_droite
bas_bis_suite:
	ld a,36
	ld (many),a
	call putman_gauche
	ld a,2
	ld (moves),a
	xor a
	ld (hauteur),a
	jp loop	

winner:				;quand t'as tout gagné et que t'es le + fort
	ld a,24
	xor e
	ld bc,pic_mur
	call SPRXOR
	ROM_CALL(DISP_GRAPH)	;on efface le mur qui sépare Mario de sa meuf
	call pause		;pause
	call CLRGBU		;CLRDRAW
	ROM_CALL(CLEARLCD)	;CLRHOME
	ld hl,$0000
	ld ($800C),hl
	ld hl,msg_winner	;affiche message "t'as sauvé..t'es un héro..."
	ROM_CALL(D_ZT_STR)
	call pause		;pause
	call fini		;on va à la routine score
	call pause		;pause
	jp prog_start		;on retourne tout au début

vitesse2:			;regle la vitesse de la boule
	ld hl,$800
	ld (dlay),hl
	jp initialisation

vitesse3:
	ld hl,$300
	ld (dlay),hl
	jp initialisation

;=====================================
;       BOUCLE POUR SAUTER
;=====================================
jump:			;routine pour faire sauter notre man national
	ld a,(hauteur)
	cp 0
	jp z,jump_1er_etage
	cp 1
	jp z,jump_2eme_etage	
jump_1er_etage:			;sauter d'en bas
	ld a,(manx)
	cp 10
	jp z,jump_suite
	cp 20
	jp z,jump_suite
	cp 40
	jp z,jump_suite
	jp loop	
jump_2eme_etage:		;sauter de l'étage du dessus
	ld a,(manx)
	cp 40
	jp z,jump_suite
	cp 60
	jp z,jump_suite
	cp 70
	jp z,jump_suite
	jp loop
jump_suite:
	ld a,(moves)
	cp 1
	jp z,jump_droite
	cp 2
	jp z,jump_gauche
jump_droite:			;on saute vers la droite	
	call putman_droite
	ld bc,man_jump_dr
	jp jump_en_l_air
jump_gauche:			;on saute vers la gauche
	call putman_gauche
	ld bc,man_jump_ga

jump_en_l_air:		;je sais c'est con comme nom de label!
	call nom_a_la_con
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	xor a		
	ld (tempair2),a
	call balle
	call balle
	call balle
	call balle
	ld a,1
	ld (tempair2),a
	ld a,(moves)
	cp 1
	jp z,retombe_droite
	cp 2
	jp z,retombe_gauche
retombe_droite:			;si il retombe sur la droite 
	ld bc,man_jump_dr
	call rtemp
	call putman_droite
	jp loop
retombe_gauche:			;si il retombe sur la gauche
	ld bc,man_jump_ga
	call rtemp
	call putman_gauche
	jp loop
rtemp:
	call nom_a_la_con
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret
nom_a_la_con		;en fait je trouvais pas de nom pour cette routine....
	ld a,(many)	
	sub 9
	ld e,a
	ld a,(manx)
	ret

;==============================
;     ROUTINE DE LA BALLE
;==============================
balle:
	call putballe		;affiche la 1ere balle
	call putballe2		;affiche la 2eme balle
	ld a,(weapon)
	inc a
	ld (weapon),a
	ld a,(vrball)
	cp 1
	jp z,balle_droite	;la 1ere balle va à droite
	cp 2
	jp z,balle_gauche	;""""""""""""""""à gauche

balle_droite:
	ld a,(ballex)
	cp 24
	jp z,descend_dr
	cp 52			;si la balle est ds certaines positions, elle descends
	jp z,descend_dr
	cp 84
	jp z,transition		;elle tombe si x de la balle=84
	jp go_balle_dr		;sinon elle continue
descend_dr:			
	ld a,(balley)
	add a,2
	ld (balley),a
	ld a,(balle2y)
	add a,2	
	ld (balle2y),a
go_balle_dr:
	ld a,(ballex)
	add a,4
	ld (ballex),a
	call putballe
	ld a,(balle2x)
	dec a
	dec a
	dec a
	dec a
	ld (balle2x),a
	call putballe2
	call delay
	jp mort_droite

transition:			;routine pour faire tomber la boule
	ld a,12
	ld (balle2y),a
	ld a,36
	ld (balley),a
	ld a,2
	ld (vrball),a
	
balle_gauche:			;pareil que pour à droite
	ld a,(ballex)
	cp 28
	jp z,descend_ga
	cp 60
	jp z,descend_ga
	cp 0
	jp z,transition2
	jp go_balle_ga
descend_ga:
	ld a,(balley)
	add a,2
	ld (balley),a
	ld a,(balle2y)
	add a,2
	ld (balle2y),a
go_balle_ga:
	ld a,(ballex)
	dec a
	dec a
	dec a
	dec a
	ld (ballex),a
	call putballe
	ld a,(balle2x)
	add a,4
	ld (balle2x),a
	call putballe2 	
	call delay
	jp mort_gauche	

transition2:			;fait repartir la boule en haut à gauche
	ld a,36
	ld (balle2y),a
	ld a,12
	ld (balley),a
	ld a,1
	ld (vrball),a
	jp balle_droite

mort_gauche:			;on regarde si la balle 1 ne touche pas Mario
	ld a,(hauteur)		;quand elle va à gauche.
	cp 1
	jp z,mort_droite_balle2
	ld a,(tempair2)
	cp 0
	jp z,pas_mort
	ld a,(ballex)
	ld h,a
	ld a,(manx)
	cp h
	jp z,mort_spe
	ld a,(manx)
	add a,2
	cp h
	jp z,mort_spe
	ld a,(manx)
	sub 4
	cp h
	jp z,mort_spe
	ld a,(manx)
	add a,4
	cp h
	jp z,mort_spe
	ld a,(manx)
	sub 2 
	cp h
	jp z,mort_spe
	jp loop2
mort_gauche_balle2:		;pareil mais pour la 2eme balle
	ld a,(tempair2)
	cp 0
	jp z,pas_mort
	ld a,(balle2x)
	ld h,a
	ld a,(manx)
	cp h
	jp z,mort_spe
	ld a,(manx)
	add a,2
	cp h
	jp z,mort_spe
	ld a,(manx)
	sub 4
	cp h
	jp z,mort_spe
	ld a,(manx)
	add a,4
	cp h
	jp z,mort_spe
	ld a,(manx)
	sub 2
	cp h
	jp z,mort_spe
	jp loop2
mort_droite:			;pareil pour la boule 1 à droite
	ld a,(hauteur)
	cp 0
	jp z,mort_gauche_balle2
	ld a,(tempair2)
	cp 0
	jp z,pas_mort
	ld a,(ballex)
	ld h,a
	ld a,(manx)
	cp h
	jp z,mort_spe
	ld a,(manx)
	sub 2
	cp h
	jp z,mort_spe
	ld a,(manx)
	add a,2
	cp h
	jp z,mort_spe
	ld a,(manx)
	add a,4
	cp h
	jp z,mort_spe
	ld a,(manx)
	sub 4
	cp h
	jp z,mort_spe
	jp loop2

mort_droite_balle2:		;boule gauche
	ld a,(tempair2)
	cp 0
	jp z,pas_mort
	ld a,(balle2x)
	ld h,a
	ld a,(manx)
	cp h
	jp z,mort_spe
	ld a,(manx)
	sub 2
	cp h
	jp z,mort_spe
	ld a,(manx)
	add a,2
	cp h
	jp z,mort_spe
	ld a,(manx)
	add a,4
	cp h
	jp z,mort_spe
	ld a,(manx)
	sub 4
	cp h
	jp z,mort_spe
	jp loop2


pas_mort:		;si la boule ne touche rien on retourne dans la boucle "loop"
	ld a,(scr)
	inc a
	ld (scr),a
	ret

mort_spe:
	ld a,(moves)
	cp 1
	jp z,met1
	cp 2
	jp z,met2
met1:
	call putman_droite
	jp mort
met2:
	call putman_gauche	

mort:				;quand on est touché
	ld a,(many)
	ld e,a
	ld a,(manx)
	ld bc,raide
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	set	3,(IY+05)
	ld hl,35*256+12
	ld (CURSOR_X),hl
	ld hl,msg_mort
	ROM_CALL(D_ZM_STR)	;on affiche en blanc sur noir le message "You have been killed"
	res	3,(IY+05)		
	call pause
	ld a,(lives)
	dec a
	ld (lives),a		;on enleve une vie
	cp 0
	jp z,mort_definitive	;si on est à 0 vie on va à la routine mort_definitive
	xor a
	ld (levels),a		;on retourne au level 0
	jp initialisation	;on recommence au déut
mort_definitive:	
	call CLRGBU		;Clrdraw
	ROM_CALL(CLEARLCD)	;clrhome
	ld hl,30*256+30
	ld (CURSOR_X),hl
	ld hl,gameover
	ROM_CALL(D_ZM_STR)	;affiche "game over"
	call pause
	call fini		;on va voire les scores
	call pause		;pause
	jp prog_start		;recommence tout au début
;============================
;       LES LEVELS
;============================
level:				;sert à afficher les levels
	ld a,(levels)
	cp 0
	jp z,affiche_level1
	cp 1
	jp z,affiche_level2
	cp 2
	jp z,affiche_level3
affiche_level1:			;on affiche les levels 0 et 1 qui sont identiques
	call affiche_standart	;on affiche le bas de l'image qui se répète partout
	ld hl,first_bg	
	ld de,$88B8	
	ld bc,264		
	ldir			
	ROM_CALL(DISP_GRAPH)	;et enfin affiche le haut	
	ret
affiche_level2:
	call affiche_standart
	ld hl,first_bg	
	ld de,$88B8	
	ld bc,264		
	ldir			
	ROM_CALL(DISP_GRAPH)	
	ld hl,bg_level2
	ld de,GRAPH_MEM+576
	ld bc,84
	ldir
	ROM_CALL(DISP_GRAPH)
	ret
affiche_level3:
	call affiche_standart
	ld hl,second_bg
	ld de,$88B8
	ld bc,264
	ldir
	ROM_CALL(DISP_GRAPH)	;pareil mais on affiche pas le même haut
	ld hl,bg_level2
	ld de,GRAPH_MEM+576
	ld bc,84
	ldir
	ROM_CALL(DISP_GRAPH)
	ret
affiche_standart:	
	CALL_(CLRGBU)		;appelle de la routine pour effacer l'écran
	ld hl,bg_standart		 
	ld de,GRAPH_MEM+264
	ld bc,420
	ldir			
	ROM_CALL(DISP_GRAPH)
	ret
	
;======================================================
;       toutes les routines d'affichage
;=====================================================
putman_gauche:		;routine permettant d'afficher le man tourné vers la gauche
	ld a,(many)
	ld e,a
	ld a,(manx)
	ld bc,man_gauche	;on charge l'image du bonhomme en mémoire
	call SPRXOR		;on appelle la routine de movax pour l'affciher
	ROM_CALL(DISP_GRAPH)	;on l'affiche
	ret			;et enfin on retourne dans la boucle

putman_marche_gauche:
	ld a,(many)
	ld e,a
	ld a,(manx)
	ld bc,man_gauche_marche
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret

putman_droite:		;pareil vers la droite
	ld a,(many)
	ld e,a
	ld a,(manx)
	ld bc,man_droite	
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret	

putman_marche_droite:
	ld a,(many)
	ld e,a
	ld a,(manx)
	ld bc,man_droite_marche
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret

putballe:
	ld a,(vrball)
	cp 1
	jp z,nom
	ld a,(weapon)
	cp 0
	call z,putballetemp
	cp 1
	call z,putballetemp2
	cp 2
	call z,putballetemp3
	cp 3
	jp z,casindet
	ret
nom:
	ld a,(weapon)
	cp 0
	call z,putballetemp4
	cp 1
	call z,putballetemp5
	cp 2
	call z,putballetemp6
	cp 3
	jp z,casindet
	ret
casindet:
	xor a
	ld (weapon),a
	jp putballe
putballetemp:		;affiche la bouboule
	ld a,(balley)
	ld e,a
	ld a,(ballex)
	ld bc,pic_balle
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret
putballetemp2:		;affiche la bouboule
	ld a,(balley)
	ld e,a
	ld a,(ballex)
	ld bc,pic_balle2
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret
putballetemp3:		;affiche la bouboule
	ld a,(balley)
	ld e,a
	ld a,(ballex)
	ld bc,pic_balle3
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret
putballetemp4:		;affiche la bouboule
	ld a,(balley)
	ld e,a
	ld a,(ballex)
	ld bc,pic_balle4
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret
putballetemp5:		;affiche la bouboule
	ld a,(balley)
	ld e,a
	ld a,(ballex)
	ld bc,pic_balle5
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret
putballetemp6:		;affiche la bouboule
	ld a,(balley)
	ld e,a
	ld a,(ballex)
	ld bc,pic_balle6
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret

putballe2:
	ld a,(vrball)
	cp 2
	jp z,nom2
	ld a,(weapon)
	cp 0
	call z,putballe2temp
	cp 1
	call z,putballe2temp2
	cp 2
	call z,putballe2temp3
	cp 3
	jp z,casindet
	ret
nom2:
	ld a,(weapon)
	cp 0
	call z,putballe2temp4
	cp 1
	call z,putballe2temp5
	cp 2
	call z,putballe2temp6
	cp 3
	jp z,casindet
	ret
putballe2temp:		;affiche la bouboule
	ld a,(balle2y)
	ld e,a
	ld a,(balle2x)
	ld bc,pic_balle
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret
putballe2temp2:		;affiche la bouboule
	ld a,(balle2y)
	ld e,a
	ld a,(balle2x)
	ld bc,pic_balle2
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret
putballe2temp3:		;affiche la bouboule
	ld a,(balle2y)
	ld e,a
	ld a,(balle2x)
	ld bc,pic_balle3
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret
putballe2temp4:		;affiche la bouboule
	ld a,(balle2y)
	ld e,a
	ld a,(balle2x)
	ld bc,pic_balle4
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret
putballe2temp5:		;affiche la bouboule
	ld a,(balle2y)
	ld e,a
	ld a,(balle2x)
	ld bc,pic_balle5
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret
putballe2temp6:		;affiche la bouboule
	ld a,(balle2y)
	ld e,a
	ld a,(balle2x)
	ld bc,pic_balle6
	call SPRXOR
	ROM_CALL(DISP_GRAPH)
	ret


;======================
;    GAME PAUSE
;======================
gamepause:		;une ptite pause dans le jeu
	ROM_CALL(BACKUP_DISP)
	ROM_CALL(CLEARLCD)
	ld hl,0
	ld ($800C),hl
	ld hl,affiche_pause	;on affiche le texte "paused..."
	ROM_CALL(D_ZT_STR)
ptite_loop:
	CALL GET_KEY
	cp $30
	jp z,power_down		;si on press alpha on eteint la calc
	cp $2F
	jp z,pause_high		;si """""""" MATH on montre les high scores
	cp $36
	jp z,return		;si c'est 2nd on retourne dans le jeu
	jp ptite_loop

pause_high:			
	CALL_(affiche_meilleur)	;on affiche les high scores
	call pause		;pause
	jp gamepause 		;retourne dans la ptite loop
return:
	ROM_CALL(RESTOR_DISP)
	jp loop
power_down:
	CALL $07EA				;éteint la caltos
	jp gamepause			;retourne dans la boucle quand on l'a ralumée 

exit:				;on se casse du jeu	
	ret

;=======================
pause:			;routine de pause
	call GET_KEY		;on attend qu'une touche soit préssée
	cp $36			;on rappelle a quelconque
	jp nz,pause		;si on a tapé aucune touche on refait un tour
	ret			;retourne ds la prog si un etouche a été  préssée

delay:			; permet de créer un ptit retard et donc un peu de tmps d'attente
	PUSH AF
	PUSH BC
	ld bc,(dlay)		;définit le retard comme étant de 2000 (2000->bc)
delayloop:
	dec bc			;on fait (bc-1)->bc
	ld a,b	
	or c
	jr nz,delayloop		;tant que bc n'est pas égal à 0 on refait un tour
	POP BC
	POP AF
	ret			;sinon on quitte cette routine

CLRGBU:			;cette routine permet d'effacer tout l'écran (comme CLRDRAW en basic)
	ld hl,GRAPH_MEM
	ld de,GRAPH_MEM+1
	ld bc,768
	ld (hl),0
	ldir
	ret

;============================
;   routine du score
;============================
score:			;on affiche le bas de l'écran "Lives:..  Keys:... SCr:.."
	SET 7,(IY+$14)		;on sauvegarde ces textes pour pas qu'ils s'effacent
	ld hl,57*256+0
	ld (CURSOR_X),hl
	ld hl,affiche_lives	;affiche "lives:"
	ROM_CALL(D_ZM_STR)
	ld hl,57*256+32
	ld (CURSOR_X),hl
	ld hl,affiche_keys	;affiche "keys:"
	ROM_CALL(D_ZM_STR)
	ld hl,57*256+65
	ld (CURSOR_X),hl
	ld hl,affiche_score	;affiche "Scr:"
	ROM_CALL(D_ZM_STR)
	ld hl,57*256+52
	ld (CURSOR_X),hl
	ld a,(keys)
	add a,48
	ld c,a
	ROM_CALL(M_CHARPUT)	;on affiche le nbre de clefs
	ld hl,57*256+20
	ld (CURSOR_X),hl
	ld hl,(lives)		;le nbre de vies
	call DispHL
	ld hl,57*256+81
	ld (CURSOR_X),hl
	ld hl,(scr)		;et enfin le score
	call DispHL
	RES 7,(IY+$14)
	ret			

DispHL:				;routine pour afficher des caractères
        push de
        push hl
        ld de,string+5
        xor a
        ld (de),a
Repeat:
        call UNPACK_HL
        add a,'0'
        dec de
        ld (de),a
        ld a,h
        or l
        jr nz,Repeat
        ex de,hl
        ROM_CALL(D_ZM_STR)
        pop hl
        pop de
        ret
;==============================
;La routine pour le scrolling (défilement de l'écran d'intro)
;==============================

start_scroll:				;cette routine permet de faire défiler l'écran vers le haut
	ld	b,64			;je l'ai emprunté à Nicolas Hannebicque de son Master Mind 82
scroll:				 	;merci à lui encore une fois! 
	push	bc			
	ld	hl,GRAPH_MEM+12	
	ld	de,GRAPH_MEM
	ld	bc,768
	ldir
	ld	a,0
	ld	de,GRAPH_MEM+756
	ld	(de),a
	ld	de,GRAPH_MEM+757
	ld	(de),a
	ld	de,GRAPH_MEM+758
	ld	(de),a
	ld	de,GRAPH_MEM+759
	ld	(de),a
	ld	de,GRAPH_MEM+760
	ld	(de),a
	ld	de,GRAPH_MEM+761
	ld	(de),a
	ld	de,GRAPH_MEM+762
	ld	(de),a
	ld	de,GRAPH_MEM+763
	ld	(de),a
	ld	de,GRAPH_MEM+764
	ld	(de),a
	ld	de,GRAPH_MEM+765
	ld	(de),a
	ld	de,GRAPH_MEM+766
	ld	(de),a
	ld	de,GRAPH_MEM+767
	ld	(de),a
	ROM_CALL(DISP_GRAPH)
	pop bc			
	djnz	scroll
	ret

;==============================
;la routine pour le classement	;cette routine a été emprunté à Nicolas Hannebicque (et oui encore lui!)
;==============================	;de son Ultimate Pocker.
						;J'ai préféré vous laisser ses propres commentaires.
						;Merci à lui encore une fois.
fini:
	push	af			; sauvegarde le contenu de f en particulier
	ld	hl,(scr)		; compare le score
	ld	de,(moins_bon)	; et le moins bon des meilleurs scores
	call	CP_HL_DE		; compare les valeurs hl et de
	jr	c,gagne_seul	; s'il est inférieur ou égal, va à
	jr	z,gagne_seul	; gagné seulement
	ld	(moins_bon),hl	; charge le nouveau score en tant que moins bon score
	ld	hl,moins_bon+2	; pointe le nom du dernier high-score
	CALL_(entree_nom)		; rentre le nom de (l'heureux ?) joueur
	CALL_(reclasse)		; reclasse les scores
	CALL_(affiche_meilleur)	; affiche les meilleurs scores
	pop	af			; restaure f
	ret

gagne_seul:
	CALL_(affiche_meilleur)
	pop	af			; on restitue à a et f leurs valeurs
	ret				; retourne

affiche_meilleur:			; affiche ce qu'on appelle communément les high-scores
	ROM_CALL(CLEARLCD)	; faciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiile :)
	ld	hl,$0000		; curseur
	ld	($800C),hl		; texte
	ld	hl,msg_meilleurs	; pointe le message du haut
	set	3,(iy+$5)		; met en blanc sur noir
	ROM_CALL(D_ZT_STR)	; affiche la chaîne
	ld	b,5			; 5 scores à afficher
	ld	hl,hauts_scores	; pointe les hauts scores
	ld	de,$0000		; met 0 dans de qui servira de position du curseur texte
bouboucle:				; délire perso (il faut bien péter les plombs de temps en temps)
	push	bc			; sauve le compteur b
	inc	de			; incrémente la position du curseur d'1 en ordonnée
	push	de			; la sauve
	push	hl			; sauve l'adresse du high score courant
	bit	3,(iy+$5)		; change la couleur
	jr	z,apres		; du texte
	res	3,(iy+$5)		; à afficher
	jr	apres2		; regardez de plus près
apres:				; c'est
	set	3,(iy+$5)		; compréhensible
apres2:
	push	hl			; resauve cette adresse
	inc	hl			; l'incrémente
	inc	hl			; re
	ld	($800C),de		; position du curseur texte
	ROM_CALL(D_ZT_STR)	; affiche le nom du high-score courant
	ld	a,d			; ajoute
	add	a,$0B			; 11
	ld	d,a			; à l'abscisse
	ld	($800C),de		; du curseur texte
	pop	hl			; restaure l'adresse initiale du high-score courant
	ld	e,(hl)		; met dans de
	inc	hl			; le nombre
	ld	d,(hl)		; contenu à l'adresse hl
	ld	h,d			; transfert ensuite le
	ld	l,e			; nombre de dans hl
	ROM_CALL(D_HL_DECI)	; affiche le nombre hl
	pop	hl			; restaure hl
	ld	bc,12			; met 12 dans bc
	add	hl,bc			; ajoute 12 à l'adresse hl pour pointer le score suivant
	pop	de			; restaure le curseur texte
	pop	bc			; restaure le compteur
	djnz	bouboucle		; boucle
	set	3,(iy+$5)		; texte en blanc sur noir
	ld	hl,$0006		; affiche
	ld	($800C),hl		; les
	ld	hl,msg_fin1		; messages
	ROM_CALL(D_ZT_STR)	; de fin
	res	3,(iy+$5)
	ret

reclasse:				; classe les scores dans l'ordre
	ld	b,4			; méthode du tri par bulle, comme pour le tri des figures
tri_bulle1:				; 2 boucles qui se répètent chacune 4 fois
	push	bc			; sauve le compteur
	ld	hl,hauts_scores-12; pointe le premier high-score - 12 octets
	ld	de,hauts_scores	; pointe le premier high-score
	ld	b,4			; compteur à 4
tri_bulle2:				; 2ème boucle
	push	bc			; sauve compteur
	ld	bc,12			; ajoute
	add	hl,bc			; à l'adresse hl
	push	hl			; 12 puis sauve hl
	ex	de,hl			; pour ajouter 12 à de,
	ld	bc,12			; on échange pour calculer avec hl
	add	hl,bc			; on ajoute à hl bc
	ex	de,hl			; puis on remet le résultat en de
	pop	hl			; on restaure hl
	push	de			; on sauve de
	push	hl			; on sauve hl
	push	de			; sauvegardes...
	push	hl			;
	push	bc			;
	ld	b,h			; compare
	ld	c,l			; les
	ld	a,(bc)		; paires
	ld	l,a			; de 
	inc	bc			; registres
	ld	a,(bc)		; hl
	ld	h,a			; et
	ld	b,d			; de
	ld	c,e			; |
	ld	a,(bc)		; |
	ld	e,a			; |
	inc	bc			; V
	ld	a,(bc)
	ld	d,a
	push	hl
	ld	h,d
	ld	l,e
	pop	hl
	ex	de,hl
	call	CP_HL_DE
	jr	c,plus_bas
	pop	bc			; dépope, etc
	pop	hl
	pop	de
	push	hl
	push	de
	ex	de,hl			; copie le score 2 dans l'espace temporaire imparti
	ld	de,place_temp	; 12 octets à copier (10 de nom + 2 de score)
	ld	bc,12
	ldir
	pop	de
	pop	hl
	push	de			; copie le score 1 dans le score 2
	push	hl			; même principe
	ld	bc,12
	ldir
	pop	hl
	pop	de
	ex	de,hl			; copie l'espace temporaire dans le score 1
	ld	hl,place_temp
	ld	bc,12
	ldir				; voyez les notes relatives à la fonction ldir : très utile
	jr	plus_bas2		; quand on veut copier une zone mémoire vers une autre
plus_bas:
	pop	bc
	pop	hl
	pop	de
plus_bas2:
	pop	hl			; dépile tout ce qu'on avait empilé sinon CRASH !!!!!!
	pop	de			; boucle là où il faut boucler
	pop	bc			; etc...
	djnz	tri_bulle2
	pop	bc
	djnz	tri_bulle1
	ret

;======================
;la routine "input"		;(encore issue de l'Ultimate Pocker)		
;======================
entree_nom:				; pour rentrer ton nom si t'es le plus beau et le plus fort
	push	hl			; sauve la position moins_bon+2 en hl
	ROM_CALL(CLEARLCD)	; c'est dur !
	set	3,(iy+$5)		; pour écrire en blanc sur noir
	ld	hl,$0000		; curseur
	ld	($800C),hl		; texte
	ld	hl,msg_bravo	; message
	ROM_CALL(D_ZT_STR)	; l'affiche
	res	3,(iy+$5)		; remet en noir sur blanc
	ld	hl,$0304		; charge la nouvelle position
	ld	($800C),hl		; du curseur texte
	pop	hl			; restaure hl
	ld	e,0			; compte le nombre de lettres rentrées
attendre_touche:
	push	hl			; sauvegarde la position car GET_KEY utilise hl
	call	GET_KEY		; explicite
	cp	$38			; touche DEL : revient en arrière
	jr	z,retour
	cp	$09			; touche entrée : nom=ok
	jr	z,nom_ok
	or	a			; rappelle a
	jr	nz,saisie_lettre	; si on avait appuyé sur une touche on va la traiter
	pop	hl			; restitue la position en mémoire du nom du dernier high-score
	jr	attendre_touche	; boucle
saisie_lettre:
	ld	hl,lettres		; pointe sur le tableau de correspondance entre touches->lettres
	ld	bc,26			; il y a 26 lettres à comparer
	cpir				; compare le truc pointé par hl avec a (notre touche tapée)
					; jusqu'à temps que bc=0 ou que (hl)=a
	ld	d,c			; si on trouve la lettre, c est l'index de cette lettre
	pop	hl			; hl=position dans la chaîne
	jr	nz,attendre_touche; si on n'a pas eu d'égalité avec une quelconque touche
					; ie Z=0 <=> NZ=1, on retourne saisir une touche
	ld	a,65			; 65 est le code ASCII de A
	add	a,d			; a contient le code ASCII de la bonne lettre (index+décalage ASCII)
mettre_lettre:
	ld	c,a			; c contient le lettre à afficher, enfin son code...
	ld	a,9			; nombre maximal de lettres pour le nom
	cp	e			; le compare à la taille du nom déjà inscrit
	jr	z,attendre_touche	; s'il y a dix letttres affichées, retourne plus haut
	ld	(hl),c		; sinon mémorise la lettre
	inc	hl			; pointe la lettre suivante
	inc	e			; incrémente le compteur de lettres
	ld	a,c			; restitue à a la lettre à afficher
	ROM_CALL(TX_CHARPUT)	; l'affiche
	jr	attendre_touche	; retourne à la saisie de touches
retour:
	pop	hl			; restitue à hl l'adresse qu'il pointait (le nom du joueur)
	ld	a,e			; charge dans l'accumulateur le compteur de lettres affichées
	or	a			; regarde si le nombre de lettres affichées est égal à 0
	jr	z,attendre_touche	; si tel est le cas le retour est impossible donc on retourne en haut
	dec	e			; décrémente le nombre de lettres entrées
	dec	hl			; et l'adresse pointée
	push	hl			; sauve cette adresse
	ld	hl,$800D		; hl pointe le curseur texte (x)
	dec	(hl)			; décrémente (hl) donc x
	ld	a,32			; affiche un espace au dessus des autres caractères
	ROM_CALL(TX_CHARPUT)	; l'affiche
	dec	(hl)			; décrémente le curseur texte
	pop	hl			; restaure hl
	jr	attendre_touche	; attend une nouvelle touche
nom_ok:
	pop	hl			; hl position actuelle dans le nom du joueur
	ld	(hl),0		; affiche un zéro NECESSAIRE à la fin de la chaîne
	ret				; retourne, idiot !

; Voici l'interface entre numéro de touche et lettre correspondante

lettres:
	.db $1A,$22,$2A			; Z Y X
	.db $0B,$13,$1B,$23,$2B		; W V U T S
	.db $0C,$14,$1C,$24,$2C		; R Q P O N
	.db $0D,$15,$1D,$25,$2D		; M L K J I
	.db $0E,$16,$1E,$26,$2E		; H G F E D
	.db $1F,$27,$2F			; C B A

;======================================================
;======================================================

;voici SPRXOR une routine sympa permettant l'affichage d'un sprite
;tout est expliqué en-dessous en anglais.

;ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄ¿
;³ÛÛÛÛÛ Z80 ÛÛÛÛÛÛ³    Sprite83    ³ÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ³ movax ³ÛÛÛÛÛÛÛÛÛÛÛÛ³
;ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÙ

; Sprite xor routine v1.0
; Coded by Hannes Edfeldt in 1997

; This routine uses xor to draw the sprite, therefore you can erase the sprite
; by just drawing it again at the same x and y coordinates. See xordemo.z80
; for an example of how to use this routine.

; Feel free to use this routine in your own productions as long as you give me
; some credit.

; This file should of course be viewed in a DOS texteditor ;)

; Hannes Edfeldt -+- movax@algonet.se -+- http://www.algonet.se/~movax


;ÜÛÛÛÛÛÛÛÛÛÛÛÛß SPRXOR ßÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ
;ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
;³ Xor 8x8 sprite þ a=x, e=y, bc=sprite address                               ³
;ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
SPRXOR:

        push    bc              ; Save sprite address

;ÛÛÛÛ   Calculate the address in graphbuf   ÛÛÛÛ

        ld      hl,0            ; Do y*12
        ld      d,0
        add     hl,de
        add     hl,de
        add     hl,de
        add     hl,hl
        add     hl,hl

        ld      d,0             ; Do x/8
        ld      e,a
        srl     e
        srl     e
        srl     e
        add     hl,de

        ld      de,$88B8
        add     hl,de           ; Add address to graphbuf

        ld      b,00000111b     ; Get the remainder of x/8
        and     b
        cp      0               ; Is this sprite aligned to 8*n,y?
        jp      z,ALIGN


;ÛÛÛÛ   Non aligned sprite blit starts here   ÛÛÛÛ

        pop     ix              ; ix->sprite
        ld      d,a             ; d=how many bits to shift each line

        ld      e,8             ; Line loop
LILOP:  ld      b,(ix+0)        ; Get sprite data

        ld      c,0             ; Shift loop
        push    de
SHLOP:  srl     b
        rr      c
        dec     d
        jp      nz,SHLOP
        pop     de

        ld      a,b             ; Write line to graphbuf
        xor     (hl)
        ld      (hl),a
        inc     hl
        ld      a,c
        xor     (hl)
        ld      (hl),a

        ld      bc,11           ; Calculate next line address
        add     hl,bc
        inc     ix              ; Inc spritepointer

        dec     e
        jp      nz,LILOP        ; Next line

        jp      DONE1


;ÛÛÛÛ   Aligned sprite blit starts here   ÛÛÛÛ

ALIGN:                          ; Blit an aligned sprite to graphbuf
        pop     de              ; de->sprite
        ld      b,8
ALOP1:  ld      a,(de)
        xor     (hl)
        ld      (hl),a
        inc     de
        push    bc
        ld      bc,12
        add     hl,bc
        pop     bc
        djnz    ALOP1

DONE1:
        ret
;ÜÛÛÛÛÛÛÛÛÛÛÛÛÜ SPRXOR ÜÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ


;============================================
; affichage des textes
;============================================

gameover:	.db "Game  Over",0	
msg_mort:	.db " You have been killed ! ",0
msg_key:	.db " You have a key !!",0
msg_winner:	.db "Congratulation, ",
		.db "you have saved  ",
		.db "princess Paulina",
		.db "                ",
		.db "You're a hero ! ",
		.db "Your next night "
		.db "will be funny...",0 

affiche_lives: 	.db "lives:",0
affiche_keys:  	.db "Keys:",0
affiche_score: 	.db "Scr:",0
affiche_pause:	.db "Paused          ",
		.db "                ",
		.db "2nd   returns   ",
		.db "ALPHA power-down",
		.db "MATH high scores",0			 
msg_bravo:
	.db	" Congratulation "
	.db	" a high-score ! "
	.db	"Your name please",0
msg_fin1:
	.db "   Press 2nd    ",	
	.db "    to Quit    ",0
msg_meilleurs:
	.db	"=>HIGH SCORES!<=",0
hauts_scores:
	.db	$00,$00
	.db	"Donkey   ",0
	.db	$00,$00
	.db	"Donkey   ",0
	.db 	$00,$00
	.db	"Donkey   ",0
	.db	$00,$00
	.db	"Donkey   ",0
moins_bon:
	.db	$00,$00
	.db	"Donkey   ",0

;================================
;   Les Sprites
;================================
pic_key:
	.db %00000000
	.db %00000000
	.db %00000000
	.db %00000000
	.db %11111000
	.db %10011000
	.db %00000000
	.db %00000000
pic_mur:
	.db %00011100
	.db %00011100
	.db %00010100
	.db %00011100
	.db %00011100
	.db %00011100
	.db %00010100
	.db %00011100
man_droite:
	.db %00011100
	.db %00011000
	.db %00111100
	.db %01011010
	.db %00011000
	.db %00100100
	.db %00100100
	.db %01100110
man_droite_marche:
	.db %00011100
	.db %00011000
	.db %00111100
	.db %01011010
	.db %00011000
	.db %00010100
	.db %00011000
	.db %00111100
man_jump_dr:
	.db %00011100
	.db %00011000
	.db %00111100
	.db %01011010
	.db %00011001
	.db %01110111
	.db %01000000
	.db %00000000

man_gauche:
	.db %00111000
	.db %00011000
	.db %00111100
	.db %01011010
	.db %00011000
	.db %00100100
	.db %00100100
	.db %01100110
man_gauche_marche:
	.db %00111000
	.db %00011000
	.db %00111100
	.db %01011010
	.db %00011000
	.db %00101000
	.db %00011000
	.db %00111100
man_jump_ga:
	.db %00111000
	.db %00011000
	.db %00111100
	.db %01011010
	.db %10011000
	.db %11101110
	.db %00000010
	.db %00000000
raide:
	.db %00000000
	.db %00000000
	.db %00000000
	.db %00000000
	.db %00000000
	.db %00000000
	.db %00011000
	.db %11111111
pic_balle:
	.db %00000000
	.db %00000000
	.db %00000000
	.db %00001100
	.db %01111110
	.db %11011110
	.db %11111110
	.db %01111100
pic_balle2:
	.db %00000000
	.db %00000000
	.db %00111000
	.db %01111100
	.db %11011110
	.db %11111110
	.db %11111100
	.db %01111000
pic_balle3:
	.db %00000000
	.db %00111000
	.db %01111100
	.db %01011100
	.db %11111100
	.db %11111100
	.db %01111100
	.db %01111100
pic_balle4:
	.db %00000000
	.db %00000000
	.db %00000000
	.db %00110000
	.db %01111110
	.db %01111011
	.db %01111111
	.db %00111110
pic_balle5:
	.db %00000000
	.db %00000000
	.db %00011100
	.db %00111110
	.db %01111011
	.db %01111111
	.db %00111111
	.db %00011110
pic_balle6:
	.db %00000000
	.db %00011100
	.db %00111110
	.db %00111010
	.db %00111111
	.db %00111111
	.db %00111110
	.db %00111110
intro:			;code en héxadécimal de l'image de présentation
	.db 255,255,255,255,255,255,255,255,255,255,255,254
	.db 128,48,6,16,1,176,0,1,192,1,128,50
	.db 128,48,6,25,66,85,86,162,0,1,128,50
	.db 255,255,254,20,130,85,84,194,0,63,255,254
	.db 255,255,254,25,1,148,150,129,208,63,255,254
	.db 140,3,0,0,0,0,0,0,0,48,24,2
intro2:
	.db 128,48,0,0,0,0,0,0,0,0,0,50
	.db 255,255,0,0,0,0,0,0,0,0,15,254
	.db 255,255,0,0,0,0,0,0,0,0,15,254
	.db 140,3,0,0,0,0,0,0,0,0,12,2
	.db 140,3,0,0,0,3,252,0,0,0,12,2
	.db 255,255,0,0,0,15,255,0,0,0,255,254
	.db 255,255,0,0,0,63,255,128,0,0,255,254
	.db 128,48,0,252,0,127,255,192,0,0,192,50
	.db 128,48,1,3,0,93,255,224,0,0,192,50
	.db 255,255,2,0,128,73,255,231,128,63,255,254
	.db 255,255,4,0,128,91,255,248,64,63,255,254
	.db 140,3,4,0,129,251,247,240,32,48,12,2
	.db 140,3,7,0,134,14,227,224,16,48,12,2
	.db 255,255,7,199,9,96,99,224,16,63,255,254
	.db 255,255,15,253,8,0,99,224,8,63,255,254
	.db 128,48,31,243,113,0,7,160,8,0,192,50
	.db 128,48,63,254,242,4,7,176,8,0,192,50
	.db 255,255,63,253,226,12,7,208,120,63,255,254
	.db 255,255,127,255,192,24,15,255,252,63,255,254
	.db 140,3,127,255,255,240,31,255,254,48,12,2
	.db 140,3,127,255,224,0,255,255,255,48,12,2
	.db 255,255,255,255,240,0,255,255,255,191,255,254
	.db 255,255,255,255,254,7,255,255,255,191,255,254
	.db 128,48,255,255,255,255,255,255,255,192,192,50
	.db 128,48,255,255,252,0,255,255,255,192,192,50
	.db 255,243,255,255,240,0,63,255,255,240,255,254
	.db 255,243,255,255,240,0,31,255,255,240,255,254
	.db 140,3,0,255,224,0,7,255,192,48,12,2
	.db 140,3,0,255,192,0,3,255,192,48,12,2
	.db 255,255,255,255,255,255,255,255,255,255,255,254
	.db 255,255,255,255,255,255,255,255,255,255,255,254
	.db 128,48,12,3,0,192,48,12,3,0,192,50
	.db 128,48,12,3,0,192,48,12,3,0,192,50
	.db 255,255,255,255,255,255,255,255,255,255,255,254
	.db 255,255,255,255,255,255,255,255,255,255,255,254
	.db 140,3,0,192,48,12,3,0,192,48,12,2
	.db 140,3,0,192,48,12,3,0,192,48,12,2
	.db 255,255,255,255,255,255,255,255,255,255,255,254
	.db 255,255,255,255,255,255,255,255,255,255,255,254
	.db 128,48,12,3,0,192,48,12,3,0,192,50
	.db 128,48,12,3,0,192,48,12,3,0,192,50
	.db 255,255,255,255,255,255,255,255,255,255,255,254
initial_pic:
	.db 255,255,255,255,255,255,255,255,255,255,255,254
	.db 128,0,0,0,0,0,0,0,0,0,0,2
	.db 128,255,135,249,239,59,188,241,223,253,255,130
	.db 128,192,72,37,41,76,197,33,87,101,33,130
	.db 128,192,48,19,41,73,229,33,36,53,63,130
	.db 128,103,17,17,169,147,82,65,41,18,51,130
	.db 128,101,22,208,179,24,82,129,14,210,32,2
	.db 128,101,19,144,19,41,136,129,5,154,32,2
	.db 128,99,20,80,18,41,117,1,38,92,47,130
	.db 128,96,16,20,20,73,149,1,50,28,61,130
	.db 128,48,40,38,22,36,21,1,49,26,37,130
	.db 128,48,40,37,22,36,117,1,41,106,49,130
	.db 128,63,199,220,253,247,135,1,231,249,239,2
	.db 128,0,0,0,0,0,0,0,0,0,0,2
	.db 255,255,255,255,255,255,255,255,255,255,255,254
initial_pic2:
	.db 255,255,255,255,255,255,255,255,255,255,255,254
	.db 128,0,0,0,0,0,0,0,0,0,0,2
	.db 128,255,135,249,239,59,188,241,223,253,255,130
	.db 128,255,207,253,239,127,253,225,223,253,255,130
	.db 128,255,255,255,239,127,253,225,255,253,255,130
	.db 128,127,255,255,239,255,223,193,255,255,243,130
	.db 128,125,254,255,255,255,223,129,254,255,224,2
	.db 128,125,255,255,255,239,143,129,255,255,224,2
	.db 128,127,255,255,255,239,247,1,255,255,239,130
	.db 128,127,255,255,255,207,247,1,255,255,255,130
	.db 128,63,239,255,255,231,247,1,255,251,255,130
	.db 128,63,239,253,255,231,247,1,239,251,255,130
	.db 128,63,199,220,253,247,135,1,231,249,239,2
	.db 128,0,0,0,0,0,0,0,0,0,0,2
	.db 255,255,255,255,255,255,255,255,255,255,255,254

bg_standart:			;code en hexa du bas de l'écran que l'on retrove tt le temps 
	.db 166,76,153,50,255,187,118,224,0,0,0,0
	.db 153,179,102,205,34,68,137,16,0,0,0,0
	.db 128,0,0,1,147,38,76,155,183,110,208,0
	.db 144,32,129,2,108,217,179,100,72,145,40,0
	.db 128,0,0,0,0,0,0,2,100,201,152,0
	.db 128,8,16,32,32,59,65,5,155,54,104,0
	.db 132,0,0,0,0,36,224,0,0,0,8,0
	.db 128,22,35,98,54,64,19,20,217,50,104,0
	.db 128,41,252,159,201,128,28,239,39,255,240,0
	.db 128,160,0,0,0,0,0,0,0,99,0,0
	.db 144,64,0,0,0,0,0,0,0,99,0,0
	.db 128,128,0,0,0,0,0,0,0,127,0,0
	.db 129,0,0,0,0,0,0,0,0,127,0,0
	.db 218,0,0,0,0,0,0,0,0,99,0,0
	.db 36,0,0,0,0,0,0,0,0,99,0,0
	.db 0,0,0,0,0,0,0,0,0,127,0,0
	.db 0,0,0,0,0,0,0,0,0,127,0,0
	.db 0,0,0,0,0,0,0,0,0,99,0,0
	.db 0,0,0,0,0,0,0,0,0,99,0,0
	.db 0,0,0,0,0,0,0,0,0,127,0,0
	.db 0,0,0,0,0,0,0,0,0,127,0,0
	.db 0,0,0,0,0,0,0,0,0,99,0,0
	.db 0,0,0,0,0,0,0,3,219,247,110,220
	.db 0,0,0,0,0,0,0,6,36,72,145,151
	.db 0,0,0,3,183,110,221,189,50,100,201,151
	.db 0,0,0,6,72,145,34,70,205,155,54,111
	.db 110,221,187,119,100,201,147,36,0,0,0,7
	.db 145,34,68,138,219,54,108,216,66,4,32,71
	.db 201,147,38,76,0,0,0,0,0,0,0,7
	.db 182,108,217,176,16,65,2,4,16,65,4,7
	.db 129,0,64,64,0,0,0,0,0,0,0,7
	.db 136,4,4,4,4,8,32,129,4,16,64,135
	.db 128,0,0,0,0,0,0,0,0,0,0,7
	.db 255,255,255,255,255,255,255,255,255,255,255,255
	.db 255,255,255,255,255,255,255,255,255,255,255,255

bg_level2:
	.db 198,221,187,119,100,201,147,36,0,0,0,7
	.db 199,34,68,138,219,54,108,216,66,4,32,71
	.db 198,147,38,76,0,0,0,0,0,0,0,7
	.db 254,108,217,176,16,65,2,4,16,65,4,7
	.db 254,0,64,64,0,0,0,0,0,0,0,7
	.db 198,4,4,4,4,8,32,129,4,16,64,135
	.db 198,0,0,0,0,0,0,0,0,0,0,7

first_bg:			;affiche le haut des 2 premiers levels
	.db 136,32,0,0,0,0,0,0,32,0,16,10
	.db 128,1,4,16,66,59,64,137,141,147,100,226
	.db 145,8,65,4,0,36,226,6,114,124,159,30
	.db 128,0,0,0,144,64,16,184,0,0,0,0
	.db 108,145,147,101,239,128,31,88,0,0,0,0
	.db 19,255,252,158,0,0,3,24,0,0,0,0
	.db 0,31,192,0,0,0,3,248,0,0,0,0
	.db 0,24,192,0,0,0,3,248,0,0,0,0
	.db 0,24,192,0,0,0,3,24,0,0,0,0
	.db 0,31,192,0,0,0,3,0,0,0,0,0
	.db 0,31,192,0,0,0,0,0,0,0,0,0
	.db 0,24,192,0,0,0,0,0,0,0,0,0
	.db 0,24,192,0,0,0,0,0,0,0,0,0
	.db 0,31,192,0,0,0,0,0,0,0,0,0
	.db 0,31,192,0,0,0,0,0,0,0,0,0
	.db 0,24,192,0,0,0,0,0,0,0,0,0
	.db 0,24,192,0,0,0,0,0,0,0,0,0
	.db 0,31,192,0,0,0,3,24,0,0,0,0
	.db 0,31,192,0,0,0,3,24,0,0,0,0
	.db 0,24,192,0,0,0,3,248,0,0,0,0
	.db 187,118,237,216,0,0,3,248,0,0,0,0
	.db 196,137,18,38,0,0,3,24,0,0,0,0

second_bg:			;affiche le haut du level avec le boss
	.db 0,0,0,28,0,0,64,0,0,0,16,10
	.db 0,0,3,156,0,0,100,32,141,147,100,226
	.db 0,0,3,20,0,0,32,7,242,124,159,30
	.db 0,0,7,156,0,0,32,136,0,0,0,0
	.db 0,0,11,92,248,0,32,16,0,0,0,0
	.db 0,0,7,156,152,0,20,32,0,0,0,0
	.db 0,12,7,148,0,0,17,32,0,0,0,0
	.db 0,62,15,220,0,0,14,192,0,0,0,0
	.db 1,251,14,223,184,0,0,0,0,0,0,0
	.db 3,233,9,34,70,0,0,0,0,0,0,0
	.db 7,231,9,147,38,0,0,0,0,0,0,0
	.db 7,251,14,108,218,0,0,0,0,0,0,0
	.db 7,252,7,255,252,0,0,0,0,0,0,0
	.db 7,240,0,1,140,0,0,0,0,0,0,0
	.db 15,184,0,1,140,0,0,0,0,0,0,0
	.db 31,184,0,1,252,0,0,0,0,0,0,0
	.db 63,159,0,1,252,0,0,0,0,0,0,0
	.db 251,140,128,1,140,0,0,0,0,0,0,0
	.db 231,4,128,1,140,0,0,0,0,0,0,0
	.db 99,131,0,1,252,0,0,0,0,0,0,0
	.db 187,118,237,249,252,0,0,0,0,0,0,0
	.db 196,137,18,39,140,0,0,0,0,0,0,0

.end		;et voilà c'est fini!!!!!!!!!!!