Add files via upload

BlinkerBranch.gd

@@ -0,0 +1,23 @@
+class_name BlinkerBranch extends Node
+
+@export var mat_1 : StandardMaterial3D
+@export var mat_2 : StandardMaterial3D
+@export var delay_range1 : float
+@export var delay_range2 : float
+var parent : MeshInstance3D
+var looping = false
+
+func _ready():
+	parent = get_parent()
+	looping = true
+	Loop()
+	pass
+
+func Loop():
+	while (looping):
+		var delay = randf_range(delay_range1, delay_range2)
+		parent.set_surface_override_material(0, mat_1)
+		await get_tree().create_timer(delay, false).timeout
+		parent.set_surface_override_material(0, mat_2)
+		await get_tree().create_timer(delay, false).timeout
+	pass

BlockoutManager.gd

@@ -0,0 +1,7 @@
+class_name Blockout extends Node
+
+@export var objArray_club : Array[Node3D]
+
+func HideClub():
+	for i in range(objArray_club.size()):
+		objArray_club[i].visible = false

BpmLight.gd

@@ -0,0 +1,26 @@
+class_name BpmLight extends Node
+
+@export var animator : AnimationPlayer
+var delay
+var l
+var looping = false
+
+func _ready():
+	l = get_parent()
+	
+func BeginMainLoop():
+	looping = true
+	BeginLoop()
+	
+func Hit():
+	animator.play("hit")
+	pass
+	
+func BeginLoop():
+	while (looping):
+		Hit()
+		await get_tree().create_timer(delay, false).timeout
+		Hit()
+		await get_tree().create_timer(delay, false).timeout
+		pass
+	pass

BriefcaseMachine.gd

@@ -0,0 +1,63 @@
+class_name BriefcaseMachine extends Node
+
+@export var ending : EndingManager
+@export var cam : CameraManager
+@export var cursor : CursorManager
+@export var parent_eyes : Node3D
+@export var parent_machine : Node3D
+@export var speaker_machine : AudioStreamPlayer2D
+@export var anim_machine : AnimationPlayer
+@export var speaker_latchL : AudioStreamPlayer2D
+@export var speaker_latchR : AudioStreamPlayer2D
+@export var speaker_lid : AudioStreamPlayer2D
+@export var anim_latchL : AnimationPlayer
+@export var anim_latchR : AnimationPlayer
+@export var anim_lid : AnimationPlayer
+@export var intbranch_L : InteractionBranch
+@export var intbranch_R : InteractionBranch
+@export var intbranch_lid : InteractionBranch
+
+var latchRaisedL = false
+var latchRaisedR = false
+
+func MainRoutine():
+	speaker_machine.play()
+	await get_tree().create_timer(.42, false).timeout
+	parent_eyes.visible = true
+	await get_tree().create_timer(1.28, false).timeout
+	parent_eyes.visible = false
+	anim_machine.play("move to table")
+	parent_machine.visible = true
+	await get_tree().create_timer(5.14, false).timeout
+	cam.BeginLerp("cash briefcase")
+	await get_tree().create_timer(.8, false).timeout
+	cursor.SetCursor(true, true)
+	intbranch_L.interactionAllowed = true
+	intbranch_R.interactionAllowed = true
+
+func CheckLatches():
+	if (latchRaisedL == true && latchRaisedR == true):
+		await get_tree().create_timer(.3, false).timeout
+		intbranch_lid.interactionAllowed = true
+
+func OpenLatch(alias : String):
+	match (alias):
+		"L":
+			intbranch_L.interactionAllowed = false
+			speaker_latchL.play()
+			anim_latchL.play("raise")
+			latchRaisedL = true
+			CheckLatches()
+		"R":
+			intbranch_R.interactionAllowed = false
+			speaker_latchR.play()
+			anim_latchR.play("raise")
+			latchRaisedR = true
+			CheckLatches()
+
+func OpenLid():
+	cursor.SetCursor(false, false)
+	intbranch_lid.interactionAllowed = false
+	anim_lid.play("open")
+	speaker_lid.play()
+	ending.BeginEnding()

ButtonClass.gd

@@ -0,0 +1,36 @@
+class_name ButtonClass extends Node
+
+@export var cursor : CursorManager
+@export var alias : String
+@export var isActive : bool
+@export var isDynamic : bool
+@export var ui : CanvasItem
+@export var speaker_press : AudioStreamPlayer2D
+@export var speaker_hover : AudioStreamPlayer2D
+@export var playing : bool
+
+func _ready():
+	get_parent().connect("mouse_entered", OnHover)
+	get_parent().connect("mouse_exited", OnExit)
+	get_parent().connect("pressed", OnPress)
+	pass
+	
+func OnHover():
+	if (isActive):
+		if (isDynamic):
+			speaker_hover.pitch_scale = randf_range(.95, 1.0)
+			speaker_hover.play()
+			ui.modulate.a = .78
+		cursor.SetCursorImage("hover")
+
+func OnExit():
+	if (isActive):
+		if (isDynamic):
+			ui.modulate.a = 1
+		cursor.SetCursorImage("point")
+
+signal is_pressed
+func OnPress():
+	if (isActive):
+		if (isDynamic && playing): speaker_press.play()
+		emit_signal("is_pressed")

CameraManager.gd

@@ -0,0 +1,96 @@
+class_name CameraManager extends Node
+
+@export var cam : Camera3D
+@export var obj : Node3D
+
+@export var defib : DefibCutter
+@export var animator_background : AnimationPlayer
+@export var speaker_pan : AudioStreamPlayer2D
+@export var socketArray: Array[CameraSocket]
+
+@export var dur : float
+@export var isPlayingSound : bool
+var moving = false
+var elapsed = 0
+var currentPos : Vector3
+var currentRot : Vector3
+var currentFov : float
+var activeIndex
+var activeSocket : String
+var pos_previous : Vector3
+var rot_previous : Vector3
+@export var anim_test : AnimationPlayer
+
+func _ready():
+	pass
+
+
+func _process(delta):
+	LerpMovement()
+	pass
+
+func CutOutBackground():
+	animator_background.play("cut out")
+func FadeInBackground():
+	animator_background.play("fade in")
+
+func BeginLerp(lerpName : String):
+	#SavePrevious()
+	#speaker_pan.play()
+	PanSound()
+	activeSocket = lerpName
+	for i in range(socketArray.size()):
+		if (lerpName == socketArray[i].socketName):
+			activeIndex = i
+			currentPos = cam.transform.origin
+			currentRot = cam.rotation_degrees
+			currentFov = cam.fov
+			elapsed = 0
+			moving = true
+	pass
+
+func BeginLerpCutSegment():
+	PanSound()
+	activeSocket = "dealer cut shotgun"
+	for i in range(socketArray.size()):
+		if (activeSocket == socketArray[i].socketName):
+			activeIndex = i
+			currentPos = cam.transform.origin
+			currentRot = cam.rotation_degrees
+			currentFov = cam.fov
+			elapsed = 0
+			moving = true
+
+func BeginLerpEnemy():
+	PanSound()
+	activeSocket = "enemy"
+	for i in range(socketArray.size()):
+		if (activeSocket == socketArray[i].socketName):
+			activeIndex = i
+			currentPos = cam.transform.origin
+			currentRot = cam.rotation_degrees
+			currentFov = cam.fov
+			elapsed = 0
+			moving = true
+
+func PanSound():
+	var pitch = randf_range(.5, 1)
+	speaker_pan.pitch_scale = pitch
+	if (isPlayingSound): speaker_pan.play()
+
+func SavePrevious():
+	rot_previous = cam.rotation_degrees
+	pos_previous = cam.transform.origin
+
+func LerpMovement():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / dur, 0.0, 1.0)
+		c = ease(c, 0.2)
+		var pos = lerp(currentPos, socketArray[activeIndex].pos, c)
+		var rot = lerp(currentRot, socketArray[activeIndex].rot, c)
+		var fov = lerp(currentFov, socketArray[activeIndex].fov, c)
+		cam.fov = fov
+		cam.transform.origin = pos
+		cam.rotation_degrees = rot
+		pass

CameraShaker.gd

@@ -0,0 +1,31 @@
+class_name CameraShaker extends Node
+
+@export var camera_to_shake : Camera3D
+
+@export var intensity : float
+@export var duration : float
+var shake_timer = 0.0
+var initial_h_offset = 0.0
+var initial_v_offset = 0.0
+
+func _ready():
+	if camera_to_shake:
+		initial_h_offset = camera_to_shake.h_offset
+		initial_v_offset = camera_to_shake.v_offset
+
+func Shake():
+	if camera_to_shake:
+		shake_timer = duration
+
+func _process(delta):
+	if shake_timer > 0:
+		if camera_to_shake:
+			var h_offset = randf() * intensity - intensity / 2.0
+			var v_offset = randf() * intensity - intensity / 2.0
+			camera_to_shake.h_offset = initial_h_offset + h_offset
+			camera_to_shake.v_offset = initial_v_offset + v_offset
+			shake_timer -= delta
+	else:
+		if camera_to_shake:
+			camera_to_shake.h_offset = initial_h_offset
+			camera_to_shake.v_offset = initial_v_offset

CameraSocket.gd

@@ -0,0 +1,6 @@
+class_name CameraSocket extends Resource
+
+@export var socketName : String
+@export var pos : Vector3
+@export var rot : Vector3
+@export var fov : float

CompartmentManager.gd

@@ -0,0 +1,49 @@
+class_name CompartmentManager extends Node
+
+@export var animator_compartment : AnimationPlayer
+@export var animator_briefcase : AnimationPlayer
+@export var speaker_briefcase : AudioStreamPlayer2D
+@export var speaker_main : AudioStreamPlayer2D
+@export var soundArray_briefcase : Array[AudioStream]
+@export var soundArray_main : Array[AudioStream]
+var isHiding_items = true
+
+var toggle = false
+var toggle2 = false
+
+func _ready():
+	animator_compartment.play("RESET")
+	animator_briefcase.play("RESET")
+
+func PlaySound_ShowBriefcase():
+	speaker_briefcase.stream = soundArray_briefcase[0]
+	speaker_briefcase.play()
+
+func PlaySound_HideBriefcase():
+	speaker_briefcase.stream = soundArray_briefcase[1]
+	speaker_briefcase.play()
+
+func PlaySound_ClearItems():
+	speaker_main.stream = soundArray_main[0]
+	speaker_main.play()
+
+func PlaySound_ShowItems():
+	speaker_main.stream = soundArray_main[1]
+	speaker_main.play()
+
+func PlaySound_HideItems():
+	speaker_main.stream = soundArray_main[2]
+	speaker_main.play()
+
+func CycleCompartment(alias : String):
+	match (alias):
+		"show items":
+			animator_compartment.play("show items")
+			isHiding_items = false
+		"hide items":
+			animator_compartment.play("hide items")
+			isHiding_items = true
+		"show briefcase":
+			animator_briefcase.play("show briefcase")
+		"hide briefcase":
+			animator_briefcase.play("hide briefcase")

CursorManager.gd

@@ -0,0 +1,27 @@
+class_name CursorManager extends Node
+
+@export var speaker : AudioStreamPlayer2D
+@export var cursor_point : CompressedTexture2D
+@export var cursor_hover : CompressedTexture2D
+@export var cursor_invalid : CompressedTexture2D
+var cursor_visible = false
+
+func _ready():
+	SetCursor(false, false)
+
+func SetCursor(isVisible : bool, playSound : bool):
+	if (playSound):
+		speaker.play()
+	if (isVisible):
+		Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
+		cursor_visible = true
+	if (!isVisible):
+		Input.set_mouse_mode(Input.MOUSE_MODE_HIDDEN)
+		cursor_visible = false
+
+func SetCursorImage(alias : String):
+	match(alias):
+		"point": Input.set_custom_mouse_cursor(cursor_point, 0, Vector2(12, 0))
+		"hover": Input.set_custom_mouse_cursor(cursor_hover, 0, Vector2(9, 0))
+		"invalid": Input.set_custom_mouse_cursor(cursor_invalid, 0, Vector2(12, 0))
+	pass

DealerIntelligence.gd

@@ -0,0 +1,283 @@
+class_name DealerIntelligence extends Node
+#ALTHOUGH THE CLASS NAME SUGGESTS THAT THE DEALER HAS INTELLIGENCE, AND IT'S TRUE THERE ARE MANY INTELLIGENT DEALERS,
+#CONTRARY TO THOSE THIS ONE IS NOT. HERE THERE IS NO INTELLIGENCE. ONLY LAYERS, HEAPS AND CLUMPS OF SPAGHETTI JUMBLE CODE.
+
+@export var hands : HandManager
+@export var itemManager : ItemManager
+@export var shellSpawner : ShellSpawner
+@export var shellLoader : ShellLoader
+@export var shotgunShooting : ShotgunShooting
+@export var roundManager : RoundManager
+@export var animator_shotgun : AnimationPlayer
+@export var animator_dealerHands : AnimationPlayer
+@export var camera : CameraManager
+@export var ejectManager : ShellEjectManager
+@export var healthCounter : HealthCounter
+@export var death : DeathManager
+@export var cameraShaker : CameraShaker
+@export var smoke : SmokeController
+@export var shellEject_dealer : ShellEjectManager
+@export var speaker_dealerarrive : AudioStreamPlayer2D
+@export var speaker_handCrack : AudioStreamPlayer2D
+@export var soundArray_cracks : Array[AudioStream]
+@export var speaker_checkHandcuffs : AudioStreamPlayer2D
+@export var speaker_breakHandcuffs : AudioStreamPlayer2D
+@export var speaker_giveHandcuffs : AudioStreamPlayer2D
+@export var sound_dealerarrive : AudioStream
+@export var sound_dealerarriveCuffed : AudioStream
+@export var dealermesh_normal : VisualInstance3D
+@export var dealermesh_crushed : VisualInstance3D
+
+var dealerItemStringArray : Array[String]
+var dealerAboutToBreakFree = false
+var dealerCanGoAgain = false
+var dealerHoldingShotgun = false
+
+func DealerCheckHandCuffs():
+	var brokeFree = false
+	camera.BeginLerp("enemy cuffs close")
+	if (!dealerAboutToBreakFree):
+		await get_tree().create_timer(.3, false).timeout
+		speaker_checkHandcuffs.play()
+		animator_dealerHands.play("dealer check handcuffs")
+		await get_tree().create_timer(.7, false).timeout
+		brokeFree = false
+	else:
+		await get_tree().create_timer(.3, false).timeout
+		animator_dealerHands.play("dealer break cuffs") #replace with broke free anim
+		speaker_breakHandcuffs.play()
+		#await get_tree().create_timer(.7, false).timeout
+		brokeFree = true
+		roundManager.dealerCuffed = false
+		dealerAboutToBreakFree = false
+	dealerAboutToBreakFree = true
+	roundManager.ReturnFromCuffCheck(brokeFree)
+
+func Animator_CheckHandcuffs():
+	speaker_checkHandcuffs.play()
+
+func Animator_GiveHandcuffs():
+	speaker_giveHandcuffs.play()
+
+func BeginDealerTurn():
+	mainLoopFinished = false
+	usingHandsaw = false
+	DealerChoice()
+
+var dealerTarget = ""
+var knownShell = ""
+var dealerKnowsShell = false
+var mainLoopFinished = false
+var usingHandsaw = false
+var dealerUsedItem = false
+func DealerChoice():
+	var dealerWantsToUse = ""
+	var dealerFinishedUsingItems = false
+	var hasHandsaw = false
+	if (roundManager.requestedWireCut):
+		await(roundManager.defibCutter.CutWire(roundManager.wireToCut))
+	if (shellSpawner.sequenceArray.size() == 0):
+		roundManager.StartRound(true)
+		return
+	if (roundManager.shellSpawner.sequenceArray.size() == 1):
+		knownShell = shellSpawner.sequenceArray[0]
+		if (shellSpawner.sequenceArray[0] == "live"): knownShell = "live" 
+		else: knownShell = "blank"
+		if (knownShell == "live"): dealerTarget = "player"
+		else: dealerTarget = "self"
+		dealerKnowsShell = true
+	for i in range(itemManager.itemArray_dealer.size()):
+		if (itemManager.itemArray_dealer[i] == "magnifying glass" && !dealerKnowsShell && shellSpawner.sequenceArray.size() != 1):
+			dealerWantsToUse = "magnifying glass"
+			if (shellSpawner.sequenceArray[0] == "live"): knownShell = "live" 
+			else: knownShell = "blank"
+			if (knownShell == "live"): dealerTarget = "player"
+			else: dealerTarget = "self"
+			dealerKnowsShell = true
+			break
+		if (itemManager.itemArray_dealer[i] == "cigarettes"):
+			var breaking = false
+			if (roundManager.health_opponent < roundManager.roundArray[0].startingHealth):
+				dealerWantsToUse = "cigarettes"
+				breaking = true
+			if (breaking): break
+		if (itemManager.itemArray_dealer[i] == "beer" && knownShell != "live" && shellSpawner.sequenceArray.size() != 1):
+			dealerWantsToUse = "beer"
+			shellEject_dealer.FadeOutShell()
+			break
+		if (itemManager.itemArray_dealer[i] == "handcuffs" && roundManager.playerCuffed == false && shellSpawner.sequenceArray.size() != 1):
+			dealerWantsToUse = "handcuffs"
+			roundManager.playerCuffed = true
+			break
+		if (itemManager.itemArray_dealer[i] == "handsaw" && !roundManager.barrelSawedOff && knownShell == "live"):
+			dealerWantsToUse = "handsaw"
+			usingHandsaw = true
+			roundManager.barrelSawedOff = true
+			roundManager.currentShotgunDamage = 2
+			break
+	
+	if (dealerWantsToUse == ""): mainLoopFinished = true
+	for i in range(itemManager.itemArray_dealer.size()):
+		if (itemManager.itemArray_dealer[i] == "handsaw"): hasHandsaw = true
+	if (mainLoopFinished && !usingHandsaw && hasHandsaw && !roundManager.barrelSawedOff && knownShell != "blank"):
+		var decision = CoinFlip()
+		if (decision == 0): dealerTarget = "self"
+		else: 
+			dealerUsedItem = true
+			dealerTarget = "player"
+			dealerWantsToUse = "handsaw"
+			usingHandsaw = true
+			roundManager.barrelSawedOff = true
+			roundManager.currentShotgunDamage = 2
+		
+	if (dealerWantsToUse != ""): 
+		if (dealerHoldingShotgun):
+			animator_shotgun.play("enemy put down shotgun")
+			shellLoader.DealerHandsDropShotgun()
+			dealerHoldingShotgun = false
+			await get_tree().create_timer(.45, false).timeout
+		dealerUsedItem = true
+		if (roundManager.waitingForDealerReturn):
+			await get_tree().create_timer(1.8, false).timeout
+			roundManager.waitingForDealerReturn = false
+		await(hands.PickupItemFromTable(dealerWantsToUse))
+		#if (dealerWantsToUse == "handcuffs"): await get_tree().create_timer(.8, false).timeout #additional delay for initial player handcuff check (continues outside animation)
+		if (dealerWantsToUse == "cigarettes"): await get_tree().create_timer(1.1, false).timeout #additional delay for health update routine (called in aninator. continues outside animation)
+		itemManager.itemArray_dealer.erase(dealerWantsToUse)
+		itemManager.numberOfItemsGrabbed_enemy -= 1
+		DealerChoice()
+		return
+	if (dealerWantsToUse == ""): dealerFinishedUsingItems = true
+	if (roundManager.waitingForDealerReturn):
+		await get_tree().create_timer(1.8, false).timeout
+	if (!dealerHoldingShotgun && dealerFinishedUsingItems):
+		GrabShotgun()
+		await get_tree().create_timer(1.4 + .5 - 1, false).timeout
+	await get_tree().create_timer(1, false).timeout
+	if (dealerTarget == ""): ChooseWhoToShootRandomly()
+	else: Shoot(dealerTarget)
+	dealerTarget = ""
+	knownShell = ""
+	dealerKnowsShell = false
+	pass
+
+func EndDealerTurn(canDealerGoAgain : bool):
+	dealerCanGoAgain = canDealerGoAgain
+	#USINGITEMS: ASSIGN DEALER CAN GO AGAIN FROM ITEMS HERE
+	#CHECK IF OUT OF HEALTH
+	var outOfHealth_player = roundManager.health_player == 0
+	var outOfHealth_enemy = roundManager.health_opponent == 0
+	var outOfHealth = outOfHealth_player or outOfHealth_enemy
+	if (outOfHealth):
+		#if (outOfHealth_player): roundManager.OutOfHealth("player")
+		if (outOfHealth_enemy):	roundManager.OutOfHealth("dealer")
+		return
+
+	if (!dealerCanGoAgain):
+		EndTurnMain()
+	else:
+		if (shellSpawner.sequenceArray.size()):
+			BeginDealerTurn()
+		else:
+			EndTurnMain()
+	pass
+
+func ChooseWhoToShootRandomly():
+	var decision = CoinFlip()
+	if (decision == 0): Shoot("self")
+	else: Shoot("player")
+
+func GrabShotgun():
+	#await get_tree().create_timer(1, false).timeout
+	#camera.BeginLerp("enemy")
+	#await get_tree().create_timer(.8, false).timeout
+	await(shellLoader.DealerHandsGrabShotgun())
+	await get_tree().create_timer(.2, false).timeout
+	animator_shotgun.play("grab shotgun_pointing enemy")
+	dealerHoldingShotgun = true
+	pass
+
+func EndTurnMain():
+	await get_tree().create_timer(.5, false).timeout
+	camera.BeginLerp("home")
+	if (dealerHoldingShotgun): 
+		animator_shotgun.play("enemy put down shotgun")
+		shellLoader.DealerHandsDropShotgun()
+	dealerHoldingShotgun = false
+	roundManager.EndTurn(true)
+
+func Shoot(who : String):
+	var currentRoundInChamber = shellSpawner.sequenceArray[0]
+	dealerCanGoAgain = false
+	var playerDied = false
+	var dealerDied = false
+	ejectManager.FadeOutShell()
+	#ANIMATION DEPENDING ON WHO IS SHOT
+	match(who):
+		"self":
+			await get_tree().create_timer(.2, false).timeout
+			animator_shotgun.play("enemy shoot self")
+			await get_tree().create_timer(2, false).timeout
+			shotgunShooting.whoshot = "dealer"
+			shotgunShooting.PlayShootingSound()
+			pass
+		"player":
+			animator_shotgun.play("enemy shoot player")
+			await get_tree().create_timer(2, false).timeout
+			shotgunShooting.whoshot = "player"
+			shotgunShooting.PlayShootingSound()
+			pass
+	#SUBTRACT HEALTH. ASSIGN DEALER CAN GO AGAIN. RETURN IF DEAD
+	if (currentRoundInChamber == "live" && who == "self"): 
+		roundManager.health_opponent -= roundManager.currentShotgunDamage
+		if (roundManager.health_opponent < 0): roundManager.health_opponent = 0
+		smoke.SpawnSmoke("barrel")
+		cameraShaker.Shake()
+		dealerCanGoAgain = false
+		death.Kill("dealer", false, true)
+		return
+	if (currentRoundInChamber == "live" && who == "player"): 
+		roundManager.health_player -= roundManager.currentShotgunDamage
+		if (roundManager.health_player < 0): roundManager.health_player = 0
+		cameraShaker.Shake()
+		smoke.SpawnSmoke("barrel")
+		await(death.Kill("player", false, false))
+		playerDied = true
+	if (currentRoundInChamber == "blank" && who == "self"): dealerCanGoAgain = true
+	#EJECTING SHELLS
+	await get_tree().create_timer(.4, false).timeout
+	if (who == "player"): animator_shotgun.play("enemy eject shell_from player")
+	if (who == "self"): animator_shotgun.play("enemy eject shell_from self")
+	await get_tree().create_timer(1.7, false).timeout
+	#shellSpawner.sequenceArray.remove_at(0)
+	EndDealerTurn(dealerCanGoAgain)
+
+func Speaker_DealerArrive():
+	var p = randf_range(.9, 1.0)
+	speaker_dealerarrive.pitch_scale = p
+	speaker_dealerarrive.stream = sound_dealerarrive
+	speaker_dealerarrive.play()
+	
+func Speaker_DealerArrive_Cuffed():
+	var p = randf_range(.9, 1.0)
+	speaker_dealerarrive.pitch_scale = p
+	speaker_dealerarrive.stream = sound_dealerarriveCuffed
+	speaker_dealerarrive.play()
+
+func Speaker_HandCrack():
+	var randindex = randi_range(0, soundArray_cracks.size() - 1)
+	speaker_handCrack.stream = soundArray_cracks[randindex]
+	speaker_handCrack.play()
+
+var swapped = false
+func SwapDealerMesh():
+	if (!swapped):
+		dealermesh_normal.set_layer_mask_value(1, false)
+		dealermesh_crushed.set_layer_mask_value(1, true)
+		swapped = true
+	pass
+
+func CoinFlip():
+	var result = randi_range(0, 1)
+	return result
+	pass

