Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : Création d'une démo - chapitre 3, partie 2, les lutins
(Article écrit par Nori - octobre 2024)
|
|
Introduction
Nous voilà prêts pour un plongeon dans l'univers des lutins deuxième opus, un plongeon en eau claire,
calme, apaisée, il n'y aura donc aucune difficulté à surnager tant le sujet est facile à appréhender,
à un point tel que j'ai l'impression de vous vendre du vent.
Évoqué dernièrement, nous ferons évoluer notre programme de façon à ajouter un champ de lutins qui
bougeront en parallaxe. L'effet que je vous propose ressemble à s'y méprendre aux champs étoilés
tels qu'on peut les voir dans certaines vielles démos Amiga. Ces champs sont en général composés
de lutins ayant une hauteur d'une seule ligne pour quelques pixels de large, quatre ou cinq tout
au plus. Pour notre démo, j'ai volontairement considérablement grossi les étoiles de façon à rendre
l'exemple plus parlant.
Un prérequis sera d'avoir lu la partie 1 de cet article que l'on peut trouver
ici.
Principe
Nous allons utiliser la capacité d'afficher avec un seul canal DMA plusieurs lutins, cela n'est
possible que s'ils ne se superposent pas verticalement. Sachant que nous choisissons de ne déplacer
les lutins qu'horizontalement, cela devient donc très facile à appliquer car l'électronique de
l'Amiga est parfaitement adaptée à ce type d'effet.
Avant de continuer, nous allons jeter un oeil sur un des effets d'une célèbre démo du groupe Scoopex :
Mental Hangover. L'effet en question est un champ d'étoiles qui se déplace horizontalement, il est
composé de trois plans qui bougent en (pseudo) parallaxe, exactement le même effet que l'on s'apprête
à programmer.
Champ d'étoiles bleues de la démo Mental Hangover/Scoopex
Voyons comment le programmeur s'y prend. Au tout début de la démo, pendant l'affichage de l'aigle,
interrompez le déroulement du programme (utilisez Action Replay ou un émulateur), la routine qui
gère le déplacement des étoiles se trouve à l'adresse $00000426. Ce sous-programme ne fait que 26
octets de long, c'est court, très court, mais amplement suffisant pour déplacer les étoiles latéralement
sur trois plans distincts. Ce que nous indique ce bout de programme est que la première liste de lutins
se trouve en $07F802, les étoiles pour chaque plan sont au nombre de 45 (le compteur de boucle vaut $2C),
ce qui nous fait donc un total de 45*3=135 lutins. La boucle ne fait rien d'autre qu'incrémenter l'abscisse
de chaque lutin des listes de respectivement 2, 4 et 6 pixels (en basse résolution).
; sous-routine deplacement lutins (etoiles)
$000426 41f9 0007 f803 lea $7f803,a0
$00042c 7e2c moveq #$2c,d7
$00042e 5610 addq.b #$03,(a0)
$000430 5428 016c addq.b #$02,$016c(a0)
$000434 5228 02d8 addq.b #$01,$02d8(a0)
$000438 5088 addq.l #$08,a0
$00043a 51cf fff2 dbf .w d7,#$fff2
$00043e 4e75 rts
; liste premier plan du champ d'etoiles (etoiles les plus rapides)
$7F802 2756 2800 0006 0003 2D9F 2E00 0006 0003
$7F812 3311 3400 0006 0003 3980 3A00 0006 0003
$7F822 3FD9 4000 0006 0003 4503 4600 0006 0003
$7F832 4B55 4C00 0006 0003 51A9 5200 0006 0003
$7F842 57C0 5800 0006 0003 5D6D 5E00 0006 0003
$7F852 63FE 6400 0006 0003 6937 6A00 0006 0003
|
Parallaxe
Revenons à notre démo, nous allons définir trois plans de déplacement distincts, avec une seule liste
de lutins par plan. Chaque objet volant sera en seize couleurs, ce qui implique et oblige à combiner les
lutins deux par deux (Cf. partie de l'article
précédent sur les lutins). Voilà comment nous allons distribuer les huit lutins :
- Champ d'avant-plan composé de quatre lutins pour obtenir un objet de 32 pixels de large pour une
hauteur de huit lignes :
Une étoile de ce champ composée de quatre lutins ressemble à ceci :
Cet objet a une largeur de 32 pixels, sachant qu'il s'agit de lutins en seize couleurs, il faut donc :
2x2=4 lutins en tout pour composer une étoile du premier plan.
- Champ intermédiaire composé de lutins pour un objet de 16 pixels x 6 lignes :
La largeur de l'objet est exactement de seize pixels, nous n'avons besoin que de deux lutins pour le
représenter. Oui deux lutins de quatre couleurs parfaitement superposés nous donnent à l'affichage
un lutin de seize couleurs (Cf. article précédent).
- Champ d'arrière-plan composé de lutins de 16 pixels x 4 lignes :
Ici, même remarque que pour le plan intermédiaire.
Convertisseurs
Nous avons dessiné nos lutins (sous Deluxe Paint ou autre), nos fichiers sauvés en IFF, il nous faut à
présent les convertir en format compréhensible par l'électronique de l'Amiga. Pour ce faire, IFFMaster
est notre allié.
Avant de charger le fichier image de notre étoile, veillez à correctement paramétrer les caractéristiques
des fichiers de sortie :
Après chargement de l'image, il faudra sélectionner l'étoile, la sélection horizontale devra avoir une
taille de seize pixels de largeur, pour un dessin plus large que seize pixels, il faudra traiter chaque tranche
de seize pixels une à une.
La sélection achevée, aller dans le menu et sauver le fichier lutin tel quel :
Voilà, les fichiers ainsi convertis sont prêts à être embarqués dans notre programme.
Commentaire du programme
Liste Copper
Comme d'habitude, nous allons débuter par la construction de la liste Copper, du moins la partie qui a en
charge les lutins.
; palette lutins
lea pall(pc),a1 ; liste palette source
move.w #$01a0,d0 ; 1er registre couleur
move.w #16-1,d7 ; nb de couleurs
.lc: ;
move.w d0,(a0)+ ; registre couleur
move.w (a1)+,(a0)+ ; couleur
addq.w #2,d0 ; incremente registre couleur
dbf d7,.lc ;
|
Ce bout de programme charge la palette des lutins, ici seize couleurs sont chargées. On pourrait ne charger
que douze couleurs (les quatre autres correspondent aux couleurs transparentes) mais j'ai voulu, une fois
de plus, simplifier.
; pointeurs lutins
lea ptlut(pc),a1 ; liste des pointeurs donnees lutins
move.w #$0120,d0 ; registre pointeur
moveq #16-1,d7 ;
.lp: ;
move.l (a1)+,d1 ; pt lutin
beq.b .e ; sortie boucle si fin de liste
move.w d0,(a0)+ ; registre pointeur partie haute
swap d1 ; partie haute adresse lutin
move.w d1,(a0)+ ; partie haute adresse lutin
addq.w #2,d0 ;
move.w d0,(a0)+ ; registre pointeur partie basse
addq.w #2,d0 ;
swap d1 ; partie basse adresse lutin
move.w d1,(a0)+ ; partie basse adresse lutin
bra.b .lp ; tt prochain lutin
.e:
|
Nous chargeons les pointeurs des lutins ($DFF120,$DFF122,...) avec les adresses des listes lutins
correspondants aux étoiles des champs.
- $DFF120,$DFF122,$DFF124,$DFF126,$DFF128,$DFF12A,$DFF12C,$DFF12E sont
chargés avec l'étoile, la grosse (32x8 pixels).
- $DFF130,$DFF132,$DFF134,$DFF136 sont chargés avec les lutins correspondants à l'étoile
moyenne (16x6 pixels).
- $DFF138,$DFF13A,$DFF13C,$DFF13E sont chargés avec les lutins correspondants
à la petite étoile (16x4 pixels).
Initialisation
La toute première initialisation consiste à dupliquer les lutins de chaque liste. Les étoiles de chaque plan
étant identiques, nous n'avons donc qu'à copier le premier lutin dans tous les lutins de la liste.
Voici à quoi ressemble la liste de nos lutins, le premier lutin de chaque liste est le seul renseigné. Au
passage, vous remarquerez le bit "AT" ($0080) activé dans chaque mot de contrôle du lutin impair, ceci nous permet
d'afficher des lutins en seize couleurs.
; liste lutins 32x8 pairs
lut0: dc.w $0000,$0000
dc.w $2666,$1E1E,$6666,$1E1E,$E666,$1E1E,$E666,$1E1E
dc.w $E666,$1E1E,$E666,$1E1E,$6666,$1E1E,$2666,$1E1E
flut0:
blk.b NBLG*(flut0-lut0),0
dc.w $0000,$0000 ; fin de liste
; liste lutins 32x8 impairs x4
lut1: dc.w $0000,$0080
dc.w $01FE,$0001,$01FE,$0001,$01FE,$0001,$01FE,$0001
dc.w $01FE,$0001,$01FE,$0001,$01FE,$0001,$01FE,$0001
flut1:
blk.b NBLG*(flut1-lut1),0
dc.w $0000,$0000 ; fin de liste
; liste lutins 32x8 pairs
lut2: dc.w $0000,$0000
dc.w $1998,$0784,$1998,$0786,$1998,$0787,$1998,$0787
dc.w $1998,$0787,$1998,$0787,$1998,$0786,$1998,$0784
flut2:
blk.b NBLG*(flut2-lut2),0 ; 3 autres lutins
dc.w $0000,$0000 ; fin de liste
; liste lutins 32x8 impairs x4
lut3: dc.w $0000,$0080
dc.w $007C,$FFFC,$007E,$FFFE,$007F,$FFFF,$007F,$FFFF
dc.w $007F,$FFFF,$007F,$FFFF,$007E,$FFFE,$007C,$FFFC
flut3:
blk.b NBLG*(flut3-lut3),0 ; 3 autres lutins
dc.w $0000,$0000 ; fin de liste
; liste lutins 16x6 pairs x7
lut4: dc.w $0000,$0000
dc.w $2670,$1E0C,$E673,$1E0F,$E673,$1E0F,$E673,$1E0F
dc.w $E673,$1E0F,$2670,$1E0C
flut4:
blk.b NBLM*(flut4-lut4),0 ; 6 autres lutins
dc.w $0000,$0000 ; fin de liste
; liste lutins 16x6 impairs x7
lut5: dc.w $0000,$0080
dc.w $01FC,$0000,$01FF,$0000,$01FF,$0000,$01FF,$0000
dc.w $01FF,$0000,$01FC,$0000
flut5:
blk.b NBLM*(flut5-lut5),0 ; 6 autres lutins
dc.w $0000,$0000 ; fin de liste
; liste lutins 16x4 pairs x11
lut6: dc.w $0000,$0000
dc.w $6300,$1F00,$E300,$1F00,$E300,$1F00,$6300,$1F00
flut6:
blk.b NBLP*(flut6-lut6),0 ; 11 autres lutins
dc.w $0000,$0000 ; fin de liste
; liste lutins 16x4 impairs x11
lut7: dc.w $0000,$0080
dc.w $0080,$0000,$00C0,$0000,$00C0,$0000,$0080,$0000
flut7:
blk.b NBLP*(flut7-lut7),0 ; 11 autres lutins
dc.w $0000,$0000 ; fin de liste
|
Il suffit donc de simplement dupliquer les données des lutins le long de la liste (mots de contrôle inclus).
; duplique lutins dans liste
lea ptlut(pc),a0 ; liste des lutins de reference pour copie
lea nlutc(pc),a1 ; nb de copie par lutin
lea tlut(pc),a2 ; table taille lutin
move.w #8-1,d7 ; 8 listes lutins
.c0: ;
move.l (a0)+,a3 ; pt vers lutin
move.l a3,a5 ;
move.l (a2)+,d6 ; taille d'un lutin
lea (a3,d6.w),a4 ; adr depart copie
subq.w #1,d6 ; compteur pr copie
move.w d6,d4 ;
moveq #0,d5 ;
move.b (a1)+,d5 ;
subq.w #2,d5 ; compteur pr copie
.c1: ;
move.l a5,a3 ; adr source corrigee
move.w d4,d6 ; compteur copie
.c2: ;
move.b (a3)+,(a4)+ ; duplique lutin
dbf d6,.c2 ; copie d'un lutin
dbf d5,.c1 ; copie prochaine lutin de la liste
dbf d7,.c0 ; tt prochaine liste lutins
|
La seconde des initialisations correspond à celles des ordonnées des lutins. Les étoiles sont distribuées
aléatoirement dans la zone rectangulaire occupée par le logo. Cependant, verticalement les étoiles ne sont
pas positionnées aléatoirement, car il y a la contrainte que les lutins de chaque plan (trois plans) ne
doivent pas se superposer, ni même se trouver collées l'une sous l'autre. Bien évidemment les ordonnées
respectives doivent être croissantes. Nous avons entré les ordonnées des trois listes dans trois
tables manuellement :
; ordonnees des 3 listes de lutins
coorlut0: dc.b $2c+04,$2c+16,$2c+32,$2c+48 ; 4x ordonnees lutins taille 32x8
dc.b 0 ; marqueur de fin de liste
coorlut1: dc.b $2c+00,$2c+08,$2c+16,$2c+24,$2c+38,$2c+48,$2c+58 ; 7x ordonnees lutins taille 16x6
dc.b 0 ; marqueur de fin de liste
coorlut2: dc.b $2c+02,$2c+08,$2c+16,$2c+22,$2c+30,$2c+37,$2c+44 ; 11x ordonnees lutins taille 16x4
dc.b $2c+51,$2c+58,$2c+64,$2c+70 ;
dc.b 0 ; marqueur de fin de liste
|
Vous remarquerez que la première liste contient quatre lutins, la deuxième sept, et la troisième onze.
La zone étant étroite verticalement (64 pixels de haut) et les lutins relativement gros, on ne peut donc
en placer énormément.
Il suffit maintenant de récupérer les ordonnées de ces tables pour les injecter dans les mots de contrôle
des lutins. Ce que fait cette routine :
; init ordonnees lutins champs etoiles -grandes-
lea coorlut0(pc),a0 ; ordonnees
lea lut0,a1 ; liste lutins pairs -grande taille
lea lut1,a2 ; liste lutins impairs -grande taille
lea lut2,a3 ; 2eme partie lutin
lea lut3,a4 ; 2eme partie lutin
moveq #NBLG-1,d7 ; nb-1 lutins
.0: ;
move.b (a0)+,d0 ; y
move.b d0,(a1) ;
move.b d0,(a2) ;
move.b d0,(a3) ;
move.b d0,(a4) ;
addq.b #TGL,d0 ;
move.b d0,2(a1) ; y+hauteur+1
move.b d0,2(a2) ; idem pour lutin impair
move.b d0,2(a3) ; idem 2eme partie lutin
move.b d0,2(a4) ; idem 2eme partie lutin
lea flut0-lut0(a1),a1 ; passe au prochain lutin de la liste
lea flut0-lut0(a2),a2 ; idem pour lutin impair
lea flut0-lut0(a3),a3 ; idem 2eme partie lutin
lea flut0-lut0(a4),a4 ; idem 2eme partie lutin
dbf d7,.0 ; tt prochain lutin
; init ordonnees lutins champs etoiles -moyennes-
lea coorlut1(pc),a0 ; ordonnees
lea lut4,a1 ; liste lutins
lea lut5,a2 ; 2eme partie lutin
moveq #NBLM-1,d7 ; nb-1 lutins
.1: ;
move.b (a0)+,d0 ; y
move.b d0,(a1) ;
move.b d0,(a2) ;
addq.b #TML,d0 ;
move.b d0,2(a1) ; y+hauteur+1
move.b d0,2(a2) ; idem pour lutin impair
lea flut4-lut4(a1),a1 ; passe au prochain lutin de la liste
lea flut5-lut5(a2),a2 ; idem pour lutin impair
dbf d7,.1 ; tt prochain lutin
; init ordonnees lutins champs etoiles -petites-
lea coorlut2(pc),a0 ; ordonnees
lea lut6,a1 ; liste lutins
lea lut7,a2 ; 2eme partie lutin
moveq #NBLP-1,d7 ; nb-1 lutins
.2: ;
move.b (a0)+,d0 ; y
move.b d0,(a1) ;
move.b d0,(a2) ;
addq.b #TPL,d0 ;
move.b d0,2(a1) ; y+hauteur+1
move.b d0,2(a2) ; idem pour lutin impair
lea flut6-lut6(a1),a1 ; passe au prochain lutin de la liste
lea flut7-lut7(a2),a2 ; idem pour lutin impair
dbf d7,.2 ; tt prochain lutin
|
L'initialisation horizontale, quant à elle, est une autre affaire, nous pouvons sans contrainte distribuer
aléatoirement les abscisses.
Pour ce faire, nous avons donc ajouté une routine qui génère aléatoirement des abscisses pour chaque
lutin de la liste. Petite difficulté (un bien grand mot) supplémentaire, les abscisses des lutins associés
pour être affichés en seize couleurs doivent être rigoureusement identiques.
La période des nombres générés aléatoirement n'est pas d'une grande amplitude mais,
pour notre cas, elle suffit amplement.
; genere des abscisses pseudo aleatoires lutins
moveq #0,d0 ; genere une racine base de
lea $dff000,a6 ; la generation nbre aleatoire
move.w 6(a6),d0 ;
lsl.w #8,d0 ;
nop ;
move.b 7(a6),d0 ; racine
lea ptlut(pc),a0 ; liste des lutins
lea nlut(pc),a1 ; liste nb de nbre aleatoire a generer par lutin
lea lluti(pc),a2 ; liste taille lutins (en octets)
lea llut(pc),a3 ; liste taille entre deux lutins (en octets)
moveq #4-1,d7 ; nb-1 de paires de lutins a traiter
.3: ;
move.w d0,d1 ; copie racine
move.l (a0),a4 ; pointeur vers mot controle lutin
move.l (a2)+,d3 ; distance entre lutin pair/impair
move.l (a3)+,d2 ; taille d'un lutin
moveq #0,d6 ;
move.b (a1)+,d6 ;
subq.w #1,d6 ; nb-1 lutins de la liste
.4: ;
lsl.w #5,d1 ;
add.w d0,d1 ;
addq.w #1,d1 ; nb aleatoire
move.w d1,d0 ; nouvelle racine
move.b d1,1(a4) ; abscisse lutin
move.b d1,1(a4,d3.w) ; meme abscisse lutin impair
add.w d2,a4 ; prochain lutin liste
dbf d6,.4 ;
addq.w #8,a0 ; prochain lutin pair
dbf d7,.3 ; prochain nbre
rts
|
Nous en avons fini avec l'initialisation, passons au traitement des lutins qui se trouvent dans la
boucle principale. Il consiste en toute simplicité à déplacer horizontalement chaque lutin. Pour ce
faire, tout ce que nous avons à faire est d'incrémenter l'abscisse dans le mot de contrôle de chaque
lutin. Autre astuce pour simplifier le traitement, nous n'incrémentons que H1-H8, qui se trouvent dans
l'octet de poids faible du premier mot de contrôle, on ne peut plus simple car une unique instruction
d'incrémentation suffit : addq.b #x,mot de contrôle. La contrainte est que les abscisses
des lutins ne peuvent être que paires car le bit H0 n'est pas activé ni altéré. Si le bit H0 était activé,
les abscisses seraient toutes impaires.
Extrait de La Bible De L'Amiga © Micro Application
; deplacement etoiles -grandes-
lea lut0+1,a1 ; liste lutins pairs -grande taille
lea lut1+1,a2 ; liste lutins impairs -grande taille
lea lut2+1,a3 ; liste 2eme partie lutins pairs -grande taille
lea lut3+1,a4 ; liste 2eme partie lutins impairs -grande taille
moveq #4-1,d7 ; nb-1 lutins
.0: ;
move.b (a1),d0 ;
addq.b #VGL,d0 ; deplacement de 6 pixels a droite
move.b d0,(a1) ; injecte nouvelle abscisse
move.b d0,(a2) ; idem pour lutin impair
addq.b #8,d0 ; abscisse 2eme partie lutins
move.b d0,(a3) ; injecte nouvelle abscisse
move.b d0,(a4) ; idem pour lutin impair
lea flut0-lut0(a1),a1 ; passe au prochain lutin de la liste
lea flut0-lut0(a2),a2 ; idem pour lutin impair
lea flut0-lut0(a3),a3 ; passe au prochain lutin de la liste
lea flut0-lut0(a4),a4 ; idem pour 2eme partie lutins
dbf d7,.0 ;
; deplacement etoiles -moyennes-
lea lut4+1,a1 ; liste lutins pairs -grande taille
lea lut5+1,a2 ; liste lutins impairs -grande taille
moveq #7-1,d7 ; nb-1 lutins
.1: ;
move.b (a1),d0 ;
addq.b #VML,d0 ; deplacement de 4 pixels a droite
move.b d0,(a1) ; injecte nouvelle abscisse
move.b d0,(a2) ; idem pour lutin impair
lea flut4-lut4(a1),a1 ; passe au prochain lutin de la liste
lea flut5-lut5(a2),a2 ; idem pour lutin impair
dbf d7,.1 ;
; deplacement etoiles -petites-
lea lut6+1,a1 ; liste lutins pairs -grande taille
lea lut7+1,a2 ; liste lutins impairs -grande taille
moveq #11-1,d7 ; nb-1 lutins
.2: ;
move.b (a1),d0 ;
addq.b #VPL,d0 ; deplacement de 2 pixels a droite
move.b d0,(a1) ; injecte nouvelle abscisse
move.b d0,(a2) ; idem pour lutin impair
lea flut6-lut6(a1),a1 ; passe au prochain lutin de la liste
lea flut7-lut7(a2),a2 ; idem pour lutin impair
dbf d7,.2 ;
|
Vous aurez remarqué que c'est exactement ce que fait la routine du champ d'étoiles de la démo de Scoopex,
à la petite différence que ses étoiles à lui ont toute la même hauteur, soit une seule ligne.
Nous sommes arrivés au programme complet, plus bas. Même s'il manque encore quelques éléments, le résultat
commence à ressembler étrangement à une démo.
Je vous laisse à la lecture et la compréhension du programme et je vous donne rendez-vous pour un prochain
article traitant du Blitter et plus particulièrement de l'affichage des BOB. Ce n'est pas extrêmement
compliqué (le mode copie de blocs en tout cas) mais cela nécessite tout de même pas mal d'explications.
Champ d'étoiles bougeant en parallaxe sous le logo
Dernière remarque
Le positionnement simpliste des lutins de ce genre est guidé par la simplicité de l'effet, un cas particulier,
donc simplifié à outrance. Si on devait positionner librement un lutin n'importe où à l'écran, voici ce à quoi
ressemblerait la routine renseignant les mots de contrôle. Je n'ai pas testé cette routine et à dire vrai, je
n'ai jamais programmé ce type de routine auparavant, mais à la relecture cela me semble correct (combien de
fois ne me suis-je trompé avec une telle affirmation ?). La difficulté de ce programme réside dans le fait
que les bits sont esseulés, mélangés dans le deuxième mot de contrôle, il faut donc à coup de décalage et
activation de bits rétablir la cohérence du tout.
Personnellement, je n'ai jamais utilisé ce genre de petit programme tel que celui ci-dessous. Pour positionner
un lutin à l'écran, je lui préfère et je crois que tous les autres programmeurs aussi, la méthode qui met en scène
deux tables précalculées. L'une contient tous les premiers mots de contrôle pour chaque abscisse, l'autre tous
les deuxièmes mots de contrôle pour chaque ordonnée. Ainsi donc, si je veux afficher un lutin à la position (x,y),
il suffit d'aller piocher dans la table le mot de contrôle en utilisant comme index de tables 2x et 2y (x et y
sont les coordonnées du lutin). Plus simple, ce serait indécent. Il y a tout de même une contrainte et non des
moindres, la hauteur du lutin ne peut être changée à la volée, il faudrait recalculer une autre table en fonction
de la hauteur changeante. Si vous utilisez des lutins à hauteur fixe et possédez un Amiga 500 de base,
cette méthode est la plus rapide.
HAUTEURLUTIN = 16
; init : parametres entree
move.w #2,d0 ; abscisse lutin
move.w #211,d1 ; ordonnee lutin
bsr lutin ; renseigne mots controle
rts
; positionne lutin
; entree : d0 = x d1 = y
; sortie :
; regs : d0/d1/d2/d3
lutin:
; traitement H0
move.w #%0000000000000000,d2 ; deuxieme mot controle lutin
and.w #$01ff,d0 ; abscisse dans l'intervalle [0,511]
lsr #1,d0 ; recupere H0 dans le drapeau C
bcc.b .0 ; C = 0 ?
bset #0,d2 ; non alors H0 = 1
bra.b .1 ;
.0: ;
bclr #0,d2 ; oui alors H0 = 0
.1:
; traitment E8
cmp.w #255,d1 ; y > 255 ?
bcs.b .2 ;
bset #2,d2 ; oui alors active E8
bra.b .3 ;
.2: ;
bclr #2,d2 ; non alors desactive E8
.3:
move.w d1,d3 ;
; traitment L8
add.w #HAUTEURLUTIN,d1 ; ordonnee + 1 de la derniere ligne lutin
cmp.w #255,d1 ; y > 255 ?
bcs.b .4 ;
bset #1,d2 ; oui alors active L8
bra.b .5 ;
.4: ;
bclr #1,d2 ; non alors desactive L8
.5:
; fusionne x/2 et y/2 dans 1er mot de controle
lsl.w #8,d3 ; decale Ex dans octet superieur du 1er mot de controle
add.w d3,d0 ; 1er mot de controle
move.w d0,motcontrole ; injecte dans premier mot de controle du lutin
move.w d2,motcontrole+2 ; injecte dans second mot de controle du lutin
rts
|
Programme
; **************************************************
; * *
; * DEMO OBLIGEMENT *
; * *
; **************************************************
; date: aout 2023
; auteur: NoRi
; plateforme: Amiga OCS (512 ko minimum)
; compileur/linkeur: ASm-One ou VASM + VLINK
; publication: Amiga Obligement
INCDIR "" ; recherche fichiers et donnees dans le repertoire
section programme,code_p ; hunk pour DOS, alloue memoire pour code
DEBUG = 0 ; drapeau activation des parties code pour debogage
; constantes ecran
LECRAN = 320 ; largeur ecran video affichage
HECRAN = 256 ; hauteur ecran video affichage
; donnees affichage ecran (centrage affichage)
XSTRT = 129 ; position de depart
XSTOP = XSTRT+LECRAN ; 129+320
YSTRT = $2c ;
YSTOP = YSTRT+HECRAN ;
HSTRT = XSTRT-16 ; 129-16
RES = 8 ; 8=basse resolution (4=haute resolution)
; **************************************************
; * CONSTANTES ECRAN PRINCIPAL *
; **************************************************
NBP = 0 ; nb de plan de bits
WS = LECRAN ; largeur ecran de travail
HS = HECRAN ; hauteur ecran de travail
; **************************************************
; * CONSTANTES RASTERS *
; **************************************************
COLB = $0000 ; couleur bordure
NBB = 16 ; nb de barres rasters
HBR = 16 ; hauteur en pixel d'une barre
; **************************************************
; * CONSTANTES LOGO *
; **************************************************
HL = 64 ; hauteur en pixels logo
LL = 640 ; largeur en pixels logo
NBPDBL = 1 ; nb de plans de bits partie logo
WL = WS ; largeur ecran logo, DMA*16
; **************************************************
; * CONSTANTES LUTINS *
; **************************************************
NBLG = 4 ; nb de grands lutins champ etoile
NBLM = 7 ; nb de moyens lutins champ etoile
NBLP = 11 ; nb de petits lutins champ etoile
TGL = 8 ; hauteur lutins -grands
TML = 6 ; hauteur lutins -moyens
TPL = 4 ; hauteur lutins -petits
VGL = 5 ; vitesse champs de lutins -grands
VML = 2 ; vitesse champs de lutins -moyens
VPL = 1 ; vitesse champs de lutins -petits
; ***************************************************
; * MACRO DEFINITION *
; ***************************************************
; macro d'attente de la liberation du blitter
waitblt MACRO
tst.b $02(a6) ; evite bug A4000
.\@ btst #6,$02(a6) ;
bne.b .\@ ;
ENDM
debut:
; **************************************************
; * INIT GENERALES *
; **************************************************
bsr sauvesys ; pas terrible a remplacer par qqch de plus solide
lea $dff000,a6 ; adresse de base registres specialises de l'amiga
waitblt ; on s'assure que le blitter ait fini
bsr initcopvide ; genere la liste copper vide
move.w #$7fff,$96(a6) ; desactive tous les DMA
lea $dff000,a6 ; attend d'etre dans la zone non affichable
move.l #300<<8,d1 ; avant de continuer
bsr vbl ;
move.w #$83e0,$96(a6) ; active DMA pdb,copper,blitter
move.w #$7fff,$9a(a6) ; coupe interruptions
bsr init ; inits generales
; **************************************************
; * *
; * BOUCLE PRINCIPALE *
; * *
; **************************************************
bouclep:
lea $dff000,a6 ; synchro verticale
move.l #280<<8,d1 ;
bsr vbl ;
move.l principal,a0 ; recupere pointeur vers routine principale en cours
jsr (a0) ; tt principal
btst.b #6,$bfe001 ; test bouton gauche souris appuye ?
bne.b bouclep ; non alors continue la boucle
exit: ; oui
bsr restauresys ; pas terrible a remplacer par qqch de plus solide
clr.l d0 ; code retour Amiga DOS
rts ; sortie vers DOS
; **************************************************
; * *
; * SOUS-ROUTINES GENERALES *
; * *
; **************************************************
; synchro verticale
; entree: d1 = position verticale raster * 256
; a6 = $dff000
; sortie:
; regs : d0/d1/d2
vbl:
move.l #$1ff00,d2 ; masque
.1: ;
move.l $04(a6),d0 ; position faisceau a electron en cours
and.l d2,d0 ;
cmp.l d1,d0 ; position atteinte ?
bne.b .1 ; non
rts ; oui commence tt trame
sauvesys:
move.b #%10000111,$bfd100 ;
move.w $dff01c,sintena ;
or.w #$c000,sintena ;
move.w $dff002,sdmacon ;
or.w #$8100,sdmacon ;
rts ;
restauresys:
move.w #$7fff,$dff09a ;
move.w sintena,$dff09a ;
move.w #$7fff,$dff096 ;
move.w sdmacon,$dff096 ;
move.l 4,a6 ;
lea nom_glib,a1 ;
moveq #0,d0 ;
jsr -552(a6) ;
move.l d0,a0 ;
move.l 38(a0),$dff080 ;
clr.w $dff088 ;
move.l 4,a6 ;
jsr -138(a6) ;
rts
; *************************************************
; * *
; * INITIALISATIONS *
; * *
; *************************************************
init:
move.l #initpart6,principal ; init pt routine principale
; duplique lutins dans liste
lea ptlut(pc),a0 ; liste des lutins de reference pour copie
lea nlutc(pc),a1 ; nb de copie par lutin
lea tlut(pc),a2 ; table taille lutin
move.w #8-1,d7 ; 8 listes lutins
.c0: ;
move.l (a0)+,a3 ; pt vers lutin
move.l a3,a5 ;
move.l (a2)+,d6 ; taille d'un lutin
lea (a3,d6.w),a4 ; adr depart copie
subq.w #1,d6 ; compteur pr copie
move.w d6,d4 ;
moveq #0,d5 ;
move.b (a1)+,d5 ;
subq.w #2,d5 ; compteur pr copie
.c1: ;
move.l a5,a3 ; adr source corrigee
move.w d4,d6 ; compteur copie
.c2: ;
move.b (a3)+,(a4)+ ; duplique lutin
dbf d6,.c2 ; copie d'un lutin
dbf d5,.c1 ; copie prochaine lutin de la liste
dbf d7,.c0 ; tt prochaine liste lutins
; init ordonnees lutins champs etoiles -grandes-
lea coorlut0(pc),a0 ; ordonnees
lea lut0,a1 ; liste lutins pairs -grande taille
lea lut1,a2 ; liste lutins impairs -grande taille
lea lut2,a3 ; 2eme partie lutin
lea lut3,a4 ; 2eme partie lutin
moveq #NBLG-1,d7 ; nb-1 lutins
.0: ;
move.b (a0)+,d0 ; y
move.b d0,(a1) ;
move.b d0,(a2) ;
move.b d0,(a3) ;
move.b d0,(a4) ;
addq.b #TGL,d0 ;
move.b d0,2(a1) ; y+hauteur+1
move.b d0,2(a2) ; idem pour lutin impair
move.b d0,2(a3) ; idem 2eme partie lutin
move.b d0,2(a4) ; idem 2eme partie lutin
lea flut0-lut0(a1),a1 ; passe au prochain lutin de la liste
lea flut0-lut0(a2),a2 ; idem pour lutin impair
lea flut0-lut0(a3),a3 ; idem 2eme partie lutin
lea flut0-lut0(a4),a4 ; idem 2eme partie lutin
dbf d7,.0 ; tt prochain lutin
; init ordonnees lutins champs etoiles -moyennes-
lea coorlut1(pc),a0 ; ordonnees
lea lut4,a1 ; liste lutins
lea lut5,a2 ; 2eme partie lutin
moveq #NBLM-1,d7 ; nb-1 lutins
.1: ;
move.b (a0)+,d0 ; y
move.b d0,(a1) ;
move.b d0,(a2) ;
addq.b #TML,d0 ;
move.b d0,2(a1) ; y+hauteur+1
move.b d0,2(a2) ; idem pour lutin impair
lea flut4-lut4(a1),a1 ; passe au prochain lutin de la liste
lea flut5-lut5(a2),a2 ; idem pour lutin impair
dbf d7,.1 ; tt prochain lutin
; init ordonnees lutins champs etoiles -petites-
lea coorlut2(pc),a0 ; ordonnees
lea lut6,a1 ; liste lutins
lea lut7,a2 ; 2eme partie lutin
moveq #NBLP-1,d7 ; nb-1 lutins
.2: ;
move.b (a0)+,d0 ; y
move.b d0,(a1) ;
move.b d0,(a2) ;
addq.b #TPL,d0 ;
move.b d0,2(a1) ; y+hauteur+1
move.b d0,2(a2) ; idem pour lutin impair
lea flut6-lut6(a1),a1 ; passe au prochain lutin de la liste
lea flut7-lut7(a2),a2 ; idem pour lutin impair
dbf d7,.2 ; tt prochain lutin
; genere des abscisses pseudo aleatoires lutins
moveq #0,d0 ; genere une racine base de
lea $dff000,a6 ; la generation nbre aleatoire
move.w 6(a6),d0 ;
lsl.w #8,d0 ;
nop ;
move.b 7(a6),d0 ; racine
lea ptlut(pc),a0 ; liste des lutins
lea nlut(pc),a1 ; liste nb de nbre aleatoire a generer par lutin
lea lluti(pc),a2 ; liste taille lutins (en octets)
lea llut(pc),a3 ; liste taille entre deux lutins (en octets)
moveq #4-1,d7 ; nb-1 de paires de lutins a traiter
.3: ;
move.w d0,d1 ; copie racine
move.l (a0),a4 ; pointeur vers mot controle lutin
move.l (a2)+,d3 ; distance entre lutin pair/impair
move.l (a3)+,d2 ; taille d'un lutin
moveq #0,d6 ;
move.b (a1)+,d6 ;
subq.w #1,d6 ; nb-1 lutins de la liste
.4: ;
lsl.w #5,d1 ;
add.w d0,d1 ;
addq.w #1,d1 ; nb aleatoire
move.w d1,d0 ; nouvelle racine
move.b d1,1(a4) ; abscisse lutin
move.b d1,1(a4,d3.w) ; meme abscisse lutin impair
add.w d2,a4 ; prochain lutin liste
dbf d6,.4 ;
addq.w #8,a0 ; prochain lutin pair
dbf d7,.3 ; prochain nbre
rts
nlut: dc.b NBLG,NBLG,NBLM,NBLP ; nb de nbr aleatoires a generer par liste
nlutc: dc.b NBLG,NBLG,NBLG,NBLG,NBLM,NBLM,NBLP,NBLP ; nb de nbr aleatoires a generer par liste developpee
even
lluti: dc.l lut1-lut0,lut3-lut2,lut5-lut4,lut7-lut6 ; taille lutins
llut: dc.l flut0-lut0,flut2-lut2,flut4-lut4,flut6-lut6 ; taille lutins
tlut: dc.l flut0-lut0,flut1-lut1,flut2-lut2,flut3-lut3 ; taille lutins pour duplication en init
dc.l flut4-lut4,flut5-lut5,flut6-lut6,flut7-lut7 ;
; construction liste copper
; entree:
; sortie:
; regs : d0/d1/d7/a0/a1
initcop:
lea copper0,a0 ;
move.l #$01060000,(a0)+ ; bplcon3 minimal
move.l #$01fc0000,(a0)+ ; mode 16 bits lutins/plan de bits
; partie superieure = logo
lea pallogo(pc),a1 ; table contenant les valeurs RVB de la palette
move.w #$0180,d0 ; 1er registre couleur
move.w #(1<<NBPDBL)-1,d7 ; nb-1 couleurs / tt 2 couleurs
.c: ;
move.w d0,(a0)+ ; registre couleur
move.w (a1)+,(a0)+ ; couleur RVB
addq.w #2,d0 ; incremente registre couleur
dbf d7,.c ; tt prochaine couleur
move.l #$008e2c91,(a0)+ ; DIWSTRT / cache le 1er mot de DMA a chqe ligne
move.l #$00902cc1,(a0)+ ; DIWSTOP
move.l #$00920038,(a0)+ ; DDFSTR
move.l #$009400d0,(a0)+ ; DDTSTOP / 20 mots de DMA charges a chqe ligne
move.l a0,sptlogo ; sauve pos registre pdb ds liste copper
move.l #logo,d0 ; adr 1er pdb
move.l #(LL/8)*(HL),d1 ; taille en octets d'1 pdb => 80*64 = 5120 octets
move.w #NBPDBL-1,d7 ; nb-1 de pdb
bsr setpdb ; injecte init pdb ds liste copper
move.l a0,sretardlogo ; sauve pos dans liste copper du registre retard
addq.l #2,sretardlogo ; on se cale directement sur la valeur du registre
move.l #$01020000,(a0)+ ; delai DMA plan de bits
move.l #$01040000,(a0)+ ; priorite pdb/lutins
move.w #$0108,(a0)+ ;
move.w #(LL/8)-(WL/8),(a0)+ ; modulo plans impairs = 40
move.w #$010a,(a0)+ ;
move.w #(LL/8)-(WL/8),(a0)+ ; modulo plans pairs = 40
move.w #$0100,(a0)+ ; registre contrôle pdb
move.w #(NBPDBL*$1000)+$0200,(a0)+ ; ecran 1 plan de bits
; palette lutins
lea pall(pc),a1 ; liste palette source
move.w #$01a0,d0 ; 1er registre couleur
move.w #16-1,d7 ; nb de couleurs
.lc: ;
move.w d0,(a0)+ ; registre couleur
move.w (a1)+,(a0)+ ; couleur
addq.w #2,d0 ; incremente registre couleur
dbf d7,.lc ;
; pointeurs lutins
lea ptlut(pc),a1 ; liste des pointeurs donnees lutins
move.w #$0120,d0 ; registre pointeur
moveq #16-1,d7 ;
.lp: ;
move.l (a1)+,d1 ; pt lutin
beq.b .e ; sortie boucle si fin de liste
move.w d0,(a0)+ ; registre pointeur partie haute
swap d1 ; partie haute adresse lutin
move.w d1,(a0)+ ; partie haute adresse lutin
addq.w #2,d0 ;
move.w d0,(a0)+ ; registre pointeur partie basse
addq.w #2,d0 ;
swap d1 ; partie basse adresse lutin
move.w d1,(a0)+ ; partie basse adresse lutin
bra.b .lp ; tt prochain lutin
.e:
; degrade couleurs ds logo
move.l a0,sdeglogocop ; sauve pos. ds liste copper des
; couleurs du degrade logo
addq.l #6,sdeglogocop ; on se positionne directement sur la 1ere couleur
lea deglogo(pc),a1 ; table de couleurs du degrade
move.l #$2bdffffe,d0 ; 1er WAIT
move.w #HL-1,d7 ; nb-1 de lignes a traiter -> couleurs
; sur toute la hauteur du logo
.l1: ;
move.l d0,(a0)+ ; WAIT copper
move.w #$0182,(a0)+ ; registre couleur du logo a degrader
move.w (a1)+,(a0)+ ; couleur de la ligne
add.l #$01000000,d0 ; incremente ordonnee du WAIT
dbf d7,.l1 ; tt prochaine ligne
move.l #(($2b+HL)<<24)+($df<<16)+$fffe,(a0)+ ; wait fin logo et debut rasters = $6bdffffe
move.l #$01000200,(a0)+ ; desactive tous les plan de bits
; ecran principal = degrade et barres couleurs
move.l a0,sdegcop ; sauve pos. ds liste copper du degrade de couleurs
lea degrade(pc),a1 ;
move.l #$6ce3fffe,d0 ; partie droite ligne
move.l #$6c07fffe,d1 ; partie gauche ligne
move.w #HS-HL-1,d7 ; nb-1 de lignes a traiter
.l2: ;
move.l d1,(a0)+ ; wait pour bordure gauche
move.w #$0180,(a0)+ ; couleur de fond degradee
move.w (a1)+,(a0)+ ; couleur de la ligne
move.l d0,(a0)+ ; wait pour bordure droite
move.w #$0180,(a0)+ ;
move.w #COLB,(a0)+ ; couleur bordure (noire)
add.l #$01000000,d0 ;
add.l #$01000000,d1 ;
dbf d7,.l2 ; prochaine ligne
move.l #$fffffffe,(a0)+ ; fin liste copper
rts
; active un ecran noir vide
initcopvide:
lea copperv,a0 ; liste copper minimaliste
move.l #$01000200,(a0)+ ; aucun plans de bits
move.l #$01800000,(a0)+ ; fond noir
move.l #$fffffffe,(a0)+ ; fin liste copper
move.l #copperv,$dff080 ;
clr.w $dff088 ; active liste copper noire
rts
; injecte pts pdbs dans liste copper
; entree: d0= adr 1er pdb
; d1= taille en octets d'1 pdb
; a0= pos liste copper
; d7= nb-1 de pdb
; sortie:
; Regs : d0/d1/d2/d7/a0
setpdb:
move.w #$00e0,d2 ; premier registre pt pdb
.l: ;
move.w d2,(a0) ; registre pt pdb poids fort
move.w d0,6(a0) ; adresse pdb poids faible
swap d0 ;
addq.w #2,d2 ;
move.w d2,4(a0) ; registre pt pdb poids faible
move.w d0,2(a0) ; adresse pdb poids fort
swap d0 ;
add.l d1,d0 ;
addq.w #2,d2 ; prochain registre pt pdb
addq.l #8,a0 ; prochaine position dans liste copper
dbf d7,.l ; tt prochain plan
rts
; **************************************************
; * *
; * VARS/TABLES *
; * *
; **************************************************
principal: dc.l 0 ; pt vers sous routine principale
sdegcop: dc.l 0 ; pt vers degrade couleurs ds liste copper
degrade:
dc.w $000,$000,$000,$000,$000,$000,$001,$000 ; couleurs du degrade
dc.w $001,$001,$101,$001,$101,$101,$111,$101
dc.w $111,$111,$111,$111,$112,$111,$112,$112
dc.w $112,$112,$112,$112,$112,$112,$112,$112
dc.w $112,$112,$112,$112,$112,$112,$213,$212
dc.w $213,$213,$213,$213,$213,$213,$213,$213
dc.w $213,$213,$213,$213,$213,$213,$213,$213
dc.w $213,$213,$213,$213,$213,$213,$213,$213
dc.w $213,$213,$223,$213,$223,$223,$223,$223
dc.w $223,$223,$223,$223,$223,$223,$223,$223
dc.w $223,$223,$223,$223,$223,$223,$223,$223
dc.w $223,$223,$223,$223,$223,$223,$223,$223
dc.w $223,$223,$223,$223,$223,$223,$223,$223
dc.w $223,$223,$223,$223,$223,$223,$223,$223
dc.w $223,$223,$223,$223,$223,$223,$223,$223
dc.w $223,$223,$223,$223,$223,$223,$223,$223
dc.w $223,$223,$223,$223,$233,$233,$233,$233
dc.w $233,$233,$233,$233,$233,$233,$233,$233
dc.w $233,$233,$233,$233,$233,$233,$243,$233
dc.w $243,$243,$243,$243,$243,$243,$243,$243
dc.w $244,$244,$244,$244,$244,$244,$244,$244
dc.w $244,$244,$244,$244,$244,$244,$244,$244
dc.w $244,$244,$244,$244,$244,$244,$254,$244
dc.w $254,$254,$254,$254,$254,$254,$254,$254
dc.w $254,$254,$253,$254,$253,$253,$253,$253
dc.w $353,$353,$353,$353,$353,$353,$353,$353
dc.w $353,$353,$452,$353,$452,$452,$452,$452
dc.w $452,$452,$452,$452,$452,$452,$452,$452
dc.w $552,$552,$552,$552,$552,$552,$551,$552
dc.w $561,$561,$561,$561,$561,$561,$561,$561
dc.w $561,$561,$561,$561,$661,$561,$661,$661
dc.w $661,$661,$661,$661,$661,$661,$661,$661
itbsin: blk.w NBB,0 ; indexes table mvt barres rasters
tbsin: dc.b 128,126,124,123,121,120,118,117,115,113,112 ; table des ordonnees barres rasters
dc.b 110,109,107,106,104,103,101,100,99,97,96,94
dc.b 93,92,91,89,88,87,86,84,83,82,81,80,79,78
dc.b 77,76,75,74,73,72,72,71,70,70,69,68,68,67
dc.b 67,66,66,65,65,65,64,64,64,64,64,64,64,64
dc.b 64,64,64,64,64,64,65,65,65,66,66,66,67,67
dc.b 68,69,69,70,71,71,72,73,74,75,75,76,77,78
dc.b 79,80,82,83,84,85,86,87,89,90,91,92,94,95
dc.b 97,98,99,101,102,104,105,107,108,110,111
dc.b 113,114,116,117,119,120,122,124,125,127
dc.b 128,130,131,133,135,136,138,139,141,142
dc.b 144,145,147,148,150,151,153,154,156,157
dc.b 158,160,161,163,164,165,166,168,169,170
dc.b 171,172,173,175,176,177,178,179,180,180
dc.b 181,182,183,184,184,185,186,186,187,188
dc.b 188,189,189,189,190,190,190,191,191,191
dc.b 191,191,191,191,191,191,191,191,191,191
dc.b 191,190,190,190,189,189,188,188,187,187
dc.b 186,185,185,184,183,183,182,181,180,179
dc.b 178,177,176,175,174,173,172,171,169,168
dc.b 167,166,164,163,162,161,159,158,156,155
dc.b 154,152,151,149,148,146,145,143,142,140
dc.b 138,137,135,134,132,131,129,128
barre: dc.w $0518,$0627,$0746,$0865 ; couleurs barre raster de 16 lignes de haut
dc.w $0A84,$0B93,$0CB2,$0DD1
dc.w $0DD1,$0CB2,$0B93,$0A84
dc.w $0865,$0746,$0627,$0518
itbmvtlogo: dc.w 0 ; index table mvt logo
tbmvtlogo:
dc.w 0,-3,-7,-11,-15,-19,-23,-27,-31,-35,-39,-42,-46 ; table des abscisses du mvt logo
dc.w -50,-54,-57,-61,-65,-68,-72,-75,-79,-82,-85,-89
dc.w -92,-95,-98,-101,-104,-107,-110,-113,-116,-118
dc.w -121,-124,-126,-128,-131,-133,-135,-137,-139
dc.w -141,-143,-144,-146,-148,-149,-150,-152,-153
dc.w -154,-155,-156,-157,-157,-158,-158,-159,-159
dc.w -159,-159,-159,-159,-159,-159,-159,-158,-158
dc.w -157,-156,-155,-154,-153,-152,-151,-150,-148
dc.w -147,-145,-144,-142,-140,-138,-136,-134,-132
dc.w -130,-127,-125,-122,-120,-117,-114,-112,-109
dc.w -106,-103,-100,-97,-94,-90,-87,-84,-80,-77,-73
dc.w -70,-66,-63,-59,-55,-52,-48,-44,-40,-37,-33
dc.w -29,-25,-21,-17,-13,-9,-5,-1,1,5,9,13,17,21
dc.w 25,29,33,37,40,44,48,52,55,59,63,66,70,73,77
dc.w 80,84,87,90,94,97,100,103,106,109,112,114,117
dc.w 120,122,125,127,130,132,134,136,138,140,142,144
dc.w 145,147,148,150,151,152,153,154,155,156,157
dc.w 158,158,159,159,159,159,159,159,159,159,159
dc.w 159,158,158,157,157,156,155,154,153,152,150
dc.w 149,148,146,144,143,141,139,137,135,133,131
dc.w 128,126,124,121,118,116,113,110,107,104,101
dc.w 98,95,92,89,85,82,79,75,72,68,65,61,57,54,50
dc.w 46,42,39,35,31,27,23,19,15,11,7,3
sretardlogo: dc.l 0 ; pt vers registre retard logo ds liste copper
sptlogo: dc.l 0 ; pt vers registres pt pdb logo ds liste copper
pallogo: dc.w $0000,$0ffe ; palette logo
sdeglogocop: dc.l 0 ; sauve pt vers degrade couleurs logo ds liste copper
deglogo:
dc.w $FFF,$FFF,$FFF,$EFF,$EFF,$EFF,$EFF,$DFF ; liste couleurs du degrade de couleurs logo
dc.w $DFF,$DEF,$CEF,$CEF,$CEF,$CEF,$BEF,$BEF
dc.w $BEF,$AEF,$AEF,$ADF,$ADF,$9DF,$9DF,$9DF
dc.w $8DF,$8DF,$8DF,$8DF,$7CF,$7CF,$7CF,$6CF
dc.w $6CF,$6CF,$6CF,$5CF,$5CF,$5CF,$5CF,$5CE
dc.w $5CE,$5CD,$6CD,$6CD,$6CC,$6CC,$6CB,$7CB
dc.w $7CA,$7BA,$7BA,$7B9,$8B9,$8B8,$8B8,$8B7
dc.w $8B7,$9B7,$9B6,$9B6,$9B5,$9A5,$AA4,$AA4
dc.w $AA4,$AA3,$BA3,$BA2,$BA2,$BA1,$CA1,$CA1
dc.w $CA0,$CA0,$CA0,$CA0,$CA1,$CA1,$CA1,$CA2
dc.w $DA2,$DA2,$DA3,$DA3,$DA3,$DA4,$DA4,$E94
dc.w $E95,$E95,$E95,$E96,$E96,$E97,$F97,$F98
dc.w $F98,$F99,$F99,$F9A,$F9A,$F9A,$F9A,$F9A
dc.w $F9A,$FAB,$FAB,$FAB,$FAB,$FBB,$FBC,$FBC
dc.w $FBC,$FCC,$FCD,$FCD,$FCD,$FDD,$FDD,$FDE
dc.w $FDE,$FEE,$FEE,$FEF,$FEF,$FFF,$FFF,$FFF
fdeglogo:
ideglogo: dc.w 0 ; index table degrade couleurs logo
sintena: dc.w 0 ; sauve intena
sdmacon: dc.w 0 ; sauve dmacon
nom_glib: dc.b"graphics.library",0 ; nom de la librairie
even
; donnees lutins
pall: dc.w $0000,$0115,$0225,$0236,$0246,$0256,$0167
dc.w $0177,$0198, $01A8,$00B8,$00C9,$00D9,$00EA
dc.w $00FA,$0000
; liste pointeurs vers lutins
ptlut: dc.l lut0,lut1,lut2,lut3,lut4,lut5,lut6,lut7 ;
dc.l 0 ; marqueur fin de liste
; ordonnees des 3 listes de lutins
coorlut0: dc.b $2c+04,$2c+16,$2c+32,$2c+48 ; 4x ordonnees lutins taille 32x8
dc.b 0 ; marqueur de fin de liste
coorlut1: dc.b $2c+00,$2c+08,$2c+16,$2c+24,$2c+38,$2c+48,$2c+58 ; 7x ordonnees lutins taille 16x6
dc.b 0 ; marqueur de fin de liste
coorlut2: dc.b $2c+02,$2c+08,$2c+16,$2c+22,$2c+30,$2c+37,$2c+44 ; 11x ordonnees lutins taille 16x4
dc.b $2c+51,$2c+58,$2c+64,$2c+70 ;
dc.b 0 ; marqueur de fin de liste
even
; **************************************************
; * *
; * SOUS-ROUTINES BOUCLE PRINCIPALE *
; * *
; **************************************************
; tt double tampon
; entree:
; sortie:
; regs :
;dtampon:
; eor.b #$ff,flgdf ; permutte indicateur double tampon
; beq.b .page2 ;
; bra.b .nxt1 ;
;.page2:
; bra.b .nxt1
;nxt1:
; rts
; initialisations rasters
; entree:
; sortie:
; regs : d0/d7/a0
initpart6:
bsr initcopvide ; ecran noir et vide
; init les index des barres rasters
lea itbsin(pc),a0 ;
moveq #0,d0 ;
move.w #NBB-1,d7 ;
.ib: ;
and.w #$00ff,d0 ; empeche debordement index
move.w d0,(a0)+ ;
add.w #6,d0 ; dephase le prochain index de 6
dbf d7,.ib ; tt prochain index
bsr initcop ; construction nouvelle liste copper
move.l #copper0,$dff080 ; nouvelle liste copper active a la prochaine trame
clr.w itbsin ; raz index table sinus
addq.l #6,sdegcop ; pointe directement sur couleur ds
; liste degrade copper
move.l #part6,principal ; a la prochaine trame, le tt se fera
; dans l'effet demo en-soi
rts
part6:
; bsr dtampon ; tt double tampon
bsr mvtetoiles ; deplace lutins du champ etoiles
bsr rasters ; effet de couleurs barres et fond colore
bsr cologo ; effet couleurs dans logo
bsr mvtlogo ; oscillation horizontale logo
rts
; couleurs mouvantes dans logo
; entree:
; sortie:
; regs : d0/d1/d7/a0/a1
cologo:
lea deglogo(pc),a0 ; table des couleurs
move.w ideglogo(pc),d0 ; index
addq.w #2,d0 ; deplace couleurs
and.w #$00ff,d0 ; empeche debordement index
move.w d0,ideglogo-deglogo(a0) ; sauve nouvel index
move.l sdeglogocop(pc),a1 ; 1ere couleur du degrade ds liste copper
move.w #HL-1,d7 ; nb-1 de couleurs a traiter
.l: ;
and.w #$00ff,d0 ; empeche debordement index
move.w (a0,d0.w),(a1) ; injecte nouvelle couleur ds liste copper
addq.w #8,a1 ; on se positionne sur prochaine ligne copper
addq.w #2,d0 ; deplace pos. 1ere couleur
and.w #$00ff,d0 ; empeche debordement index
dbf d7,.l ; tt prochaine ligne
rts
; mvt oscillatoire logo
; entree:
; sortie:
; regs : d0/d1/d2/d7/a0
mvtlogo:
lea tbmvtlogo(pc),a0 ; table mvt logo
moveq #0,d0 ;
move.w itbmvtlogo(pc),d0 ; index table
move.w d0,d1 ;
addq #2,d1 ; mouvement grace a incrementation index
and.w #$00ff,d1 ; empeche debordement index
move.w d1,itbmvtlogo-tbmvtlogo(a0) ; reinjecte nouvel index
add.w d0,d0 ; table en .W
move.w (a0,d0.w),d0 ; abscisse
add.w #WL/2,d0 ; recentrage abscisse logo
move.w d0,d1 ;
lsr.w #4,d0 ; nbre de mots
add.w d0,d0 ; adresse partielle paire, en octets
add.l #logo,d0 ; adresse finale plan du logo
and.w #$000f,d1 ; uniquement 4 bits poids faible abscisse logo
move.w #15,d2 ;
sub.w d1,d2 ;
move.w d2,d1 ; retard plans pairs
lsl.w #4,d2 ; calcul retard plans impairs
or.w d2,d1 ; retard plans pairs et impairs
move.l sretardlogo(pc),a0 ; pos. du registre retard ds liste copper
move.w d1,(a0) ; injecte nouvelle valeur retard ds liste copper
move.l sptlogo(pc),a0 ; pos. ds liste copper
move.l #LL/8*HL,d1 ; taille en octets d'1 pdb
move.w #NBPDBL-1,d7 ; nb-1 de pdb a traiter
bsr setpdb ; injecte pt pdb ds liste copper
rts
; tt effets de couleurs au copper
; entree:
; sortie:
; regs : d0/d6/d7/a0/a1/a2/a3/a4
rasters:
; tt effacement barres rasters
lea degrade(pc),a0 ; couleurs du degrade de fond
move.l sdegcop(pc),a2 ; pt vers liste copper
move.w #HS-HL-1,d7 ; 256 lignes a traiter
.clr: ;
move.w (a0)+,(a2) ; injecte couleur ds liste copper
lea 16(a2),a2 ; prochaine ligne copper
dbf d7,.clr ; tt prochaine ligne
; tt affichage barres rasters
lea itbsin(pc),a0 ; liste d'index des 16 barres rasters
lea tbsin(pc),a1 ;
move.l sdegcop(pc),a2 ; pointe vers liste copper
move.w #NBB-1,d7 ; nb-1 barres rasters
.2:
move.w (a0),d0 ; index table sinus
addq.w #1,(a0)+ ; incremente index
and.w #$00ff,d0 ; evite debordement
move.b (a1,d0.w),d0 ; ordonnee ecran de la barre raster
sub.w #HL-1,d0 ; recentrage
lsl.w #4,d0 ; adresse offset ds liste copper
move.l a2,a3 ; base adr. debut degrade dans liste copper
add.w d0,a3 ; a3=adr. cible ds liste copper où y dessiner barre
lea barre(pc),a4 ; pointe sur couleurs de la barre raster
move.w #HBR-1,d6 ; hauteur-1 d'une barre raster
.1: ;
move.w (a4)+,(a3) ; injecte couleur ligne barre raster ds liste copper
lea 16(a3),a3 ;
dbf d6,.1 ; tt prochaine ligne de la barre
dbf d7,.2 ; tt prochaine barre
rts ;
; deplace lutins en parallax
; entree:
; sortie:
; regs : d0/d7/a1/a2/a3/a4
mvtetoiles:
; deplacement etoiles -grandes-
lea lut0+1,a1 ; liste lutins pairs -grande taille
lea lut1+1,a2 ; liste lutins impairs -grande taille
lea lut2+1,a3 ; liste 2eme partie lutins pairs -grande taille
lea lut3+1,a4 ; liste 2eme partie lutins impairs -grande taille
moveq #4-1,d7 ; nb-1 lutins
.0: ;
move.b (a1),d0 ;
addq.b #VGL,d0 ; deplacement de 6 pixels a droite
move.b d0,(a1) ; injecte nouvelle abscisse
move.b d0,(a2) ; idem pour lutin impair
addq.b #8,d0 ; abscisse 2eme partie lutins
move.b d0,(a3) ; injecte nouvelle abscisse
move.b d0,(a4) ; idem pour lutin impair
lea flut0-lut0(a1),a1 ; passe au prochain lutin de la liste
lea flut0-lut0(a2),a2 ; idem pour lutin impair
lea flut0-lut0(a3),a3 ; passe au prochain lutin de la liste
lea flut0-lut0(a4),a4 ; idem pour 2eme partie lutins
dbf d7,.0 ;
; deplacement etoiles -moyennes-
lea lut4+1,a1 ; liste lutins pairs -grande taille
lea lut5+1,a2 ; liste lutins impairs -grande taille
moveq #7-1,d7 ; nb-1 lutins
.1: ;
move.b (a1),d0 ;
addq.b #VML,d0 ; deplacement de 4 pixels a droite
move.b d0,(a1) ; injecte nouvelle abscisse
move.b d0,(a2) ; idem pour lutin impair
lea flut4-lut4(a1),a1 ; passe au prochain lutin de la liste
lea flut5-lut5(a2),a2 ; idem pour lutin impair
dbf d7,.1 ;
; deplacement etoiles -petites-
lea lut6+1,a1 ; liste lutins pairs -grande taille
lea lut7+1,a2 ; liste lutins impairs -grande taille
moveq #11-1,d7 ; nb-1 lutins
.2: ;
move.b (a1),d0 ;
addq.b #VPL,d0 ; deplacement de 2 pixels a droite
move.b d0,(a1) ; injecte nouvelle abscisse
move.b d0,(a2) ; idem pour lutin impair
lea flut6-lut6(a1),a1 ; passe au prochain lutin de la liste
lea flut7-lut7(a2),a2 ; idem pour lutin impair
dbf d7,.2 ;
rts
; ***********************************************
; * *
; * CHIP RAM *
; * *
; ***********************************************
section donneesgraph,data_c
;logo: blk.b 80*64,0
; premier plan du logo qui est deja precharge par le graphisme du logo
logo:
dc.l $00000000,$00000000,$0007FE00,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$001FFF80,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$003FFFE0,$00001FF8,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$003F8000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$007FFFF8,$0000FFF0
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$03FFF800,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00FFFFFC,$0003FFF0,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$0FFFFE00,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00FFFFFE,$000FFFF0
dc.l $00000000,$00007F00,$00000000,$00000000,$00000000,$3FFFFF80,$007F8000,$0000FE00
dc.l $0FE00000,$00000000,$00000000,$00000000,$00000000,$00000000,$000FF000,$00000000
dc.l $00000000,$00000000,$01FFFFFF,$001FFFE0,$00000000,$0000FFC0,$00000000,$00000000
dc.l $00000000,$FFFFFFC0,$007FC000,$0000FF80,$1FF00000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$000FFC00,$00000000,$00000000,$00000000,$01FFFFFF,$807FFFE0
dc.l $00000000,$0001FFE0,$00000000,$00000000,$00000001,$FFFFFFE0,$007FF000,$0000FFC0
dc.l $3FF80000,$00000000,$00000000,$00000000,$00000000,$00000000,$0007FE00,$00000000
dc.l $00000000,$00000000,$03FFFFFF,$C0FFFFC0,$00000000,$0001FFE0,$00000000,$00000000
dc.l $00000003,$FFFFFFF0,$003FF000,$0000FFE0,$7FFC0000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$0007FE00,$00000000,$00000000,$00000000,$03FFFFFF,$E3FFFFC0
dc.l $00000000,$0003FFE0,$00000000,$00000000,$00000007,$FF80FFF8,$003FF800,$0000FFF0
dc.l $7FFC0000,$00000000,$00000000,$00000000,$00000000,$00000000,$0007FF00,$00000000
dc.l $00000000,$00000000,$03FFFFFF,$F7FFFFC0,$00000000,$0003FFE0,$00000000,$00000000
dc.l $0000000F,$FE003FFC,$007FF800,$0000FFF0,$7FFC0000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$0007FF00,$00000000,$00000000,$00000000,$01FFFF0F,$FFFF7F80
dc.l $00000000,$0001FFE0,$00000000,$00000000,$0000001F,$F8001FFC,$007FF800,$0000FFF0
dc.l $7FFC0000,$00000000,$00000000,$00000000,$00000000,$00000000,$000FFF00,$00000000
dc.l $00000000,$00000000,$01FFFF07,$FFFE7F80,$00000000,$0000FFC0,$00000000,$00000000
dc.l $0000003F,$F0000FFE,$00FFF800,$0001FFF0,$3FF80000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$000FFF00,$00000000,$00000000,$00000000,$00FFFF03,$FFF8FF80
dc.l $00000000,$00007F80,$00000000,$00000000,$0000007F,$E00007FE,$00FFF000,$0001FFE0
dc.l $1FF00000,$00000000,$00000000,$00000000,$00000000,$00000000,$001FFE00,$00000000
dc.l $00000000,$00000000,$00FFFF00,$FFF0FF00,$00000000,$00001E00,$00000000,$00000000
dc.l $000000FF,$C00003FF,$00FFF000,$0003FFE0,$07C00000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$001FFE00,$00000000,$00000000,$00000000,$007FFF81,$FFE1FF00
dc.l $00000000,$00000000,$00000000,$00000000,$000000FF,$800003FF,$01FFF000,$0003FFC0
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$003FFE00,$00000000
dc.l $00000000,$00000000,$003FFFC3,$FFE1FF00,$00000000,$00000000,$00000000,$00000000
dc.l $000001FF,$000003FF,$01FFE000,$0003FFC0,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$003FFC00,$00000000,$00000000,$00000000,$000FFFE7,$FFC3FE3F
dc.l $C0000000,$0001FE00,$00000000,$00000000,$000001FF,$03FF81FF,$83FFE3FE,$0007FFC0
dc.l $7F800000,$00000000,$FF007F80,$00000000,$0000FF00,$3F000000,$003FFC00,$00000000
dc.l $00000000,$00000000,$0003FF8F,$FFC3FE3F,$F01FF00F,$F007FF00,$00007F00,$000007F0
dc.l $000003FE,$0FFFE1FF,$83FFEFFF,$8007FF80,$FFC00000,$1FE0000F,$FFE03FE0,$1FF00FE0
dc.l $000FFFE0,$7FE007FC,$007FFC00,$00000000,$00000000,$00000000,$00007E1F,$FFC7FE1F
dc.l $F87FF87F,$FC07FF00,$01FFFFC0,$007FC7F8,$000003FE,$3FFFF1FF,$87FFFFFF,$E00FFF80
dc.l $FFE0007F,$FFF8003F,$FFF03FF0,$7FF87FFC,$003FFFF0,$3FF03FFF,$07FFFF80,$00000000
dc.l $00000000,$00000000,$0000003F,$FFE7FE1F,$F8FFFCFF,$FE07FF00,$07FFFFE0,$01FFE7FC
dc.l $000003FC,$7FFFF9FF,$87FFFFFF,$F00FFF00,$FFE001FF,$FFFC00FF,$FFF83FF9,$FFF9FFFE
dc.l $00FFFFF8,$3FF8FFFF,$9FFFFFC0,$00000000,$00000000,$00000000,$3800007F,$FFFFFC1F
dc.l $FDFFFFFF,$FF07FF00,$1FFFFFF0,$07FFFFFE,$000007FC,$FFFFF9FF,$8FFFFFFF,$F01FFF00
dc.l $FFE007FF,$FFFC01FF,$F3F83FFF,$FFFFFFFE,$01FFF3F8,$3FF9FFFF,$DFFFFFC0,$00000000
dc.l $00000000,$00000000,$F80000FF,$FFFFFC1F,$FFFFFFFF,$FF07FF00,$7FFFFFF0,$0FFFFFFE
dc.l $000007FD,$FFFFF9FF,$8FFFF03F,$F81FFF01,$FFE00FFF,$FFFE03FF,$E1FC3FFF,$FFFFFFFF
dc.l $03FFE1FC,$3FFFFFFF,$FFFFFFC0,$00000000,$00000000,$00000003,$F80001FF,$FFFFF83F
dc.l $FFCFFFFF,$FF07FF00,$FFFFFFF0,$1FFFFFFE,$000007FF,$FFFFF9FF,$9FFFC03F,$F81FFE01
dc.l $FFE01FFF,$FFFE07FF,$C1FC3FFF,$8FFFFFFF,$07FFC1FC,$3FFFFFFF,$FBFFE780,$00000000
dc.l $00000000,$00000007,$F80003FF,$FCFFF83F,$FF07FF8F,$FF0FFF01,$FFF3FFF0,$3FFE7FFE
dc.l $000007FF,$FFFFF9FF,$9FFF801F,$F83FFE01,$FFC03FFC,$FFFE0FFF,$C1FC3FFF,$07FF8FFF
dc.l $0FFFC1FC,$3FFFC3FF,$C1FFE000,$00000000,$00000000,$0000000F,$F80007FF,$F87FF83F
dc.l $FE07FF07,$FF0FFE03,$FFC1FFF0,$7FF83FFE,$000003FF,$FFFFFBFF,$9FFF003F,$FC3FFE03
dc.l $FFC07FF8,$3FFE1FFF,$81FC7FFE,$07FE0FFF,$1FFF81FC,$3FFF81FF,$C3FFE000,$00000000
dc.l $00000000,$0000001F,$F8000FFF,$F87FF87F,$FE07FE0F,$FF1FFE03,$FFC0FFF0,$FFF01FFE
dc.l $000003FF,$F0FFF3FF,$BFFE003F,$FC7FFC03,$FFC0FFF0,$1FFE1FFF,$83FC7FFC,$07FE0FFE
dc.l $1FFF83FC,$7FFF03FF,$C3FFC000,$00000000,$00000000,$0000003F,$F8003FFF,$F03FF87F
dc.l $FC07FE0F,$FF1FFE07,$FF80FFF0,$FFF03FFC,$000001FF,$E0FFF3FF,$BFFE003F,$FC7FFC07
dc.l $FF81FFF0,$1FFE3FFF,$87FC7FFC,$0FFC1FFE,$3FFF87FC,$7FFE07FF,$C7FFC000,$00000000
dc.l $00000000,$0000003F,$FC007FFF,$F07FF07F,$FC0FFC1F,$FE1FFC0F,$FF80FFF1,$FFF03FFC
dc.l $0000007F,$C0FFE7FF,$3FFE007F,$FC7FFC07,$FF81FFE0,$1FFE3FFF,$8FF8FFF8,$1FFC1FFE
dc.l $3FFF8FF8,$FFFC07FF,$87FFC000,$00000000,$00000000,$0000007F,$FE01FFFF,$E07FF07F
dc.l $F81FFC1F,$FE3FFC0F,$FF00FFF1,$FFF07FF8,$0000001F,$C3FFC7FF,$3FFE00FF,$F8FFFC07
dc.l $FF03FFE0,$3FFC7FFF,$FFF8FFF8,$1FF83FFC,$7FFFFFF8,$FFFC0FFF,$87FFC000,$00000000
dc.l $00000000,$0000007F,$FF8FFFFF,$E0FFF0FF,$F83FF83F,$FE3FF81F,$FF01FFF3,$FFF07FF8
dc.l $1C00001F,$E3FF0FFF,$3FFE00FF,$F8FFF80F,$FF03FFE0,$3FFC7FFF,$FFF0FFF8,$3FF87FFC
dc.l $7FFFFFF0,$FFF81FFF,$8FFFC03C,$00000000,$00000000,$0000007F,$FFFFFFFF,$C0FFF0FF
dc.l $F83FF87F,$FC7FF81F,$FF83FFF3,$FFF07FF0,$3E00001F,$E1FC1FFF,$3FFE03FF,$F8FFF80F
dc.l $FF07FFE0,$7FFCFFFF,$FFF1FFF0,$7FF07FFC,$FFFFFFF1,$FFF01FFF,$0FFFC07C,$00000000
dc.l $00000000,$0000007F,$FFFFFFFF,$C0FFF1FF,$F07FF07F,$FC7FF81F,$FFC7FFE3,$FFF8FFF0
dc.l $3E00003F,$F0003FFE,$3FFF07FF,$F8FFF81F,$FE07FFF1,$FFFCFFFF,$FFE1FFF0,$7FF0FFF8
dc.l $FFFFFFE1,$FFF03FFF,$0FFFC0FC,$00000000,$00000000,$0000007F,$FFFFFFFF,$80FFF1FF
dc.l $F07FF0FF,$F87FF83F,$FFFFFFE3,$FFFFFFF0,$7C00003F,$F000FFFE,$3FFFFFFF,$F1FFFC1F
dc.l $FE07FFFF,$FFFCFFFF,$FFC3FFF0,$FFF0FFF8,$FFFFFFC3,$FFF03FFE,$0FFFC0FC,$00000000
dc.l $00000000,$0000007F,$FFFFFFFF,$01FFE3FF,$F0FFF0FF,$F8FFF87F,$FFFFFFE3,$FFFFFFF0
dc.l $7C00003F,$FC03FFFC,$3FFFFFFF,$F1FFFC1F,$FE0FFFFF,$FFF8FFFF,$FF87FFE0,$FFE1FFF8
dc.l $FFFFFF87,$FFE03FFE,$0FFFC1F8,$00000000,$00000000,$0000007F,$FFFFFFFE,$01FFE3FF
dc.l $F0FFE1FF,$F8FFF87F,$FFFFFFE3,$FFFFFFF0,$F800003F,$FFFFFFFC,$1FFFFFFF,$F1FFFF7F
dc.l $FE1FFFFF,$FFF8FFFE,$7F07FFE1,$FFE1FFF0,$FFFE7F07,$FFE07FFE,$0FFFE7F0,$00000000
dc.l $00000000,$0000007F,$FFFFFFFE,$01FFE3FF,$E1FFE1FF,$F8FFFDFF,$FFFFFFC3,$FFFFFFFD
dc.l $F000003F,$FFFFFFF8,$1FFFFFFF,$E1FFFFFF,$FFBFFFFF,$FFF87FFE,$001FFFE1,$FFE1FFF0
dc.l $7FFE001F,$FFE07FFE,$1FFFFFF0,$00000000,$00000000,$0000003F,$FFFFFFFC,$01FFF7FF
dc.l $E1FFE1FF,$F8FFFFFF,$FFFFFFC3,$FFFFFFFF,$F000003F,$FFFFFFF8,$1FFFFFFF,$C1FFFFFF
dc.l $FFFFFFFF,$FFF87FFF,$003FFFE3,$FFC1FFF0,$7FFF003F,$FFC07FFE,$0FFFFFE0,$00000000
dc.l $00000000,$0000003F,$FFFFFFF8,$03FFF7FF,$E3FFE1FF,$F8FFFFFF,$FFFFFFC1,$FFFFFFFF
dc.l $E000001F,$FFFFFFF0,$0FFFFFFF,$C1FFFFFF,$FFFFFFFF,$FFF03FFF,$81FFFFC3,$FFC1FFF0
dc.l $3FFF81FF,$FFC07FFE,$0FFFFFC0,$00000000,$00000000,$0000001F,$FFFFFFF8,$03FFFFFF
dc.l $E3FFC1FF,$FCFFFFEF,$FFFFFFC1,$FFFFFFFF,$C000001F,$FFFFFFE0,$07FFFFFF,$80FFFFFF
dc.l $FFFFFFFF,$FFF03FFF,$FFFFFFC3,$FFC1FFF8,$3FFFFFFF,$FFC07FFF,$0FFFFF80,$00000000
dc.l $00000000,$0000000F,$FFFFFFF0,$03FFFFFF,$E3FFC0FF,$FFFFFFC7,$FFFFFF80,$FFFFFFFF
dc.l $8000001F,$FFFFFFC0,$03FFFFFF,$00FFFFFF,$FFF9FFFF,$FFF01FFF,$FFFFFFC7,$FFC1FFFF
dc.l $1FFFFFFF,$FFC03FFF,$EFFFFF00,$00000000,$00000000,$0000000F,$FFFFFFE0,$03FFFFFF
dc.l $C3FFC0FF,$FFFFFF83,$FFFFFF80,$7FFE7FFF,$0000000F,$FFFFFF80,$01FFFFFC,$00FFFFEF
dc.l $FFF0FFFF,$FFF00FFF,$FFFFFFC7,$FFC0FFFF,$0FFFFFFF,$FFC03FFF,$E7FFFE00,$00000000
dc.l $00000000,$00000007,$FFFFFFC0,$01FFFFFF,$C3FFC07F,$FF3FFF01,$FFEFFF80,$3FFC3FFE
dc.l $00000007,$FFFFFF00,$007FFFF8,$007FFF87,$FFC03FFB,$FFE007FF,$FFE7FFC7,$FFC0FFFF
dc.l $07FFFFE7,$FFC01FFF,$C7FFFC00,$00000000,$00000000,$00000003,$FFFFFF00,$01FFFFFF
dc.l $C3FFC03F,$FE0FFC00,$3F0FFF00,$1FF01FF8,$00000007,$FFFFFC00,$001FFFC0,$001FFE03
dc.l $FF800FE3,$FFE001FF,$FF01FFC3,$FFC03FFE,$01FFFF01,$FFC00FFF,$81FFF000,$00000000
dc.l $00000000,$00000000,$FFFFFE00,$01FFFF3F,$C1FFC00F,$F803E000,$001FFF00,$07C007E0
dc.l $00000003,$FFFFF800,$0001FE00,$0007F000,$FC000003,$FFC0001F,$F0007FC3,$FF800FF8
dc.l $001FF000,$7FC003FE,$007F8000,$00000000,$00000000,$00000000,$3FFFF800,$00FFFE00
dc.l $00FF0000,$00000000,$001FFF00,$00000000,$00000000,$FFFFC000,$00000000,$00000000
dc.l $00000007,$FFC00000,$00000000,$FE000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$0FFFC000,$007FF800,$00000000,$00000000,$003FFE00,$00000000
dc.l $00000000,$3FFE0000,$00000000,$00000000,$00000007,$FFC00000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$000F8000
dc.l $00000000,$00000003,$007FFE00,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $0000E00F,$FF800000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000007,$C0FFFC00,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$0000F81F,$FF800000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000007,$FFFFFC00,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $0001FFFF,$FF000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000007,$FFFFF800,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$0001FFFF,$FF000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$0000000F,$FFFFF800,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $0001FFFF,$FE000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$0000000F,$FFFFF000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$0001FFFF,$FE000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000007,$FFFFE000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $0001FFFF,$FC000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000007,$FFFFE000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$0001FFFF,$F8000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000007,$FFFFC000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $0000FFFF,$F0000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000003,$FFFF8000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$0000FFFF,$F0000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000001,$FFFF0000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00007FFF,$C0000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$FFFE0000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00003FFF,$80000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$7FF80000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000FFF,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$0FE00000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$000003FC,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
dc.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
; liste lutins 32x8 pairs
lut0: dc.w $0000,$0000
dc.w $2666,$1E1E,$6666,$1E1E,$E666,$1E1E,$E666,$1E1E
dc.w $E666,$1E1E,$E666,$1E1E,$6666,$1E1E,$2666,$1E1E
flut0:
blk.b NBLG*(flut0-lut0),0
dc.w $0000,$0000 ; fin de liste
; liste lutins 32x8 impairs x4
lut1: dc.w $0000,$0080
dc.w $01FE,$0001,$01FE,$0001,$01FE,$0001,$01FE,$0001
dc.w $01FE,$0001,$01FE,$0001,$01FE,$0001,$01FE,$0001
flut1:
blk.b NBLG*(flut1-lut1),0
dc.w $0000,$0000 ; fin de liste
; liste lutins 32x8 pairs
lut2: dc.w $0000,$0000
dc.w $1998,$0784,$1998,$0786,$1998,$0787,$1998,$0787
dc.w $1998,$0787,$1998,$0787,$1998,$0786,$1998,$0784
flut2:
blk.b NBLG*(flut2-lut2),0 ; 3 autres lutins
dc.w $0000,$0000 ; fin de liste
; liste lutins 32x8 impairs x4
lut3: dc.w $0000,$0080
dc.w $007C,$FFFC,$007E,$FFFE,$007F,$FFFF,$007F,$FFFF
dc.w $007F,$FFFF,$007F,$FFFF,$007E,$FFFE,$007C,$FFFC
flut3:
blk.b NBLG*(flut3-lut3),0 ; 3 autres lutins
dc.w $0000,$0000 ; fin de liste
; liste lutins 16x6 pairs x7
lut4: dc.w $0000,$0000
dc.w $2670,$1E0C,$E673,$1E0F,$E673,$1E0F,$E673,$1E0F
dc.w $E673,$1E0F,$2670,$1E0C
flut4:
blk.b NBLM*(flut4-lut4),0 ; 6 autres lutins
dc.w $0000,$0000 ; fin de liste
; liste lutins 16x6 impairs x7
lut5: dc.w $0000,$0080
dc.w $01FC,$0000,$01FF,$0000,$01FF,$0000,$01FF,$0000
dc.w $01FF,$0000,$01FC,$0000
flut5:
blk.b NBLM*(flut5-lut5),0 ; 6 autres lutins
dc.w $0000,$0000 ; fin de liste
; liste lutins 16x4 pairs x11
lut6: dc.w $0000,$0000
dc.w $6300,$1F00,$E300,$1F00,$E300,$1F00,$6300,$1F00
flut6:
blk.b NBLP*(flut6-lut6),0 ; 11 autres lutins
dc.w $0000,$0000 ; fin de liste
; liste lutins 16x4 impairs x11
lut7: dc.w $0000,$0080
dc.w $0080,$0000,$00C0,$0000,$00C0,$0000,$0080,$0000
flut7:
blk.b NBLP*(flut7-lut7),0 ; 11 autres lutins
dc.w $0000,$0000 ; fin de liste
; liste copper principale
even
copper0: blk.b 8192,0 ; a modifier par un allocmem()
fcopper0:
even
copperv: blk.b 24,0 ; liste copper vide (ecran noir)
end
|
|
