[gd_scene load_steps=23 format=3 uid="uid://b5kwd5kw78cke"] [ext_resource type="Texture2D" uid="uid://cc3u2gb7vnhd8" path="res://assets/Cursors/Outline/crosshair001.png" id="1_8f2jx"] [ext_resource type="PackedScene" uid="uid://cryv12f1bokc6" path="res://ships/components/movement/basic_movement.tscn" id="1_x6p55"] [sub_resource type="GDScript" id="GDScript_va0u0"] script/source = "extends Node2D @export var ai_type : AiManager.AIType @export var ship : Node @export var action_components : Node @export var vision_cone_detector : Node @export var vision_area : Area2D var simulated_mouse_position : Vector2 var input_direction : Vector2 var looking_direction : Vector2 var want_to_fire_attacking_weapons : bool = false var want_to_fire_mining_weapons : bool = false func _physics_process(delta: float) -> void: looking_direction = get_angle_of_ship().normalized() func get_angle_of_ship() -> Vector2: return Vector2.from_angle(ship.rotation) " [sub_resource type="CircleShape2D" id="CircleShape2D_vexfc"] [sub_resource type="CircleShape2D" id="CircleShape2D_humqr"] radius = 500.0 [sub_resource type="GDScript" id="GDScript_kp1mh"] script/source = "extends Node2D @onready var ai_type = owner.ai_type @export var current_state : AiManager.States var enemy_in_surroundings var enemy_in_attacking_range var enemy_already_detected : bool = true ## ALWAYS TRUE FOR TESTING var asteroid_in_surroundings var loot_in_surroundings @onready var ai_state_nodes = { AiManager.States.IDLE: $state_brains/idle, #AiManager.States.CHASING: $state_brains/chasing, AiManager.States.ATTACKING: $state_brains/attacking, AiManager.States.FLEEING: $state_brains/fleeing, AiManager.States.PATROLLING: $state_brains/patrolling, AiManager.States.WANDERING: $state_brains/wandering, AiManager.States.MINING: $state_brains/mining, AiManager.States.LOOTING: $state_brains/looting, #AiManager.States.LOBOTOMY: $state_brains/lobotomy } #IDLE, #CHASING, #ATTACKING, #FLEEING, #PATROLLING, #WANDERING, #MINING, #LOOTING, #LOBOTOMY, func _physics_process(delta: float) -> void: ai_state_nodes[current_state].brain_process(delta) func get_new_state() -> void: if enemy_in_surroundings: if true: #AiManager.ai_parameters[ai_type][\"aggression\"] >= randf(): # Fight or flee current_state = AiManager.States.ATTACKING else: current_state = AiManager.States.FLEEING #current_state = AiManager.States.CHASING elif loot_in_surroundings: current_state = AiManager.States.LOOTING elif asteroid_in_surroundings: current_state = AiManager.States.MINING #elif ai_type[\"exploration_tendency\"] <= randf(): else: current_state = AiManager.States.WANDERING #print(\"get_new_state: \", AiManager.States.find_key(current_state)) func check_surroundings(): enemy_in_surroundings = $vision.surroundings_dict[\"Enemies\"] asteroid_in_surroundings = $vision.surroundings_dict[\"Asteroids\"] loot_in_surroundings = $vision.surroundings_dict[\"Loot\"] get_new_state() func _on_vision_surroundings_changed() -> void: check_surroundings() " [sub_resource type="GDScript" id="GDScript_y2pbm"] resource_name = "vision_AI" script/source = "extends Node signal surroundings_changed() @onready var surroundings_dict: Dictionary = {\"Enemies\": false, \"Asteroids\": false, \"Loot\": false} var entities: Array[Node2D] var updated: bool = false var enemies: bool = false var asteroids: bool = false var loot: bool = false func check_surroundings() -> void: updated = false enemies = false asteroids = false loot = false for entity in entities: if entity.is_in_group(\"Player\"): enemies = true elif entity.is_in_group(\"Asteroids\"): asteroids = true elif entity.is_in_group(\"World_item\"): loot = true if surroundings_dict[\"Enemies\"] != enemies: updated = true if surroundings_dict[\"Asteroids\"] != asteroids: updated = true if surroundings_dict[\"Loot\"] != loot: updated = true surroundings_dict[\"Enemies\"] = enemies surroundings_dict[\"Asteroids\"] = asteroids surroundings_dict[\"Loot\"] = loot if updated: surroundings_changed.emit() func _on_vision_area_body_entered(body: Node2D) -> void: entities.append(body) check_surroundings() func _on_vision_area_body_exited(body: Node2D) -> void: var index = entities.find(body) if index > -1: entities.remove_at(index) check_surroundings() " [sub_resource type="GDScript" id="GDScript_8fu8m"] resource_name = "action_components" script/source = "extends Node @export var look : Node @export var move : Node @export var weapons : Node @export var abilities : Node " [sub_resource type="GDScript" id="GDScript_uxcfm"] resource_name = "ai_look" script/source = "extends Node2D @onready var ship = self.owner.ship # Variables for controlling the angular speed and movement @export var angular_speed : float = 470.0 # How fast the ship can turn in degrees per second @export var lerp : float = 0.1 var current_angular_velocity: float = 0.0 # Current angular velocity of the ship @onready var angular_speed_rad = deg_to_rad(angular_speed) func _physics_process(delta: float) -> void: if owner.simulated_mouse_position: # Get the global mouse position #var mouse_position = get_global_mouse_position() var mouse_position = self.owner.simulated_mouse_position # Calculate the direction vector from the ship to the mouse cursor var direction_to_mouse = (mouse_position - ship.global_position).normalized() # Calculate the target angle towards the mouse in radians var target_angle = direction_to_mouse.angle() # Get the current angle of the ship in radians var current_angle = ship.rotation # Calculate the shortest angle difference between the current angle and the target angle var angle_delta = wrapf(target_angle - current_angle, -PI, PI) # Calculate the slowdown factor based on how far the angle delta is var slowdown_factor = clamp(abs(angle_delta) / PI, 0.12, 1) # Calculate the desired angular velocity (radians per second) var desired_angular_velocity = slowdown_factor * sign(angle_delta) * angular_speed_rad # Smoothly interpolate the current angular velocity towards the desired angular velocity current_angular_velocity = lerp(current_angular_velocity, desired_angular_velocity, 0.1) # Clamp the angular velocity to the maximum angular velocity #current_angular_velocity = clamp(current_angular_velocity, -max_angular_velocity, max_angular_velocity) # Apply rotation based on the current angular velocity ship.angular_velocity = current_angular_velocity " [sub_resource type="GDScript" id="GDScript_j1l3h"] resource_name = "attacking_ai" script/source = "extends Node2D #var target : Node2D var desired_position # Position this AI wants to be in to fight optimally @onready var vision_cone_detector = self.owner.vision_cone_detector @onready var target = GameManager.player ## ONLY WORKS IF PLAYER IS THE ONLY POSSIBLE TARGET EVER @onready var type = self.owner.ai_type @onready var max_move_time : float = 20.0 var picked_move_time : float = 0.0 @onready var moves = { \"flyby\": { \"aggression_weight\": 0.7, # Aggressive AIs favor flyby for its offensive nature and speed. \"self_preservation_weight\": 0.2, # Less cautious, as flyby focuses on action rather than defense. \"stress_weight\": 0.4, # Moderate stress since the move can be risky or time-sensitive. \"surprise_weight\": 0.6, # High surprise, as a flyby can catch the opponent off guard. \"node_path\": $flyby, \"final_weight\": 0.0 }, \"snipe\": { \"aggression_weight\": 0.8, # High aggression, as the snipe is a focused, long-range attack. \"self_preservation_weight\": 0.3, # Slight self-preservation, but the focus is offensive. \"stress_weight\": 0.5, # High stress since the snipe requires precision and can lead to consequences if missed. \"surprise_weight\": 0.7, # High surprise, as sniping can be unexpected and difficult to defend against. \"node_path\": $snipe, \"final_weight\": 0.0 }, \"circle\": { \"aggression_weight\": 0.6, # Balanced aggression, as circling can set up more offensive strategies. \"self_preservation_weight\": 0.6, # Balanced between aggression and self-preservation, offering flexibility. \"stress_weight\": 0.3, # Moderate stress as circling is more about positioning and strategy. \"surprise_weight\": 0.4, # Moderate surprise, as circling is somewhat predictable once the pattern is established. \"node_path\": $circle, \"final_weight\": 0.0 }, \"juking\": { \"aggression_weight\": 0.3, # Low aggression, since juking is more about evasion than attacking. \"self_preservation_weight\": 0.8, # High self-preservation, as the focus is on dodging and avoiding damage. \"stress_weight\": 0.7, # High stress, as juking requires quick reactions and high pressure. \"surprise_weight\": 0.5, # Moderate surprise, as a well-executed juke can throw off the opponent. \"node_path\": $juking, \"final_weight\": 0.0 }, \"mirroring\": { \"aggression_weight\": 0.5, # Balanced aggression, as mirroring can follow up with an offensive move. \"self_preservation_weight\": 0.6, # Slightly more cautious, as mirroring is a reactionary move. \"stress_weight\": 0.6, # High stress, as mirroring requires timely responses and constant vigilance. \"surprise_weight\": 0.3, # Lower surprise, as the move is more about reading the opponent's actions. \"node_path\": $mirroring, \"final_weight\": 0.0 }, \"anti-mirroring\": { \"aggression_weight\": 0.9, # High aggression, as anti-mirroring is about disrupting the opponent’s rhythm. \"self_preservation_weight\": 0.4, # Less focus on self-preservation, as the move is more aggressive. \"stress_weight\": 0.8, # High stress due to the challenge of responding correctly and timing the counterattack. \"surprise_weight\": 0.8, # High surprise, as anti-mirroring can throw off the opponent by disrupting their patterns. \"node_path\": $antimirroring, \"final_weight\": 0.0 } } # decision making factors var stress : float var suprise : float @onready var aggression = AiManager.ai_parameters[type][\"aggression\"] var dmf = [stress, suprise] var picked_move func calculate_final_weights(): var total_weight = 0.0 # First pass: Calculate the weighted sums and store them in the moves dictionary for move_name in moves.keys(): var move = moves[move_name] var weighted_sum = move[\"aggression_weight\"] * aggression + move[\"stress_weight\"] * stress # + move[\"surprise_weight\"] * surprise move[\"final_weight\"] = weighted_sum total_weight += weighted_sum # Normalize the weights so that the total sums to 1.0 if total_weight > 0: for move_name in moves.keys(): #for move_name in final_weights.keys(): moves[move_name][\"final_weight\"] /= total_weight func get_new_action(d): # get new move if not target: # aquire target target = GameManager.player ## Update decision making factors stress = (owner.ship.health.shield.shield_hp / owner.ship.health.shield.shield_max_hp) * 0.75 if not owner.ship.health.shield.has_shield(): stress += 0.25 for i in dmf: # make sure 0= decision_f: break print(\"Im about to \" + picked_move) picked_move_time = max_move_time * moves[picked_move][\"final_weight\"] picked_move_time = max(3.0, picked_move_time) #print(picked_move_time) func debug_force_action(): picked_move = \"circle\" picked_move_time = 10.0 func brain_process(delta) -> void: picked_move_time -= delta if picked_move and moves[picked_move][\"node_path\"].completed: # if the action is done get a new move print(\"action completed\") picked_move_time = 0.0 moves[picked_move][\"node_path\"].acknowledge_marked_as_done() #debug_force_action() get_new_action(delta) if picked_move_time > 0.0: # if not out of time, don't pick a new action moves[picked_move][\"node_path\"].brain_process(delta) return # Action is finished below if picked_move and moves[picked_move][\"node_path\"].has_method(\"mark_done\"): moves[picked_move][\"node_path\"].action_time_over() # Pick new action then do it #debug_force_action() get_new_action(delta) moves[picked_move][\"node_path\"].brain_process(delta) func aim_at_target(): var aim_pos = target.global_position ## aim aim_pos better aim_pos -= self.owner.ship.linear_velocity * get_physics_process_delta_time() ## add offset based on aiming skill var offset = Vector2.ZERO offset.x = (randf() - 0.5) * 50 * (1-AiManager.ai_parameters[type][\"aiming_skill\"]) offset.y = (randf() - 0.5) * 50 * (1-AiManager.ai_parameters[type][\"aiming_skill\"]) #aim_pos += offset self.owner.simulated_mouse_position = aim_pos # debug crosshair $Sprite2D.visible = true $Sprite2D.global_position = aim_pos func move_to(desired_position: Vector2): self.owner.action_components.move.move_to_point(desired_position) func contains_attacking_cone() -> bool: for area in vision_cone_detector.get_overlapping_areas(): if area.name == \"attacking_cone\": return true # Return immediately if found return false # Return false if not found " [sub_resource type="GDScript" id="GDScript_i2v4l"] resource_name = "juking" script/source = "extends Node2D var completed : bool = false func mark_action_as_done(): completed = true func acknowledge_marked_as_done(): completed = false const desired_distance = 200 var new_dodge : bool @onready var dodge_direction = ((randi_range(0,1) * -2 + 1)) # This is either 1 or -1 var same_dodge_time = 0 # by -ve delta time var desired_position : Vector2 var dodging_position_difference : Vector2 var vector_to_target : Vector2 var target = Node func brain_process(delta) -> void: target = get_parent().target get_parent().aim_at_target() desired_position = target.global_position + (self.owner.ship.global_position - target.global_position).normalized() * desired_distance # Move to closest pt desired_distance units away from player var perpendicular_position #if get_parent().contains_attacking_cone(): # DODGING if true: same_dodge_time -= delta if same_dodge_time <= 0: # Change direction and reset time for next dodge dodge_direction = -dodge_direction same_dodge_time = randi_range(0.5, 2.5) vector_to_target = (target.global_position - self.owner.ship.global_position).normalized() * 50 dodging_position_difference = Vector2(-dodge_direction*vector_to_target.y, dodge_direction*vector_to_target.x) # Perpendicular #dodging_position_difference = dodging_position_difference.normalized() * 50 perpendicular_position = (self.owner.ship.global_position + dodging_position_difference) #desired_position = perpendicular_position #debug desired_position = vector_to(target.global_position, perpendicular_position).normalized() * desired_distance + target.global_position else: dodge_direction = ((randi_range(0,1) * -2 + 1)) # This is either 1 or -1 #$Sprite2D.global_position = perpendicular_position #$Sprite2D2.global_position = desired_position get_parent().move_to(desired_position) owner.want_to_fire_attacking_weapons = true func vector_to(from: Vector2, to: Vector2) -> Vector2: return to - from " [sub_resource type="GDScript" id="GDScript_2kj8r"] script/source = "extends Node2D # Stage 1 sideswipe # Stage 2 getaway # Removing this because other actions kind of do it already var completed : bool = false var target : Node2D @export var how_close : int = 100 @onready var side = ((randi_range(0,1) * -2 + 1)) # This is either 1 or -1 var vector_to_target : Vector2 var dodging_position_difference : Vector2 var desired_position : Vector2 var initial_target_rotation : float var initiation_point : Vector2 #var stage1_complete : bool = false #@export var stage2_timer : float = 0.5 func mark_action_as_done(): completed = true func acknowledge_marked_as_done(): side = (randi_range(0,1) * -2 + 1) # 1 or -1 #stage1_complete = false #stage2_timer = 0.5 completed = false func brain_process(_delta): #print(\"flyby\") target = get_parent().target get_parent().aim_at_target() if not desired_position: # finding point to sideswipe vector_to_target = (target.global_position - self.owner.ship.global_position).normalized() * 50 dodging_position_difference = Vector2(-side*vector_to_target.y, side*vector_to_target.x).normalized() * how_close # Perpendicular desired_position = target.global_position + dodging_position_difference initial_target_rotation = target.rotation initiation_point = self.owner.ship.global_position else: # if sideswipe point is known, adjust it for new positions and do it desired_position = target.global_position + dodging_position_difference#.rotated(target.rotation - initial_target_rotation) if desired_position and has_passed_destination(initiation_point, desired_position, self.owner.ship.global_position): # Follow tangent for a bit before finishing? maybe add this later print(\"BAZINGA\") mark_action_as_done() get_parent().move_to(desired_position) #$Sprite2D.global_position = desired_position func has_passed_destination(original_point: Vector2, destination_point: Vector2, current_position: Vector2) -> bool: # Calculate the direction from the original point to the destination point var direction = (destination_point - original_point).normalized() # Check if the current position has passed the destination point by comparing the dot product var original_to_current = current_position - original_point var original_to_destination = destination_point - original_point # If the dot product between the direction and the vectors from original to current and original to destination # is negative, that means we've passed the destination. return original_to_current.dot(original_to_destination) > 0 " [sub_resource type="GDScript" id="GDScript_ddvim"] script/source = "extends Node2D var completed : bool = false func mark_action_as_done(): completed = true func acknowledge_marked_as_done(): completed = false const max_range : int = 250 const min_range : int = 150 const position_randomness : int = 25 const min_dodge_time = 0.4 const max_dodge_time = 0.8 var current_dodge_time = 0 # by -ve delta time var desired_position : Vector2 var dodging_position_difference : Vector2 var vector_to_target : Vector2 var target = Node func brain_process(delta) -> void: target = get_parent().target get_parent().aim_at_target() current_dodge_time -= delta if current_dodge_time < 0: vector_to_target = (target.global_position - self.owner.ship.global_position) # get the distance right if min_range < vector_to_target.length() and vector_to_target.length() < max_range: desired_position = self.owner.ship.global_position else: #desired_position = self.owner.ship.global_position + vector_to_target.normalized() * bell_curve_random_int(min_range, max_range) desired_position = target.global_position - vector_to_target.normalized() * bell_curve_random_int(min_range, max_range) # add a bit off offset desired_position.x + randi_range(-position_randomness, position_randomness) desired_position.y + randi_range(-position_randomness, position_randomness) current_dodge_time = randf_range(min_dodge_time, max_dodge_time) $Sprite2D.visible = true $Sprite2D.global_position = desired_position get_parent().move_to(desired_position) owner.want_to_fire_attacking_weapons = true func vector_to(from: Vector2, to: Vector2) -> Vector2: return to - from func has_passed_destination(original_point: Vector2, destination_point: Vector2, current_position: Vector2) -> bool: # Calculate the direction from the original point to the destination point var direction = (destination_point - original_point).normalized() # Check if the current position has passed the destination point by comparing the dot product var original_to_current = current_position - original_point var original_to_destination = destination_point - original_point # If the dot product between the direction and the vectors from original to current and original to destination # is negative, that means we've passed the destination. return original_to_current.dot(original_to_destination) > 0 func bell_curve_random_int(min: int, max: int) -> int: # Calculate the mean and approximate standard deviation var mean = (min + max) / 2.0 var stddev = (max - min) / 6.0 # Approximation: 99.7% of values fall within ±3 stddev # Generate a random value using a simple approximation var total = 0.0 var samples = 3 # More samples increase bell curve smoothness for i in range(samples): total += randf_range(-1, 1) # Scale the result to match the desired range var z = total / samples # Averages out to approximate a normal distribution var result = mean + z * stddev # Clamp to ensure the value stays within bounds return clamp(int(round(result)), min, max) " [sub_resource type="PlaceholderTexture2D" id="PlaceholderTexture2D_a1o4t"] size = Vector2(10, 10) [sub_resource type="GDScript" id="GDScript_6rqi6"] resource_name = "circle" script/source = "extends Node2D var completed : bool = false func mark_action_as_done(): completed = true func acknowledge_marked_as_done(): completed = false func action_time_over(): var dodge_direction = ((randi_range(0,1) * -2 + 1)) # This is either 1 or -1 const desired_distance = 200 var new_dodge : bool @onready var dodge_direction = ((randi_range(0,1) * -2 + 1)) # This is either 1 or -1 var desired_position : Vector2 var dodging_position_difference : Vector2 var vector_to_target : Vector2 var target = Node func brain_process(delta) -> void: target = get_parent().target get_parent().aim_at_target() desired_position = target.global_position + (self.owner.ship.global_position - target.global_position).normalized() * desired_distance # Move to closest pt desired_distance units away from player var perpendicular_position vector_to_target = (target.global_position - self.owner.ship.global_position).normalized() * 50 dodging_position_difference = Vector2(-dodge_direction*vector_to_target.y, dodge_direction*vector_to_target.x) # Perpendicular #dodging_position_difference = dodging_position_difference.normalized() * 50 perpendicular_position = (self.owner.ship.global_position + dodging_position_difference) #desired_position = perpendicular_position #debug desired_position = vector_to(target.global_position, perpendicular_position).normalized() * desired_distance + target.global_position #$Sprite2D.global_position = perpendicular_position #$Sprite2D2.global_position = desired_position get_parent().move_to(desired_position) owner.want_to_fire_attacking_weapons = true func vector_to(from: Vector2, to: Vector2) -> Vector2: return to - from " [sub_resource type="GDScript" id="GDScript_3whgw"] resource_name = "mirroring" script/source = "extends Node2D var completed : bool = false func mark_action_as_done(): completed = true func acknowledge_marked_as_done(): completed = false const desired_distance = 200 var new_dodge : bool var dodge_direction = -1 # 1 or -1 only var same_dodge_time = 0 # by -ve delta time var desired_position : Vector2 var dodging_position_difference : Vector2 var vector_to_target : Vector2 var target = Node func brain_process(delta) -> void: target = get_parent().target get_parent().aim_at_target() desired_position = target.global_position + (self.owner.ship.global_position - target.global_position).normalized() * desired_distance # Move to closest point desired_distance units away from player var perpendicular_position #if get_parent().contains_attacking_cone(): # DODGING if true: same_dodge_time -= delta if same_dodge_time <= 0: # Change direction and reset time for next dodge dodge_direction = -dodge_direction same_dodge_time = randi_range(0.5, 2.5) # Calculate vector pointing from ship to target vector_to_target = (target.global_position - self.owner.ship.global_position).normalized() * 50 # Calculate vector perpendicular to the vector_to_target using cross product # 2D cross product of A (target-to-ship vector) and B (perpendicular vector) var cross_product_result = vector_to_target.x * dodge_direction - vector_to_target.y * 0 # This is simply A x B (Z-component of the cross product) # Perpendicular to target-to-ship vector (clockwise or counterclockwise based on cross product result) if cross_product_result > 0: # Counter-clockwise direction (dodge left) dodging_position_difference = Vector2(-vector_to_target.y, vector_to_target.x) else: # Clockwise direction (dodge right) dodging_position_difference = Vector2(vector_to_target.y, -vector_to_target.x) # Now use dodging_position_difference for movement perpendicular_position = self.owner.ship.global_position + dodging_position_difference # Recalculate the desired position to dodge towards desired_position = vector_to(target.global_position, perpendicular_position).normalized() * desired_distance + target.global_position else: dodge_direction = ((randi_range(0,1) * -2 + 1)) # This is either 1 or -1 #$Sprite2D.global_position = perpendicular_position #$Sprite2D2.global_position = desired_position get_parent().move_to(desired_position) owner.want_to_fire_attacking_weapons = true func vector_to(from: Vector2, to: Vector2) -> Vector2: return to - from " [sub_resource type="GDScript" id="GDScript_7loqq"] resource_name = "anti-mirroring" script/source = "extends Node2D var completed : bool = false func mark_action_as_done(): completed = true func acknowledge_marked_as_done(): completed = false const desired_distance = 200 var new_dodge : bool var dodge_direction = -1 # 1 or -1 only var same_dodge_time = 0 # by -ve delta time var desired_position : Vector2 var dodging_position_difference : Vector2 var vector_to_target : Vector2 var target = Node func brain_process(delta) -> void: target = get_parent().target get_parent().aim_at_target() desired_position = target.global_position + (self.owner.ship.global_position - target.global_position).normalized() * desired_distance # Move to closest point desired_distance units away from player var perpendicular_position #if get_parent().contains_attacking_cone(): # DODGING if true: same_dodge_time -= delta if same_dodge_time <= 0: # Change direction and reset time for next dodge dodge_direction = -dodge_direction same_dodge_time = randi_range(0.5, 2.5) # Calculate vector pointing from ship to target vector_to_target = (target.global_position - self.owner.ship.global_position).normalized() * 50 # Calculate vector perpendicular to the vector_to_target using cross product # 2D cross product of A (target-to-ship vector) and B (perpendicular vector) var cross_product_result = vector_to_target.x * dodge_direction - vector_to_target.y * 0 # This is simply A x B (Z-component of the cross product) # Perpendicular to target-to-ship vector (clockwise or counterclockwise based on cross product result) if not cross_product_result > 0: # Counter-clockwise direction (dodge left) dodging_position_difference = Vector2(-vector_to_target.y, vector_to_target.x) else: # Clockwise direction (dodge right) dodging_position_difference = Vector2(vector_to_target.y, -vector_to_target.x) # Now use dodging_position_difference for movement perpendicular_position = self.owner.ship.global_position + dodging_position_difference # Recalculate the desired position to dodge towards desired_position = vector_to(target.global_position, perpendicular_position).normalized() * desired_distance + target.global_position else: dodge_direction = ((randi_range(0,1) * -2 + 1)) # This is either 1 or -1 #$Sprite2D.global_position = perpendicular_position #$Sprite2D2.global_position = desired_position get_parent().move_to(desired_position) owner.want_to_fire_attacking_weapons = true func vector_to(from: Vector2, to: Vector2) -> Vector2: return to - from " [sub_resource type="GDScript" id="GDScript_khvd3"] script/source = "extends Node2D #var target # The ship this AI is attacking var desired_position # Position this AI wants to be in to fight optimally @onready var vision_cone_detector = self.owner.vision_cone_detector var desired_distance = 170 var new_dodge : bool var dodge_direction = -1 # 1 or -1 only var dodging_position_difference var vector_to_target var same_dodge_time = 0 # by -ve delta time @onready var target = GameManager.player ## ONLY WORKS IF PLAYER IS ONLY ENEMY func brain_process(delta) -> void: if target == null: target = GameManager.player owner.simulated_mouse_position = target.global_position desired_position = target.global_position + (self.owner.ship.global_position - target.global_position).normalized() * desired_distance # Move to closest pt desired_distance units away from player if contains_attacking_cone(): # DODGING same_dodge_time -= delta if same_dodge_time <= 0: # Change direction and reset time for next dodge dodge_direction = -dodge_direction same_dodge_time = randi_range(0.5, 2.5) vector_to_target = (target.global_position - self.owner.ship.global_position) dodging_position_difference = Vector2(-dodge_direction*vector_to_target.y, dodge_direction*vector_to_target.x) # Perpendicular #dodging_position_difference=Vector2(dodging_position_difference + vector_to_target/(PI/2)).normalized()*desired_distance # Add slight offset towards target dodging_position_difference=Vector2(dodging_position_difference + vector_to_target/(2.8)).normalized()*desired_distance # Add slight offset towards target desired_position = self.owner.ship.global_position + dodging_position_difference else: dodge_direction = ((randi_range(0,1) * -2 + 1)) # This is either 1 or -1 #$Sprite2D.global_position = desired_position #$Sprite2D2.global_position = dodging_position_difference #print(desired_position) self.owner.action_components.move.move_to_point(desired_position) owner.want_to_fire_attacking_weapons = true func contains_attacking_cone() -> bool: for area in vision_cone_detector.get_overlapping_areas(): if area.name == \"attacking_cone\": return true # Return immediately if found return false # Return false if not found " [sub_resource type="GDScript" id="GDScript_7v7vb"] resource_name = "wandering_ai_state" script/source = "extends Node2D func brain_process(_delta) -> void: pass #owner.want_to_fire_attacking_weapons = false #self.owner.action_components.move.move_to_point(Vector2.ZERO) " [sub_resource type="GDScript" id="GDScript_2w8n3"] script/source = "extends Node2D func brain_process(_delta) -> void: pass #print(\"IDLE\") #self.owner.owner.add_constant_torque(10) " [sub_resource type="GDScript" id="GDScript_onngt"] resource_name = "mining" script/source = "extends Node2D func brain_process(_delta) -> void: pass #print(\"Mining\") #self.owner.owner.add_constant_torque(10) " [sub_resource type="GDScript" id="GDScript_w6w8o"] resource_name = "looting" script/source = "extends Node2D func brain_process(_delta) -> void: pass print(\"Looting\") #self.owner.owner.add_constant_torque(10) " [node name="ai_controller" type="Node2D" node_paths=PackedStringArray("action_components", "vision_cone_detector", "vision_area")] script = SubResource("GDScript_va0u0") ai_type = 7 action_components = NodePath("state_machine/action_components") vision_cone_detector = NodePath("Vision_cone_detector") vision_area = NodePath("Vision_area") [node name="Vision_cone_detector" type="Area2D" parent="."] [node name="CollisionShape2D" type="CollisionShape2D" parent="Vision_cone_detector"] shape = SubResource("CircleShape2D_vexfc") [node name="Vision_area" type="Area2D" parent="."] [node name="CollisionPolygon2D" type="CollisionPolygon2D" parent="Vision_area"] modulate = Color(0, 1, 1, 0.282353) polygon = PackedVector2Array(0, 0, 254, 155, 254, -155) [node name="CollisionShape2D" type="CollisionShape2D" parent="Vision_area"] shape = SubResource("CircleShape2D_humqr") [node name="state_machine" type="Node2D" parent="."] script = SubResource("GDScript_kp1mh") [node name="vision" type="Node" parent="state_machine"] script = SubResource("GDScript_y2pbm") [node name="action_components" type="Node" parent="state_machine" node_paths=PackedStringArray("look", "move")] script = SubResource("GDScript_8fu8m") look = NodePath("look") move = NodePath("basic_movement") [node name="look" type="Node2D" parent="state_machine/action_components"] script = SubResource("GDScript_uxcfm") angular_speed = 750.0 [node name="basic_movement" parent="state_machine/action_components" instance=ExtResource("1_x6p55")] [node name="state_brains" type="Node" parent="state_machine"] [node name="attacking" type="Node2D" parent="state_machine/state_brains"] script = SubResource("GDScript_j1l3h") [node name="juking" type="Node2D" parent="state_machine/state_brains/attacking"] script = SubResource("GDScript_i2v4l") [node name="flyby" type="Node2D" parent="state_machine/state_brains/attacking"] script = SubResource("GDScript_2kj8r") how_close = 50 [node name="snipe" type="Node2D" parent="state_machine/state_brains/attacking"] script = SubResource("GDScript_ddvim") [node name="Sprite2D" type="Sprite2D" parent="state_machine/state_brains/attacking/snipe"] visible = false texture = SubResource("PlaceholderTexture2D_a1o4t") [node name="circle" type="Node2D" parent="state_machine/state_brains/attacking"] script = SubResource("GDScript_6rqi6") [node name="mirroring" type="Node2D" parent="state_machine/state_brains/attacking"] script = SubResource("GDScript_3whgw") [node name="antimirroring" type="Node2D" parent="state_machine/state_brains/attacking"] script = SubResource("GDScript_7loqq") [node name="Sprite2D" type="Sprite2D" parent="state_machine/state_brains/attacking"] visible = false texture = ExtResource("1_8f2jx") [node name="attacking3" type="Node2D" parent="state_machine/state_brains"] script = SubResource("GDScript_khvd3") [node name="wandering" type="Node2D" parent="state_machine/state_brains"] script = SubResource("GDScript_7v7vb") [node name="idle" type="Node2D" parent="state_machine/state_brains"] script = SubResource("GDScript_2w8n3") [node name="mining" type="Node2D" parent="state_machine/state_brains"] script = SubResource("GDScript_onngt") [node name="looting" type="Node2D" parent="state_machine/state_brains"] script = SubResource("GDScript_w6w8o") [node name="memory" type="Node" parent="state_machine"] [connection signal="area_entered" from="Vision_area" to="state_machine/vision" method="_on_vision_area_area_entered"] [connection signal="body_entered" from="Vision_area" to="state_machine/vision" method="_on_vision_area_body_entered"] [connection signal="body_exited" from="Vision_area" to="state_machine/vision" method="_on_vision_area_body_exited"] [connection signal="surroundings_changed" from="state_machine/vision" to="state_machine" method="_on_vision_surroundings_changed"]