buckshotroulette-decomp/ItemManager.gd

class_name ItemManager extends Node

@export var grid : GridIndicator
@export var cursor : CursorManager
@export var controller : ControllerManager
@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
@export var amounts : Amounts
@export var interaction : ItemInteraction
@export var btnParent_stealing : Control
@export var btnparent_ff_stealing : Control
var itemGrabSoundIndex = 0
var itemArray_dealer : Array[String]
var itemArray_instances_dealer : Array[Node3D]
var itemArray_instances_dealer_previous : Array[Node3D]
var itemArray_dealer_previous : Array[String]
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()
	CheckTimer()
	ItemStealTimeout()

@export var btnParent_intake : Control
@export var btn_intake : Control
@export var btn_grids : Array[Control]
func SetIntakeFocus(state : bool):
	btnParent_intake.visible = true
	if (state):
		for grid in btn_grids: grid.visible = false
		btn_intake.visible = true
		if (cursor.controller_active): btn_intake.grab_focus()
		controller.previousFocus = btn_intake
	else:
		for grid in btn_grids: grid.visible = true
		#btn_intake.visible = false

func ClearIntakeFocus():
	btnParent_intake.visible = false
	for grid in btn_grids: grid.visible = false
	btn_intake.visible = false

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(tr("MORE 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]
		string = str(stringIndex)
		dialogue.ShowText_Forever(tr("ITEMS EACH") % string)
		await get_tree().create_timer(2.5, false).timeout
		dialogue.ShowText_Forever(tr("MORE ITEMS"))
		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]
		string = str(stringIndex)
		dialogue.ShowText_Forever(tr("ITEMS EACH") % string)
		await get_tree().create_timer(2.5, false).timeout
		dialogue.HideText()
		roundManager.playerData.hasReadItemDistributionIntro2 = true
	#ALLOW ITEM GRAB
	cursor.SetCursor(true, true)
	SetIntakeFocus(true)
	interaction_intake.interactionAllowed = true
	pass

func EndItemGrabbing():
	GrabItems_Enemy()
	GridParents(false)
	interaction_intake.interactionAllowed = false
	cursor.SetCursor(false, false)
	ClearIntakeFocus()
	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)
	ClearIntakeFocus()
	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)
	SetIntakeFocus(true)
	interaction_intake.interactionAllowed = true

