.nolist
#INCLUDE "DWEDIT.INC"
    .list 
#ifdef TI83P			;Quand on compile pour 83+: 
    .org progstart-2	        ;indique l'adresse de début du fichier quand on l'exécute
    .db $BB,$6D			;sert à identifier le fichier comme programme en asm 
#else				;Si on compile pas pour 83+, c'est pour 83-
    .org progstart		;indique l'adresse de début du fichier quand on l'exécute 
#endif				;à la suite, c'est pareil pour 83 et 83+ 
    ret				;Si on exécute ce fichier du tios, il quitte tout de suite 
    jr nc,start			;saute à l'adresse de start 
    .db "Bouncy! editeur",0	;description du programme
start: 

#define STextWrite      set     7,(iy+14h)
#define RTextWrite      res     7,(iy+14h)
#define STextInverse    set     3,(iy+05h)
#define RTextInverse    res     3,(iy+05h)

#define Xcurseur		saferam1
#define Ycurseur		Xcurseur+1
#define bonusedit       Ycurseur+1
#define nBrique         bonusedit+1
#define plusmoins       nBrique+1
#define adrlvl          plusmoins+1
#define AdrLVL          adrlvl+2
#define adrbrique       AdrLVL+2
#define BonusProb       adrbrique+2
#define TempBonusProb   BonusProb+2
#define xlvl            TempBonusProb+1
#define xmaxlvl         xlvl+1
#define taille          xmaxlvl+1
#define nligne          taille+1
#define nbrligne        nligne+1
#define stop            nbrligne+1

#define briclvl         saferam3

restart:
 bcall(_zeroop1)
 ld a,$15
 ld (op1),a
cherchepremier:
 bcall(_FindAlphaUp)
 jp c,creatlvl
 bcall(_chksysvar)
 ex de,hl
 inc hl
 inc hl
 ld a,(hl)
 cp 'B'
 jr nz,cherchepremier
 inc hl
 ld a,(hl)
 cp 'N'
 jr nz,cherchepremier
 inc hl
 ld a,(hl)
 cp 'C'
 jr nz,cherchepremier
 STextWrite
 jp slctbassuite

selectlvl

 call dezip
 bcall(_cleargbuf)

 call affbric

 ld hl,256*50+6
 ld (pencol),hl
 ld hl,op1+1
 bcall(_vputs)

        ld hl,58*256+9
        ld (pencol),hl
        ld a,(xlvl)
        inc a
        call affa
        ld a,'/'
        bcall(_vputmap)
        ld a,(xmaxlvl)
        inc a
        call affa

 ld a,80
 ld l,56
 ld bc,256*8+2
 ld ix,NewS
 call ionlargesprite

 xor a
 ld l,49
 ld ix,fleche
 ld b,15
 call ionputsprite

 call ionfastcopy

slctlvlkey
 bcall(_getcsc)
 cp $37
 ret z
 cp 02
 jp nz,selectpasgauche
 ld a,(xlvl)
 or a
 jp z,slctlvlkey
 call prelvl
 jp selectlvl
selectpasgauche:
 cp 03
 jp nz,slctpasdr
 ld bc,(xlvl)
 ld a,(xmaxlvl)
 cp c
 jp z,slctlvlkey
 call nextlvl
 jp selectlvl
slctpasdr:
 cp 04
 jp nz,selecetpashaut
selecthaut:
 bcall(_FindAlphaDn)
 jr selecthautbas
selecetpashaut:
 cp 01
 jp nz,slctpasbas
selectbas:
 bcall(_FindAlphaUp)
selecthautbas:
 jp c,restart
 bcall(_chksysvar)
 ex de,hl
 inc hl
 inc hl
 ld a,(hl)
 cp 'B'
 jr nz,selectbas
 inc hl
 ld a,(hl)
 cp 'N'
 jr nz,selectbas
 inc hl
 ld a,(hl)
 cp 'C'
 jr nz,selectbas
slctbassuite:
 inc hl
 inc hl
 inc hl
 ld (AdrLVL),hl
 ld a,(hl)
 ld (xmaxlvl),a
 inc a
 ld d,0
 ld e,a
 add hl,de
 add hl,de
 inc hl
; ld (frstlvl),hl
 ld (adrlvl),hl
        ld a,(hl)
        ld (nbrligne),a
        ld (nligne),a
 xor a
 ld (xlvl),a
 ld (stop),a

 
 jp selectlvl
slctpasbas:
 cp $36
 jp z,editelvl
 cp $31
 jp nz,slctlvlkey

creatlvl:
        bcall(_clrlcdf)
        ld a,0
        ld (Xcurseur),a
raffC:
        ld hl,Levelname
        ld a,3
        ld (currow),a
        ld a,4
        ld (curcol),a
        bcall(_puts)


        ld hl,Levelname
        ld a,(Xcurseur)
        ld e,a
        ld d,0
        add hl,de
        add a,4
        ld (curcol),a
        ld a,3
        ld (currow),a
        ld a,(hl)
        STextInverse
        bcall(_putc)
        RTextInverse
        
Csuite:
	bcall(_getcsc)
	cp $37
	ret z
 	cp 1
 	jr nz,pasbasC
 	jr nz,pashautC
        ld hl,Levelname
        ld a,(Xcurseur)
        ld e,a
        ld d,0
        add hl,de
        dec (hl)
        jr raffC 	
