Swarm/InsectButton.gd

extends TextureButton
class_name InsectButton

@onready var hex = $Hex
@onready var tile_count_label = $Hex/TileCountLabel
@onready var insect_icon = $Hex/InsectIcon
var BEE = load("res://Tile/Prefabs/Bee.tres")
@export var insect_resource: TileResource = BEE

const HEX_BLACK = preload("res://InsectTiles/Assets/UI/hex_black.svg")
const HEX_WHITE = preload("res://InsectTiles/Assets/UI/hex_white.svg")

@export var is_black: bool = false

var disable_amount_display: bool = false

var tile_count: int = 1

var selected: bool = false
var hovered: bool = false
var deactivated: bool = false

var is_blacks_turn: bool = false

var should_disable: bool = false

@rpc("call_local", "authority")
func set_authority(peer_id: int) -> void:
	set_multiplayer_authority(peer_id, true)
	pass
	

func is_players_turn() -> bool:
	return is_blacks_turn == is_black

# Have a functions that checks if we're the "owner"
func is_owner() -> bool:
	# TODO: Only use multiplayer authority
	# According to https://docs.godotengine.org/en/stable/classes/class_offlinemultiplayerpeer.html
	# Even without active multiplayer, the normal calls just work as expected
	#if GameData.is_hot_seat:
	#	return true
	#elif GameData.is_player_black == is_black: # we could use multiplayer authority here
	#	return true
	
	#return false
	return is_multiplayer_authority()

@rpc("call_remote", "any_peer")
func update_amount(amount: int) -> void:
	tile_count = amount
	update_tile_count_display()

func update_color(_is_black: bool) -> void:
	is_black = _is_black
	if is_black:
		hex.texture = HEX_BLACK
	else:
		hex.texture = HEX_WHITE
		
	update_tile_count_display()
	insect_icon.texture = insect_resource.ui_texture
		
	if is_black != GameData.is_player_black:
		disabled = true
		return
	
func is_empty() -> bool:
	return tile_count <= 0

func update_tile_count_display() -> void:
	tile_count_label.text = str(tile_count)
	if is_empty():
		disable()

func decrement_tile_count() -> void:
	tile_count -= 1
	update_tile_count_display()
	update_amount.rpc(tile_count)

func disable() -> void:
	disabled = true
	deactivated = true
			
	var tween = get_tree().create_tween()
	tween.tween_property(self, "modulate", Color.DIM_GRAY, 0.15)

func enable() -> void:
	disabled = false
	deactivated = false
	
	var tween = get_tree().create_tween()
	tween.tween_property(self, "modulate", Color.WHITE, 0.15)


func _on_placement_cancelled() -> void:
	refresh_state()

func _on_insect_placed(resource: TileResource, _is_black: bool, pos: Vector4i) -> void:
	refresh_state()
	
	if insect_resource == resource and _is_black == is_black:
		decrement_tile_count()

func refresh_state() -> void:
	selected = false
	
	if should_disable:
		disable()
	
	if not is_empty() and not should_disable:
		enable()
		
	if hovered and not is_empty():
		hover()
	else:
		unhover()

# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	update_color(is_black)
	
	if disable_amount_display:
		$Hex/TileCountLabel.visible = false
	
	GameEvents.insect_selected.connect(_on_insect_selected)
	GameEvents.insect_placement_cancelled.connect(_on_placement_cancelled)
	GameEvents.insect_placed.connect(_on_insect_placed)
	GameEvents.insect_tile_selected.connect(_on_insect_tile_selected)
	GameEvents.insect_tile_moved.connect(_on_insect_tile_moved)
	GameEvents.insect_tile_deselected.connect(_on_insect_tile_deselected)
	
	GameEvents.turn_started.connect(_on_turn_started)
	
	name = insect_resource.tile_name
	
func _on_turn_started(turn_num: int, map: HexGrid, _is_blacks_turn: bool) -> void:
	is_blacks_turn = _is_blacks_turn
	should_disable = false
	if turn_num >= 7 and not GameData.bees_placed.has(is_black):
		if is_black == is_blacks_turn:
			# if not bee has been placed for this player
			# lock all buttons except the bee
			if is_same(BEE, insect_resource):
				# don't lock
				should_disable = false
			else:
				#lock
				should_disable = true
			
	
	refresh_state()
	
func _on_insect_tile_deselected(tile: InsectTile) -> void:
	refresh_state()

func _on_insect_tile_selected(tile: InsectTile) -> void:
	disable()
	
func _on_insect_tile_moved(tile: InsectTile, to: Vector4i) -> void:
	refresh_state()

func _on_insect_selected(button: InsectButton, _is_black: bool) -> void:
	if button != self:
		disable()
		
func hover() -> void:
	if is_blacks_turn != is_black:
		return
		
	if not is_owner():
		return

	var tween = get_tree().create_tween()
	tween.tween_property(hex, "position", Vector2(0, -16), 0.1).set_ease(Tween.EASE_OUT).set_trans(Tween.TRANS_SPRING)

func unhover() -> void:
	#if GameData.is_player_black != is_black:
		#return
	
	var tween = get_tree().create_tween()
	tween.tween_property(hex, "position", Vector2(0, 0), 0.25).set_ease(Tween.EASE_OUT).set_trans(Tween.TRANS_SPRING)

func _on_mouse_entered():
	hovered = true
	
	if not deactivated:
		hover()

func _on_mouse_exited():
	hovered = false
	
	if not selected:
		unhover()

func _on_pressed():
	if is_empty():
		return
		
	if not is_owner():
		return
		
	if not is_players_turn():
		return
		
	selected = true
		
	GameEvents.insect_selected.emit(self, is_black)
	
	release_focus()

func _input(event):
	if Input.is_action_just_pressed("deselect_tile"):
		release_focus()
		return