initial commit

scripts/AmmoCounter.gd

@@ -0,0 +1,21 @@
+extends Label
+
+const ASPECT_RATIO_STD = .5625 #9/16 for standard ratio
+@export var padding_amount = .05 #multiplied by screen size
+
+@onready var player = $"../../.."
+@onready var gun_anim = $"../gun/GunAnims"
+
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	var viewportWidth = get_viewport().size.x
+	var viewportHeight = get_viewport().size.y
+	var viewportHeightAdjusted = viewportWidth * ASPECT_RATIO_STD
+	
+	size = Vector2(viewportWidth - (padding_amount * viewportWidth), viewportHeight - (padding_amount * viewportHeightAdjusted))
+	position = Vector2(0 - (padding_amount * viewportWidth) ,0 - (padding_amount * viewportHeightAdjusted))
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	text = "Ammo: " + str(player.ammo) +"  " + str(player.ammo_reserve)

scripts/EnemyTarget.gd

@@ -0,0 +1,17 @@
+extends Area3D
+
+@export var damage :=1
+
+signal body_part_hit(dam)
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	pass # Replace with function body.
+
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	pass
+
+func hit():
+	emit_signal("body_part_hit", damage)

scripts/JumpPlatform.gd

@@ -0,0 +1,25 @@
+extends StaticBody3D
+
+@export var jump_amount = 20
+@export var stamina_replenish = true
+@export var ammo_amount = 20
+@onready var jump_sound = $JumpSound
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	pass # Replace with function body.
+
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	pass
+
+
+func _on_area_3d_body_entered(body):
+	if body.is_in_group("player"):
+		body.velocity.y = jump_amount
+		jump_sound.play()
+		if body.ammo < body.gun.max_ammo + ammo_amount:
+			body.ammo += ammo_amount
+		if stamina_replenish == true:
+			body.remaining_stamina = body.MAX_STAMINA

scripts/Mag.gd

@@ -0,0 +1,12 @@
+extends MeshInstance3D
+
+@onready var player = $"../../../../../"
+var start_size = self.scale.y
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	pass
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	self.scale.y = (player.ammo/player.MAX_AMMO) #right now this makes the mag disappear

scripts/PickupAnnounce.gd

@@ -0,0 +1,18 @@
+extends Label
+
+var rng = RandomNumberGenerator.new()
+const WIGGLE_SPEED = 100
+var pickuptext
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	self.visible = true
+	text = pickuptext
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	var lv_x = rng.randf_range(-10,10.0) 
+	var lv_y = rng.randf_range(-10.0,10.0)
+	self.position = + Vector2(lv_x, lv_y) * (delta * WIGGLE_SPEED)
+	await get_tree().create_timer(.6).timeout
+	queue_free()

scripts/StaminaCounter.gd

@@ -0,0 +1,20 @@
+extends Label
+
+@onready var player = $"../../.."
+
+const ASPECT_RATIO_STD = .5625 #9/16 for standard ratio
+@export var padding_amount = .05 #multiplied by screen size
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	var viewportWidth = get_viewport().size.x
+	var viewportHeight = get_viewport().size.y
+	var viewportHeightAdjusted = viewportWidth * ASPECT_RATIO_STD
+	
+	size = Vector2(viewportWidth + (padding_amount * viewportWidth), viewportHeight - (padding_amount * viewportHeightAdjusted))
+	position = Vector2(0 + (padding_amount * viewportWidth) ,- (padding_amount * viewportHeightAdjusted))
+
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	text = "Stamina: " + str(int((player.remaining_stamina/player.MAX_STAMINA)*100)) + "%"

scripts/UIScreenAdjust.gd

@@ -0,0 +1,19 @@
+extends TextureRect
+
+var viewportWidth
+var viewportHeight
+var start_size
+var changed_size
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	viewportWidth = get_viewport().size.x
+	viewportHeight = get_viewport().size.y
+	start_size = Vector2(size.x, size.y)
+	changed_size = start_size
+
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	position = Vector2(viewportWidth/2 - (size.x/2), viewportHeight/2 - (size.y/2))
+	

scripts/bullet.gd