pasbasC:
	cp 2
	jr nz,pasgaucheC
	ld a,(Xcurseur)
	or a
	jr z,raffC
	dec a
	ld (Xcurseur),a
	jr raffC
pasgaucheC:
	cp 3
	jr nz,pasdroiteC
	ld a,(Xcurseur)
	cp 7
	jr z,raffC
	inc a
	ld (Xcurseur),a
	jr raffC
pasdroiteC:
	cp 4
 	jr nz,pashautC
        ld hl,Levelname
        ld a,(Xcurseur)
        ld e,a
        ld d,0
        add hl,de
        inc (hl)
        jr raffC 	
pashautC:
	cp $36
 	jr nz,Csuite




        ld hl,TypenName
        bcall(_Mov9ToOP1)
        bcall(_chkFindSym)
        ld a,(de)
        ld l,a
        inc de
        ld a,(de)
        ld h,a
        ld (taille),hl
        inc de
        inc de
        inc de
        inc de
        jp nc,lvlExisteDeja
        ;ld hl,TypenName
        ;rst 20h
        ld hl,39
        ld (taille),hl
        bcall(_createappvar)
        inc de
        inc de
        ld hl,newLVL
        ld bc,11
        ldir
        dec de
        dec de
        dec de
        dec de
        dec de
        dec de
        dec de
        dec de
lvlExisteDeja:
        xor a    ;
        ld (de),a;
        inc de   ;Hscore remis à zéro
        ld (de),a;
        inc de   ;
        ld (AdrLVL),de
        ld a,(de)
        ld (xmaxlvl),a
	  ex de,hl
	  ld d,0
	  ld e,a
	inc de
	  add hl,de
	  add hl,de
	  ex de,hl
        inc de
        ld (adrlvl),de
        ld a,(de)
        ld (nbrligne),a
        ld (nligne),a
        xor a
        ld (xlvl),a
        
        call clear

editelvl:
        bcall(_cleargbuf)
;        ld de,(adrlvl)
;        ld a,(de)
;        ld (BonusProb),a
        call dezip

        ld hl,Xcurseur   ;\ (Xcurseur)  = 0
        ld (hl),0        ; |(Ycurseur)  = 0
        ld de,Xcurseur+1 ; |(nBrique)   = 0
        ld bc,4          ; |(bonusedit) = 0
        ldir             ; |
        inc (hl)         ;/ (plusmoins) = 1

        STextWrite
        call raffxlvl

        ld hl,49*256+0
        ld (pencol),hl
        ld hl,BonusString
        bcall(_vputs)
        call raffbonusprob

        call affbricbonus
	call affcurseur

	xor a
	ld (stop),a
	ld l,56
	ld ix,menu
	ld bc,8*256+12
	call ionlargesprite

;        call XORgaucheinactive
;        ld a,(xmaxlvl)
;        or a
;        call z,XORdroiteinactive

         ld hl,(adrlvl)
         inc hl
         inc hl
         bit 1,(hl)
         call nz,xorstop

progsuite:


	call affcurseur
	bcall(_getcsc)
	cp $37
        jp z,quit
;	ret z
 	cp 1
 	call z,bas
	cp 2
	call z,gauche
	cp 3
	call z,droite
	cp 4
	call z,haut
	push af
	call p,affbricbonus
	pop af
	cp $0F
	call z,clear
        cp $35
        call z,Yegal
        cp $34
        call z,Window
        cp $33
        call z,Zoom
        cp $32
        call z,Trace
        cp $31
        call z,Graph
        push af
        ld a,$FF
        out (1),a
        ld a,$FD
        out (1),a
        in a,(1)
        cp $FD
        call z,plus
        cp $FB
        call z,moins
        pop af
	cp $22
	call z,setbric1
	cp $1A
	call z,setbric2
	cp $12
	call z,setbric3
	cp $23
	call z,setflecheg
	cp $13
	call z,setfleched
	cp $1B
	call z,setflecheb
	cp $1C
	call z,setflecheh
	cp $21
	call z,setgbombe
	cp $19
	call z,setpbombe
	cp $11
	call z,setincasseble
        cp $20
        call z,stat
        cp $38
        call z,del
        cp $30
        call z,alpha
	cp $36
 	call z,seconde



        cp 4
	call p,key4p
	call affcurseur

        call ionFastCopy



 jp progsuite

divabyb:
 ld c,00
divabybs:
 cp b
; jp m,divabybf
 ret m
 sub b
 inc c
 jp divabybs
;divabybf
; ld a,c
 ret

raffbonusprob:
        ld hl,49*256+23
        ld (pencol),hl
        ld a,(BonusProb)
        or a
        jp nz,affa
        ld (pencol),hl
        ld hl,Defstring
        bcall(_vputs)
        ret

raffxlvl:
        ld hl,49*256+67
        ld (pencol),hl
        ld a,(xlvl)
        inc a
        call affa
        ld a,'/'
        bcall(_vputmap)
        ld a,(xmaxlvl)
        inc a
;        call affa
;        ret

affa:
        ld b,100
