;====================================
;
;            DARK FORCE
;            ----------          
; Game Design, Graphics and SFX by
;
;  Richard Bayliss and Alf Yngve
;
;  Music arranged and composed by
;
;           RICHARD BAYLISS
;
; COPYRIGHT (C)2014 THE NEW DIMENSION
;=====================================

;DARK-FORCE by Richard Bayliss
;(C)2014 THE NEW DIMENSION
;-------------------------------------

;Variables:
GenAmount = 20  ;Total number of generators to be 
                ;destroyed.
          

MusicInit = $8800 ;Initialize music from relocated tune
MusicPlay = $8803 ;Play music from relocated tune.
 
            !to "darkforce.prg",cbm ;Target filename    

;Use VIC BANK 3, screen RAM data at $0400 to
;install the full enhancements into the split
;up raw SEUCK game files. (Using EXOMIZER or 
;PUCRUNCH, set JUMP address at $0400.


      ;ONE TIME RUN ... Always execute at $0400 
      ;at run of main program. 
      
      ;exomizer sfx $9d00 darkforcce.prg -o darkforce.prg -n
      ;
      ; or 
      ;
      ;pucrunch darkforce.prg -s darkforce.prg -x $9d00
      ;
      ; or use a native C64 packer which can pack up to $0400-$ffff
      ; and does not use a depacker inside the $0400-$07e8 memory.
      
      *=$0400  
      sei
      lda #0
      sta 16964 ;Disable SEUCK editor (POKE 16964)
      lda #2
      sta 16578 ;Bolt 2 player to one joystick control
      
      lda #$35  ;Disable KERNAL ROM for being able to
      sta $01   ;use $e000-$fffa
      
      ;Sometimes in a SEUCK game, with enhancements
      ;the status panel gets inverted. We need to
      ;reverse the status panel back to its normal
      ;state, when initializing the game. 
      
      ;Inverting charset data is called by setting
      ;itself with EOR #$ff and storing it back
      ;by itself.
      
      ldx #$00  
InvertStatus
      lda $f400,x
      eor #$ff
      sta $f400,x
      lda $f500,x
      eor #$ff
      sta $f500,x
      inx
      bne InvertStatus
      
      lda #$37  ;Switch KERNAL back on (if you need to).
      sta $01
      
      lda #4    ;Starting amount of lives.
      sta $40ad ;- for player 1
      sta $40c0 ;- for player 2
      
      lda #<store ;Store low/hi bits of the total value of the
      ldx #>store ;total score into the score display code.
      sta $5a2a
      stx $5a2b
                      
      
      ;Force the old title screen to jump directly to the
      ;brand new title screen, by skipping the standard
      ;SEUCK title code, and executing the new routines
      ;instead.
      
      ;This is done by storing the value of #$4c (JMP)
      ;and the low-hi bytes of the Front End code into
      ;what used to be to set the BORDER colour ($D020) in 
      ;$40dd.
      
      
      lda #$4c 
      ldx #<.FrontEnd
      ldy #>.FrontEnd
      sta $40dd
      stx $40de
      sty $40df
   
      ;Where the game normally loops, after completion of 
      ;the game. Replace the game loop/restart with a JMP 
      ;.EndScreen2 prompt. So instead of looping, the game 
      ;will execute the game ending code. 
      
      ;Dark Force has 2 endings. This one is for when the
      ;player has failed to destroy all 20 generators, and 
      ;the game is over.
      
      lda #$4c
      ldx #<.EndScreen2
      ldy #>.EndScreen2
      sta $47a1
      stx $47a2
      sty $47a3

      ;Where the original SFX player is stored, replace the
      ;SFX player, with an additional routine for playing
      ;new in game subroutines (as well as sounds). This is 
      ;done by storing the low + hi bytes of the in game 
      ;enhancement code. (.InGameLoop). 
      
      lda #<.InGameLoop
      ldx #>.InGameLoop
      ldy #$20
      sty $4503
      sta $4504
      stx $4505
      
      ;Where  player 1 loses a life, instead of exploding
      ;one player we want to explode both. A new JSR (LDA #$20)
      ;needs to be stored into the original player life lost code.
      ;This is so that we have both players killed at the same time.
      ;This will also trigger a deadly background trick on the
      ;second player, and make the linked ship explode in one go.
      
      lda #$20
      ldx #<.LifeLostEnhancement
      ldy #>.LifeLostEnhancement
      sta $4b0f
      stx $4b10
      sty $4b11
      
      
      ;Where  player 2 loses a life, instead of exploding
      ;one player we want to explode both. A new JSR (LDA #$20)
      ;needs to be stored into the original player life lost code.
      ;This is so that we have both players killed at the same time.
      ;This will also trigger a deadly background trick on the
      ;second player, and make the linked ship explode in one go.
      
      
      lda #$20
      ldx #<.LifeLostEnhancement2
      ldy #>.LifeLostEnhancement2
      sta $4e1e
      stx $4e1f
      sty $4e20
      
      ;Where player 1 respawns. Set the low-hi bytes to an additional
      ;subroutine to JSR .DefaultPlayer(x). Where both players respawn at
      ;the same time. Also disable the deadly background trick, and restore
      ;the settings of sprite/char collision.
      
      lda #$20
      ldx #<.DefaultPlayer2
      ldy #>.DefaultPlayer2
      sta $4e7c
      stx $4e7d
      sty $4e7e
            
      ;Where player 2 respawns. Set the low-hi bytes to an additional
      ;subroutine to JSR .DefaultPlayer(x). Where both players respawn at
      ;the same time. Also disable the deadly background trick, and restore
      ;the settings of sprite/char collision.
      
      lda #$20 
      
      ldx #<.DefaultPlayer1
      ldy #>.DefaultPlayer1
      sta $4b6c
      stx $4b6d
      sty $4b6e
      
      ;After the last life has been lost, instead of waiting for the 
      ;screen delay to finish. This next subroutine will make the 
      ;game jump directly to the GAME OVER screen.
      
      lda #$4c
      sta $42bf
      lda #<.GameOver
      sta $42c0
      lda #>.GameOver
      sta $42c1
      
      ;Default sounds in the game is going to be set as MUSIC, so 
      ;BIT out (LDA #$2C) the sound effects voices to make them 
      ;not interfere with the in game music.
      
      lda #$2c
      sta $5c0d
      sta $5c10
      sta $5c13
      sta $5c18
      sta $5c24
      sta $5c27
      sta $5c2a
      sta $5c2f
      sta $5c52
      sta $5c55
      sta $5c58
      
      ;Force low-hi byte of the address .ObjectHit into the enemy 
      ;killed subroutine (JSR .ObjectHit). This will link the
      ;code, which will detect which enemy object has been killed,
      ;in order to generate some effects. This method can also be 
      ;used for other tricks, such as power ups. Darkforce has no 
      ;need for power ups, so instead this is being used for the 
      ;Generators counter.
      
      lda #$20
      sta $55c3
      lda #<.ObjectHit
      sta $55c4
      lda #>.ObjectHit
      sta $55c5
      
      ;Fix the common SEUCK scoring bug, by jumping to the
      ;FixScoring routine. This will allow the correct player 
      ;to own the correct score. 
      
      lda #$4c
      ldx #<FixScoring
      ldy #>FixScoring
      sta $54a2
      stx $54a3
      sty $54a4
  
      ;Setup the new position of player 1 and player 2's score panel.
      ;NOTE: A table is required to do this. 
      
      ldx #$00  
.CentrePlot lda .PlotTable,x
      sta $5eaf,x
      lda #$55
      sta $5eb7,x
      
      inx
      cpx #$09
      bne .CentrePlot 
      
      ;Finished the one-time routine, so now EXECUTE to the main game.
      
      jmp $4245


;Linked explosions routine.

.DestroyAll
                 lda #$0a         ;Set the value of the linked explosion
                 sta ExplodeTimer ;counter, in order to produce a smart bomb
                 ;lda #$00        ;feature.
                 ;sta FlashPTR
                 lda $bd06,y
                 
                 rts
                 
.PlotTable    !byte $03,$89,$07,$a1,$07,$b9,$07,$d1,$07,$d9

;Fix player 1's score and player 2 score so 
;that the scoring bug doesn't occur (One player 
;kills and object, and the opponent scored)     

FixScoring

  sta $5dbb
  lda #$00
  sta $09
  jmp $54a5
  
;Level colour settings. Accoring to the level value * 7
  
FixLevelSetup
  ;inc $d020
 
  ldx $5dc9 ;Read current level from SEUCK set level parameters, and multiply value by 7
            ;SEUCK uses 22 levels in total 
            
  cpx #2*7  ;Level 2?
  beq .SetGreen ;Make green background scheme
  cpx #3*7  ;Level 3?
  beq .SetBlue  ;Make blue background scheme
  cpx #7*7  ;Level 7?
  beq .SetBrownWhite ;Make brown background scheme
  cpx #14*7 ;Level 14?
  beq .SetRedPink   ;Make red background scheme
  cpx #17*7 ;Level 17?
  beq .SetGrey      ;Make grey background scheme
  cpx #20*7 ;Level 20?
  beq .FlashLaser   ;If ending, make lazer flash  
  
  cpx #21*7 ;Level 21?
  beq .FlashLaser   ;If ending make laser flash 
  cpx #22*7 ;Level 22?
  beq .FlashLaser   ;If ending make laser flash
  cpx #23*7 ;Level 23? - Actually it is level 22
  beq .FlashLaser   ;If ending make laser flash
  rts
  
  
;Set the background colour scheme for each level 
;chosen.
  
.SetGreen ;Green + light green scheme
  lda #$05  ;BG colour 2 - green
  ldx #$0d  ;BG colour 3 - light green
  sta $d022 ;BG colour 2 - stored 
  stx $d023 ;BG colour 3 - stored
  rts
  
.SetBlue  ;Blue + light blue scheme
  lda #$06  ;BG colour 2 - blue
  ldx #$0e  ;BG colour 3 - light blue
  sta $d022 ;BG colour 2 - stored 
  stx $d023 ;BG colour 3 - stored
  rts
  
.SetBrownWhite  ;Brown + green scheme
  lda #$09  ;BG colour 2 - brown
  ldx #$05  ;BG colour 3 - green 
  sta $d022 ;BG colour 2 - stored  
  stx $d023 ;BG colour 3 - stored
  rts
  
.SetRedPink ;Red+Pink scheme
  lda #$02  ;BG colour 2 - red  
  ldx #$0a  ;BG colour 3 - pink
  sta $d022 ;BG colour 2 - stored 
  stx $d023 ;BG colour 3 - stored
  rts
  
.SetGrey    ;Grey scheme
  lda #$0b  ;BG colour 2 - dark grey
  ldx #$0c  ;BG colour 3 - medium grey
  sta $d022 ;BG Colour 2 - stored
  stx $d023 ;BG Colour 3 - stored
  rts
  
.FlashLaser 

;Flash laser gives out a flickering effect, to give
;the laser an effect. This uses the EOR values to  
;flash the backround colours of the laser firing.

  lda $d022
  eor #$04
  sta $d022
  lda $d023
  eor #$03
  sta $d023
  rts
  
  
;Import the first segment of the finished SEUCK game data from $0900 - $6580

      *=$0900
      !bin "DARK08A.prg",,2

;Initialize the game. This is always activated when called from
;the GET READY screen. 
      
      *=$6580
.InitGameTune lda #$00
      jsr MusicInit   ;Initialise music for in game
      jsr .Fix1       ;Fix player 1 position
      jsr .Fix2       ;Fix player 2 position
      jsr .InitPlayerStartPositions

;Initialise the player starting positions
;according to the SEUCK starting positions 
;you originally set in the SEUCK game. 
.InitPlayerStartPositions

      ;When initialising each player, allow the player 
      ;to move around everywhere, by disabling the DIE 
      ;command, and setting the collision char value as 
      ;255.
      
      lda #$00  ;Player 2 Die/Stop = Stop 
      sta $40be
      
      lda #255  ;Player 2 collision with character
      sta $40bf
      
      lda #$00  ;Player 1 Die/Stop = Stop
      sta $40ab
      lda #255  ;Player 1 collision with character
      sta $40ac
      
      ;Default player positions. In order
      ;to work out the X, XMSB and Y values of 
      ;the player's position. You will need to use a
      ;M/C monitor. Simply by using:

;M 40a3
;M 40a4
;M 40a5
;... etc.
      
      ;Initialized start positions for player 1
      
      lda #$92  ;Player 1 X-Start position
      sta $40a3 ;Store to player 1 X start position
      lda #$00  ;Player 1 X-MSB Start position 
      sta $40a4 ;Store to player 1 X MSB start position
      lda #$e5  ;Player 1 Y-Start Position
      sta $40a5 ;Store to player 1 Y start position
      
      lda #$00  ;Player 1 stop
      sta $40ab ;Store to player 1 stop / die parameters
      lda #255  ;Player 1 collision with character
      sta $40ac ;Store to player 1 collision character
      
      ;Initialized start positions for player 2
      
      lda #$aa  ;Player 2 X-Start position
      sta $40b6 ;Store to player 2 X-start position
      lda #$00  ;Player 2 X-MSB Start Position
      sta $40b7 ;Store to player 2  X-MSB start position
      lda #$e5  ;Player 2 Y-Start Position
      sta $40b8 ;Store to player 2 Y-start position
      
      lda #$00      ;Tune NO.0 - In game music  
      jsr MusicInit ;Initialise music 
      
      ldx #$00  ;Silence the SID chip, using a loop 
.SilenceChip    ;that zero fills all SID registers
      lda #$00  ;between $d400-$d418.
      sta $d400,x
      inx
      cpx #$18
      bne .SilenceChip
      
      jmp $41a4 ;SEUCK title screen exit routine ... Inits game start.
      
;This is the LIFE LOST enhancement, which will trigger an effect
;on both players. It stores the player death routine, and also
;will trigger a deadly sprite/background collision, so that both
;players die simultaneously.
      
.LifeLostEnhancement
  
      sta $5dbf       ;Store player 1's death routine.
      lda #$00        ;Set deadly char value for sprite/background.
      sta $40bf       ;collision for player 2.
      lda #$01        ;Set STOP/DIE for player 2 to DIE ...
      sta $40be       ;and store it.
      
      rts
      
.LifeLostEnhancement2

      sta $5dc0       ;Store player 2's death routine.
      lda #$00        ;Set deadly char value for sprite/background.
      sta $40ac       ;collision for player 1.
      lda #$01        ;Set STOP/DIE for player 1 to DIE ...
      sta $40ab       ;and store it.
      rts   

      
;Players lose a life, so positions are reset 
      
.DefaultPlayer1
      sta $5db7 ;This is where lives are lost for player 1
  
.Fix1
      lda #$00        ;Set STOP/DIE for player 1 to STOP ...
      sta $40ab       ;and store it.
      lda #255        ;Set player 1 collision with char to 255, so
      sta $40ac       ;that the player has free movement when alive.
      lda $40a4       ;Load default X starting position of player 1
      sta $bc01       ;and force it to actual X position
      lda $40a5       ;Load default XMSB starting position of player 1
      sta $bc02       ;and force it to actual XMSB position
      lda $40a6       ;Load default Y starting position of player 1
      sta $bc03       ;and force it to actual Y position
      
        ;Initialized start positions for player 1
      
      rts
      
.DefaultPlayer2
    sta $5db8 ;This is where lives are lost for player 2
   
.Fix2
      lda #$00        ;Set STOP/DIE for player 2 tio stop ...
      sta $40be       ;and store it.
      lda #255        ;Set player 2 collision with char to 255, so
      sta $40bf       ;that the player has free movement when alive.
      lda $40b6       ;Load default X starting position of player 2
      sta $bc31       ;and force it to actual X position
      lda $40b7       ;Load default XMSB starting position of player 2
      sta $bc32       ;and force it to actual YMSB position
      lda $40b8       ;Load default Y starting position of player 2
      sta $bc33       ;and force it to actual Y position
      rts
      
;The main in game loop, which is linked to where the subroutine used
;to play in game sound effects.
      
.InGameLoop      lda $5db7  ;Share the lives of player 1 and
                 sta $5db8  ;give to player 2.
                 lda $5db7  ;Check amount of lives, for player 1 to
                 cmp #$00   ;see if LIVES = 0.
                 beq GameLost ;Game over
                 
                 ;The game is not over so ...
                 jsr .BackgroundAnim ;Call subroutine to animate background
                 jsr .BorrowScore    ;Call subroutine to share score 
                 jsr .FixPositionsXY ;Call subroutine to fix X+Y position of player
                 jsr FixLevelSetup   ;Call subroutine to check colour scheme
.SoundPlayer     jsr MusicPlay       ;Selfmod music or sfx player
                 rts                 ;end of loop subroutine.
      
GameLost         jmp .GameOver       ;Jump to the Game Over subroutine

;Fix player position, so that it is stuck together all the time

;.FixPositionsXY is a calculation subroutine, which will constantly
;bolt both player 1 and player 2 together permanently, in order to
;make a really big ship. The subroutine places the actual Y position
;of player 2, to where player 1 is. Also the X position has to be 
;moved $18 bytes in order for player 2's ship to be connected to
;player 1 properly.

.FixPositionsXY

            lda $bc01     ;Load actual X position of player 1.
            clc           ;add $18 bytes (For the linked ship
            adc #$18      ;trick).
            sta $bc31     ;Store it to player 2's actual X position
            lda $bc03     ;Load actual Y position of player 1.
            sta $bc33     ;Store player 2 on the same Y position.
            rts
            
; Score sharing routine. Which will share both player 1's score 
; and player 2's score. Add it all together and give out an overall
; calculation.            

.BorrowScore   
         
           lda #0         ;Initialise borrow pointer
           sta borrow
           ldx #$05       ;Loop to call 6 digits of the score object 
calc1      lda score1,x   ;Pick up player one's score 
           clc            ;Calculate
           adc score2,x   ;Also add player 2's score with player 1
           clc            ;Calculate
           adc borrow     ;Add to borrow
           ldy #0         ;Init borrow again
           sty borrow
           and #$1f       
           cmp #$0a       ;Check if digit is over 10
           bcc noborrow   ;else, don't add 1 to borrow.
           inc borrow     ;Increase pointer, borrow by 1
           sec            ;
           sbc #$0a       ;Subtract 10.
          ; ora #$30
noborrow   sta result,x   ;Store the result of the overall score
           dex            ;Else keep on with the calculation.
           bpl calc1
           
           ldx #$00       ;Otherwise clear the table

           
           ldx #$05
           lda #$00
calc0      sta borrow,x   
           dex
           bpl calc0
           ldx #$00
calc2      lda result,x   ;Then put the result into the
           sta store,x    ;actual score panel sprites.
           inx
           cpx #$06
           bne calc2

           rts           

;This next subroutine will animate the background, simply by
;picking certain chars and rolling those downwards.            
           
.BackgroundAnim
                 lda .scrDelay    ;Delay of the single char scroll
                 cmp #3           ;is set to 3. If not then wait
                 beq .slowEnough  ;a bit more, and add 1 to the 
                 inc .scrDelay    ;pointer .scrDelay.
                 rts
.slowEnough      lda #0           ;Reset the delay of the colour 
                 sta .scrDelay    ;roll.
                 
                 ;A C64 character consists of 8 bytes in total. 
                 ;If you wanted to scroll a byte up / down, you would
                 ;need to but all 8 bits inside a loop.
                 
                 lda $fa30+7      ;Last value of the 8-byte character 
                 sta $9ff0        ;position. Gets stored to a temp byte 1
                 lda $fb20+7      ;Same as above, but with a different
                 sta $9ff1        ;character ...
                 lda $fb28+7      ;
                 sta $9ff2        ;Same here ... Etc.!
                 lda $fb30+7
                 sta $9ff3
                 lda $fbc0+7
                 sta $9ff4
                 
;Scroll the 8-byte of the character downwards inside a
;loop.
                 ldx #7        ;Start counter with X
.scrChar         lda $fa30-1,x ;Always use -1 to roll chars downwards
                 sta $fa30,x   ;then store to the next byte of each character
                 lda $fb20-1,x
                 sta $fb20,x
                 lda $fb28-1,x
                 sta $fb28,x
                 lda $fb30-1,x
                 sta $fb30,x
                 lda $fbc0-1,x
                 sta $fbc0,x
                 dex            ;Subtract a byte
                 bpl .scrChar   ;Not = 0 yet, loop .scrChar
                 lda $9ff0      ;Load tempbyte1
                 
                 sta $fa30      ;Store to first byte of char
                 lda $9ff1      ;Load tempbyte2
                 sta $fb20      ;Store to second byte of char 
                 lda $9ff2      ;... etc ...
                 sta $fb28
                 lda $9ff3
                 sta $fb30
                 lda $9ff4
                 sta $fbc0
                 rts
                 
;Some quick variables to represent the object values (not enemy values), which 
;represent the generator object (The goal of the game is to
;simply destroy them all in order to save the universe from
;catastrophe).
                 
Generator1 = 46 ;Object (not enemy) value for generator 1
Generator2 = 47 ;Object value for generator 2
Generator3 = 48 ;Object value for generator 3

;This subroutine will check for which object has been hit.
;If an object is either of the generators, the code should
;add 1 to the amount of generators destroyed.

.ObjectHit     
                 lda $bc00,y          ;Load actual object hit
                 sta ObjectDestroyed  ;store to pointer ObjectDestroyed
                 lda ObjectDestroyed  ;load the pointer ObjectDestroyed 
                 
                 cmp #Generator1      ;Was object Generator1? 
                 beq .AddGen          ;call .AddGen to add 1 to generator counter
                 cmp #Generator2      ;Was object Generator2?
                 beq .AddGen          ;call .AddGen to add 1 to generator counter
                 cmp #Generator3      ;Was object Generator3?
                 beq .AddGen          ;call .AddGen to add 1 to generator counter
                 lda $bd06,y          ;Load back the object pointers
                 rts
                 
;Generators are hit, so add 1 to the amount of generators 
;that have been destroyed. 
                 
.AddGen          inc GeneratorsToDestroy  ;Add amount of generators to be destroyed
                 inc GeneratorsDestroyed  ;Add amount of generators that have been destroyed
                 lda GeneratorsToDestroy  ;Load amount of generators to be destroyed
                 cmp #GenAmount           ;does amount add up to total value GenAmount = 20?
                 beq .AllGeneratorsDestroyed ;Yes ... Skip to all .GeneratorsDestroyed subroutine
                 
;Check for 6 generators destroyed? If 6 are destroyed
;the player gains an extra life.
                 
                 lda GeneratorsDestroyed ;Load amount of generators destroyed
                 cmp #$06                ;Have 6 been destroyed?
                 beq .AwardExtraLife     ;Yes, call subroutine to award extralife
                 lda $bd06,y             ;No. Just load back object pointers and exit routine
                 rts
                 
.AwardExtraLife  inc $5db7               ;Add 1 value to player 1's lives counter
                 lda #$00                ;Reset the number of GeneratorsDestroyed
                 sta GeneratorsDestroyed ;before next extra life can be awarded.
                 lda $bd06,y             ;Load back object pointers
                 rts
                 
;All generatores have been destroyed, so now, execute the happy 
;ending subroutine. Where the screen flashes and explodes the 
;alien complex.
                 
.AllGeneratorsDestroyed
                 lda $bd06,y              ;Finish object check
                 jmp .EndScreen1          ;Execute the happy ending.
                 
                 
;In game pointers ... Loads of them ;)                 
                 
ObjectDestroyed !byte $00       ;Pointer to check which object value is destroyed
GeneratorsDestroyed !byte $00   ;Counter for amount of generators destroyed for extra life
GeneratorsToDestroy !byte $00   ;Counter for how many generators to destroy to complete the game

score1 = $5ea3                  ;Player 1's score data
score2 = $5ea9                  ;Player 2's score data
ExplodeTimer !byte 0            ;Explosion pointer
.scrDelay !byte 0               ;Delay for 8-byte background char scroll
.scrPointer !byte 0             ;Counter for 8-byte background char scroll

;Pointers to represent score values for the score sharing subroutine

borrow !byte 0,0,0,0,0,0    
result !byte 0,0,0,0,0,0
store  !byte 0,0,0,0,0,0    
      
tempScore   !byte 0,0,0,0,0,0 ;We will be using the
            ;temp score for the
      

Sync !byte 0  ;Synchronized timer for the title screen, and other
              ;bits.
              
animpointer      !byte 0  ;Animation pointer

objectHit   !byte 0       ;Pointer for which object has been it
  
explodeColourDelay !byte 0  ;Explosion colour delay pointer
explodeColourTimer !byte 0  ;Explosion actual colour pointer
        
                  ;Explosion colour table.
explodeColours    !byte $0b,$0c,$0f,$07,$01,$07,$0f,$0c,$0b,$0f,$0f,$0f,$0f,$0f,$0f,$0f 
                  !byte 0

                  ;Import / link main front end code. The whole front end 
                  ;code is in 'frontend.asm'
                  *=$6800
                  !source "frontend.asm"
    
                  ;Import / link custom title screen character set. Make 
                  ;sure your character set is NOT more than 3 blocks otherwise
                  ;you may need to trim the char or use a different free 
                  ;memory location for the charset. If you do, the value of
                  ;the charset and VIC2 BANK memory may need to be altered.
                  ;SCREEN RAM $7c00-$7fe8 in VIC BANK #$02 is being used for
                  ;the front end graphics. 
                  
                  *=$7800
                  !bin "charset.prg",,2
                  

                  
                  ;Import logo colour RAM data. Do not overflow memory
                  *=$8000
                  !bin "dfcolram.prg",,2
                  
                  ;Import logo video RAM data. Do not overflow memory
                  *=$8400
                  !bin "dfvidram.prg",,2
   
                  ;Import title music (Composed from Goat Tracker)
                  *=$8800
                  !bin "dfmus.prg",,2
                  
                  ;Link end code for the game ending. The end code is based
                  ;in 'endcode.asm'.
                  *=$9a00
                  !source "endcode.asm"
    
                  
                  ;Import bitmap data of logo into higher memory.
                  *=$a000
                  !bin "newdfbitmap.prg",,2
                  
                  ;Some space available for a scroll text. So here
                  ;it is. Write any odd bunf if you want. :)
                  *=$ac00
   
ScrollText

   !ct scr ;Turn text into C64 screencodes
   
   !text " ... it is the year 2173, the entire solar system is under threat from "
   !text "an intergalactic alien race, the cygons ...   they are planning a huge "
   !text "attack against all planets of the solar system ...   to make matters wo"
   !text "rse, they have brought out a huge atomic laser beam, and threaten to us"
   !text "e it on all the planets of the solar system, via reflectors ...   if th"
   !text "is laser gets fired, the planet will get destroyed ...   you have been "
   !text "assigned as a fearless pilot of the 'dark force' supercraft ...   it's "
   !text "big, it's cool and it is very powerful ...   you enter the ship, begin "
   !text "to take off and you make it into space, ready for a huge battle against"
   !text " the cygons ...   during your mission, you must battle through space an"
   !text "d other enemy planets - fighting your way against the enemies ...   you"
   !text " must also destroy all 20 of the generators, which contain the energy of"
   !text " the huge laser beam ...   destroying six generators will give you an extra ship ...   can you destroy them all, or will the cygons"
   !text " be too tough for you ...   good luck pilot, you need it! ...    - dark"
   !text " force - special edition - is a s.e.u.c.k tribute to hewson's awesome game 'light force' "
   !text " by faster than light...   created using the shoot 'em up construction kit, a tool written by jon hare and chris yates of sensible software ...   game design by rich"
   !text "ard bayliss and alf yngve ...   front end and enhancements programming "
   !text "were done by richard bayliss ...   dark force logo and loading picture was painted by johan "
   !text "'jsl' janssen ...   finally the awesome music was arranged and composed "
   !text "by richard bayliss ...   - check out http://tnd64.unikat.sk/darkforce.html for the game data and source - ...   "
   !text "huge thank you to everyone involved ...   use joystick in port 2 ...   press fire to play! ...       "
   !byte 0  ;Scroll reset marker.
   
;The still text. The 6 lines below indicates the text for the BAD ending. Basically
;if the laser is fired from the laser cannon, the mission is failed.

EndFailText1           !text "               mission failed           "
EndFailText2           !text " you did not shoot enough generators to "
EndFailText3           !text "  save all planets of the solar system  "
EndFailText4           !text " the laser was activated by the cygons. "
EndFailText5           !text "all planets of the solar system are gone"
EndFailText6           !text "                 game over              "

;The still text. The 6 lines below indicate the happy ending for Dark Force. The
;players destroyed all of the generators that appeared on screen and saved the
;universe, and everything. Wahey :)

EndPassText1           !text "              congratulations           "
EndPassText2           !text "   all generators have been destroyed   "
EndPassText3           !text "  the laser didn't work, and the cygons "
EndPassText4           !text "           finally admit defeat.        "
EndPassText5           !text "       peace has now been restored.     "
EndPassText6           !text "         press fire to continue         "
GetReadyText1          !text "        prepare to kick cygon butt      "
GetReadyText2          !text "           get ready for action         "
GetReadyText3          !text "      press fire to commence battle     "

;The next 3 lines are the game over text. 

GameOverText1          !text "      dark force has been wiped out     "
GameOverText2          !text "   and so has the entire solar system   "
GameOverText3          !text "                 game over              "

;Also the final score output. We make FinalScore as a self-mod text 
;label in order for new scores to be added.

FinalScoreMess         !text "       your final score was: "
FinalScore             !text "000000     "

;Self-mod text variable PlayerName for hi-score entry.

PlayerName             !text "abcdefghi"

;No hi-score achieved message.

HiFailMessage1         !text "        sorry, but not a high score     "
HiFailMessage2         !text "          press fire to continue        "

;Hi-score achieved message
HiPassMessage1         !text "  well done, you are one of the top 3!  "
HiPassMessage2         !text "         please enter your name.        "

                       ;Second bulk segment of the SEUCK file data. Basically SEUCK
                       ;game sprites, graphics and other bits of data which is very
                       ;important for the SEUCK game.
                       
                       *=$b6c0  
                       !bin "dark08b.prg",,2
      
;Finished.