Entities_Actions:
	CALL =Reset_Entities_Collision_Map

	LD HL, $mem_entities_list
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	CALL =Entity_Action
	RET

Entity_Action:
	LD A, (HL+)
	CP $00
	JR Z, =Entity_Action.skip

	INC HL
	INC HL
	INC HL

	LD E, (HL)
	PUSH HL

	LD A, L
	AND $f0
	LD L, A

	LD BC, =Turn_Jump_table
	LD A, E

	.JUMP_TABLE

	POP HL

	Entity_Action.skip:
	LD A, L
	AND $f0
	ADD $10
	LD L, A
	RET

Update_Animation_Steps:
	LD A, $mem_map_loading_flags
	BIT 3, A
	JR Z, =Update_Animation_Steps.update_mode

	LD A, $mem_moving_animation_step
	INC A
	AND $0f
	LD $mem_moving_animation_step, A

	CP $00
	JR NZ, =Update_Animation_Steps.end

	LD A, $mem_map_loading_flags
	RES 3, A
	SET 1, A
	LD $mem_map_loading_flags, A

	Update_Animation_Steps.update_mode:

	LD A, $mem_bunny_health
	CP $00
	JR Z =Update_Animation_Steps.Dead_mode

	LD A, $mem_requested_mode
	LD $mem_current_mode, A

	Update_Animation_Steps.end:
	RET

	Update_Animation_Steps.Dead_mode:

	LD A, $enum_dead_mode
	LD $mem_current_mode, A

	LD A, $00
	LD $mem_display_flag, A

	RET

Turn_Jump_table:
	; 00
	RET
	NOP
	NOP
	NOP

	; 01
	JP =Move_Bunny
	NOP

	; 02
	JP =Fox_Turn
	NOP

Interaction_Jump_table:
	; 00
	RET
	NOP
	NOP
	NOP

	; 01
	JP =Fox_Interaction
	NOP

	; 02
	JP =Open_Dialogue
	NOP

Fox_Interaction:
	LD A, L
	AND $f0
	ADD $06
	LD L, A
	LD A, (HL)
	DEC A
	DAA
	LD (HL), A
	RET

Open_Dialogue:
	LD HL, $dialogue_first_line
	LD BC, =Bunny_Prefix
	CALL =Print_str

	LD HL, $dialogue_third_line
	LD BC, =Text_1
	CALL =Print_str

	LD A, $01
	LD $mem_display_flag, A

	LD A, $mem_bunny_direction
	AND $0f
	LD $mem_bunny_direction, A

	LD A, $enum_dungeon_menu_mode
	LD $mem_requested_mode, A
	RET

