;#SECTION "MAIN", CODE

MapBuffer equ   appBackUpScreen
VarBuffer equ   appData
CustomBlockBuffer equ   saveSScreen
PlayerX equ VarBuffer
PlayerY equ PlayerX + 1
ScrollX equ PlayerY + 1
ScrollY equ ScrollX + 1
BlkEditX equ ScrollY + 1
BlkEditY equ BlkEditX + 1
BlkEditPtr equ BlkEditY + 1
CurKey equ BlkEditPtr + 2
NeedRedraw equ CurKey + 1
CurBlk equ NeedRedraw + 1
AltBlk equ CurBlk + 1
JumpCounter equ AltBlk + 1
TMP equ JumpCounter + 1

    org userMem - 2
    db  0BBh, 6Dh
Start:
    B_CALL  _RunIndicOff
    B_CALL  _ClrLCDFull
    B_CALL  _GrBufClr

    ld  hl, MapBuffer         ; clear the map
    ld  bc, 768
    B_CALL  _MemClear

    ld  hl, VarBuffer         ; clear the space used for variables
    ld  bc, 256
    B_CALL  _MemClear

    ld  hl, plotSScreen + 9 ; make left edge of stats display
    ld  b, 64
    ld  a, 128
    call    PutVert

    ld  hl, plotSScreen + 11 + 12 * 16 ; make solid ground in minimap
    ld  b, 48
    ld  a, 1
    call    PutVert

    ld  hl, CustomBlockBuffer        ; clear out the custom block buffer
    ld  bc, 8 * 16
    B_CALL  _MemClear

; init vars
    ld  a, 2
    ld  (CurBlk), a       ; store 2 (lowest user-available block) to current block
    inc a
    ld  (AltBlk), a       ; store 3 as the alternate block

    ld  a, 8
    ld  (ScrollY), a
    ld  a, 15
    ld  (PlayerY), a

    ld  a, 1               ; make solid ground on map
    ld  hl, MapBuffer + 48 * 15
    ld  bc, 48
    B_CALL  _MemSet

    call    BDisp          ; render the screen
    call    SafeCopy       ; ... and display it!

    call    MainLoop       ; start main loop!
    cp  skYEqu             ; if the key used to exit was Y=, start program over
    jp  z, Start

    B_CALL  _ClrLCDFull    ; be nice and clear the screen when we're done
    B_CALL  _HomeUp
    ret

PutVert:                   ; makes a vertical column of A at DE, B rows tall
    push    de
    push    hl
    ld  de, 12
@:
    ld  (hl), a
    add hl, de
    djnz    @B
    pop hl
    pop de
    ret

PutVertI:                  ; makes a vertical column of (HL) at IX, B rows tall
    ld  de, 12
@:
    ld  a, (hl)
    ld  (ix + 0), a
    inc hl
    add ix, de
    djnz    @B
    ret

DelayB:                    ; simply delays for B interrupts
    ei
@:
    halt
    djnz    @B
    ret

;#SECTION "Game", CODE

MainLoop:
    ld  b, 6
    call    DelayB

    ld  de, (PlayerX)      ; player X -> E, player Y -> D
    call    GetB
    or  a
    push    af
    call    z, EraseMMP    ; if the player is occupying a blank tile, erase the minimap pixel
    pop af
    call    nz, Raise
    call    TryFall

    ld  a, (NeedRedraw)    ; redraw if redraw flag is on
    or  a
    call    nz, DrawAll

    B_CALL  _GetCSC        ; READ KEY
    or  a
    jq  z, MainLoop        ; no key pressed? TRY AGAIN

    cp  skClear            ; exiting with Clear actually exits, but Y= restarts
    ret z
    cp  skYEqu
    ret z

    ld  de, (PlayerX)
    push    af
    push    de
    call    GetMMPix
    cpl
    and (hl)
    ld  (hl), a
    pop de
    pop af
    ld  (CurKey), a
    cp  skLeft
    call    z, GoLeft
    ld  a, (CurKey)
    cp  skRight
    call    z, GoRight
    ld  a, (CurKey)
    cp  sk2nd
    call    z, TryJumpCounter

    push    de             ; upcoming chunk of code has nothing to do with the X and Y so save them

    ld  a, (CurKey)
    cp  skLParen
    call    z, BlkPrev

    ld  a, (CurKey)
    cp  skRParen
    call    z, BlkNext

    ld  a, (CurKey)
    cp  skComma
    call    z, BlkSwap

    ld  a, (CurKey)
    cp  skMath
    call    z, StartMenu

    ld  a, (CurKey)
    cp  skTan
    call    z, TanMenu

    pop de

    ld  a, d
    and 15
    ld  d, a
    ld  (PlayerX), de
    ld  a, (CurKey)
    cp  skSquare
    call    z, BlkLift
    ld  a, (CurKey)
    cp  skLog
    call    z, BlkSink
    call    AdjustHScroll
    ld  de, (PlayerX)
    call    ChkPutBlk
    ld  a, 1
    ld  (NeedRedraw), a
    jq  MainLoop

