extends GutTest
## Passive health regeneration.

var world: SimWorld
const PEER := 4


func before_each() -> void:
	world = SimWorld.new(1)
	world.add_player(PEER, "tester")


func _player() -> SimPlayer:
	return world.players[PEER]


func test_it_heals_the_configured_share_of_maximum_per_second() -> void:
	var p := _player()
	p.hp = 1
	for _i in SimConfig.TICK_RATE:
		world.step()
	var expected := float(p.max_hp) * SimConfig.HP_REGEN_PERCENT_PER_SEC / 100.0
	assert_almost_eq(float(p.hp - 1), expected, 1.0,
		"one second should restore %.1f%% of maximum" % SimConfig.HP_REGEN_PERCENT_PER_SEC)


## The reason for the fractional carry: at this rate a tick heals far less than
## one hit point, so truncating every tick would heal exactly nothing forever.
func test_fractions_accumulate_rather_than_being_lost() -> void:
	var p := _player()
	p.hp = 1
	var per_tick := float(p.max_hp) * (SimConfig.HP_REGEN_PERCENT_PER_SEC / 100.0) \
		* SimConfig.TICK_DELTA
	assert_lt(per_tick, 1.0, "setup: a single tick must heal less than one hp")
	for _i in SimConfig.TICK_RATE * 10:
		world.step()
	assert_gt(p.hp, 1, "ten seconds of sub-integer healing must still add up")


func test_it_scales_with_maximum_health_so_levels_do_not_dilute_it() -> void:
	var low := _player()
	# Taken from the curve rather than written down, so a rescale of the health
	# numbers cannot leave this test comparing two arbitrary constants.
	low.max_hp = Progression.max_hp_for_level(Progression.START_LEVEL)
	low.hp = 1
	for _i in SimConfig.TICK_RATE:
		world.step()
	var low_gain := low.hp - 1

	var world2 := SimWorld.new(1)
	var high := world2.add_player(PEER, "tester")
	high.max_hp = Progression.max_hp_for_level(Progression.MAX_LEVEL)
	high.hp = 1
	for _i in SimConfig.TICK_RATE:
		world2.step()
	assert_gt(high.hp - 1, low_gain,
		"a levelled character should regain more per second, not the same")


func test_it_never_exceeds_maximum() -> void:
	var p := _player()
	p.hp = p.max_hp - 1
	for _i in SimConfig.TICK_RATE * 30:
		world.step()
	assert_eq(p.hp, p.max_hp)


func test_the_dead_do_not_heal() -> void:
	var p := _player()
	p.alive = false
	p.hp = 0
	for _i in SimConfig.TICK_RATE * 10:
		world.step()
	assert_eq(p.hp, 0, "regeneration must not quietly revive a downed player")


## A replica never heals anyone: health, like damage, is the server's to decide.
func test_a_replica_world_does_not_regenerate() -> void:
	world.authoritative = false
	var p := _player()
	p.hp = 1
	for _i in SimConfig.TICK_RATE * 5:
		world.step()
	assert_eq(p.hp, 1)


## Slow enough that it cannot out-heal being shot, which is what makes an
## out-of-combat gate unnecessary.
func test_it_cannot_outpace_incoming_fire() -> void:
	var p := _player()
	p.pos = Vector2.ZERO
	p.spawn_grace = 0
	var start := p.hp
	for _i in 60:
		world.pool.spawn(Vector2.ZERO, Vector2.ZERO, 6.0, 60, 5,
			SimConfig.TEAM_ENEMY, SimConfig.KIND_ORB)
		world.step()
	assert_lt(p.hp, start, "standing in fire must still lose health")