;        ld (pencol),hl

        ld h,0
        ld l,a
        ld de,100
        ;call divabyb
        call divhlparde
        ld a,l

        ld e,a
        ld a,c
        add a,$30
        push de
        bcall(_vputmap)
        pop de
        ld a,e
        ld b,10
        call divabyb
        ld e,a
        ld a,c
        add a,$30
        push de
        bcall(_vputmap)
        pop de
        ld a,e
        add a,$30
        push de
        bcall(_vputmap)
        pop de
	ret
	
divhlparde:
	or a
	ld bc,0
DivhlbyDE:
	sbc hl,de
	jp c,nomore
	inc bc
	jp z,suite
	jp DivhlbyDE
nomore:
	add hl,de
	ret
suite:
	ld	hl,0
	ret

clrgb
 ld hl,$9340
 ld (hl),00
 ld de,$9341
 ld bc,$02FE
	ldir
 ret

prelvl:
        ld a,(bonusedit)
        or a
        call nz,zoom

        ld hl,xlvl
	ld a,(hl)
	or a
	ret z
        dec (hl)
	dec a
        ld b,a
	ld hl,(AdrLVL)
	  ld d,0
	  ld e,(hl)
	  inc e
	  add hl,de
	  add hl,de
	inc hl
        ld (adrlvl),hl
        push af
        ld a,(hl)
        ld (nligne),a
        pop af
        or a
        ret z
prelvls:
        push hl
;        ld hl,(adrlvl)  ;
        ld a,(hl)        ;
        inc hl           ;
        inc hl           ;
        add a,6          ;
        sra a            ;
        sra a            ; appartient à dezip... optimisation ?
        sra a            ;
        inc a            ;
        ld d,0           ;
        ld e,a           ;
        add hl,de        ;
        ld (adrbrique),hl;
        pop hl
        call nextlvlhl
;test: jr test
        djnz prelvls
        ret

nextlvl:
        ld a,(bonusedit)
        or a
        call nz,zoom

        ld hl,xlvl
        inc (hl)
        ld hl,(adrlvl)
nextlvlhl:
        ld a,(hl)
        inc hl
        ld c,(hl)
        add a,7
        ld h,0
        ld l,a
        add hl,hl
        add hl,hl
        ex de,hl
        ld hl,(adrbrique)
        ld a,c
        or a
        jr nz,nextlvlrand
        add hl,de
nextlvlrand:
        add hl,de
        ld (adrlvl),hl
        ld a,(hl)
        ld (nligne),a
        ret


;suprime les ligne vides en fin de niveau
testrien:
;        ld bc,0
;        call teststopchangec
;        or a
;        ret nz
        ld hl,(adrbrique)
        ld b,4

testriensuite:
        ld a,(hl)
        or a
        ret nz
        inc hl
        djnz testriensuite
        ld hl,(adrlvl)
        ld a,(hl)
        or a
        ret z
        dec a
        ld (hl),a
        ld hl,(adrbrique)
        ld de,4
        ld bc,-4
        and %0000 0111
        dec a
        jr nz,testrienpasstopdel
        dec hl
        ld (adrbrique),hl
        inc de
        dec bc
testrienpasstopdel:
        push bc
        bcall(_deletemem)
        pop bc
        call raffprogtaille

        ld a,(BonusProb)
        or a
        jr nz,testrien
        ld de,(adrbrique)
        ld a,(nbrligne)
        add a,7-1
        ld h,0
        ld l,a
        add hl,hl
        add hl,hl
        add hl,de
        ld de,4
        bcall(_deletemem)
        ld bc,-4
        call raffprogtaille
        jr testrien

quit:
        ld a,(bonusedit)
        or a
        call nz,zoom
;        call zip
        


zip:
 ;vérifie si les sytème des bonus a changé
        ld hl,(nbrligne)
        ld h,0
        ld bc,7
        add hl,bc
        add hl,hl
        add hl,hl
        ex de,hl          ;de = taille des briques briques ou des bonus
        ld hl,(adrbrique)
        add hl,de         ;briques
        push hl           ;hl pointe sur le 1er et 2ème bonus
        push de           ;de = taille à inserrer
        ld a,(BonusProb)
        or  a
        jr nz,zippasnewdef
        ex de,hl
        ;        dec hl
        push hl
        bcall(_insertmem)
        pop bc
        ;        ld bc,28
        call raffprogtaille
zippasnewdef:
        ld hl,(adrlvl)
        inc hl
        ld a,(hl)
        pop de
        pop hl
        ;        dec de
        or a
        jr nz,zippasenddef
        ;        ld de,28
        push de
        bcall(_deletemem)
        pop de
        ld hl,0
        or a
        sbc hl,de
        ld b,h
        ld c,l
        ;        ld bc,-28
        call raffprogtaille
zippasenddef:
;compresse le niveau
	  ld hl,(AdrLVL)
	  dec hl
	  ld (hl),0 ;\
	  dec hl    ;|remet le Hi-score à zéro
	  ld (hl),0 ;/
        inc hl
        inc hl
        inc hl
	  ld de,(xlvl)
	  ld d,0
	  add hl,de
	  add hl,de
	  ld (hl),15	;\
	  inc hl		;|remet le meilleur temps du niveau à 9999
	  ld (hl),39	;/
        ld hl,(adrlvl)
        ld a,(nbrligne)
        ld (hl),a
        inc hl
        ld a,(BonusProb)
	ld (hl),a

	ld de,(adrbrique)
        ld hl,(nligne)
        ld h,0