GetBlkUnder:           ; fetch block type under the player
    ld  de, (PlayerX)
    inc d
    call    GetB
    ret

BlkLift:
    call    GetBlkUnder  ; make sure the player is standing on something!
    or  a
    ret z
    cp  1                ; ... that isn't the solid floor!
    ret z

    push    af
    call    EraseBlk
    ld  de, (PlayerX)
    call    GetB
    pop af
    call    PlaceBlk
    ret

BlkSink:
    call    GetBlkUnder  ; make sure the player is standing on something!
    or  a
    ret z
    cp  1                ; ... that isn't the solid floor!
    ret z

    push    af
    call    EraseBlk
    ld  de, (PlayerX)
    inc d
    inc d
    call    GetB
    or  a
    jq  nz, NoEraseSink
    pop af
    call    PlaceBlk
    ld  de, (PlayerX)
    inc d
    ld  (PlayerX), de
    ret

NoEraseSink:
    ld  de, (PlayerX)
    inc d
    call    GetB
    pop af
    call    PlaceBlk
    ret

TryFall:
    ld  de, (PlayerX)
    ld  a, (JumpCounter)
    or  a
    jq  nz, TryJumpCounterR
    ld  a, d
    cp  15
    ret z
    inc d
    call    GetB
    or  a
    jq  nz, AdjustVScroll
    ld  (PlayerX), de
    call    DrawAll
    ret

TryJumpCounterR:
    ld  a, (JumpCounter)
    dec a
    ld  (JumpCounter), a
    cp  3
    ret c
    dec d
    call    GetB
    or  a
    ret nz
    ld  (PlayerX), de
    call    DrawAll
    ret

TryJumpCounter:
    ld  a, (JumpCounter)
    or  a
    ret nz
    push    de
    ld  de, (PlayerX)
    inc d
    call    GetB
    pop de
    or  a
    ret z
    ld  a, 5
    ld  (JumpCounter), a
    ret

BlkSwap:
    ld  a, (CurBlk)
    ld  b, a
    ld  a, (AltBlk)
    ld  (CurBlk), a
    ld  a, b
    ld  (AltBlk), a
    call    DrawAll
    ret

BlkPrev:
    ld  a, (CurBlk)
    cp  2   ; minimum block in block list
    ret z
    dec a
    ld  (CurBlk), a
    ld  a, 1
    ld  (NeedRedraw), a
    call    DrawAll
    ret

BlkNext:
    ld  a, (CurBlk)
    cp  NumBlks + 15 ; maximum block in block list
    ret z
    inc a
    ld  (CurBlk), a
    ld  a, 1
    ld  (NeedRedraw), a
    call    DrawAll
    ret

RestorePos:     ; load saved position
    ld  de, (TMP)
    ret

MoveOnSolid:
    call    GetB ; check position of block moved into
    or  a        ; if it's empty space then that's fine
    ret z
    dec d        ; not empty space! is the block above empty space?
    call    GetB
    or  a        ; if it's filled with something, go back to the saved position
    jq  nz, RestorePos
    ret          ; but if it ISN'T, the decremented D stays and you're up 1 block

