149 lines
4.8 KiB
GDScript
149 lines
4.8 KiB
GDScript
extends RigidBody
|
|
|
|
const TIME_STEP : float = 0.01
|
|
const BASE_DPS : float = 300.0
|
|
|
|
var thrust_plan : Plan = Plan.new()
|
|
var weapons_plan : Plan = Plan.new()
|
|
|
|
var is_ready : bool = false
|
|
var running_plan : bool = false
|
|
var plan_time : float = 0.0
|
|
|
|
var health : float = 100.0
|
|
var is_alive : bool = true
|
|
var time_of_death : float = -1
|
|
|
|
var initial_translation : Vector3 = get_translation()
|
|
var initial_rotation : Vector3 = get_rotation()
|
|
var initial_velocity : Vector3 = Vector3(0,0,0)
|
|
var initial_rotational_velocity : Vector3 = Vector3(0,0,0)
|
|
var last_translation : Vector3 = get_translation()
|
|
var last_rotation : Vector3 = get_rotation()
|
|
var enable_physics : bool = false
|
|
var waiting_for_completion : bool = false
|
|
|
|
func init():
|
|
last_rotation = get_rotation()
|
|
last_translation = get_translation()
|
|
initial_rotation = get_rotation()
|
|
initial_translation = get_translation()
|
|
enable_physics = true
|
|
health = 100
|
|
|
|
remote func add_thrust_element(time: float, linear_thrust : Vector3, rotational_thrust : Vector3) -> void:
|
|
var element : ThrustElement = ThrustElement.new()
|
|
element.time = time
|
|
element.linear_thrust = linear_thrust
|
|
element.rotational_thrust = rotational_thrust
|
|
get_parent().get_parent().console_print("Adding thrust element with the following params: time = " + String(time) + ", lin = " + String(linear_thrust) + ", rot = " + String(rotational_thrust) + ".")
|
|
thrust_plan.add_element(element)
|
|
|
|
remote func add_weapons_element(time: float, firing: bool) -> void:
|
|
var element : WeaponsElement = WeaponsElement.new()
|
|
element.time = time
|
|
element.firing = firing
|
|
get_parent().get_parent().console_print("Adding weapons element with the following params: time = " + String(time) + ", firing = "+ String(firing))
|
|
weapons_plan.add_element(element)
|
|
|
|
func send_all_plans() -> void:
|
|
get_parent().get_parent().console_print("Sending plan...")
|
|
for element in thrust_plan.current_elements:
|
|
rpc("add_thrust_element", element.time, element.linear_thrust, element.rotational_thrust)
|
|
for element in weapons_plan.current_elements:
|
|
rpc("add_weapons_element", element.time, element.firing)
|
|
get_parent().get_parent().console_print("Time of death is " + String(time_of_death) + " with health " + String(health) + ".")
|
|
rpc("r_end_turn", time_of_death)
|
|
thrust_plan.new_turn()
|
|
weapons_plan.new_turn()
|
|
|
|
remote func end_turn() -> void:
|
|
get_parent().get_parent().console_print("Setting ready status to true...")
|
|
is_ready = true
|
|
|
|
func _get_current_plan_element(all_elements) -> PlanElement:
|
|
var summed_time : float = 0.0
|
|
for element in all_elements:
|
|
summed_time += element.time
|
|
if summed_time > plan_time:
|
|
return element
|
|
return null
|
|
|
|
func _get_all_thrust_elements():
|
|
var all_elements = []
|
|
all_elements = thrust_plan.elements
|
|
for element in thrust_plan.current_elements:
|
|
all_elements.append(element)
|
|
return all_elements
|
|
|
|
func _get_all_weapons_elements():
|
|
var all_elements = []
|
|
for element in weapons_plan.elements:
|
|
all_elements.append(element)
|
|
for element in weapons_plan.current_elements:
|
|
all_elements.append(element)
|
|
return all_elements
|
|
|
|
func _physics_process(delta : float) -> void:
|
|
if !enable_physics:
|
|
return
|
|
if !running_plan:
|
|
if waiting_for_completion:
|
|
send_all_plans()
|
|
waiting_for_completion = false
|
|
translation = last_translation
|
|
rotation = last_rotation
|
|
return
|
|
var all_thrust_elements = _get_all_thrust_elements()
|
|
var current_thrust_element : ThrustElement = _get_current_plan_element(all_thrust_elements)
|
|
if current_thrust_element == null:
|
|
last_translation = translation
|
|
last_rotation = rotation
|
|
running_plan = false
|
|
return
|
|
add_central_force(self.transform.basis.xform(current_thrust_element.linear_thrust))
|
|
add_torque(self.transform.basis.xform(current_thrust_element.rotational_thrust))
|
|
|
|
var all_weapons_elements = _get_all_weapons_elements()
|
|
var current_weapons_element : WeaponsElement = _get_current_plan_element(all_weapons_elements)
|
|
if current_weapons_element == null:
|
|
running_plan = false
|
|
return
|
|
if current_weapons_element.firing and is_alive:
|
|
fire(delta, plan_time)
|
|
|
|
plan_time += delta
|
|
|
|
func fire(delta : float, time : float) -> void:
|
|
if $GunContainer/RayCast.is_colliding():
|
|
var target : RigidBody = $GunContainer/RayCast.get_collider()
|
|
target.take_damage(BASE_DPS * delta, time)
|
|
|
|
func take_damage(damage : float, time : float) -> void:
|
|
get_parent().get_parent().console_print("tmp")
|
|
health -= damage
|
|
if health < 0:
|
|
self.die(time)
|
|
|
|
func die(time : float) -> void:
|
|
is_alive = false
|
|
$CollisionShape.disabled = true
|
|
time_of_death = time
|
|
|
|
func play_all_plans():
|
|
get_parent().play_full_plans()
|
|
|
|
func play_full_plan():
|
|
set_linear_velocity(initial_velocity)
|
|
set_angular_velocity(initial_rotational_velocity)
|
|
set_translation(initial_translation)
|
|
set_rotation(initial_rotation)
|
|
running_plan = true
|
|
plan_time = 0.0
|
|
is_alive = true
|
|
$CollisionShape.disabled = false
|
|
|
|
func calculate_plans():
|
|
play_full_plan()
|
|
waiting_for_completion = true
|