cass.cityboundforest.com
A dungeon delver roguelike using Pathfinder 2nd edition rules
Almost done re-implementing the dungeon generation algorithm, need to implement get_neighbor_room_index
+280
-44
+266
-18
gb/src/dungeon.asm
+266
-18
gb/src/dungeon.asm
···
1
1
SECTION "DungeonVariables", WRAM0
2
2
3
-
dungeon_grid:: ds 512
4
-
entrance_id:: db
5
-
current_room:: db
6
-
current_width:: db
7
-
current_height:: db
8
-
generated_cells:: ds 512
3
+
wDungeonGrid:: ds 512
4
+
wEntrance:: db
5
+
wCurrentRoom:: db
6
+
wCurrentWidth:: db
7
+
wCurrentHeight:: db
8
+
wGeneratedCells:: ds 512
9
+
wDungeonArea:: db
10
+
wTwoThirdsArea:: db
11
+
wPotentialDoors:: db
9
12
10
13
SECTION "DungeonCode", ROM0
11
14
12
-
BIT_USED_ROOM:: db $01
13
-
BIT_ENTRANCE:: db $02
14
-
BIT_DOOR_NORTH:: db $04
15
-
BIT_DOOR_EAST:: db $08
16
-
BIT_DOOR_SOUTH:: db $10
17
-
BIT_DOOR_WEST:: db $20
18
-
BIT_STAIR_BELOW:: db $40
19
-
BIT_STAIR_UP:: db $80
15
+
INCLUDE "macros/dungeon.inc"
16
+
17
+
BIT_USED_ROOM:: db %00000001
18
+
BIT_ENTRANCE:: db %00000010
19
+
BIT_DOOR_NORTH:: db %00000100
20
+
BIT_DOOR_EAST:: db %00001000
21
+
BIT_DOOR_SOUTH:: db %00010000
22
+
BIT_DOOR_WEST:: db %00100000
23
+
BIT_STAIR_BELOW:: db %01000000
24
+
BIT_STAIR_UP:: db %10000000
20
25
MAX_ROOMS:: dw 512
21
-
NEIGHBORS:: db %00111100
26
+
NEIGHBORS:: db %00111100
22
27
23
28
; Params:
24
29
; Starting Width: B
25
30
; Starting Height: C
31
+
; Dungeon Area: D
32
+
; Two Thirds Dungeon Area: E
26
33
InitDungeon::
34
+
ld a, b ; wCurrentWidth = REG_B
35
+
ld [wCurrentWidth], a
36
+
ld a, c ; wCurrentHeight = REG_C
37
+
ld [wCurrentHeight], a
38
+
ld a, d ; wDungeonArea = REG_D
39
+
ld [wDungeonArea], a
40
+
ld a, e ; wTwoThirdsArea = REG_E
41
+
ld [wTwoThirdsArea], a
42
+
ret
43
+
44
+
GenerateDungeon::
45
+
; REG_B = generated_cells_number
46
+
; REG_C = i
47
+
ld b, 0 ; REG_B = 0
48
+
ld c, 0 ; REG_C = 0
49
+
.LoopCheck
50
+
ld a, [wDungeonArea] ; IF REG_B >= wDungeonArea
51
+
ld e, a
27
52
ld a, b
28
-
ld [current_width], a
29
-
ld a, c
30
-
ld [current_height], a
53
+
cp e
54
+
jp nc, .LoopSkip ; break
55
+
jp z, .LoopSkip
56
+
ld a, c ; IF REG_C == 0
57
+
cp 0
58
+
jp z, .LoopBody ; proceed to loop
59
+
cp b ; IF REG_C >= REG_B
60
+
jp nc, .LoopSkip ; break
61
+
jp z, .LoopSkip
62
+
.LoopBody
63
+
ld a, c ; IF REG_C == 0
64
+
cp 0
65
+
jp nz, .LoopBody2
66
+
ld a, b ; AND REG_B == 0
67
+
cp 0
68
+
jp nz, .LoopBody2
69
+
ld d, b ; wEntrance = rand_range(0, wDungeonArea)
70
+
ld e, c
71
+
call rand
72
+
ld a, b
73
+
ld hl, wDungeonArea
74
+
.LoopBodyLoop
75
+
cp [hl]
76
+
jp c, .LoopBodyLoopSkip
77
+
sub [hl]
78
+
jp .LoopBodyLoop
79
+
.LoopBodyLoopSkip
80
+
ld [wEntrance], a
81
+
ld b, d
82
+
ld c, e
83
+
ld hl, wGeneratedCells ; wGeneratedCells[0] = wEntrance
84
+
ld a, l
85
+
add b
86
+
ld l, a
87
+
ld a, [wEntrance]
88
+
ld [hl], a
89
+
ld hl, wDungeonGrid ; wDungeonGrid[wEntrance] = BIT_ENTRANCE | BIT_USED_ROOM
90
+
ld e, a
91
+
ld a, l
92
+
add e
93
+
ld l, a
94
+
ld [hl], $03
95
+
ld b, 1 ; REG_B = 1
96
+
.LoopBody2
97
+
call GenerateRoom ; generate_room(wDungeonGrid, REG_B, REG_C, wGeneratedCells)
98
+
ld hl, wGeneratedCells ; IF wDungeonGrid[wGeneratedCells[REG_C]] IS_NOT_USED
99
+
ld a, l
100
+
add c
101
+
ld l, a
102
+
ld e, [hl]
103
+
ld hl, wDungeonGrid
104
+
ld a, l
105
+
add e
106
+
ld l, a
107
+
ld a, [hl]
108
+
ld hl, BIT_USED_ROOM
109
+
and [hl]
110
+
jp nz, .LoopBody3
111
+
ld hl, wGeneratedCells ; SET USED_BIT IN wDungeonGrid[wGeneratedCells[REG_C]]
112
+
ld a, l
113
+
add c
114
+
ld l, a
115
+
ld e, [hl]
116
+
ld hl, wDungeonGrid
117
+
ld a, l
118
+
add e
119
+
ld l, a
120
+
ld a, [hl]
121
+
set 7, a
122
+
ld [hl], a
123
+
.LoopBody3
124
+
ld a, c ; IF REG_C == REG_B - 1
125
+
ld e, b
126
+
dec e
127
+
cp e
128
+
jp nz, .LoopBody4
129
+
ld a, b
130
+
ld hl, wTwoThirdsArea ; AND REG_B < wTwoThirdsArea
131
+
cp [hl]
132
+
jp nc, .LoopBody4
133
+
jp z, .LoopBody4
134
+
ld c, -1 ; REG_C = -1
135
+
.LoopBody4
136
+
inc c ; REG_C += 1
137
+
jp .LoopCheck ; LOOP
138
+
.LoopSkip
139
+
ret
140
+
141
+
GenerateRoom::
142
+
; REG_B = queue_size => cell_index
143
+
; REG_C = cell_index_queue => neighbor_room
144
+
; REG_D = door
145
+
; REG_E = opposite_door
146
+
; cells_queue = wGeneratedCells
147
+
ld d, b ; REG_D = rand_range(0, NEIGHBORS)
148
+
ld e, c
149
+
call rand
150
+
ld a, b
151
+
ld hl, NEIGHBORS
152
+
.Loop1
153
+
cp [hl]
154
+
jp c, .Loop1Skip
155
+
sub [hl]
156
+
jp .Loop1
157
+
.Loop1Skip
158
+
ld [wPotentialDoors], a
159
+
ld b, d
160
+
ld c, e
161
+
push bc
162
+
ld hl, wGeneratedCells ; REG_B = wGeneratedCells[REG_C]
163
+
ld a, l
164
+
add c
165
+
ld l, a
166
+
ld b, [hl]
167
+
ld d, 1
168
+
.LoopCheck
169
+
ld a, d ; IF REG_D > NEIGHBORS
170
+
ld hl, NEIGHBORS
171
+
cp [hl]
172
+
jp nc, .LoopSkip ; BREAK
173
+
jp nz, .LoopSkip
174
+
and [hl] ; IF (REG_D & NEIGHBORS) != REG_D
175
+
cp d
176
+
jp nz, .LoopContinue ; CONTINUE
177
+
ld hl, wDungeonGrid ; IF wDungeonGrid[REG_B] & REG_D
178
+
ld a, l
179
+
add b
180
+
ld l, a
181
+
ld a, [hl]
182
+
and d
183
+
cp 0
184
+
jp nz, .LoopContinue ; CONTINUE
185
+
call GetNeighborRoomIndex ; REG_C = get_neighbor_room_index(wDungeonGrid, REG_B, REG_D)
186
+
ld a, c ; IF ! ~REG_C
187
+
cpl
188
+
cp 0
189
+
jp z, .LoopContinue ; CONTINUE
190
+
ld hl, wDungeonGrid ; IF wDungeonGrid[REG_C] & BIT_USED_ROOM
191
+
ld a, l
192
+
add c
193
+
ld l, a
194
+
ld a, [hl]
195
+
and $01
196
+
jp nz, .LoopContinue ; CONTINUE
197
+
call GetOppositeDirectionBit ; REG_E = get_opposite_direction_bit(REG_D)
198
+
ld a, [wPotentialDoors] ; IF (REG_D & wPotentialDoors) == REG_D
199
+
and d
200
+
cp d
201
+
jp nz, .LoopBody2
202
+
ld hl, wDungeonGrid ; wDungeonGrid[REG_B] |= REG_D
203
+
ld a, l
204
+
add b
205
+
ld l, a
206
+
ld a, [hl]
207
+
or d
208
+
ld [hl], a
209
+
ld hl, wDungeonGrid ; wDungeonGrid[REG_C] |= REG_E
210
+
ld a, l
211
+
add c
212
+
ld l, a
213
+
ld a, [hl]
214
+
or e
215
+
ld [hl], a
216
+
.LoopBody2
217
+
ld hl, wDungeonGrid ; IF wDungeonGrid[REG_C] == REG_E
218
+
ld a, l
219
+
add c
220
+
ld l, a
221
+
ld a, [hl]
222
+
cp e
223
+
jp nz, .LoopContinue
224
+
pop hl ; wGeneratedCells[OLD_REG_B] = REG_C
225
+
push de
226
+
ld d, h
227
+
ld e, l
228
+
ld hl, wGeneratedCells
229
+
ld a, l
230
+
add d
231
+
ld l, a
232
+
ld [hl], c
233
+
inc d ; OLD_REG_B += 1
234
+
ld h, d
235
+
ld l, e
236
+
pop de
237
+
push hl
238
+
.LoopContinue
239
+
rlc d ; REG_D <= 1
240
+
jp .LoopCheck ; LOOP
241
+
.LoopSkip
242
+
pop bc
243
+
ret
244
+
245
+
GetNeighborRoomIndex::
246
+
; REG_B = current_room
247
+
; REG_C = return val
248
+
; REG_D = direction
249
+
250
+
GetOppositeDirectionBit::
251
+
; REG_D = door
252
+
; REG_E = return val
253
+
ld a, d
254
+
;BIT_DOOR_NORTH:: db %00000100
255
+
;BIT_DOOR_EAST:: db %00001000
256
+
;BIT_DOOR_SOUTH:: db %00010000
257
+
;BIT_DOOR_WEST:: db %00100000
258
+
cp %00000100
259
+
jp nz, .Check1
260
+
ld e, %00010000
261
+
ret
262
+
.Check1
263
+
cp %00001000
264
+
jp nz, .Check2
265
+
ld e, %00100000
266
+
ret
267
+
.Check2
268
+
cp %00010000
269
+
jp nz, .Check3
270
+
ld e, %00000100
271
+
ret
272
+
.Check3
273
+
cp %00100000
274
+
jp nz, .Check4
275
+
ld e, %00001000
276
+
ret
277
+
.Check4
278
+
ld e, -1
31
279
ret
+3
gb/src/main.asm
+3
gb/src/main.asm
+11
-26
gb/src/utils.asm
+11
-26
gb/src/utils.asm
···
3
3
randstate:: ds 4
4
4
5
5
SECTION "Math", ROM0
6
+
6
7
;; From: https://github.com/pinobatch/libbet/blob/master/src/rand.z80#L34-L54
7
8
; Generates a pseudorandom 16-bit integer in BC
8
9
; using the LCG formula from cc65 rand():
···
42
43
ld [hl],c
43
44
ret
44
45
45
-
; HL = DE * A
46
-
Mul8::
46
+
; HL = D * E
47
+
Multiply::
47
48
ld hl, 0
48
-
ld b, 8
49
-
.Loop:
50
-
rrca
51
-
jp nc, Mul8.Skip
52
-
add hl, de
53
-
.Skip:
54
-
sla e
55
-
rl d
56
-
jp nz, Mul8.Loop
57
-
ret
58
-
59
-
; A = HL % C
60
-
; HL = HL / C
61
-
Mod8::
62
-
ld b, 16
49
+
ld a, d
50
+
or a
51
+
ret z
52
+
ld b, d
53
+
ld d, h
63
54
.Loop
64
-
xor a
65
-
add hl, hl
66
-
rla
67
-
cp c
68
-
jp c, Mod8.Exit
69
-
inc l
70
-
sub c
71
-
jr nz, Mod8.Loop
72
-
.Exit
55
+
add hl, de
56
+
dec b
57
+
jp nz, .Loop
73
58
ret