Raise:
    dec d
    ld  (PlayerX), de
    ld  a, 1
    ld  (NeedRedraw), a
    ret

GoLeft:
    ld  (TMP), de  ; save just in case movement is not possible
    ld  a, e
    or  a          ; can't move left if at leftmost part of map
    ret z
    dec e
    jq  MoveOnSolid

GoRight:
    ld  (TMP), de  ; save just in case movement is not possible
    ld  a, e
    cp  47         ; can't move right if at rightmost part of map
    ret z
    inc e
    jq  MoveOnSolid

GetBClip:          ; Get block from map, with horizontal wraparound
    ld  a, d
    cp  -1
    jr  nz, @F
    ld  d, 47
@:
    cp  48
    jr  nz, GetB
    ld  d, 0
GetB:                ; Get block from map
    push    de
    ld  a, e
    ld  h, 0
    ld  l, d

    ld  d, h
    ld  e, l

    add hl, hl       ; *2
    add hl, de       ; *3
    add hl, hl       ; *6
    add hl, hl       ; *12
    add hl, hl       ; *24
    add hl, hl       ; *48

    ld  d, 0
    ld  e, a
    add hl, de
    ld  de, MapBuffer
    add hl, de
    pop de
    ld  a, (hl)
    ret

;#SECTION "Data", DATA

TitleString:
    db  "JoshCraft 0.4", 0
PlayerSprite:
    db  00111100b
    db  01000010b
    db  10100101b
    db  10100101b
    db  10000001b
    db  10011001b
    db  01000010b
    db  00111100b
BlkSpr:
    db  0, 0, 0, 0, 0, 0, 0, 0
    db  255, 255, 255, 255, 255, 255, 255, 255
    db  255, 129, 129, 129, 129, 129, 129, 255
    db  255, 213, 171, 213, 171, 213, 171, 255
    db  255, 205, 179, 179, 205, 205, 179, 255
    db  255, 241, 241, 241, 143, 143, 143, 255
    db  255, 195, 165, 153, 153, 165, 195, 255
    db  255, 129, 255, 129, 255, 129, 255, 255
NumBlks equ 8
NumKey2Off:
    db  sk1, 1, -1
    db  sk2, 1, 0
    db  sk3, 1, 1
    db  sk4, 0, -1
    db  sk5, 0, 0
    db  sk6, 0, 1
    db  sk7, -1, -1
    db  sk8, -1, 0
    db  sk9, -1, 1
    db  0
BasicHelpStr:
    db  "2nd: JumpCounter, Clear:Exit", 0
    db  "1-9: Put block", 0
    db  "(/): Select block", 0
    db  "x\xd3/Log: Rise/Fall", 0
    db  0
;#SECTION "Render", CODE

EraseMMP:
    ld  de, (PlayerX)
    call    GetMMPix
    cpl
    and (hl)
    ld  (hl), a
    ret

SetHScr0:
    xor a
    ld  (ScrollX), a
    ret

SetHScrR:
    ld  a, 48 - 9
    ld  (ScrollX), a
    ret

AdjustHScroll:
    ld  a, (PlayerX)
    cp  4
    jq  c, SetHScr0
    cp  48 - 4
    jq  nc, SetHScrR
    sub 4
    ld  (ScrollX), a
    ret

SetVScr0:
    xor a
    ld  (ScrollY), a
    jq  DrawAll

SetVScr8:
    ld  a, 8
    ld  (ScrollY), a
    jq  DrawAll

AdjustVScroll:
    ld  a, (PlayerY)
    cp  4
    jq  c, SetVScr0
    cp  12
    jq  nc, SetVScr8
    sub 3
    ld  (ScrollY), a
DrawAll:
    ld  de, (PlayerX)
    call    GetMMPix
    or  (hl)
    ld  (hl), a
    xor a
    ld  (NeedRedraw), a
    call    BDisp
    call    PutPlayer
    call    SafeCopy
    ld  a, (CurBlk)
    call    Bimg
    ld  ix, plotSScreen + 11
    ld  b, 8
    call    PutVertI
    ld  a, (AltBlk)
    call    Bimg
    ld  ix, plotSScreen + 10
    ld  b, 8
    call    PutVertI
    ret

