660 lines
22 KiB
GDScript
660 lines
22 KiB
GDScript
extends AIScriptModule
|
|
|
|
const garments_female_lingerie = ["female-panties1", "female-bra1"]
|
|
const garments_head_female = []
|
|
const garments_male_lingerie = ["male-panties1"]
|
|
const garments_head_male = []
|
|
const garments_female_main = ["female-shirt_skirt1"]
|
|
const garments_male_main = ["male-pants1", "male-shoes1"]
|
|
const basedir = "res://scenes/clothes/"
|
|
const material_female = preload("res://scenes/clothes/nun-clothes.material")
|
|
const material_male = preload("res://scenes/clothes/clothes-male.material")
|
|
|
|
const attack_distance = 2.0
|
|
const guard_distance = 2.0
|
|
const engage_distance = 10.0
|
|
const flee_distance = 5.0
|
|
|
|
const init_blackboard = {
|
|
"stamina": 100.0,
|
|
"health": 100.0,
|
|
"melee_weapon_equipped": false,
|
|
"attack_cooldown": 0.0,
|
|
"guard_cooldown": 0.0,
|
|
"flee_cooldown": 0.0,
|
|
"guard": false,
|
|
"melee_damage": false,
|
|
"dot": 0.0
|
|
}
|
|
|
|
class AITreeBuilder:
|
|
var parent
|
|
func seq(a: Array):
|
|
var e = AITreeBuilder.new()
|
|
e.parent = self
|
|
return e
|
|
|
|
func look_at(tick, ch):
|
|
var root = get_character(tick)
|
|
var current = root.global_transform
|
|
var at = ch.global_transform.origin
|
|
at.y = current.origin.y
|
|
root.global_transform = current.looking_at(at, Vector3.UP)
|
|
|
|
func combat_event(ev, data, blackboard):
|
|
var root = blackboard.self
|
|
var cam = root.get_viewport().get_camera()
|
|
var player
|
|
if cam:
|
|
player = cam.get_meta("player")
|
|
assert(player)
|
|
match ev:
|
|
"about_to_attack":
|
|
var who = data[0]
|
|
if who != root:
|
|
var where = who.global_transform.origin
|
|
var curpos = root.global_transform.origin
|
|
var dst = where.distance_squared_to(curpos)
|
|
if dst < guard_distance * guard_distance:
|
|
if who == player:
|
|
blackboard["guard"] = true
|
|
# blackboard_set(tick, "melee_damage", true)
|
|
"damage":
|
|
var who = data[0]
|
|
var weapon = data[1]
|
|
if who != root:
|
|
var where = who.global_transform.origin
|
|
var curpos = root.global_transform.origin
|
|
var dst = where.distance_squared_to(curpos)
|
|
if dst < attack_distance * attack_distance:
|
|
if who == player:
|
|
blackboard["melee_damage"] = true
|
|
# blackboard_set(tick, "melee_damage", true)
|
|
|
|
class take_weapon extends AIScriptModule:
|
|
func init(tick):
|
|
get_memory(tick).root = get_character(tick)
|
|
get_memory(tick).skel = get_memory(tick).root.get_meta("skeleton")
|
|
func update_physics(tick, delta):
|
|
var root = get_memory(tick).root
|
|
assert(root)
|
|
if blackboard_get(tick, "melee_weapon_equipped"):
|
|
return FAILED
|
|
var wslot = get_memory(tick).skel.get_node("wrist_r/weapon_right")
|
|
wslot.set_meta("owner", root)
|
|
inventory.equip(wslot, get_memory(tick).weapon)
|
|
blackboard_set(tick, "melee_weapon_equipped", true)
|
|
assert(blackboard_get(tick, "melee_weapon_equipped"))
|
|
return OK
|
|
func stop(tick):
|
|
# can't re-run this one
|
|
var root = get_memory(tick).root
|
|
assert(root)
|
|
|
|
class guard extends AIScriptModule:
|
|
func init(tick):
|
|
get_memory(tick).root = get_character(tick)
|
|
get_memory(tick).state = 0
|
|
func update_physics(tick, delta):
|
|
var root = get_memory(tick).root
|
|
assert(root)
|
|
if blackboard_get(tick, "guard_cooldown") > 0:
|
|
return FAILED
|
|
if blackboard_get(tick, "guard"):
|
|
blackboard_set(tick, "guard", false)
|
|
match get_memory(tick).state:
|
|
0:
|
|
# guard
|
|
var anim
|
|
if blackboard_get(tick, "dot") < 0:
|
|
anim = get_memory(tick).anim1
|
|
else:
|
|
anim = get_memory(tick).anim2
|
|
characters.animation_node_travel(root, anim)
|
|
get_memory(tick).state = 1
|
|
return ERR_BUSY
|
|
1:
|
|
get_memory(tick).state = 2
|
|
return ERR_BUSY
|
|
2:
|
|
blackboard_set(tick, "guard_cooldown", 1.5)
|
|
return OK
|
|
return OK
|
|
func stop(tick):
|
|
get_memory(tick).state = 0
|
|
class rest extends AIScriptModule:
|
|
func init(tick):
|
|
get_memory(tick).root = get_character(tick)
|
|
func update_physics(tick, delta):
|
|
var root = get_memory(tick).root
|
|
assert(root)
|
|
if blackboard_get(tick, "stamina") < 100.0:
|
|
blackboard_set(tick, "stamina", blackboard_get(tick, "stamina") + 15500.0 * delta)
|
|
return ERR_BUSY
|
|
else:
|
|
return OK
|
|
func stop(tock):
|
|
pass
|
|
class idle extends AIScriptModule:
|
|
func init(tick):
|
|
get_memory(tick).root = get_character(tick)
|
|
func update_physics(tick, delta):
|
|
var root = get_memory(tick).root
|
|
assert(root)
|
|
if blackboard_get(tick, "stamina") < 100.0:
|
|
blackboard_set(tick, "stamina", blackboard_get(tick, "stamina") + 0.5 * delta)
|
|
return ERR_BUSY
|
|
else:
|
|
return OK
|
|
func stop(tock):
|
|
pass
|
|
|
|
|
|
class unconcious extends AIScriptModule:
|
|
func init(tick):
|
|
get_memory(tick).root = get_character(tick)
|
|
get_memory(tick).state = 0
|
|
|
|
func update_physics(tick, delta):
|
|
var root = get_memory(tick).root
|
|
var anim1 = get_memory(tick).anim1
|
|
var anim2 = get_memory(tick).anim2
|
|
assert(root)
|
|
assert(anim1)
|
|
assert(anim2)
|
|
match get_memory(tick).state:
|
|
0:
|
|
characters.animation_node_travel(root, anim1)
|
|
get_memory(tick).state = 1
|
|
return ERR_BUSY
|
|
return ERR_BUSY
|
|
func stop(tick):
|
|
pass
|
|
|
|
class get_damage extends AIScriptModule:
|
|
func init(tick):
|
|
get_memory(tick).root = get_character(tick)
|
|
get_memory(tick).state = 0
|
|
|
|
func update_physics(tick, delta):
|
|
var root = get_memory(tick).root
|
|
var anim1 = get_memory(tick).anim1
|
|
var anim2 = get_memory(tick).anim2
|
|
var cost = get_memory(tick).cost
|
|
assert(root)
|
|
if blackboard_get(tick, "guard_cooldown") > 0:
|
|
return FAILED
|
|
if blackboard_get(tick, "melee_damage"):
|
|
blackboard_set(tick, "melee_damage", false)
|
|
match get_memory(tick).state:
|
|
0:
|
|
# guard
|
|
var anim
|
|
if blackboard_get(tick, "dot") < 0:
|
|
anim = get_memory(tick).anim1
|
|
else:
|
|
anim = get_memory(tick).anim2
|
|
characters.animation_node_travel(root, anim)
|
|
if blackboard_get(tick, "stamina") > 50.0:
|
|
blackboard_set(tick, "health", blackboard_get(tick, "health") - cost)
|
|
else:
|
|
blackboard_set(tick, "health", blackboard_get(tick, "health") - 5.0 * cost)
|
|
blackboard_set(tick, "stamina", 5.0)
|
|
get_memory(tick).state = 1
|
|
return ERR_BUSY
|
|
1:
|
|
get_memory(tick).state = 2
|
|
return ERR_BUSY
|
|
2:
|
|
blackboard_set(tick, "guard_cooldown", 1.5)
|
|
return OK
|
|
func stop(tick):
|
|
get_memory(tick).state = 0
|
|
|
|
class walkto extends AIScriptModule:
|
|
func init(tick):
|
|
get_memory(tick).state = 0
|
|
get_memory(tick).pdist = INF
|
|
get_memory(tick).root = get_character(tick)
|
|
get_memory(tick).timeout = get_memory(tick).config_timeout
|
|
func look_at(root, where):
|
|
var current = root.global_transform
|
|
var at = where
|
|
at.y = current.origin.y
|
|
root.global_transform = current.looking_at(at, Vector3.UP)
|
|
root.set_meta("orientation", Transform(root.global_transform.basis, Vector3()))
|
|
func update_physics(tick, delta):
|
|
var root = get_memory(tick).root
|
|
assert(root)
|
|
var flee = get_memory(tick).flee
|
|
var where: Vector3
|
|
var adest = blackboard_get(tick, "enemy_pos")
|
|
var away = (root.global_transform.origin - adest).normalized()
|
|
var fdest = root.global_transform.origin + away * 4.0
|
|
|
|
if !flee:
|
|
where = adest
|
|
else:
|
|
where = fdest
|
|
var gpos = root.global_transform.origin
|
|
var dst = gpos.distance_squared_to(where)
|
|
var finished = false
|
|
var pdist = get_memory(tick).pdist
|
|
var speed = get_memory(tick).speed
|
|
var cost = get_memory(tick).cost
|
|
var gap = get_memory(tick).gap
|
|
# get_memory(tick).timeout -= delta
|
|
match get_memory(tick).state:
|
|
0:
|
|
look_at(root, where)
|
|
characters.animation_node_travel(root, "locomotion")
|
|
characters.set_walk_speed(root, speed, 0)
|
|
get_memory(tick).state = 1
|
|
1:
|
|
blackboard_set(tick, "stamina", blackboard_get(tick, "stamina") - cost * delta)
|
|
get_memory(tick).state = 2
|
|
2:
|
|
if dst < gap * gap:
|
|
get_memory(tick).state = 10
|
|
elif get_memory(tick).timeout < 0.0:
|
|
root.global_transform.origin = where
|
|
get_memory(tick).state = 20
|
|
# elif dst > pdist && dst > gap * gap:
|
|
# root.global_transform.origin = where
|
|
# get_memory(tick).state = 30
|
|
# printerr("missed the target: ", sqrt(dst), gap)
|
|
# elif dst < 3.0 * gap * gap && get_memory(tick).timeout > 0.0:
|
|
# characters.set_walk_speed(root, speed, 0)
|
|
# get_memory(tick).state = 3
|
|
else:
|
|
get_memory(tick).state = 0
|
|
10:
|
|
finished = true
|
|
20:
|
|
finished = true
|
|
30:
|
|
finished = true
|
|
# 200:
|
|
# get_memory(tick).timeout -= delta
|
|
# if get_memory(tick).timeout < 0.0:
|
|
# root.global_transform.origin = where
|
|
# characters.set_walk_speed(root, 0, 0)
|
|
# finished = true
|
|
# state = 300
|
|
# 300:
|
|
# printerr("should not be here: ", sqrt(dst), gap)
|
|
# breakpoint
|
|
get_memory(tick).pdist = dst
|
|
if !finished:
|
|
return ERR_BUSY
|
|
else:
|
|
return OK
|
|
func stop(tick):
|
|
var root = get_memory(tick).root
|
|
characters.set_walk_speed(root, 0, 0)
|
|
get_memory(tick).state = 0
|
|
get_memory(tick).timeout = get_memory(tick).config_timeout
|
|
class attack extends AIScriptModule:
|
|
func init(tick):
|
|
get_memory(tick).root = get_character(tick)
|
|
get_memory(tick).state = 0
|
|
func look_at(tick, root):
|
|
var current = root.global_transform
|
|
var at = blackboard_get(tick, "enemy_pos")
|
|
at.y = current.origin.y
|
|
root.global_transform = current.looking_at(at, Vector3.UP)
|
|
root.set_meta("orientation", Transform(root.global_transform.basis, Vector3()))
|
|
func update_physics(tick, delta):
|
|
var root = get_memory(tick).root
|
|
var event = get_memory(tick).event
|
|
var anim = get_memory(tick).anim
|
|
var finished = false
|
|
assert(root)
|
|
if blackboard_get(tick, "attack_cooldown") > 0.0:
|
|
blackboard_set(tick, "attack_cooldown", blackboard_get(tick, "attack_cooldown") - delta)
|
|
return FAILED
|
|
match get_memory(tick).state:
|
|
0:
|
|
combat.emit_signal("event", get_memory(tick).event, [root])
|
|
look_at(tick, root)
|
|
get_memory(tick).state = 1
|
|
1:
|
|
blackboard_set(tick, "stamina", blackboard_get(tick, "stamina") - 0.5 * delta)
|
|
blackboard_set(tick, "stamina", blackboard_get(tick, "stamina") - 3500 * delta)
|
|
characters.animation_node_travel(root, anim)
|
|
get_memory(tick).state = 2
|
|
2:
|
|
blackboard_set(tick, "stamina", blackboard_get(tick, "stamina") - 5 * delta)
|
|
blackboard_set(tick, "attack_cooldown", 1.8)
|
|
finished = true
|
|
if finished:
|
|
return OK
|
|
else:
|
|
return ERR_BUSY
|
|
func stop(tick):
|
|
get_memory(tick).state = 0
|
|
|
|
func init(tick):
|
|
assert(tick)
|
|
assert(!get_memory(tick).has("initialized"))
|
|
get_memory(tick).name = "bandit_ai"
|
|
var considerations_data = {
|
|
"take_melee_weapon": {
|
|
"considerations": [
|
|
{"c": health_consideration.new(), "score": 1.0},
|
|
{"c": no_melee_weapon_equipped_consideration.new(), "score": 1.0},
|
|
{"c": threat_consideration.new(), "score": 1.0}
|
|
],
|
|
"score": 180.0,
|
|
"conf": {"weapon": "s_dagger"},
|
|
},
|
|
"approach_far": {
|
|
"considerations": [
|
|
{"c": health_consideration.new(), "score": 1.0},
|
|
{"c": enemy_very_far_consideration.new(), "score": 1.0},
|
|
{"c": has_melee_weapon_equipped_consideration.new(), "score": 1.0},
|
|
{"c": half_or_more_stamina_consideration.new(), "score": 1.0},
|
|
{"c": threat_consideration.new(), "score": 1.0}
|
|
],
|
|
"score": 120.0,
|
|
"conf": {"gap": 0.6, "config_timeout": 3.0, "speed": 4.0, "cost": 6.0, "flee": false},
|
|
},
|
|
"approach_near": {
|
|
"considerations": [
|
|
{"c": health_consideration.new(), "score": 1.0},
|
|
{"c": enemy_far_consideration.new(), "score": 1.0},
|
|
{"c": has_melee_weapon_equipped_consideration.new(), "score": 1.0},
|
|
{"c": half_or_more_stamina_consideration.new(), "score": 1.0},
|
|
{"c": threat_consideration.new(), "score": 1.0}
|
|
],
|
|
"score": 150.0,
|
|
"conf": {"gap": 0.6, "config_timeout": 1.5, "speed": 2.0, "cost": 6.0, "flee": false},
|
|
},
|
|
"melee_attack": {
|
|
"considerations": [
|
|
{"c": health_consideration.new(), "score": 1.0},
|
|
{"c": has_melee_weapon_equipped_consideration.new(), "score": 1.0},
|
|
{"c": melee_attack_ready_consideration.new(), "score": 1.0},
|
|
{"c": twenty_or_more_stamina_consideration.new(), "score": 1.0},
|
|
{"c": melee_attack_distance_consideration.new(), "score": 1.0}
|
|
],
|
|
"score": 50.0,
|
|
"conf": {"anim": "attack-melee1", "event": "about_to_attack"},
|
|
},
|
|
"flee": {
|
|
"considerations": [
|
|
{"c": health_consideration.new(), "score": 1.0},
|
|
{"c": ready_to_flee_consideration.new(), "score": 1.0},
|
|
{"c": has_energy_consideration.new(), "score": 1.0},
|
|
{"c": dangerous_distance_consideration.new(), "score": 1.0},
|
|
],
|
|
"score": 300.0,
|
|
"conf": {"gap": 0.6, "config_timeout": 1.5, "speed": 20.0, "cost": 6.0, "flee": true},
|
|
},
|
|
"guard": {
|
|
"considerations": [
|
|
{"c": health_consideration.new(), "score": 1.0},
|
|
{"c": ready_to_guard_consideration.new(), "score": 1.0},
|
|
{"c": guarding_consideration.new(), "score": 1.0},
|
|
],
|
|
"score": 900.0,
|
|
"conf": {"anim1": "guard-melee1", "anim2": "guard-front-melee1"},
|
|
},
|
|
"unconcious": {
|
|
"considerations": [
|
|
{"c": critical_health_consideration.new(), "score": 1.0}
|
|
],
|
|
"score": 2000.0,
|
|
"conf": {"anim1": "fall-front", "anim2": "fall-back"},
|
|
},
|
|
"rest": {
|
|
"considerations": [
|
|
{"c": critical_stamina_consideration.new(), "score": 1.0},
|
|
{"c": flee_or_more_distance_consideration.new(), "score": 1.0}
|
|
],
|
|
"score": 150.0,
|
|
"conf": {},
|
|
},
|
|
"get_melee_damage": {
|
|
"considerations": [
|
|
{"c": health_consideration.new(), "score": 1.0},
|
|
{"c": melee_damage_consideration.new(), "score": 1.0},
|
|
],
|
|
"score": 3000.0,
|
|
"conf": {"anim1": "guard-melee1", "anim2": "guard-front-melee1", "cost": 10.0},
|
|
},
|
|
"idle": {
|
|
"considerations": [
|
|
],
|
|
"score": 1.0,
|
|
"conf": {},
|
|
}
|
|
}
|
|
|
|
var root = get_character(tick)
|
|
for e in init_blackboard.keys():
|
|
if !blackboard_is_set(tick, e):
|
|
blackboard_set(tick, e, init_blackboard[e])
|
|
blackboard_set(tick, "self", root)
|
|
assert(root.has_meta("skeleton"))
|
|
get_memory(tick).rnd = RandomNumberGenerator.new()
|
|
get_memory(tick).rnd.randomize()
|
|
root.add_to_group("bandits")
|
|
root.add_to_group("bandit")
|
|
var character_data = root.get_meta("character_data")
|
|
if character_data.sex == "female":
|
|
var g = garments_female_lingerie
|
|
var h = []
|
|
g += garments_female_main
|
|
h += garments_head_female
|
|
characters.call_deferred("setup_garments", root, g, h, material_female)
|
|
else:
|
|
var g = garments_male_lingerie
|
|
var h = []
|
|
g += garments_male_main
|
|
h += garments_head_male
|
|
characters.call_deferred("setup_garments", root, g, h, material_male)
|
|
|
|
var ai_runner: AIUtilityRunner = AIUtilityRunner.new()
|
|
get_memory(tick).runner = ai_runner
|
|
_register_module(tick, get_memory(tick).runner)
|
|
combat.connect("event", self, "combat_event", [blackboard_get_dict(tick)])
|
|
if !get_memory(tick).has("run_behaviors"):
|
|
get_memory(tick).run_behaviors = {}
|
|
for e in conf_behaviors.keys():
|
|
if !get_memory(tick).run_behaviors.has(e):
|
|
get_memory(tick).run_behaviors[e] = conf_behaviors[e].new()
|
|
_register_module(tick, get_memory(tick).run_behaviors[e])
|
|
var conf = considerations_data[e].conf
|
|
get_memory(tick).run_behaviors[e].setup(tick, conf)
|
|
ai_runner.add_choice(tick, e, considerations_data[e].score, get_memory(tick).run_behaviors[e])
|
|
for c in considerations_data[e].considerations:
|
|
ai_runner.add_consideration(tick, e, c.c, c.score)
|
|
get_memory(tick).initialized = true
|
|
var cooldown = 0.0
|
|
|
|
var conf_behaviors: = {
|
|
"take_melee_weapon": take_weapon,
|
|
"approach_far": walkto,
|
|
"approach_near": walkto,
|
|
"flee": walkto,
|
|
"melee_attack": attack,
|
|
"guard": guard,
|
|
"rest": rest,
|
|
"idle": idle,
|
|
"get_melee_damage": get_damage,
|
|
"unconcious": unconcious
|
|
}
|
|
|
|
class health_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "health") <= 0.0:
|
|
return 0.0
|
|
var ret = blackboard_get(tick, "health") / 100.0
|
|
ret = clamp(ret, 0.0, 1.0)
|
|
return ret * ret
|
|
class no_melee_weapon_equipped_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if !blackboard_get(tick, "melee_weapon_equipped"):
|
|
return 1.0
|
|
return 0.0
|
|
class threat_consideration extends AIUtilityScriptedConsideration:
|
|
const engage_distance = 20.0
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "enemy_distance") < engage_distance * engage_distance:
|
|
return 1.0
|
|
return 0.0
|
|
class safe_consideration extends AIUtilityScriptedConsideration:
|
|
const engage_distance = 20.0
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "enemy_distance") >= engage_distance * engage_distance:
|
|
return 1.0
|
|
return 0.0
|
|
class enemy_far_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "enemy_distance") < 1.6 * 1.6:
|
|
return 0.0
|
|
return 1.0
|
|
class enemy_very_far_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "enemy_distance") > 5.0 * 5.0:
|
|
return 1.0
|
|
return 0.0
|
|
class half_or_more_stamina_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "stamina") > 50.0:
|
|
return 1.0
|
|
return 0.0
|
|
class has_melee_weapon_equipped_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "melee_weapon_equipped"):
|
|
return 1.0
|
|
return 0.0
|
|
class melee_attack_ready_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "attack_cooldown") <= 0.0:
|
|
return 1.0
|
|
return 0.0
|
|
class twenty_or_more_stamina_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "stamina") > 20.0:
|
|
return 1.0
|
|
return 0.0
|
|
class melee_attack_distance_consideration extends AIUtilityScriptedConsideration:
|
|
const attack_distance = 2.0
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "enemy_distance") < attack_distance * attack_distance:
|
|
return 1.0
|
|
return 0.0
|
|
class need_healing_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "health") >= 100.0:
|
|
return 0.0
|
|
var ret = 1.0 - blackboard_get(tick, "health") / 100.0
|
|
return clamp(ret, 0.0, 1.0)
|
|
class need_rest_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "stamina") >= 80.0:
|
|
return 0.0
|
|
var e = blackboard_get(tick, "stamina") / 100.0
|
|
e = clamp(e, 0.0, 1.0)
|
|
var d = (1.0 / (e + 1.0) - 0.5) * 0.5
|
|
return clamp(d, 0.0, 1.0)
|
|
class critical_health_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "health") < 10.0:
|
|
return 1.0
|
|
return 0.0
|
|
class critical_stamina_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "stamina") < 10.0:
|
|
return 1.0
|
|
return 0.0
|
|
class flee_or_more_distance_consideration extends AIUtilityScriptedConsideration:
|
|
const flee_distance = 5.0
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "enemy_distance") >= flee_distance * flee_distance:
|
|
return 1.0
|
|
return 0.0
|
|
class dangerous_distance_consideration extends AIUtilityScriptedConsideration:
|
|
const flee_distance = 5.0
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "enemy_distance") < flee_distance * flee_distance:
|
|
return 1.0
|
|
return 0.0
|
|
class ready_to_flee_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "flee_cooldown") < 0.0:
|
|
return 1.0
|
|
return 0.0
|
|
class has_energy_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "stamina") >= 10.0:
|
|
return 1.0
|
|
return 0.0
|
|
class ready_to_guard_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "guard_cooldown") < 0.0:
|
|
return 1.0
|
|
return 0.0
|
|
class guarding_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "guard"):
|
|
return 1.0
|
|
return 0.0
|
|
class melee_damage_consideration extends AIUtilityScriptedConsideration:
|
|
func evalute(tick, delta):
|
|
if blackboard_get(tick, "melee_damage"):
|
|
return 1.0
|
|
return 0.0
|
|
func update_physics(tick, delta):
|
|
assert(get_memory(tick).initialized)
|
|
var root = get_character(tick)
|
|
assert(root)
|
|
var cam = root.get_viewport().get_camera()
|
|
if !cam:
|
|
return FAILED
|
|
if !cam.has_meta("player"):
|
|
return FAILED
|
|
blackboard_set(tick, "self", get_character(tick))
|
|
var space: PhysicsDirectSpaceState = root.get_world().get_direct_space_state()
|
|
var o = root.global_transform.origin
|
|
var p = cam.get_meta("player").global_transform
|
|
var pdst = o.distance_squared_to(p.origin)
|
|
blackboard_set(tick, "enemy_distance", pdst)
|
|
blackboard_set(tick, "randf", get_memory(tick).rnd.randf())
|
|
blackboard_set(tick, "enemy_pos", p.origin)
|
|
blackboard_set(tick, "space", space)
|
|
var adest = p.origin
|
|
var away = (o - p.origin).normalized()
|
|
var attack_xform = Transform(root.global_transform.basis, o + away * 1.5)
|
|
|
|
var fdest = o + away * 4.0
|
|
blackboard_set(tick, "away_pos", fdest)
|
|
var enemy_dir: Vector3 = Transform(p.basis, Vector3()).xform(Vector3(0, 0, -1))
|
|
var root_dir: Vector3 = Transform(root.global_transform.basis, Vector3()).xform(Vector3(0, 0, -1))
|
|
var dot = root_dir.dot(enemy_dir)
|
|
blackboard_set(tick, "dot", dot)
|
|
|
|
var result = get_memory(tick).runner._update_physics(tick, delta)
|
|
|
|
if blackboard_get(tick, "stamina") < 100.0:
|
|
blackboard_set(tick, "stamina", blackboard_get(tick, "stamina") + delta)
|
|
if blackboard_get(tick, "attack_cooldown") > 0.0:
|
|
blackboard_set(tick, "attack_cooldown", blackboard_get(tick, "attack_cooldown") - delta)
|
|
if blackboard_get(tick, "guard_cooldown") > 0.0:
|
|
blackboard_set(tick, "guard_cooldown", blackboard_get(tick, "guard_cooldown") - delta)
|
|
if blackboard_get(tick, "flee_cooldown") > 0.0:
|
|
blackboard_set(tick, "flee_cooldown", blackboard_get(tick, "flee_cooldown") - delta)
|
|
blackboard_set(tick, "stamina", clamp(blackboard_get(tick, "stamina"), 0, 100.0))
|
|
blackboard_set(tick, "health", clamp(blackboard_get(tick, "health"), 0, 100.0))
|
|
return ERR_BUSY
|
|
func update(tick, delta):
|
|
return ERR_BUSY
|
|
|
|
func stop(tick):
|
|
for e in conf_behaviors.keys():
|
|
if get_memory(tick).run_behaviors.has(e):
|
|
_unregister_module(tick, get_memory(tick).run_behaviors[e])
|
|
_unregister_module(tick, get_memory(tick).runner)
|