conforms file names to consistant standard

scripts/weapons/hitscan_weapon.gd

@@ -0,0 +1,43 @@
+class_name HitscanWeapon
+extends Weapon
+
+@export var raycast: RayCast3D
+@export var range_debug_indicator: CSGSphere3D
+
+var attack_range: float = 0.0
+
+
+func _ready() -> void:
+	super._ready()
+	attack_range = stats.get_attribute("Range")
+
+
+func _process(delta: float) -> void:
+	super._process(delta)
+	raycast.global_position = hero.camera.global_position
+	raycast.target_position = Vector3(0, 0, -attack_range)
+
+
+func shoot() -> void:
+	super.shoot()
+	if raycast.is_colliding():
+		var target: CharacterBody3D = raycast.get_collider()
+		if target != null and target is EnemyController:
+			var hitbox: Hitbox = target.shape_owner_get_owner(raycast.get_collider_shape())
+			hit(hitbox, raycast.get_collision_point())
+			networked_hit.rpc(get_tree().root.get_path_to(hitbox), raycast.get_collision_point())
+			if particle_emitter:
+				particle_emitter.global_position = raycast.get_collision_point()
+				particle_emitter.process_material.direction = raycast.get_collision_normal()
+				particle_emitter.restart()
+				particle_emitter.emitting = true
+
+
+func hit(hitbox: Hitbox, hit_pos: Vector3) -> void:
+	hitbox.damage(damage, Data.DamageIndicationType.PLAYER, hit_pos)
+
+
+@rpc("reliable")
+func networked_hit(hitbox_path: String, hit_pos: Vector3) -> void:
+	var hitbox: Hitbox = get_tree().root.get_node(hitbox_path) as Hitbox
+	hitbox.damage(damage, Data.DamageIndicationType.OTHER_PLAYER, hit_pos)

scripts/weapons/hitscan_weapon.gd.uid

@@ -0,0 +1 @@
+uid://bp3o5klntwmhd

scripts/weapons/projectile_weapon.gd

@@ -0,0 +1,32 @@
+class_name ProjectileWeapon
+extends Weapon
+
+@export var projectile_scene: PackedScene
+
+var force: float = 20.0
+var projectile_id: int = 0
+
+
+func shoot() -> void:
+	super.shoot()
+	networked_spawn_projectile.rpc(multiplayer.get_unique_id(), -global_transform.basis.z)
+
+
+@rpc("reliable")
+func networked_shoot() -> void:
+	super.networked_shoot()
+
+
+@rpc("reliable", "call_local")
+func networked_spawn_projectile(peer_id: int, direction: Vector3) -> void:
+	var projectile: Projectile = projectile_scene.instantiate() as Projectile
+	projectile.position = global_position
+	var effect: Effect = Effect.new()
+	effect.damage = damage
+	projectile.effect = effect
+	projectile.direction = direction
+	projectile.force = force
+	projectile.owner_id = peer_id
+	projectile.name = str(peer_id) + str(projectile_id)
+	get_tree().root.add_child(projectile)
+	projectile_id += 1

scripts/weapons/projectile_weapon.gd.uid

@@ -0,0 +1 @@
+uid://d2gdg2lcedfgg

scripts/weapons/shapecast_weapon.gd

@@ -0,0 +1,51 @@
+class_name ShapecastWeapon
+extends Weapon
+
+@export var shapecast: ShapeCast3D
+@export var range_debug_indicator: CSGSphere3D
+@export var status_stats: StatusStats
+@export var particles: GPUParticles3D
+
+var attack_range: float = 0.0
+
+
+func _ready() -> void:
+	super._ready()
+	attack_range = stats.get_attribute("Range")
+	range_debug_indicator.radius = attack_range
+	shapecast.shape.size.z = attack_range
+	shapecast.target_position = -hero.camera.basis.z * (attack_range / 2.0)
+
+
+func _process(delta: float) -> void:
+	super._process(delta)
+	particles.emitting = trigger_held
+
+
+func shoot() -> void:
+	super.shoot()
+	for index: int in shapecast.get_collision_count():
+		var target: CharacterBody3D = shapecast.get_collider(index)
+		if target:
+			var target_hitbox: Hitbox = target.shape_owner_get_owner(shapecast.get_collider_shape(index))
+			if target_hitbox is Hitbox:
+				hit(target, target_hitbox)
+				networked_hit.rpc(get_tree().root.get_path_to(target), get_tree().root.get_path_to(target_hitbox))
+
+
+func build_status_object() -> StatusEffect:
+	var status: StatusEffect = StatusEffect.new()
+	status.stats = status_stats
+	return status
+
+
+func hit(target: CharacterBody3D, target_hitbox: Hitbox) -> void:
+	target_hitbox.damage(damage)
+	target.status_manager.add_effect(build_status_object())
+
+
+@rpc("reliable")
+func networked_hit(target_path: String, target_hitbox_path: String) -> void:
+	var target: CharacterBody3D = get_tree().root.get_node(target_path) as CharacterBody3D
+	var target_hitbox: Hitbox = get_tree().root.get_node(target_hitbox_path) as Hitbox
+	hit(target, target_hitbox)

