P3 bear: one bear per island raids unattended food, palisades and closed huts keep it out, warns then charges, hide/fat/meat, fur rug (Cozy), death saved (protocol 8)
This commit is contained in:
Paul Bailey
216
scripts/creatures/bear.gd
Normal file
216
scripts/creatures/bear.gd
Normal file
@@ -0,0 +1,216 @@
|
||||
extends "res://scripts/creatures/creature.gd"
|
||||
## The bear (docs/PROGRESSION_DESIGN.md §4): one per island, living in the
|
||||
## deep forest by the rim (bear_range.gd finds the spot and brings it back
|
||||
## after it's killed).
|
||||
##
|
||||
## By day it ambles round its patch. From day 3 it sniffs out food left
|
||||
## unattended: food in a chest, or lying on the ground, with nobody about.
|
||||
## It walks over, eats every bit of food (nothing else) and wanders off. A
|
||||
## palisade ring or a closed hut keeps it out: it can't get at food it can't
|
||||
## walk to, and it doesn't break things.
|
||||
##
|
||||
## It won't start a fight, but it won't be crowded: closer than 8 m it rears
|
||||
## up and warns you, closer than 6 m after that and it charges. Hit it and it
|
||||
## charges too. Badly hurt, it runs home. At night it sleeps at its home.
|
||||
|
||||
const WARN_DIST := 8.0
|
||||
const CHARGE_DIST := 6.0
|
||||
const EAT_SECONDS := 8.0
|
||||
const RAID_COOLDOWN := 40.0 ## after a meal, before it goes looking again
|
||||
const SNIFF_EVERY := 2.0
|
||||
const STUCK_GIVE_UP := 15.0 ## no closer for this long: forget that food for a while
|
||||
|
||||
var range_: Node ## bear_range.gd
|
||||
var food: Node3D = null ## what it's going for
|
||||
var _raid_cd := 0.0
|
||||
var _sniff := 0.0
|
||||
var _eat_t := 0.0
|
||||
var _stuck_t := 0.0
|
||||
var _last_d := INF
|
||||
var _skip := {} ## food instance id -> seconds to ignore it
|
||||
var _goal_d := 0.0
|
||||
|
||||
func display_name() -> String:
|
||||
return def.name
|
||||
|
||||
func interact_prompt(p: Node) -> String:
|
||||
if is_dead():
|
||||
return "Bear carcass [E] Butcher"
|
||||
var s := "Bear"
|
||||
match state:
|
||||
"rest": s = "Bear (asleep)"
|
||||
"raid": s = "Bear (following its nose)"
|
||||
"eat": s = "Bear (eating)"
|
||||
"warn": s = "Bear (warning you off!)"
|
||||
"charge": s = "Bear (angry!)"
|
||||
"flee": s = "Bear (running off)"
|
||||
if not Actions.melee_stats(p).armed and not ItemDB.get_item(p.held_item_id()).has("bow"):
|
||||
s += " (you need a weapon)"
|
||||
return s
|
||||
|
||||
func _think(dt: float) -> void:
|
||||
var pp: Vector3 = player.global_position
|
||||
var d := global_position.distance_to(pp)
|
||||
_state_t -= dt
|
||||
_raid_cd = maxf(_raid_cd - dt, 0.0)
|
||||
for k in _skip.keys():
|
||||
_skip[k] = float(_skip[k]) - dt
|
||||
if float(_skip[k]) <= 0.0:
|
||||
_skip.erase(k)
|
||||
if state == "flee":
|
||||
var away := global_position - _threat
|
||||
steer(atan2(-away.x, -away.z))
|
||||
if _state_t <= 0.0:
|
||||
state = "wander"
|
||||
return
|
||||
if _aggro > 0.0:
|
||||
if player.survival.dead or d > 40.0:
|
||||
_aggro = 0.0
|
||||
state = "wander"
|
||||
else:
|
||||
state = "charge"
|
||||
var to := pp - global_position
|
||||
steer(atan2(-to.x, -to.z))
|
||||
if d < def.attack_range and _attack_cd <= 0.0 and _can_reach(player):
|
||||
_attack_cd = def.attack_cd
|
||||
player.survival.damage(def.damage * world.difficulty_mult("damage"), global_position, "a bear")
|
||||
return
|
||||
if not range_.awake():
|
||||
_go_home_to_sleep()
|
||||
return
|
||||
# Too close: rear up, then charge if you don't back off.
|
||||
if d < WARN_DIST and not player.survival.dead and _can_reach(player):
|
||||
var to := pp - global_position
|
||||
steer(atan2(-to.x, -to.z))
|
||||
if state != "warn":
|
||||
state = "warn"
|
||||
_state_t = 2.5
|
||||
elif _state_t <= 0.0 and d < CHARGE_DIST:
|
||||
_aggro = 12.0
|
||||
_attack_cd = 0.3
|
||||
state = "charge"
|
||||
return
|
||||
if state == "warn":
|
||||
state = "wander"
|
||||
match state:
|
||||
"eat":
|
||||
_eat_t -= dt
|
||||
if _eat_t <= 0.0:
|
||||
state = "wander"
|
||||
_raid_cd = RAID_COOLDOWN
|
||||
"raid":
|
||||
_raid_step(dt)
|
||||
_:
|
||||
_sniff -= dt
|
||||
if _sniff <= 0.0 and _raid_cd <= 0.0 and range_.raids_now():
|
||||
_sniff = SNIFF_EVERY
|
||||
var f: Node3D = range_.find_food(self, _skip)
|
||||
if f != null:
|
||||
food = f
|
||||
state = "raid"
|
||||
_last_d = INF
|
||||
_stuck_t = 0.0
|
||||
return
|
||||
_amble(dt)
|
||||
|
||||
func _raid_step(dt: float) -> void:
|
||||
if food == null or not is_instance_valid(food) or not range_.raidable(food):
|
||||
food = null
|
||||
state = "wander"
|
||||
return
|
||||
var fp: Vector3 = food.global_position
|
||||
var fd := Vector2(fp.x - global_position.x, fp.z - global_position.z).length()
|
||||
if fd < 1.9:
|
||||
range_.raid(self, food)
|
||||
food = null
|
||||
state = "eat"
|
||||
_eat_t = EAT_SECONDS
|
||||
_goal_d = 0.0
|
||||
return
|
||||
_go_to(fp)
|
||||
if fd > _last_d - 0.05 * dt * 10.0:
|
||||
_stuck_t += dt
|
||||
else:
|
||||
_stuck_t = 0.0
|
||||
_last_d = minf(_last_d, fd)
|
||||
if _stuck_t > STUCK_GIVE_UP:
|
||||
_skip[food.get_instance_id()] = 120.0
|
||||
food = null
|
||||
state = "wander"
|
||||
|
||||
## Idles and wanders like any animal, but never far from home.
|
||||
func _amble(dt: float) -> void:
|
||||
var home: Vector3 = range_.home
|
||||
if Vector2(home.x - global_position.x, home.z - global_position.z).length() > range_.HOME_RADIUS:
|
||||
state = "home"
|
||||
_go_to(home)
|
||||
return
|
||||
if state == "home":
|
||||
state = "wander"
|
||||
_state_t = rng.randf_range(3.0, 8.0)
|
||||
if _state_t <= 0.0:
|
||||
if state == "idle":
|
||||
state = "wander"
|
||||
target_yaw = yaw + rng.randf_range(-1.6, 1.6)
|
||||
_state_t = rng.randf_range(4.0, 9.0)
|
||||
else:
|
||||
state = "idle"
|
||||
_state_t = rng.randf_range(3.0, 7.0)
|
||||
|
||||
func _go_home_to_sleep() -> void:
|
||||
var home: Vector3 = range_.home
|
||||
if Vector2(home.x - global_position.x, home.z - global_position.z).length() > 2.0:
|
||||
state = "home"
|
||||
_go_to(home)
|
||||
else:
|
||||
state = "rest"
|
||||
|
||||
func _go_to(p: Vector3) -> void:
|
||||
var to := p - global_position
|
||||
to.y = 0.0
|
||||
if to.length() > 0.3:
|
||||
steer(atan2(-to.x, -to.z))
|
||||
_goal_d = to.length()
|
||||
|
||||
func _desired_speed() -> float:
|
||||
match state:
|
||||
"wander": return def.walk
|
||||
"raid": return 0.0 if _goal_d < 1.0 else 3.2
|
||||
"home": return 0.0 if _goal_d < 1.0 else 3.0
|
||||
"charge", "flee": return def.run
|
||||
return 0.0
|
||||
|
||||
## (The chest it's going for isn't in its way: it walks right up to it.)
|
||||
func _blocked(dir: Vector3) -> bool:
|
||||
if state == "raid" and food != null and is_instance_valid(food) and global_position.distance_to(food.global_position) < 3.5:
|
||||
var probe := global_position + dir * 1.4
|
||||
var h: float = terrain.sample_height(probe.x, probe.z)
|
||||
return h < terrain.water_level + 0.2 or absf(h - global_position.y) > 1.1
|
||||
return super._blocked(dir)
|
||||
|
||||
## Rearing up on its hind legs when it warns you (also on puppets online).
|
||||
func _animate(dt: float) -> void:
|
||||
if state == "warn":
|
||||
_visual.rotation.x = lerpf(_visual.rotation.x, 0.6, minf(dt * 4.0, 1.0))
|
||||
_visual.position.y = lerpf(_visual.position.y, 0.25, minf(dt * 4.0, 1.0))
|
||||
return
|
||||
super._animate(dt)
|
||||
|
||||
## No wall, door or rock between the bear and `p`.
|
||||
func _can_reach(p: Node3D) -> bool:
|
||||
var from := global_position + Vector3(0, 0.9, 0)
|
||||
var to: Vector3 = p.global_position + Vector3(0, 1.0, 0)
|
||||
var q := PhysicsRayQueryParameters3D.create(from, to, 1)
|
||||
q.exclude = [get_rid(), p.get_rid(), terrain.get_node("TerrainBody").get_rid()]
|
||||
return get_world_3d().direct_space_state.intersect_ray(q).is_empty()
|
||||
|
||||
func _react(from: Vector3) -> void:
|
||||
if hp < def.hp * 0.25:
|
||||
_aggro = 0.0
|
||||
_threat = from
|
||||
state = "flee"
|
||||
_state_t = 10.0
|
||||
return
|
||||
_aggro = 25.0
|
||||
_attack_cd = maxf(_attack_cd, 0.4)
|
||||
state = "charge"
|
||||
211
scripts/creatures/bear_range.gd
Normal file
211
scripts/creatures/bear_range.gd
Normal file
@@ -0,0 +1,211 @@
|
||||
extends Node3D
|
||||
## The bear's patch (docs/PROGRESSION_DESIGN.md §4): where the island's one
|
||||
## bear lives, bringing it back after it's killed, and the food it can get at.
|
||||
##
|
||||
## Home is the densest forest near the rim, away from the spawn and the wolf
|
||||
## den, picked from the seed (the same on every machine). The bear is there
|
||||
## from day 1; raids start on day 3. Killed, it's back RESPAWN_DAYS later,
|
||||
## at dawn, when nobody's near its home.
|
||||
##
|
||||
## Food it can raid: a chest with food in it, or food left on the ground,
|
||||
## within SMELL of the bear, with nobody within GUARD of it, and not fenced
|
||||
## in. Fenced in = every one of 32 level rays from it hits a building piece
|
||||
## (a palisade ring, the walls of a closed hut; an open door lets it in).
|
||||
|
||||
const BearScript = preload("res://scripts/creatures/bear.gd")
|
||||
|
||||
const RAID_DAY := 3
|
||||
const RESPAWN_DAYS := 3
|
||||
const SMELL := 60.0
|
||||
const GUARD := 12.0
|
||||
const HOME_RADIUS := 35.0
|
||||
const FENCE_RAY := 25.0
|
||||
const FENCE_RAYS := 32 ## fine enough that an open doorway lets one through
|
||||
|
||||
signal raided(target: Node3D, eaten: int)
|
||||
|
||||
var world: Node3D
|
||||
var home := Vector3.ZERO
|
||||
var found := false
|
||||
var bear: Node3D = null
|
||||
var enabled := true
|
||||
var dead_day := -1 ## the day it was killed (-1: alive or never)
|
||||
var _rng := RandomNumberGenerator.new()
|
||||
|
||||
func setup(w: Node3D) -> void:
|
||||
world = w
|
||||
_rng.seed = w.terrain.noise_seed + 881
|
||||
found = _find_home()
|
||||
if found:
|
||||
spawn_bear()
|
||||
|
||||
## The densest stand of trees near the rim, at least 60 m from the spawn
|
||||
## and the den.
|
||||
func _find_home() -> bool:
|
||||
var terrain: Node3D = world.terrain
|
||||
var trees: Array = []
|
||||
for n in world.props.resource_nodes.values():
|
||||
if n.kind == "tree":
|
||||
trees.append((n as Node3D).global_position)
|
||||
if trees.is_empty():
|
||||
return false
|
||||
var spawn: Vector3 = world._spawn
|
||||
var den_at: Vector3 = world.den.position if world.den != null and world.den.found else Vector3(1e9, 0, 1e9)
|
||||
var best := -1.0
|
||||
var r := RandomNumberGenerator.new()
|
||||
r.seed = _rng.seed
|
||||
for _i in range(120):
|
||||
var c: Vector3 = trees[r.randi() % trees.size()]
|
||||
var rim: float = world.props._near_rim(c.x, c.z)
|
||||
if rim < 0.1 or rim > 0.9 or not terrain.inside_boundary(c.x, c.z, 10.0):
|
||||
continue
|
||||
if Vector2(c.x - spawn.x, c.z - spawn.z).length() < 60.0 or Vector2(c.x - den_at.x, c.z - den_at.z).length() < 60.0:
|
||||
continue
|
||||
if terrain.sample_height(c.x, c.z) < terrain.water_level + 1.0:
|
||||
continue
|
||||
var near := 0
|
||||
for t: Vector3 in trees:
|
||||
if absf(t.x - c.x) < 18.0 and absf(t.z - c.z) < 18.0:
|
||||
near += 1
|
||||
var score := near + rim * 6.0
|
||||
if score > best:
|
||||
best = score
|
||||
# Stand just beside the tree, not in its trunk.
|
||||
home = c + Vector3(1.6, 0, 0)
|
||||
home.y = terrain.sample_height(home.x, home.z)
|
||||
return best > 0.0
|
||||
|
||||
func spawn_bear() -> Node3D:
|
||||
var b: AnimatableBody3D = BearScript.new()
|
||||
b.setup("bear", world, home, _rng.randi())
|
||||
b.range_ = self
|
||||
b.state = "rest" if not awake() else "idle"
|
||||
add_child(b)
|
||||
b.died.connect(func(_c): dead_day = world.day_night.day)
|
||||
bear = b
|
||||
dead_day = -1
|
||||
return b
|
||||
|
||||
func alive() -> bool:
|
||||
return bear != null and is_instance_valid(bear) and not bear.is_dead()
|
||||
|
||||
## Saved with the world: whether it's dead (and since when), and how hurt
|
||||
## it is. Where it is isn't kept: it goes home over a reload.
|
||||
func save_data() -> Dictionary:
|
||||
if not found:
|
||||
return {}
|
||||
return {"dead_day": dead_day, "hp": float(bear.hp) if alive() else 0.0}
|
||||
|
||||
func load_data(d: Dictionary) -> void:
|
||||
if not found or d.is_empty():
|
||||
return
|
||||
var dd := int(d.get("dead_day", -1))
|
||||
if dd >= 0:
|
||||
if bear != null and is_instance_valid(bear):
|
||||
bear.queue_free()
|
||||
bear = null
|
||||
dead_day = dd
|
||||
return
|
||||
if not alive():
|
||||
spawn_bear()
|
||||
var hp := float(d.get("hp", 0.0))
|
||||
if hp > 0.0:
|
||||
bear.hp = minf(hp, float(bear.def.hp))
|
||||
|
||||
func awake() -> bool:
|
||||
var h: float = world.day_night.hours()
|
||||
return h >= 6.0 and h < 19.5
|
||||
|
||||
func raids_now() -> bool:
|
||||
return world.day_night.day >= RAID_DAY and awake()
|
||||
|
||||
func _physics_process(_delta: float) -> void:
|
||||
if enabled:
|
||||
step()
|
||||
|
||||
## Brings the bear back a few days after it was killed (at dawn, unseen).
|
||||
func step() -> void:
|
||||
if not found or alive() or dead_day < 0:
|
||||
return
|
||||
var h: float = world.day_night.hours()
|
||||
if world.day_night.day >= dead_day + RESPAWN_DAYS and h >= 6.0 and h < 9.0:
|
||||
for p in world.players():
|
||||
if p.global_position.distance_to(home) < 40.0:
|
||||
return
|
||||
spawn_bear()
|
||||
|
||||
# --- food --------------------------------------------------------------------------
|
||||
|
||||
static func is_food(id: String) -> bool:
|
||||
return ItemDB.get_item(id).has("food")
|
||||
|
||||
## Food that's worth the bear's while: `target` still has food in it.
|
||||
func has_food(target: Node3D) -> bool:
|
||||
if target.get("inventory") != null:
|
||||
for s in target.inventory.slots:
|
||||
if s != null and is_food(s.id):
|
||||
return true
|
||||
return false
|
||||
return target.get("item_id") != null and is_food(target.item_id) and not target.taken
|
||||
|
||||
## Food the bear could go for now: has food, nobody guarding it, not fenced in.
|
||||
func raidable(target: Node3D) -> bool:
|
||||
if not is_instance_valid(target) or target.is_queued_for_deletion() or not has_food(target):
|
||||
return false
|
||||
for p in world.players():
|
||||
if p.global_position.distance_to(target.global_position) < GUARD and not p.survival.dead:
|
||||
return false
|
||||
return not fenced(target.global_position)
|
||||
|
||||
## Walled in on every side (a palisade ring, a closed hut).
|
||||
func fenced(pos: Vector3) -> bool:
|
||||
var from := pos + Vector3(0, 0.6, 0)
|
||||
var space := world.get_world_3d().direct_space_state
|
||||
for i in range(FENCE_RAYS):
|
||||
var a := TAU * i / FENCE_RAYS
|
||||
var q := PhysicsRayQueryParameters3D.create(from, from + Vector3(cos(a), 0, sin(a)) * FENCE_RAY, world.BuildPiece.BUILD_LAYER)
|
||||
if space.intersect_ray(q).is_empty():
|
||||
return false
|
||||
return true
|
||||
|
||||
## The nearest food `b` can smell and get at (null: none).
|
||||
func find_food(b: Node3D, skip: Dictionary = {}) -> Node3D:
|
||||
var best: Node3D = null
|
||||
var best_d := SMELL
|
||||
var cands: Array = []
|
||||
for p in world.all_pieces():
|
||||
if p.item_id == "chest":
|
||||
cands.append(p)
|
||||
for d in world.all_dropped():
|
||||
if is_food(d.item_id):
|
||||
cands.append(d)
|
||||
for c in cands:
|
||||
if skip.has(c.get_instance_id()):
|
||||
continue
|
||||
var dist: float = c.global_position.distance_to(b.global_position)
|
||||
if dist < best_d and raidable(c):
|
||||
best_d = dist
|
||||
best = c
|
||||
return best
|
||||
|
||||
## The bear eats every bit of food in `target`. Tells anyone nearby.
|
||||
func raid(b: Node3D, target: Node3D) -> int:
|
||||
var eaten := 0
|
||||
var what := ""
|
||||
if target.get("inventory") != null:
|
||||
var inv: Inventory = target.inventory
|
||||
for i in range(inv.size()):
|
||||
var s = inv.get_slot(i)
|
||||
if s != null and is_food(s.id):
|
||||
eaten += int(s.count)
|
||||
inv.set_slot(i, null)
|
||||
what = "A bear has broken into your chest and eaten the food!"
|
||||
else:
|
||||
eaten = int(target.amount)
|
||||
target.collected()
|
||||
what = "A bear is eating the food you left out!"
|
||||
for p in world.players():
|
||||
if p.global_position.distance_to(target.global_position) < 80.0:
|
||||
Actions.tell(p, what)
|
||||
raided.emit(target, eaten)
|
||||
return eaten
|
||||
@@ -46,6 +46,12 @@ const KINDS := {
|
||||
"notice": 0.0, "notice_loud": 0.0, "calm": 40.0,
|
||||
"damage": 16.0, "attack_range": 2.1, "attack_cd": 1.4, "door_damage": 22.0,
|
||||
"drops": {"raw_meat": [2, 3], "alpha_pelt": [1, 1], "wolf_fang": [1, 2]}},
|
||||
# One bear per island, in the deep forest by the rim (bear.gd, bear_range.gd).
|
||||
# Slower than you sprinting, but it hits like a falling tree.
|
||||
"bear": {"name": "Bear", "hp": 220.0, "walk": 1.3, "run": 7.0, "turn": 3.5,
|
||||
"notice": 0.0, "notice_loud": 0.0, "calm": 40.0,
|
||||
"damage": 24.0, "attack_range": 2.3, "attack_cd": 1.8,
|
||||
"drops": {"raw_meat": [5, 7], "bear_hide": [1, 1], "bear_fat": [2, 3]}},
|
||||
}
|
||||
const CARCASS_SECONDS := 300.0
|
||||
|
||||
@@ -137,7 +143,7 @@ func setup(k: String, w: Node3D, pos: Vector3, seed: int) -> void:
|
||||
cs.position = Vector3(0, parts.height * 0.5, 0)
|
||||
if k != "rabbit":
|
||||
# Long bodies: lay the capsule along the spine.
|
||||
cap.height = {"deer": 1.5, "boar": 1.4, "wolf": 1.25, "alpha": 1.65}.get(k, 1.4)
|
||||
cap.height = {"deer": 1.5, "boar": 1.4, "wolf": 1.25, "alpha": 1.65, "bear": 2.0}.get(k, 1.4)
|
||||
cs.rotation.x = PI * 0.5
|
||||
cs.position = Vector3(0, parts.height * 0.55, 0)
|
||||
add_child(cs)
|
||||
|
||||
@@ -19,6 +19,7 @@ static func build(kind: String) -> Dictionary:
|
||||
"deer": d = _deer()
|
||||
"wolf": d = _wolf()
|
||||
"alpha": d = _wolf(true)
|
||||
"bear": d = _bear()
|
||||
_: d = _boar()
|
||||
_cache[kind] = d
|
||||
return d
|
||||
@@ -153,3 +154,27 @@ static func _wolf_parts(coat: Color, pale: Color, seed: int) -> Dictionary:
|
||||
return {"body": P._commit(st), "eyes": P._commit(est), "leg": _leg(0.52, 0.045, 0.03, coat, dark, seed + 1),
|
||||
"hips": [Vector3(-0.11, 0.52, -0.38), Vector3(0.11, 0.52, -0.38), Vector3(-0.11, 0.54, 0.38), Vector3(0.11, 0.54, 0.38)],
|
||||
"radius": 0.32, "height": 1.0}
|
||||
|
||||
## Brown bear: a heavy humped body, a broad head with a pale muzzle and
|
||||
## round ears, thick short legs.
|
||||
static func _bear() -> Dictionary:
|
||||
var coat := Color(0.36, 0.24, 0.15)
|
||||
var hump := Color(0.42, 0.29, 0.18)
|
||||
var muzzle := Color(0.58, 0.45, 0.32)
|
||||
var dark := Color(0.1, 0.08, 0.07)
|
||||
var st := P._begin()
|
||||
var r := _rng(261)
|
||||
var n := _noise(261, 1.3)
|
||||
P._blob(st, Vector3(0, 0.95, 0.15), Vector3(0.5, 0.5, 0.85), n, 0.14, coat, r, 1) # body
|
||||
P._blob(st, Vector3(0, 1.22, -0.35), Vector3(0.44, 0.38, 0.42), n, 0.18, hump, r, 1) # shoulder hump
|
||||
P._blob(st, Vector3(0, 1.05, -0.95), Vector3(0.3, 0.27, 0.3), n, 0.12, coat, r, 1) # head
|
||||
P._cylinder(st, Vector3(0, 0.98, -1.12), Vector3(0, 0.92, -1.36), 0.15, 0.1, 6, muzzle, r, -1.0, dark)
|
||||
for s in [-1.0, 1.0]:
|
||||
P._blob(st, Vector3(s * 0.2, 1.3, -0.9), Vector3(0.08, 0.08, 0.05), n, 0.1, P._mul(coat, 0.85), r, 0) # ears
|
||||
P._blob(st, Vector3(0, 0.98, 0.98), Vector3(0.08, 0.08, 0.07), n, 0.2, coat, r, 0) # stub tail
|
||||
var est := P._begin()
|
||||
for s in [-1.0, 1.0]:
|
||||
P._blob(est, Vector3(s * 0.13, 1.12, -1.18), Vector3.ONE * 0.025, n, 0.0, Color(0.9, 0.6, 0.25), r, 0)
|
||||
return {"body": P._commit(st), "eyes": P._commit(est), "leg": _leg(0.72, 0.13, 0.11, coat, dark, 262),
|
||||
"hips": [Vector3(-0.28, 0.72, -0.5), Vector3(0.28, 0.72, -0.5), Vector3(-0.28, 0.74, 0.6), Vector3(0.28, 0.74, 0.6)],
|
||||
"radius": 0.62, "height": 1.6}
|
||||
|
||||
Reference in New Issue
Block a user