home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #6 / amigamamagazinepolishissue1998.iso / coders / assembler-kurs / listings3 / listing7x3.s < prev    next >
Text File  |  1977-12-31  |  9KB  |  325 lines
  1.  
  2. ; Listing7x3.s    - Kollisionen zwischen Playfield im Dual-Playfield-Mode
  3. ; In diesem Beispiel zeigen wir die Kollisionen zwischen zwei Playfields.
  4. ; Das Playfield 1 bewegt sich von Oben nach Unten.
  5. ; Wenn sich Color3 des Playfield 1 mit dem Color1 des Playfield 2 überlappt,
  6. ; wird eine Kollision ausgelöst, die das Ändern der Hintergrundfarbe zur 
  7. ; Folge hat
  8.  
  9.     SECTION CipundCop,CODE
  10.  
  11. Anfang:
  12.     move.l    4.w,a6        ; Execbase
  13.     jsr    -$78(a6)    ; Disable
  14.     lea    GfxName(PC),a1    ; Name lib
  15.     jsr    -$198(a6)    ; OpenLibrary
  16.     move.l    d0,GfxBase
  17.     move.l    d0,a6
  18.     move.l    $26(a6),OldCop    ; speichern die alte COP
  19.  
  20. ; Verwenden 2 Planes pro Playfield
  21.  
  22. ;    Pointen wie immer auf unser PIC
  23.  
  24.         MOVE.L  #PIC1,d0    ; pointen auf Playfield 1
  25.         LEA     BPLPOINTERS1,A1
  26.         MOVEQ   #2-1,D1
  27. POINTBP:
  28.     move.w  d0,6(a1)
  29.     swap    d0
  30.     move.w  d0,2(a1)
  31.     swap    d0
  32.     ADD.L   #40*256,d0
  33.     addq.w  #8,a1
  34.     dbra    d1,POINTBP
  35.  
  36.     MOVE.L  #PIC2,d0        ; pointen auf Playfield 2
  37.     LEA     BPLPOINTERS2,A1
  38.     MOVEQ   #2-1,D1
  39. POINTBP2:
  40.     move.w    d0,6(a1)
  41.     swap    d0
  42.     move.w    d0,2(a1)
  43.     swap    d0
  44.     ADD.L    #40*256,d0
  45.     addq.w    #8,a1
  46.     dbra    d1,POINTBP2
  47.  
  48.     move.l    #COPPERLIST,$dff080    ; unsere COP
  49.     move.w    d0,$dff088        ; START COP
  50.     move.w    #0,$dff1fc        ; NO AGA!
  51.     move.w    #$c00,$dff106        ; NO AGA!
  52.  
  53.  
  54.     move.w    #$0024,$dff104    ; BPLCON2
  55.                 ; mit diesem Wert sind alle Sprites über
  56.                 ; den Bitplanes
  57.  
  58.  
  59. Warte1:
  60.     cmpi.b    #$ff,$dff006    ; Zeile 255?
  61.     bne.s    Warte1
  62. Warte11:
  63.     cmpi.b    #$ff,$dff006    ; Immer noch Zeile 255?
  64.     beq.s    Warte11
  65.  
  66.     btst    #6,$bfe001
  67.     beq.s    Raus
  68.  
  69.     bsr.s    BewegeCopper    ; Bewege Playfield 1
  70.     bsr.w    CheckColl    ; Kontrolliert die Kollision und greift ein
  71.  
  72.     bra.s    Warte1
  73.  
  74. Raus    move.l    OldCop(PC),$dff080    ; Pointen auf die SystemCOP
  75.     move.w    d0,$dff088        ; Starten die alte COP
  76.  
  77.     move.l    4.w,a6
  78.     jsr    -$7e(a6)    ; Enable
  79.     move.l    gfxbase(PC),a1
  80.     jsr    -$19e(a6)    ; Closelibrary
  81.     rts
  82.  
  83. ;    Daten
  84.  
  85. GfxName:
  86.     dc.b    "graphics.library",0,0
  87.  
  88. GfxBase:
  89.     dc.l    0
  90.  
  91. OldCop:
  92.     dc.l    0
  93.  
  94. ; Diese Routine bewegt ein Playfield nach unten. Es ist die selbe wie in
  95. ; Lektion 5, nur daß wir hier nur das Playfield 1 bewegen, also die
  96. ; ungeraden Bitplanes.
  97.  
  98. BewegeCopper:
  99.     LEA    BPLPOINTERS1,A1    ; Mit diesen 4 Instruktionen hole ich aus der
  100.     move.w    2(a1),d0    ; Copperlist die Adresse, wohin das $dff0e0
  101.     swap    d0        ; gerade pointet und gebe es in d0 - das
  102.     move.w    6(a1),d0    ; Gegenteil der Routine, die auf die Planes
  103.                 ; pointet! Hier nehmen wir uns die Adresse
  104.                 ; anstatt sie einzusetzen!
  105.  
  106.     TST.B    RaufRunter    ; Müssen wir rauf oder runter? Wenn RaufRunter
  107.                 ; auf Null steht (TST also ein BEQ ergibt),
  108.                 ; dann springen wir auf GehRunter, wenn es
  109.                 ; hingegen auf $FF steht (und TST nicht 
  110.                 ; eintrifft), dann steigen wir weiter
  111.  
  112.     beq.w    GehRunter
  113.     cmp.l    #PIC1-(40*90),d0; Sind wir weit genug OBEN?
  114.     beq.s    SetzRunter    ; wenn ja, sind wir am Gipfel und müssen runter
  115.     sub.l    #40,d0        ; subtrahieren 40, also 1 Zeile, dadurch
  116.                 ; scrollt das Bild um 1 nach unten
  117.     bra.s    ENDE
  118.  
  119. SetzRunter:
  120.     clr.b    RaufRunter     ; Löscht RaufRunter, beim TST.B RaufRunter
  121.                 ; wird ein BEQ
  122.     bra.s    ENDE        ; zur Routine GehRunter abzweigen
  123.  
  124. GehRunter:
  125.     cmpi.l    #PIC1+(40*30),d0 ; sind wir weit genug UNTEN?
  126.     beq.s    SetzRauf    ; wenn ja, sind wir ganz unten und müssen rauf
  127.     add.l    #40,d0        ; Addieren 40, also eine, Zeile, das Bild 
  128.                 ; scrollt nach OBEN
  129.     bra.s    ENDE
  130.  
  131. SetzRauf:
  132.     move.b    #$ff,RaufRunter    ; Wenn das Label RaufRunter nicht auf Null ist
  133.     rts            ; bedeutet es, daß wir steigen müssen
  134.  
  135. ENDE:                ; POINTEN DIE BITPLANEPOINTER
  136.     LEA    BPLPOINTERS1,A1    ; pointer in der COPPERLIST
  137.     MOVEQ    #1,D1        ; Anzahl der Bitplanes -1 (hier sind es 2)
  138. POINTBP3:
  139.     move.w    d0,6(a1)
  140.     swap    d0
  141.     move.w    d0,2(a1)
  142.     swap    d0
  143.     ADD.L    #40*256,d0
  144.     addq.w    #8,a1
  145.     dbra    d1,POINTBP3
  146.     rts
  147.  
  148.  
  149. ; Dieses Byte, an der Stelle, die RaufRunter markiert, ist ein FLAG.
  150.  
  151. RaufRunter:
  152.     dc.b    0,0
  153.  
  154.  
  155. ; Diese Routine kontrolliert, ob es eine Kollision gibt.
  156. ; Wenn ja, verändert sie die Farbe des Hintergrundes, indem sie auf
  157. ; das Register COLOR00 in der Copperlist zugreift.
  158.  
  159. CheckColl:
  160.         move.w    $dff00e,d0    ; liest CLXDAT ($dff00e)
  161.                 ; das Lesen dieses Registers bewirkt auch
  162.                 ; seine sofortige Löschung, es ist also besser,
  163.                 ; man kopiert es sich in d0 und macht dort dann
  164.                 ; die Tests
  165.     btst.l    #0,d0           ; das Bit 1 meldet eine Kollision zwischen 
  166.                 ; zwei Playfields
  167.         beq.s    no_coll        ; wenn´s keine Kollision gab, überspringe
  168.  
  169.         move.w    #$f00,Kollisions_Sensor    ; "anschalten" des Signales (COLOR0)
  170.                     ; verändert die Copperlist (Rot)
  171.         bra.s    exitColl        ; Raus
  172.     
  173. no_coll:
  174.     move.w    #$000,Kollisions_Sensor ; Schaltet den Sensor aus (Color0)
  175.                     ; indem er auf die Copperlist einwirkt
  176. ExitColl:
  177.     rts
  178.  
  179. flag:
  180.     dc.w    0
  181. altezza:
  182.     dc.w    $2c
  183.  
  184.  
  185.  
  186.     SECTION    GRAPHIC,DATA_C
  187.  
  188. COPPERLIST:
  189. SpritePointers:
  190.     dc.w    $120,0,$122,0,$124,0,$126,0,$128,0 ; SPRITE
  191.     dc.w    $12a,0,$12c,0,$12e,0,$130,0,$132,0
  192.     dc.w    $134,0,$136,0,$138,0,$13a,0,$13c,0
  193.     dc.w    $13e,0
  194.  
  195.     dc.w    $8E,$2c81    ; DiwStrt
  196.     dc.w    $90,$2cc1    ; DiwStop
  197.     dc.w    $92,$38        ; DdfStart
  198.     dc.w    $94,$d0        ; DdfStop
  199.     dc.w    $102,0        ; BplCon1
  200.     dc.w    $108,0        ; Bpl1Mod
  201.     dc.w    $10a,0        ; Bpl2Mod
  202.  
  203.             ; 5432109876543210
  204.     dc.w    $100,%0100011000000000    ; Bit 10 an = Dual Playfield
  205.                     ; verwende 4 Planes = 4 FArben pro
  206.                     ; Playfield
  207.  
  208. BPLPOINTERS1:
  209.     dc.w $e0,0,$e2,0    ;erstes Bitplane Playfield 1 (BPLPT1)
  210.     dc.w $e8,0,$ea,0    ;zweites Bitplane Playfield 1 (BPLPT3)
  211.  
  212.  
  213. BPLPOINTERS2:
  214.     dc.w $e4,0,$e6,0    ;erstes Bitplane Playfield 2 (BPLPT2)
  215.     dc.w $ec,0,$ee,0    ;zweites Bitplane Playfield 2 (BPLPT4)
  216.  
  217. ; Das ist das Register CLXCON (kontrolliert die Art der Signalisierung)
  218.  
  219. ; Die Bit von 0 bis 5 sind die Werte, die die Planes annehmen müssen
  220. ; Die Bit von 6 bis 11 geben an, welche Planes für Kollisionen freigegeben sind
  221. ; Die Bit von 12 bis 15 geben an, welche der ungeraden Sprites für die
  222. ; Kollisionserfassung aktiviert sind
  223.  
  224.             ;5432109876543210
  225.     dc.w    $98,%0000001111000111    ; CLXCON
  226.  
  227. ; Die Planes 1,2,3,4 sind für Kollisionen aktiviert (Bit 6,7,8,9).
  228. ; Es wird eine Kollision angezeigt, wenn sich folgende Situationen ergeben:
  229. ;            Plane 1 = 1 (Bit 0)
  230. ;               Plane 3 = 1 (Bit 2)
  231. ; Also Color3 des Playfield 1
  232. ;             Plane 2 = 1 (Bit 1)
  233. ;               Plane 4 = 0 (Bit 3)
  234. ; also Color2 des Playfield 2
  235.  
  236.  
  237.     dc.w    $180    ; COLOR00
  238. Kollisions_Sensor:
  239.     dc.w    0    ; AN DIESEM PUNKT modifiziert die Routine CheckColl
  240.             ; die Copperlist, indem sie einen anderen Wert einträgt
  241.  
  242.                             ; Palette Playfield 1
  243.     dc.w    $182,$005    ; Farben von 0 bis 7
  244.     dc.w    $184,$a40
  245.     dc.w    $186,$f80
  246.     dc.w    $188,$f00
  247.     dc.w    $18a,$0f0
  248.     dc.w    $18c,$00f
  249.     dc.w    $18e,$080
  250.  
  251.  
  252.                 ; Palette Playfield 2
  253.     dc.w    $192,$367    ; Farben von 9 bis 15
  254.     dc.w    $194,$0cc     ; Color8 ist durchsichtig, er wird also nicht
  255.     dc.w    $196,$a0a     ; gesetzt
  256.     dc.w    $198,$242
  257.     dc.w    $19a,$282
  258.     dc.w    $19c,$861
  259.     dc.w    $19e,$ff0
  260.  
  261.     dc.w    $FFFF,$FFFE    ; Ende der Copperlist
  262.  
  263.     dcb.b    40*90,0    ; Diesen freien Raum brauchen wir, denn wenn wir über
  264.             ; bzw. unter der Zone des PIC1 anzeigen, dann sehen
  265.             ; wir ja das, was darüber/darunterliegt, und das
  266.             ; ergäbe im Normalfall zufällige Bytes.
  267.             ; Durch viele Nullen aber haben wir COLOR0, also die
  268.             ; Hintergrundfarbe.
  269.  
  270. PIC1:    incbin    "colldual1.raw"
  271.     dcb.b    40*30,0    ; siehe oben
  272.  
  273. PIC2:    incbin    "colldual2.raw"
  274.  
  275.     end
  276.  
  277. In diesem Beispiel zeigen wir die  Kollision zwischen zwei Playfields. Der
  278. Mechanismus ist der gleiche wie mit den  Sprites. Das Register CLXCON wird
  279. verwendet, um  anzugeben, welche Planes für  die Spriteerkennung aktiviert 
  280. werden sollen.  Wie immer ist es  möglich, das anzugeben, und  bei welchen 
  281. Werten der Überlagerung der Farben sich eine Kollision ergeben soll.
  282. Im Beispiel erkennen wir die Kollision zwischen Color3 des Playfield 1 und
  283. Color1 des Playfield 2.  Wenn ihr  die Copperlist verändert,  und den Wert
  284. von CLXCON  austauscht,  dann  könnt  ihr  andere  Typen von Zusammenstöße 
  285. erkennen. Zum Beispiel so:
  286.  
  287.     dc.w    $98,%0000001111000110    ; CLXCON
  288.  
  289. Die Planes 1,2,3 und 4 sind für die Kollisionen aktiviert (Bit 6,7,8,9).
  290.  
  291. Es wird eine Kollision angezeigt, wenn sich ein Pixel mit
  292.             Plane 1 = 0 (Bit 0)
  293.                        Plane 3 = 1 (Bit 2)
  294.  also Color2 des Playfield1
  295.  
  296.  und ein Pixel mit    Plane 2 = 1 (Bit 1)
  297.                        Plane 4 = 0 (Bit 3)
  298.  also Color1 des Playfield 2
  299.  überlagern.
  300.  
  301. Ihr könnt auch Kollisionen zwischen mehreren Farben erkennen, indem ihr
  302. einfach einige Planes ausschaltet. Beispiel:
  303.  
  304.     dc.w    $98,%0000001011000011    ; CLXCON
  305.  
  306. Die Planes 1,2 und 4 sind für Kollisionen aktiviert (Bit 6,7 und 9).
  307. Was Playfield 2 angeht, so wurden beide Planes aktiviert, es werden also
  308. die Pixel betrachtet, die:    Plane 2 = 1 (Bit 1)
  309.                 Plane 4 = 0 (Bit 3)
  310. haben, also Color1 des Playfield 2.
  311.  
  312. Bei  Playfield1  hingegen  wurde  nur Plane 1 eingeschaltet, der Wert  des
  313. Plane3 hat keinen Einfluß.Es werden also die Pixel betrachtet,die folgende
  314. Konfiguration haben:    Plane 0 = 1 (Bit 0)
  315.             Plane 3 = 0 (Bit 2)
  316.             Plane 0 = 1 (Bit 0)
  317.                         Plane 3 = 1 (Bit 2)
  318.  
  319. Es wird also Color1 und Color3 des Playfield1 betrachtet.
  320.  
  321. Für die  Erkennung  wird  dann wie  immer ein Bit in CLXDAT  verwendet. In 
  322. diesem Fall handelt es sich  um das Bit 0.  Wenn  es auf 1 steht, dann hat 
  323. eine Kollision stattgefunden, ansonsten nicht.
  324.  
  325.