overhaul bot
This commit is contained in:
@@ -0,0 +1,495 @@
|
||||
extends Node
|
||||
class_name BotController
|
||||
|
||||
# BotController - Standalone modular bot AI system (no Beehave dependency)
|
||||
# Handles all bot decision-making: movement, grabbing, putting, arranging, and sabotage
|
||||
|
||||
# Configuration
|
||||
@export var tick_rate: int = 60 # Ticks between AI updates (in frames)
|
||||
@export var action_delay: float = 0.5 # Delay between actions
|
||||
|
||||
# References
|
||||
var actor: Node3D # The player character this controller is attached to
|
||||
var enhanced_gridmap: Node
|
||||
var strategic_planner: RefCounted
|
||||
|
||||
# State tracking
|
||||
var _tick_counter: int = 0
|
||||
var _is_processing_action: bool = false
|
||||
var _current_action: String = "idle"
|
||||
|
||||
# Tile constants
|
||||
const GOAL_TILES = [7, 8, 9, 10]
|
||||
const HOLO_TILES = [11, 12, 13, 14]
|
||||
|
||||
func _ready():
|
||||
# print("[BotController] _ready called for parent: ", get_parent().name)
|
||||
if Engine.is_editor_hint():
|
||||
return
|
||||
|
||||
# Get parent (should be player character)
|
||||
actor = get_parent()
|
||||
if not actor:
|
||||
push_error("[BotController] No parent node found")
|
||||
queue_free()
|
||||
return
|
||||
|
||||
# Only run for bots
|
||||
# DEBUG: Print exact state of checks
|
||||
# print("[BotController] Checking if %s is bot. in_group(Bots): %s, is_bot: %s" % [actor.name, actor.is_in_group("Bots"), actor.get("is_bot")])
|
||||
|
||||
if not actor.is_in_group("Bots") and not actor.get("is_bot"):
|
||||
# print("[BotController] Actor is not a bot, removing controller.")
|
||||
queue_free()
|
||||
return
|
||||
|
||||
# Wait for actor to be fully ready
|
||||
await get_tree().create_timer(1.0).timeout # Increased wait time to 1.0s to be safe
|
||||
|
||||
enhanced_gridmap = actor.enhanced_gridmap
|
||||
if not enhanced_gridmap:
|
||||
push_error("[BotController] EnhancedGridMap not found for " + actor.name)
|
||||
return # Don't crash, just stop
|
||||
|
||||
# Initialize strategic planner
|
||||
var BotStrategicPlanner = load("res://scripts/bot_strategic_planner.gd")
|
||||
strategic_planner = BotStrategicPlanner.new(actor, enhanced_gridmap)
|
||||
|
||||
# Disable input processing for bots
|
||||
actor.set_process_input(false)
|
||||
actor.set_process_unhandled_input(false)
|
||||
|
||||
print("[BotController] SUCCESFULLY STARTED for bot: %s (Authority: %s)" % [actor.name, actor.get_multiplayer_authority()])
|
||||
|
||||
func _exit_tree():
|
||||
# Ensure explicit cleanup to assist RefCounted cycle breaking
|
||||
strategic_planner = null
|
||||
actor = null
|
||||
enhanced_gridmap = null
|
||||
|
||||
func _physics_process(_delta):
|
||||
if not is_instance_valid(actor) or not strategic_planner:
|
||||
return
|
||||
|
||||
# Only run on server/authority (Authority 1)
|
||||
# NOTE: If we are not the server, we should not run logic
|
||||
if not multiplayer.is_server():
|
||||
return
|
||||
|
||||
# Rate limiting
|
||||
_tick_counter += 1
|
||||
if _tick_counter < tick_rate:
|
||||
return
|
||||
_tick_counter = 0
|
||||
|
||||
# Don't process if already doing something
|
||||
if _is_processing_action:
|
||||
return
|
||||
|
||||
# Run AI decision loop
|
||||
print("[BotController] Running AI Tick for ", actor.name)
|
||||
_run_ai_tick()
|
||||
|
||||
func _run_ai_tick():
|
||||
"""Main AI decision loop - replaces Beehave behavior tree."""
|
||||
if not is_instance_valid(actor) or _is_processing_action:
|
||||
return
|
||||
|
||||
print("[BotController] AI Tick: evaluating priorities...")
|
||||
|
||||
# Priority 1: Use power-up sabotage if conditions are met
|
||||
if await _try_use_powerup():
|
||||
print("[BotController] Action Taken: PowerUp")
|
||||
return
|
||||
|
||||
# Priority 2: Grab tiles (goal tiles or holo tiles)
|
||||
if await _try_grab():
|
||||
print("[BotController] Action Taken: Grab")
|
||||
return
|
||||
|
||||
# Priority 3: Move toward needed tiles
|
||||
if await _try_move():
|
||||
print("[BotController] Action Taken: Move")
|
||||
return
|
||||
|
||||
# Priority 4: Put tiles back on grid (rarely needed)
|
||||
if await _try_put():
|
||||
print("[BotController] Action Taken: Put")
|
||||
return
|
||||
|
||||
# Priority 5: Arrange playerboard
|
||||
if await _try_arrange():
|
||||
print("[BotController] Action Taken: Arrange")
|
||||
return
|
||||
|
||||
print("[BotController] No action taken (Idle). AP: %d, GoalsAchieved: %s" % [actor.action_points, _is_goals_achieved()])
|
||||
|
||||
# =============================================================================
|
||||
# Power-Up / Sabotage
|
||||
# =============================================================================
|
||||
|
||||
func _try_use_powerup() -> bool:
|
||||
"""Check and execute power-up sabotage."""
|
||||
var powerup_manager = actor.get_node_or_null("PowerUpManager")
|
||||
if not powerup_manager or not powerup_manager.can_use_special():
|
||||
return false
|
||||
|
||||
# Evaluate sabotage opportunity
|
||||
var eval = strategic_planner.evaluate_sabotage_opportunity()
|
||||
if not eval.should_sabotage:
|
||||
return false
|
||||
|
||||
# Execute sabotage
|
||||
_is_processing_action = true
|
||||
_current_action = "sabotaging"
|
||||
|
||||
var success = powerup_manager.use_special_effect()
|
||||
if success:
|
||||
print("[BotController] %s used power-up (reason: %s)" % [actor.name, eval.reason])
|
||||
var main = get_tree().get_root().get_node_or_null("Main")
|
||||
if main and main.has_method("broadcast_message"):
|
||||
main.rpc("broadcast_message", actor.display_name, "Used a special power!")
|
||||
|
||||
await get_tree().create_timer(action_delay).timeout
|
||||
if not is_instance_valid(self): return true # Early exit if deleted
|
||||
|
||||
_is_processing_action = false
|
||||
_current_action = "idle"
|
||||
return success
|
||||
|
||||
# =============================================================================
|
||||
# Grab Tiles
|
||||
# =============================================================================
|
||||
|
||||
func _try_grab() -> bool:
|
||||
"""Try to grab a tile from the grid."""
|
||||
# Check AP only if turn-based
|
||||
if TurnManager.turn_based_mode and actor.action_points <= 0:
|
||||
return false
|
||||
|
||||
if _is_playerboard_full():
|
||||
# print("[BotController] Grab failed: Board full")
|
||||
return false
|
||||
|
||||
# Check if goals already achieved
|
||||
if _is_goals_achieved():
|
||||
return false
|
||||
|
||||
# Get tiles we need
|
||||
var tiles_needed = strategic_planner.get_tiles_needed()
|
||||
|
||||
# Check current position and adjacent cells for tiles
|
||||
var grab_info = _find_tile_to_grab(tiles_needed)
|
||||
if not grab_info.position:
|
||||
# print("[BotController] Grab failed: No valid tile found in range")
|
||||
return false
|
||||
|
||||
# Execute grab
|
||||
_is_processing_action = true
|
||||
_current_action = "grabbing"
|
||||
|
||||
var cell = Vector3i(grab_info.position.x, 1, grab_info.position.y)
|
||||
var item = enhanced_gridmap.get_cell_item(cell)
|
||||
|
||||
# Handle holo tiles (power-up)
|
||||
if item in HOLO_TILES:
|
||||
if actor.is_multiplayer_authority():
|
||||
actor.rpc("sync_grid_item", cell.x, cell.y, cell.z, -1)
|
||||
var powerup_manager = actor.get_node_or_null("PowerUpManager")
|
||||
if powerup_manager:
|
||||
powerup_manager.add_holo_pickup()
|
||||
|
||||
# Only consume AP in turn-based mode
|
||||
if TurnManager.turn_based_mode:
|
||||
actor.action_points -= 1
|
||||
|
||||
print("[BotController] %s collected holo tile!" % actor.name)
|
||||
else:
|
||||
# Regular tile - place in playerboard
|
||||
var target_slot = strategic_planner.find_best_slot_for_tile(item)
|
||||
if target_slot != -1 and actor.is_multiplayer_authority():
|
||||
actor.playerboard[target_slot] = item
|
||||
actor.rpc("sync_grid_item", cell.x, cell.y, cell.z, -1)
|
||||
actor.rpc("sync_playerboard", actor.playerboard)
|
||||
|
||||
if TurnManager.turn_based_mode:
|
||||
actor.action_points -= 1
|
||||
|
||||
print("[BotController] %s grabbed tile %d -> slot %d" % [actor.name, item, target_slot])
|
||||
|
||||
# Check goal completion
|
||||
if _is_goals_achieved():
|
||||
_handle_goal_completion()
|
||||
|
||||
await get_tree().create_timer(action_delay).timeout
|
||||
if not is_instance_valid(self): return true
|
||||
_is_processing_action = false
|
||||
_current_action = "idle"
|
||||
return true
|
||||
|
||||
func _find_tile_to_grab(tiles_needed: Array) -> Dictionary:
|
||||
"""Find best tile to grab from current or adjacent positions."""
|
||||
var result = {"position": null, "type": - 1}
|
||||
|
||||
# Check current position first
|
||||
var current_cell = Vector3i(actor.current_position.x, 1, actor.current_position.y)
|
||||
var item = enhanced_gridmap.get_cell_item(current_cell)
|
||||
|
||||
# Priority: needed tiles > holo tiles > any goal tile
|
||||
if item in tiles_needed:
|
||||
return {"position": actor.current_position, "type": item}
|
||||
if item in HOLO_TILES:
|
||||
result = {"position": actor.current_position, "type": item}
|
||||
|
||||
# Check adjacent cells
|
||||
var neighbors = enhanced_gridmap.get_neighbors(actor.current_position, 0)
|
||||
|
||||
for neighbor in neighbors:
|
||||
if not neighbor.is_walkable:
|
||||
continue
|
||||
var cell = Vector3i(neighbor.position.x, 1, neighbor.position.y)
|
||||
item = enhanced_gridmap.get_cell_item(cell)
|
||||
|
||||
if item in tiles_needed:
|
||||
return {"position": neighbor.position, "type": item}
|
||||
|
||||
if item in HOLO_TILES and not result.position:
|
||||
result = {"position": neighbor.position, "type": item}
|
||||
|
||||
# Third pass: any goal tile
|
||||
if not result.position:
|
||||
for neighbor in neighbors:
|
||||
if not neighbor.is_walkable:
|
||||
continue
|
||||
var cell = Vector3i(neighbor.position.x, 1, neighbor.position.y)
|
||||
item = enhanced_gridmap.get_cell_item(cell)
|
||||
if item in actor.goals and item != -1:
|
||||
return {"position": neighbor.position, "type": item}
|
||||
|
||||
return result
|
||||
|
||||
# =============================================================================
|
||||
# Movement
|
||||
# =============================================================================
|
||||
|
||||
func _try_move() -> bool:
|
||||
"""Try to move toward needed tiles."""
|
||||
if TurnManager.turn_based_mode and actor.action_points <= 0:
|
||||
return false
|
||||
|
||||
if _is_goals_achieved():
|
||||
return false
|
||||
|
||||
# Find optimal movement target
|
||||
var target_pos = strategic_planner.find_optimal_move_target()
|
||||
|
||||
if target_pos == Vector2i(-1, -1) or target_pos == actor.current_position:
|
||||
print("[BotController] Move failed: No valid target or already at target. Pos: %s" % actor.current_position)
|
||||
return false
|
||||
|
||||
# Check if within movement range
|
||||
if not actor.is_within_movement_range(target_pos):
|
||||
print("[BotController] Move failed: Target %s out of range" % target_pos)
|
||||
return false
|
||||
|
||||
# Execute movement
|
||||
_is_processing_action = true
|
||||
_current_action = "moving"
|
||||
|
||||
if actor.is_multiplayer_authority():
|
||||
var path = enhanced_gridmap.find_path(
|
||||
Vector2(actor.current_position),
|
||||
Vector2(target_pos),
|
||||
0,
|
||||
false
|
||||
)
|
||||
if path.size() > 1:
|
||||
path.pop_front()
|
||||
actor.rpc("start_movement_along_path", path, false)
|
||||
|
||||
if TurnManager.turn_based_mode:
|
||||
actor.action_points -= 1
|
||||
|
||||
var tiles_needed = strategic_planner.get_tiles_needed()
|
||||
print("[BotController] %s moving toward tiles %s (Target: %s)" % [actor.name, tiles_needed, target_pos])
|
||||
|
||||
await get_tree().create_timer(action_delay * 2).timeout # Movement takes longer
|
||||
if not is_instance_valid(self): return true
|
||||
_is_processing_action = false
|
||||
_current_action = "idle"
|
||||
return true
|
||||
|
||||
# =============================================================================
|
||||
# Put Tiles Back
|
||||
# =============================================================================
|
||||
|
||||
func _try_put() -> bool:
|
||||
"""Try to put a tile from playerboard onto grid."""
|
||||
if actor.action_points <= 0:
|
||||
return false
|
||||
|
||||
# Find a tile in playerboard that we could put
|
||||
var put_slot = -1
|
||||
for i in range(actor.playerboard.size()):
|
||||
if actor.playerboard[i] in GOAL_TILES:
|
||||
put_slot = i
|
||||
break
|
||||
|
||||
if put_slot == -1:
|
||||
return false
|
||||
|
||||
# Find empty adjacent cell
|
||||
var put_position = _find_empty_adjacent_cell()
|
||||
if not put_position:
|
||||
return false
|
||||
|
||||
# Execute put
|
||||
_is_processing_action = true
|
||||
_current_action = "putting"
|
||||
|
||||
if actor.is_multiplayer_authority():
|
||||
var item = actor.playerboard[put_slot]
|
||||
var cell = Vector3i(put_position.x, 1, put_position.y)
|
||||
actor.rpc("sync_grid_item", cell.x, cell.y, cell.z, item)
|
||||
actor.playerboard[put_slot] = -1
|
||||
actor.rpc("sync_playerboard", actor.playerboard)
|
||||
actor.action_points -= 1
|
||||
print("[BotController] %s put tile %d at %s" % [actor.name, item, put_position])
|
||||
|
||||
await get_tree().create_timer(action_delay).timeout
|
||||
if not is_instance_valid(self): return true
|
||||
_is_processing_action = false
|
||||
_current_action = "idle"
|
||||
return true
|
||||
|
||||
func _find_empty_adjacent_cell() -> Vector2i:
|
||||
"""Find an empty cell adjacent to player."""
|
||||
var current_cell = Vector3i(actor.current_position.x, 1, actor.current_position.y)
|
||||
if enhanced_gridmap.get_cell_item(current_cell) == -1:
|
||||
return actor.current_position
|
||||
|
||||
var neighbors = enhanced_gridmap.get_neighbors(actor.current_position, 0)
|
||||
for neighbor in neighbors:
|
||||
if not neighbor.is_walkable:
|
||||
continue
|
||||
var cell = Vector3i(neighbor.position.x, 1, neighbor.position.y)
|
||||
if enhanced_gridmap.get_cell_item(cell) == -1:
|
||||
return neighbor.position
|
||||
|
||||
return Vector2i(-1, -1)
|
||||
|
||||
# =============================================================================
|
||||
# Arrange Playerboard
|
||||
# =============================================================================
|
||||
|
||||
func _try_arrange() -> bool:
|
||||
"""Try to rearrange tiles in playerboard."""
|
||||
if actor.action_points < 2:
|
||||
return false
|
||||
|
||||
if _is_goals_achieved():
|
||||
return false
|
||||
|
||||
# Find misplaced item and better position
|
||||
var arrangement = _find_best_arrangement()
|
||||
if arrangement.is_empty():
|
||||
return false
|
||||
|
||||
# Execute arrangement
|
||||
_is_processing_action = true
|
||||
_current_action = "arranging"
|
||||
|
||||
if actor.is_multiplayer_authority():
|
||||
var item = actor.playerboard[arrangement.source_slot]
|
||||
actor.playerboard[arrangement.target_slot] = item
|
||||
actor.playerboard[arrangement.source_slot] = -1
|
||||
actor.rpc("sync_playerboard", actor.playerboard)
|
||||
actor.action_points -= 2
|
||||
print("[BotController] %s arranged slot %d -> %d" % [actor.name, arrangement.source_slot, arrangement.target_slot])
|
||||
|
||||
await get_tree().create_timer(action_delay).timeout
|
||||
if not is_instance_valid(self): return true
|
||||
_is_processing_action = false
|
||||
_current_action = "idle"
|
||||
return true
|
||||
|
||||
func _find_best_arrangement() -> Dictionary:
|
||||
"""Find a tile that can be moved to a better position."""
|
||||
for i in range(1, 4): # Check central 3x3
|
||||
for j in range(1, 4):
|
||||
var board_idx = i * 5 + j
|
||||
var goal_idx = (i - 1) * 3 + (j - 1)
|
||||
|
||||
var current_item = actor.playerboard[board_idx]
|
||||
var goal_item = actor.goals[goal_idx] if goal_idx < actor.goals.size() else -1
|
||||
|
||||
if current_item != goal_item and current_item != -1:
|
||||
# Find better position for this item
|
||||
for gi in range(3):
|
||||
for gj in range(3):
|
||||
if actor.goals[gi * 3 + gj] == current_item:
|
||||
var target_slot = (gi + 1) * 5 + (gj + 1)
|
||||
if actor.playerboard[target_slot] == -1:
|
||||
return {"source_slot": board_idx, "target_slot": target_slot}
|
||||
|
||||
return {}
|
||||
|
||||
# =============================================================================
|
||||
# Utility Functions
|
||||
# =============================================================================
|
||||
|
||||
func _is_playerboard_full() -> bool:
|
||||
for item in actor.playerboard:
|
||||
if item == -1:
|
||||
return false
|
||||
return true
|
||||
|
||||
func _is_goals_achieved() -> bool:
|
||||
"""Check if goal pattern is complete in any 3x3 region of playerboard."""
|
||||
var goals_2d = []
|
||||
for i in range(3):
|
||||
var row = []
|
||||
for j in range(3):
|
||||
row.append(actor.goals[i * 3 + j] if i * 3 + j < actor.goals.size() else -1)
|
||||
goals_2d.append(row)
|
||||
|
||||
var board_2d = []
|
||||
for i in range(5):
|
||||
var row = []
|
||||
for j in range(5):
|
||||
row.append(actor.playerboard[i * 5 + j] if i * 5 + j < actor.playerboard.size() else -1)
|
||||
board_2d.append(row)
|
||||
|
||||
for start_row in range(3):
|
||||
for start_col in range(3):
|
||||
var matches = true
|
||||
for i in range(3):
|
||||
for j in range(3):
|
||||
var board_item = board_2d[start_row + i][start_col + j]
|
||||
var goal_item = goals_2d[i][j]
|
||||
if goal_item != -1 and goal_item != board_item:
|
||||
matches = false
|
||||
break
|
||||
elif goal_item == -1 and board_item != -1:
|
||||
matches = false
|
||||
break
|
||||
if not matches:
|
||||
break
|
||||
if matches:
|
||||
return true
|
||||
return false
|
||||
|
||||
func _handle_goal_completion():
|
||||
"""Handle goal completion - trigger scoring."""
|
||||
var main = get_tree().get_root().get_node_or_null("Main")
|
||||
if main:
|
||||
var goals_cycle_manager = main.get_node_or_null("GoalsCycleManager")
|
||||
if goals_cycle_manager:
|
||||
var time_remaining = goals_cycle_manager.get_time_remaining()
|
||||
goals_cycle_manager.on_goal_completed(actor, time_remaining)
|
||||
|
||||
var powerup_manager = actor.get_node_or_null("PowerUpManager")
|
||||
if powerup_manager:
|
||||
powerup_manager.add_goal_completion_reward()
|
||||
|
||||
print("[BotController] %s COMPLETED GOAL!" % actor.name)
|
||||
Reference in New Issue
Block a user