;        ld hl,0 ;;;
        add hl,hl
        add hl,hl
        add hl,de
;        inc hl
	ld de,briclvl
        ld b,28
;        push hl
	call zips
;	pop hl
        ld a,(BonusProb)
	or a
	ret nz
;        ret ;;;;;;;;;;;;;;;;
        push hl
        ld hl,(nbrligne)
        ld h,0
;        ld de,7
;        add hl,de
        add hl,hl
        add hl,hl
        pop de
        add hl,de
        ld de,briclvl+56
	ld b,28
zips:
        ld a,(de)
;        and $0F
        inc de
	add a,a
	add a,a
	add a,a
	add a,a
        ld c,a
        ld a,(de)
        and $0F
        add a,c
        inc de
        ld (hl),a
        inc hl
        djnz zips
;        inc hl
;        ld (nextlvladr),hl
        ret

dezip:
        ld hl,(adrlvl)
        ld a,(hl)
        ld (nbrligne),a             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
        inc hl

	ld a,(hl)
	ld (BonusProb),a
	inc hl

        ld a,(nbrligne)
        add a,6
        sra a
        sra a
        sra a
        inc a
        ld d,0
        ld e,a
        add hl,de
        ld (adrbrique),hl
        ex de,hl
        ld hl,(nligne)
	ld h,0
        add hl,hl
        add hl,hl
        add hl,de
	ld b,28
	ld de,briclvl
;        inc de
;	or a
;	jr z,dezips
;	ld b,28

        call dezips
        
	ld a,(BonusProb)
        or a
        ret nz
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
        ex de,hl                                 ;
        ld hl,(nbrligne)                       ;
	ld h,0                                    ;
        add hl,hl                                  ;
        add hl,hl                                ;
        add hl,de                              ;
	ld b,28                               ;
	ld de,briclvl+56                        ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
dezips:
	ld a,(hl)
	srl a
	srl a
	srl a
	srl a
	ld (de),a
	inc de
	ld a,(hl)
	and $0F
	ld (de),a
        inc de
        inc hl
        djnz dezips

        ret

taillestopper:
        ld a,(nligne)
        add a,7
        sra a
        sra a
        sra a
        ld d,0
        ld e,a
        add hl,de
        ret

raffprogtaille:
        ld hl,(AdrLVL)
        dec hl
        dec hl
        dec hl
        dec hl
        dec hl
        dec hl
        ld d,(hl)
        dec hl
        ld e,(hl)
        ex de,hl
        add hl,bc
        ex de,hl
        ld (hl),e
        inc hl
        ld (hl),d
        ret

bonushlix:
 ld a,(hl)
 ld b,a
bonusaix:
 add a,a
 add a,a
 add a,a
 sub b
 add a,a
 ld b,00
 ld c,a
 push hl
 ld hl,bonusSprite
 add hl,bc
 .db $E3,$DD,$E3,$E3
 pop hl
 ret

affbricbonus:
;        jr affbric ; ou affbonus
.db $18,affbric-affbonus ;$0C
        nop
affbonus:


        ld hl,$8540
        ld de,briclvl
        ld b,56
zoomdeftest:
        ld a,(de)
        inc de
        cp 4
        jp p,zoompasbonus
        or a
        jr nz,zoombonus
zoompasbonus:
        ld (hl),16
zoombonus:
        inc hl
        djnz zoomdeftest


        ld de,$8540
        ld hl,bonusSprite
        ld b,7
        ld a,$80+2
        jr affbricbonusbonus

affbric:
        ld de,briclvl
        ld hl,bric1
        ld b,6
        xor a
affbricbonusbonus:
        ld (BBtaille),a
        ld (BBselect+1),hl
        ld hl,$0000
affbricbonusS:
 ld a,(de)
 or a
 push de
 push af
 push hl
 dec a
 add a,a
 ld d,a
 add a,a
 ld e,a
 add a,a
 add a,e
BBtaille: add a,d ; ou nop
BBselect: ld hl,bric1
 ld d,00
 ld e,a
 add hl,de
; ex ix,hl
 .db $E3,$DD,$E3,$E3
 pop hl
 pop af
 ld c,2
 push hl
	ld a,h
 push bc
 call nz,ionlargesprite
 pop bc
 pop hl
 push hl
 ld de,$5300
 or a
 sbc hl,de
 pop hl
 jp p,bricyp
 ld de,$0C00
 add hl,de
 jp bricxpF
bricyp:
 ld de,$53F9
 or a
 sbc hl,de
bricxpF:

 push hl
 ld de,$0031
 or a
 sbc hl,de
 pop hl
 pop de
	inc de
 ret z
 jp affbricbonusS

key4p:
	call affbricbonus
	call raffxlvl
;	ld a,(xmaxlvl)
;	ld bc,(xlvl)
;	sub c
;        cp 2
;        jp p,key4psuite
;        ld bc,(flechedroite)
;        cp c
;        call nz,XORdroiteinactive
;key4psuite:
;	ld a,(xlvl)
;	cp 2
;	ret p
;        ld bc,(flechegauche)
;        cp c
;        jp nz,XORgaucheinactive
        ret

xorstop:
        ld a,(stop)
        xor 1
        ld (stop),a
        ld a,50
        ld l,a
        ld bc,5*256+2
        ld ix,stopsprite
        call ionlargesprite
        ret