var randindex = 4
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
	
	#SET PLAYER AVAILABLE ITEMS ACCORDING TO MAX COUNTS
	var amountArray : Array[AmountResource] = amounts.array_amounts
	availableItemsToGrabArray_player = []
	for res in amountArray:
		if (res.amount_active == 0): continue
		if (res.amount_player != res.amount_active):
			availableItemsToGrabArray_player.append(res.itemName)
	#for res in amountArray: availableItemsToGrabArray_player.append(res.itemName)
	
	if (roundManager.currentRound == 0 && roundManager.roundArray[roundManager.currentRound].startingHealth == 2):
		if ("handsaw" in availableItemsToGrabArray_player): availableItemsToGrabArray_player.erase("handsaw")
	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()
	
	for res in amountArray:
		if (selectedResource.itemName == res.itemName):
			res.amount_player += 1
			break
	
	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)
		SetIntakeFocus(false)
	else:
		#NOT ENOUGH SPACE. PUT ITEM BACK AND END ITEM GRABBING
		for res in amountArray:
			if (selectedResource.itemName == res.itemName):
				res.amount_player -= 1
				break
		
		dialogue.ShowText_Forever(tr("NO SPACE"))
		await get_tree().create_timer(1.8, false).timeout
		dialogue.ShowText_Forever(tr("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)
		ClearIntakeFocus()
		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
	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
	temp_interaction.isPlayerSide = true
	temp_indicator.dealerGridIndex = gridIndex + 8
	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)
		ClearIntakeFocus()
		await get_tree().create_timer(lerpDuration, false).timeout
		interaction_intake.interactionAllowed = true
		SetIntakeFocus(true)
	pass

var firstItem = true
func GrabItems_Enemy():
	var selectedResource
	for i in range(roundManager.roundArray[roundManager.currentRound].numberOfItemsToGrab):
		if (numberOfItemsGrabbed_enemy != 8):
			
			var amountArray : Array[AmountResource] = amounts.array_amounts
			availableItemsToGrabArray_dealer = []
			for res in amountArray:
				if (res.amount_active == 0): 
					continue
				if (res.amount_dealer != res.amount_active):
					availableItemsToGrabArray_dealer.append(res.itemName)
			
			if (roundManager.currentRound == 0 && roundManager.roundArray[roundManager.currentRound].startingHealth == 2):
				if ("handsaw" in availableItemsToGrabArray_dealer): availableItemsToGrabArray_dealer.erase("handsaw")
			
			var randindex = randi_range(0, availableItemsToGrabArray_dealer.size() - 1)
			var selectedItem = availableItemsToGrabArray_dealer[randindex]
			
			#SPAWN ITEM
			for c in range(instanceArray_dealer.size()):
				if (selectedItem == instanceArray_dealer[c].itemName):
					selectedResource = instanceArray_dealer[c]
					#ADD STRING TO DEALER ITEM ARRAY
					itemArray_dealer.append(instanceArray_dealer[c].itemName.to_lower())
					break
			var itemInstance = selectedResource.instance.instantiate()
			var temp_itemIndicator = itemInstance.get_child(0)
			temp_itemIndicator.isDealerItem = true
			for res in amountArray:
				if (selectedResource.itemName == res.itemName):
					res.amount_dealer += 1
					break
			
			#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)
			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


var PREVIOUS_items_dyanmicIndicatorArray : Array[PickupIndicator]
var PREVIOUS_items_dynamicInteractionArray : Array[InteractionBranch]
func SetupItemSteal():
	PREVIOUS_items_dyanmicIndicatorArray = []
	PREVIOUS_items_dynamicInteractionArray = []
	PREVIOUS_items_dyanmicIndicatorArray = items_dynamicIndicatorArray
	PREVIOUS_items_dynamicInteractionArray = items_dynamicInteractionArray
	items_dynamicIndicatorArray = []
	items_dynamicInteractionArray = []
	interaction.pos_hand = interaction.pos_hand_stealing
	interaction.rot_hand = interaction.rot_hand_stealing
	
	interaction.stealing = true
	
	var ch = itemSpawnParent.get_children()
	for c in ch.size():
		if(ch[c].get_child(0) is PickupIndicator):
			var temp_indicator : PickupIndicator = ch[c].get_child(0)
			var temp_interaction : InteractionBranch = ch[c].get_child(1)
			items_dynamicIndicatorArray.append(temp_indicator)
			items_dynamicInteractionArray.append(temp_interaction)
	
	camera.BeginLerp("enemy items")
	await get_tree().create_timer(.7, false).timeout
	interaction.stealing_fs = true
	interaction.EnablePermissions()
	interaction.DisableShotgun()
	roundManager.ClearDeskUI(true)
	btnParent_stealing.visible = true
	if (cursor.controller_active): btnparent_ff_stealing.grab_focus()
	controller.previousFocus = btnparent_ff_stealing
	for c in ch.size():
		if(ch[c].get_child(0) is PickupIndicator):
			var temp_indicator : PickupIndicator = ch[c].get_child(0)
			var temp_interaction : InteractionBranch = ch[c].get_child(1)
	Counter(true)

func RevertItemSteal(): 
	btnParent_stealing.visible = false
	items_dynamicIndicatorArray = PREVIOUS_items_dyanmicIndicatorArray
	items_dynamicInteractionArray = PREVIOUS_items_dynamicInteractionArray

func RevertItemSteal_Timeout():
	btnParent_stealing.visible = false
	interaction.stealing = false
	interaction.DisablePermissions()
	items_dynamicIndicatorArray = PREVIOUS_items_dyanmicIndicatorArray
	items_dynamicInteractionArray = PREVIOUS_items_dynamicInteractionArray
	var ch = itemSpawnParent.get_children()
	for c in ch.size():
		if(ch[c].get_child(0) is PickupIndicator):
			var temp_indicator : PickupIndicator = ch[c].get_child(0)
			temp_indicator.Revert()
	camera.BeginLerp("home")
	await get_tree().create_timer(.4, false).timeout
	interaction.stealing_fs = false
	interaction.pos_hand = interaction.pos_hand_main
	interaction.rot_hand = interaction.rot_hand_main
	interaction.EnablePermissions()

func Counter(starting : bool):
	if (starting):
		timer_steal_current = 0
		counting = true
		checking = true
		fs = false
	else:
		timer_steal_current = 0
		counting = false
		checking = false
		fs = true

var timer_steal_current = 0.0
var timer_steal_max = 7.0
var counting = false
var checking = false
func ItemStealTimeout():
	if (counting): timer_steal_current += get_process_delta_time()

var fs = false
func CheckTimer():
	if ((timer_steal_current > timer_steal_max) && checking && !fs):
		RevertItemSteal_Timeout()
		fs = true
	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 = []
	
	var amountArray : Array[AmountResource] = amounts.array_amounts
	for res in amountArray:
		res.amount_dealer = 0
		res.amount_player = 0

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

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