piecelib.asc

; MSX Block Puzzle game, released as entry for the MSXDev'20
; Created by David Heremans, aka turbor on mrc
;
; Check if the player is allowed to move the piece and handle the actions initiated by the player
;

shiftleftallowed
	; out Z-flag indicates shift allowed {{{
	ld hl,itemmask+1
	ld bc,10*256+128
shiftleftallowed1:
	ld a,(hl)
	and c
	ret nz
	inc hl
	inc hl
	djnz shiftleftallowed1
	xor a
	ret	;}}}

shiftrightallowed
	; out Z-flag indicates shift allowed {{{
	ld hl,itemmask
	ld bc,10*256+64
shiftrightallowed1:
	ld a,(hl)
	and c
	ret nz
	inc hl
	inc hl
	djnz shiftrightallowed1
	xor a
	ret	;}}}

shiftupallowed
	; out Z-flag indicates shift allowed {{{
	ld hl,itemmask
	ld a,(hl)
	inc hl
	or (hl)
	ret	;}}}

shiftdownallowed
	; out Z-flag indicates shift allowed {{{
	ld hl,itemmask+2*9
	ld a,(hl)
	inc hl
	or (hl)
	ret	;}}}

item_is_placable_on_board:	; in a=piecenumber, out Z-flag indicates if placing is possible
	; {{{
	call addressofpiece
	; copy 5 words of mask to itemmask
	inc hl
	inc hl
	inc hl
	ld de,itemmask
	ld bc,10
	ldir
	; clear mask lower lines
	ld hl,0
	ld (itemmask+10),hl
	ld (itemmask+12),hl
	ld (itemmask+14),hl
	ld (itemmask+16),hl
	ld (itemmask+18),hl

	xor a
	ld (ai_possible_x),a
item_is_placable_on_board1
	; make backup of piece at top row
	ld hl,itemmask
	ld de,maskbackup
	ld bc,20
	ldir
	xor a
	ld (ai_possible_y),a

item_is_placable_on_board2
	;debug show image of piece for a while
;	;call item_place_color
;	ld a,7
;	ld (piececolor),a
;	call grid10x10_to_nametabel		; draw grid
;	call item_to_nametabel		; draw item over grid
;	call gridnametabel_to_vram
;	ei
;	halt
;	halt
;	halt
;	halt
;	halt
;	halt
;	halt
;	halt
	;
	call item_place_allowed
	ret z
	call shiftdownallowed
	jr nz,item_is_placable_on_board4
	call shiftdown
	ld hl,ai_possible_y
	inc (hl)
	jr item_is_placable_on_board2
	; checked entire column so restore backup and shift right (if allowed)
item_is_placable_on_board4
	ld hl,maskbackup
	ld de,itemmask
	ld bc,20
	ldir
	call shiftrightallowed
	ret nz ;can not move to right anymore so entire playarea checked and no placing possible
	call shiftright
	ld hl,ai_possible_x
	inc (hl)
	jr item_is_placable_on_board1




; place itemmask over gridbitmap
item_place_allowed:
	; out Z-flag indiactes if placing is allowed {{{
	ld b,20
	ld hl,itemmask
	ld de,gridbitmap
item_place_allowed1:
	ld a,(de)
	and (hl)
	ret nz
	inc de
	inc hl
	djnz item_place_allowed1
	or a
	ret	;}}}

item_place_color:
	ld a,1	; {{{
	ld (piececolor),a
	call item_place_allowed
	ret z
	ld a,2
	ld (piececolor),a
	ret;	}}}
	
item_to_nametabel:
	ld ix,nametabel+32+1 ; row 1 column 1 {{{
	ld de,(pieceoffset)
	add ix,de
	ld de,itemmask
	ld b,10
	
item_to_nametabel1
	ld a,(de)
	inc de
	ld l,a
	ld a,(de)
	inc de
	ld h,a
	
	or l
	jr z,item_to_nametabel2
	push ix
	push de
	push bc
	call item_to_nametabel3
	pop bc
	pop de
	pop ix
item_to_nametabel2:
	ex de,hl
	ld de,64
	add ix,de
	ex de,hl
	djnz item_to_nametabel1
	ret
	; now use the bits in hl to set the correct chars in (ix+?)
item_to_nametabel3:
	ld b,10
item_to_nametabel4:
	add hl,hl
	jr nc,item_to_nametabel18
	ld a,(piececolor)
	add a,a
	add a,a
	ld (ix+0),a
	inc a
	ld (ix+1),a
	inc a
	ld (ix+32),a
	inc a
	ld (ix+33),a
item_to_nametabel18
	inc ix
	inc ix
	djnz item_to_nametabel4
	ret	;}}}
	
	
shiftright:	;{{{
	ld b,10
	ld hl,itemmask
shiftright1:
	ld e,(hl)
	inc hl
	ld d,(hl)
	srl d
	rr e
	ld (hl),d
	dec hl
	ld (hl),e
	inc hl
	inc hl
	djnz shiftright1
	ret	;}}}

shiftleft:	;{{{
	ld b,10
	ld hl,itemmask
shiftleft1:
	ld e,(hl)
	inc hl
	ld d,(hl)
	ex de,hl
	add hl,hl
	ex de,hl
	ld (hl),d
	dec hl
	ld (hl),e
	inc hl
	inc hl
	djnz shiftleft1
	ret	;}}}

shiftdown:	;{{{
	ld de,itemmask+2*10-1
	ld hl,itemmask+2*9-1
	ld bc,10*2
	lddr
	ld hl,0
	ld (itemmask),hl
	ret	;}}}
	
shiftup:	;{{{
	ld de,itemmask
	ld hl,itemmask+2
	ld bc,10*2
	ldir
	ld hl,0
	ld (itemmask+2*9),hl
	ret	;}}}

check_possible_gameover: ;for all pieceplayable[123] check if pieceplacable somehwere on board
	call check_possible_gameover1	; {{{
	push af
	call clear_itemmask
	pop af
	ret z
	ld a,1
	ld (gameover),a
	ret	;}}}

check_possible_gameover1:
	call clear_itemmask
	ld a,(pieceplayable1)
	cp 255
	jr z,check_possible_gameover2
	call item_is_placable_on_board
	jr nz,check_possible_gameover2
	xor a
	ret 

check_possible_gameover2:
	ld a,(pieceplayable2)
	cp 255
	jr z,check_possible_gameover3
	call item_is_placable_on_board
	jr nz,check_possible_gameover3
	xor a
	ret 

check_possible_gameover3:
	ld a,(pieceplayable3)
	cp 255
	jr z,check_possible_gameover4
	call item_is_placable_on_board
	ret nz
	xor a
	ret 

check_possible_gameover4:
	; all 3 pieces checked and no placable one
	ld a,1
	or a
	ret
	; }}}