stoppreparre:
        ld hl,(adrlvl)
        inc hl
        inc hl
        ld a,(nbrligne)
        add a,7
        ld de,(Ycurseur)
        sub e
        sub c
        dec a
        ld b,a
        sra a
        sra a
        sra a
        ld d,0
        ld e,a
        add hl,de
        ld a,b
        and %0000 0111
        inc a
        ld b,a
	  ret

stat:
        push af
        
        call xorstop
        ld bc,(nligne)
	  call stoppreparre
        ld a,%0000 0001
statpuissance:
        rrca
        djnz statpuissance
        xor (hl)
        ld (hl),a
        pop af
        ret

teststopchange:
        ld bc,(nligne)
teststopchangec:
	  call stoppreparre
	  ld a,8
        sub b
	  add a,a
	  add a,a
	  add a,a
        ld c,$C7
	  add a,c
	  ld (teststopchangebitvariable+1),a
	  xor a
teststopchangebitvariable: set 0,a
        ld c,(hl)
	  and c
	  push af
stopchangetestdecalbit7:
        rlca
        djnz stopchangetestdecalbit7
	  ld bc,(stop)
;test: jr test
	  xor c
	  or a
	  call nz,xorstop
	  pop af
        ret



plus:
        push af
        ld a,(plusmoins)
        dec a
        ld (plusmoins),a
        or a
        jr nz,plusfin
        ld a,8
        ld (plusmoins),a
        ld a,(BonusProb)
        cp 63
        jr z,plusfin
        or a
        jr z,pluspasbonusdef

pluspasbonusdef:
        inc a
        ld (BonusProb),a
        call raffbonusprob
plusfin:
        pop af
        ret
        
moins:
        ld a,(plusmoins)
        dec a
        ld (plusmoins),a
        or a
        ret nz
        ld a,8
        ld (plusmoins),a
        ld a,(BonusProb)
        or a
        ret z
        dec a
        or a
        jr z,moinspasbonusdef

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;        ld hl,(nbrligne)
;        l,0
;        add hl,hl
;        add hl,hl
;        push hl
;        bcall(_ErrNotEnoughMem)
;        pop hl
;        ld de,(adrlvl)
;        ex de,hl
;        add hl,de
;        ex de,hl
;        bcall(_insertmem)
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

moinspasbonusdef:
        ld (BonusProb),a
        jp raffbonusprob
;        ret

Trace:
        push af
        ld a,(xmaxlvl)
        or a
        jr z,Tracefin
        dec a
        ld (xmaxlvl),a
;        ld hl,(adrlvl)
;        push hl
;        ld a,(nbrligne)
;        add a,7
;        ld h,0
;        ld l,a
;        add hl,hl
;        add hl,hl
;        ex de,hl   ; de = taille des brique (!!! Bonus ? fois 2 !!!)
;;        ld hl,(adrbrique)
;;        add hl,de  ;hl = adresse de fin de niveau (début du suivant)
;;        push hl
;        ld bc,(adrlvl)
;        ld hl,(adrbrique)
;        or a
;        sbc hl,bc
;        add hl,de
;        ex de,hl   ; de = taille du niveau à supprimer
;;        pop hl
;;        ld (adrlvl),hl  ;\
;;        push de         ; |
;;        call dezip      ; | Le niveau en édition sera le suivant
;;        pop de          ;/
;        pop hl
;;        ld (adrlvl),hl  ; Adresse actuelle du niveau suprimé et future du niveau suivant.
;;        ld de,30

	ld de,(adrlvl)
	push de
	call nextlvl
	pop de
	ld hl,(adrlvl)
	or a
	sbc hl,de
	push hl
	call prelvl
	pop hl
	ex de,hl
	ld hl,(adrlvl)

        push de
        bcall(_deletemem)

        ld hl,(AdrLVL)
	inc hl	
        ld de,2

        bcall(_deletemem)
	  ld hl,(adrlvl)
	  dec hl
	  dec hl
	  ld (adrlvl),hl
	ld a,(hl)
	ld (nligne),a

        call dezip
        pop de

	inc de
	inc de
        ld hl,0
        or a
        sbc hl,de
        ld b,h
        ld c,l
        ld hl,(AdrLVL)
        dec (hl)
        call raffprogtaille
        ld bc,(xmaxlvl)
        ld a,(xlvl)
        cp c
        call p,prelvlraff

 ; plantage à cause de adrbrique (résolu)
; ld hl,(adrlvl)
;test: jr test

Tracefin:
        pop af
        ret


prelvlraff:
 push af
 jp Yegalsuite


Zoom:
        push af
        ld a,(BonusProb)
        or a
        jr nz,Zoomfin
        call zip

        ld a,(bonusedit)
        xor 1
        ld (bonusedit),a

        ld a,(secondeBBadr+1)
        xor 72
;        xor 8
;        xor $40
        ld (secondeBBadr+1),a

        ld a,(secondeBBmax+1)
        xor %0001 1011
        ld (secondeBBmax+1),a

	ld a,40
	ld l,56
        ld ix,bonusbrique
	ld bc,8*256+2
	call ionlargesprite

        ld a,(affbricbonus+1)
        xor affbric-affbonus;$0C
        ld (affbricbonus+1),a

        call dezip