PutPlayer:
    ld  de, (PlayerX)
    ld  hl, (ScrollX)
    ld  a, d
    sub h
    add a, a
    add a, a
    add a, a
    ld  b, a
    ld  a, e
    sub l
    add a, a
    add a, a
    add a, a
    cp  96 - 8 * 3
    ret nc
    ld  d, a
    cp  8 * 10
    jq  c, NoNeedSR
NoNeedSR:
    ld  e, b
    ld  ix, PlayerSprite
    ld  b, 8
    call    Spr8b
    ret

Bimg:
    push    de
    ld  de, BlkSpr
    cp  NumBlks
    call    nc, BimgCust
    ld  h, 0
    ld  l, a
    add hl, hl
    add hl, hl
    add hl, hl
    add hl, de
    pop de
    ret

BimgCust:
    ld  de, CustomBlockBuffer
    sub NumBlks
    ret

BDisp:
    ld  ix, plotSScreen
    ld  de, (ScrollX)
    call    GetBClip
    ex  de, hl
    call    BCol
    call    BCol
    call    BCol
    call    BCol
    call    BCol
    call    BCol
    call    BCol
    call    BCol
    call    BCol
    ret

BCol:
    push    ix
    push    de
    call    BBlk
    call    BBlk
    call    BBlk
    call    BBlk
    call    BBlk
    call    BBlk
    call    BBlk
    call    BBlk
    pop de
    inc de
    pop ix
    inc ix
    ret

BBlk:
    ld  a, (de)
    ex  de, hl
    ld  de, 48
    add hl, de
    ex  de, hl
    push    de
    call    Bimg
    ld  b, 8
BBL:
    ld  a, (hl)
    ld  (ix + 0), a
    inc hl
    ld  de, 12
    add ix, de
    djnz    BBL
    pop de
    ret

;#SECTION "PutBlock", CODE

ChkPutBlk:
    ld  ix, NumKey2Off
    ld  a, (CurKey)
    ld  b, a
@:
    ld  a, (ix + 0)
    or  a
    ret z
    cp  b
    jp  z, OkPutBlk
    inc ix
    inc ix
    inc ix
    jq  @B
    ret

OkPutBlk:
    ld  l, (ix + 2)
    ld  h, (ix + 1)
    ld  de, (PlayerX)
    ld  a, h
    add a, d
    ld  d, a
    ld  a, l
    add a, e
    ld  e, a
    call    GetBClip
    ld  a, (hl)
    or  a
    jq  nz, EraseBlk
    ld  a, (CurBlk)
PlaceBlk:
    ld  (hl), a
    ld  a, 1
    ld  (NeedRedraw), a
    call    GetMMPix
    or  (hl)
    ld  (hl), a
    ret

EraseBlk:
    ld  a, (hl)
    cp  1
    ret z
    ld  a, 0
    ld  (hl), a
    ld  a, 1
    ld  (NeedRedraw), a
    call    GetMMPix
    cpl
    and (hl)
    ld  (hl), a
    ret

GetMMPix:
    ld  a, d
    sub 96 - 16
    ld  d, a
    ld  a, 15 + 48 - 1
    sub e
    ld  e, a
    call    GetPixel
    ret

;#SECTION "Menu", CODE

ShowBasicHelp:
    ld  a, 1
    ld  (penCol), a
    ld  a, 10
    ld  (penRow), a
    ld  hl, BasicHelpStr
DispChoices:
    ld  a, (hl)
    or  a
    ret z
    ld  a, 1
    ld  (penCol), a
    B_CALL  _VPutS
    ld  a, (penRow)
    add a, 7
    ld  (penRow), a
    jq  DispChoices

TanMenu:
    ld  a, (CurBlk)
    cp  NumBlks
    jq  nc, BlkEdit
    ret

ClearView:
    ld  a, 0
    ld  b, 9
    ld  hl, plotSScreen
