249 lines
7.9 KiB
GDScript
249 lines
7.9 KiB
GDScript
extends RigidBody
|
|
|
|
const TIME_STEP : float = 0.01
|
|
const BASE_DPS : float = 300.0
|
|
const BASE_ENERGY_USAGE : float = 75.0
|
|
const BASE_ENERGY_REGEN : float = 150.0
|
|
const BASE_OVERCHARGE_DAMAGE : float = 5.0
|
|
const OOB_DAMAGE : float = 100.0
|
|
|
|
var id: int = 0
|
|
|
|
var thrust_plan : Plan = Plan.new()
|
|
var weapons_plan : Plan = Plan.new()
|
|
|
|
var is_ready : bool = false
|
|
var running_plan : bool = false
|
|
var was_running_plan : bool = false
|
|
var using_full_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 has_died : bool = false
|
|
var is_zombie : bool = false
|
|
|
|
var turn_number : int = 0
|
|
|
|
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
|
|
|
|
var end_translation : Vector3 = Vector3.ZERO
|
|
var end_rotation : Vector3 = Vector3.ZERO
|
|
var end_linear_velocity : Vector3 = Vector3.ZERO
|
|
var end_rotational_velocity : Vector3 = Vector3.ZERO
|
|
var end_health : float = 100.0
|
|
var end_energy : float = 100.0
|
|
var energy : float = 100.0
|
|
|
|
var players_in_firing_arc = []
|
|
|
|
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) + ".")
|
|
end_translation = self.translation
|
|
end_rotation = self.rotation
|
|
end_linear_velocity = self.linear_velocity
|
|
end_rotational_velocity = self.angular_velocity
|
|
end_health = self.health
|
|
end_energy = self.energy
|
|
get_parent().get_parent().console_print("Starting parameters are: linear velocity = " + String(end_linear_velocity) + ", rotational_velocity = " + String(end_rotational_velocity) + ", position = " + String(end_translation) + ", rotation = " + String(end_rotation))
|
|
rpc("r_end_turn", time_of_death, end_translation, end_rotation, end_linear_velocity, end_rotational_velocity, end_health, end_energy)
|
|
turn_number += 1
|
|
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 = []
|
|
for element in thrust_plan.elements:
|
|
all_elements.append(element)
|
|
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
|
|
was_running_plan = false
|
|
return
|
|
|
|
if !was_running_plan:
|
|
players_in_firing_arc = $GunContainer/Cone.get_overlapping_bodies()
|
|
if using_full_plan:
|
|
set_linear_velocity(initial_velocity)
|
|
set_angular_velocity(initial_rotational_velocity)
|
|
set_translation(initial_translation)
|
|
set_rotation(initial_rotation)
|
|
else:
|
|
set_linear_velocity(end_linear_velocity)
|
|
set_angular_velocity(end_rotational_velocity)
|
|
set_translation(end_translation)
|
|
set_rotation(end_rotation)
|
|
was_running_plan = true
|
|
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)
|
|
elif energy < 100:
|
|
energy += BASE_ENERGY_REGEN * delta
|
|
|
|
calculate_other_damage(delta, plan_time)
|
|
|
|
|
|
plan_time += delta
|
|
|
|
func fire(delta : float, time : float) -> void:
|
|
var closest_enemy = null
|
|
var distance_of_closest = -1
|
|
for player in players_in_firing_arc:
|
|
if player.id == id or !player.is_alive:
|
|
continue
|
|
var player_distance : float = (player.translation - translation).length()
|
|
if distance_of_closest == -1 or player_distance < distance_of_closest:
|
|
closest_enemy = player
|
|
distance_of_closest = player_distance
|
|
|
|
energy -= delta * BASE_ENERGY_USAGE
|
|
if closest_enemy != null:
|
|
closest_enemy.take_damage(BASE_DPS * delta, time)
|
|
|
|
func take_damage(damage : float, time : float) -> void:
|
|
health -= damage
|
|
if health < 0 and is_alive:
|
|
self.die(time)
|
|
|
|
func die(time : float) -> void:
|
|
is_alive = false
|
|
$GunContainer/Cone.monitoring = false
|
|
if !has_died:
|
|
if report_death_to_arena():
|
|
finish_game()
|
|
has_died = true
|
|
$CollisionShape.disabled = true
|
|
time_of_death = time
|
|
|
|
func play_all_plans():
|
|
get_parent().play_full_plans()
|
|
|
|
func play_full_plan():
|
|
using_full_plan = true
|
|
running_plan = true
|
|
plan_time = 0.0
|
|
is_alive = true
|
|
$GunContainer/Cone.monitoring = true
|
|
$CollisionShape.disabled = false
|
|
|
|
func play_last_plan():
|
|
using_full_plan = false
|
|
running_plan = true
|
|
plan_time = 5 * turn_number
|
|
if !has_died:
|
|
is_alive = true
|
|
$GunContainer/Cone.monitoring = true
|
|
$CollisionShape.disabled = false
|
|
|
|
func calculate_plans():
|
|
if is_zombie:
|
|
create_zombie_plan()
|
|
if turn_number == 0:
|
|
play_full_plan()
|
|
else:
|
|
play_last_plan()
|
|
waiting_for_completion = true
|
|
|
|
func calculate_other_damage(delta : float, time : float):
|
|
if (translation.length_squared() > 100):
|
|
take_damage(OOB_DAMAGE * delta, time)
|
|
if energy < 0:
|
|
take_damage(-energy * BASE_OVERCHARGE_DAMAGE * delta, time)
|
|
|
|
func report_death_to_arena() -> bool:
|
|
return get_parent().register_death()
|
|
|
|
func finish_game() -> void:
|
|
get_parent().finish_game()
|
|
|
|
func _on_player_enter_firing_arc(body):
|
|
players_in_firing_arc.append(body)
|
|
|
|
func _on_player_exit_firing_arc(body):
|
|
players_in_firing_arc.erase(body)
|
|
|
|
func create_zombie_plan() -> void:
|
|
add_thrust_element(5, Vector3.ZERO, Vector3.ZERO)
|
|
add_weapons_element(5, false)
|