Zoomfin:
        pop af
        ret

Graph:
        push af
        ld a,(xmaxlvl)
        inc a
        or a
;        cp 256
        jr z,Graphfin
        ld (xmaxlvl),a
        ld a,(BonusProb)
        ld (TempBonusProb),a
        call Window

;        call zip
;        call nextlvl

        ld hl,33
        bcall(_ErrNotEnoughMem)

        ld hl,(AdrLVL)
	  ld d,0
	  ld e,(hl)
	  inc e
	  add hl,de
	  add hl,de
	  ex de,hl
        ld hl,2
        bcall(_insertmem)
	  ld hl,(adrlvl)
	  inc  hl
	  inc  hl
	  ld (adrlvl),hl

        ld de,(adrlvl)
        ld hl,31
        bcall(_insertmem)

        ld hl,(adrlvl)
        ld (hl),0 ; nbrligne = 0
        inc hl
        ld a,(TempBonusProb)
        ld (hl),a
        inc hl
        inc hl
        ld (adrbrique),hl
        xor a
        ld (nligne),a
        ld (nbrligne),a

        ld hl,(AdrLVL)
        inc (hl)
        ld bc,33
        call raffprogtaille
        ld a,(TempBonusProb)
        ld (BonusProb),a
        call raffbonusprob
        call clear
Graphfin:
        pop af
        ret

Yegal:
        push af
        ld a,(xlvl)
        or a
        jr z,Yegalfin
;        dec a
;        ld (xlvl),a
        call zip
        call testrien
Yegalsuite:
        call prelvl
        call dezip
        call raffbonusprob
        call teststopchange
Yegalfin:
        pop af
        ret

Window:
        push af
        ld a,(xlvl)
        ld bc,(xmaxlvl)
        cp c
        jr z,Windowfin
;        inc a
;        ld (xlvl),a
        call zip
        call testrien
        call nextlvl
        call initligne
        call dezip
        call raffbonusprob
        call teststopchange
Windowfin:
        pop af
        ret

clear:
        ld hl,briclvl
        ld (hl),0
        ld de,briclvl+1
        ld bc,56
        ldir
;        ld hl,briclvl
        ld (hl),16
;        ld de,$8509
        ld bc,56
        ldir
        ret



setbric1:
	ld l,1
	jr changebrique
setbric2:
	ld l,2
	jr changebrique
setbric3:
	ld l,3
	jr changebrique
setpbombe:
	ld l,4
	jr changebrique
setgbombe:
	ld l,5
	jr changebrique
setincasseble:
	ld l,6
	jr changebrique
setflecheg:
	ld l,7
	jr changebrique
setfleched:
	ld l,8
	jr changebrique
setflecheh:
	ld l,9
	jr changebrique
setflecheb:
	ld l,10
	jr changebrique
del:
	  ld l,0

changebrique:
        push af
        ld bc,(nBrique)
        ld a,(secondeBBmax+1)
        push af
        ld a,l
        ld (secondeBBmax+1),a
        ld (nBrique),a
        call seconde
        pop af
        ld (secondeBBmax+1),a
        ld a,c
        ld (nBrique),a
        pop af
        ret

alpha:
        ld b,0
        jr secondealpha
seconde:
        ld b,1
secondealpha:
        push af
	ld a,(Ycurseur)
	add a,a
	add a,a
	add a,a
	ld de,(Xcurseur)
	add a,e
	ld d,0
	ld e,a
secondeBBadr:	ld hl,briclvl
	add hl,de
	ld a,(hl)
	cp 16
	jr z,secondefin2
	ld de,(nBrique)
	cp e
	jr z,secondesuite
	ld a,e
	jr secondefin
secondesuite:
        ld c,a
        ld a,b
        or a
        jr z,alphasuite
        ld a,c
	inc a
secondeBBmax:	cp 11
	jp m,secondefin
        xor a
        ld (nBrique),a
secondefin:
	ld (hl),a
        ld (nBrique),a
secondefin2:
        pop af
	ret

alphasuite:
        ld a,c
	dec a
        cp -1
        jr nz,alphafin
        ld a,(secondeBBmax+1)
        dec a
        ld (nBrique),a
alphafin:
	ld (hl),a
        ld (nBrique),a
        pop af
	ret


gauche:
	push af
	ld a,(Xcurseur)
	or a
	jp z,gauchefin
	dec	a
	ld (Xcurseur),a
gauchefin:
	pop af
	ret

droite:
	push af
	ld a,(Xcurseur)
	cp 7
	jp z,gauchefin
	inc a
	ld (Xcurseur),a
droitefin:
	pop af
	ret

bas:
	push af
	ld a,(Ycurseur)
	cp 6
	jp z,basfin
	inc a
	ld (Ycurseur),a
	call teststopchange
	pop af
	ret
basfin:
        call zip
        call affbricbonus
        ld a,(nligne)
        ld bc,(nbrligne)
        cp c
        jp z,creatlignefin
        inc a
        ld (nligne),a
        jp creatlignefin

haut:
      push af
	ld a,(Ycurseur)
	or a
	jp z,hautligne
	dec	a
	ld (Ycurseur),a
	call teststopchange
	pop af
	ret