@@ -0,0 +1,67 @@
+extends Node3D
+
+var bullet_speed
+var bullet_drop
+var random_spread_amt
+var bullet_damage
+var instance_bullethole
+var gun
+
+@onready var mesh = $gunbullet1
+@onready var ray = $RayCast3D
+@onready var particles = $GPUParticles3D
+@onready var enemy_particles = $GPUParticlesEnemy
+@onready var timer = $Timer
+@onready var gunbullet1 = $gunbullet1/Cylinder
+@onready var hit_indicator = $Audio/HitIndicator
+
+
+
+var rng = RandomNumberGenerator.new()
+var av_x
+var av_y
+var av_z
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	
+	#apply random rotation
+	av_x = deg_to_rad(rng.randf_range(-random_spread_amt,random_spread_amt))
+	av_y = deg_to_rad(rng.randf_range(-random_spread_amt,random_spread_amt))
+	av_z = deg_to_rad(rng.randf_range(-random_spread_amt,random_spread_amt))
+	rotation += Vector3(av_x,av_y,av_z)
+	timer.start()
+	visible = false
+
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	position += transform.basis * Vector3(0, 0, -bullet_speed) * delta
+	rotation.x = clamp(rotation.x - delta * bullet_drop,deg_to_rad(-90),deg_to_rad(90))
+	
+	await get_tree().create_timer(.02).timeout
+	visible = true
+	
+	
+	if ray.is_colliding() and !ray.get_collider().is_in_group("player"):
+		
+		mesh.visible = false
+		ray.enabled = false
+		
+		#bullethole effect
+		instance_bullethole = gun.bullethole.instantiate()
+		ray.get_collider().add_child(instance_bullethole)
+		instance_bullethole.global_transform.origin = ray.get_collision_point()
+		instance_bullethole.look_at(ray.get_collision_point() + ray.get_collision_normal(), Vector3.UP)
+		
+		#move rigidbodies
+		if ray.get_collider().is_in_group("scene_rigidbody"):
+			ray.get_collider().linear_velocity += transform.basis * Vector3(0,0,-1 * 5)
+		
+		if ray.get_collider().is_in_group("enemy"):
+			print("enemy hit")
+			hit_indicator.play()
+			enemy_particles.emitting = true
+			ray.get_collider().hit()
+		await get_tree().create_timer(1.0).timeout
+		queue_free()

scripts/bullet_fake.gd

@@ -0,0 +1,19 @@
+extends Node3D
+
+var bullet_speed
+var bullet_drop
+var random_spread_amt
+var bullet_damage
+
+@onready var mesh = $gunbullet1
+@onready var timer = $Timer
+@onready var gunbullet1 = $gunbullet1/Cylinder
+
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	position += transform.basis * Vector3(0, 0, -bullet_speed) * delta
+	rotation.x = clamp(rotation.x - delta * bullet_drop,deg_to_rad(-90),deg_to_rad(90))
+	
+	await get_tree().create_timer(.01).timeout
+	queue_free()

scripts/bullet_hole.gd

@@ -0,0 +1,16 @@
+extends Node3D
+@onready var timer = $Timer
+
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	timer.start()
+
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	pass
+
+
+func _on_timer_timeout():
+	queue_free()

scripts/cannon.gd

@@ -0,0 +1,59 @@
+extends Node3D
+
+@export var CANNON_MIN_POWER = 7
+@export var CANNON_MAX_POWER = 20
+@export var TIMER_MIN = 0
+@export var  TIMER_MAX = 20
+
+var stamina = load("res://assets/stamina_pickup.tscn")
+var ammo = load("res://assets/ammo_pickup.tscn")
+var jump = load("res://assets/jump_pickup.tscn")
+
+@onready var timer = $Timer
+@onready var cannonparticles = $cannonparticles
+@onready var cannon_dir = $RayCast3D
+@onready var fire_audio = $Audio/FireAudio
+
+
+var rand_item
+var rand_select
+var rng = RandomNumberGenerator.new()
+var rand_rot_y
+var fire = true
+
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	pass # Replace with function body.
+
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	pass #self.rotation += Vector3(0,0,0) * delta
+	
+func _on_timer_timeout():
+	# Random Variables
+	var lv_y = rng.randf_range(CANNON_MIN_POWER,CANNON_MAX_POWER)
+	var rand_selector = int(round(rng.randf_range(1,2)))
+	var rand_timer = rng.randf_range(TIMER_MIN,TIMER_MAX)
+	
+	match rand_selector:
+		1:
+			rand_select = stamina
+		2:
+			rand_select = ammo
+		3:
+			rand_select = jump
+	
+	# Reset Timer
+	timer.wait_time = rand_timer #rand_timer
+	
+	# Shoot that shit
+	rand_item = rand_select.instantiate()
+	rand_item.position = cannon_dir.global_position
+	rand_item.transform.basis = cannon_dir.global_transform.basis
+	rand_item.linear_velocity += cannon_dir.global_transform.basis * Vector3(0,lv_y,0)
+	#cannonparticles.emitting = true
+	#fir_audio.pitch_scale = 
+	fire_audio.play()
+	get_parent().add_child(rand_item)

