Swarm/Tile/Tile.gd

extends Area3D
class_name InsectTile

var map_reference: HexGrid

var is_blacks_turn: bool = false

var coordinates: Vector4i
var layer: int = 0

@export var is_black: bool = false
@export var resource: TileResource

@onready var hexagon_small = $HexagonSmall

var hat: InsectTile = null

var build_in_progress: bool = false
var move_in_progress: bool = false


var deactivated: bool = false

var hovered: bool = false

var selected: bool = false

var hover_shader: ShaderMaterial = preload("res://InsectTiles/HoverShader.tres")

const SELECTION_FAILED_MAT: ShaderMaterial = preload("res://InsectTiles/SelectionFailedMat.tres")
const ACTION_SHADER = preload("res://InsectTiles/ActionShader.tres")

var mat: StandardMaterial3D

var tween: Tween

var tweening: bool = false

var selected_for_action: bool = false
var can_be_selected: bool = false

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()

func _ready() -> void:
	if is_black:
		hexagon_small.set_surface_override_material(0, resource.material_black.duplicate())
	else:
		hexagon_small.set_surface_override_material(0, resource.material_white.duplicate())

	mat = hexagon_small.get_surface_override_material(0)
	
	mat.next_pass = hover_shader.duplicate()
	
	if is_black:
		hexagon_small.rotation.y = PI
		
	GameEvents.insect_selected.connect(_on_insect_selected)
	GameEvents.insect_placed.connect(_on_insect_placed)
	GameEvents.insect_placement_cancelled.connect(_on_insect_placement_cancelled, CONNECT_DEFERRED)
	GameEvents.insect_tile_selected.connect(_on_insect_tile_selected)
	GameEvents.insect_tile_deselected.connect(_on_insect_tile_deselected)
	GameEvents.insect_tile_moved.connect(_on_insect_tile_moved)
	GameEvents.insect_tiles_selected_for_action.connect(_on_tiles_selected_for_action)
	
	GameEvents.turn_started.connect(_on_turn_started)

func _on_turn_started(turn_num: int, map: HexGrid, _is_blacks_turn: bool) -> void:
	is_blacks_turn = _is_blacks_turn

	can_be_selected = GameData.bees_placed.has(is_black)
	#print(GameData.has_bee_been_placed)
	if turn_num >= 7 and not GameData.bees_placed.has(is_black):
		can_be_selected = true

func _on_tiles_selected_for_action(source_pos: Vector4i, targets: Array[InsectTile]) -> void:
	if self in targets:
		selected_for_action = true
		mat.next_pass = ACTION_SHADER
		return
		
	deactivated = true
	
		
func _on_insect_tile_moved(tile: InsectTile, to: Vector4i) -> void:
	move_in_progress = false
	selected = false
	
	if tile == self:
		hovered = false
		if not tweening:
			mat.next_pass = null
	
func _on_insect_tile_deselected(tile: InsectTile) -> void:
	move_in_progress = false
	selected = false
	
func _on_insect_tile_selected(tile: InsectTile) -> void:
	if tile == self:
		selected = true
	
func _on_insect_placed(resource: TileResource, is_black: bool, pos: Vector4i) -> void:
	build_in_progress = false
	
func _on_insect_placement_cancelled() -> void:
	build_in_progress = false
	
func _on_insect_selected(button: InsectButton, is_black: bool) -> void:
	build_in_progress = true

func _process(delta):
	if Input.is_action_just_pressed("place_tile"):
		if not can_be_selected:
			return
		
		if deactivated:
			return
		
		if not hovered:
			return
			
		if not is_owner():
			return

		if not is_players_turn():
			return
			
		# Move up the insect stack.... or just do not react while we have something on top of us? 
		
		if GameData.allow_selecting_in_stack:
			var top: InsectTile = self
			while top.hat != null:
				top = top.hat
				
			if top.is_black == GameData.is_player_black or GameData.debug:
				GameEvents.insect_tile_selected.emit(top)
		else:
			if hat != null:
				return
			else:
				GameEvents.insect_tile_selected.emit(self)

func hover() -> void:
	if is_blacks_turn != is_black:
		return
		
	if tween != null:
		tween.kill()

	tween = get_tree().create_tween()
	#tween.tween_property(self, "position", Vector3(0, 0, 5), 0.5).set_ease(Tween.EASE_OUT).set_trans(Tween.TRANS_SPRING)
	tween.tween_method(tween_hover_shader, Color(0, 0, 0, 0), Color(0, 0, 0, 1), 0.1).set_ease(Tween.EASE_IN_OUT).set_trans(Tween.TRANS_EXPO)


func tween_hover_shader(color: Color) -> void:
	if mat.next_pass != null:
		mat.next_pass.set_shader_parameter("albedo", color)
		mat.next_pass.set_shader_parameter("emission_color", color)
	
func unhover() -> void:
	if is_blacks_turn != is_black:
		return

	if tween != null:
		tween.kill()

	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)
	tween.tween_method(tween_hover_shader, Color(0, 0, 0, 1), Color(0, 0, 0, 0), 0.25).set_ease(Tween.EASE_IN_OUT).set_trans(Tween.TRANS_EXPO)


func _on_mouse_entered():
	hovered = true
	
	if not deactivated and not selected_for_action:
		hover()
	
func _on_mouse_exited():
	hovered = false
	
	if not selected and not selected_for_action:
		unhover()