DeathManager.gd

@@ -0,0 +1,136 @@
+class_name DeathManager extends Node
+
+@export var viewblocker : ColorRect
+@export var speakersToDisable : Array[SpeakerController]
+@export var animator_playerDefib : AnimationPlayer
+@export var defibParent : Node3D
+@export var speaker_playerDefib : AudioStreamPlayer2D
+@export var cameraShaker : CameraShaker
+@export var healthCounter : HealthCounter
+@export var animator_shotgun : AnimationPlayer
+@export var ejectManager_player : ShellEjectManager
+@export var ejectManager_dealer : ShellEjectManager
+@export var shotgunShooting : ShotgunShooting
+@export var animator_dealer : AnimationPlayer
+@export var speaker_crash : AudioStreamPlayer3D
+@export var dealerAI : DealerIntelligence
+@export var animator_dealerHands : AnimationPlayer
+@export var shellLoader : ShellLoader
+@export var scene_death : PackedScene
+@export var savefile : SaveFileManager
+@export var filter : FilterController
+@export var animator_pp : AnimationPlayer
+@export var speaker_heartbeat : AudioStreamPlayer2D
+
+func _ready():
+	defibParent.visible = false
+
+var shitIsFuckedUp = false
+func Kill(who : String, trueDeath : bool, returningShotgun : bool):
+	var dealerKilledSelf = false
+	shitIsFuckedUp = false
+	match(who):
+		"player":
+			if (trueDeath):
+				pass
+			else:
+				await get_tree().create_timer(.08, false).timeout
+				viewblocker.visible = true
+				if (returningShotgun):
+					var addingDelay = false
+					animator_shotgun.play("RESET")
+					ejectManager_player.DeathEjection()
+					await get_tree().create_timer(2)
+					if (shotgunShooting.roundManager.health_opponent == 1 or shotgunShooting.roundManager.health_player == 1): addingDelay = true
+					#if (shellLoader.roundManager.shellSpawner.sequenceArray.size() != 0): shotgunShooting.delaying = true
+					if (shotgunShooting.roundManager.health_player == 1): shitIsFuckedUp = true
+					if (shotgunShooting.roundManager.health_player != 0): shotgunShooting.FinalizeShooting(shotgunShooting.playerCanGoAgain, false, true, addingDelay)
+				DisableSpeakers()
+				if (shotgunShooting.roundManager.health_player == 0):
+					shotgunShooting.roundManager.OutOfHealth("player")
+					return
+				await get_tree().create_timer(.4, false).timeout
+				speaker_playerDefib.play()
+				await get_tree().create_timer(.85, false).timeout
+				speaker_heartbeat.play()
+				animator_pp.play("revival brightness")
+				defibParent.visible = true
+				animator_playerDefib.play("RESET")
+				viewblocker.visible = false
+				filter.BeginPan(filter.lowPassMaxValue, filter.lowPassDefaultValue)
+				FadeInSpeakers()
+				cameraShaker.Shake()
+				await get_tree().create_timer(.6, false).timeout
+				animator_playerDefib.play("remove defib device")
+				await get_tree().create_timer(.4, false).timeout
+				await(healthCounter.UpdateDisplayRoutine(false, !shotgunShooting.playerCanGoAgain, false))
+				defibParent.visible = false
+				pass
+		"dealer":
+			if (trueDeath):
+				pass
+			else:
+				if (returningShotgun):
+					dealerKilledSelf = true
+					shotgunShooting.MainSlowDownRoutine("dealer", true)
+					animator_shotgun.play("enemy return shotgun self")
+					dealerAI.dealerHoldingShotgun = false	
+					ejectManager_dealer.DeathEjection()
+				animator_dealer.play("dealer fly away")
+				animator_dealerHands.play("hide hands")
+				dealerAI.SwapDealerMesh()
+				shellLoader.shotgunHand_L.visible = false
+				shellLoader.shotgunHand_R.visible = false
+				shotgunShooting.roundManager.dealerAtTable = false
+				await get_tree().create_timer(.4, false).timeout
+				speaker_crash.play()
+				if (!dealerKilledSelf):
+					#player shot dealer. eject shell and end turn here.
+					shotgunShooting.ShootingDealerEjection(shotgunShooting.shellSpawner.sequenceArray[0], "dealer", false)
+					pass
+				await get_tree().create_timer(1.8, false).timeout
+				if(shotgunShooting.roundManager.health_opponent == 0):
+					shotgunShooting.roundManager.OutOfHealth("dealer")
+					healthCounter.UpdateDisplayRoutine(false, false, true)
+					return
+				if (shotgunShooting.roundManager.health_player == 0):
+					shotgunShooting.roundManager.OutOfHealth("player")
+					return
+				if (dealerKilledSelf): healthCounter.checkingPlayer = true
+				else: healthCounter.checkingPlayer = false
+				await(healthCounter.UpdateDisplayRoutine(false, true, false))
+				if (!shotgunShooting.roundManager.dealerCuffed): 
+					animator_dealerHands.play("dealer hands on table")
+					shotgunShooting.roundManager.waitingForDealerReturn = true
+				else: 
+					animator_dealerHands.play("dealer hands on table cuffed")
+					shotgunShooting.roundManager.waitingForReturn = true
+				animator_dealer.play("dealer return to table")
+				await get_tree().create_timer(2, false).timeout
+				if (dealerKilledSelf): dealerAI.EndDealerTurn(dealerAI.dealerCanGoAgain)
+
+func MainDeathRoutine():
+	var loadingHeaven = false
+	if(shotgunShooting.roundManager.wireIsCut_player): 
+		shotgunShooting.roundManager.playerData.enteringFromTrueDeath = true
+		loadingHeaven = true
+	shotgunShooting.roundManager.playerData.playerEnteringFromDeath = true
+	savefile.SaveGame()
+	await get_tree().create_timer(.5, false).timeout
+	if (!loadingHeaven): get_tree().change_scene_to_file("res://scenes/death.tscn")
+	else: get_tree().change_scene_to_file("res://scenes/heaven.tscn")
+	pass
+
+func DisableSpeakers():
+	for i in range(speakersToDisable.size()):
+		speakersToDisable[i].SnapVolume(false)
+
+func FadeInSpeakers():
+	for i in range(speakersToDisable.size()):
+		speakersToDisable[i].fadeDuration = 3
+		speakersToDisable[i].FadeIn()
+		#if (i != 1):
+		#	speakersToDisable[i].fadeDuration = 3
+		#	speakersToDisable[i].FadeIn()
+		#else:
+		#	speakersToDisable[i].SnapVolume(true)

DecisionTextManager.gd

@@ -0,0 +1,22 @@
+class_name DecisionTextManager extends Node
+
+@export var textArray : Array[TextInteraction]
+@export var colliderArray : Array[StaticBody3D]
+@export var animator : AnimationPlayer
+
+func _ready():
+	for i in range(colliderArray.size()):
+		colliderArray[i].collision_layer = 0
+		colliderArray[i].collision_mask = 0
+
+func SetUI(state : bool):
+	if (state):
+		for i in range(colliderArray.size()):
+			colliderArray[i].collision_layer = 1
+			colliderArray[i].collision_mask = 1
+		animator.play("show text")
+	else:
+		for i in range(colliderArray.size()):
+			colliderArray[i].collision_layer = 0
+			colliderArray[i].collision_mask = 0
+		animator.play("hide text")

DefibBlade.gd

@@ -0,0 +1,17 @@
+class_name DefibBlade extends Node
+
+@export var anim : AnimationPlayer
+@export var speaker : AudioStreamPlayer2D
+@export var sound_open : AudioStream
+@export var sound_close : AudioStream
+@export var wire_normal : Node3D
+@export var wire_broken : Node3D
+
+func Blade(state : String, playSound : bool):
+	anim.play(state)
+	if (state == "open"): speaker.stream = sound_open
+	else: 
+		speaker.stream = sound_close
+		wire_normal.visible = false
+		wire_broken.visible = true
+	if (playSound): speaker.play()

DefibCutter.gd

@@ -0,0 +1,161 @@
+class_name DefibCutter extends Node
+
+@export var cam : CameraManager
+@export var dia : Dialogue
+@export var animator_main : AnimationPlayer
+@export var consoleArray : Array[Node3D]
+@export var speaker_motor : AudioStreamPlayer2D
+@export var speaker_bootup : AudioStreamPlayer2D
+@export var speaker_beep : AudioStreamPlayer2D
+@export var speaker_blademove : AudioStreamPlayer2D
+@export var blade_player : DefibBlade
+@export var blade_dealer : DefibBlade
+@export var roundManager : RoundManager
+@export var errorUI_player : Node3D
+@export var errorUI_dealer : Node3D
+@export var speaker_error : AudioStreamPlayer2D
+@export var soundArray_error : Array[AudioStream]
+@export var healthUI_player : Node3D
+@export var healthUI_dealer : Node3D
+@export var healthUI_divider : Node3D
+
+var cutDialogueSent = false
+
+func InitialSetup():
+	cam.BeginLerp("defib setup")
+	await get_tree().create_timer(.6, false).timeout
+	animator_main.play("initial setup")
+	speaker_motor.play()
+	await get_tree().create_timer(3.6, false).timeout
+	cam.BeginLerp("defib console")
+	speaker_bootup.play()
+	await get_tree().create_timer(1.9, false).timeout
+	for i in range(consoleArray.size()):
+		consoleArray[i].visible = true
+		speaker_beep.pitch_scale = randf_range(.8, 1.0)
+		speaker_beep.play()
+		await get_tree().create_timer(.09, false).timeout
+	await get_tree().create_timer(.4, false).timeout
+	cam.BeginLerp("defib setup")
+	await get_tree().create_timer(.6, false).timeout
+	blade_player.Blade("open", true)
+	blade_dealer.Blade("open", false)
+	await get_tree().create_timer(.5, false).timeout
+	animator_main.play("main setup")
+	speaker_blademove.play()
+	await get_tree().create_timer(.6, false).timeout
+	cam.BeginLerp("defib blade insert")
+	await get_tree().create_timer(1.8, false).timeout
+	cam.BeginLerp("home")
+	await get_tree().create_timer(.6, false).timeout
+
+func CutWire(who : String):
+	var tempwho = who
+	var origsocket = cam.activeSocket
+	cam.BeginLerp("enemy")
+	await get_tree().create_timer(3, false).timeout
+	if (!cutDialogueSent):
+		dia.ShowText_Forever("ARE YOU READY?")
+		await get_tree().create_timer(4, false).timeout
+		dia.HideText()
+		await get_tree().create_timer(.2, false).timeout
+		cutDialogueSent = true
+	cam.BeginLerp("defib blade insert")
+	await get_tree().create_timer(1, false).timeout
+	if (who == "player"): blade_player.Blade("close", true)
+	if (who == "dealer"): blade_dealer.Blade("close", true)
+	roundManager.requestedWireCut = false
+	roundManager.wireToCut = ""
+	await get_tree().create_timer(.05, false).timeout
+	BreakDisplay(tempwho)
+	await get_tree().create_timer(.8, false).timeout
+	cam.BeginLerp("health counter")
+	await get_tree().create_timer(.6, false).timeout
+	FlashError(tempwho)
+	await get_tree().create_timer(.8, false).timeout
+	cam.BeginLerp(origsocket)
+	await get_tree().create_timer(1, false).timeout
+
+#.36
+func FlashError(who : String):
+	var act = null
+	if (who == "player"): act = errorUI_player
+	else: act = errorUI_dealer
+	act.visible = true
+	PlayError()
+	await get_tree().create_timer(.05, false).timeout
+	act.visible = false
+	await get_tree().create_timer(.05, false).timeout
+	act.visible = true
+	PlayError()
+	await get_tree().create_timer(.11, false).timeout
+	act.visible = false
+	await get_tree().create_timer(.05, false).timeout
+	act.visible = true
+	PlayError()
+	await get_tree().create_timer(.05, false).timeout
+	act.visible = false
+	PlayError()
+
+func BlipError(who : String):
+	var act = null
+	if (who == "player"): act = errorUI_player
+	else: act = errorUI_dealer
+	act.visible = true
+	PlayError()
+	await get_tree().create_timer(.05, false).timeout
+	act.visible = false
+	await get_tree().create_timer(.05, false).timeout
+	act.visible = true
+	PlayError()
+	await get_tree().create_timer(.11, false).timeout
+	act.visible = false
+	PlayError()
+
+func BlipError_Both():
+	errorUI_dealer.visible = true
+	errorUI_player.visible = true
+	PlayError()
+	await get_tree().create_timer(.05, false).timeout
+	errorUI_dealer.visible = false
+	errorUI_player.visible = false
+	await get_tree().create_timer(.05, false).timeout
+	errorUI_dealer.visible = true
+	errorUI_player.visible = true
+	PlayError()
+	await get_tree().create_timer(.11, false).timeout
+	errorUI_dealer.visible = false
+	errorUI_player.visible = false
+	PlayError()
+
+var displayBroken_player = false
+var displayBroken_dealer = false
+func BreakDisplay(who : String):
+	if (who == "player"):
+		healthUI_player.visible = false
+		displayBroken_player = true
+	else:
+		healthUI_dealer.visible = false
+		displayBroken_dealer = true
+	if (displayBroken_dealer && displayBroken_player):
+		healthUI_divider.visible = false
+
+func PlayError():
+	var index = randi_range(0, soundArray_error.size() - 1)
+	var s = soundArray_error[index]
+	speaker_error.stream = s
+	speaker_error.play()
+
+
+
+
+
+
+
+
+
+
+
+
+
+

DescriptionManager.gd

@@ -0,0 +1,61 @@
+class_name DescriptionManager extends Node
+
+@export var interaction : InteractionManager
+@export var uiArray : Array[Label]
+@export var dur : float
+
+var elapsed
+var moving = false
+var current_opacity = 0.0
+var next_opacity = 1.0
+
+var started = false
+
+func _ready():
+	HideText()
+
+func _process(delta):
+	LerpText()
+	CheckInteraction()
+
+func HideText():
+	for i in range(uiArray.size()):
+		uiArray[i].modulate.a = 0
+	pass
+
+func CheckInteraction():
+	if (interaction.activeParent != null):
+		var childArray = interaction.activeParent.get_children()
+		var found = false
+		for i in range(childArray.size()):
+			if (childArray[i] is PickupIndicator):
+				found = true
+				return
+		if (!found && started):
+			EndLerp()
+			started = false
+
+func BeginLerp():
+	started = true
+	current_opacity = uiArray[0].modulate.a
+	next_opacity = 1.0
+	elapsed = 0.0
+	moving = true
+	pass
+	
+func EndLerp():
+	current_opacity = uiArray[0].modulate.a
+	next_opacity = 0.0
+	elapsed = 0.0
+	moving = true
+	pass
+	
+func LerpText():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / dur, 0.0, 1.0)
+		var opacity = lerp(current_opacity, next_opacity, c)
+		for i in range(uiArray.size()):
+			var color = Color(uiArray[i].modulate.r, uiArray[i].modulate.g, uiArray[i].modulate.b, opacity)
+			uiArray[i].modulate = color
+	pass

DialogueManager.gd

@@ -0,0 +1,59 @@
+class_name Dialogue extends Node
+
+@export var speaker_click : AudioStreamPlayer2D
+@export var soundArray_clicks : Array[AudioStream]
+@export var dialogueUI : Label
+@export var dialogueUI_backdrop : ColorRect
+@export var dialogueSpeed : float
+@export var incrementDelay : float
+
+var dealerLowPitched = false
+var elapsed = 0
+var moving = false
+var looping = false
+
+func _ready():
+	speaker_click.stream = soundArray_clicks[3]
+
+func ShowText_ForDuration(activeText : String, showDuration : float):
+	looping = false
+	dialogueUI.visible_characters = 0
+	dialogueUI.text = activeText
+	dialogueUI.visible = true
+	dialogueUI_backdrop.visible = true
+	looping = true
+	TickText()
+	await get_tree().create_timer(showDuration, false).timeout
+	looping = false
+	dialogueUI.visible = false
+	dialogueUI_backdrop.visible = false
+
+func ShowText_Forever(activeText : String):
+	looping = false
+	dialogueUI.visible_characters = 0
+	dialogueUI.text = activeText
+	dialogueUI.visible = true
+	dialogueUI_backdrop.visible = true
+	looping = true
+	TickText()
+
+func ShowDealerInspectionText():
+	ShowText_Forever("VERY INTERESTING ...")
+
+func HideText():
+	looping = false
+	dialogueUI.visible = false
+	dialogueUI_backdrop.visible = false
+	pass
+
+func TickText():
+	while(looping):
+		dialogueUI.visible_characters += 1
+		if (!dealerLowPitched): speaker_click.pitch_scale = randf_range(0.5, .6)
+		else: speaker_click.pitch_scale = randf_range(.2, .3)
+		speaker_click.play()
+		if (dialogueUI.visible_ratio >= 1):
+			looping = false
+		await get_tree().create_timer(incrementDelay, false).timeout
+		pass
+	pass

DialogueManager_Ending.gd

@@ -0,0 +1,38 @@
+class_name DialogueEnding extends Node
+
+@export var speaker_click : AudioStreamPlayer2D
+@export var soundArray_clicks : Array[AudioStream]
+@export var dialogueUI : Label
+@export var dialogueSpeed : float
+@export var incrementDelay : float
+
+var elapsed = 0
+var moving = false
+var looping = false
+
+func _ready():
+	speaker_click.stream = soundArray_clicks[0]
+
+func ShowText_Forever(activeText : String):
+	looping = false
+	dialogueUI.visible_characters = 0
+	dialogueUI.text = activeText
+	dialogueUI.visible = true
+	looping = true
+	TickText()
+
+func HideText():
+	looping = false
+	dialogueUI.visible = false
+	pass
+
+func TickText():
+	while(looping):
+		dialogueUI.visible_characters += 1
+		speaker_click.pitch_scale = randf_range(.8, 1)
+		speaker_click.play()
+		if (dialogueUI.visible_ratio >= 1):
+			looping = false
+		await get_tree().create_timer(incrementDelay, false).timeout
+		pass
+	pass

EndingManager.gd

@@ -0,0 +1,142 @@
+class_name EndingManager extends Node
+
+@export var roundManager : RoundManager
+@export var pp : WorldEnvironment
+@export var animator_cam : AnimationPlayer
+@export var animator_backdrop : AnimationPlayer
+@export var cam : CameraManager
+@export var blockout : Array[Node3D]
+@export var viewblocker : ColorRect
+@export var animator_viewblocker : AnimationPlayer
+@export var animator_streetlights : AnimationPlayer
+@export var music_ending : AudioStreamPlayer2D
+@export var dia : DialogueEnding
+@export var label_congrats : Label
+@export var label_array : Array[Label]
+@export var uiparent : Control
+@export var animator_congrats : AnimationPlayer
+@export var animator_cash : AnimationPlayer
+@export var fireArray : Array[TextFire]
+@export var speaker_load : AudioStreamPlayer2D
+@export var speaker_ambience : AudioStreamPlayer2D
+@export var cntrl_ambience : SpeakerController
+@export var cntrl_endingmusic : SpeakerController
+@export var animator_anykey : AnimationPlayer
+@export var animator_pan : AnimationPlayer
+var waitingForInput = false
+
+func _input(event):
+	if event is InputEventKey and event.pressed:
+		if (waitingForInput): 
+			ExitGame()
+			waitingForInput = false
+
+func BeginEnding():
+	cam.moving = false
+	animator_pan.play("pan to brief")
+	music_ending.play()
+	AmbienceFade()
+	await get_tree().create_timer(10.67, false).timeout
+	viewblocker.visible = true
+	animator_viewblocker.play("snap")
+	animator_pan.stop()
+	SetupEnding()
+	FinalScore()
+	for l in label_array: l.visible = false
+	label_congrats.visible = false
+	await get_tree().create_timer(1.2, false).timeout
+	animator_viewblocker.play("fade out")
+	await get_tree().create_timer(6, false).timeout
+	#SHOW UI
+	label_congrats.visible = true
+	animator_congrats.play("wobble it")
+	animator_cash.play("wobble it")
+	dia.ShowText_Forever(glob_text_congratulations)
+	await get_tree().create_timer(2, false).timeout
+	for i in fireArray:
+		speaker_load.pitch_scale = randf_range(.95, 1)
+		speaker_load.play()
+		await get_tree().create_timer(.15, false).timeout
+	await get_tree().create_timer(.5, false).timeout
+	for i in range(fireArray.size()):
+		if (i == 5): 
+			await get_tree().create_timer(.4, false).timeout
+			fireArray[i].changed = true
+			fireArray[i].speaker.pitch_scale = .15
+		fireArray[i].Fire()
+		await get_tree().create_timer(.33, false).timeout
+	await get_tree().create_timer(3, false).timeout
+	GetInput()
+
+func GetInput():
+	animator_anykey.play("flicker")
+	await get_tree().create_timer(.8, false).timeout
+	waitingForInput = true
+
+func ExitGame():
+	animator_viewblocker.play("fade in")
+	cntrl_endingmusic.FadeOut()
+	cntrl_ambience.fadeDuration = 3
+	cntrl_ambience.FadeOut()
+	isActive = false
+	await get_tree().create_timer(4, false).timeout
+	get_tree().quit()
+
+var isActive = true
+func AmbienceFade():
+	await get_tree().create_timer(55, false).timeout
+	if (isActive):
+		cntrl_ambience.SnapVolume(false)
+		speaker_ambience.play()
+		cntrl_ambience.FadeIn()
+
+func SetupEnding():
+	await get_tree().create_timer(.1, false).timeout
+	uiparent.visible = true
+	for b in blockout: b.visible = true
+	pp.environment.adjustment_brightness = 5.68
+	pp.environment.adjustment_contrast = 1.3
+	pp.environment.adjustment_saturation = .26
+	cam.moving = false
+	cam.cam.fov = 60
+	animator_streetlights.play("looping")
+	animator_backdrop.play("loop exterior")
+	animator_cam.play("camera loop car")
+
+var glob_text_congratulations
+func FinalScore():
+	var playername = roundManager.playerData.playername
+	var shots_fired = roundManager.playerData.stat_shotsFired
+	var shells_ejected = roundManager.playerData.stat_shellsEjected
+	var doors_kicked = roundManager.playerData.stat_doorsKicked
+	var cigarettes_smoked = roundManager.playerData.stat_cigSmoked
+	var ml_of_beer_drank = roundManager.playerData.stat_beerDrank
+	var max_cash = 70000
+	
+	var cancer_bills = cigarettes_smoked * 220
+	var new_leg_bones_price = doors_kicked * 1000
+	var DUI_fine = ml_of_beer_drank * 1.5
+	var total_cash = max_cash - cancer_bills - DUI_fine
+	if (doors_kicked > 2): total_cash -= new_leg_bones_price
+	if (total_cash < 0): total_cash = 0
+	
+	#if (playername == "sex"): total_cash = 69
+	#if (playername == "leet"): total_cash = 1337
+	#if (playername == "snoop" or playername == "weed" or playername == "kush"): total_cash = 420
+	
+	var text_congratulations = "CONGRATULATIONS, " + playername + "!"
+	var text_shotsFired = "shots fired ........ " + str(shots_fired)
+	var text_shellsEjected = "shells ejected ..... " + str(shells_ejected)
+	var text_doorsKicked = "doors kicked ....... " + str(doors_kicked)
+	var text_cigSmoked = "cigarettes smoked .. " + str(cigarettes_smoked)
+	var text_beerDrank = "ml of beer drank ... " + str(ml_of_beer_drank)
+	var text_totalcash = "total cash: " + str(total_cash) + " $"
+	
+	glob_text_congratulations = text_congratulations
+	
+	label_array[0].text = text_shotsFired
+	label_array[1].text = text_shellsEjected
+	label_array[2].text = text_doorsKicked
+	label_array[3].text = text_cigSmoked
+	label_array[4].text = text_beerDrank
+	label_array[5].text = text_totalcash

