591 lines
21 KiB
PHP
591 lines
21 KiB
PHP
;-----------------------------------------------------------------------------
|
|
; edit.inc
|
|
; Part of penetrator, the zx spectrum game, made for Apple II
|
|
;
|
|
; Stefan Wessels, 2019
|
|
; This is free and unencumbered software released into the public domain.
|
|
|
|
;-----------------------------------------------------------------------------
|
|
.segment "CODE"
|
|
|
|
;-----------------------------------------------------------------------------
|
|
.proc editLoop
|
|
|
|
jsr drawClearScreen ; make sure the screen is clear before adjusting the
|
|
|
|
jsr editInit
|
|
jsr editLoadStage
|
|
lda #2
|
|
sta updateHUD
|
|
|
|
loop:
|
|
jsr inputEdit
|
|
beq :+
|
|
jsr editHandleKeys
|
|
lda pause ; pause is quit flag in endit
|
|
beq :+
|
|
rts
|
|
:
|
|
clc
|
|
jsr terrainShow ; show terrain 1st because it collides with nothing
|
|
jsr drawEnemies ; enemies collide with nothing in edit mode
|
|
jsr editDrawCursor
|
|
lda updateHUD
|
|
beq :+
|
|
jsr uiShowEditLabels
|
|
:
|
|
jsr drawPresent ; flip layers 0/1 (bring backLayer to visible)
|
|
|
|
jmp loop
|
|
|
|
.endproc
|
|
|
|
;-----------------------------------------------------------------------------
|
|
.proc editHandleKeys
|
|
|
|
cmp #'6' ; 6 or bigger - not a stage command
|
|
bcs notnum
|
|
cmp #'1' ; less than 1 - not a stage command
|
|
bcc notnum
|
|
sbc #'1' ; stages are 0 based
|
|
sta stage
|
|
|
|
lda #AUDIO_UI_TICK ; make a sound
|
|
sta audioFrame
|
|
jsr serviceAudio
|
|
|
|
lda #0 ; reset where the buffers will start
|
|
sta bufferInsert
|
|
jsr drawClearScreen
|
|
jsr editLoadStage ; get the right stage at the right place
|
|
jmp uiShowEditLabels ; update the HUD
|
|
|
|
notnum:
|
|
cmp #$1b ; ESC key
|
|
bne notQuit
|
|
|
|
lda #AUDIO_UI_TICK ; make a sound
|
|
sta audioFrame
|
|
jsr serviceAudio
|
|
|
|
lda #1
|
|
sta pause ; abuse pause to signal quit
|
|
rts
|
|
|
|
notQuit:
|
|
cmp #'c' ; c or C for help
|
|
beq help
|
|
cmp #'C'
|
|
bne notHelp
|
|
|
|
help:
|
|
lda #AUDIO_UI_TICK ; make a sound
|
|
sta audioFrame
|
|
jsr serviceAudio
|
|
|
|
jmp uiShowEditHelp
|
|
|
|
notHelp:
|
|
cmp #'s' ; s or S for save
|
|
beq save
|
|
cmp #'S'
|
|
bne notSave
|
|
|
|
save:
|
|
lda #AUDIO_UI_TICK ; make a sound
|
|
sta audioFrame
|
|
jsr serviceAudio
|
|
|
|
lda #0 ; a 0 is save
|
|
jsr uiFileLoadSave
|
|
jmp editLoop
|
|
|
|
notSave:
|
|
cmp #'l' ; l or L for load
|
|
beq load
|
|
cmp #'L'
|
|
bne done
|
|
|
|
load:
|
|
lda #AUDIO_UI_TICK ; make a sound
|
|
sta audioFrame
|
|
jsr serviceAudio
|
|
|
|
lda #1 ; a 1 is load
|
|
jsr uiFileLoadSave
|
|
jmp editLoop
|
|
|
|
done:
|
|
clc
|
|
rts
|
|
|
|
.endproc
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Move the world left (feels like YOU are moving right)
|
|
; will update the stage when a stage boundary is crossed and will then
|
|
; update the HUD
|
|
.proc editGameWorldRight
|
|
|
|
zaWorldPtr = tempBlock + 14 ; 2 bytes for a ptr
|
|
|
|
lda stage ; only scroll right while the stage
|
|
cmp #4 ; isn't 5 (0 based so 4). Stage 5
|
|
bcc :+ ; cannot be edited
|
|
rts
|
|
:
|
|
jsr gameWorldMove ; use the game move code
|
|
|
|
lda zWorldPtr + 1 ; but then calculate a point where the stage marker might be
|
|
sta zaWorldPtr + 1
|
|
lda zWorldPtr
|
|
sec
|
|
sbc #((XSIZE+3)*3)
|
|
sta zaWorldPtr
|
|
bcs :+
|
|
dec zaWorldPtr + 1
|
|
|
|
:
|
|
ldy #2 ; and read the enemy byte
|
|
lda (zaWorldPtr), y
|
|
bit Bit7Mask ; and see if this is a stage change
|
|
beq :+
|
|
inc stage ; bit was set so change stage
|
|
lda #2 ; and update the HUD
|
|
sta updateHUD
|
|
:
|
|
inc bufferDraw ; the bufferDraw (col 0) is also one more to the right
|
|
rts
|
|
|
|
.endproc
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Scroll to the left, updating the stage boundary and adding enemies as needed.
|
|
.proc editGameWorldLeft
|
|
|
|
leftWorldPtr = tempBlock + 14
|
|
|
|
lda zWorldPtr + 1 ; get the left edge insert point by subtracting
|
|
sta leftWorldPtr + 1 ; XSIZE+3 from the right edge. XSIZE-1 is the current
|
|
lda zWorldPtr ; left screen col. +3 is 4 past, which is the width
|
|
sec ; of a radar that could now scroll on-screen
|
|
sbc #((XSIZE+3)*3) ; the buffer will have proper height data for at least
|
|
sta leftWorldPtr ; 2 of these 3 cols to the left - see editLoadStage
|
|
bcs :+
|
|
dec leftWorldPtr + 1
|
|
|
|
:
|
|
lda leftWorldPtr + 1 ; see if this new dest is <= the world start.
|
|
cmp #>worldDataStart ; if it is then don't scroll any further left, just exit
|
|
beq :+ ; hi equal to worldStart hi, so test low
|
|
bcs leftOk ; hi > worldStart hi so good to go
|
|
done:
|
|
rts
|
|
:
|
|
lda leftWorldPtr
|
|
cmp #<worldDataStart
|
|
bcc done ; lo < lo - too small, no go
|
|
beq done ; lo equal so also no go
|
|
|
|
leftOk:
|
|
lda zWorldPtr ; there's room to go left so move the right edge left
|
|
sec ; by 1 col, or one triplet of data, so 3 bytes
|
|
sbc #3
|
|
sta zWorldPtr
|
|
bcs :+
|
|
dec zWorldPtr + 1
|
|
:
|
|
dec bufferDraw ; adjust the draw and insert buffer "counters"
|
|
dec bufferInsert ; now points at the "new" screen locations
|
|
|
|
clc
|
|
ldx bufferDraw ; the bufferDraw is the left edge
|
|
dex ; back up 4 bytes (so 1 past where a radar
|
|
dex ; could be added) and write a 0 in there
|
|
dex ; to stomp any old circular buffer data
|
|
dex
|
|
lda #0
|
|
sta enemyBuffer, x
|
|
inx ; now move to the col where the heights will be added
|
|
|
|
ldy #0 ; get the world bottom
|
|
lda (leftWorldPtr), y
|
|
sta worldBBuffer, x ; and put it in the buffer
|
|
iny ; and get the world top
|
|
lda (leftWorldPtr), y
|
|
sta worldTBuffer, x ; and put it in the buffer
|
|
|
|
ldy #2 ; see if there's a radar to go with this height data
|
|
lda (leftWorldPtr), y ; get the enemy flag
|
|
bit Bit7Mask ; see if this is a stage change
|
|
beq radar ; no - check for radar
|
|
pha ; stage is changing so save a
|
|
dec stage ; dec the stage
|
|
lda #2 ; mark the HUD for update
|
|
sta updateHUD
|
|
pla ; restore a - could also hold a missile or radar
|
|
|
|
radar:
|
|
bit Bit2Mask ; is it a radar
|
|
beq missile ; no - go check for a missile
|
|
jmp gameWorldFlag ; add the radar - can't also be a missile so all done
|
|
|
|
missile:
|
|
inx ; the missile will start 2 cols later
|
|
inx
|
|
ldy #8 ; and is also 2 (past height)+(2*3) bytes later in the world
|
|
lda (leftWorldPtr), y ; get the enemy flag
|
|
bit Bit1Mask ; see if it's a missile
|
|
beq done ; if not a missile then done
|
|
jmp gameWorldFlag ; add the missile and finish
|
|
|
|
.endproc
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Prepare for editing by initializing the needed variables
|
|
.proc editInit
|
|
|
|
brushType = tempBlock + 16
|
|
|
|
lda #GAME_MODE_EDIT
|
|
sta gameMode
|
|
|
|
lda #0
|
|
sta brushType ; BRUSH_TERRAIN is also 0
|
|
sta direction ; go to the right
|
|
sta terrainOrigin ; don't scroll in, just be all there
|
|
sta zCollision
|
|
sta stopScrolling
|
|
sta bufferInsert
|
|
sta dangerTickIdx
|
|
sta pause
|
|
|
|
tax ; start at 0 for the buffers
|
|
:
|
|
sta worldBBuffer, x ; and init all 256 bytes of each buffer to 0
|
|
sta worldTBuffer, x
|
|
sta enemyBuffer, x
|
|
sta enemyHgtBuffer, x
|
|
sta explosionBuffer, x
|
|
sta bulletsBuffer, x
|
|
dex
|
|
bne :-
|
|
|
|
ldx #NUM_STAGES-1 ; mark all stages as all rockets, no monsters
|
|
:
|
|
sta makeMonster, x
|
|
dex
|
|
bpl :-
|
|
|
|
lda #$ff
|
|
sta lastInput ; set no keys down - all 1's
|
|
sta nextStage
|
|
|
|
lda #DANGER_TICKS
|
|
sta dangerTickCount
|
|
|
|
lda #(XSIZE/2) ; middle of the screen in X
|
|
sta playerShipX ; is where the cursor is
|
|
|
|
lda #(WORLD_START + (WORLD_END - WORLD_START) / 2)
|
|
sta playerShipY ; and in Y also in the middle
|
|
|
|
rts
|
|
|
|
.endproc
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Show a custom character as a cursor. Also redraw the down arrow
|
|
; since the cursor draws into the top 8 likes that don't get cleaned/updated
|
|
; with every frame. Drawing the arrow fixes up the out of bounds areas
|
|
.proc editDrawCursor
|
|
|
|
yPos = tempBlock + 14
|
|
xPos = tempBlock + 15
|
|
|
|
zaStrL = tempBlock + 1 ; parameter - string lo
|
|
zaStrH = tempBlock + 2 ; parameter - string hi
|
|
zaFontL = tempBlock + 4 ; internal - point at the character memory Lo
|
|
zaFontH = tempBlock + 5 ; internal - point at the character memory Hi
|
|
zaFontOffset = tempBlock + 6 ; 0-15 - index from zaFont
|
|
|
|
lda playerShipX
|
|
lsr
|
|
sta xPos
|
|
|
|
print textEditDnArrow, xPos, 0 ; redraw arrow to fix out of top cursor overwrite
|
|
|
|
lda #$87 ; cursor symbol
|
|
ldy #0
|
|
jsr setFont
|
|
|
|
lda playerShipY ; get the screen Y for cursor
|
|
sec ; but raise it so the horz bar is at the "ship" level
|
|
sbc #2
|
|
sta yPos ; init the row working buffer
|
|
ldx backLayer ; write to back layer
|
|
|
|
plotLoop:
|
|
ldy yPos ; at the working row offset
|
|
lda rowL, y ; get the memory address
|
|
clc
|
|
adc xPos ; add in column
|
|
sta write + 1 ; point lo at memory
|
|
lda rowH, y
|
|
adc layersH, x
|
|
sta write + 2
|
|
|
|
ldy zaFontOffset ; get the offset into the character
|
|
lda (zaFontL), y
|
|
|
|
write: ; get the actual left character byte
|
|
sta PLACEHOLDER ; plot the left hand side
|
|
cpy #$05 ; cursor character is 5 rows high
|
|
bcs done ; if 10 then done with the cursor
|
|
inc zaFontOffset ; move 2 bytes for last row plotted
|
|
inc zaFontOffset
|
|
inc yPos ; move down a row on screen
|
|
|
|
bne plotLoop ; always take this branch
|
|
|
|
done:
|
|
rts
|
|
|
|
.endproc
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Will set the terrain to the cursor, and will move enemies to be back
|
|
; on the terrain when needed. Will set both the draw buffers and the
|
|
; actual world data stream (the triplets)
|
|
.proc editSetTerrainBottom
|
|
|
|
zaColumn = tempBlock + 3
|
|
zaMidScreen = tempBlock + 4
|
|
|
|
lda zWorldPtr + 1 ; make a copy of the world pointer
|
|
sta zaMidScreen + 1 ; that corresponds with the position of the cursor
|
|
lda zWorldPtr
|
|
sec
|
|
sbc #((XSIZE/2)*3) ; 1/2 way in screen, 3 bytes per column
|
|
sta zaMidScreen
|
|
bcs :+
|
|
dec zaMidScreen + 1
|
|
|
|
:
|
|
ldy #3 ; index from ptr
|
|
lda playerShipY ; cursor height in playerShipY
|
|
sta (zaMidScreen), y ; store in the terrain bottom
|
|
|
|
lda bufferDraw ; now update the draw buffer
|
|
clc
|
|
adc playerShipX ; get to the correct column offset
|
|
tax ; save in x
|
|
lda playerShipY ; get the height
|
|
sta worldBBuffer, x ; update the buffer
|
|
lda enemyBuffer, x ; get the enemy flag
|
|
beq done ; no enemy - all done
|
|
bit Bit12Mask ; see if it's a radar or missile
|
|
beq done ; if bits 12 not set then not an enemy
|
|
ldy #2 ; assume a missile - 2 columns
|
|
and #%00001110 ; column and way to id enemy (10 is radar)
|
|
lsr ; move col to 1's position
|
|
lsr
|
|
bcc :+ ; if carry clear then this is a missile
|
|
ldy #4 ; a radar is 4 columns
|
|
:
|
|
sta zaColumn ; save the enemy column
|
|
txa ; get the screen column under the cursor (in the buffer)
|
|
sec
|
|
sbc zaColumn ; subtract the enemy column, giving the buffer column of the 1st enemy column
|
|
tax ; get the index into a
|
|
lda worldBBuffer, x ; get the world height
|
|
sec
|
|
sbc #1 ; and go 1 row higher (on top of ground)
|
|
:
|
|
sta enemyHgtBuffer, x ; write the world height to all
|
|
inx ; the columns of the enemy
|
|
dey
|
|
bne :-
|
|
|
|
done:
|
|
rts
|
|
|
|
.endproc
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Set the terrain top in the world data stream as well as the draw buffers
|
|
.proc editSetTerrainTop
|
|
|
|
zaMidScreen = tempBlock + 4
|
|
|
|
lda zWorldPtr + 1 ; make a ptr to the cursor
|
|
sta zaMidScreen + 1
|
|
lda zWorldPtr
|
|
sec
|
|
sbc #((XSIZE/2)*3)
|
|
sta zaMidScreen
|
|
bcs :+
|
|
dec zaMidScreen + 1
|
|
|
|
:
|
|
ldy #4 ; index from ptr
|
|
lda playerShipY
|
|
sta (zaMidScreen), y ; save the top in the world data
|
|
|
|
lda bufferDraw ; also update the draw buffer
|
|
clc
|
|
adc playerShipX
|
|
tax
|
|
lda playerShipY
|
|
sta worldTBuffer, x
|
|
|
|
rts
|
|
|
|
.endproc
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; This routine will "kill" enemies that overlap with the cursor column.
|
|
; the zaDrawSprWidth is 4 (radar) or 2 (missile) for the type of enemy
|
|
; for which room needs to be created
|
|
; Enemies are removed from the world stream and the draw buffers
|
|
.proc editPreSetEnemy
|
|
|
|
zaDrawSprWidth = tempBlock + 3 ; Parameter
|
|
zaMidScreenL = tempBlock + 5
|
|
zaMidScreenH = tempBlock + 6
|
|
|
|
lda zWorldPtr + 1 ; calculate an offset for the cursor
|
|
sta zaMidScreenH
|
|
lda zWorldPtr
|
|
sec
|
|
sbc #(((XSIZE/2)+2)*3)
|
|
sta zaMidScreenL
|
|
bcs :+
|
|
dec zaMidScreenH
|
|
|
|
:
|
|
lda #3 ; check 3 columns before the cursor as a 4 col
|
|
clc ; radar could start 3 col earlier and still overlap
|
|
adc zaDrawSprWidth ; and add the length of the enemy (4 for radar, 2 for missile)
|
|
tax ; put the number of cols to check in x
|
|
ldy #2 ; index off of ptr to point at enemy bytes
|
|
krl:
|
|
lda (zaMidScreenL), y ; get the enemy byte
|
|
bit Bit2Mask ; see if it's a radar
|
|
beq :+
|
|
and #%11111100 ; mask off the enemy bits (making it blank but keeping stage data)
|
|
sta (zaMidScreenL), y ; and save the "deleted" enemy
|
|
:
|
|
iny ; advance the offset by 3 to the next enemy byte
|
|
iny
|
|
iny
|
|
dex ; and one less column to do
|
|
bne krl ; repeat till all cols checked
|
|
|
|
lda #1 ; now do the exact same but for missiles
|
|
clc ; but start only 1 column before the cursor as
|
|
adc zaDrawSprWidth ; a missile that overlaps can only overlap from 1 col earlier
|
|
tax
|
|
ldy #8
|
|
kml:
|
|
lda (zaMidScreenL), y
|
|
bit Bit1Mask
|
|
beq :+
|
|
and #%11111100
|
|
sta (zaMidScreenL), y
|
|
:
|
|
iny
|
|
iny
|
|
iny
|
|
dex
|
|
bne kml
|
|
|
|
lda #(XSIZE/2) ; get the offset of the cursor into the buffers
|
|
clc
|
|
adc bufferDraw
|
|
sta zEnemyCol ; and put it in the "enemy column"
|
|
jsr gameKillEnemy ; and call the game kill to see if there's an enemy to destroy
|
|
|
|
rts
|
|
|
|
.endproc
|
|
|
|
;-----------------------------------------------------------------------------
|
|
.proc editSetRadar
|
|
|
|
zaDrawSprWidth = tempBlock + 3 ; Parameter
|
|
zaMidScreenL = tempBlock + 5
|
|
|
|
lda #4 ; need room for a radar so 4 cols
|
|
sta zaDrawSprWidth
|
|
jsr editPreSetEnemy ; delete any overlapping enemies
|
|
lda enemyHitType ; if set, then an enemy was deleted. Just exit
|
|
bmi :+
|
|
rts
|
|
|
|
:
|
|
ldy #11 ; no overlapping enemies. The offset in the world stream from the ptr
|
|
lda #2 ; and the radar type
|
|
ora (zaMidScreenL), y ; add it to whatever is there (stage marker)
|
|
sta (zaMidScreenL), y ; and save it
|
|
|
|
lda bufferDraw ; and also insert it into the draw buffers
|
|
clc
|
|
adc #(XSIZE/2)
|
|
tax
|
|
clc
|
|
lda #2
|
|
jsr gameWorldFlag
|
|
|
|
rts
|
|
.endproc
|
|
|
|
;-----------------------------------------------------------------------------
|
|
.proc editSetMissile
|
|
|
|
zaDrawSprWidth = tempBlock + 3 ; Parameter
|
|
zaMidScreenL = tempBlock + 5
|
|
|
|
lda #2 ; need room for a missile (so 2 cols)
|
|
sta zaDrawSprWidth
|
|
jsr editPreSetEnemy ; delete overlapping enemies from the world and draw buffers
|
|
lda enemyHitType ; if set, enemies were deleted so exit
|
|
bmi :+
|
|
rts
|
|
|
|
:
|
|
ldy #11 ; no overlapping enemies. The offset in the world stream from the ptr
|
|
lda #1 ; and the missile type
|
|
ora (zaMidScreenL), y ; add it to whatever is there (stage marker)
|
|
sta (zaMidScreenL), y ; and save it
|
|
|
|
lda bufferDraw ; also add the missile to the draw buffers
|
|
clc
|
|
adc #(XSIZE/2)
|
|
tax
|
|
clc
|
|
lda #1
|
|
jsr gameWorldFlag
|
|
|
|
rts
|
|
.endproc
|
|
|
|
;-----------------------------------------------------------------------------
|
|
.proc editLoadStage
|
|
|
|
jsr gameFindStage ; find the stage
|
|
|
|
lda #(XSIZE+2) ; scroll it on-screen but make sure there are
|
|
sta tempBlock + 1 ; extra cols of data in the buffers
|
|
:
|
|
jsr gameWorldMove ; populate the buffers
|
|
dec tempBlock + 1
|
|
bpl :-
|
|
|
|
lda #4 ; start the screen draw 2 cols more to the right than
|
|
sta bufferDraw ; there's buffer data for so a left scroll will work
|
|
|
|
rts
|
|
|
|
.endproc
|