Carve_Map: ; X in C, Y in B
	PUSH BC
	PUSH HL

	LD A, C
	AND $e0
	JR NZ, =Carve_Map.end

	LD A, B
	AND $e0
	JR NZ, =Carve_Map.end

	LD A, C

	LD H, $00
	CP $10
	RL B
	AND $0f
	CP $08
	RL B
	AND $07
	LD L, A

	LD C, B
	LD B, high($mem_dungeon_map)
	LD A, (BC)

	OR (HL)
	LD (BC), A

	Carve_Map.end:

	POP HL
	POP BC
 	RET

Generation_Head_Mitosis:
	PUSH HL
	PUSH BC

	LD A, $mem_next_free_head_lower_bytes
	LD C, A

	LD A, (HL)

	DEC A
	XOR $02
	LD B, A
	CALL =RNG_Step
	AND $01
	XOR B
	INC A

	LD B, high($mem_dungeon_generation_heads)

	LD (BC), A
	DEC A
	XOR $01
	INC A
	LD (HL), A
	INC HL
	INC BC

	LD A, (HL+)
	LD (BC), A
	INC BC

	LD A, (HL+)
	LD (BC), A
	INC BC

	LD A, C
	LD $mem_next_free_head_lower_bytes, A

	SLA E
	SLA E
	SLA E

	POP BC
	POP HL
	RET

Enforce_Map_Bounds: ; X OR Y in A
	CP $80
	JR NC, =Enforce_Map_Bounds.Zero

	CP $1f
	JR NC, =Enforce_Map_Bounds.Thirty_one

	RET

	Enforce_Map_Bounds.Zero:
	LD A, $00
	RET

	Enforce_Map_Bounds.Thirty_one:
	LD A, $1f

	RET

Generation_Head_Explosion:
	PUSH HL

	INC HL
	LD A, (HL+)
	LD E, A ; X

	LD A, (HL+)
	LD D, A ; Y

	LD H, high($mem_room_list)
	LD A, $mem_number_of_rooms
	SLA A
	SLA A
	ADD low($mem_room_list)
	LD L, A

	LD A, E
	CALL =RNG_Step
	AND $03
	ADD $06
	LD B, A
	SRA A
	XOR $ff
	INC A
	ADD E
	CALL =Enforce_Map_Bounds
	LD E, A ; X

	ADD B
	CALL =Enforce_Map_Bounds
	SUB E
	LD B, A

	LD A, E
	LD (HL+), A
	LD A, B ; X size
	LD (HL+), A

	LD A, D
	CALL =RNG_Step
	AND $03
	ADD $06
	LD C, A
	SRA A
	XOR $ff
	INC A
	ADD D
	CALL =Enforce_Map_Bounds
	LD D, A ; Y

	ADD C
	CALL =Enforce_Map_Bounds
	SUB D
	LD C, A

	LD A, D
	LD (HL+), A
	LD A, C
	LD (HL+), A

	LD L, B
	Room_Generation.X_loop:
		LD H, C
		Room_Generation.Y_loop:
			PUSH BC
			LD A, D
			ADD H
			LD B, A
			LD A, E
			ADD L
			LD C, A
			CALL =Carve_Map
			POP BC

			DEC H
			LD A, H
			CP $ff
			JR NZ, =Room_Generation.Y_loop
		DEC L
		LD A, L
		CP $ff
		JR NZ, =Room_Generation.X_loop

	POP HL
	RET

Dungeon_Generation:
	; Head initialization
	LD HL, $mem_dungeon_generation_heads
	CALL =RNG_Step
	AND $03
	INC A
	LD (HL+), A
	LD A, $10
	LD (HL+), A
	LD (HL+), A
	LD C, A
	LD B, A
	CALL =Carve_Map

	LD E, $intial_duplication_probablity
	LD A, L
	LD $mem_next_free_head_lower_bytes, A

	LD A, $40
	PUSH AF

	.Step:
		LD HL, $mem_dungeon_generation_heads

		.Head_loop:
			LD B, (HL)
			LD A, B

			CP $00
			JR Z, =.Head_loop.end

			LD A, E
			CP $00
			JR Z, =.Head_Mitosis.end

			DEC A
			LD C, A
			CALL =RNG_Step
			AND C
			CP $00
			CALL Z, =Generation_Head_Mitosis

			.Head_Mitosis.end:

			CALL =RNG_Step
			AND $0f
			JR NZ, =.Direction_Change.end
			.Direction_Change:
				DEC B
				CALL =RNG_Step
				AND $01
				XOR B
				XOR $02
				INC A
				LD B, A
				LD (HL), B
			.Direction_Change.end:

			INC HL

			LD C, (HL)
			LD A, B

			CP $enum_direction_left
			JR NZ =.Left.end
			.Left:
				DEC C
			.Left.end:

			CP $enum_direction_right
			JR NZ =.Right.end
			.Right:
				INC C
			.Right.end:

			LD A, C
			AND $e0

			JR NZ, =.DonT_Update_X
			LD (HL), C
			.DonT_Update_X:

			INC HL

			LD C, (HL)
			LD A, B

			CP $enum_direction_up
			JR NZ =.Up.end
			.Up:
				DEC C
			.Up.end:

			CP $enum_direction_down
			JR NZ =.Down.end
			.Down:
				INC C
			.Down.end:

			LD A, C
			AND $e0

			JR NZ, =.DonT_Update_Y
			LD (HL), C
			.DonT_Update_Y:

			DEC HL
			LD A, (HL+)
			LD C, A
			LD A, (HL+)
			LD B, A
			LD A, C
			CALL =Carve_Map
			JP =.Head_loop

		.Head_loop.end:

		POP AF
		DEC A
		PUSH AF
		CP $00
		JR NZ, =.Step

	POP AF

	LD HL, $mem_dungeon_generation_heads

	.Head_explosion_loop:
		LD B, (HL)
		LD A, B

		CP $00
		JR Z, =.Head_explosion_loop.end

		CALL =Generation_Head_Explosion

		LD A, $mem_number_of_rooms
		INC A
		LD $mem_number_of_rooms, A

		INC HL
		INC HL
		INC HL
		JR =.Head_explosion_loop

	.Head_explosion_loop.end:

	RET

Reset_Map:
	LD A, $00
	LD $mem_next_free_head_lower_bytes, A
	LD HL, $mem_dungeon_generation_heads
	LD BC, $0280
	JP =bzero