hautligne:
        call zip
        call affbricbonus
        ld a,(nligne)
        or a
        jr z,creatligne
        dec a
        ld (nligne),a
        jr creatlignefin
creatligne:
        ld de,(adrbrique)
        ld bc,4
        ld a,(nbrligne)
        add a,7
        and %0000 0111
        or a
        jr nz,creatlignesuite
        inc bc
        inc de
        ld (adrbrique),de
        dec de
creatlignesuite:
        ld h,b
        ld l,c
        push bc
        bcall(_insertmem)
        pop bc
        call raffprogtaille
;        ld hl,nbrligne
;        inc (hl)
        ld hl,(adrlvl)
        inc (hl)
        ld hl,(adrbrique)
        ld a,c
        cp 05
        jr nz,creatlignesuitepasstopeff
        dec hl
creatlignesuitepasstopeff:
        ld (hl),0
        ld d,h
        ld e,l
        inc de
        dec bc
;        ld bc,3
        ldir

creatlignefin:
        call dezip
        call affbricbonus
	  call teststopchange
        pop af
	ret

initligne:
        ld hl,(adrlvl)
        ld a,(hl)
        ld (nbrligne),a
        ld (nligne),a
        ret


;stoptest:
;        ld bc,(nligne)
;        ld b,1
;stoptestc:
;        push bc
;        ld hl,(adrlvl)
;        inc hl
;        inc hl
;        ld a,(nbrligne)
;        add a,7
;        ld bc,(Ycurseur)
;        sub c
;        sub c
;        dec a
;        ld b,a
;        sra a
;        sra a
;        sra a
;        ld d,0
;        ld e,a
;        add hl,de
;        ld a,b
;        and %0000 0111
;        inc a
;        ld b,a
;        ld a,%0000 0001
;stoppuissance:
;        rrca
;        djnz stoppuissance
;        pop bc
;        ld c,(hl)
;        and c
;        ld a,1
;        jr nz,stopset
;	xor a
;stopset:
;        ld e,a
;        ld a,b
;        or a
;        ld a,e
;        ret z
;        ld bc,(stop)
;        cp c
;        ld (stop),a
;        xor a
;        jp nz,xorstop


affcurseur:
	ld a,(Ycurseur)
	ld b,a
	add a,a
	add a,b
	add a,a
	add a,b
	ld l,a
	ld a,(Xcurseur)
	ld b,a
	add a,a
	add a,b
	add a,a
	add a,a
	ld ix,curseur
	ld bc,7*256+2
	call ionlargesprite
	ret

XORgaucheinactive:
;        ld a,(flechegauche)
;        xor 1
;        ld (flechegauche),a
;	xor a
;	ld l,56
;	ld ix,gaucheinactive
;	ld bc,8*256+2
;	jp ionlargesprite
;
XORdroiteinactive:
;        ld a,(flechedroite)
;        xor 1
;        ld (flechedroite),a
;	ld a,20
;	ld l,56
;	ld ix,droiteinactive
;	ld bc,8*256+2
;	jp ionlargesprite


stopsprite:
.db %00010000,%00000000
.db %11011001,%00110000
.db %10010010,%10101000
.db %01010010,%10110000
.db %11001001,%00100000



BonusString:
 .db "Bonus : ___/63",0

Defstring:
 .db "Def",0

TypenName:
 .db $15
Levelname:
 .db "Levelbnc",0

newLVL:
 .db "BNC"
 .db 0,0  ; Score
 .db 0    ; nombre de niveaux - 1
 .db 15,39; temps record du permier niveau (détaché)
 .db 0    ; nombre de lignes - 7 du 1er niveau (attaché)
 .db 16   ; probabilité de bonus du premier niveau (attaché)
 .db 0    ; initialisation du stoppeur (attaché)

menu:
 .db %00011111,%11111111,%10000011,%11111111,%11110000,%01111111,%11111110,%00001111,%11111111,%11000001,%11111111,%11111000
 .db %00111110,%11111111,%11000111,%11111110,%11111000,%11100000,%00000111,%00011111,%11111111,%11100011,%11111000,%11111100
 .db %01111100,%11111111,%11101111,%11111110,%01111101,%10000000,%01110001,%10111111,%11111111,%11110111,%11111000,%11111110
 .db %01111000,%00000000,%11101110,%00000000,%00111101,%00000011,%11111000,%10111110,%00000001,%11110111,%11100000,%00111110
 .db %01110000,%00000000,%11101110,%00000000,%00011101,%00111111,%11111000,%10111110,%00000001,%11110111,%11100000,%00111110
 .db %01111000,%00000000,%11101110,%00000000,%00111101,%00000011,%11111000,%10111110,%00000001,%11110111,%11100000,%00111110
 .db %01111100,%11111111,%11101111,%11111110,%01111101,%10000000,%01110001,%10111111,%11111111,%11110111,%11111000,%11111110
 .db %01111110,%11111111,%11101111,%11111110,%11111101,%11100000,%00000111,%10111111,%11111111,%11110111,%11111000,%11111110

gaucheinactive:
 .db %00000000,%00000000
 .db %00000000,%00000000
 .db %00000001,%00000000
 .db %00000010,%10101010
 .db %00000101,%01010101
 .db %00000010,%10101010
 .db %00000001,%00000000
 .db %00000000,%00000000

