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 : Assembleur - Défilement Kick Off
(Article écrit par Jérôme Étienne et extrait d'Amiga News Tech - novembre 1991)
|
|
Le mois dernier, je vous avais promis le défilement
le plus rapide possible. Voici qui est prometteur, mais beaucoup d'entre vous se sont peut-être
dit que ce n'était là qu'un moyen malhonnête d'attirer l'attention du lecteur...
Je viens de me rendre compte qu'il est possible que certains croient que je parle de la technique très
répandue dans le domaine des démos, qui consiste à créer un gros plan de bits et à faire bouger l'écran
dessus... Cette pratique est non seulement très simple à programmer, mais aussi très rapide en temps
d'exécution (en fait, plus rapide que la technique dite Kick Off), mais les contraintes mémoire
qu'elle entraîne la rendent inutilisable dans un jeu digne de ce nom.
Le gros avantage du défilement que je vais vous décrire, provient du fait qu'il permet de ne
gérer que les nouveaux blocs de 16x16 pixels et donc, si l'on n'affiche que le strict nécessaire,
on ne peut pas faire moins (à l'exception de ne rien faire, et pour cela je ne connais que la
technique du gros plan de bits).
Après cette introduction, je vais vous expliquer plus précisément comment programmer un tel
défilement et quelles sont ses limites.
Le principe
Tout d'abord, le défilement horizontal. L'écran doit être défini à la taille voulue, en ajoutant un
modulo de deux octets permettant d'utiliser le défilement matériel (registre BPLCON1). Pour procéder
au défilement, on calcule la direction en comparant la position actuelle (variables ori_x, ori_y) à
l'ancienne (variables old_ori_x, old_ori_y). Si le défilement va vers la droite, on affiche une
nouvelle colonne de blocs à droite de l'écran et s'il va vers la gauche, on l'affiche devinez où ?
Eh bien oui, à gauche, bien joué, vous reviendrez en deuxième semaine.
Pour voir le défilement bouger, on incrémente les pointeurs plans de bits pour la droite et on les
décrémente pour la gauche, mais uniquement quand cela est nécessaire, c'est-à-dire tous les 16
pixels. Le spectateur a ainsi l'impression que l'écran tout entier bouge dans la direction voulue.
Comme vous l'avez sûrement deviné, on peut aller très loin dans la mémoire comme cela et c'est
en effet le seul défaut de cette technique : il n'est pas infini en horizontal. Par exemple,
pour un défilement sur 80 écrans de large, il faut prévoir 80 lignes supplémentaires en bas de
la page. Ce défaut n'est pas vraiment excessif, compte tenu des avantages. De plus, avec le
double tampon mémoire qui est nécessaire dans la majorité des jeux ou autres applications,
nous ne sommes pas forcés d'avoir deux fois ce supplément.
En effet, quand une page va descendre, l'autre aussi, donc si on espace un peu les deux
pages pour ne pas qu'elles se chevauchent au moment des changements de direction, le supplément
de ligne n'est que de 80 pour les deux pages.
Passons maintenant au défilement vertical, qui est lui plus efficace car infini. Il est
en fait la partie forte de la technique grâce à la manière originale dont il est géré. Il a
besoin pour pouvoir s'exprimer pleinement, d'une hauteur de champ de jeu ("playfield") égale à celle de l'écran
plus 16 pixels. Tout se fait grâce au Copper : quand le défilement descend, on fait descendre
le pointeur des plans de bits sur la page. Après avoir descendu 16 pixels, la page n'est plus assez
grande pour descendre encore de cette manière. Quand le défilement est dans cette position,
on remarque que l'on ne se sert pas des 16 premiers pixels de la page, donc la ruse consiste
à afficher la nouvelle ligne de blocs à cet endroit. Pour donner l'illusion au spectateur que
le défilement continue normalement, on interrompt au moment opportun le balayage-écran avec
le Copper pour changer les pointeurs qui montrent la zone contenant les nouveaux blocs.
Dans cette posture, on peut encore descendre de 16 pixels. Arrivé à cette nouvelle limite, on
affiche encore une nouvelle ligne en bas de l'écran, donc en fait sur le haut de la page, entre
les lignes 16 et 32, et ainsi de suite pour le reste de la descente.
Quand le premier pointeur arrive en bas de la page, on le fait remonter tout en haut et on peut
continuer comme cela très longtemps. Pour faire monter le défilement, le procédé est identique,
à l'exception du pointeur plan de bits qui monte et de la nouvelle ligne de blocs qui est affichée en
haut de l'écran.
On détecte dans un premier temps la direction de la même manière que dans le défilement
horizontal pour savoir si on affiche une ligne de blocs en haut ou en bas de l'écran.
Réalisation
Ceux qui ont tout suivi se sont très probablement aperçus que le défilement
vertical empêchait l'utilisation du défilement horizontal tel qu'il a été décrit
plus haut. Pour avoir un défilement multidirectionnel, il faut obtenir une parfaite
compatibilité entre les deux. Pour ce faire, on va modifier le défilement
horizontal et plus précisément la routine qui affiche les nouvelles colonnes : on fait en
sorte que le premier bloc de la colonne s'affiche à l'endroit que montre le premier
pointeur plan de bits. On affiche chaque bloc en dessous de l'autre, en testant à chaque fois
si l'on arrive en bas de la page ; si oui, on affiche les prochains blocs en haut de
la page. De cette façon, on peut avoir un défilement tout à fait intéressant, car il
permet un déplacement de 16 pixels en X et en Y simultanément, le tout en cinquante lignes de trame
(rasterlines) pour un écran de 320x256 en 4 plans de bits.
Dans le cas de l'utilisation du double tampon mémoire, le pas maximum descend à 8 pixels en
X et en Y.
OPT C-
incdir 'include:'
include 'exec/exec_lib.i'
include 'hardware/custom.i'
custom = $dff000
execbase = 4
BPL_X = 320
BPL_Y = 192
BPL_DEPTH = 4
MODULO = 2
BPL_WIDTH = BPL_X/8+MODULO
BPL_SIZE = BPL_WIDTH*BPL_Y
SCR_SIZE = BPL_SIZE*BPL_DEPTH
MAP_WIDTH = 35
MAP_HEIGHT = 35
BLK_WIDTH = 16
BLK_HEIGHT = 16
SCROLL_SPEED = 8
vsync: macro
.wait_vsync\@:
move.l vposr(a5),d0
and.l #$1ff00,d0
cmp.l #$11000,d0
bne.s .wait_vsync\@
endm
wait_blt: macro
btst #14,dmaconr(a5)
.loop_wait_blt\@:
btst #14,dmaconr(a5)
bne.s .loop_wait_blt\@
endm
MOD: MACRO \1,\2 * \1 chiffre a moduler \2 la base du modulo
.MODULO_GO_ON\@:
cmp.w \2,\1
blt.s .MODULO_IS_FINISH\@
sub.w \2,\1
bra.s .MODULO_GO_ON\@
.MODULO_IS_FINISH\@:
ENDM
******************************************************
************** programme principal *****************
******************************************************
move.l (execbase).w,a6
lea custom,a5
CALLEXEC Forbid
move.w #$03e0,dmacon(a5) * all dma off except disk
move.w #(BPL_DEPTH<<12)+$200,bplcon0(a5)
clr.w bplcon1(a5)
clr.w bplcon2(a5)
move.w #BPL_WIDTH*(BPL_DEPTH-1),bpl1mod(a5)
move.w #BPL_WIDTH*(BPL_DEPTH-1),bpl2mod(a5)
move.w #$2981,diwstrt(a5) *\
move.w #$e9c0,diwstop(a5) * > init un ecran 320*192
move.w #$0030,ddfstrt(a5) * > avec un mot en plus pour
move.w #$00d0,ddfstop(a5) */ le shift
bsr build_coplist
move.l coplist_adr,cop1lc(a5) * > run my coplist
clr.w copjmp1(a5) */
move.w #$83c0,dmacon(a5) * dma blitter,copper & plan de bits on
move.w #$f00,color+15*2(a5)
move.w #$0f0,color+1*2(a5)
move.w #$00f,color+6*2(a5)
bsr INIT_FIRST_SCR
main_loop:
vsync
move.w #-1,color(a5)
bsr INIT_SCR_PT_ADR
bsr SCROLL
bsr build_coplist
bsr CHANGE_DIRECTION_WITH_KEYBOARD
tst.w ORI_X
bge.s .ORI_X_NE_SORT_PAS_A_GAUCHE
clr.w ORI_X
.ORI_X_NE_SORT_PAS_A_GAUCHE
cmp.w #MAP_WIDTH*16-BPL_X-1,ORI_X
ble.s .ORI_X_NE_SORT_PAS_A_DROITE
move.w #MAP_WIDTH*16-BPL_X-1,ORI_X
.ORI_X_NE_SORT_PAS_A_DROITE
tst.w ORI_Y
bge.s .ORI_Y_NE_SORT_PAS_EN_HAUT
clr.w ORI_Y
.ORI_Y_NE_SORT_PAS_EN_HAUT
cmp.w #MAP_HEIGHT*16-BPL_Y-1,ORI_Y
ble.s .ORI_Y_NE_SORT_PAS_EN_BAS
move.w #MAP_HEIGHT*16-BPL_Y-1,ORI_Y
.ORI_Y_NE_SORT_PAS_EN_BAS
clr.w color(a5)
move.b $bfec01,d0 *\
not d0 * >capture the key wich is pressed
ror.b #1,d0 */ and put is code RAW in d0
cmp.b #$45,d0 *\
beq init_end */ sort si on press sur esc
btst #6,$bfe001
bne main_loop
******** init end ***********
* reactivation de l'old coplist
init_end:
wait_blt
lea GfxName(pc),a1 * nom de la library ds a1
moveq #0,d0 * version 0 (the last)
CALLEXEC OpenLibrary * lib graphique ouverte
move.l d0,a4 * adr de graphicbase ds a4
move.l 38(a4),cop1lc(a5) * chargement de l'adr de
clr.w copjmp1(a5) * l'old coplist et lancement
move.w #$83e0,dmacon(a5) * activation des canaux dma necessaires
CALLEXEC Permit * multi switching autorise
fin: moveq #0,d0 * flag d'erreur desactive
rts
GfxName: dc.b "graphics.library",0
even
CHANGE_DIRECTION_WITH_KEYBOARD: ******************************************
move.b $bfec01,d0 *\
not d0 * >capture the key wich is pressed
ror.b #1,d0 */ and put is code RAW in d0
ext.w d0
lea TAB_DELTA_X_Y_ACOORDING_TO_KEYBOARD,a0
.TRY_ANOTHER_KEY:
tst.w (a0)
blt.s .TST_KEY_FINISH
cmp.w (a0),d0
bne.s .NOT_THIS_KEY
move.w 2(a0),d0
add.w d0,ORI_X
move.w 4(a0),d0
add.w d0,ORI_Y
bra.s .TST_KEY_FINISH
.NOT_THIS_KEY:
addq.l #6,a0
bra.s .TRY_ANOTHER_KEY
.TST_KEY_FINISH:
rts
s SET SCROLL_SPEED
TAB_DELTA_X_Y_ACOORDING_TO_KEYBOARD:
dc.w $3f,s,-s,$3e,0,-s,$3d,-s,-s,$2d,-s,0,$2f,s,0,$1d,-s,s
dc.w $1e,0,s,$1f,s,s
dc.w -1
**************************************** END_CHANGE_DIRECTION_WITH_KEYBOARD
INIT_SCR_PT_ADR: *******************************************************
move.l LOG_SCR_ADR,a0
move.w ORI_X,d0
and.w #$fff0,d0
lsr.w #3,d0
lea (a0,d0.w),a0
move.l a0,SCR_PT_ADR
rts
***************************************************** END_INIT_SCR_PT_ADR
SCROLL: **************************************************************
move.w ORI_Y,d0
move.w #BPL_Y+BLK_HEIGHT,d1
MOD d0,d1
move.w d0,START_FIRST_PART
neg.w d0
add.w #BPL_Y+BLK_HEIGHT,d0
cmp.w #BPL_Y,d0
ble.s .FIRST_PART_SIZE_NOT_BIGGER_THAN_SCREEN
move.w #BPL_Y,d0
.FIRST_PART_SIZE_NOT_BIGGER_THAN_SCREEN
move.w d0,FIRST_PART_SIZE
move.w ORI_Y,d0
add.w #BPL_Y,d0
move.w #BPL_Y+BLK_HEIGHT,d1
MOD d0,d1
move.w d0,END_SECOND_PART
lea MAP,a0
move.w ORI_X,d0
lsr.w #4,d0
lea (a0,d0.w),a0
move.w ORI_Y,d0
lsr.w #4,d0
mulu #MAP_WIDTH,d0
add.l d0,a0
move.l a0,MAP_PT
* on init les registres blitter qui resteront ainsi durant toute la routine
WAIT_BLT
move.w #$09f0,BLTCON0(a5)
clr.w BLTCON1(a5)
move.w #-1,BLTAFWM(a5)
move.w #-1,BLTALWM(a5)
move.w #BPL_WIDTH-2,BLTDMOD(a5)
clr.w BLTAMOD(a5)
* maintenant on affiche les blk pour le scroll en x
move.w ORI_X,d0
cmp.w OLD_ORI_X,d0
ble.s .DONT_SCROLL_TOWARD_RIGHT
move.w OLD_ORI_X,d0
add.w #BPL_X-1,d0
and.w #$fff0,d0
move.w ORI_X,d1
add.w #BPL_X-1,d1
and.w #$fff0,d1
cmp.w d0,d1
beq.s .DONT_SCROLL_TOWARD_RIGHT
move.l SCR_PT_ADR,a0
move.w START_FIRST_PART,d0
and.w #$fff0,d0
mulu #BPL_WIDTH*BPL_DEPTH,d0
add.l d0,a0
lea BPL_WIDTH-MODULO(a0),a0
move.l MAP_PT,a1
add.l #BPL_X/16,a1
bsr AFF_A_COLUMM_OF_BLK
.DONT_SCROLL_TOWARD_RIGHT:
move.w ORI_X,d0
cmp.w OLD_ORI_X,d0
bge.s .DONT_SCROLL_TOWARD_LEFT
move.w OLD_ORI_X,d0
and.w #$fff0,d0
move.w ORI_X,d1
and.w #$fff0,d1
cmp.w d0,d1
beq.s .DONT_SCROLL_TOWARD_LEFT
move.l SCR_PT_ADR,a0
move.w START_FIRST_PART,d0
and.w #$fff0,d0
mulu #BPL_WIDTH*BPL_DEPTH,d0
add.l d0,a0
move.l MAP_PT,a1
bsr AFF_A_COLUMM_OF_BLK
.DONT_SCROLL_TOWARD_LEFT:
* maintenant on affiche les blk pour le scroll en y
move.w ORI_Y,d0
cmp.w OLD_ORI_Y,d0
ble.s .DONT_SCROLL_TOWARD_DOWN
move.w OLD_ORI_Y,d0
add.w #BPL_Y-1,d0
and.w #$fff0,d0
move.w ORI_Y,d1
add.w #BPL_Y-1,d1
and.w #$fff0,d1
cmp.w d0,d1
beq.s .DONT_SCROLL_TOWARD_DOWN
move.l SCR_PT_ADR,a0
move.w END_SECOND_PART,d0
and.w #$fff0,d0
mulu #BPL_WIDTH*BPL_DEPTH,d0
add.l d0,a0
move.l MAP_PT,a1
add.l #(BPL_Y/16)*MAP_WIDTH,a1
bsr AFF_A_LINE_OF_BLK
.DONT_SCROLL_TOWARD_DOWN:
move.w ORI_Y,d0
cmp.w OLD_ORI_Y,d0
bge.s .DONT_SCROLL_TOWARD_UP
move.w OLD_ORI_Y,d0
and.w #$fff0,d0
move.w ORI_Y,d1
and.w #$fff0,d1
cmp.w d0,d1
beq.s .DONT_SCROLL_TOWARD_UP
move.l SCR_PT_ADR,a0
move.w START_FIRST_PART,d0
and.w #$fff0,d0
mulu #BPL_WIDTH*BPL_DEPTH,d0
add.l d0,a0
move.l MAP_PT,a1
bsr AFF_A_LINE_OF_BLK
.DONT_SCROLL_TOWARD_UP:
move.w ORI_X,OLD_ORI_X
move.w ORI_Y,OLD_ORI_Y
rts
ORI_X: ds.w 1 *\ coor du coin en haut a gauche
ORI_Y: ds.w 1 */
OLD_ORI_X: ds.w 1
OLD_ORI_Y: ds.w 1
START_FIRST_PART: ds.w 1
END_SECOND_PART: ds.w 1
FIRST_PART_SIZE: ds.w 1
MAP_PT: ds.l 1
************************************************************ END_SCROLL
AFF_A_COLUMM_OF_BLK: ***********************************************
* IN: a0= adr ou on va poser les blk
* a1= adr de la map ou on va chercher quel blk afficher
* OUT: rien
lea TAB_ADR_BLK_GFX,a2
moveq #0,d2
move.w #BPL_Y/16-1+1,d0
.LOOP_AFF_EACH_BLK:
move.b (a1),d1
lea MAP_WIDTH(a1),a1
ext.w d1
lsl.w #2,d1
move.l (a2,d1.w),d1
WAIT_BLT
move.l a0,BLTDPT(a5)
move.l d1,BLTAPT(a5)
move.w #BLK_HEIGHT*BPL_DEPTH*64+BLK_WIDTH/16,BLTSIZE(a5)
lea BLK_HEIGHT*BPL_WIDTH*BPL_DEPTH(a0),a0
tst.w d2
bne.s .SECOND_PART_ALREADY_BEGIN
move.l SCR_PT_ADR,a3
add.l #(BPL_Y+BLK_HEIGHT-1)*BPL_WIDTH*BPL_DEPTH,a3
cmp.l a3,a0
ble.s .FIRST_PART_NOT_TOTALLY_PRINT
sub.l #(BPL_Y+BLK_HEIGHT)*BPL_WIDTH*BPL_DEPTH,a0
moveq #-1,d2
.SECOND_PART_ALREADY_BEGIN
.FIRST_PART_NOT_TOTALLY_PRINT:
dbf d0,.LOOP_AFF_EACH_BLK
rts
************************************************** END_AFF_A_COLUMM_OF_BLK
AFF_A_LINE_OF_BLK: ******************************************************
* IN: a0= adr ou on va poser les blk
* a1= adr de la map ou on va chercher quel blk afficher
* OUT: rien
lea TAB_ADR_BLK_GFX,a2
moveq #BPL_WIDTH/2-1,d0
.LOOP_AFF_EACH_BLK:
move.b (a1)+,d1
ext.w d1
lsl.w #2,d1
move.l (a2,d1.w),d1
WAIT_BLT
move.l a0,BLTDPT(a5)
move.l d1,BLTAPT(a5)
move.w #BLK_HEIGHT*BPL_DEPTH*64+BLK_WIDTH/16,BLTSIZE(a5)
addq.l #BLK_WIDTH/8,a0
dbf d0,.LOOP_AFF_EACH_BLK
rts
************************************************** END_AFF_A_LINE_OF_BLK
INIT_FIRST_SCR: **********************************************************
clr.w ORI_X
clr.w ORI_Y
clr.w OLD_ORI_X
clr.w OLD_ORI_Y
* on init les registres blitter qui resteront ainsi durant toute la routine
WAIT_BLT
move.w #$09f0,BLTCON0(a5)
clr.w BLTCON1(a5)
move.w #-1,BLTAFWM(a5)
move.w #-1,BLTALWM(a5)
move.w #BPL_WIDTH-2,BLTDMOD(a5)
clr.w BLTAMOD(a5)
* maintenant on affiche le premier ecran
move.l LOG_SCR_ADR,a0
move.l PHY_SCR_ADR,a3
lea MAP,a1
lea TAB_ADR_BLK_GFX,a2
moveq #BPL_Y/16+1-1,d2
.LOOP_AFF_EACH_LINE:
move.w #BPL_WIDTH/2-1,d0
.LOOP_AFF_EACH_BLK:
move.b (a1)+,d1
ext.w d1
lsl.w #2,d1
move.l (a2,d1.w),d1
WAIT_BLT
move.l a0,BLTDPT(a5)
move.l d1,BLTAPT(a5)
move.w #16*BPL_DEPTH*64+1,BLTSIZE(a5)
addq.l #2,a0
WAIT_BLT
move.l a3,BLTDPT(a5)
move.l d1,BLTAPT(a5)
move.w #16*BPL_DEPTH*64+1,BLTSIZE(a5)
addq.l #2,a3
dbf d0,.LOOP_AFF_EACH_BLK
lea 16*BPL_WIDTH*BPL_DEPTH-BPL_WIDTH(a0),a0
lea 16*BPL_WIDTH*BPL_DEPTH-BPL_WIDTH(a3),a3
lea MAP_WIDTH-BPL_WIDTH/2(a1),a1
dbf d2,.LOOP_AFF_EACH_LINE
rts
**************************************************** END_INIT_FIRST_SCR
build_coplist: ********************************************************
move.l COPLIST_ADR(pc),a0
move.w ORI_X,d0
and.w #$000f,d0
neg.w d0
add.w #$f,d0
move.w d0,d1
lsl.w #4,d0
or.w d1,d0
move.w #BPLCON1,(a0)+
move.w d0,(a0)+
move.l SCR_PT_ADR,d2
move.w START_FIRST_PART,d0
mulu #BPL_WIDTH*BPL_DEPTH,d0
add.l d0,d2
moveq #BPL_DEPTH-1,d0
move.w #bplpt,d1
.loop_init_BPL_in_clist
move.w d1,(a0)+
addq.l #2,d1
swap d2
move.w d2,(a0)+
swap d2
move.w d1,(a0)+
addq.l #2,d1
move.w d2,(a0)+
add.l #BPL_WIDTH,d2
dbf d0,.loop_init_BPL_in_clist
moveq #$29,d0
add.w FIRST_PART_SIZE,d0
lsl.w #8,d0
or.w #$0001,d0
move.w d0,(a0)+
move.w #$fffe,(a0)+
move.l SCR_PT_ADR,d2
moveq #BPL_DEPTH-1,d0
move.w #bplpt,d1
.loop_init_BPL_in_clist1
move.w d1,(a0)+
addq.l #2,d1
swap d2
move.w d2,(a0)+
swap d2
move.w d1,(a0)+
addq.l #2,d1
move.w d2,(a0)+
add.l #BPL_WIDTH,d2
dbf d0,.loop_init_BPL_in_clist1
move.l #$fffffffe,(a0)+ * montre la fin de la clist
rts
********************************************************* END_build_coplist
******** datas
* variables
TAB_ADR_BLK_GFX: dc.l BLK0_GFX,BLK1_GFX,BLK2_GFX
SCR_PT_ADR: ds.l 1
LOG_SCR_ADR: dc.l ecran1
PHY_SCR_ADR: dc.l ecran2
COPLIST_ADR: dc.l coplist
MAP:
dc.b 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
dc.b 0,0,0,1,1,1,0,0,0,1,0,0,0,0,0,1,0,1,1,1,1,1,1,1,0,0,0,0,0,1,1,0,0,0,0
dc.b 0,0,1,0,0,0,1,0,0,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0
dc.b 0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0
dc.b 0,0,1,1,1,1,1,0,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0
dc.b 0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,1,0,0,0,1,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0
dc.b 0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,1,1,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,1,1,0,1,0,0,0,1,0
dc.b 0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,1,0,1,0,1,0,0,0,1,1,0,1,1,0
dc.b 0,0,1,1,1,0,0,1,0,0,1,0,1,0,0,0,1,0,1,1,0,1,0,1,0,0,1,0,0,1,0,1,0,1,0
dc.b 0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,1,1,1,0,0,0,1,0,1,0,0,0,1,0
dc.b 0,0,1,0,0,0,0,0,1,1,0,0,1,1,1,0,1,1,1,0,0,1,0,1,0,1,1,0,0,1,0,0,0,1,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,1,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,1,0,0,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,1,0,1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,1,1,1,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,1,1,0,1,0,0,0,1,0
dc.b 0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,1,0,1,0,1,0,0,0,1,1,0,1,1,0
dc.b 0,0,1,1,1,0,0,1,0,0,1,0,1,0,0,0,1,0,2,2,0,1,0,1,0,0,1,0,0,1,0,1,0,1,0
dc.b 0,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,0,0,0,1,1,1,0,0,0,1,0,1,0,0,0,1,0
dc.b 0,0,1,0,0,0,0,0,1,1,0,0,1,1,1,0,1,1,1,0,0,1,0,1,0,1,1,0,0,1,0,0,0,1,0
dc.b 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,1,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,1,0,0,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,1,0,1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0
dc.b 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
section GFX,DATA_C
BLK0_GFX: REPT 16
dc.w -1,-1,-1,-1
ENDR
BLK1_GFX: REPT 16
dc.w -1,0,0,0
ENDR
BLK2_GFX: REPT 16
dc.w 0,-1,-1,0
ENDR
section ZONE_CHIP,BSS_C
ds.l 1
ecran1: ds.l (scr_size*2)/4
ecran2: ds.l (scr_size*2)/4
coplist: ds.l 1000*4 * taiile inconnue donc on prevoit gros
end
|
NDLR : une erreur s'est glissée dans le source, voir
cet article pour plus d'informations.
Voilà, c'est fini ; le mois prochain vous aurez très probablement droit à quelque chose plus
proche de la démo que du jeu, comme une routine de plasma ou un ciel étoilé multidirectionnel.
La phrase du mois : "si vous n'affrontez pas vos terreurs en face, elles vous grimperont dans le dos".
|