FilterController.gd

@@ -0,0 +1,38 @@
+class_name FilterController extends Node
+
+@export var panDuration : float
+@export var lowPassDefaultValue : float
+@export var lowPassMaxValue : float
+
+var effect_lowPass
+var moving = false
+var elapsed = 0
+var begin
+var dest
+
+func _ready():
+	effect_lowPass = AudioServer.get_bus_effect(1, 0)
+	effect_lowPass.cutoff_hz = lowPassDefaultValue
+
+func _process(delta):
+	PanLowPass_HighLow()
+
+func BeginSnap(valueTo : float):
+	moving = false
+	elapsed = 0
+	effect_lowPass.cutoff_hz = valueTo
+
+func BeginPan(valueFrom : float, valueTo : float):
+	moving = false
+	elapsed = 0
+	begin = valueFrom
+	dest = valueTo
+	moving = true
+
+func PanLowPass_HighLow():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / panDuration, 0.0, 1.0)
+		c = ease(c, 0.4)
+		var panValue = lerpf(begin, dest, c)
+		effect_lowPass.cutoff_hz = panValue

GameOverManager.gd

@@ -0,0 +1,4 @@
+class_name GameOverManager extends Node
+
+func PlayerWon():
+	get_tree().change_scene_to_file("res://scenes/win.tscn")	

HandManager.gd

@@ -0,0 +1,183 @@
+class_name HandManager extends Node
+
+@export var dealerAI : DealerIntelligence
+@export var itemManager : ItemManager
+@export var animator_hands : AnimationPlayer
+@export var animator_dealerHeadLook : AnimationPlayer
+@export var handArray_L : Array[Node3D]
+@export var handArray_R : Array[Node3D]
+@export var gridOffsetArray : Array[Vector3] #ITEM'S ACTIVE GRID INDEX STORED IN PICKUP INDICATOR: dealerGridIndex
+
+@export var handParent_L : Node3D
+@export var handParent_R : Node3D
+@export var hand_defaultL : Node3D
+@export var hand_defaultR : Node3D
+@export var hand_cigarettepack : Node3D 	#L
+@export var hand_beer : Node3D 				#L
+@export var hand_handcuffs : Node3D 		#R
+@export var hand_handsaw : Node3D 			#R
+@export var hand_magnifier : Node3D 		#R
+
+@export var lerpDuration : float
+@export var handRot_left : Vector3 #hand rotation when grabing from left grids
+@export var handRot_right : Vector3 #same shit
+@export var parentOriginal_posL : Vector3
+@export var parentOriginal_rotL : Vector3
+@export var parentOriginal_posR : Vector3
+@export var parentOriginal_rotR : Vector3
+var moving = false
+var lerping_L = false
+var lerping_R = false
+var pos_current
+var pos_next
+var rot_current
+var rot_next
+var elapsed = 0
+var orig_pos
+var orig_rot
+var activeHandParent
+var activeItemToGrab
+
+func _process(delta):
+	LerpHandMovement()
+
+func PickupItemFromTable(itemName : String):
+	dealerAI.Speaker_HandCrack()
+	var activeIndex
+	var activeInstance
+	var whichHandToGrabWith
+	var whichGridSide
+	var matchIndex
+	activeItemToGrab = itemName 
+	for i in range(itemManager.itemArray_instances_dealer.size()):
+		if (itemName == itemManager.itemArray_instances_dealer[i].get_child(1).itemName):
+			activeInstance = itemManager.itemArray_instances_dealer[i]
+			matchIndex = i
+			break
+	activeIndex = activeInstance.get_child(0).dealerGridIndex
+	ToggleHandVisible("BOTH", false)
+	hand_defaultL.visible = true
+	hand_defaultR.visible = true
+	if (itemName == "beer" or itemName == "cigarettes"): whichHandToGrabWith = "left"
+	else: whichHandToGrabWith = "right"
+	whichGridSide = activeInstance.get_child(0).whichSide
+	animator_hands.play("RESET")
+	BeginHandLerp(whichHandToGrabWith, activeIndex, whichGridSide)
+	if (whichGridSide == "right"): animator_dealerHeadLook.play("dealer look right")
+	else: animator_dealerHeadLook.play("dealer look left")
+	await get_tree().create_timer(lerpDuration -.4, false).timeout
+	if (whichHandToGrabWith == "right"): hand_defaultR.visible = false
+	else: hand_defaultL.visible = false
+	dealerAI.Speaker_HandCrack()
+	match (itemName):
+		"handsaw":
+			hand_handsaw.visible = true
+		"magnifying glass":
+			hand_magnifier.visible = true
+		"handcuffs":
+			hand_handcuffs.visible = true
+		"cigarettes":
+			hand_cigarettepack.visible = true
+			itemManager.numberOfCigs_dealer -= 1
+		"beer":
+			hand_beer.visible = true
+	itemManager.itemArray_instances_dealer.remove_at(matchIndex)
+	var tempindicator = activeInstance.get_child(0)
+	var gridname = tempindicator.dealerGridName
+	itemManager.gridParentArray_enemy_available.append(gridname)
+	activeInstance.queue_free()
+	await get_tree().create_timer(.2, false).timeout
+	ReturnHand()
+	if (whichGridSide == "right"): animator_dealerHeadLook.play("dealer look forward from right")
+	else: animator_dealerHeadLook.play("dealer look forward from left")
+	await get_tree().create_timer(lerpDuration + .01, false).timeout
+	HandFailsafe()
+	var animationName = "dealer use " + itemName
+	animator_hands.play("RESET")
+	animator_hands.play(animationName)
+	var length = animator_hands.get_animation(animationName).get_length()
+	moving = false
+	await get_tree().create_timer(length, false).timeout
+	pass
+
+func ToggleHandVisible(selectedHand : String, state : bool):
+	if (selectedHand == "L" or "BOTH"):
+		for i in range(handArray_L.size()):
+			if (state): handArray_L[i].visible = true
+			else: handArray_L[i].visible = false
+	if (selectedHand == "R" or "BOTH"):
+		for i in range(handArray_R.size()):
+			if (state): handArray_R[i].visible = true
+			else: handArray_R[i].visible = false
+
+func BeginHandLerp(whichHand : String, gridIndex : int, whichSide : String):
+	if (whichHand == "right"): activeHandParent = handParent_R
+	else: activeHandParent = handParent_L
+	pos_current = activeHandParent.transform.origin
+	rot_current = activeHandParent.rotation_degrees
+	orig_pos = pos_current
+	orig_rot = rot_current
+	pos_next = gridOffsetArray[gridIndex]
+	lerping_L = false
+	lerping_R = false
+	if(whichSide == "right"): rot_next = handRot_right
+	else: rot_next = handRot_left
+	if(whichHand == "right"): lerping_R = true
+	else: lerping_L = true
+	elapsed = 0
+	moving = true
+
+func ReturnHand():
+	pos_current = activeHandParent.transform.origin
+	rot_current = activeHandParent.rotation_degrees
+	pos_next = orig_pos
+	rot_next = orig_rot
+	elapsed = 0
+	moving = true
+
+func HandFailsafe():
+	handParent_L.transform.origin = parentOriginal_posL
+	handParent_L.rotation_degrees = parentOriginal_rotL
+	handParent_R.transform.origin = parentOriginal_posR
+	handParent_R.rotation_degrees = parentOriginal_rotR
+
+func LerpHandMovement():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / lerpDuration, 0.0, 1.0)
+		c = ease(c, 0.2)
+		if (lerping_L):
+			var pos = lerp(pos_current, pos_next, c)
+			var rot = lerp(rot_current, rot_next, c)
+			handParent_L.transform.origin = pos
+			handParent_L.rotation_degrees = rot
+		if (lerping_R):
+			var pos = lerp(pos_current, pos_next, c)
+			var rot = lerp(rot_current, rot_next, c)
+			handParent_R.transform.origin = pos
+			handParent_R.rotation_degrees = rot
+		pass
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

HandcuffManager.gd

@@ -0,0 +1,56 @@
+class_name HandcuffManager extends Node
+
+@export var dealerAI : DealerIntelligence
+@export var roundManager : RoundManager
+@export var camera : CameraManager
+@export var animator_handcuffsPlayer : AnimationPlayer
+@export var handcuffs_player : Node3D
+
+var previousSocket
+
+func AttachHandCuffs():
+	animator_handcuffsPlayer.play("RESET")
+	await get_tree().create_timer(.1, false).timeout
+	handcuffs_player.visible = true
+
+func CheckPlayerHandCuffs(lerpingToPrevious : bool):
+	previousSocket = camera.activeSocket
+	camera.BeginLerp("check handcuffs")
+	await get_tree().create_timer(.6, false).timeout
+	animator_handcuffsPlayer.play("check handcuffs")
+	await get_tree().create_timer(.8, false).timeout
+	if (lerpingToPrevious): camera.BeginLerp(previousSocket)
+	
+func BreakPlayerHandCuffs(lerpingToPrevious : bool):
+	previousSocket = camera.activeSocket
+	camera.BeginLerp("check handcuffs")
+	await get_tree().create_timer(.6, false).timeout
+	animator_handcuffsPlayer.play("player break handcuffs")
+	await get_tree().create_timer(.8, false).timeout
+	if (lerpingToPrevious): camera.BeginLerp(previousSocket)
+	
+func CheckPlayerHandCuffs_Animation():
+	previousSocket = camera.activeSocket
+	camera.BeginLerp("check handcuffs")
+	await get_tree().create_timer(.6, false).timeout
+	animator_handcuffsPlayer.play("check handcuffs")
+	await get_tree().create_timer(.8, false).timeout
+	camera.BeginLerp(previousSocket)
+
+func RemoveAllCuffsRoutine():
+	if (roundManager.dealerCuffed):
+		camera.BeginLerp("enemy cuffs close")
+		await get_tree().create_timer(.3, false).timeout
+		dealerAI.animator_dealerHands.play("dealer break cuffs")
+		dealerAI.speaker_breakHandcuffs.play()
+		dealerAI.dealerAboutToBreakFree = false
+		roundManager.dealerCuffed = false
+		await get_tree().create_timer(.47, false).timeout
+	if (roundManager.playerCuffed):
+		camera.BeginLerp("check handcuffs")
+		await get_tree().create_timer(.6, false).timeout
+		animator_handcuffsPlayer.play("player break handcuffs")
+		roundManager.playerCuffed = false
+		roundManager.playerAboutToBreakFree = false
+		await get_tree().create_timer(.8, false).timeout
+	pass

HealthCounter.gd

@@ -0,0 +1,195 @@
+class_name HealthCounter extends Node
+
+@export var ui_playerwin : Label3D
+@export var defibCutter : DefibCutter
+@export var roundManager : RoundManager
+@export var symbolArray_player : Array[MeshInstance3D]
+@export var symbolArray_enemy : Array[MeshInstance3D]
+@export var uiparent : Node3D
+@export var ui_playername : Label3D
+@export var uiArray : Array[Node3D]
+@export var speaker_bootup : AudioStreamPlayer3D
+@export var speaker_beep : AudioStreamPlayer3D
+@export var speaker_noise : AudioStreamPlayer3D
+@export var camera : CameraManager
+@export var animator_flickerEnemy : AnimationPlayer
+@export var animator_flickerPlayer : AnimationPlayer
+@export var animator_playerHands : AnimationPlayer
+@export var animator_dealerHands : AnimationPlayer
+@export var dialogue : Dialogue
+@export var speaker_truedeath : AudioStreamPlayer2D
+@export var skullSymbols : Array[VisualInstance3D]
+
+var dialogueEntered_player = false
+var dialogueEntered_dealer = false
+
+func _ready():
+	ClearDisplay()
+	pass
+
+var setting = true
+func SetupHealth():
+	if (roundManager.roundArray[roundManager.currentRound].isFirstRound):
+		if (setting):
+			ui_playername.text = roundManager.playerData.playername.to_upper()
+			ui_playerwin.text = roundManager.playerData.playername.to_upper() + " WINS!"
+			setting = false
+		roundManager.health_player = roundManager.roundArray[roundManager.currentRound].startingHealth
+		roundManager.health_opponent = roundManager.roundArray[roundManager.currentRound].startingHealth
+		dialogueEntered_player = false
+		dialogueEntered_dealer = false
+
+func UpdateDisplay():
+	for i in range(symbolArray_player.size()):
+		if (i <= roundManager.health_player):
+			symbolArray_player[i].visible = true
+		else: symbolArray_player[i].visible = false
+	for i in range(symbolArray_enemy.size()):
+		if (i <= roundManager.health_opponent):
+			symbolArray_enemy[i].visible = true
+		else: symbolArray_enemy[i].visible = false
+	FlickerLastDigit()
+	pass
+
+func FlickerLastDigit():
+	if (roundManager.health_player == 1): animator_flickerPlayer.play("flicker digit")
+	else: animator_flickerPlayer.play("RESET")
+	if (roundManager.health_opponent == 1): animator_flickerEnemy.play("flicker digit")
+	else: animator_flickerEnemy.play("RESET")
+
+var playerShotSelf = false
+var trueDeathSetup = false
+var checkingPlayer = false
+func UpdateDisplayRoutine(isRaisingHealth : bool, goingToPreviousSocket : bool, showPlayerWin : bool):
+	var indicating = true
+	if (roundManager.dealerCuffed && playerShotSelf): 
+		roundManager.waitingForHealthCheck = true
+		playerShotSelf = false
+	if (showPlayerWin):
+		#ERROR - FLICKER BOTH HERE
+		camera.BeginLerp("health counter")
+		await get_tree().create_timer(.8, false).timeout
+		UpdateDisplay()
+		speaker_noise.play()
+		return
+	var previousSocket = camera.activeSocket
+	camera.BeginLerp("health counter")
+	await get_tree().create_timer(.8, false).timeout
+	UpdateDisplay()
+	if (checkingPlayer && defibCutter.displayBroken_player): 
+		indicating = false
+		defibCutter.BlipError("player")
+	if (!checkingPlayer && defibCutter.displayBroken_dealer): 
+		indicating = false
+		defibCutter.BlipError("dealer")
+	if (indicating):
+		if (isRaisingHealth): speaker_beep.play()
+		else: speaker_noise.play()
+	if ((roundManager.health_opponent <= 2 or roundManager.health_player <= 2) && roundManager.playerData.currentBatchIndex == 2):
+		if (roundManager.defibCutterReady && !trueDeathSetup): 
+			#roundManager.musicManager.EndTrack()
+			speaker_truedeath.play()
+			trueDeathSetup = true
+		if (roundManager.health_opponent <= 2 && !roundManager.wireIsCut_dealer): 
+			roundManager.wireToCut = "dealer"
+			roundManager.requestedWireCut = true
+			roundManager.wireIsCut_dealer = true
+			roundManager.health_opponent = 1
+		if (roundManager.health_player <= 2 && !roundManager.wireIsCut_player): 
+			roundManager.wireToCut = "player" 
+			roundManager.requestedWireCut = true
+			roundManager.wireIsCut_player = true
+			roundManager.health_player = 1
+	#if (roundManager.shellSpawner.sequenceArray[0] == null): await get_tree().create_timer(.8, false).timeout
+	await get_tree().create_timer(.7, false).timeout
+	if (roundManager.health_player == 1 && !dialogueEntered_player && !roundManager.wireIsCut_player):
+		if (!roundManager.wireIsCut_player): dialogue.ShowText_ForDuration("CAREFUL, NOW ...", 3)
+		else: dialogue.ShowText_ForDuration("OH MY ...", 3)
+		await get_tree().create_timer(3, false).timeout
+		dialogueEntered_player = true
+	var lerpingCamera = true
+	if (roundManager.shellSpawner.sequenceArray.size() == 0): 
+		#lerpingCamera = false
+		pass
+	if (lerpingCamera):
+		if (goingToPreviousSocket): camera.BeginLerp(previousSocket)
+		else: camera.BeginLerp("home")
+	await get_tree().create_timer(.4, false).timeout
+
+#why can I not add functions with arguments into godot animator :sob:
+func UpdateDisplayRoutineCigarette_Enemy():
+	var maxHealth = roundManager.roundArray[0].startingHealth
+	var changingHealth = false
+	var prevhealth = roundManager.health_opponent
+	if (!roundManager.wireIsCut_dealer): roundManager.health_opponent += 1
+	if (roundManager.health_opponent > maxHealth): roundManager.health_opponent = maxHealth
+	var newhealth = roundManager.health_opponent
+	if (newhealth != prevhealth): changingHealth = true
+	UpdateDisplayRoutineCigarette_Main(changingHealth, true)
+	pass
+
+func UpdateDisplayRoutineCigarette_Player():
+	var maxHealth = roundManager.roundArray[0].startingHealth
+	var changingHealth = false
+	var prevhealth = roundManager.health_player
+	if (!roundManager.wireIsCut_player): roundManager.health_player += 1
+	if (roundManager.health_player > maxHealth): roundManager.health_player = maxHealth
+	var newhealth = roundManager.health_player
+	if (newhealth != prevhealth): changingHealth = true
+	UpdateDisplayRoutineCigarette_Main(changingHealth, false)
+	pass
+
+func UpdateDisplayRoutineCigarette_Main(isChanging : bool, isAddingEnemy : bool):
+	var prevsocket = camera.activeSocket
+	var playingsound = true
+	camera.BeginLerp("health counter")
+	await get_tree().create_timer(.8, false).timeout
+	if (isAddingEnemy && defibCutter.displayBroken_dealer):
+		defibCutter.BlipError("dealer")
+		playingsound = false
+	if (!isAddingEnemy && defibCutter.displayBroken_player):
+		defibCutter.BlipError("player")
+		playingsound = false
+	UpdateDisplay()
+	if (isChanging && playingsound): speaker_beep.play()
+	await get_tree().create_timer(.7, false).timeout
+	if (!isAddingEnemy): 
+		camera.BeginLerp("home")
+		animator_playerHands.play("player revert cigarette")
+	else: 
+		camera.BeginLerp("enemy")
+		animator_dealerHands.play("RESET")
+	pass
+
+func SwapSkullSymbols():
+	for sym in skullSymbols:
+		sym.set_layer_mask_value(1, true)
+		sym.get_parent().set_layer_mask_value(1, false)
+
+#orig .13
+var settingUpBroken = false
+func Bootup():
+	speaker_bootup.play()
+	#uiparent.visible = true
+	ClearDisplay()
+	for i in range(uiArray.size()):
+		uiArray[i].visible = true
+	await get_tree().create_timer(.85, false).timeout
+	if (roundManager.playerData.currentBatchIndex == 2 && !settingUpBroken):
+		speaker_beep.pitch_scale = .09
+		SwapSkullSymbols()
+		settingUpBroken = true
+	speaker_beep.play()
+	UpdateDisplay()
+	pass
+
+func ClearDisplay():
+	for i in range(symbolArray_player.size()):
+		symbolArray_player[i].visible = false
+	for i in range(symbolArray_enemy.size()):
+		symbolArray_enemy[i].visible = false
+
+func DisableCounter():
+	for i in range(uiArray.size()):
+		uiArray[i].visible = false
+	#uiparent.visible = false

HeavenManager.gd

@@ -0,0 +1,60 @@
+class_name Heaven extends Node
+
+@export var cursor : CursorManager
+@export var viewblocker : Control
+@export var speaker_music : AudioStreamPlayer2D
+@export var animator : AnimationPlayer
+@export var intbranch_heavendoor : InteractionBranch
+@export var interactionManager : InteractionManager
+@export var buttonArray : Array[ButtonClass]
+@export var speaker_button : AudioStreamPlayer2D
+
+func _ready():
+	Signals()
+	BeginLoop()
+
+func Signals():
+	buttonArray[0].is_pressed.connect(Button_Retry)
+	buttonArray[1].is_pressed.connect(Button_Exit)
+	pass
+
+func Button_Retry():
+	Button_Main("retry")
+
+func Button_Exit():
+	Button_Main("exit")
+
+func Button_Main(tag : String):
+	speaker_music.stop()
+	speaker_button.play()
+	cursor.SetCursor(false, false)
+	animator.play("fade out")
+	for cl in buttonArray:
+		cl.isActive = false
+	await get_tree().create_timer(3.12, false).timeout
+	match tag:
+		"retry":
+			get_tree().change_scene_to_file("res://scenes/death.tscn")
+		"exit":
+			get_tree().quit()
+
+func BeginLoop():
+	await get_tree().create_timer(1, false).timeout
+	speaker_music.play()
+	viewblocker.visible = false
+	animator.play("camera pan down")
+	animator.queue("camera idle")
+	await get_tree().create_timer(11.1, false).timeout
+	cursor.SetCursor(true, true)
+	intbranch_heavendoor.interactionAllowed = true
+
+func Fly():
+	intbranch_heavendoor.interactionAllowed = false
+	cursor.SetCursor(false, false)
+	animator.play("move")
+	await get_tree().create_timer(15.6, false).timeout
+	cursor.SetCursor(true, true)
+	interactionManager.checking = false
+	for cl in buttonArray:
+		cl.isActive = true
+	pass

InteractionBranch.gd

@@ -0,0 +1,18 @@
+class_name InteractionBranch extends Node
+
+@export var interactionAlias : String
+@export var itemName : String
+@export var interactionAllowed : bool
+@export var isGrid : bool
+@export var gridIndex : int
+@export var itemGridIndex : int
+@export var interactionInvalid : bool
+@export var signatureButton_letterAlias : String
+@export var signatureButton_specialAlias : String
+@export var assignedSignatureButton : SignButton
+
+func _ready():
+	if (signatureButton_letterAlias != ""):
+		assignedSignatureButton = get_parent().get_child(3)
+	if (signatureButton_specialAlias != ""):
+		assignedSignatureButton = get_parent().get_child(3)