scripts/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\93.0.1.0\GoogleDriveFS.exe,25

scripts/die_particles.gd

@@ -0,0 +1,13 @@
+extends Node3D
+
+@onready var die_particles = $dieParticles
+@onready var audio_die = $Audio/Die
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	die_particles.emitting = true
+	audio_die.play()
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	pass

scripts/enemy_cannon.gd

@@ -0,0 +1,40 @@
+extends Node3D
+
+const CANNON_MIN_POWER = 7
+const CANNON_MAX_POWER = 20
+const TIMER_MIN = 0
+const  TIMER_MAX = 20
+
+var spider = load("res://assets/spider.tscn")
+
+@onready var timer = $Timer
+var enemy
+var rng = RandomNumberGenerator.new()
+var rand_rot_y
+var fire = true
+
+@onready var cannon_dir = $RayCast3D
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	pass # Replace with function body.
+
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	pass #self.rotation += Vector3(0,0,0) * delta
+	
+func _on_timer_timeout():
+	# Random Variables
+	var lv_y = rng.randf_range(CANNON_MIN_POWER,CANNON_MAX_POWER)
+	var rand_timer = rng.randf_range(TIMER_MIN,TIMER_MAX)
+	
+	# Reset Timer
+	timer.wait_time = rand_timer #rand_timer
+	
+	# Shoot that shit
+	enemy = spider.instantiate()
+	enemy.position = cannon_dir.global_position
+	enemy.transform.basis = cannon_dir.global_transform.basis
+	#enemy.linear_velocity += cannon_dir.global_transform.basis * Vector3(0,lv_y,0)
+	get_parent().add_child(enemy)

scripts/gun.gd

@@ -0,0 +1,57 @@
+extends Node3D
+
+var start_position
+var start_rotation
+var random_spread_start
+
+@export_group("Gun Feel")
+@export var recoil_amount = .2
+@export var max_ammo = 15
+@export var start_mags = 3
+@export var bullet_damage = 1
+@export var kick_amount = 1
+@export var bullet_speed = 150
+@export var bullet_drop = .3
+@export var random_spread_amt = 1.0
+@export_group("Gun Assets")
+@export_subgroup("Main Assets")
+@export var flare_light : Node
+@export var bullet : Resource
+@export var bullethole : Resource
+@export var casing : Resource
+@export var mag : Resource
+@export_subgroup("Raycast Nodes")
+@export var anim_player : Node
+@export var barrel_raycast : Node
+@export var casing_ejector : Node
+@export var mag_ejector : Node
+@export_subgroup("Audio Clips")
+@export var audio_fire : Node
+@export var audio_empty : Node
+@export var audio_reload : Node
+
+@onready var player = $"../../../../"
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	start_position = self.position
+	start_rotation = self.rotation
+	random_spread_start = random_spread_amt
+	
+
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	pass
+
+
+func _on_gun_anims_animation_finished(anim_name):
+	if anim_name == "reload":
+		if player.ammo_reserve >= max_ammo:
+			player.ammo += max_ammo
+			player.ammo_reserve -= max_ammo
+			player.reloading = false
+		else:
+			player.ammo += player.ammo_reserve
+			player.ammo_reserve -= player.ammo_reserve
+			player.reloading = false

scripts/item_pickup.gd

@@ -0,0 +1,22 @@
+extends RigidBody3D
+
+@onready var player = $"../Player"
+@onready var collision_shape = $CollisionShape3D2
+
+var rand_amt
+var rng = RandomNumberGenerator.new()
+var playermagnet = false
+var playerloc
+var x_magnet
+var y_magnet
+var z_magnet
+@export var pickupType: String
+
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	rand_amt = rng.randf_range(10.0,100.0)
+	await get_tree().create_timer(10).timeout
+	collision_shape.disabled = true
+	await get_tree().create_timer(1).timeout
+	self.queue_free()

