287 lines
8.2 KiB
GDScript
287 lines
8.2 KiB
GDScript
extends Node
|
|
|
|
func _ready():
|
|
pass # Replace with function body.
|
|
|
|
var stats = {
|
|
"health": {"rise": 0.0005, "base": 100, "random": 1000, "bonus": 10000},
|
|
"stamina": {"rise": 0.0012, "base": 100, "random": 1000, "bonus": 10000},
|
|
"strength": {"rise": 0.0, "base": 100, "random": 1000, "bonus": 10000},
|
|
"agility": {"rise": 0.0, "base": 100, "random": 1000, "bonus": 10000},
|
|
"intelligence": {"rise": 0.0, "base": 100, "random": 1000, "bonus": 10000},
|
|
}
|
|
|
|
var needs = {
|
|
"hunger": {
|
|
"stat": "max_health",
|
|
"mul": 0.001
|
|
},
|
|
"thirst": {
|
|
"stat": "max_health",
|
|
"mul": 0.001
|
|
},
|
|
"lust": {
|
|
"stat": "strength",
|
|
"mul": 0.002
|
|
}
|
|
}
|
|
|
|
func create_stats(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
for k in stats.keys():
|
|
var kmax = "max_" + k
|
|
var val = stats[k].base + randi() % stats[k].random
|
|
obj.set_meta(k, val)
|
|
obj.set_meta(kmax, val)
|
|
obj.set_meta("submission", 0)
|
|
obj.set_meta("agression", 0)
|
|
obj.set_meta("panic", 0)
|
|
obj.set_meta("xp", 0)
|
|
obj.set_meta("next_xp", 100)
|
|
obj.set_meta("level", 1)
|
|
for k in needs.keys():
|
|
obj.set_meta(k, 0.0)
|
|
if obj.is_in_group("guard"):
|
|
var st = obj.get_meta("max_strength")
|
|
if st < 1000.0:
|
|
obj.set_meta("strength", st)
|
|
obj.set_meta("max_strength", st)
|
|
var sm = obj.get_meta("max_stamina")
|
|
if sm < 2000.0:
|
|
obj.set_meta("stamina", sm)
|
|
obj.set_meta("max_stamina", sm)
|
|
if obj.is_in_group("maid"):
|
|
var subm = obj.get_meta("submission")
|
|
if subm < 1000.0:
|
|
obj.set_meta("submission", subm)
|
|
var save_stats = [
|
|
"health",
|
|
"stamina",
|
|
"strength",
|
|
"agility",
|
|
"intelligence",
|
|
"submission",
|
|
"xp",
|
|
"next_xp",
|
|
"level"]
|
|
func update_needs(obj):
|
|
for k in needs.keys():
|
|
var s = needs[k].stat
|
|
var m = needs[k].mul
|
|
var nval = obj.get_meta(k)
|
|
nval += obj.get_meta(s) * m * get_process_delta_time()
|
|
obj.set_meta(k, nval)
|
|
func update_stats(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
if obj.get_meta("grabbing"):
|
|
return
|
|
if obj.get_meta("smart_object"):
|
|
return
|
|
for k in stats.keys():
|
|
var val = obj.get_meta(k)
|
|
var max_val = obj.get_meta("max_" + k)
|
|
var incr = stats[k].rise * max_val * get_process_delta_time()
|
|
# print("incr: ", obj.name, " ", incr)
|
|
if val < 0.1 * max_val:
|
|
val += 0.3 * incr
|
|
else:
|
|
val += incr
|
|
# print("stat: ", k, " incr: ", incr, " val: ", val)
|
|
obj.set_meta(k, clamp(val, 0, max_val))
|
|
var sub = get_submission(obj)
|
|
var aggr = get_agression(obj)
|
|
var pnc = get_panic(obj)
|
|
var pnc_inc = 0.0
|
|
var aggr_inc = 0.0
|
|
if combat.enemy_nearby(obj, 4.0):
|
|
pnc_inc += 1.0 / (1.0 + sub * 2.0)
|
|
aggr_inc += get_strength(obj) / (1.0 + pnc + sub)
|
|
if obj.is_in_group("maid"):
|
|
pnc_inc *= 0.1
|
|
elif obj.is_in_group("guard"):
|
|
pnc_inc = 0.0
|
|
else:
|
|
pnc_inc -= 0.5 * (get_strength(obj) + (1.0 + sub))
|
|
if obj.is_in_group("maid"):
|
|
pnc_inc *= 100.0
|
|
if obj.is_in_group("guard"):
|
|
pnc_inc *= 200.0
|
|
if obj.is_in_group("maid"):
|
|
pnc_inc *= 0.1
|
|
aggr += aggr_inc * get_process_delta_time()
|
|
pnc += pnc_inc * get_process_delta_time()
|
|
aggr = clamp(aggr, 0.0, 100000.0)
|
|
pnc = clamp(pnc, 0.0, 100000.0)
|
|
obj.set_meta("panic", pnc)
|
|
obj.set_meta("agression", aggr)
|
|
|
|
func level_up(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
var level = obj.get_meta("level")
|
|
var next_xp = obj.get_meta("next_xp")
|
|
for k in stats.keys():
|
|
var kmax = "max_" + k
|
|
if level < 100:
|
|
var val = obj.get_meta(kmax) + stats[k].bonus / (100 - level)
|
|
obj.set_meta(kmax, val)
|
|
obj.set_meta(k, val)
|
|
|
|
else:
|
|
var val = obj.get_meta(kmax) + stats[k].bonus
|
|
obj.set_meta(kmax, val)
|
|
obj.set_meta(k, val)
|
|
if level < 100:
|
|
next_xp += int(clamp(level * next_xp / 5, 50, next_xp * 2))
|
|
else:
|
|
next_xp += int(next_xp * 1.5)
|
|
level += 1
|
|
dump_stats(obj)
|
|
|
|
func update_xp(obj, xp):
|
|
assert(obj.is_in_group("characters"))
|
|
var cur_xp = obj.get_meta("xp")
|
|
var next_xp = obj.get_meta("next_xp")
|
|
cur_xp += xp
|
|
if cur_xp >= next_xp:
|
|
level_up(obj)
|
|
cur_xp -= next_xp
|
|
obj.set_meta("xp", cur_xp)
|
|
|
|
func can_attack(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
if obj.get_meta("grabbed"):
|
|
return false
|
|
if obj.get_meta("smart_object"):
|
|
return false
|
|
if obj.get_meta("health") <= 0:
|
|
return false
|
|
if obj.get_meta("stamina") <= 0:
|
|
return false
|
|
return true
|
|
func melee_attack(attacker, enemy):
|
|
assert(attacker.is_in_group("characters"))
|
|
assert(enemy.is_in_group("characters"))
|
|
if !can_attack(attacker):
|
|
return
|
|
var attack_base = int(attacker.get_meta("strength"))
|
|
var attack_bonus = int(attacker.get_meta("agility"))
|
|
var attack_val = attack_base + randi() % (1 + attack_bonus)
|
|
var defence = enemy.get_meta("agility") + randi() % (1 + int(enemy.get_meta("strength")))
|
|
var damage = int(clamp(attack_val - defence, 0, attack_val))
|
|
var enemy_health = int(enemy.get_meta("health"))
|
|
enemy_health = int(clamp(enemy_health - damage, 0, enemy_health))
|
|
enemy.set_meta("health", enemy_health)
|
|
var stamina = attacker.get_meta("stamina")
|
|
stamina -= damage / (2 + attacker.get_meta("agility"))
|
|
attacker.set_meta("stamina", stamina)
|
|
if enemy_health == 0:
|
|
update_xp(attacker, int(enemy.get_meta("max_health") * 0.1))
|
|
else:
|
|
update_xp(attacker, int(damage * 0.1))
|
|
# dump_stats(enemy)
|
|
func projectile_attack(pj, enemy):
|
|
var damage = pj.get_mass() * pj.get_linear_velocity().length() * 3.0
|
|
# print("DAMAGE: ", damage)
|
|
if pj.has_meta("owner"):
|
|
var attacker = pj.get_meta("owner")
|
|
update_xp(attacker, int(10 + damage))
|
|
var enemy_health = int(enemy.get_meta("health"))
|
|
enemy_health = int(clamp(enemy_health - damage, 0, enemy_health))
|
|
enemy.set_meta("health", enemy_health)
|
|
# dump_stats(enemy)
|
|
func submission_check(attacker, enemy):
|
|
assert(attacker.is_in_group("characters"))
|
|
assert(enemy.is_in_group("characters"))
|
|
var astrength = attacker.get_meta("strength")
|
|
var estrength = enemy.get_meta("strength")
|
|
var esub = enemy.get_meta("submission")
|
|
if astrength > estrength + esub:
|
|
return true
|
|
return false
|
|
|
|
func strength_check(attacker, enemy):
|
|
assert(attacker.is_in_group("characters"))
|
|
assert(enemy.is_in_group("characters"))
|
|
var astrength = attacker.get_meta("strength")
|
|
var estrength = attacker.get_meta("strength")
|
|
if astrength * 0.5 > estrength:
|
|
return true
|
|
return false
|
|
func dump_stats(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
# print(stats.keys())
|
|
for k in stats.keys():
|
|
assert(obj.get_meta(k))
|
|
print(k + ": ", obj.get_meta(k))
|
|
print("submission: ", obj.get_meta("submission"))
|
|
print("xp: ", obj.get_meta("xp"))
|
|
print("next_xp: ", obj.get_meta("next_xp"))
|
|
print("level: ", obj.get_meta("level"))
|
|
func damage_stamina(obj, val):
|
|
assert(obj.is_in_group("characters"))
|
|
var stamina = obj.get_meta("stamina")
|
|
var max_stamina = obj.get_meta("max_stamina")
|
|
stamina -= val
|
|
obj.set_meta("stamina", clamp(stamina, 0.0, max_stamina))
|
|
func get_health(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
var health = obj.get_meta("health")
|
|
return health
|
|
func get_stamina(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
var stamina = obj.get_meta("stamina")
|
|
return stamina
|
|
func get_strength(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
var strength = obj.get_meta("strength")
|
|
return strength
|
|
func get_agression(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
var agression = obj.get_meta("agression")
|
|
return agression
|
|
func get_submission(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
var submission = obj.get_meta("submission")
|
|
return submission
|
|
func get_panic(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
var panic = obj.get_meta("panic")
|
|
return panic
|
|
func get_lust(obj):
|
|
assert(obj.is_in_group("characters"))
|
|
var lust = obj.get_meta("lust")
|
|
return lust
|
|
func add_panic(obj, val):
|
|
assert(obj.is_in_group("characters"))
|
|
var panic = get_panic(obj)
|
|
panic += val
|
|
obj.set_meta("panic", panic)
|
|
func add_agression(obj, val):
|
|
assert(obj.is_in_group("characters"))
|
|
var agression = get_agression(obj)
|
|
agression += val
|
|
obj.set_meta("panic", agression)
|
|
func is_enemy(ch1, ch2):
|
|
var versus = [
|
|
["player", "player", false],
|
|
["player", "guard", false],
|
|
["player", "maid", false],
|
|
["player", "captive", true],
|
|
["guard", "guard", false],
|
|
["guard", "player", false],
|
|
["guard", "maid", false],
|
|
["guard", "captive", true],
|
|
["maid", "maid", false],
|
|
["maid", "player", false],
|
|
["maid", "guard", true],
|
|
["maid", "captive", true],
|
|
["captive", "player", true],
|
|
["captive", "guard", true],
|
|
["captive", "maid", true],
|
|
["captive", "captive", false]
|
|
]
|
|
for e in versus:
|
|
if ch1.is_in_group(e[0]) && ch2.is_in_group(e[1]):
|
|
return e[2]
|
|
return false
|