InteractionManager.gd

@@ -0,0 +1,104 @@
+class_name InteractionManager extends Node
+
+@export var sign : Signature
+@export var brief : BriefcaseMachine
+@export var heaven : Heaven
+@export var intro : IntroManager
+@export var cursor : CursorManager
+@export var mouseRay : MouseRaycast
+@export var shotgun : ShotgunShooting
+@export var decision : DecisionTextManager
+@export var itemManager : ItemManager
+@export var itemInteraction : ItemInteraction
+var activeParent
+var activeInteractionBranch
+var checking = true
+
+func _process(delta):
+	CheckPickupLerp()
+	CheckInteractionBranch()
+	if (checking): CheckIfHovering()
+	pass
+
+func _input(event):
+	if event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_LEFT and event.pressed:
+		if (activeInteractionBranch != null && activeInteractionBranch.interactionAllowed && !activeInteractionBranch.interactionInvalid):
+			var childArray = activeInteractionBranch.get_parent().get_children()
+			for i in range(childArray.size()): if (childArray[i] is PickupIndicator): childArray[i].SnapToMax()
+			if (!activeInteractionBranch.isGrid): InteractWith(activeInteractionBranch.interactionAlias)
+			else: InteractWithGrid(activeInteractionBranch.gridIndex)
+
+func CheckIfHovering():
+	if (activeInteractionBranch != null && activeInteractionBranch.interactionAllowed):
+		if (activeInteractionBranch.interactionAllowed && !activeInteractionBranch.interactionInvalid):
+			cursor.SetCursorImage("hover")
+		else: if (activeInteractionBranch.interactionAllowed && activeInteractionBranch.interactionInvalid):
+			cursor.SetCursorImage("invalid")
+	else:
+		cursor.SetCursorImage("point")
+
+func InteractWith(alias : String):
+	match(alias):
+		"shotgun":
+			shotgun.GrabShotgun()
+			pass
+		"text dealer":
+			shotgun.Shoot("dealer")
+			decision.SetUI(false)
+		"text you":
+			shotgun.Shoot("self")
+			decision.SetUI(false)
+		"briefcase intake":
+			itemManager.GrabItem()
+		"item":
+			if (activeInteractionBranch.itemName != ""):
+				itemInteraction.PickupItemFromTable(activeInteractionBranch.get_parent(), activeInteractionBranch.itemName)
+		"bathroom door":
+			intro.Interaction_BathroomDoor()
+		"backroom door":
+			intro.Interaction_BackroomDoor()
+		"heaven door":
+			heaven.Fly()
+		"latch left":
+			brief.OpenLatch("L")
+		"latch right":
+			brief.OpenLatch("R")
+		"briefcase lid":
+			brief.OpenLid()
+		"release form on table":
+			sign.PickUpWaiver()
+		"signature machine button":
+			sign.GetInput(activeInteractionBranch.signatureButton_letterAlias, activeInteractionBranch.signatureButton_specialAlias)
+			activeInteractionBranch.assignedSignatureButton.Press()
+
+func InteractWithGrid(tempGridIndex : int):
+	itemManager.PlaceDownItem(tempGridIndex)
+	pass
+
+func CheckPickupLerp():
+	if (mouseRay.result != null && mouseRay.result.has("collider") && cursor.cursor_visible):
+		var parent = mouseRay.result.collider.get_parent()
+		activeParent = parent
+		var childArray = parent.get_children()
+		for i in range(childArray.size()):
+			if (childArray[i] is PickupIndicator):
+				var indicator = childArray[i]
+		pass
+	else:	
+		activeParent = null
+	pass
+
+func CheckInteractionBranch():
+	var isFound = null
+	if (activeParent != null):
+		var childArray = activeParent.get_children()
+		for i in range(childArray.size()):
+			if (childArray[i] is InteractionBranch):
+				var branch = childArray[i]
+				# activeInteractionBranch = childArray[i]
+				isFound = childArray[i]
+				break
+	if (isFound):
+		activeInteractionBranch = isFound
+	else:
+		activeInteractionBranch = null

IntroManager.gd

@@ -0,0 +1,127 @@
+class_name IntroManager extends Node
+
+@export var cameraParent : Node3D
+@export var intbranch_bathroomdoor : InteractionBranch
+@export var intbranch_backroomdoor: InteractionBranch
+@export var cursor : CursorManager
+@export var roundManager : RoundManager
+@export var speaker_amb_restroom : AudioStreamPlayer2D
+@export var viewblocker : Control
+@export var animator_camera : AnimationPlayer
+@export var animator_smokerdude : AnimationPlayer
+@export var musicmanager : MusicManager
+@export var filter : FilterController
+@export var bpmlight : BpmLight
+@export var smokerdude_revival : Node3D
+@export var speaker_defib : AudioStreamPlayer2D
+@export var pos_floor : Vector3
+@export var rot_floor : Vector3
+@export var animator_pp : AnimationPlayer
+@export var cameraShaker : CameraShaker
+@export var dia : Dialogue
+@export var blockout : Blockout
+@export var animator_hint : AnimationPlayer
+
+func _ready():
+	await get_tree().create_timer(.5, false).timeout
+	if (roundManager.playerData.playerEnteringFromDeath && !roundManager.playerData.enteringFromTrueDeath):
+		RevivalBathroomStart()
+	else:
+		MainBathroomStart()
+	pass
+
+func MainBathroomStart():
+	RestRoomIdle()
+	await get_tree().create_timer(.5, false).timeout
+	viewblocker.visible = false
+	MainTrackLoad()
+	await get_tree().create_timer(3, false).timeout
+	Hint()
+	cursor.SetCursor(true, true)
+	intbranch_bathroomdoor.interactionAllowed = true
+
+func Hint():
+	await get_tree().create_timer(1, false).timeout
+	if (!roundManager.playerData.seenHint):
+		animator_hint.play("show")
+		roundManager.playerData.seenHint = true
+
+func RevivalBathroomStart():
+	cameraParent.transform.origin = pos_floor
+	cameraParent.rotation_degrees = rot_floor
+	#animator_smokerdude.stop(true)
+	smokerdude_revival.visible = true
+	await get_tree().create_timer(1, false).timeout
+	speaker_defib.play()
+	await get_tree().create_timer(.85, false).timeout
+	dia.speaker_click.stream = dia.soundArray_clicks[0]
+	animator_smokerdude.play("revive player")
+	cameraShaker.Shake()
+	animator_pp.play("revival brightness")
+	viewblocker.visible = false
+	MainTrackLoad()
+	await get_tree().create_timer(.5, false).timeout
+	animator_smokerdude.play("revive player")
+	dia.ShowText_Forever("YOU'RE LUCKY IT LEFT YOU\nWITH A CHARGE!")
+	var n = roundManager.playerData.playername
+	var firstpart = "GET UP, " + n + "."
+	var secondpart = "\nTHE NIGHT IS YOUNG."
+	var full = firstpart + secondpart
+	await get_tree().create_timer(4, false).timeout
+	dia.ShowText_Forever(full)
+	await get_tree().create_timer(4, false).timeout
+	dia.HideText()
+	animator_pp.play("brightness fade out")
+	await get_tree().create_timer(2.05, false).timeout
+	smokerdude_revival.visible = false
+	RestRoomIdle()
+	animator_pp.play("brightness fade in")
+	dia.speaker_click.stream = dia.soundArray_clicks[3]
+	await get_tree().create_timer(3, false).timeout
+	cursor.SetCursor(true, true)
+	intbranch_bathroomdoor.interactionAllowed = true
+	pass
+
+func MainTrackLoad():
+	var increment = musicmanager.trackArray[roundManager.playerData.currentBatchIndex].bpmIncrement
+	bpmlight.delay = increment
+	musicmanager.LoadTrack()
+	bpmlight.BeginMainLoop()
+	speaker_amb_restroom.play()
+
+func Interaction_BackroomDoor():
+	roundManager.playerData.stat_doorsKicked += 1
+	animator_camera.play("camera enter backroom")
+	intbranch_backroomdoor.interactionAllowed = false
+	cursor.SetCursor(false, false)
+
+func Interaction_BathroomDoor():
+	intbranch_bathroomdoor.interactionAllowed = false
+	cursor.SetCursor(false, false)
+	animator_camera.play("camera exit bathroom")
+	await get_tree().create_timer(5, false).timeout
+	cursor.SetCursor(true, true)
+	intbranch_backroomdoor.interactionAllowed = true
+	pass
+
+
+func BeginGame():
+	blockout.HideClub()
+	roundManager.BeginMainGame()
+
+func PanFilter():
+	filter.BeginPan(filter.lowPassMaxValue, filter.lowPassDefaultValue)
+	pass
+
+func KickDoorBackroom():
+	pass
+
+func KickDoorLobby():
+	roundManager.playerData.stat_doorsKicked += 1
+	await get_tree().create_timer(.25, false).timeout
+	filter.BeginPan(filter.lowPassDefaultValue, filter.lowPassMaxValue)
+	speaker_amb_restroom.stop()
+
+func RestRoomIdle():
+	animator_camera.play("camera idle bathroom")
+	pass

ItemGridIndicator.gd

@@ -0,0 +1,12 @@
+class_name GridIndicator extends Node
+
+@export var roundManager : RoundManager
+@export var animator : AnimationPlayer
+@export var parent: Node3D
+
+func ShowGridIndicator():
+	parent.visible = true
+	animator.play("show")
+	roundManager.playerData.indicatorShown = true
+	await get_tree().create_timer(1, false).timeout
+	parent.visible = false

ItemInteraction.gd

@@ -0,0 +1,135 @@
+class_name ItemInteraction extends Node
+
+@export var roundManager : RoundManager
+@export var dealerIntelligence : DealerIntelligence
+@export var cursor : CursorManager
+@export var perm : PermissionManager
+@export var itemManager : ItemManager
+@export var lerpDuration : float
+@export var pos_hand : Vector3
+@export var rot_hand : Vector3
+@export var animator_dealerHands : AnimationPlayer
+@export var animator_playerHands : AnimationPlayer
+@export var camera : CameraManager
+@export var shellEject_player : ShellEjectManager
+@export var speaker_pickup : AudioStreamPlayer2D
+@export var speaker_breakcuffs : AudioStreamPlayer2D
+
+var temp_itemParent
+var pos_current
+var pos_next
+var rot_current
+var rot_next
+var temp_interaction
+var temp_indicator
+var elapsed = 0
+var moving = false
+
+func _process(delta):
+	LerpMovement()
+
+func PickupItemFromTable(itemParent : Node3D, passedItemName : String):
+	#SET INTERACTION PERMISSIONS, HIDE CURSOR
+	perm.SetIndicators(false)
+	perm.SetInteractionPermissions(false)
+	perm.RevertDescriptionUI()
+	cursor.SetCursor(false, false)
+	#GET VARIABLES
+	temp_itemParent = itemParent
+	temp_indicator = itemParent.get_child(0)
+	temp_interaction = itemParent.get_child(1)
+	#PLAY PICKUP SOUND
+	speaker_pickup.stream = temp_indicator.sound_pickup
+	speaker_pickup.pitch_scale = randf_range(.93, 1.0)
+	speaker_pickup.play()
+	#INTERACTION PERMISSIONS
+	#perm.SetIndicators(false)
+	#cursor.SetCursor(false, false)
+	#perm.SetInteractionPermissions(false)
+	temp_indicator.lerpEnabled = false
+	temp_indicator.interactionAllowed = false
+	temp_indicator.SnapToMax()
+	temp_interaction.interactionAllowed = false
+	#LERP
+	pos_current = temp_itemParent.transform.origin
+	rot_current = temp_itemParent.rotation_degrees
+	pos_next = pos_hand
+	rot_next = rot_hand
+	elapsed = 0
+	moving = true
+	await get_tree().create_timer(lerpDuration -.1, false).timeout
+	moving = false
+	RemovePlayerItemFromGrid(temp_itemParent)
+	temp_itemParent.queue_free() #check where player grid index is given, and remove item from player item array, unoccupy given grid
+	InteractWith(passedItemName)
+
+func InteractWith(itemName : String):
+	#INTERACTION
+	match (itemName):
+		"handcuffs":
+			animator_dealerHands.play("dealer get handcuffed")
+			await get_tree().create_timer(1, false).timeout
+			camera.BeginLerp("enemy")
+			await get_tree().create_timer(1.3, false).timeout
+			camera.BeginLerp("dealer handcuffs")
+			roundManager.dealerCuffed = true
+			dealerIntelligence.dealerAboutToBreakFree = false
+			await get_tree().create_timer(1.3, false).timeout
+			camera.BeginLerp("home")
+			await get_tree().create_timer(.6, false).timeout
+			EnablePermissions()
+		"beer":
+			roundManager.playerData.stat_beerDrank += 330
+			var isFinalShell = false
+			if (roundManager.shellSpawner.sequenceArray.size() == 1): isFinalShell = true
+			animator_playerHands.play("player use beer")
+			await get_tree().create_timer(1.4, false).timeout
+			shellEject_player.FadeOutShell()
+			await get_tree().create_timer(4.2, false).timeout
+			#check if ejected last shell
+			if (!isFinalShell): EnablePermissions()
+			else:
+				roundManager.StartRound(true)
+		"magnifying glass":
+			animator_playerHands.play("player use magnifier")
+			var length = animator_playerHands.get_animation("player use magnifier").get_length()
+			await get_tree().create_timer(length + .2, false).timeout
+			EnablePermissions()
+		"cigarettes":
+			roundManager.playerData.stat_cigSmoked += 1
+			animator_playerHands.play("player use cigarettes")
+			await get_tree().create_timer(5, false).timeout
+			itemManager.numberOfCigs_player -= 1
+			EnablePermissions()
+		"handsaw":
+			animator_playerHands.play("player use handsaw")
+			roundManager.barrelSawedOff = true
+			roundManager.currentShotgunDamage = 2
+			await get_tree().create_timer(4.28 + .2, false).timeout
+			EnablePermissions()
+
+func EnablePermissions():
+	perm.SetStackInvalidIndicators()
+	perm.SetIndicators(true)
+	perm.SetInteractionPermissions(true)
+	perm.RevertDescriptionUI()
+	cursor.SetCursor(true, true)
+
+func PlaySound_BreakHandcuffs():
+	speaker_breakcuffs.play()
+
+func RemovePlayerItemFromGrid(parent : Node3D):
+	var indic = parent.get_child(0)
+	var inter = parent.get_child(1)
+	itemManager.items_dynamicIndicatorArray.erase(indic)
+	itemManager.items_dynamicInteractionArray.erase(inter)
+	itemManager.gridOccupiedArray[inter.itemGridIndex] = false
+	itemManager.numberOfOccupiedGrids -= 1
+
+func LerpMovement():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / lerpDuration, 0.0, 1.0)
+		#c = ease(c, 0.1)
+		temp_itemParent.transform.origin = lerp(pos_current, pos_next, c)
+		temp_itemParent.rotation_degrees = lerp(rot_current, rot_next, c)

ItemManager.gd