@:
    push    bc
    ld  b, 64
    call    PutVert
    pop bc
    inc hl
    djnz    @B
    ret

StartMenu:
    call    ClearView
    call    SafeCopy
    ld  a, 2
    ld  (penRow), a
    ld  a, 13
    ld  (penCol), a
    ld  hl, TitleString
    B_CALL  _VPutS
    call    ShowBasicHelp
    B_CALL  _GetKey
    ret

;#SECTION "BlkEdit", CODE

BlkEdLoop:
    call    RenderBlkEd
    call    SafeCopy
@:
    B_CALL  _GetCSC
    or  a
    jp  z, @B
    cp  skClear
    jp  z, BlkEdExit
    cp  skTan
    ret z

    ld  b, a
    ld  de, (BlkEditX)
    cp  skLeft
    call    z, BlkEdGoL

    ld  a, b
    cp  skRight
    call    z, BlkEdGoR

    ld  a, b
    cp  skUp
    call    z, BlkEdGoU

    ld  a, b
    cp  skDown
    call    z, BlkEdGoD
    ld  (BlkEditX), de

    ld  a, b
    cp  skDel
    call    z, BlkEdClear

    ld  a, b
    cp  sk2nd
    call    z, BlkEdSet
    jp  BlkEdLoop

BlkEdClear:
    ld  hl, (BlkEditPtr)
    ld  b, 8
@:
    ld  (hl), 0
    inc hl
    djnz    @B
    ret

BlkEdSet:
    ld  hl, (BlkEditPtr)
    ld  a, (BlkEditY)
    add a, l
    ld  l, a
    adc a, h
    sub l
    ld  h, a
    ld  a, (BlkEditX)
    or  a
    jp  z, BlkEdSet128
    ld  b, a
    ld  a, 128
@:
    srl a
    djnz    @B
    xor (hl)
    ld  (hl), a
    ret

BlkEdSet128:
    ld  a, 128
    xor (hl)
    ld  (hl), a
    ret

BlkEdExit:
    ret

BlkEdGoL:
    ld  a, e
    dec a
    and 7
    ld  e, a
    ret

BlkEdGoR:
    ld  a, e
    inc a
    and 7
    ld  e, a
    ret

BlkEdGoU:
    ld  a, d
    dec a
    and 7
    ld  d, a
    ret

BlkEdGoD:
    ld  a, d
    inc a
    and 7
    ld  d, a
    ret

BlkEdit:
    call    ClearView
    ld  a, (CurBlk)
    call    Bimg
    ld  (BlkEditPtr), hl
    call    RenderBlkEd
    call    SafeCopy
    jp  BlkEdLoop

RenderBlkEd:                 ; render block editor
    call    ClearView
    ld  hl, plotSScreen + 8
    ld  b, 32
    ld  de, 12
@:
    ld  a, 10101010b
    ld  (hl), a
    add hl, de
    ld  a, 11010101b
    ld  (hl), a
    add hl, de
    djnz    @B
    ld  hl, plotSScreen
    ld  ix, (BlkEditPtr)
    ld  b, 8
RndrBlkEL:
    push    hl
    push    bc
    ld  a, (ix + 0)
    ld  b, 8
RndrBlkELR:
    or  a
    jp  p, RndrBlkELR2
    push    af
    push    bc
    ld  a, 255
    ld  b, 8
    call    PutVert
    pop bc
    pop af
RndrBlkELR2:
    add a, a
    inc hl
    djnz    RndrBlkELR

    pop bc
    pop hl
    ld  de, 12 * 8
    add hl, de
    inc ix
    djnz    RndrBlkEL
    ld  ix, plotSScreen + 11
    ld  hl, (BlkEditPtr)
    ld  b, 8
    call    PutVertI
    ld  a, (BlkEditX)
    add a, a
    add a, a
    add a, a
    ld  d, a
    ld  a, (BlkEditY)
    add a, a
    add a, a
    add a, a
    ld  e, a
    ld  b, 8
    ld  ix, PlayerSprite
    call    Spr8b
    ret

;#IMPORT "LCDLIB"