Eight slot weapons: the six from the design plus the rivet repeater (fast, short-range automatic) and the harpoon gun (slow heavy bolt, 2.5x damage to built pieces). Four quality tiers, Rusted to Captain's, scale damage and reload time. The line thrower now yanks the shooter towards where its line lands, through a data field (pull_speed) any weapon can use. Four consumables: sailcloth bandage (heals to 75), brine tonic, cork vest and the new tar patch. Fire with one held starts using it if it would help; it takes effect after its use time. Changing slot, dropping, sprinting, swimming or elimination interrupts it and uses nothing up. All checks run on the server. A data-validation test covers every weapon, tier, consumable and ammunition type, including unknown stat keys, name format and that every ammo type is used. The GDD's weapons section lists the roster. Closes #21 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
273 lines
10 KiB
GDScript
273 lines
10 KiB
GDScript
extends TestCase
|
|
|
|
## The weapon roster and consumables from issue B7: a data-validation pass over every
|
|
## weapon, tier and consumable, tier effects, the line thrower's pull, and consumable
|
|
## use that is timed, validated and interruptible.
|
|
|
|
const FEET: Vector3 = Vector3(100.0, 0.0, 100.0)
|
|
## Names must read as Tidewall's own: lowercase words joined by underscores.
|
|
const NAME_PATTERN: String = "^[a-z]+(_[a-z]+)*$"
|
|
|
|
|
|
func _code(id: String) -> int:
|
|
return ItemCatalog.code_of(id)
|
|
|
|
|
|
func _sim() -> Simulation:
|
|
var sim: Simulation = Simulation.new(9, SimGround.flat())
|
|
var player: SimEntity = sim.entities.find(sim.add_player())
|
|
player.position = FEET
|
|
player.on_ground = true
|
|
return sim
|
|
|
|
|
|
func _step(sim: Simulation, buttons: int = 0, selection: int = 1, move: Vector2 = Vector2.ZERO, pitch: float = 0.0) -> void:
|
|
sim.submit_command(1, PlayerCommand.from_input(sim.tick, move, 0.0, pitch, buttons, selection))
|
|
sim.step()
|
|
|
|
|
|
func _has_event(sim: Simulation, kind: String) -> bool:
|
|
for event: Dictionary in sim.events:
|
|
if event["type"] == kind:
|
|
return true
|
|
return false
|
|
|
|
|
|
func test_the_roster_has_eight_weapons_and_four_consumables() -> void:
|
|
var weapons: int = 0
|
|
var consumables: int = 0
|
|
for def: ItemDef in ItemCatalog.all():
|
|
if def.kind == ItemDef.WEAPON:
|
|
weapons += 1
|
|
elif def.kind == ItemDef.CONSUMABLE:
|
|
consumables += 1
|
|
assert_eq(weapons, 8, "eight slot weapons, besides the boathook")
|
|
assert_eq(consumables, 4)
|
|
assert_eq(Tuning.WEAPON_TIERS.size(), 4)
|
|
|
|
|
|
func test_every_weapon_is_valid() -> void:
|
|
var name_check: RegEx = RegEx.create_from_string(NAME_PATTERN)
|
|
for def: ItemDef in ItemCatalog.all():
|
|
if def.kind != ItemDef.WEAPON:
|
|
continue
|
|
assert_not_null(name_check.search(def.id), "%s: name format" % def.id)
|
|
assert_true(def.damage >= 0, "%s: damage" % def.id)
|
|
assert_true(def.pellets >= 1, "%s: pellets" % def.id)
|
|
assert_true(def.fire_rate > 0.0 and def.fire_rate <= Tuning.TICK_RATE_HZ, "%s: fire rate" % def.id)
|
|
assert_true(def.range_max >= def.range_full and def.range_full >= 0.0, "%s: ranges" % def.id)
|
|
assert_true(def.falloff_min > 0.0 and def.falloff_min <= 1.0, "%s: falloff" % def.id)
|
|
assert_true(def.rarity >= 0 and def.rarity < Tuning.WEAPON_TIERS.size(), "%s: rarity" % def.id)
|
|
assert_true(def.spread_degrees >= 0.0 and def.spread_degrees < 15.0, "%s: spread" % def.id)
|
|
assert_true(def.headshot_multiplier >= 1.0, "%s: headshot" % def.id)
|
|
assert_true(def.structure_factor >= 0.0, "%s: structure factor" % def.id)
|
|
if def.thrown:
|
|
assert_eq(def.ammo_code, ItemCatalog.NONE, "%s: thrown weapons are their own ammo" % def.id)
|
|
else:
|
|
assert_true(def.magazine > 0, "%s: magazine" % def.id)
|
|
assert_true(def.reload_seconds > 0.0, "%s: reload" % def.id)
|
|
var ammo: ItemDef = ItemCatalog.get_def(def.ammo_code)
|
|
assert_not_null(ammo, "%s: ammo" % def.id)
|
|
if ammo != null:
|
|
assert_eq(ammo.kind, ItemDef.AMMO, "%s: ammo kind" % def.id)
|
|
assert_true(ammo.cap >= def.magazine, "%s: a full magazine fits in the ammo cap" % def.id)
|
|
if def.projectile_speed > 0.0:
|
|
assert_true(def.projectile_gravity >= 0.0, "%s: gravity" % def.id)
|
|
for key: String in Tuning.WEAPONS[def.id]:
|
|
assert_true(key in [
|
|
"damage", "pellets", "fire_rate", "magazine", "reload", "range_full", "range_max",
|
|
"falloff_min", "rarity", "spread", "aim_spread", "bloom", "headshot", "ammo", "stack",
|
|
"projectile_speed", "projectile_gravity", "structure_damage", "structure_factor",
|
|
"blast_radius", "fuse", "pull_speed",
|
|
], "%s: unknown stat %s, probably a typo" % [def.id, key])
|
|
|
|
|
|
func test_every_consumable_and_ammo_type_is_valid() -> void:
|
|
var name_check: RegEx = RegEx.create_from_string(NAME_PATTERN)
|
|
for def: ItemDef in ItemCatalog.all():
|
|
assert_not_null(name_check.search(def.id), "%s: name format" % def.id)
|
|
match def.kind:
|
|
ItemDef.CONSUMABLE:
|
|
assert_true(def.heal > 0 or def.armor > 0, "%s does something" % def.id)
|
|
assert_true(def.use_seconds > 0.0 and def.use_seconds <= 10.0, "%s: use time" % def.id)
|
|
assert_true(def.stack >= 1, "%s: stack" % def.id)
|
|
assert_true(def.heal_cap > 0 and def.heal_cap <= Tuning.PLAYER_MAX_HEALTH, "%s: heal cap" % def.id)
|
|
ItemDef.AMMO:
|
|
assert_true(def.cap > 0 and def.pickup_amount > 0 and def.pickup_amount <= def.cap, "%s: amounts" % def.id)
|
|
var used_ammo: Dictionary = {}
|
|
for def: ItemDef in ItemCatalog.all():
|
|
if def.ammo_code >= 0:
|
|
used_ammo[def.ammo_code] = true
|
|
for def: ItemDef in ItemCatalog.all():
|
|
if def.kind == ItemDef.AMMO:
|
|
assert_true(used_ammo.has(def.code), "%s is used by some weapon" % def.id)
|
|
|
|
|
|
func test_tiers_only_improve() -> void:
|
|
var name_check: RegEx = RegEx.create_from_string(NAME_PATTERN)
|
|
var previous: Dictionary = {"damage": 0.0, "reload": INF}
|
|
for tier: Dictionary in Tuning.WEAPON_TIERS:
|
|
assert_not_null(name_check.search(tier["name"]))
|
|
assert_true(float(tier["damage"]) > float(previous["damage"]))
|
|
assert_true(float(tier["reload"]) < float(previous["reload"]))
|
|
previous = tier
|
|
assert_eq(float(Tuning.WEAPON_TIERS[0]["damage"]), 1.0, "the lowest tier is the table's stats")
|
|
|
|
|
|
func test_a_higher_tier_hits_harder_and_reloads_faster() -> void:
|
|
var damage: Array[int] = []
|
|
for tier: int in [0, 3]:
|
|
var sim: Simulation = _sim()
|
|
var shooter: SimEntity = sim.entities.find(1)
|
|
Inventory.give(shooter, _code("signal_revolver"), 1, -1, tier)
|
|
var target: SimEntity = sim.entities.find(sim.add_player())
|
|
target.position = FEET + Vector3(0.0, 0.0, 10.0)
|
|
var eye: Vector3 = Harvest.eye(shooter)
|
|
var aim: float = atan2(target.position.y + 0.9 - eye.y, 10.0)
|
|
for _i: int in 10:
|
|
_step(sim, PlayerCommand.BUTTON_FIRE | PlayerCommand.BUTTON_AIM, 1, Vector2.ZERO, aim)
|
|
if target.health < Tuning.PLAYER_MAX_HEALTH:
|
|
break
|
|
damage.append(Tuning.PLAYER_MAX_HEALTH - target.health)
|
|
assert_eq(damage[0], 38)
|
|
assert_eq(damage[1], roundi(38 * 1.25))
|
|
var def: ItemDef = ItemCatalog.get_def(_code("signal_revolver"))
|
|
assert_true(def.reload_ticks(3) < def.reload_ticks(0))
|
|
assert_eq(def.reload_ticks(99), def.reload_ticks(3), "out-of-range tiers clamp")
|
|
|
|
|
|
func test_the_line_thrower_pulls_the_shooter_towards_where_it_lands() -> void:
|
|
var sim: Simulation = _sim()
|
|
var shooter: SimEntity = sim.entities.find(1)
|
|
Inventory.give(shooter, _code("line_thrower"), 1)
|
|
sim.ground.add_solid(AABB(Vector3(90.0, 0.0, 130.0), Vector3(20.0, 12.0, 2.0)))
|
|
var pulled: bool = false
|
|
for _i: int in 30:
|
|
_step(sim, PlayerCommand.BUTTON_FIRE, 1, Vector2.ZERO, 0.15)
|
|
if _has_event(sim, "line_pull"):
|
|
pulled = true
|
|
break
|
|
assert_true(pulled, "the line reached the wall")
|
|
assert_true(shooter.velocity.z > 10.0, "pulled towards the wall, at %s" % shooter.velocity)
|
|
assert_false(shooter.on_ground)
|
|
var start_z: float = shooter.position.z
|
|
for _i: int in 10:
|
|
_step(sim, 0)
|
|
assert_true(shooter.position.z > start_z + 3.0, "and it moves")
|
|
|
|
|
|
func test_the_harpoon_gun_is_hard_on_structures() -> void:
|
|
var def: ItemDef = ItemCatalog.get_def(_code("harpoon_gun"))
|
|
assert_true(def.structure_factor > 1.0)
|
|
assert_true(def.projectile_speed > 0.0)
|
|
|
|
|
|
func test_a_bandage_heals_after_its_use_time() -> void:
|
|
var sim: Simulation = _sim()
|
|
var player: SimEntity = sim.entities.find(1)
|
|
var bandage: ItemDef = ItemCatalog.get_def(_code("sailcloth_bandage"))
|
|
Inventory.give(player, bandage.code, 2)
|
|
player.health = 40
|
|
_step(sim, 0)
|
|
for _i: int in 10:
|
|
_step(sim, PlayerCommand.BUTTON_FIRE)
|
|
if player.use_ticks > 0:
|
|
break
|
|
assert_true(player.use_ticks > 0, "use started")
|
|
var used_at: int = -1
|
|
for i: int in bandage.use_ticks() + 2:
|
|
_step(sim, 0)
|
|
if _has_event(sim, "item_used"):
|
|
used_at = i
|
|
assert_eq(used_at, bandage.use_ticks() - 1, "takes effect after the use time")
|
|
assert_eq(player.health, 65)
|
|
assert_eq(Inventory.count_of(player, bandage.code), 1)
|
|
|
|
|
|
func test_healing_stops_at_the_items_cap() -> void:
|
|
var sim: Simulation = _sim()
|
|
var player: SimEntity = sim.entities.find(1)
|
|
Inventory.give(player, _code("sailcloth_bandage"), 1)
|
|
player.health = 70
|
|
player.selected = 1
|
|
assert_true(Consumables.start(sim, player))
|
|
for _i: int in 200:
|
|
_step(sim, 0)
|
|
assert_eq(player.health, 75)
|
|
player.health = 80
|
|
Inventory.give(player, _code("sailcloth_bandage"), 1)
|
|
assert_false(Consumables.start(sim, player), "above the cap a bandage does nothing, so it can't start")
|
|
|
|
|
|
func test_armor_stops_at_the_maximum() -> void:
|
|
var sim: Simulation = _sim()
|
|
var player: SimEntity = sim.entities.find(1)
|
|
Inventory.give(player, _code("cork_vest"), 2)
|
|
player.selected = 1
|
|
player.armor = 80
|
|
assert_true(Consumables.start(sim, player))
|
|
for _i: int in 200:
|
|
_step(sim, 0)
|
|
assert_eq(player.armor, Tuning.PLAYER_MAX_ARMOR)
|
|
assert_false(Consumables.start(sim, player), "full armor")
|
|
assert_eq(Inventory.count_of(player, _code("cork_vest")), 1)
|
|
|
|
|
|
func test_switching_slots_interrupts_and_uses_nothing() -> void:
|
|
var sim: Simulation = _sim()
|
|
var player: SimEntity = sim.entities.find(1)
|
|
var tonic: int = _code("brine_tonic")
|
|
Inventory.give(player, tonic, 1)
|
|
player.health = 30
|
|
player.selected = 1
|
|
assert_true(Consumables.start(sim, player))
|
|
for _i: int in 30:
|
|
_step(sim, 0, 1)
|
|
_step(sim, 0, 2)
|
|
assert_eq(player.use_ticks, 0)
|
|
for _i: int in 300:
|
|
_step(sim, 0, 2)
|
|
assert_eq(player.health, 30)
|
|
assert_eq(Inventory.count_of(player, tonic), 1)
|
|
|
|
|
|
func test_sprinting_interrupts() -> void:
|
|
var sim: Simulation = _sim()
|
|
var player: SimEntity = sim.entities.find(1)
|
|
Inventory.give(player, _code("tar_patch"), 1)
|
|
player.selected = 1
|
|
assert_true(Consumables.start(sim, player))
|
|
_step(sim, 0)
|
|
_step(sim, PlayerCommand.BUTTON_SPRINT, 1, Vector2(0.0, 1.0))
|
|
assert_true(_has_event(sim, "use_cancelled"))
|
|
assert_eq(player.armor, 0)
|
|
assert_eq(Inventory.count_of(player, _code("tar_patch")), 1)
|
|
|
|
|
|
func test_walking_does_not_interrupt() -> void:
|
|
var sim: Simulation = _sim()
|
|
var player: SimEntity = sim.entities.find(1)
|
|
Inventory.give(player, _code("tar_patch"), 1)
|
|
player.selected = 1
|
|
assert_true(Consumables.start(sim, player))
|
|
for _i: int in 90:
|
|
_step(sim, 0, 1, Vector2(0.0, 1.0))
|
|
assert_eq(player.armor, 20)
|
|
|
|
|
|
func test_damage_mid_use_does_not_interrupt_but_elimination_does() -> void:
|
|
var sim: Simulation = _sim()
|
|
var player: SimEntity = sim.entities.find(1)
|
|
Inventory.give(player, _code("brine_tonic"), 1)
|
|
player.health = 50
|
|
player.selected = 1
|
|
assert_true(Consumables.start(sim, player))
|
|
_step(sim, 0)
|
|
Weapons.damage_player(sim, player, 10, 0)
|
|
_step(sim, 0)
|
|
assert_true(player.use_ticks > 0)
|
|
player.health = 0
|
|
_step(sim, 0)
|
|
assert_true(player.eliminated)
|
|
assert_eq(player.use_ticks, 0)
|