@@ -0,0 +1,443 @@
+class_name ItemManager extends Node
+
+@export var grid : GridIndicator
+@export var cursor : CursorManager
+@export var roundManager : RoundManager
+@export var dialogue : Dialogue
+@export var camera : CameraManager
+@export var comp : CompartmentManager
+@export var interaction_intake : InteractionBranch
+@export var instanceArray : Array[ItemResource]
+@export var instanceArray_dealer : Array[ItemResource]
+@export var availableItemArray : Array[String]
+@export var itemSpawnParent : Node3D
+@export var lerpDuration : float
+@export var gridParentArray : Array[Node3D]
+@export var gridParentArray_enemy : Array[Node3D]
+var gridParentArray_enemy_available : Array[Node3D]
+@export var gridOccupiedArray : Array[bool]
+@export var stringNumberArray : Array[String]
+@export var gridParent_1 : Node3D
+@export var gridParent_2 : Node3D
+@export var gridParent_3 : Node3D
+@export var gridParent_4 : Node3D
+@export var soundArray_itemGrab : Array[AudioStream]
+@export var speaker_itemgrab : AudioStreamPlayer2D
+@export var speaker_placedown : AudioStreamPlayer2D
+@export var anim_spook : AnimationPlayer
+@export var speakercontroller_musicmain : SpeakerController
+@export var speaker_god : AudioStreamPlayer2D
+var itemGrabSoundIndex = 0
+var itemArray_dealer : Array[String]
+var itemArray_instances_dealer : Array[Node3D]
+var itemArray_player : Array[String]
+var hasBegun = false
+var items_dynamicIndicatorArray : Array[PickupIndicator]
+var items_dynamicInteractionArray : Array[InteractionBranch]
+
+var numberOfCigs_player = 0
+var numberOfCigs_dealer = 0
+var playerItemStringArray
+var availableItemsToGrabArray_player
+var availableItemsToGrabArray_dealer
+var numberOfItemsGrabbed_enemy = 0
+var numberOfItemsGrabbed = 0
+var numberOfOccupiedGrids = 0
+var activeItem_offset_pos
+var activeItem_offset_rot
+var activeItem
+var activeItem_enemy
+var elapsed = 0
+var moving = false
+var pos_current
+var pos_next
+var rot_current
+var rot_next
+var temp_indicator
+var temp_interaction
+
+func _ready():
+	playerItemStringArray = []
+	availableItemsToGrabArray_player = availableItemArray
+	availableItemsToGrabArray_dealer = availableItemArray
+	ResetDealerGrid()
+
+func _process(delta):
+	LerpItem()
+
+func ItemClear_Remote():
+	var itemParentChildrenArray = itemSpawnParent.get_children()
+	for i in range(itemParentChildrenArray.size()):
+		if (itemParentChildrenArray[i].get_child(0) is PickupIndicator):
+			requestingItemClear = true
+			break
+	if (requestingItemClear):
+		camera.BeginLerp("home")
+		await get_tree().create_timer(.8, false).timeout
+		SetupItemClear()
+		comp.animator_compartment.play("clear items")
+		await get_tree().create_timer(1.6).timeout
+		comp.animator_compartment.play("hide items")
+		await get_tree().create_timer(.8, false).timeout
+	else:
+		camera.BeginLerp("home")
+		await get_tree().create_timer(.8, false).timeout
+		comp.animator_compartment.play("hide items")
+		await get_tree().create_timer(.8, false).timeout
+
+var newBatchHasBegun = false
+var requestingItemClear = false
+func BeginItemGrabbing():
+	roundManager.ignoring = false
+	numberOfItemsGrabbed = 0
+	if (roundManager.playerData.hasReadItemSwapIntroduction): camera.BeginLerp("home")
+	else: camera.BeginLerp("enemy")
+	var itemParentChildrenArray = itemSpawnParent.get_children()
+	#CLEAR ITEMS FROM TABLE
+	if (newBatchHasBegun):
+		for i in range(itemParentChildrenArray.size()):
+			if (itemParentChildrenArray[i].get_child(0) is PickupIndicator):
+				requestingItemClear = true
+				break
+		if (requestingItemClear):
+			await get_tree().create_timer(.8, false).timeout
+			SetupItemClear()
+			comp.animator_compartment.play("clear items")
+			await get_tree().create_timer(1.4).timeout
+		newBatchHasBegun = false
+	
+	await get_tree().create_timer(.8, false).timeout
+	if (!roundManager.playerData.hasReadItemSwapIntroduction):
+		dialogue.ShowText_ForDuration("LET'S MAKE THIS A LITTLE\nMORE INTERESTING ...", 3)
+		await get_tree().create_timer(3, false).timeout
+		camera.BeginLerp("home")
+		await get_tree().create_timer(.8, false).timeout
+		roundManager.playerData.hasReadItemSwapIntroduction = true
+	comp.CycleCompartment("show briefcase")
+	await get_tree().create_timer(.8, false).timeout
+	if (comp.isHiding_items): comp.CycleCompartment("show items")
+	await get_tree().create_timer(.8, false).timeout
+	camera.BeginLerp("briefcase")
+	await get_tree().create_timer(.8, false).timeout
+	
+	if (!roundManager.playerData.hasReadItemDistributionIntro):
+		var stringIndex = roundManager.roundArray[roundManager.currentRound].numberOfItemsToGrab
+		var string = stringNumberArray[stringIndex]
+		dialogue.ShowText_Forever(string+" ITEMS EACH.")
+		await get_tree().create_timer(2.5, false).timeout
+		dialogue.ShowText_Forever("MORE ITEMS BEFORE\nEVERY LOAD.")
+		await get_tree().create_timer(2.5, false).timeout
+		dialogue.HideText()
+		roundManager.playerData.hasReadItemDistributionIntro = true
+
+	if (!roundManager.playerData.hasReadItemDistributionIntro2 && roundManager.roundArray[roundManager.currentRound].hasIntro2):
+		var stringIndex = roundManager.roundArray[roundManager.currentRound].numberOfItemsToGrab
+		var string = stringNumberArray[stringIndex]
+		dialogue.ShowText_Forever(string+" ITEMS EACH.")
+		await get_tree().create_timer(2.5, false).timeout
+		dialogue.HideText()
+		roundManager.playerData.hasReadItemDistributionIntro2 = true
+	#ALLOW ITEM GRAB
+	cursor.SetCursor(true, true)
+	interaction_intake.interactionAllowed = true
+	pass
+
+func EndItemGrabbing():
+	GrabItems_Enemy()
+	GridParents(false)
+	interaction_intake.interactionAllowed = false
+	cursor.SetCursor(false, false)
+	await get_tree().create_timer(.45, false).timeout
+	comp.CycleCompartment("hide briefcase")
+	await get_tree().create_timer(1, false).timeout
+	camera.BeginLerp("home")
+	await get_tree().create_timer(.9, false).timeout
+	moving = false
+	roundManager.ReturnFromItemGrabbing()
+	pass
+
+func GrabSpook():
+	interaction_intake.interactionAllowed = false
+	cursor.SetCursor(false, false)
+	PlayItemGrabSound()
+	speakercontroller_musicmain.SnapVolume(false)
+	speaker_god.play()
+	anim_spook.play("grab form")
+	await get_tree().create_timer(2 + .8, false).timeout
+	anim_spook.play("put back")
+	PlayItemGrabSound()
+	camera.BeginLerp("briefcase")
+	speaker_god.stop()
+	speakercontroller_musicmain.FadeIn()
+	await get_tree().create_timer(.8, false).timeout
+	cursor.SetCursor(true, true)
+	interaction_intake.interactionAllowed = true
+
+var randindex = -1
+var spook_counter = 0
+var spook_fired = false
+func GrabItem():
+	if (roundManager.playerData.currentBatchIndex == 1 && roundManager.currentRound == 1):
+		if (spook_counter == 1 && !spook_fired && !roundManager.playerData.seenGod):
+			GrabSpook()
+			roundManager.playerData.seenGod = true
+			spook_fired = true
+			return
+		spook_counter += 1
+	#GET RANDOM ITEM
+	PlayItemGrabSound()
+	interaction_intake.interactionAllowed = false
+	var selectedResource : ItemResource
+	if (numberOfCigs_player >= 2):
+		availableItemsToGrabArray_player.erase("cigarettes")
+	else:
+		var hasInArray = false
+		for i in range(availableItemsToGrabArray_player.size()):
+			if (availableItemsToGrabArray_dealer[i] == "cigarettes"):
+				hasInArray = true
+				break
+		if (!hasInArray): availableItemsToGrabArray_player.append("cigarettes")
+	randindex = randi_range(0, availableItemsToGrabArray_player.size() - 1)
+	numberOfItemsGrabbed += 1
+	#SPAWN ITEM
+	for i in range(instanceArray.size()):
+		if (availableItemsToGrabArray_player[randindex] == instanceArray[i].itemName):
+			selectedResource = instanceArray[i]
+	var itemInstance = selectedResource.instance.instantiate()
+	activeItem = itemInstance
+	itemSpawnParent.add_child(itemInstance)
+	itemInstance.transform.origin = selectedResource.pos_inBriefcase
+	itemInstance.rotation_degrees = selectedResource.rot_inBriefcase
+	activeItem_offset_pos = selectedResource.pos_offset
+	activeItem_offset_rot = selectedResource.rot_offset
+	#ADD ITEM TO PICKUP INDICATOR & INTERACTION BRANCH ARRAY
+	if (numberOfOccupiedGrids != 8):
+		temp_indicator = activeItem.get_child(0)
+		temp_interaction = activeItem.get_child(1)
+		items_dynamicIndicatorArray.append(temp_indicator)
+		items_dynamicInteractionArray.append(temp_interaction)
+		var ind = items_dynamicIndicatorArray.size() - 1
+		temp_indicator.locationInDynamicArray = ind
+	#DISABLE ITEM COLLIDER
+	var childArray = activeItem.get_children()
+	for i in childArray.size():
+		if (childArray[i] is StaticBody3D): childArray[i].get_child(0).disabled = true
+	#LERP TO HAND
+	pos_current = itemInstance.transform.origin
+	rot_current = itemInstance.rotation_degrees
+	pos_next = selectedResource.pos_inHand
+	rot_next = selectedResource.rot_inHand
+	elapsed = 0
+	moving = true
+	await get_tree().create_timer(lerpDuration - .2, false).timeout
+	if (!roundManager.playerData.indicatorShown): grid.ShowGridIndicator()
+	if (numberOfOccupiedGrids != 8):
+		GridParents(true)
+	else:
+		#NOT ENOUGH SPACE. PUT ITEM BACK AND END ITEM GRABBING
+		dialogue.ShowText_Forever("OUT OF SPACE.")
+		await get_tree().create_timer(1.8, false).timeout
+		dialogue.ShowText_Forever("HOW UNFORTUNATE ...")
+		await get_tree().create_timer(2.2, false).timeout
+		dialogue.HideText()
+		pos_current = activeItem.transform.origin
+		rot_current = activeItem.rotation_degrees
+		pos_next = selectedResource.pos_inBriefcase
+		rot_next = selectedResource.rot_inBriefcase
+		elapsed = 0
+		moving = true
+		cursor.SetCursor(false, false)
+		PlayItemGrabSound()
+		await get_tree().create_timer(lerpDuration, false).timeout
+		moving = false
+		activeItem.queue_free()
+		EndItemGrabbing()
+	pass
+
+func PlaceDownItem(gridIndex : int):
+	numberOfOccupiedGrids += 1
+	gridOccupiedArray[gridIndex] = true
+	moving = false
+	#activeItem.get_parent().remove_child(activeItem)
+	#gridParentArray[gridIndex].add_child(activeItem)
+	var temp_indicator = activeItem.get_child(0)
+	if (temp_interaction.itemName == "cigarettes"): numberOfCigs_player += 1
+	pos_current = activeItem.transform.origin
+	rot_current = activeItem.rotation_degrees
+	pos_next = gridParentArray[gridIndex].transform.origin + activeItem_offset_pos
+	rot_next = gridParentArray[gridIndex].rotation_degrees + activeItem_offset_rot
+	elapsed = 0
+	moving = true
+	temp_interaction.itemGridIndex = gridIndex
+	if (temp_indicator.sound_placeDown != null):
+		speaker_placedown.stream = temp_indicator.sound_placeDown
+		speaker_placedown.play()
+	var childArray = activeItem.get_children()
+	for i in childArray.size():
+		if (childArray[i] is StaticBody3D): childArray[i].get_child(0).disabled = false
+	if (numberOfItemsGrabbed == roundManager.roundArray[roundManager.currentRound].numberOfItemsToGrab):
+		#END ITEM GRABBING
+		EndItemGrabbing()
+	else:
+		#GRAB NEXT ITEM
+		GridParents(false)
+		await get_tree().create_timer(lerpDuration, false).timeout
+		interaction_intake.interactionAllowed = true
+	pass
+
+var firstItem = true
+func GrabItems_Enemy():
+	var selectedResource
+	for i in range(roundManager.roundArray[roundManager.currentRound].numberOfItemsToGrab):
+		if (numberOfItemsGrabbed_enemy != 8):
+			if (numberOfCigs_dealer >= 2):
+				availableItemsToGrabArray_dealer.erase("cigarettes")
+			else:
+				var hasInArray = false
+				for k in range(availableItemsToGrabArray_dealer.size()):
+					if (availableItemsToGrabArray_dealer[k] == "cigarettes"):
+						hasInArray = true
+						break
+				if (!hasInArray): availableItemsToGrabArray_dealer.append("cigarettes")
+			
+			var randindex = randi_range(0, availableItemsToGrabArray_dealer.size() - 1)
+			#SPAWN ITEM
+			for c in range(instanceArray_dealer.size()):
+				if (availableItemArray[randindex] == instanceArray_dealer[c].itemName):
+					selectedResource = instanceArray_dealer[c]
+					#ADD STRING TO DEALER ITEM ARRAY
+					itemArray_dealer.append(instanceArray_dealer[c].itemName)
+			var itemInstance = selectedResource.instance.instantiate()
+			var temp_itemIndicator = itemInstance.get_child(0)
+			temp_itemIndicator.isDealerItem = true
+			#ADD INSTANCE TO DEALER ITEM ARRAY (mida vittu this code is getting out of hand)
+			itemArray_instances_dealer.append(itemInstance)
+			activeItem_enemy = itemInstance
+			itemSpawnParent.add_child(activeItem_enemy)
+			#PLACE ITEM ON RANDOM GRID
+			var randgrid = randi_range(0, gridParentArray_enemy_available.size() - 1)
+			#higher than z0 is right
+			var gridname = gridParentArray_enemy_available[randgrid]
+			activeItem_enemy.transform.origin = gridParentArray_enemy_available[randgrid].transform.origin + selectedResource.pos_offset
+			activeItem_enemy.rotation_degrees = gridParentArray_enemy_available[randgrid].rotation_degrees + selectedResource.rot_offset
+			if (activeItem_enemy.transform.origin.z > 0): temp_itemIndicator.whichSide = "right"
+			else: temp_itemIndicator.whichSide = "left"
+			temp_itemIndicator.dealerGridIndex = gridParentArray_enemy_available[randgrid].get_child(0).activeIndex
+			temp_itemIndicator.dealerGridName = gridname
+			if (activeItem_enemy.get_child(1).itemName == "cigarettes"): numberOfCigs_dealer += 1
+			gridParentArray_enemy_available.erase(gridname)
+			numberOfItemsGrabbed_enemy += 1
+		pass
+	pass
+
+func UseItem_Dealer(itemName : String):
+	match (itemName):
+		"beer":
+			pass
+	pass
+
+func ResetDealerGrid():
+	#CLEAR DEALER GRID
+	numberOfItemsGrabbed_enemy = 0
+	gridParentArray_enemy_available = []
+	for i in range(gridParentArray_enemy.size()):
+		gridParentArray_enemy_available.append(gridParentArray_enemy[i])
+
+func SetupItemClear():
+	instancesToDelete = []
+	#DEALER
+	numberOfCigs_dealer = 0
+	numberOfItemsGrabbed_enemy = 0
+	gridParentArray_enemy_available = []
+	for i in range(gridParentArray_enemy.size()):
+		gridParentArray_enemy_available.append(gridParentArray_enemy[i])
+	itemArray_dealer = []
+	
+	#PLAYER
+	numberOfCigs_player = 0
+	items_dynamicIndicatorArray = []
+	items_dynamicInteractionArray = []
+	for i in range(gridOccupiedArray.size()):
+		gridOccupiedArray[i] = false
+	numberOfOccupiedGrids = 0
+	
+	var childarray = itemSpawnParent.get_children()
+	for i in range(childarray.size()):
+		if (childarray[i].get_child(0) is PickupIndicator):
+			instancesToDelete.append(childarray[i])
+	
+	var spawnChildren = itemSpawnParent.get_children()
+	#PARENT INSTANCES TO APPROPRIATE GRID COMPARTMENT PARENT
+	for i in range(spawnChildren.size()):
+		if (spawnChildren[i].get_child(0) is PickupIndicator):
+			var objPos_x = spawnChildren[i].transform.origin.x
+			var objPos_z = spawnChildren[i].transform.origin.z
+			if (objPos_x < 0 && objPos_z > 0): 
+				var orig = spawnChildren[i].global_transform
+				spawnChildren[i].get_parent().remove_child(spawnChildren[i])
+				gridParent_1.add_child(spawnChildren[i])
+				spawnChildren[i].global_transform = orig
+			if (objPos_x < 0 && objPos_z < 0): 
+				var orig = spawnChildren[i].global_transform
+				spawnChildren[i].get_parent().remove_child(spawnChildren[i])
+				gridParent_2.add_child(spawnChildren[i])
+				spawnChildren[i].global_transform = orig
+			if (objPos_x > 0 && objPos_z > 0): 
+				var orig = spawnChildren[i].global_transform
+				spawnChildren[i].get_parent().remove_child(spawnChildren[i])
+				gridParent_3.add_child(spawnChildren[i])
+				spawnChildren[i].global_transform = orig
+			if (objPos_x > 0 && objPos_z < 0): 
+				var orig = spawnChildren[i].global_transform
+				spawnChildren[i].get_parent().remove_child(spawnChildren[i])
+				gridParent_4.add_child(spawnChildren[i])
+				spawnChildren[i].global_transform = orig
+
+var instancesToDelete = []
+func ClearAllItems():
+	#DELETE INSTANCES
+	for i in range (instancesToDelete.size()):
+		instancesToDelete[i].queue_free()
+	itemArray_instances_dealer = []
+
+func GridParents(setState : bool):
+	if (setState):
+		for i in range(gridParentArray.size()):
+			gridParentArray[i].get_child(1).get_child(0).disabled = false
+			if(gridOccupiedArray[i] == false): gridParentArray[i].get_child(0).interactionAllowed = true
+	else:
+		for i in range(gridParentArray.size()):
+			gridParentArray[i].get_child(1).get_child(0).disabled = true
+			gridParentArray[i].get_child(0).interactionAllowed = false
+
+func PlayItemGrabSound():
+	speaker_itemgrab.stream = soundArray_itemGrab[itemGrabSoundIndex]
+	speaker_itemgrab.play()
+	if (itemGrabSoundIndex != soundArray_itemGrab.size() - 1): itemGrabSoundIndex += 1
+	else: itemGrabSoundIndex = 0
+	pass
+
+func LerpItem():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / lerpDuration, 0.0, 1.0)
+		c = ease(c, 0.4)
+		var pos = lerp(pos_current, pos_next, c)
+		var rot = lerp(rot_current, rot_next, c)
+		activeItem.transform.origin = pos
+		activeItem.rotation_degrees = rot
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

ItemProperties.gd

@@ -0,0 +1,6 @@
+class_name ItemProperties extends Node
+
+@export var pos_inBriefcase : Vector3
+@export var rot_inBriefcase : Vector3
+@export var pos_inHand : Vector3
+@export var rot_inHand : Vector3

ItemResource.gd

@@ -0,0 +1,10 @@
+class_name ItemResource extends Resource
+
+@export var itemName : String
+@export var instance : PackedScene
+@export var pos_inHand : Vector3
+@export var rot_inHand : Vector3
+@export var pos_inBriefcase : Vector3
+@export var rot_inBriefcase : Vector3
+@export var pos_offset : Vector3
+@export var rot_offset : Vector3

MenuManager.gd

@@ -0,0 +1,88 @@
+class_name MenuManager extends Node
+
+@export var savefile : SaveFileManager
+@export var cursor : CursorManager
+@export var animator_intro : AnimationPlayer
+@export var speaker_music : AudioStreamPlayer2D
+@export var speaker_start : AudioStreamPlayer2D
+@export var buttons : Array[ButtonClass]
+@export var screen_main : Array[Control]
+@export var screen_creds : Array[Control]
+@export var title : Node3D
+@export var waterfalls : Array[AnimationPlayer]
+
+func _ready():
+	Show("main")
+	buttons[0].connect("is_pressed", Start)
+	buttons[1].connect("is_pressed", Credits)
+	buttons[2].connect("is_pressed", Exit)
+	buttons[3].connect("is_pressed", Return)
+	Intro()
+
+func Intro():
+	cursor.SetCursor(false, false)
+	await get_tree().create_timer(.5, false).timeout
+	speaker_music.play()
+	animator_intro.play("splash screen")
+	await get_tree().create_timer(9, false).timeout
+	cursor.SetCursor(true, false)
+	buttons[0].isActive = true
+	buttons[1].isActive = true
+	buttons[2].isActive = true
+	pass
+
+func Buttons(state : bool):
+	if (!state):
+		for i in buttons: i.isActive = false
+	else: for i in buttons: i.isActive = true
+
+func Show(what : String):
+	title.visible = false
+	for i in screen_main: i.visible = false
+	for i in screen_creds: i.visible = false
+	if (what == "credits"): for i in screen_creds: i.visible = true
+	else: if (what == "main"): 
+		for i in screen_main: i.visible = true 
+		title.visible = true
+	else:
+		pass
+
+func ResetButtons():
+	for b in buttons:
+		b.ui.modulate.a = 1
+	cursor.SetCursorImage("point")
+
+func Start():
+	Buttons(false)
+	ResetButtons()
+	Show("e")
+	speaker_music.stop()
+	animator_intro.play("snap")
+	for w in waterfalls: w.pause()
+	speaker_start.play()
+	cursor.SetCursor(false, false)
+	savefile.ClearSave()
+	await get_tree().create_timer(4, false).timeout
+	get_tree().change_scene_to_file("res://scenes/main.tscn")
+
+func Credits():
+	ResetButtons()
+	Show("credits")
+	Buttons(false)
+	buttons[3].isActive = true
+	ResetButtons()
+
+func Exit():
+	Buttons(false)
+	ResetButtons()
+	speaker_music.stop()
+	animator_intro.play("snap2")
+	cursor.SetCursor(false, false)
+	await get_tree().create_timer(.5, false).timeout
+	get_tree().quit()
+
+func Return():
+	Show("main")
+	Buttons(true)
+	buttons[3].isActive = false
+	ResetButtons()

MouseRaycast.gd

@@ -0,0 +1,17 @@
+class_name MouseRaycast extends Camera3D
+
+var mouse = Vector2()
+var result = null
+
+func _input(event):
+	if event is InputEventMouse:
+		mouse = event.position
+
+func _process(delta):
+	get_selection()
+
+func get_selection():
+	var worldspace = get_world_3d().direct_space_state
+	var start = project_ray_origin(mouse)
+	var end = project_position(mouse, 20000)
+	result = worldspace.intersect_ray(PhysicsRayQueryParameters3D.create(start, end))

MusicManager.gd

@@ -0,0 +1,34 @@
+class_name MusicManager extends Node
+
+@export var trackArray : Array[TrackInstance]
+@export var speaker_music : AudioStreamPlayer2D
+@export var speakerController_music : SpeakerController
+@export var filter : FilterController
+@export var roundManager : RoundManager
+
+func _ready():
+	#LoadTrack()
+	pass
+
+func EndTrack():
+	speaker_music.stop()
+
+func LoadTrack_FadeIn():
+	speakerController_music.SnapVolume(false)
+	LoadTrack()
+	speakerController_music.FadeIn()
+
+var trackset = false
+func LoadTrack():
+	var currentBatch = roundManager.playerData.currentBatchIndex
+	var currentTrack
+	if (roundManager.playerData.playerEnteringFromDeath && !trackset):
+		currentTrack = trackArray[currentBatch].audiofile_secondloop
+		trackset = true
+	else:
+		currentTrack = trackArray[currentBatch].audiofile
+	filter.lowPassDefaultValue = trackArray[currentBatch].defaultLowPassHz
+	filter.effect_lowPass.cutoff_hz = filter.lowPassDefaultValue
+	filter.moving = false
+	speaker_music.stream = currentTrack
+	speaker_music.play()

ObjectShaker.gd

@@ -0,0 +1,28 @@
+class_name ObjectShaker extends Node
+
+@export var obj : Node3D
+@export var delay : float
+@export var offset_1 : float
+@export var offset_2 : float
+
+var originalPos : Vector3
+var shaking = false
+
+func StartShaking():
+	originalPos = obj.transform.origin
+	shaking = true
+	ShakeRoutine()
+
+func StopShaking():
+	shaking = false
+	obj.transform.origin = originalPos
+
+func ShakeRoutine():
+	while(shaking):
+		var val = randf_range(offset_1, offset_2)
+		var pos = Vector3(obj.transform.origin.x + val, obj.transform.origin.y + val, obj.transform.origin.z + val)
+		obj.transform.origin = pos
+		await get_tree().create_timer(delay, false).timeout
+		obj.transform.origin = originalPos
+		await get_tree().create_timer(delay, false).timeout
+	pass

PermissionManager.gd

@@ -0,0 +1,69 @@
+class_name PermissionManager extends Node
+
+@export var roundManager : RoundManager
+@export var itemManager : ItemManager
+@export var indicatorArray : Array[PickupIndicator]
+@export var interactionBranchArray : Array[InteractionBranch]
+@export var description : DescriptionManager
+@export var userItemsParent : Node3D
+@export var stackDisabledItemArray : Array[String]
+@export var stackDisabledItemArray_bools : Array[bool]
+
+func _ready():
+	#SetItemInteraction(true)
+	pass
+
+func SetIndicators(state : bool):
+	if (state):
+		for i in range(indicatorArray.size()):
+			indicatorArray[i].interactionAllowed = true
+	if (!state):
+		for i in range(indicatorArray.size()):
+			indicatorArray[i].interactionAllowed = false
+			indicatorArray[i].moving = false
+
+func SetInteractionPermissions(state : bool):
+	if (state):
+		for i in range(interactionBranchArray.size()):
+			interactionBranchArray[i].interactionAllowed = true
+	if (!state):
+		for i in range(interactionBranchArray.size()):
+			interactionBranchArray[i].interactionAllowed = false
+	if (roundManager.roundArray[roundManager.currentRound].usingItems && itemManager.items_dynamicIndicatorArray.size() != 0):
+		if (state):
+			for i in range(itemManager.items_dynamicInteractionArray.size()):
+				itemManager.items_dynamicInteractionArray[i].interactionAllowed = true
+				itemManager.items_dynamicIndicatorArray[i].interactionAllowed = true
+		else:
+			for i in range(itemManager.items_dynamicInteractionArray.size()):
+				itemManager.items_dynamicInteractionArray[i].interactionAllowed = false
+				itemManager.items_dynamicIndicatorArray[i].interactionAllowed = false
+
+func SetItemInteraction(state : bool):
+	var children = userItemsParent.get_children()
+	for i in range(children.size()):
+		if (children[i].get_child(0) != null):
+			if (children[i].get_child(0) is PickupIndicator):
+				var tempindicator : PickupIndicator = children[i].get_child(0)
+				tempindicator.interactionAllowed = state
+			if (children[i].get_child(1) is InteractionBranch):
+				var tempBranch : InteractionBranch = children[i].get_child(1)
+				tempBranch.interactionAllowed = state
+
+func SetStackInvalidIndicators():
+	if (roundManager.dealerCuffed): stackDisabledItemArray_bools[4] = true
+	else: stackDisabledItemArray_bools[4] = false
+	if (roundManager.barrelSawedOff): stackDisabledItemArray_bools[0] = true
+	else: stackDisabledItemArray_bools[0] = false
+	if (roundManager.roundArray[roundManager.currentRound].usingItems && itemManager.items_dynamicIndicatorArray.size() != 0):
+		for i in range(stackDisabledItemArray.size()):
+			for c in range(itemManager.items_dynamicInteractionArray.size()):
+				if (itemManager.items_dynamicInteractionArray[c].itemName == stackDisabledItemArray[i] && stackDisabledItemArray_bools[i]):
+					itemManager.items_dynamicInteractionArray[c].interactionInvalid = true
+					itemManager.items_dynamicIndicatorArray[c].interactionInvalid = true
+				if (itemManager.items_dynamicInteractionArray[c].itemName == stackDisabledItemArray[i] && !stackDisabledItemArray_bools[i]):
+					itemManager.items_dynamicInteractionArray[c].interactionInvalid = false
+					itemManager.items_dynamicIndicatorArray[c].interactionInvalid = false
+
+func RevertDescriptionUI():
+	description.EndLerp()

PickupIndicator.gd

@@ -0,0 +1,133 @@
+class_name PickupIndicator extends Node
+
+@export var description : DescriptionManager
+@export var interaction : InteractionManager
+@export var obj : Node3D
+@export var collider : Node3D
+
+@export var dur : float
+@export var axisOffset : float
+@export var originalAxis : float
+@export var activeAxis : String
+
+@export var uiArray : Array[Label]
+@export var itemName : String
+@export_multiline var itemDescription : String
+@export var whichSide : String
+@export var dealerGridIndex : int
+@export var sound_placeDown : AudioStream
+@export var sound_indicatorPickup : AudioStream
+@export var sound_indicatorPutdown : AudioStream
+@export var sound_pickup : AudioStream
+var speaker_indicatorCheck : AudioStreamPlayer2D
+var locationInDynamicArray
+var itemManager
+
+var isDealerItem = false
+var dealerGridName
+var lerpEnabled = true
+var interactionAllowed = false
+var interactionInvalid = false
+var current = 0
+var next = 0
+var elapsed = 0
+var moving = false
+var fs = false
+var fs2 = false
+
+func _ready():
+	speaker_indicatorCheck = get_node("/root/main/speaker parent/speaker_indicator check")
+	interaction = get_node("/root/main/standalone managers/interaction manager")
+	description = get_node("/root/main/standalone managers/description manager")
+	itemManager = get_node("/root/main/standalone managers/item manager")
+
+func _process(delta):
+	if (lerpEnabled): LerpMovement()
+	CheckIfActive()
+	pass
+
+func CheckIfActive():
+	if (interactionAllowed && !interactionInvalid):
+		if (interaction.activeParent != null and interaction.activeParent == collider):
+			if (!fs):
+				BeginPickup()
+				fs2 = false
+				fs = true
+		if (interaction.activeParent != collider):
+			if (!fs2):
+				Revert()
+				fs = false
+				fs2 = true
+	pass
+
+func BeginPickup():
+	speaker_indicatorCheck.pitch_scale = randf_range(.9, 1.0)
+	speaker_indicatorCheck.play()
+	current = originalAxis
+	next = axisOffset	
+	description.uiArray[0].text = itemName
+	description.uiArray[1].text = itemName
+	description.uiArray[2].text = itemDescription
+	description.uiArray[3].text = itemDescription
+	elapsed = 0
+	moving = true
+	description.BeginLerp()
+	itemManager.hasBegun = true
+	pass
+
+func Revert():
+	#if (itemManager.hasBegun): description.EndLerp()
+	itemManager.hasBegun = false
+	match(activeAxis):
+		"x":
+			current = obj.transform.origin.x
+		"y":
+			current = obj.transform.origin.y
+		"z":
+			current = obj.transform.origin.z
+	next = originalAxis
+	elapsed = 0
+	moving = true
+	pass
+
+func LerpMovement():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / dur, 0.0,  1.0)
+		var pos = lerp(current, next, c)
+		match(activeAxis):
+			"x":
+				obj.transform.origin = Vector3(pos, obj.transform.origin.y, obj.transform.origin.z)
+			"y":
+				obj.transform.origin = Vector3(obj.transform.origin.x, pos, obj.transform.origin.z)
+			"z":
+				obj.transform.origin = Vector3(obj.transform.origin.x, obj.transform.origin.y, pos)
+
+func SnapToMax():
+	match(activeAxis):
+		"x":
+			obj.transform.origin = Vector3(axisOffset, obj.transform.origin.y, obj.transform.origin.z)
+		"y":
+			obj.transform.origin = Vector3(obj.transform.origin.x, axisOffset, obj.transform.origin.z)
+		"z":
+			obj.transform.origin = Vector3(obj.transform.origin.x, obj.transform.origin.y, axisOffset)
+
+func SnapToMin():
+	match(activeAxis):
+		"x":
+			obj.transform.origin = Vector3(originalAxis, obj.transform.origin.y, obj.transform.origin.z)
+		"y":
+			obj.transform.origin = Vector3(obj.transform.origin.x, originalAxis, obj.transform.origin.z)
+		"z":
+			obj.transform.origin = Vector3(obj.transform.origin.x, obj.transform.origin.y, originalAxis)
+
+
+
+
+
+
+
+
+
+
+