; out Z-flag if new items generated
check_new_pieces_needed:
	; {{{
	ld a,(pieceplayable1)
	ld hl,(pieceplayable2)
	and h
	and l
	cp 255
	ret nz
	call selectnewplayablepieces
	call makepiecesharder
	ld de,charanimationinit
	call addroutine
	call playablepieces_to_nametabel
	xor a
	ret     ; ret z flag if new pieces are added
	;jr select_next_piece
	; }}}

determine_itemmaskoffset:
	; {{{
	; first get extra offset to center for current piece
	ld hl,(pieceplayednowpnt)
	inc hl
	ld a,(hl)
	neg
	ld (itemmask_oldpiece_offsetrow),a

	inc hl
	ld a,(hl)
	neg
	ld (itemmask_oldpiece_offsetcol),a

	ld b,10
	ld hl,itemmask
determine_itemmaskoffset2:
	ld a,(hl)
	ld e,a
	inc hl
	ld d,(hl)
	inc hl
	or d
	jr nz,determine_itemmaskoffset3
	djnz determine_itemmaskoffset2
	; empty mask so offset  0,0
	xor a
	ld (itemmaskrowoffset),a
	ld (itemmaskcoloffset),a
	ret
determine_itemmaskoffset3:
	ld a,10
	sub b
	ld (itemmaskrowoffset),a
	dec hl
	dec hl

determine_itemmaskoffset4:	
	ld a,(hl)
	or e
	ld e,a
	inc hl
	ld a,(hl)
	inc hl
	or d
	ld d,a
	djnz determine_itemmaskoffset4

	ld b,16
	ex de,hl
determine_itemmaskoffset5:
	add hl,hl
	jr c,determine_itemmaskoffset6
	djnz determine_itemmaskoffset5
determine_itemmaskoffset6:
	ld a,16
	sub b
	ld (itemmaskcoloffset),a
	ret
	; }}}

select_next_piece:
	call select_next_piece7
	xor a
	ld (pieceplacenextpiece),a ; we use this variable at the end to start the soundeffect so we can not clear at the beginning of the routine
	ret