Fox_Turn:
	PUSH HL
	PUSH BC
	PUSH DE
	INC HL
	LD A, (HL+)
	LD B, A
	LD A, (HL+)
	LD C, A
	LD A, (HL+)
	LD D, A

	Fox_Turn.Start_action_or_movement:
		LD A, $mem_map_loading_flags
		BIT 3, A
		JP Z, =Fox_Turn.Start_action_or_movement.end
		LD A, $mem_moving_animation_step
		CP $00
		JP NZ, =Fox_Turn.Start_action_or_movement.end

		; Is bunny right next to fox
		Fox_Turn.Check_next_to_vertical:

		LD A, $mem_bunny_x
		CP B
		JR NZ, =Fox_Turn.Check_next_to_horizontal

		; up
		LD E, $14
		LD A, $mem_bunny_y
		SUB $01
		CP C
		JR Z, =Fox_Turn.Start_Attack

		; down
		LD E, $13
		ADD $02
		CP C
		JR Z, =Fox_Turn.Start_Attack

		JR =Fox_Turn.Check_next_to.end

		Fox_Turn.Check_next_to_horizontal:

		LD A, $mem_bunny_y
		CP C
		JR NZ, =Fox_Turn.Check_next_to.end

		; left
		LD E, $12
		LD A, $mem_bunny_x
		SUB $01
		CP B
		JR Z, =Fox_Turn.Start_Attack

		; right
		LD E, $11
		ADD $02
		CP B
		JR Z, =Fox_Turn.Start_Attack

		JR NZ, =Fox_Turn.Check_next_to.end

		Fox_Turn.Start_Attack:
		LD D, E

		LD A, $mem_bunny_health
		SUB $01
		JR C, =Fox_Turn.health_underflow_fix
		DAA
		LD $mem_bunny_health, A
		JR =Fox_Turn.Skip_health_underflow_fix

		Fox_Turn.health_underflow_fix:
		LD A, $00
		LD $mem_bunny_health, A
		Fox_Turn.Skip_health_underflow_fix:

		JP =Fox_Turn.Check_Collision

		Fox_Turn.Check_next_to.end:

		; Is Bunny close enough to follow
		LD A, $mem_bunny_x
		SUB B
		.ABS
		CP $08
		JR NC, =Fox_Turn.Random_walker

		LD A, $mem_bunny_y
		SUB C
		.ABS
		CP $08
		JR NC, =Fox_Turn.Random_walker

		JR =Fox_Turn.Follow_bunny

		Fox_Turn.Random_walker:
		CALL =RNG_Step
		LD E, $00
		RR A
		RR E
		SWAP E
		AND $03
		INC A
		OR E
		LD D, A
		JP =Fox_Turn.Check_Collision

		Fox_Turn.Follow_bunny:
		LD A, $mem_bunny_x
		LD $tmp_var_1, A

		LD A, $mem_bunny_y
		LD $tmp_var_2, A

		CALL =RNG_Step
		AND $02
		LD $tmp_var_3, A

		CP $00
		JR Z, =Fox_Turn.skip_invert_axis

		LD A, $mem_bunny_y
		LD $tmp_var_1, A

		LD A, $mem_bunny_x
		LD $tmp_var_2, A

		LD E, B
		LD B, C
		LD C, E

		Fox_Turn.skip_invert_axis:

		; Choose direction
		LD A, B
		ADD $80
		LD E, A
		LD A, $tmp_var_1
		ADD $80
		CP E
		JR Z =Fox_Turn.Vertical
		JR C =Fox_Turn.Go_Left

		Fox_Turn.Go_Right:
		LD A, $enum_direction_right
		JR =Fox_Turn.Check_Horizontal_Collision
		Fox_Turn.Go_Left:
		LD A, $enum_direction_left

		Fox_Turn.Check_Horizontal_Collision:
		LD E, A
		DEC E
		LD A, $tmp_var_3
		XOR E
		INC E
		INC A
		OR $08
		PUSH BC
		CALL =Get_Position_After_Move
		LD A, C
		CALL =Is_Collisionable
		POP BC
		CP $00
		LD A, E
		JR Z, =Fox_Turn.Direction_check_end

		Fox_Turn.Vertical:
		LD A, C
		ADD $80
		LD E, A
		LD A, $tmp_var_2
		ADD $80
		CP E

		JR Z =Fox_Turn.No_movement
		JR C =Fox_Turn.Go_Up
		Fox_Turn.Go_Down:
		LD A, $enum_direction_down
		JR =Fox_Turn.Direction_check_end
		Fox_Turn.Go_Up:
		LD A, $enum_direction_up

		Fox_Turn.Direction_check_end:

		DEC A
		LD E, A
		LD A, $tmp_var_3
		XOR E
		INC A
		OR $08
		LD D, A

		; Check collision

		Fox_Turn.No_movement:
		LD A, $tmp_var_3
		CP $00
		JR Z, =Fox_Turn.skip_invert_axis2
		LD E, B
		LD B, C
		LD C, E
		Fox_Turn.skip_invert_axis2:

		Fox_Turn.Check_Collision:
		LD A, D
		PUSH BC
		CALL =Get_Position_After_Move
		LD A, C
		CALL =Is_Collisionable
		CALL =Carve_Entity_Collision_Map
		POP BC
		CP $00
		JR Z, =Fox_Turn.Start_action_or_movement.not_collision
		RES 3, D
		Fox_Turn.Start_action_or_movement.not_collision:

	Fox_Turn.Start_action_or_movement.end:

	Fox_Turn.End_movement:
		LD A, $mem_map_loading_flags
		BIT 3, A
		JP Z, =Fox_Turn.End_movement.end
		LD A, $mem_moving_animation_step
		CP $0f
		JP NZ, =Fox_Turn.End_movement.end
		BIT 3, D
		JR Z, =Fox_Turn.End_movement.end
		LD A, $01
		.ADD_A_TO_DIRECTION_BC
	Fox_Turn.End_movement.end:

	Fox_Turn.Health_check:
		LD A, $mem_map_loading_flags
		BIT 3, A
		JP Z, =Fox_Turn.Health_check.end

		LD A, $mem_moving_animation_step
		CP $03
		JR NZ, =Fox_Turn.Health_check.end

		LD A, L
		AND $f0
		ADD $06
		LD L, A

		LD A, (HL)
		CP $00
		JR NZ, =Fox_Turn.Health_check.end

		LD A, L
		AND $f0
		LD L, A

		LD (HL), $00
	Fox_Turn.Health_check.end:

	LD A, L
	AND $f0
	LD L, A
	INC HL
	LD A, B
	LD (HL+), A
	LD A, C
	LD (HL+), A
	LD A, D
	LD (HL+), A
	POP DE
	POP BC
	POP HL
	RET