PlayerCameraTest.gd

@@ -0,0 +1,3 @@
+class_name PlayerCameraTest extends Node
+
+@export var cameraManager : CameraManager

PlayerData.gd

@@ -0,0 +1,23 @@
+class_name PlayerData extends Resource
+
+@export var hasReadIntroduction : bool
+@export var hasReadItemSwapIntroduction : bool
+@export var hasReadItemDistributionIntro : bool
+@export var hasReadItemDistributionIntro2 : bool
+@export var currentBatchIndex : int
+@export var playerEnteringFromDeath : bool
+@export var testValue : int
+@export var numberOfDialogueRead : int
+@export var skippingShellDescription : bool
+@export var indicatorShown : bool
+@export var cutterDialogueRead : bool
+@export var enteringFromTrueDeath : bool
+@export var hasSignedWaiver : bool
+@export var seenHint : bool
+@export var seenGod : bool
+@export var playername : String
+@export var stat_shotsFired : int
+@export var stat_shellsEjected : int
+@export var stat_doorsKicked : int
+@export var stat_cigSmoked : int
+@export var stat_beerDrank : int

RoundBatch.gd

@@ -0,0 +1,4 @@
+class_name RoundBatch extends Node
+
+@export var batchIndex : int
+@export var roundArray : Array[RoundClass]

RoundClass.gd

@@ -0,0 +1,24 @@
+class_name RoundClass extends Resource
+
+@export var hasIntroductoryText : bool
+@export var isFirstRound : bool
+@export var startingHealth : int
+@export var roundIndex : int
+@export var amountBlank : int
+@export var amountLive : int
+@export var usingItems : bool
+@export var showingIndicator : bool
+@export var indicatorNumber: int
+@export var bootingUpCounter : bool
+@export var sequenceHidden : bool
+@export var shufflingArray : bool
+@export var insertingInRandomOrder : bool
+@export var numberOfItemsToGrab : int
+@export var hasIntro2 : bool
+
+func _ready():
+	pass
+
+
+func _process(delta):
+	pass

RoundManager.gd

@@ -0,0 +1,331 @@
+class_name RoundManager extends Node
+
+@export var sign : Signature
+@export var brief : BriefcaseMachine
+@export var defibCutter : DefibCutter
+@export var segmentManager : SegmentManager
+@export var handcuffs : HandcuffManager
+@export var itemManager : ItemManager
+@export var death : DeathManager
+@export var playerData : PlayerData
+@export var cursor : CursorManager
+@export var perm : PermissionManager
+@export var health_player : int
+@export var health_opponent : int
+@export var batchArray : Array[Node]
+@export var roundArray : Array[RoundClass]
+@export var shellSpawner : ShellSpawner
+@export var shellLoader : ShellLoader
+@export var currentRound : int
+var mainBatchIndex : int
+@export var healthCounter : HealthCounter
+@export var dealerAI : DealerIntelligence
+@export var typingManager : TypingManager
+@export var camera : CameraManager
+@export var roundIndicatorPositions : Array[Vector3]
+@export var roundIndicatorParent : Node3D
+@export var roundIndicator : Node3D
+@export var animator_roundIndicator : AnimationPlayer
+@export var speaker_roundHum : AudioStreamPlayer3D
+@export var speaker_roundShutDown : AudioStreamPlayer3D
+@export var speaker_winner : AudioStreamPlayer3D
+@export var ui_winner : Node3D
+@export var animator_dealer : AnimationPlayer
+@export var ejectManagers : Array[ShellEjectManager]
+@export var animator_dealerHands : AnimationPlayer
+@export var gameover : GameOverManager
+@export var musicManager : MusicManager
+@export var deficutter : DefibCutter
+
+var shellLoadingSpedUp = false
+var dealerItems : Array[String]
+var currentShotgunDamage = 1
+var dealerAtTable = false
+var dealerHasGreeted = false
+var dealerCuffed = false
+var playerCuffed = false
+var playerAboutToBreakFree = false
+var waitingForDealerReturn = false
+var barrelSawedOff = false
+var defibCutterReady = false
+var trueDeathActive = false
+
+func _ready():
+	HideDealer()
+	#await get_tree().create_timer(.2, false).timeout
+	pass
+
+func BeginMainGame():
+	MainBatchSetup(true)
+
+func HideDealer():
+	animator_dealerHands.play("hide hands")
+	animator_dealer.play("hide dealer")
+
+#MAIN BATCH SETUP
+var lerping = false
+var enteringFromWaiver = false
+func MainBatchSetup(dealerEnterAtStart : bool):
+	if (!enteringFromWaiver):
+		if (lerping): camera.BeginLerp("enemy")
+		currentRound = 0
+		if (!dealerAtTable && dealerEnterAtStart):
+			await get_tree().create_timer(.5, false).timeout
+			if (!dealerCuffed): animator_dealerHands.play("dealer hands on table")
+			else: animator_dealerHands.play("dealer hands on table cuffed")
+			animator_dealer.play("dealer return to table")
+			await get_tree().create_timer(2, false).timeout
+			var greeting = true
+			if (!playerData.hasSignedWaiver):
+				shellLoader.dialogue.ShowText_Forever("PLEASE SIGN THE WAIVER.")
+				await get_tree().create_timer(2.3, false).timeout
+				shellLoader.dialogue.HideText()
+				camera.BeginLerp("home")
+				sign.AwaitPickup()
+				return
+			if (!dealerHasGreeted && greeting):
+				var tempstring
+				if (!playerData.enteringFromTrueDeath): tempstring = "WELCOME BACK."
+				else: 
+					shellSpawner.dialogue.dealerLowPitched = true
+					tempstring = "..."
+				if (!playerData.playerEnteringFromDeath):
+					shellLoader.dialogue.ShowText_Forever("WELCOME TO\nBUCKSHOT ROULETTE.")
+					await get_tree().create_timer(2.3, false).timeout
+					shellLoader.dialogue.HideText()
+					dealerHasGreeted = true
+				else:
+					shellLoader.dialogue.ShowText_Forever(tempstring)
+					await get_tree().create_timer(2.3, false).timeout
+					shellLoader.dialogue.HideText()
+					dealerHasGreeted = true
+			dealerAtTable = true
+	enteringFromWaiver = false
+	playerData.enteringFromTrueDeath = false
+	mainBatchIndex = playerData.currentBatchIndex
+	healthCounter.DisableCounter()
+	SetupRoundArray()
+	if (playerData.hasReadIntroduction): roundArray[0].hasIntroductoryText = false
+	else: roundArray[0].hasIntroductoryText = true
+	if (roundArray[0].showingIndicator): await(RoundIndicator())
+	healthCounter.SetupHealth()
+	lerping = true
+	#await get_tree().create_timer(1.5, false).timeout
+	StartRound(false)
+
+#APPEND ROUNDS FROM BATCH
+func SetupRoundArray():
+	roundArray = []
+	for i in range(batchArray.size()):
+		if (batchArray[i].batchIndex == mainBatchIndex):
+			var matched = batchArray[i]
+			for z in range(matched.roundArray.size()):
+				roundArray.append(matched.roundArray[z])
+				pass
+	pass
+
+#SHOW ROUND INDICATOR
+func RoundIndicator():
+	roundIndicator.visible = false
+	#await get_tree().create_timer(1.5, false).timeout
+	animator_roundIndicator.play("RESET")
+	camera.BeginLerp("health counter")
+	await get_tree().create_timer(.8, false).timeout
+	var activePos = roundIndicatorPositions[roundArray[0].indicatorNumber]
+	roundIndicator.transform.origin = activePos
+	roundIndicatorParent.visible = true
+	speaker_roundHum.play()
+	await get_tree().create_timer(.8, false).timeout
+	roundIndicator.visible = true
+	animator_roundIndicator.play("round blinking")
+	await get_tree().create_timer(2, false).timeout
+	roundIndicatorParent.visible = false
+	speaker_roundHum.stop()
+	speaker_roundShutDown.play()
+	animator_roundIndicator.play("RESET")
+	pass
+
+#MAIN ROUND SETUP
+func StartRound(gettingNext : bool):
+	if (gettingNext && (currentRound +  1) != roundArray.size()): currentRound += 1
+	#USINGITEMS: SETUP ITEM GRIDS IF ROUND CLASS HAS SETUP ITEM GRIDS ENABLED
+	#UNCUFF BOTH PARTIES BEFORE ITEM DISTRIBUTION
+	await (handcuffs.RemoveAllCuffsRoutine())
+	#FINAL SHOWDOWN DIALOGUE
+	if (playerData.currentBatchIndex == 2 && !defibCutterReady):
+		shellLoader.dialogue.dealerLowPitched = true
+		camera.BeginLerp("enemy") 
+		await get_tree().create_timer(.6, false).timeout
+		#var origdelay = shellLoader.dialogue.incrementDelay
+		#shellLoader.dialogue.incrementDelay = .1
+		if (!playerData.cutterDialogueRead):
+			shellLoader.dialogue.ShowText_Forever("LONG LAST, WE ARRIVE\nAT THE FINAL SHOWDOWN.")
+			await get_tree().create_timer(4, false).timeout
+			shellLoader.dialogue.ShowText_Forever("NO MORE DEFIBRILLATORS.\nNO MORE BLOOD TRANSFUSIONS.")
+			await get_tree().create_timer(4, false).timeout
+			shellLoader.dialogue.ShowText_Forever("NOW, ME AND YOU, WE ARE DANCING\nON THE EDGE OF LIFE AND DEATH.")
+			await get_tree().create_timer(4.8, false).timeout
+			shellLoader.dialogue.HideText()
+			playerData.cutterDialogueRead = true
+		else:
+			shellLoader.dialogue.ShowText_Forever("I BETTER NOT\nSEE YOU AGAIN.")
+			await get_tree().create_timer(3, false).timeout
+			shellLoader.dialogue.HideText()
+		await(deficutter.InitialSetup())
+		defibCutterReady = true
+		trueDeathActive = true
+		#await get_tree().create_timer(100, false).timeout
+	#USINGITEMS: SHARE ITEMS TO PLAYERS HERE
+	if (roundArray[currentRound].usingItems):
+		itemManager.BeginItemGrabbing()
+		return
+	shellSpawner.MainShellRoutine()
+	pass
+
+#MAIN ROUND SETUP AFTER ITEMS HAVE BEEN DISTRIBUTED. RETURN TO HERE FROM ITEM GRABBING INTERACTION
+func ReturnFromItemGrabbing():
+	shellSpawner.MainShellRoutine()
+	pass
+
+func LoadShells():
+	shellLoader.LoadShells()
+	pass
+
+func CheckIfOutOfHealth():
+	#CHECK IF OUT OF HEALTH
+	var outOfHealth_player = health_player == 0
+	var outOfHealth_enemy = health_opponent == 0
+	var outOfHealth = outOfHealth_player or outOfHealth_enemy
+	if (outOfHealth):
+		if (outOfHealth_player): OutOfHealth("player")
+		if (outOfHealth_enemy):  OutOfHealth("dealer")
+		return outOfHealth
+
+var waitingForReturn = false
+var waitingForHealthCheck = false
+var waitingForHealthCheck2 = false
+var requestedWireCut = false
+var wireToCut = ""
+var wireIsCut_dealer = false
+var wireIsCut_player = false
+
+var ignoring = false
+func EndTurn(playerCanGoAgain : bool):
+	#USINGITEMS: ASSIGN PLAYER CAN GO AGAIN FROM ITEMS HERE
+	#USINGITEMS: MAKE SHOTGUN GROW NEW BARREL
+	#var isOutOfHealth = CheckIfOutOfHealth()
+	#if (isOutOfHealth): return
+	if (barrelSawedOff):
+		await get_tree().create_timer(.6, false).timeout
+		if (waitingForHealthCheck2): await get_tree().create_timer(2, false).timeout
+		waitingForHealthCheck2 = false
+		await(segmentManager.GrowBarrel())
+	if (shellSpawner.sequenceArray.size() != 0):
+		#PLAYER TURN
+		if (playerCanGoAgain):
+			BeginPlayerTurn()
+		else:
+			#DEALER TURN
+			if (!dealerCuffed):
+				dealerAI.BeginDealerTurn()
+			else:
+				if (waitingForReturn):
+					await get_tree().create_timer(1.4, false).timeout
+					waitingForReturn = false
+				if (waitingForHealthCheck): 
+					await get_tree().create_timer(1.8, false).timeout
+					waitingForHealthCheck = false
+				dealerAI.DealerCheckHandCuffs()
+	else:
+		#SHOTGUN IS EMPTY. NEXT ROUND
+		if (requestedWireCut):
+			await(defibCutter.CutWire(wireToCut)) 
+		if (!ignoring): 
+			StartRound(true)
+
+func ReturnFromCuffCheck(brokeFree : bool):
+	if (brokeFree):
+		await get_tree().create_timer(.8, false).timeout
+		camera.BeginLerp("enemy")
+		dealerAI.BeginDealerTurn()
+		pass
+	else:
+		camera.BeginLerp("home")
+		BeginPlayerTurn()
+	pass
+
+func BeginPlayerTurn():
+	if (playerCuffed):
+		var returning = false
+		if (playerAboutToBreakFree == false):
+			handcuffs.CheckPlayerHandCuffs(false)
+			await get_tree().create_timer(1.4, false).timeout
+			camera.BeginLerp("enemy")
+			dealerAI.BeginDealerTurn()
+			returning = true
+			playerAboutToBreakFree = true
+		else:
+			handcuffs.BreakPlayerHandCuffs(false)
+			await get_tree().create_timer(1.4, false).timeout
+			camera.BeginLerp("home")
+			playerCuffed = false
+			playerAboutToBreakFree = false
+			returning = false
+		if (returning): return
+	if (requestedWireCut):
+		await(defibCutter.CutWire(wireToCut))
+	await get_tree().create_timer(.6, false).timeout
+	perm.SetStackInvalidIndicators()
+	cursor.SetCursor(true, true)
+	perm.SetIndicators(true)
+	perm.SetInteractionPermissions(true)
+
+func OutOfHealth(who : String):
+	if (who == "player"): 
+		death.MainDeathRoutine()
+	else:
+		await get_tree().create_timer(1, false).timeout
+		EndMainBatch()
+
+func EndMainBatch():
+	#ADD TO BATCH INDEX
+	ignoring = true
+	playerData.currentBatchIndex += 1
+	#PLAY WINNING SHIT
+	await get_tree().create_timer(.8, false).timeout
+	if (playerData.currentBatchIndex == 3): 
+		healthCounter.speaker_truedeath.stop()
+		healthCounter.DisableCounter()
+		defibCutter.BlipError_Both()
+		await get_tree().create_timer(.4, false).timeout
+		#gameover.PlayerWon()
+		camera.BeginLerp("enemy")
+		await get_tree().create_timer(.7, false).timeout
+		brief.MainRoutine()
+		return
+	healthCounter.DisableCounter()
+	speaker_roundShutDown.play()
+	await get_tree().create_timer(1, false).timeout
+	speaker_winner.play()
+	ui_winner.visible = true
+	itemManager.newBatchHasBegun = true
+	await get_tree().create_timer(2.33, false).timeout
+	speaker_roundShutDown.play()
+	speaker_winner.stop()
+	musicManager.EndTrack()
+	ui_winner.visible = false
+	#REGROW BARREL IF MISSING
+	if (barrelSawedOff):
+		await get_tree().create_timer(.6, false).timeout
+		await(segmentManager.GrowBarrel())
+	#MAIN BATCH LOOP
+	MainBatchSetup(false)
+	if (!dealerAtTable): 
+		if (!dealerCuffed): animator_dealerHands.play("dealer hands on table")
+		else: animator_dealerHands.play("dealer hands on table cuffed")
+		animator_dealer.play("dealer return to table")
+	for i in range(ejectManagers.size()):
+		ejectManagers[i].FadeOutShell()
+	#TRACK MANAGER
+	await get_tree().create_timer(2, false).timeout
+	musicManager.LoadTrack_FadeIn()

SaveFileManager.gd

@@ -0,0 +1,98 @@
+class_name SaveFileManager extends Node
+
+const savePath := "user://buckshotroulette.save"
+var data = {}
+@export var roundManager : RoundManager
+@export var isMainMenu : bool
+
+func _ready():
+	if (!isMainMenu): LoadGame()
+	pass
+
+func SaveGame():
+	data = {
+		"has_read_introduction": roundManager.playerData.hasReadIntroduction,
+		"has_read_item_swap_introduction": roundManager.playerData.hasReadItemSwapIntroduction,
+		"has_read_item_distribution_intro": roundManager.playerData.hasReadItemDistributionIntro,
+		"current_batch_index": roundManager.playerData.currentBatchIndex,
+		"player_entering_from_death": roundManager.playerData.playerEnteringFromDeath,
+		"test_value": roundManager.playerData.testValue,
+		"has_read_item_distribution_intro_2": roundManager.playerData.hasReadItemDistributionIntro2,
+		"number_of_dialogue_read": roundManager.playerData.numberOfDialogueRead,
+		"skipping_shell_description": roundManager.playerData.skippingShellDescription,
+		"indicator_shown": roundManager.playerData.indicatorShown,
+		"cutter_dialogue_read": roundManager.playerData.cutterDialogueRead,
+		"entering_from_true_death": roundManager.playerData.enteringFromTrueDeath,
+		"has_signed_waiver": roundManager.playerData.hasSignedWaiver,
+		"seen_hint": roundManager.playerData.seenHint,
+		"seen_god": roundManager.playerData.seenGod,
+		"player_name": roundManager.playerData.playername,
+		
+		"stat_shotsFired": roundManager.playerData.stat_shotsFired,
+		"stat_shellsEjected": roundManager.playerData.stat_shellsEjected,
+		"stat_doorsKicked": roundManager.playerData.stat_doorsKicked,
+		"stat_cigSmoked": roundManager.playerData.stat_cigSmoked,
+		"stat_beerDrank": roundManager.playerData.stat_beerDrank
+	}
+	var file = FileAccess.open(savePath, FileAccess.WRITE)
+	file.store_var(data)
+	#file.store_var(roundManager.playerData.hasReadIntroduction)
+	#file.store_var(roundManager.playerData.hasReadItemSwapIntroduction)
+	#file.store_var(roundManager.playerData.hasReadItemDistributionIntro)
+	#file.store_var(roundManager.playerData.currentBatchIndex)
+	#file.store_var(roundManager.playerData.playerEnteringFromDeath)
+	#file.store_var(roundManager.playerData.testValue)
+	#file.store_var(roundManager.playerData.hasReadItemDistributionIntro2)
+	#file.store_var(roundManager.playerData.numberOfDialogueRead)
+	#file.store_var(roundManager.playerData.skippingShellDescription)
+	#file.store_var(roundManager.playerData.indicatorShown)
+	#file.store_var(roundManager.playerData.cutterDialogueRead)
+	#file.store_var(roundManager.playerData.enteringFromTrueDeath)
+	#file.store_var(roundManager.playerData.hasSignedWaiver)
+	#file.store_string(roundManager.playerData.playername)
+	file.close()
+
+func LoadGame():
+	if (FileAccess.file_exists(savePath)):
+		var file = FileAccess.open(savePath, FileAccess.READ)
+		data = file.get_var()
+		roundManager.playerData.hasReadIntroduction = data.has_read_introduction
+		roundManager.playerData.hasReadItemSwapIntroduction = data.has_read_item_swap_introduction
+		roundManager.playerData.hasReadItemDistributionIntro = data.has_read_item_distribution_intro
+		roundManager.playerData.currentBatchIndex = data.current_batch_index
+		roundManager.playerData.playerEnteringFromDeath = data.player_entering_from_death
+		roundManager.playerData.testValue = data.test_value
+		roundManager.playerData.hasReadItemDistributionIntro2 = data.has_read_item_distribution_intro_2
+		roundManager.playerData.numberOfDialogueRead = data.number_of_dialogue_read
+		roundManager.playerData.skippingShellDescription = data.skipping_shell_description
+		roundManager.playerData.indicatorShown = data.indicator_shown
+		roundManager.playerData.cutterDialogueRead = data.cutter_dialogue_read
+		roundManager.playerData.enteringFromTrueDeath = data.entering_from_true_death
+		roundManager.playerData.hasSignedWaiver = data.has_signed_waiver
+		roundManager.playerData.playername = data.player_name
+		roundManager.playerData.seenHint = data.seen_hint
+		roundManager.playerData.seenGod = data.seen_god
+		
+		roundManager.playerData.stat_shotsFired = data.stat_shotsFired
+		roundManager.playerData.stat_shellsEjected = data.stat_shellsEjected
+		roundManager.playerData.stat_doorsKicked = data.stat_doorsKicked
+		roundManager.playerData.stat_cigSmoked = data.stat_cigSmoked
+		roundManager.playerData.stat_beerDrank = data.stat_beerDrank
+		#roundManager.playerData.hasReadIntroduction = file.get_var(roundManager.playerData.hasReadIntroduction)
+		#roundManager.playerData.hasReadItemSwapIntroduction = file.get_var(roundManager.playerData.hasReadItemSwapIntroduction)
+		#roundManager.playerData.hasReadItemDistributionIntro = file.get_var(roundManager.playerData.hasReadItemDistributionIntro)
+		#roundManager.playerData.currentBatchIndex = file.get_var(roundManager.playerData.currentBatchIndex)
+		#roundManager.playerData.playerEnteringFromDeath = file.get_var(roundManager.playerData.playerEnteringFromDeath)
+		#roundManager.playerData.testValue = file.get_var(roundManager.playerData.testValue)
+		#roundManager.playerData.hasReadItemDistributionIntro2 = file.get_var(roundManager.playerData.testValue)
+		#roundManager.playerData.numberOfDialogueRead = file.get_var(roundManager.playerData.numberOfDialogueRead)
+		#roundManager.playerData.skippingShellDescription = file.get_var(roundManager.playerData.skippingShellDescription)
+		#roundManager.playerData.indicatorShown = file.get_var(roundManager.playerData.indicatorShown)
+		#roundManager.playerData.cutterDialogueRead = file.get_var(roundManager.playerData.cutterDialogueRead)
+		#roundManager.playerData.enteringFromTrueDeath = file.get_var(roundManager.playerData.enteringFromTrueDeath)
+		#roundManager.playerData.hasSignedWaiver = file.get_var(roundManager.playerData.hasSignedWaiver)
+		#roundManager.playerData.playername = file.get_as_text(roundManager.playerData.playername)
+		file.close()
+
+func ClearSave():
+	if (FileAccess.file_exists(savePath)): DirAccess.remove_absolute(savePath)

