commit 33efc850076ff5bf93c3175cd213aab2600da62e Author: Lyssa <75037904+thecatontheceiling@users.noreply.github.com> Date: Sat Jan 20 16:17:43 2024 +0400 Add files via upload diff --git a/BlinkerBranch.gd b/BlinkerBranch.gd new file mode 100644 index 0000000..7460f26 --- /dev/null +++ b/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 diff --git a/BlockoutManager.gd b/BlockoutManager.gd new file mode 100644 index 0000000..c581270 --- /dev/null +++ b/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 diff --git a/BpmLight.gd b/BpmLight.gd new file mode 100644 index 0000000..ea439d8 --- /dev/null +++ b/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 diff --git a/BriefcaseMachine.gd b/BriefcaseMachine.gd new file mode 100644 index 0000000..3eff7be --- /dev/null +++ b/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() diff --git a/ButtonClass.gd b/ButtonClass.gd new file mode 100644 index 0000000..f599510 --- /dev/null +++ b/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") diff --git a/CameraManager.gd b/CameraManager.gd new file mode 100644 index 0000000..7908881 --- /dev/null +++ b/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 diff --git a/CameraShaker.gd b/CameraShaker.gd new file mode 100644 index 0000000..ff38aaf --- /dev/null +++ b/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 diff --git a/CameraSocket.gd b/CameraSocket.gd new file mode 100644 index 0000000..f7d9c6e --- /dev/null +++ b/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 diff --git a/CompartmentManager.gd b/CompartmentManager.gd new file mode 100644 index 0000000..a7eb979 --- /dev/null +++ b/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") diff --git a/CursorManager.gd b/CursorManager.gd new file mode 100644 index 0000000..e144098 --- /dev/null +++ b/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 diff --git a/DealerIntelligence.gd b/DealerIntelligence.gd new file mode 100644 index 0000000..4396e87 --- /dev/null +++ b/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 diff --git a/DeathManager.gd b/DeathManager.gd new file mode 100644 index 0000000..828136c --- /dev/null +++ b/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) diff --git a/DecisionTextManager.gd b/DecisionTextManager.gd new file mode 100644 index 0000000..0fd9c39 --- /dev/null +++ b/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") diff --git a/DefibBlade.gd b/DefibBlade.gd new file mode 100644 index 0000000..4278dee --- /dev/null +++ b/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() diff --git a/DefibCutter.gd b/DefibCutter.gd new file mode 100644 index 0000000..aad4bfb --- /dev/null +++ b/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() + + + + + + + + + + + + + + diff --git a/DescriptionManager.gd b/DescriptionManager.gd new file mode 100644 index 0000000..61ceb89 --- /dev/null +++ b/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 diff --git a/DialogueManager.gd b/DialogueManager.gd new file mode 100644 index 0000000..6b1e79e --- /dev/null +++ b/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 diff --git a/DialogueManager_Ending.gd b/DialogueManager_Ending.gd new file mode 100644 index 0000000..f784c00 --- /dev/null +++ b/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 diff --git a/EndingManager.gd b/EndingManager.gd new file mode 100644 index 0000000..b4f25a3 --- /dev/null +++ b/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 diff --git a/FilterController.gd b/FilterController.gd new file mode 100644 index 0000000..d886fad --- /dev/null +++ b/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 diff --git a/GameOverManager.gd b/GameOverManager.gd new file mode 100644 index 0000000..7b07d14 --- /dev/null +++ b/GameOverManager.gd @@ -0,0 +1,4 @@ +class_name GameOverManager extends Node + +func PlayerWon(): + get_tree().change_scene_to_file("res://scenes/win.tscn") diff --git a/HandManager.gd b/HandManager.gd new file mode 100644 index 0000000..571ea04 --- /dev/null +++ b/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 + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/HandcuffManager.gd b/HandcuffManager.gd new file mode 100644 index 0000000..1956edb --- /dev/null +++ b/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 diff --git a/HealthCounter.gd b/HealthCounter.gd new file mode 100644 index 0000000..1b5f5ee --- /dev/null +++ b/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 diff --git a/HeavenManager.gd b/HeavenManager.gd new file mode 100644 index 0000000..90082ee --- /dev/null +++ b/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 diff --git a/InteractionBranch.gd b/InteractionBranch.gd new file mode 100644 index 0000000..6ca2171 --- /dev/null +++ b/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) diff --git a/InteractionManager.gd b/InteractionManager.gd new file mode 100644 index 0000000..495f5b6 --- /dev/null +++ b/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 diff --git a/IntroManager.gd b/IntroManager.gd new file mode 100644 index 0000000..c72f1bf --- /dev/null +++ b/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 diff --git a/ItemGridIndicator.gd b/ItemGridIndicator.gd new file mode 100644 index 0000000..dac4434 --- /dev/null +++ b/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 diff --git a/ItemInteraction.gd b/ItemInteraction.gd new file mode 100644 index 0000000..a04960e --- /dev/null +++ b/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) diff --git a/ItemManager.gd b/ItemManager.gd new file mode 100644 index 0000000..bc51ce6 --- /dev/null +++ b/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 + + + + + + + + + + + + + + + diff --git a/ItemProperties.gd b/ItemProperties.gd new file mode 100644 index 0000000..f59d725 --- /dev/null +++ b/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 diff --git a/ItemResource.gd b/ItemResource.gd new file mode 100644 index 0000000..fa44d0f --- /dev/null +++ b/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 diff --git a/MenuManager.gd b/MenuManager.gd new file mode 100644 index 0000000..a673b25 --- /dev/null +++ b/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() diff --git a/MouseRaycast.gd b/MouseRaycast.gd new file mode 100644 index 0000000..2a2cf7c --- /dev/null +++ b/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)) diff --git a/MusicManager.gd b/MusicManager.gd new file mode 100644 index 0000000..650d765 --- /dev/null +++ b/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() diff --git a/ObjectShaker.gd b/ObjectShaker.gd new file mode 100644 index 0000000..190fd84 --- /dev/null +++ b/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 diff --git a/PermissionManager.gd b/PermissionManager.gd new file mode 100644 index 0000000..9ad136d --- /dev/null +++ b/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() diff --git a/PickupIndicator.gd b/PickupIndicator.gd new file mode 100644 index 0000000..001c18e --- /dev/null +++ b/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) + + + + + + + + + + + diff --git a/PlayerCameraTest.gd b/PlayerCameraTest.gd new file mode 100644 index 0000000..a7d003d --- /dev/null +++ b/PlayerCameraTest.gd @@ -0,0 +1,3 @@ +class_name PlayerCameraTest extends Node + +@export var cameraManager : CameraManager diff --git a/PlayerData.gd b/PlayerData.gd new file mode 100644 index 0000000..e4f8b7f --- /dev/null +++ b/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 diff --git a/RoundBatch.gd b/RoundBatch.gd new file mode 100644 index 0000000..ec0742d --- /dev/null +++ b/RoundBatch.gd @@ -0,0 +1,4 @@ +class_name RoundBatch extends Node + +@export var batchIndex : int +@export var roundArray : Array[RoundClass] diff --git a/RoundClass.gd b/RoundClass.gd new file mode 100644 index 0000000..f763d58 --- /dev/null +++ b/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 diff --git a/RoundManager.gd b/RoundManager.gd new file mode 100644 index 0000000..5d00503 --- /dev/null +++ b/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() diff --git a/SaveFileManager.gd b/SaveFileManager.gd new file mode 100644 index 0000000..682bb3d --- /dev/null +++ b/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) diff --git a/SegmentManager.gd b/SegmentManager.gd new file mode 100644 index 0000000..05b2106 --- /dev/null +++ b/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) diff --git a/ShellBranch.gd b/ShellBranch.gd new file mode 100644 index 0000000..5ad4e30 --- /dev/null +++ b/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 diff --git a/ShellDropManager.gd b/ShellDropManager.gd new file mode 100644 index 0000000..f053fd6 --- /dev/null +++ b/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() diff --git a/ShellEjectManager.gd b/ShellEjectManager.gd new file mode 100644 index 0000000..167c3b6 --- /dev/null +++ b/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 diff --git a/ShellExamine.gd b/ShellExamine.gd new file mode 100644 index 0000000..24bbe98 --- /dev/null +++ b/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 diff --git a/ShellLoader.gd b/ShellLoader.gd new file mode 100644 index 0000000..f91ad5f --- /dev/null +++ b/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 diff --git a/ShellSpawner.gd b/ShellSpawner.gd new file mode 100644 index 0000000..1e02f62 --- /dev/null +++ b/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 + + + + + + + + + + + + + + + diff --git a/ShotgunShooting.gd b/ShotgunShooting.gd new file mode 100644 index 0000000..b3fc619 --- /dev/null +++ b/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 diff --git a/SignatureButtonBranch.gd b/SignatureButtonBranch.gd new file mode 100644 index 0000000..41880cf --- /dev/null +++ b/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) diff --git a/SignatureManager.gd b/SignatureManager.gd new file mode 100644 index 0000000..b724023 --- /dev/null +++ b/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 + + + + + + + + + + + + + + + + + + + + diff --git a/SmokeController.gd b/SmokeController.gd new file mode 100644 index 0000000..71977d9 --- /dev/null +++ b/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() diff --git a/SpeakerController.gd b/SpeakerController.gd new file mode 100644 index 0000000..734ebf4 --- /dev/null +++ b/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 + + + + + + + + + + + + + + + + + diff --git a/SpeakerController3D.gd b/SpeakerController3D.gd new file mode 100644 index 0000000..02f367b --- /dev/null +++ b/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 + + + + + + + + + + + + + + + + + diff --git a/TempDeathScreen.gd b/TempDeathScreen.gd new file mode 100644 index 0000000..4f8c827 --- /dev/null +++ b/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 diff --git a/TextFire.gd b/TextFire.gd new file mode 100644 index 0000000..a71d5f9 --- /dev/null +++ b/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 diff --git a/TextInteraction.gd b/TextInteraction.gd new file mode 100644 index 0000000..482f392 --- /dev/null +++ b/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 diff --git a/TextShaker.gd b/TextShaker.gd new file mode 100644 index 0000000..7e7f016 --- /dev/null +++ b/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 diff --git a/TimeScaleManager.gd b/TimeScaleManager.gd new file mode 100644 index 0000000..fc136fb --- /dev/null +++ b/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 diff --git a/TrackInstance.gd b/TrackInstance.gd new file mode 100644 index 0000000..b263dd6 --- /dev/null +++ b/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 diff --git a/TypingManager.gd b/TypingManager.gd new file mode 100644 index 0000000..8af17a4 --- /dev/null +++ b/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 diff --git a/gridBranch.gd b/gridBranch.gd new file mode 100644 index 0000000..67c92fd --- /dev/null +++ b/gridBranch.gd @@ -0,0 +1,2 @@ +extends Node +@export var activeIndex : int