scripts/weapons/shapecast_weapon.gd.uid

@@ -0,0 +1 @@
+uid://1l1qccgmp5ih

scripts/weapons/status_applying_weapon.gd

@@ -0,0 +1,15 @@
+class_name StatusApplyingWeapon
+extends HitscanWeapon
+
+@export var status_stats: StatusStats
+
+
+func hit(hitbox: Hitbox, hit_pos: Vector3) -> void:
+	super.hit(hitbox, hit_pos)
+	hitbox.add_effect(build_status_object())
+
+
+func build_status_object() -> StatusEffect:
+	var status: StatusEffect = StatusEffect.new()
+	status.stats = status_stats
+	return status

scripts/weapons/status_applying_weapon.gd.uid

@@ -0,0 +1 @@
+uid://dqcjfcecqhuec

scripts/weapons/weapon.gd

@@ -0,0 +1,113 @@
+class_name Weapon
+extends Node3D
+
+signal energy_spent(energy: int, type: Data.EnergyType)
+signal energy_recharged(energy: int, type: Data.EnergyType)
+signal energy_changed(energy: float)
+signal fired()
+
+@export var stats: CassetteText
+@export var animator: AnimationPlayer
+@export var audio_player: AudioStreamPlayer3D
+@export var recharge_timer: Timer
+@export var particle_emitter: GPUParticles3D
+
+var hero: Hero
+var trigger_held: bool = false
+var second_trigger_held: bool = false
+var time_since_firing: float = 0.0
+var time_between_shots: float = 0.0
+var damage: int = 0
+var max_energy: float = 100.0
+var current_energy: float = 100.0
+var energy_cost: float = 1.0
+var recharging: bool = false
+var recharge_speed: float = 0.0
+var recharge_acceleration: float = 3.0
+var recharge_max_speed: float = 30.0
+var duration: int = 0
+#var time_since_trigger: float = 0.0
+
+
+func _ready() -> void:
+	recharge_timer.wait_time = Data.weapon_recharge_delay
+	stats = stats.weapon_features_applied()
+	time_between_shots = stats.get_attribute("Fire Delay")
+	damage = int(stats.get_attribute("Damage"))
+	#energy_cost = stats.get_attribute("Energy")
+	max_energy = stats.get_attribute("Energy")
+	current_energy = max_energy
+
+
+func set_hero(value: Hero) -> void:
+	hero = value
+
+
+func _process(delta: float) -> void:
+	if recharging:
+		recharge_speed += recharge_acceleration * delta
+		if recharge_speed > recharge_max_speed:
+			recharge_speed = recharge_max_speed
+		current_energy += recharge_speed * delta
+		if current_energy >= max_energy:
+			current_energy = max_energy
+			recharging = false
+		energy_recharged.emit(recharge_speed * delta, stats.energy_type)
+		energy_changed.emit(current_energy)
+	if time_since_firing < time_between_shots:
+		time_since_firing += delta
+	if trigger_held and stats.energy_type == Data.EnergyType.CONTINUOUS:
+		current_energy -= delta
+		energy_spent.emit(delta, stats.energy_type)
+		energy_changed.emit(current_energy)
+
+
+@warning_ignore("unused_parameter")
+func _physics_process(delta: float) -> void:
+	if trigger_held and current_energy >= energy_cost and time_since_firing >= time_between_shots:
+		if stats.energy_type == Data.EnergyType.DISCRETE:
+			current_energy -= 1
+			current_energy = floorf(current_energy)
+			energy_spent.emit(1, stats.energy_type)
+			energy_changed.emit(current_energy)
+		time_since_firing -= time_between_shots
+		shoot()
+		networked_shoot.rpc()
+
+
+func hold_trigger() -> void:
+	trigger_held = true
+	recharge_timer.stop()
+
+
+func release_trigger() -> void:
+	if trigger_held:
+		recharge_timer.start()
+	trigger_held = false
+
+
+func hold_second_trigger() -> void:
+	second_trigger_held = true
+
+
+func release_second_trigger() -> void:
+	second_trigger_held = false
+
+
+func shoot() -> void:
+	#animator.play("shoot")
+	audio_player.play()
+	recharging = false
+	recharge_speed = 0.0
+	recharge_timer.stop()
+	fired.emit()
+
+
+@rpc
+func networked_shoot() -> void:
+	animator.play("shoot")
+	audio_player.play()
+
+
+func _on_timer_timeout() -> void:
+	recharging = true

scripts/weapons/weapon.gd.uid

@@ -0,0 +1 @@
+uid://blh4s3v07ycwa