scripts/mag1.gd

@@ -0,0 +1,17 @@
+extends RigidBody3D
+
+@onready var collision_shape = $CollisionShape3D
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	linear_velocity += transform.basis * Vector3(0, -20, 0)
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta):
+	pass
+
+
+func _on_timer_timeout():
+	collision_shape.disabled = true
+	await get_tree().create_timer(1).timeout
+	queue_free()

scripts/player.gd

@@ -0,0 +1,297 @@
+extends CharacterBody3D
+
+
+var speed
+var double_jump = true
+var gravity = 9.8
+var mouse_input : Vector2
+
+var rng = RandomNumberGenerator.new()
+
+@export_group("Player Movement")
+@export var WALK_SPEED = 7.0
+@export var SPRINT_SPEED = 15.0
+@export var JUMP_VELOCITY = 10
+@export var SENSITIVITY = .01
+@export var sensitivity_shift = true
+var start_sensitivity
+@export_subgroup("Head Bob & Gun Sway")
+@export var BOB_FREQ = 2.0
+@export var BOB_AMP = 0.08
+@export var t_bob = 1.0
+@export var weapon_holder : Node3D
+@export var weapon_sway_amount : float = 5
+@export var weapon_rotation_amount : float = 1
+@export_subgroup("FOV")
+@export var BASE_FOV : float = 80
+@export var FOV_CHANGE = 1.5
+
+@export_group("Gun")
+@export var gun : Node
+
+@onready var gun_ray = $Head/Camera3D/GunRay
+
+@onready var bullet_ray = $Head/Camera3D/BulletRay
+var instance_bullet
+var instance_casing
+var instance_mag
+var reloading = false
+var ammo
+var ammo_reserve
+var bullet_damage
+var def_weapon_holder_pos : Vector3
+var gun_folded = false
+var recoiling_fade = 0
+var bullet_destination
+var gun_fire_pitch_starting
+
+# Slow Down Variables
+const SLOWSPEED = .2
+const MAX_STAMINA = 1800
+const STAMINA_DRAIN = 100
+var remaining_stamina = MAX_STAMINA
+# Pickups
+var picked_up = false
+var picked_up_text
+var pickup_announce = load("res://assets/pickup_announce.tscn")
+var pickupmsg
+
+@onready var crosshair = $Head/Camera3D/Crosshair
+@onready var head = $Head
+@onready var camera = $Head/Camera3D
+@onready var world_environment = $"../WorldEnvironment"
+@onready var pickup_sound = $Audio/PickupSound
+@onready var ear_wind = $Audio/EarWind
+
+
+func _ready():
+	Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
+	#Set up gun variables
+	def_weapon_holder_pos = weapon_holder.position
+	ammo = gun.max_ammo
+	ammo_reserve = gun.max_ammo * gun.start_mags
+	bullet_damage = gun.bullet_damage
+	start_sensitivity = SENSITIVITY
+	gun_fire_pitch_starting = gun.audio_fire.pitch_scale
+
+func _unhandled_input(event):
+	if event is InputEventMouseMotion:
+		self.rotate_y(-event.relative.x * SENSITIVITY)
+		camera.rotate_x(-event.relative.y * SENSITIVITY)
+		camera.rotation.x = clamp(camera.rotation.x, deg_to_rad(-90), deg_to_rad(60))
+		mouse_input = event.relative
+
+
+func _physics_process(delta):
+	# Add the gravity.
+	if not is_on_floor():
+		velocity.y -= gravity * delta
+	else:
+		double_jump = true
+	
+	# Handle jump.
+	if Input.is_action_just_pressed("jump") and is_on_floor():
+		velocity.y += JUMP_VELOCITY
+	elif Input.is_action_just_pressed("jump") and double_jump == true:
+		velocity.y += JUMP_VELOCITY
+		double_jump = false
+		
+	# Handle Sprint
+	if Input.is_action_pressed("sprint") and is_on_floor():
+		speed = SPRINT_SPEED
+	else:
+		speed = WALK_SPEED
+	
+	# Get the input direction and handle the movement/deceleration.
+	var input_dir = Input.get_vector("move_left", "move_right", "move_up", "move_down")
+	var direction = (self.transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()
+	if is_on_floor():
+		if direction:
+			velocity.x = direction.x * speed
+			velocity.z = direction.z * speed
+		else:
+			velocity.x = lerp(velocity.x, direction.x * speed, delta * 3.0)
+			velocity.z = lerp(velocity.z, direction.z * speed, delta * 3.0)
+	else:
+		velocity.x = lerp(velocity.x, direction.x * speed, delta * 3.0)
+		velocity.z = lerp(velocity.z, direction.z * speed, delta * 3.0)
+	
+	# Head bob
+	t_bob += delta * velocity.length() * float(is_on_floor())
+	camera.transform.origin = _headbob(t_bob)
+	
+	# FOV
+	var velocity_clamped = clamp(velocity.length(), 0.5, SPRINT_SPEED * 2)
+	var target_fov = BASE_FOV + FOV_CHANGE * velocity_clamped
+	camera.fov = lerp(camera.fov, target_fov, delta * 8)
+	
+	# Land sound
+
+	
+	# Game Speed
+	if Input.is_action_pressed("slow_down") and remaining_stamina >0:
+		Engine.time_scale = lerp(0, 1, SLOWSPEED)
+		gun.random_spread_amt = 0
+		AudioServer.set_bus_effect_enabled(0,0,true)
+		camera.fov = lerp(camera.fov, camera.fov * .98, delta * 100)
+		if sensitivity_shift == true:
+			SENSITIVITY = lerp(SENSITIVITY, SENSITIVITY * .999, delta * 100)
+		if remaining_stamina >0:
+			remaining_stamina -= 1000 * delta
+	else:
+		Engine.time_scale = 1
+		gun.random_spread_amt = gun.random_spread_start
+		AudioServer.set_bus_effect_enabled(0,0,false)
+		if sensitivity_shift == true:
+			camera.fov = lerp(camera.fov, BASE_FOV, delta * .5)
+		SENSITIVITY = start_sensitivity
+		if remaining_stamina < MAX_STAMINA:
+			remaining_stamina += STAMINA_DRAIN * delta
+		elif remaining_stamina > MAX_STAMINA * 1.01:
+			remaining_stamina -= (STAMINA_DRAIN)/2 * delta
+			
+	# Reloading
+	if Input.is_action_just_pressed("reload"):
+		if ammo < gun.max_ammo and reloading == false and ammo_reserve > 0:
+			reloading = true
+			gun.anim_player.play("reload")
+			gun.audio_reload.play()
+			instance_mag = gun.mag.instantiate()
+			await get_tree().create_timer(.28).timeout
+			instance_mag.position = gun.mag_ejector.global_position
+			instance_mag.transform.basis = gun.mag_ejector.global_transform.basis
+			get_parent().add_child(instance_mag)
+			if gun.anim_player.is_playing() and gun.anim_player.current_animation == "reload":
+				if ammo == 0:
+					ammo = 0
+				else:
+					ammo = 1
+	if Input.is_action_pressed("inspect") and !gun.anim_player.is_playing():
+			gun.anim_player.play("inspect")
+	
+	# Shooting
+	if Input.is_action_pressed("shoot"):
+		if ammo > 0:
+			if !gun.anim_player.is_playing():
+				ammo -= 1
+				#RECOIL fix later to happen over a period of time
+				camera.rotation.x = clamp(lerp(camera.rotation.x, camera.rotation.x + gun.recoil_amount, delta * 10), deg_to_rad(-90), deg_to_rad(60))
+				#(ADD PLAYER KICK HERE. RELATIVE TO GUN POSITION)
+				gun.audio_fire.pitch_scale = 1 + rng.randf_range(-.2,.2) 
+				gun.audio_fire.play()
+				gun.anim_player.play("shoot")
+				
+				# shoot real bullet from camera
+				if gun_folded == false:
+					instance_bullet = gun.bullet.instantiate()
+					instance_bullet.position = bullet_ray.global_position
+					instance_bullet.transform.basis = bullet_ray.global_transform.basis
+					instance_bullet.bullet_speed = gun.bullet_speed
+					instance_bullet.bullet_drop = gun.bullet_drop
+					instance_bullet.random_spread_amt = gun.random_spread_amt
+					instance_bullet.gun = gun
+					get_parent().add_child(instance_bullet)
+				else:
+					instance_bullet = gun.bullet.instantiate()
+					instance_bullet.position = gun.barrel_raycast.global_position
+					instance_bullet.transform.basis = gun.barrel_raycast.global_transform.basis
+					instance_bullet.bullet_speed = gun.bullet_speed
+					instance_bullet.bullet_drop = gun.bullet_drop
+					instance_bullet.random_spread_amt = gun.random_spread_amt
+					instance_bullet.gun = gun
+					get_parent().add_child(instance_bullet)
+				
+				# Casing transform
+				instance_casing = gun.casing.instantiate()
+				instance_casing.position = gun.casing_ejector.global_position
+				instance_casing.transform.basis = gun.casing_ejector.global_transform.basis
+				
+				get_parent().add_child(instance_casing)
+		elif !gun.anim_player.is_playing():
+			gun.anim_player.play("empty")
+			gun.audio_empty.play()
+	
+
+	
+	# Gun folding out of the way
+	if gun_ray.is_colliding() and !gun_ray.get_collider().is_in_group("player"):
+		#check distance to wall later ?
+		gun.rotation = lerp(gun.rotation, Vector3(1, 1, -.25), delta * 10)
+		gun.position = lerp(gun.position, Vector3(gun.start_position.x-.25,gun.start_position.y +.2,gun.start_position.z +.6),(delta*10))
+		gun_folded = true
+	elif !gun_ray.is_colliding():
+		gun.rotation = lerp(gun.rotation, gun.start_rotation,delta*7)
+		gun.position = lerp(gun.position, gun.start_position,delta*7)
+		gun_folded = false
+	
+	move_and_slide()
+	weapon_tilt(input_dir.x, delta)
+	weapon_sway(delta)
+	weapon_bob(velocity.length(), delta)
+
+func _headbob(time) -> Vector3:
+	var pos = Vector3.ZERO
+	pos.y = sin(time * BOB_FREQ) * BOB_AMP
+	pos.x = cos(time * BOB_FREQ / 2) * BOB_AMP
+	return pos
+
+
+func _on_pick_up_detection_body_entered(body):
+	if body.pickupType == "stamina":
+		pickupmsg = pickup_announce.instantiate()
+		pickupmsg.pickuptext = "stamina"
+		get_parent().add_child(pickupmsg)
+		remaining_stamina += (body.rand_amt/100) * MAX_STAMINA
+		pickup_sound.pitch_scale = 1 + rng.randf_range(-.3,.3)
+		pickup_sound.play()
+		body.queue_free()
+	elif body.pickupType == "ammo":
+		pickupmsg = pickup_announce.instantiate()
+		pickupmsg.pickuptext = "ammo"
+		get_parent().add_child(pickupmsg)
+		ammo_reserve += int((body.rand_amt/100) * gun.max_ammo)
+		picked_up = true
+		picked_up_text = "ammo"
+		pickup_sound.pitch_scale = 1 + rng.randf_range(-.3,.3)
+		pickup_sound.play()
+		body.queue_free()
+	elif body.pickupType == "jump":
+		pickupmsg = pickup_announce.instantiate()
+		pickupmsg.pickuptext = "jump"
+		get_parent().add_child(pickupmsg)
+		double_jump = true
+		picked_up = true
+		picked_up_text = "double jump"
+		pickup_sound.pitch_scale = 1 + rng.randf_range(-.3,.3)
+		pickup_sound.play()
+		body.queue_free()
+		
+
+func _on_pick_up_magnet_body_entered(body):
+	if body.is_in_group("pickup"):
+		print("pickup")
+
+func weapon_tilt(input_x, delta):
+	if weapon_holder:
+		weapon_holder.rotation.z = lerp(weapon_holder.rotation.z, -input_x * weapon_rotation_amount * 10, 10 * delta)
+
+func weapon_sway(delta):
+	mouse_input = lerp(mouse_input, Vector2.ZERO, 10 * delta)
+	weapon_holder.rotation.x = lerp(weapon_holder.rotation.x, mouse_input.y * weapon_rotation_amount, 10 * delta)
+	weapon_holder.rotation.y = lerp(weapon_holder.rotation.y, mouse_input.x * weapon_rotation_amount, 10 * delta)
+	
+	#crosshair.position.x = lerp(crosshair.position.x, mouse_input.x * 100, 2 * delta)
+	
+	#crosshair.size.x = lerp(crosshair.size.x, clamp((abs(mouse_input.x * 10) + abs(mouse_input.y) * 1000),0.0,100.0), 1 * delta)
+	#crosshair.size.y = lerp(crosshair.size.y, clamp((abs(mouse_input.x * 10) + abs(mouse_input.y) * 1000),0.0,100.0), 1 * delta)
+	
+func weapon_bob(vel : float, delta):
+	if weapon_holder:
+		if vel > 2 and is_on_floor():
+			var bob_amount : float = 0.05
+			var bob_freq : float = 0.01
+			weapon_holder.position.y = lerp(weapon_holder.position.y, def_weapon_holder_pos.y + sin(Time.get_ticks_msec() * bob_freq) * bob_amount, 10 * delta)
+			weapon_holder.position.x = lerp(weapon_holder.position.x, def_weapon_holder_pos.x + sin(Time.get_ticks_msec() * bob_freq) * bob_amount, 10 * delta)
+		else:
+			weapon_holder.position.y = lerp(weapon_holder.position.y, def_weapon_holder_pos.y, .1 * delta)
+			weapon_holder.position.x = lerp(weapon_holder.position.x, def_weapon_holder_pos.x, .1 * delta)

scripts/spider.gd

@@ -0,0 +1,79 @@
+extends CharacterBody3D
+
+var player = null
+@export var health = 3
+@export var number_of_drops = 3
+
+const SPEED = 3.0
+const MAX_LV = 10
+const MAX_AV = 10
+
+@export var player_path : NodePath
+
+@onready var nav_agent = $NavigationAgent3D
+@onready var target = $body/target
+@onready var movement_shape = $MovementShape
+
+var stamina = load("res://assets/stamina_pickup.tscn")
+var ammo = load("res://assets/ammo_pickup.tscn")
+var jump = load("res://assets/jump_pickup.tscn")
+var die_particles = load("res://assets/die_particles.tscn")
+var particlespawn
+var rng = RandomNumberGenerator.new()
+var rand_select
+var rand_item
+
+func _ready():
+	player = get_node(player_path)
+	
+func _process(delta):
+	velocity = Vector3.ZERO
+	
+	# Navigation
+	nav_agent.set_target_position(player.global_transform.origin)
+	var next_nav_point = nav_agent.get_next_path_position()
+	velocity = (next_nav_point - global_transform.origin).normalized() * SPEED
+	
+	
+	look_at(Vector3(player.global_position.x, global_position.y, player.global_position.z), Vector3.UP)
+	
+	move_and_slide()
+
+
+func _on_area_3d_body_part_hit(dam):
+	health -= dam
+	print("health: " + str(health))
+	if health <= 0:
+		
+		particlespawn = die_particles.instantiate()
+		particlespawn.position = self.global_position
+		particlespawn.transform.basis = self.global_transform.basis
+		get_parent().add_child(particlespawn)
+		
+		#pickup drop
+		while number_of_drops > 0:
+			var rand_selector = int(round(rng.randf_range(1,2)))
+			var lv_x = rng.randf_range(-MAX_LV,MAX_LV)
+			var lv_y = rng.randf_range(0,MAX_LV)
+			var lv_z = rng.randf_range(-MAX_LV,MAX_LV)
+			var av_x = rng.randf_range(-MAX_AV,MAX_AV)
+			var av_y = rng.randf_range(-MAX_AV,MAX_AV)
+			var av_z = rng.randf_range(-MAX_AV,MAX_AV)
+			
+			match rand_selector:
+				1:
+					rand_select = stamina
+				2:
+					rand_select = ammo
+				3:
+					rand_select = jump
+			# Random Item Drop
+			rand_item = rand_select.instantiate()
+			rand_item.position = self.global_position
+			rand_item.transform.basis = self.global_transform.basis
+			rand_item.linear_velocity += self.global_transform.basis * Vector3(lv_x,lv_y,lv_z)
+			rand_item.angular_velocity += self.global_transform.basis * Vector3(av_x,av_y,av_z)
+			get_parent().add_child(rand_item)
+			number_of_drops -= 1
+		
+		queue_free()