SegmentManager.gd

@@ -0,0 +1,40 @@
+class_name SegmentManager extends Node
+
+@export var speaker : AudioStreamPlayer2D
+@export var roundManager : RoundManager
+@export var camera : CameraManager
+@export var mat : StandardMaterial3D
+var dur = 2
+var elapsed = 0
+var moving = false
+
+func _process(delta):
+	LerpSegment()
+
+func GrowBarrel():
+	var prevsocket = camera.activeSocket
+	roundManager.currentShotgunDamage = 1
+	roundManager.barrelSawedOff = false
+	camera.BeginLerp("grow barrel")
+	await get_tree().create_timer(.6, false).timeout
+	ShowSegment()
+	speaker.play()
+	await get_tree().create_timer(1.8, false).timeout
+	camera.BeginLerp(prevsocket)
+	await get_tree().create_timer(.6, false).timeout
+	pass
+
+func HideSegment():
+	moving = false
+	mat.albedo_color = Color(1, 1, 1, 0)
+
+func ShowSegment():
+	elapsed = 0
+	moving = true
+
+func LerpSegment():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / dur, 0.0, 1.0)
+		var alpha = lerp(0, 1, c)
+		mat.albedo_color = Color(1, 1, 1, alpha)

ShellBranch.gd

@@ -0,0 +1,19 @@
+class_name ShellClass extends Node
+
+@export var isLive : bool
+@export var mat_live : StandardMaterial3D
+@export var mat_blank : StandardMaterial3D
+@export var mesh : MeshInstance3D
+
+func _ready():
+	pass
+
+func _process(delta):
+	pass
+
+func ApplyStatus():
+	if (isLive):
+		mesh.set_surface_override_material(1, mat_live)
+	else:
+		mesh.set_surface_override_material(1, mat_blank)
+	pass

ShellDropManager.gd

@@ -0,0 +1,9 @@
+class_name ShellDropManager extends Node
+
+@export var speaker : AudioStreamPlayer2D
+@export var soundArray : Array[AudioStream]
+
+func PlayShellDropSound():
+	var randindex = randi_range(0, soundArray.size() - 1)
+	speaker.stream = soundArray[randindex]
+	speaker.play()

ShellEjectManager.gd

@@ -0,0 +1,70 @@
+class_name ShellEjectManager extends Node
+
+@export var mesh : MeshInstance3D
+@export var shellSpawner : ShellSpawner
+@export var mat_blank : StandardMaterial3D
+@export var mat_live : StandardMaterial3D
+@export var mat_brass : StandardMaterial3D
+@export var animator : AnimationPlayer
+@export var animator_fader : AnimationPlayer
+@export var isDealerSide : bool
+@export var smoke : SmokeController
+
+var hasFaded = false
+
+func _ready():
+	mesh.set_surface_override_material(0, mat_brass)
+
+func EjectShell():
+	shellSpawner.roundManager.playerData.stat_shellsEjected += 1
+	animator_fader.play("RESET")
+	if (shellSpawner.sequenceArray[0] == "live"): mesh.set_surface_override_material(1, mat_live)
+	else: mesh.set_surface_override_material(1, mat_blank)
+	mesh.visible = true
+	if(!isDealerSide): animator.play("ejecting shell_player1")
+	else: animator.play("eject shell")
+	if (shellSpawner.sequenceArray[0] == "live"):
+		smoke.SpawnSmoke("chamber")
+	shellSpawner.sequenceArray.remove_at(0)
+	hasFaded = false
+	pass
+
+func BeerEjection_player():
+	shellSpawner.roundManager.playerData.stat_shellsEjected += 1
+	animator_fader.play("RESET")
+	if (shellSpawner.sequenceArray[0] == "live"): mesh.set_surface_override_material(1, mat_live)
+	else: mesh.set_surface_override_material(1, mat_blank)
+	mesh.visible = true
+	animator.play("ejecting shell_player1")
+	shellSpawner.sequenceArray.remove_at(0)
+	hasFaded = false
+	pass
+
+func BeerEjection_dealer():
+	shellSpawner.roundManager.playerData.stat_shellsEjected += 1
+	animator_fader.play("RESET")
+	if (shellSpawner.sequenceArray[0] == "live"): mesh.set_surface_override_material(1, mat_live)
+	else: mesh.set_surface_override_material(1, mat_blank)
+	mesh.visible = true
+	animator.play("eject shell beer")
+	shellSpawner.sequenceArray.remove_at(0)
+	hasFaded = false
+	pass
+
+func DeathEjection():
+	animator_fader.play("RESET")
+	if (shellSpawner.sequenceArray[0] == "live"): mesh.set_surface_override_material(1, mat_live)
+	else: mesh.set_surface_override_material(1, mat_blank)
+	mesh.visible = true
+	if(!isDealerSide): animator.play("ejecting shell_player1")
+	else: animator.play("eject shell")
+	if (shellSpawner.sequenceArray[0] == "live"):
+		smoke.SpawnSmoke("chamber")
+	shellSpawner.sequenceArray.remove_at(0)
+	hasFaded = false
+	pass
+
+func FadeOutShell():
+	if(!hasFaded):
+		animator_fader.play("fade out shell")
+		hasFaded = true

ShellExamine.gd

@@ -0,0 +1,24 @@
+class_name ShellExamine extends Node
+
+@export var shellSpawner : ShellSpawner
+@export var shellParent : Node3D
+@export var mesh : MeshInstance3D
+@export var mat : StandardMaterial3D
+@export var mat_blank : StandardMaterial3D
+@export var mat_live : StandardMaterial3D
+
+func _ready():
+	shellParent.visible = false
+
+func SetupShell():
+	var color_blue = Color(0, 0, 1)
+	var color_red = Color(1, 0, 0)
+	var shellState = shellSpawner.sequenceArray[0]
+	if (shellState == "live"):
+		mesh.set_surface_override_material(1, mat_live)
+	else:
+		mesh.set_surface_override_material(1, mat_blank)
+	shellParent.visible = true
+
+func RevertShell():
+	shellParent.visible = false

ShellLoader.gd

@@ -0,0 +1,94 @@
+class_name ShellLoader extends Node
+
+@export var perm : PermissionManager
+@export var camera : CameraManager
+@export var roundManager : RoundManager
+@export var speaker_loadShell : AudioStreamPlayer2D
+@export var speaker_rackShotgun : AudioStreamPlayer2D
+@export var animator_shotgun : AnimationPlayer
+@export var dialogue : Dialogue
+@export var cursor : CursorManager
+@export var playerData : PlayerData
+@export var shotgunHand_L : Node3D
+@export var shotgunHand_R : Node3D
+@export var animator_dealerHands : AnimationPlayer
+@export var animator_dealerHandRight : AnimationPlayer
+@export var dealerAI : DealerIntelligence
+@export_multiline var introductionDialogues : Array[String]
+@export_multiline var loadingDialogues : Array[String]
+var diaindex = 0
+
+func DealerHandsGrabShotgun():
+	animator_dealerHands.play("dealer grab shotgun")
+	await get_tree().create_timer(.45, false).timeout
+	dealerAI.Speaker_HandCrack()
+	shotgunHand_L.visible = true
+	shotgunHand_R.visible = true
+
+func DealerHandsDropShotgun():
+	shotgunHand_L.visible = false
+	shotgunHand_R.visible = false
+	animator_dealerHands.play("RESET")
+	pass
+
+func LoadShells():
+	camera.BeginLerp("enemy")
+	if (!roundManager.shellLoadingSpedUp): await get_tree().create_timer(.8, false).timeout
+	await(DealerHandsGrabShotgun())
+	await get_tree().create_timer(.2, false).timeout
+	animator_shotgun.play("grab shotgun_pointing enemy")
+	await get_tree().create_timer(.45, false).timeout
+	if (roundManager.playerData.numberOfDialogueRead < 3):	
+		if (diaindex == loadingDialogues.size()):
+			diaindex = 0
+		dialogue.ShowText_ForDuration(loadingDialogues[diaindex], 3)
+		diaindex += 1
+		await get_tree().create_timer(3, false).timeout
+		roundManager.playerData.numberOfDialogueRead += 1
+	var numberOfShells = roundManager.roundArray[roundManager.currentRound].amountBlank + roundManager.roundArray[roundManager.currentRound].amountLive
+	for i in range(numberOfShells):
+		speaker_loadShell.play()
+		animator_dealerHandRight.play("load single shell")
+		if(roundManager.shellLoadingSpedUp): await get_tree().create_timer(.17, false).timeout
+		else: await get_tree().create_timer(.32, false).timeout
+		pass
+	animator_dealerHandRight.play("RESET")
+	dealerAI.Speaker_HandCrack()
+	if (roundManager.shellLoadingSpedUp): await get_tree().create_timer(.17, false).timeout
+	else: await get_tree().create_timer(.42, false).timeout
+	#INTRODUCTION DIALOGUE
+	if (roundManager.roundArray[roundManager.currentRound].hasIntroductoryText):
+		dialogue.ShowText_Forever(introductionDialogues[0])
+		await get_tree().create_timer(1.9, false).timeout
+		dialogue.ShowText_Forever(introductionDialogues[1])
+		await get_tree().create_timer(3, false).timeout
+		dialogue.ShowText_Forever(introductionDialogues[2])
+		await get_tree().create_timer(3, false).timeout
+		dialogue.ShowText_Forever(introductionDialogues[3])
+		await get_tree().create_timer(3, false).timeout
+		dialogue.ShowText_Forever(introductionDialogues[4])
+		await get_tree().create_timer(3, false).timeout
+		dialogue.ShowText_Forever(introductionDialogues[5])
+		await get_tree().create_timer(3.7, false).timeout
+		dialogue.ShowText_Forever(introductionDialogues[6])
+		await get_tree().create_timer(3.7, false).timeout
+		dialogue.ShowText_Forever(introductionDialogues[7])
+		await get_tree().create_timer(3.7, false).timeout
+		dialogue.ShowText_Forever(introductionDialogues[8])
+		await get_tree().create_timer(2.5, false).timeout
+		roundManager.playerData.hasReadIntroduction = true
+		dialogue.HideText()
+	#RACK SHOTGUN, PLACE ON TABLE
+	#speaker_rackShotgun.play()
+	animator_shotgun.play("enemy rack shotgun start")
+	await get_tree().create_timer(.8, false).timeout
+	animator_shotgun.play("enemy put down shotgun")
+	DealerHandsDropShotgun()
+	camera.BeginLerp("home")
+	#ALLOW INTERACTION
+	await get_tree().create_timer(.6, false).timeout
+	perm.SetStackInvalidIndicators()
+	cursor.SetCursor(true, true)
+	perm.SetIndicators(true)
+	perm.SetInteractionPermissions(true)
+	pass

ShellSpawner.gd

@@ -0,0 +1,155 @@
+class_name ShellSpawner extends Node
+
+@export var dialogue : Dialogue
+@export var anim_compartment : AnimationPlayer
+@export var roundManager : RoundManager
+@export var camera : CameraManager
+@export var shellInstance : PackedScene
+@export var shellLocationArray : Array[Vector3]
+@export var spawnParent : Node3D
+@export var healthCounter : HealthCounter
+@export var soundArray_latchOpen : Array[AudioStream]
+@export var speaker_latchOpen : AudioStreamPlayer2D
+@export var speaker_audioIndicator : AudioStreamPlayer2D
+@export var soundArray_indicators : Array[AudioStream]
+
+var spawnedShell
+var locationIndex
+var tempSequence : Array[String]
+var sequenceArray : Array[String]
+var shellBranch : ShellClass
+var spawnedShellObjectArray = []
+
+func _ready():
+	pass
+
+
+func _process(delta):
+	pass
+
+var skipDialoguePresented = false
+func MainShellRoutine():
+	if (roundManager.playerData.currentBatchIndex != 0):
+		roundManager.shellLoadingSpedUp = true
+	#CLEAR PREVIOUS SHELL SEQUENCE ARRAY
+	sequenceArray = []
+	#CHECK IF CONSOLE TEXT EXISTS. SHOW CONSOLE TEXT
+	
+	#INITIAL CAMERA SOCKET. HEALTH COUNTER FUNCTIONALITY
+	if (roundManager.roundArray[roundManager.currentRound].bootingUpCounter):
+		camera.BeginLerp("health counter")
+		await get_tree().create_timer(.5, false).timeout
+		healthCounter.Bootup()
+		await get_tree().create_timer(1.4, false).timeout
+	#await get_tree().create_timer(2, false).timeout #NEW
+	camera.BeginLerp("shell compartment")
+	await get_tree().create_timer(.5, false).timeout
+	#SHELL SPAWNING
+	var temp_nr = roundManager.roundArray[roundManager.currentRound].amountBlank + roundManager.roundArray[roundManager.currentRound].amountLive
+	var temp_live = roundManager.roundArray[roundManager.currentRound].amountLive
+	var temp_blank = roundManager.roundArray[roundManager.currentRound].amountBlank
+	var temp_shuf = roundManager.roundArray[roundManager.currentRound].shufflingArray
+	SpawnShells(temp_nr, temp_live, temp_blank, temp_shuf)
+	seq = sequenceArray
+	anim_compartment.play("show shells")
+	PlayLatchSound()
+	PlayAudioIndicators()
+	await get_tree().create_timer(1, false).timeout
+	roundManager.ignoring = false
+	#DIALOGUE
+	var text_lives
+	var text_blanks
+	if (temp_live == 1): text_lives = "LIVE ROUND."
+	else: text_lives = "LIVE ROUNDS."
+	if (temp_blank == 1): text_blanks = "BLANK."
+	else: text_blanks = "BLANKS."
+	var finalstring : String = str(temp_live) + " " + text_lives + " " + str(temp_blank) + " " + text_blanks
+	var maindur = 1.3
+	if (roundManager.playerData.currentBatchIndex == 2):
+		roundManager.playerData.skippingShellDescription = true
+	if (!roundManager.playerData.skippingShellDescription): dialogue.ShowText_Forever(finalstring)
+	if (roundManager.playerData.skippingShellDescription && !skipDialoguePresented):
+		dialogue.ShowText_Forever("YOU KNOW THE DRILL.")
+		maindur = 2.5
+		skipDialoguePresented = true
+	if(!roundManager.playerData.skippingShellDescription): await get_tree().create_timer(2.5, false).timeout
+	else: await get_tree().create_timer(maindur, false).timeout
+	dialogue.HideText()
+	#HIDE SHELLS
+	anim_compartment.play("hide shells")
+	PlayLatchSound()
+	if(roundManager.shellLoadingSpedUp): await get_tree().create_timer(.2, false).timeout
+	else: await get_tree().create_timer(.5, false).timeout
+	#CHECK IF INSERTING INTO CHAMBER IN RANDOM ORDER.
+	if (roundManager.roundArray[roundManager.currentRound].insertingInRandomOrder):
+		sequenceArray.shuffle()
+		sequenceArray.shuffle()
+	roundManager.LoadShells()
+	return
+	pass
+
+func SpawnShells(numberOfShells : int, numberOfLives : int, numberOfBlanks : int, shufflingArray : bool):
+	#DELETE PREVIOUS SHELLS
+	for i in range(spawnedShellObjectArray.size()):
+		spawnedShellObjectArray[i].queue_free()
+	spawnedShellObjectArray = []
+	
+	#SETUP SHELL ARRAY
+	sequenceArray = []
+	tempSequence = []
+	for i in range(numberOfLives):
+		tempSequence.append("live")
+	for i in range(numberOfBlanks):
+		tempSequence.append("blank")
+	if (shufflingArray):
+		tempSequence.shuffle()
+	for i in range(tempSequence.size()):
+		sequenceArray.append(tempSequence[i])
+		pass
+	
+	locationIndex = 0
+	#SPAWN SHELLS
+	for i in range(numberOfShells):
+		spawnedShell = shellInstance.instantiate()
+		shellBranch = spawnedShell.get_child(0)
+		if (sequenceArray[i] == "live"): shellBranch.isLive = true
+		else: shellBranch.isLive = false
+		shellBranch.ApplyStatus()
+		spawnParent.add_child(spawnedShell)
+		spawnedShell.transform.origin = shellLocationArray[locationIndex]
+		spawnedShell.rotation_degrees = Vector3(-90, -90, 180)
+		spawnedShellObjectArray.append(spawnedShell)
+		locationIndex += 1
+		pass
+	pass
+
+var tog = false
+func PlayLatchSound():
+	tog = !tog
+	if (tog): speaker_latchOpen.stream = soundArray_latchOpen[0]
+	else: speaker_latchOpen.stream = soundArray_latchOpen[1]
+	speaker_latchOpen.play()
+
+var seq = []
+func PlayAudioIndicators():
+	await get_tree().create_timer(.37, false).timeout
+	for i in range(seq.size()):
+		if (seq[i] == "blank"): speaker_audioIndicator.stream = soundArray_indicators[0]
+		else: speaker_audioIndicator.stream = soundArray_indicators[1]
+		speaker_audioIndicator.play()
+		await get_tree().create_timer(.07, false).timeout
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

ShotgunShooting.gd

@@ -0,0 +1,214 @@
+class_name ShotgunShooting extends Node
+
+@export var ejectionManager_player : ShellEjectManager
+@export var cursorManager : CursorManager
+@export var shotgunIndicator : PickupIndicator
+@export var roundManager : RoundManager
+@export var shellSpawner : ShellSpawner
+@export var collider_shotgun : StaticBody3D
+@export var decisionText : DecisionTextManager
+@export var shotgunshaker : ObjectShaker
+@export var perm : PermissionManager
+@export var animator_shotgun : AnimationPlayer
+@export var camera : CameraManager
+@export var speaker_live : AudioStreamPlayer2D
+@export var speaker_blank : AudioStreamPlayer2D
+@export var healthCounter : HealthCounter
+@export var animator_muzzleFlash : AnimationPlayer
+@export var animator_muzzleFlash_model : AnimationPlayer
+@export var cameraShaker : CameraShaker
+@export var death : DeathManager
+@export var smoke : SmokeController
+@export var speakerArray_pitchShift : Array[SpeakerController]
+@export var speakerArray_pitchShift3D : Array[SpeakerController3D]
+@export var timescale : TimeScaleManager
+@export var splatters : Array[CompressedTexture2D]
+@export var mat_splatter : GeometryInstance3D
+@export var speaker_splatter : AudioStreamPlayer2D
+@export var anim_splatter : AnimationPlayer
+
+var playerCanGoAgain
+
+func GrabShotgun():
+	perm.SetIndicators(false)
+	perm.SetInteractionPermissions(false)
+	perm.RevertDescriptionUI()
+	ShotgunCollider(false)
+	animator_shotgun.play("player grab shotgun")
+	shotgunshaker.StartShaking()
+	decisionText.SetUI(true)
+	await get_tree().create_timer(.5, false).timeout
+
+var disablingDelayShit = false
+var dealerShotTrue = false
+
+func MainSlowDownRoutine(whoCopy : String, fromDealer : bool):
+	var who = whoCopy
+	var currentRoundInChamber = shellSpawner.sequenceArray[0]
+	var healthAfterShot = 1
+	if (!fromDealer):
+		healthAfterShot = roundManager.health_opponent - roundManager.currentShotgunDamage
+		if (healthAfterShot < 0): healthAfterShot = 0
+	else: if(roundManager.health_opponent == 0): healthAfterShot = 0
+	if (currentRoundInChamber == "live" && who == "dealer" && healthAfterShot == 0): 
+		#TIME SCALE SHIFT
+		for i in range(speakerArray_pitchShift.size()):
+			speakerArray_pitchShift[i].fadeDuration_pitch = timescale.pitchShiftDuration
+			speakerArray_pitchShift[i].BeginPitchShift(speakerArray_pitchShift[i].lowestPitchValue, speakerArray_pitchShift[i].originalPitch)
+		for i in range(speakerArray_pitchShift3D.size()):
+			speakerArray_pitchShift3D[i].fadeDuration_pitch = timescale.pitchShiftDuration
+			speakerArray_pitchShift3D[i].BeginPitchShift(speakerArray_pitchShift3D[i].lowestPitchValue, speakerArray_pitchShift3D[i].originalPitch)
+		timescale.BeginTimeScaleLerp(.2, 1.0)
+		BloodSplatter()
+
+
+func BloodSplatter():
+	await get_tree().create_timer(.17, false).timeout
+	speaker_splatter.pitch_scale = randf_range(.3, .5)
+	speaker_splatter.play()
+	anim_splatter.play("fade out")
+	mat_splatter.material_override.set("albedo_texture", splatters[0])
+	await get_tree().create_timer(.08, false).timeout
+	mat_splatter.material_override.set("albedo_texture", splatters[1])
+	await get_tree().create_timer(.08, false).timeout
+	mat_splatter.material_override.set("albedo_texture", splatters[2])
+	await get_tree().create_timer(.08, false).timeout
+	mat_splatter.material_override.set("albedo_texture", splatters[3])
+	pass
+
+func Shoot(who : String):
+	dealerShotTrue = false
+	disablingDelayShit = false
+	playerCanGoAgain = false
+	var playerDied = false
+	var dealerShot = false
+	ejectionManager_player.FadeOutShell()
+	cursorManager.SetCursor(false, false)
+	#CAMERA CONTROLS & ANIMATION DEPENDING ON WHO IS SHOT
+	match(who):
+		"self":
+			await get_tree().create_timer(.25, false).timeout
+			animator_shotgun.play("player shoot self")
+			await get_tree().create_timer(.5, false).timeout
+			camera.BeginLerp("enemy")
+		"dealer":
+			await get_tree().create_timer(.25, false).timeout
+			animator_shotgun.play("player shoot dealer")
+			await get_tree().create_timer(.5, false).timeout
+			camera.BeginLerp("enemy")
+	#PLAY CORRECT SOUND. ASSIGN CURRENT ROUND IN CHAMBER
+	await get_tree().create_timer(2, false).timeout
+	var currentRoundInChamber = shellSpawner.sequenceArray[0]
+	MainSlowDownRoutine(who, false)
+	if (who == "self"): whoshot = "player"
+	else: whoshot = "dealer"
+	PlayShootingSound()
+	#SHAKE CAMERA
+	if (currentRoundInChamber == "live"):
+		smoke.SpawnSmoke("barrel")
+		cameraShaker.Shake()
+	#SUBTRACT HEALTH. ASSIGN PLAYER CAN GO AGAIN. RETURN IF DEAD
+	if (currentRoundInChamber == "live" && who == "dealer"): 
+		roundManager.health_opponent -= roundManager.currentShotgunDamage
+		if (roundManager.health_opponent < 0): roundManager.health_opponent = 0
+	if (currentRoundInChamber == "live" && who == "self"): 
+		roundManager.waitingForHealthCheck2 = true
+		if (shellSpawner.sequenceArray.size() == 1): 
+			whatTheFuck = true
+		roundManager.waitingForDealerReturn = true
+		healthCounter.playerShotSelf = true
+		playerDied = true
+		roundManager.health_player -= roundManager.currentShotgunDamage
+		if (roundManager.health_player < 0): roundManager.health_player = 0
+		playerCanGoAgain = false
+		healthCounter.checkingPlayer = true
+		await(death.Kill("player", false, true))
+	if (currentRoundInChamber == "blank" && who == "self"): playerCanGoAgain = true
+	if (currentRoundInChamber == "live" && who == "dealer"): 
+		playerCanGoAgain = false
+		dealerShot = true
+		dealerShotTrue = true
+		await(death.Kill("dealer", false, false))
+	if (playerDied): return
+	if (dealerShot): return
+	await get_tree().create_timer(.3, false).timeout
+	#EJECTING SHELLS
+	if (currentRoundInChamber == "blank" && who == "self"):
+		animator_shotgun.play("player eject shell")
+		await get_tree().create_timer(.85, false).timeout
+		camera.BeginLerp("home")
+		await get_tree().create_timer(1.35, false).timeout
+		FinalizeShooting(playerCanGoAgain, true, false, false)
+		return
+	if (currentRoundInChamber == "blank" && who == "dealer"): disablingDelayShit = true
+	ShootingDealerEjection(currentRoundInChamber, who, false)
+
+func ShootingDealerEjection(currentRoundInChamberCopy : String, whoCopy : String, hasDelay : bool):
+	if ((currentRoundInChamberCopy == "blank" or currentRoundInChamberCopy == "live") && whoCopy == "dealer"):
+		animator_shotgun.play("player eject shell2")
+		await get_tree().create_timer(2, false).timeout
+	if (hasDelay): await get_tree().create_timer(2.5, false).timeout
+	if (!disablingDelayShit): 
+		FinalizeShooting(playerCanGoAgain, true, true, false)
+	else: 
+		FinalizeShooting(playerCanGoAgain, true, false, false)
+
+var whatTheFuck = false
+var delaying = false
+var isPlayerSide = false
+func FinalizeShooting(playerCanGoAgain : bool, placeShotgunOnTable : bool, waitForRevival : bool, addDelay : bool):
+	if(placeShotgunOnTable): animator_shotgun.play("player place on table after eject")
+	shotgunshaker.StopShaking()
+	#shellSpawner.sequenceArray.remove_at(0)
+	await get_tree().create_timer(.6, false).timeout
+	shotgunIndicator.Revert()
+	ShotgunCollider(true)
+	if (death.shitIsFuckedUp): await get_tree().create_timer(3, false).timeout
+	if (waitForRevival): await get_tree().create_timer(2, false).timeout
+	if (addDelay): await get_tree().create_timer(3, false).timeout
+	if (delaying): await get_tree().create_timer(4, false).timeout
+	if (whatTheFuck): await get_tree().create_timer(2, false).timeout
+	whatTheFuck = false
+	#delaying = false
+	if (roundManager.shellSpawner.sequenceArray.size() == 0 && dealerShotTrue): await get_tree().create_timer(2, false).timeout
+	#abc
+	if ((roundManager.health_opponent <= 2 or roundManager.health_player <= 2) && roundManager.playerData.currentBatchIndex == 2):
+		if (roundManager.health_opponent <= 2 && !roundManager.wireIsCut_dealer):
+			await get_tree().create_timer(2, false).timeout
+		if (roundManager.health_player <= 2 && !roundManager.wireIsCut_player):
+			await get_tree().create_timer(2, false).timeout
+	if(roundManager.health_opponent != 0): roundManager.EndTurn(playerCanGoAgain)
+
+func PlayShootingSound():
+	var currentRoundInChamber = shellSpawner.sequenceArray[0]
+	if (currentRoundInChamber == "live"):
+		CheckIfFinalShot()
+		speaker_live.play()
+		roundManager.playerData.stat_shotsFired += 1
+		animator_muzzleFlash.play("muzzle flash fire")
+		animator_muzzleFlash_model.play("fire")
+	else: speaker_blank.play()
+	pass
+
+var fired = false
+var temphealth_dealer
+var temphealth_player
+var whoshot = ""
+func CheckIfFinalShot():
+	temphealth_dealer = roundManager.health_opponent - roundManager.currentShotgunDamage
+	temphealth_player = roundManager.health_player - roundManager.currentShotgunDamage
+	if (!fired && roundManager.playerData.currentBatchIndex == 2):
+		if (temphealth_player <= 2 && whoshot == "player"):
+			roundManager.musicManager.EndTrack()
+			fired = true
+		if (temphealth_dealer <= 2 && whoshot == "dealer"):
+			roundManager.musicManager.EndTrack()
+			fired = true
+
+func ShotgunCollider(isEnabled : bool):
+	if (isEnabled):
+		collider_shotgun.collision_layer = 1
+		collider_shotgun.collision_mask = 1
+	else:
+		collider_shotgun.collision_layer = 0
+		collider_shotgun.collision_mask = 0