droiteinactive:
 .db %00000000,%00000000
 .db %00000000,%00000000
 .db %00000000,%00010000
 .db %00001010,%10101000
 .db %00010101,%01010100
 .db %00001010,%10101000
 .db %00000000,%00010000
 .db %00000000,%00000000

bonusbrique:
 .db %00000000,%00000000
 .db %00100000,%00000100
 .db %00101101,%11000100
 .db %10011000,%10010101
 .db %10001001,%00100001
 .db %10101110,%01001101
 .db %00011011,%00011100
 .db %00100000,%00000100

curseur:
 .db $FF,$F0,$FF,$F0,$FF,$F0,$FF,$F0,$FF,$F0,$FF,$F0,$FF,$F0

bric1:
; Briques classiques
 .db $7F,$C0,$A4,$A0,$C9,$20,$92,$60,$A4,$A0,$7F,$C0
 .db $7F,$C0,$AA,$A0,$D5,$60,$AA,$A0,$D5,$60,$7F,$C0
 .db $7F,$C0,$DB,$60,$B6,$E0,$ED,$A0,$DB,$60,$7F,$C0
;Bombes
 .db %00111000,%00000000
 .db %01000100,%00100000
 .db %10011010,%01100000
 .db %10001010,%00010000
 .db %01000101,%00100000
 .db %00111000,%11000000

 .db %00111000,%00000000
 .db %01111100,%00100000
 .db %11100110,%01100000
 .db %11110110,%00010000
 .db %01111101,%00100000
 .db %00111000,%11000000
; Incassable :
 .db $7F,$C0,$FF,$E0,$DB,$60,$A4,$A0,$80,$20,$7F,$C0
; Flèches :
 .db $1C,$70,$38,$E0,$71,$C0,$71,$C0,$38,$E0,$1C,$70
 .db $E3,$80,$71,$C0,$38,$E0,$38,$E0,$71,$C0,$E3,$80
 .db $30,$C0,$79,$E0,$FF,$F0,$CF,$30,$86,$10,$00,$00
 .db $00,$00,$86,$10,$CF,$30,$FF,$F0,$79,$E0,$30,$C0

bonusSprite:
 .db $1F,$80,$7F,$E0,$80,$10,$A9,$50,$C0,$30,$7F,$E0,$1F,$80
 .db $1F,$80,$79,$E0,$F8,$70,$80,$10,$F8,$70,$79,$E0,$1F,$80
 .db $1F,$80,$7C,$60,$F0,$30,$80,$30,$F0,$30,$7C,$60,$1F,$80
 .db $1F,$80,$7C,$60,$D8,$30,$88,$30,$D8,$30,$7C,$60,$1F,$80
 .db $1F,$80,$7B,$E0,$EB,$B0,$EA,$B0,$EE,$B0,$7E,$E0,$1F,$80
; .db $1F,$80,$79,$E0,$F0,$F0,$E0,$70,$F9,$F0,$79,$E0,$1F,$80
 .db %00011111,%10000000
 .db %01111111,%11100000
 .db %11111001,%11110000
 .db %10110110,%11010000
 .db %11001111,%00110000
 .db %01111111,%11100000
 .db %00011111,%10000000
 .db $1F,$80,$6F,$60,$CF,$30,$80,$10,$CF,$30,$6F,$60,$1F,$80
 .db $1F,$80,$65,$E0,$DD,$50,$D5,$50,$E5,$10,$7F,$E0,$1F,$80
 .db $1F,$80,$7F,$E0,$FF,$F0,$80,$10,$FF,$F0,$7F,$E0,$1F,$80
 .db $07,$80,$08,$00,$3F,$00,$10,$00,$3F,$00,$08,$00,$07,$80
 .db $1F,$80,$71,$E0,$EA,$F0,$E0,$F0,$E0,$F0,$75,$E0,$1F,$80
 .db $1F,$80,$79,$E0,$E1,$F0,$80,$10,$E1,$F0,$79,$E0,$1F,$80
 .db $1D,$80,$78,$E0,$DD,$70,$DF,$B0,$EB,$B0,$71,$E0,$1B,$80
 .db $1F,$80,$72,$60,$D6,$F0,$D6,$70,$D6,$F0,$72,$60,$1F,$80
 .db $1F,$80,$6F,$60,$E6,$70,$80,$10,$E6,$70,$6F,$60,$1F,$80
 .db %10101010,%10100000
 .db %01010101,%01010000
 .db %10101010,%10100000
 .db %01010101,%01010000
 .db %10101010,%10100000
 .db %01010101,%01010000
 .db %10101010,%10100000

newS:
 .db %00111111,%11111100
 .db %01111111,%11111110
 .db %11001111,%11111111
 .db %11010110,%11011101
 .db %11010101,%01010101
 .db %11010100,%11010101
 .db %11010110,%01101011
 .db %11111111,%11111111

fleche:
.db %00100000
.db %01110000
.db %11111000
.db %00000000
.db %00000000
.db %11111000
.db %01110000
.db %00100000
.db %00000000
.db %00000000
.db %00100100
.db %01100110
.db %11100111
.db %01100110
.db %00100100

frstlvl:
 .db 0000

prelvladr:
 .db 0000

finjeu:
 .db 00

bnscoef:
 .db 01020304060607070708
 .db 0A0C0B0C0C

.END
.END