select_next_piece7:
	; {{{
	ld a,(emptyitemmask)
	or a
	jp z,select_next_piece5
	; switching from one piece to another....
	; otherwise already done by dropping
	call determine_itemmaskoffset


select_next_piece5:
	; store current version to reset view later
	ld a,(pieceplayednow)
	ld b,a
	ld a,(pieceplayednowselected)
	ld c,a
	; now to next piece
select_next_piece0:
	ld a,(pieceplayednowselected)
	inc a
	cp 3
	jr c,select_next_piece2
	xor a
select_next_piece2:
	ld (pieceplayednowselected),a
	ld d,0
	ld e,a
	ld hl,pieceplayable1
	add hl,de
	ld a,(hl)
	cp 255
	jr z,select_next_piece0 ;already used so up to next piece
	ld a,e
	cp c
	ret z ; same as when we started so two pieces are no longer in use, so simply return.
	ld a,(hl)
	ld (pieceplayednow),a
	push bc
	call addressofpiece
	pop bc
	ld (pieceplayednowpnt),hl
	; now first reset the previous to the correct color
	; if not empty
	ld a,b
	inc a
	jr z,select_next_piece3
	ld a,c
	push bc
	call get_preview_nametabel
	pop bc
	ld hl,#3031
	ld a,b
	call activateplayablepiece
select_next_piece3:

	; clear mask lower lines
	ld hl,0
	ld (itemmask+10),hl
	ld (itemmask+12),hl
	ld (itemmask+14),hl
	ld (itemmask+16),hl
	ld (itemmask+18),hl

	ld a,(pieceplayednowselected)
	call get_preview_nametabel
	ld hl,#3030 ; 3032 ; use itemmask but make preview empty...
	ld a,(pieceplayednow)
	call activateplayablepiece
	ld a,1
	ld (emptyitemmask),a
	ld a,(pieceplacenextpiece)
	or a
	jp nz,startsfx2 ; start sfx if user initiated the switch
	ret
	; }}}

drop_piece_in_grid:
	;{{{
	xor a
	ld (pieceplaceingrid),a ; flag as performed
	;return if itemmask is empty!
	ld b,20
	ld hl,itemmask
drop_piece_in_grid1:
	or (hl)
	inc hl
	djnz drop_piece_in_grid1
	or a
	ret z

	;return if not placable, to speed thins up we use the color
	ld a,(piececolor)
	cp 2
	jr nz,drop_piece_in_grid7
	call startsfx4
	xor a	; make sure we return Z
	ret


drop_piece_in_grid7:
	; first OR both masks , do not clean itemask at same time!
	ld b,20
	ld hl,gridbitmap
	ld de,itemmask
drop_piece_in_grid2:
	ld a,(de)
	or (hl)
	ld (hl),a
	inc hl
	inc de
	djnz drop_piece_in_grid2
	; then determine offset for next piece and clear itemmask
	call determine_itemmaskoffset
	call clear_itemmask
	; update our grid10x10 for display purposes
	call gridbitmap_to_grid10x10
	; now the score of this piece
	ld hl,(pieceplayednowpnt)
	ld a,(hl)
	ld (blockscore+1+5),a
	; then check if we have rows/cols that need disappearing
	call calc_cols_to_remove
	call calc_rows_to_remove
	; calc_*_to_remove can not cleanup since it would hinder the next calc_*_to_remove
	; so split this up and then clean from mask and grid10x10
	call calc_cols_remove
	call calc_rows_remove
	call calc_remove_speed
	;now start sfx for blockdrop or colrowsremove
	ld a,(row2dispnumber)
	ld e,a
	ld a,(col2dispnumber)
	or e
	jr z,drop_piece_in_grid8
	call startsfx5
	jr drop_piece_in_grid9
drop_piece_in_grid8:
	call startsfx3
drop_piece_in_grid9:
	;now the score
	ld a,(row2dispnumber)
	ld e,a
	ld a,(col2dispnumber)
	add a,e
	ld (blockscore+1+4),a
	;for each line more then 2 we add extra blockscore
	sub 2
	jr nc,drop_piece_in_grid3
	xor a
drop_piece_in_grid3
	inc a
	ld b,a
drop_piece_in_grid4
	push bc
	;then add blockscore to realscore
	ld hl,realscore+5+1
	ld de,blockscore+5+1
	call bcdadddehl
	pop bc
	djnz drop_piece_in_grid4
	; now mark piece as being used by writing 255 into it
	ld hl,pieceplayable1
	ld de,(pieceplayednowselected)
	xor a
	ld d,a
	dec a
	add hl,de
	ld (hl),a
	ld (pieceplayednow),a
	ld a,e
	call clear_piece_preview;
	;now we start the correct lettersptrite animation
	ld a,(row2dispnumber)
	ld e,a
	ld a,(col2dispnumber)
	add a,e
	sub 2
	jr c,drop_piece_in_grid6
	ld a,(encouragetext)
	inc a
	cp 7
	jr c,drop_piece_in_grid5
	xor a
drop_piece_in_grid5
	ld (encouragetext),a
	call spritestartanimation
drop_piece_in_grid6
	
	ld a,1
	or a ; make sure we return NZ
	ret	;}}}

;	vim:foldmethod=marker:ft=z8a:ts=16