SignatureButtonBranch.gd

@@ -0,0 +1,41 @@
+class_name SignButton extends Node
+
+var parent : Node3D
+var intbranch : InteractionBranch
+@export var y_up : float
+@export var y_down :  float
+@export var dur : float
+var elapsed = 0
+var moving = false
+var cur
+var next
+
+func _ready():
+	parent = get_parent()
+	intbranch = parent.get_child(1)
+
+func _process(delta):
+	Lerp()
+
+func Press():
+	intbranch.interactionAllowed = false
+	cur = y_up
+	next = y_down
+	elapsed = 0
+	moving = true
+	await get_tree().create_timer(.06, false).timeout
+	moving = false
+	cur = y_down
+	next = y_up
+	elapsed = 0
+	moving = true
+	await get_tree().create_timer(.06, false).timeout
+	moving = false
+	intbranch.interactionAllowed = true
+
+func Lerp():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = elapsed / dur
+		var temp_pos = lerpf(cur, next, c)
+		parent.transform.origin = Vector3(parent.transform.origin.x, temp_pos, parent.transform.origin.z)

SignatureManager.gd

@@ -0,0 +1,175 @@
+class_name Signature extends Node
+
+@export var roundManager : RoundManager
+@export var parent_shotgun : Node3D
+@export var parent_waiver : Node3D
+@export var parent_separateWaiver : Node3D
+@export var parent_signatureMachineMainParent : Node3D
+@export var intrbranch_waiver : InteractionBranch
+@export var cursor : CursorManager
+@export var anim_waiver : AnimationPlayer
+@export var intbranches : Array[InteractionBranch]
+@export var marker : Label3D
+@export var letterArray : Array[Label3D]
+@export var ledArray : Array[GeometryInstance3D]
+@export var posArray_marker : Array[Vector3]
+@export var letterArray_signature_joined : Array[Label3D]
+@export var letterArray_signature_separate : Array[Label3D]
+@export var speaker_bootup : AudioStreamPlayer2D
+@export var speaker_shutdown : AudioStreamPlayer2D
+@export var speaker_keypress : AudioStreamPlayer2D
+@export var speaker_punch : AudioStreamPlayer2D
+
+var fullstring = ""
+var lettercount = 0
+var origpos_shotgun
+var markerIndex = 0
+var blinking = false
+
+func _ready():
+	for l in letterArray_signature_joined: l.text = ""
+	for l in letterArray_signature_separate: l.text = ""
+	parent_signatureMachineMainParent.visible = false
+	await get_tree().create_timer(2, false).timeout
+	if (roundManager.playerData.hasSignedWaiver == false): SetupWaiver()
+
+func BlinkMarker():
+	while(blinking):
+		marker.modulate.a = 0
+		await get_tree().create_timer(.3, false).timeout
+		marker.modulate.a = 1
+		await get_tree().create_timer(.3, false).timeout
+		pass
+	pass
+
+func SetupWaiver():
+	origpos_shotgun = parent_shotgun.transform.origin
+	parent_shotgun.transform.origin = Vector3(-1.738, -5, -0.041)
+	parent_waiver.transform.origin = Vector3(-29.613, -35.341, -6.696)
+
+func AwaitPickup():
+	await get_tree().create_timer(.6, false).timeout
+	cursor.SetCursor(true, true)
+	intrbranch_waiver.interactionAllowed = true
+
+func PickUpWaiver():
+	speaker_bootup.play()
+	parent_signatureMachineMainParent.visible = true
+	intrbranch_waiver.interactionAllowed = false
+	cursor.SetCursor(false, false)
+	anim_waiver.play("pickup waiver")
+	for letter in letterArray: letter.text = ""
+	UpdateMarkerPosition()
+	UpdateLEDArray()
+	blinking = true
+	BlinkMarker()
+	await get_tree().create_timer(2.77, false).timeout #.9 anim speed
+	for intbr in intbranches : intbr.interactionAllowed = true
+	cursor.SetCursor(true, true)
+
+func GetInput(letterAlias : String, specialAlias : String):
+	speaker_keypress.pitch_scale = randf_range(.95, 1)
+	speaker_keypress.play()
+	var input
+	if (letterAlias != ""): input = letterAlias
+	else: input = specialAlias
+	if (input != "backspace" && input != "enter"):
+		Input_Letter(input)
+	else: if (input == "enter"):
+		Input_Enter()
+	else: if (input == "backspace"):
+		Input_Backspace()
+
+func Input_Letter(alias : String):
+	if (markerIndex != 6):
+		if (letterArray[markerIndex].text == ""): letterArray[markerIndex].text = alias
+	if (markerIndex != 6): markerIndex += 1
+	UpdateMarkerPosition()
+	UpdateLEDArray()
+	pass
+
+func Input_Enter():
+	var chararray = []
+	fullstring = ""
+	for letter in letterArray:
+		if (letter.text != ""):
+			chararray.append(letter.text)
+	for l in chararray: fullstring += l
+	lettercount = chararray.size()
+	if (fullstring == ""): return
+	if (fullstring == "dealer"): return
+	if (fullstring == "god"): return
+	if (fullstring != ""):
+		for br in intbranches:
+			var el = br.get_parent().get_child(2)
+			br.interactionAllowed = false
+			el.set_collision_layer_value(1, false)
+			el.set_collision_mask_value(1, false)
+	cursor.SetCursor(false, false)
+	await get_tree().create_timer(.25, false).timeout
+	for i in range(lettercount):
+		letterArray_signature_joined[i].text = chararray[i].to_upper()
+		letterArray_signature_separate[i].text = chararray[i].to_upper()
+		ledArray[i].visible = false
+		await get_tree().create_timer(.17, false).timeout
+		speaker_punch.pitch_scale = randf_range(.95, 1)
+		speaker_punch.play()
+	await get_tree().create_timer(.17, false).timeout
+	parent_shotgun.transform.origin = origpos_shotgun
+	anim_waiver.play("put away waiver")
+	speaker_bootup.stop()
+	speaker_shutdown.play()
+	roundManager.playerData.playername = fullstring
+	roundManager.playerData.hasSignedWaiver = true
+	ReturnToMainBatch()
+	await get_tree().create_timer(1.72, false).timeout
+	parent_signatureMachineMainParent.visible = false
+	parent_separateWaiver.visible = false
+	await get_tree().create_timer(.4, false).timeout
+	parent_waiver.queue_free()
+
+func ReturnToMainBatch():
+	await get_tree().create_timer(1.27, false).timeout
+	roundManager.enteringFromWaiver = true
+	roundManager.MainBatchSetup(false)
+
+func Input_Backspace():
+	if (markerIndex != 6 && markerIndex != 0): letterArray[markerIndex - 1].text = ""
+	if (markerIndex == 6): letterArray[markerIndex - 1].text = ""
+	if (markerIndex != 0): markerIndex -= 1
+	UpdateMarkerPosition()
+	UpdateLEDArray()
+	pass
+
+func UpdateMarkerPosition():
+	if(markerIndex != 6): marker.transform.origin = posArray_marker[markerIndex]
+	if (markerIndex == 5 && letterArray[markerIndex].text != ""): marker.visible = false
+	else: if (markerIndex == 6): marker.visible = false
+	else: marker.visible = true
+
+func UpdateLEDArray():
+	for i in range(ledArray.size()):
+		if letterArray[i].text != "":
+			ledArray[i].transparency = 0
+		else:
+			ledArray[i].transparency = 1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

SmokeController.gd

@@ -0,0 +1,15 @@
+class_name SmokeController extends Node
+
+@export var particle_barrel : GPUParticles3D
+@export var particle_chamber : GPUParticles3D
+
+func _ready():
+	SpawnSmoke("barrel")
+	SpawnSmoke("chamber")
+
+func SpawnSmoke(alias : String):
+	match (alias):
+		"barrel":
+			particle_barrel.restart()
+		"chamber":
+			particle_chamber.restart()

SpeakerController.gd

@@ -0,0 +1,81 @@
+class_name SpeakerController extends Node
+
+@export var fadeDuration : float
+@export var fadeDuration_pitch : float
+@export var lowestPitchValue : float
+var speaker : AudioStreamPlayer2D
+var elapsed = 0
+var elapsed_pitch = 0
+var moving = false
+var moving_pitch = false
+var originalVolumeDB : float
+var originalPitch : float
+var currentPitch : float
+var nextPitch : float
+var currentVolume : float
+var nextVolume : float
+
+func _ready():
+	speaker = self.get_parent()
+	originalVolumeDB = speaker.volume_db
+	originalPitch = speaker.pitch_scale
+
+func _process(delta):
+	LerpVolume()
+	LerpPitch()
+
+func SnapVolume(state : bool):
+	moving = false
+	if (state): speaker.volume_db = originalVolumeDB
+	else: speaker.volume_db = linear_to_db(0)
+
+func BeginPitchShift(pitchFrom : float, pitchTo : float):
+	moving_pitch = false
+	elapsed_pitch = 0
+	currentPitch = pitchFrom
+	nextPitch = pitchTo
+	moving_pitch = true
+
+func FadeIn():
+	elapsed = 0
+	currentVolume = db_to_linear(speaker.volume_db)
+	nextVolume = db_to_linear(originalVolumeDB)
+	moving = true
+
+func FadeOut():
+	elapsed = 0	
+	currentVolume = db_to_linear(speaker.volume_db)
+	nextVolume = 0
+	moving = true
+
+func LerpVolume():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / fadeDuration, 0.0, 1.0)
+		var vol = lerpf(currentVolume, nextVolume, c)
+		speaker.volume_db = linear_to_db(vol)
+
+func LerpPitch():
+	if (moving_pitch):
+		elapsed_pitch += get_process_delta_time()
+		var c = clampf(elapsed_pitch / fadeDuration_pitch, 0.0, 1.0)
+		c = ease(c, 0.4)
+		var pitch = lerpf(currentPitch, nextPitch, c)
+		speaker.pitch_scale = pitch
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

SpeakerController3D.gd

@@ -0,0 +1,81 @@
+class_name SpeakerController3D extends Node
+
+@export var fadeDuration : float
+@export var fadeDuration_pitch : float
+@export var lowestPitchValue : float
+var speaker : AudioStreamPlayer3D
+var elapsed = 0
+var elapsed_pitch = 0
+var moving = false
+var moving_pitch = false
+var originalVolumeDB : float
+var originalPitch : float
+var currentPitch : float
+var nextPitch : float
+var currentVolume : float
+var nextVolume : float
+
+func _ready():
+	speaker = self.get_parent()
+	originalVolumeDB = speaker.volume_db
+	originalPitch = speaker.pitch_scale
+
+func _process(delta):
+	LerpVolume()
+	LerpPitch()
+
+func SnapVolume(state : bool):
+	moving = false
+	if (state): speaker.volume_db = originalVolumeDB
+	else: speaker.volume_db = linear_to_db(0)
+
+func BeginPitchShift(pitchFrom : float, pitchTo : float):
+	moving_pitch = false
+	elapsed_pitch = 0
+	currentPitch = pitchFrom
+	nextPitch = pitchTo
+	moving_pitch = true
+
+func FadeIn():
+	elapsed = 0
+	currentVolume = db_to_linear(speaker.volume_db)
+	nextVolume = db_to_linear(originalVolumeDB)
+	moving = true
+
+func FadeOut():
+	elapsed = 0	
+	currentVolume = db_to_linear(speaker.volume_db)
+	nextVolume = 0
+	moving = true
+
+func LerpVolume():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / fadeDuration, 0.0, 1.0)
+		var vol = lerpf(currentVolume, nextVolume, c)
+		speaker.volume_db = linear_to_db(vol)
+
+func LerpPitch():
+	if (moving_pitch):
+		elapsed_pitch += get_process_delta_time()
+		var c = clampf(elapsed_pitch / fadeDuration_pitch, 0.0, 1.0)
+		c = ease(c, 0.4)
+		var pitch = lerpf(currentPitch, nextPitch, c)
+		speaker.pitch_scale = pitch
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

TempDeathScreen.gd

@@ -0,0 +1,22 @@
+class_name TempDeathScreen extends Node
+
+@export var isDeathScreen : bool
+@export var savefile : SaveFileManager
+@export var viewblocker : ColorRect
+@export var speaker : AudioStreamPlayer2D
+var allowed = true
+var fs = false
+
+func _ready():
+	if (isDeathScreen):
+		get_tree().change_scene_to_file("res://scenes/main.tscn")
+
+#func _unhandled_input(event):
+#	if (event.is_action_pressed("enter") && allowed && !fs):
+#		viewblocker.color = Color(0, 0, 0, 1)
+#		speaker.pitch_scale = .8
+#		await get_tree().create_timer(.5, false).timeout
+#		if (!isDeathScreen):
+#			savefile.ClearSave()
+#		get_tree().change_scene_to_file("res://scenes/main.tscn")
+#		allowed = false

TextFire.gd

@@ -0,0 +1,40 @@
+class_name TextFire extends Node
+
+var ui : Control
+var speaker : AudioStreamPlayer2D
+@export var max_x : float
+@export var max_y : float
+@export var duration : float
+
+var orig_x : float
+var orig_y : float
+var moving = false
+var elapsed = 0
+var changed = false
+
+
+func _ready():
+	speaker = get_parent().get_child(1)
+	ui = get_parent()
+
+func Fire():
+	if (!changed): speaker.pitch_scale = randf_range(.95, 1)
+	speaker.play()
+	orig_x = ui.scale.x
+	orig_y = ui.scale.y
+	elapsed = 0
+	moving = true
+	ui.visible = true
+
+func _process(delta):
+	Lerp()
+
+func Lerp():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / duration, 0.0, 1.0)
+		c = ease(c, 0.4)
+		var temp_x = lerpf(max_x, orig_x, c)
+		var temp_y = lerpf(max_y, orig_y, c)
+		ui.scale.x = temp_x
+		ui.scale.y = temp_y

TextInteraction.gd

@@ -0,0 +1,52 @@
+class_name TextInteraction extends Node
+
+@export var text : Label3D
+@export var interaction : InteractionManager
+@export var dur : float
+@export var colorvalue_min : float
+@export var colorvalue_max : float
+
+var elapsed = 0
+var moving = false
+var fs1 = true
+var fs2 = false
+var colorvalue_current = 0.0
+var colorvalue_next = 0.0
+
+func _process(delta):
+	CheckStatus()
+	LerpOpacity()
+
+func CheckStatus():
+	if (interaction.activeParent == text):
+		if (!fs1):
+			BeginLerp()
+			fs2 = false
+			fs1 = true
+	else:
+		if (!fs2):
+			EndLerp()
+			fs1 = false
+			fs2 = true
+
+func BeginLerp():
+	colorvalue_current = text.modulate.r
+	colorvalue_next = colorvalue_max
+	elapsed = 0
+	moving = true
+	pass
+
+func EndLerp():
+	colorvalue_current = text.modulate.r
+	colorvalue_next = colorvalue_min
+	elapsed = 0
+	moving = true
+	pass
+
+func LerpOpacity():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / dur, 0.0, 1.0)
+		var color = lerp(colorvalue_current, colorvalue_next, c)
+		text.modulate = Color(color, color, color, text.modulate.a)
+	pass

TextShaker.gd

@@ -0,0 +1,24 @@
+class_name TextShaker extends Node
+
+@export var delay : float
+@export var offset1 : float
+@export var offset2 : float
+@export var text : Control
+var looping = false
+var origpos
+
+func _ready():
+	origpos = text.position
+	looping = true
+	Shake()
+
+func Shake():
+	while(looping):
+		var randx = randf_range(offset1, offset2)
+		var randy = randf_range(offset1, offset2)
+		text.position = Vector2(randx, randy)
+		await get_tree().create_timer(delay, false).timeout
+		text.position = origpos
+		await get_tree().create_timer(delay, false).timeout
+		pass
+	pass

TimeScaleManager.gd

@@ -0,0 +1,36 @@
+class_name TimeScaleManager extends Node
+
+@export var pitchShiftDuration : float
+@export var timeScaleLerpDuration : float
+
+var moving = false
+var elapsed = 0
+var from
+var to
+
+
+func _process(delta):
+	LerpTimeScale()
+
+#func _unhandled_input(event):
+#	if (event.is_action_pressed("debug_left")):
+#		moving = false
+#		Engine.time_scale = 1
+#	if (event.is_action_pressed("debug_right")):
+#		moving = false
+#		Engine.time_scale = 10
+
+func BeginTimeScaleLerp(start : float, end : float):
+	moving = false
+	elapsed = 0
+	from = start
+	to = end
+	moving = true
+	
+func LerpTimeScale():
+	if (moving):
+		elapsed += get_process_delta_time()
+		var c = clampf(elapsed / timeScaleLerpDuration, 0.0 , 1.0)
+		c = ease(c, 0.4)
+		var val = lerpf(from, to, c)
+		Engine.time_scale = val

TrackInstance.gd

@@ -0,0 +1,8 @@
+class_name TrackInstance extends Resource
+
+@export var trackName : String
+@export var audiofile : AudioStream
+@export var audiofile_secondloop : AudioStream
+@export var defaultLowPassHz : float
+@export var correspondingBatchIndex : int
+@export var bpmIncrement : float

TypingManager.gd

@@ -0,0 +1,44 @@
+class_name TypingManager extends Node
+
+@export var speaker_click : AudioStreamPlayer2D
+@export var dialogueUI : Label3D
+@export var dialogueSpeed : float
+@export var incrementDelay : float
+
+var elapsed = 0
+var moving = false
+var looping = false
+
+func ShowText_ForDuration(activeText : String, showDuration : float):
+	looping = false
+	dialogueUI.visible_characters = 0
+	dialogueUI.text = activeText
+	dialogueUI.visible = true
+	looping = true
+	TickText()
+	await get_tree().create_timer(showDuration, false).timeout
+	looping = false
+	dialogueUI.visible = false
+
+func ShowText_Forever(activeText : String):
+	looping = false
+	dialogueUI.visible_characters = 0
+	dialogueUI.text = activeText
+	dialogueUI.visible = true
+	looping = true
+	TickText()
+
+func HideText():
+	looping = false
+	dialogueUI.visible = false
+	pass
+
+func TickText():
+	while(looping):
+		dialogueUI.visible_characters += 1
+		speaker_click.play()
+		if (dialogueUI.visible_ratio >= 1):
+			looping = false
+		await get_tree().create_timer(incrementDelay, false).timeout
+		pass
+	pass

gridBranch.gd

@@ -0,0 +1,2 @@
+extends Node
+@export var activeIndex : int