MrMaho/MSCO
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Beta Release

Browse Source
This commit is contained in:
MrMaho
2026-09-26 19:37:28 +02:00
parent adca4d9167
commit e77ccf2f33
29 changed files with 6819 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files
RemotePlayer.cs
+315 -13
View File
@@ -1,29 +1,331 @@
using UnityEngine;
using UnityEngine;
namespace MSCO
{
/// <summary>Bewegt den anderen Spieler weich zur zuletzt empfangenen Position.</summary>
/// <summary>
/// Figur eines Mitspielers mit echter Körperhaltung. Aus Kopfposition (Kamera) und Bodenhöhe wird
/// jedes Frame die Pose berechnet: Ducken beugt die Knie, nach vorne Lehnen neigt den Oberkörper,
/// Laufen bewegt Beine und Arme, beim Halten greift der rechte Arm (mit Ellbogen) zum Item, im Auto
/// sitzt die Figur. Die Körperteile sind abgerundete Kapseln zwischen den Gelenken.
/// </summary>
public class RemotePlayer : MonoBehaviour
{
Vector3 targetPos;
float targetRotY;
const float Smoothing = 15f;
const float StandingEyeHeight = 1.65f;
const float MaxHeadPitch = 55f;
// Körpermaße (Meter)
const float ThighLength = 0.45f, ShinLength = 0.45f;
const float UpperArmLength = 0.3f, ForearmLength = 0.29f;
const float TorsoLength = 0.55f; // Hüfte bis Hals
const float HipWidth = 0.1f, ShoulderWidth = 0.21f;
const float AnkleHeight = 0.07f;
static readonly Color Skin = new Color(0.93f, 0.76f, 0.62f);
static readonly Color Jeans = new Color(0.18f, 0.25f, 0.42f);
static readonly Color Boots = new Color(0.24f, 0.16f, 0.1f);
static readonly Color Dark = new Color(0.08f, 0.08f, 0.08f);
Color jacket;
Transform headPivot, view;
Transform pelvis, torso, belt, neck;
readonly Transform[] thigh = new Transform[2], shin = new Transform[2], boot = new Transform[2];
readonly Transform[] upperArm = new Transform[2], forearm = new Transform[2], hand = new Transform[2];
Vector3 targetFeet;
Vector3 targetHead;
Vector3 headWorld;
float targetYaw, targetPitch, pitch;
Quaternion targetViewRot = Quaternion.identity;
PlayerState last;
Vector3 lastPosition;
float walkPhase, walkAmount, speed;
// Echtes Spielmodell (NPC aus der Szene); null = eigene Figur als Rückfall
GameCharacter model;
public int HeldId { get { return last.HeldId; } }
public PlayerState LastState { get { return last; } }
public Vector3 HeadPosition { get { return model != null ? model.HeadPosition : headPivot.position; } }
public string ModelDescription { get { return model != null ? "game model: " + model.Description : "fallback figure (no NPC template found)"; } }
// ---------------------------------------------------------------- Aufbau
public static RemotePlayer Create(string name, Color jacketColor, PlayerState state, int variant)
{
var root = new GameObject(name);
var rp = root.AddComponent<RemotePlayer>();
rp.jacket = jacketColor;
rp.Build();
rp.SetTarget(state);
root.transform.position = rp.targetFeet;
root.transform.rotation = Quaternion.Euler(0f, rp.targetYaw, 0f);
// Wenn möglich einen echten NPC aus dem Spiel als Figur nehmen, sonst die eigene Figur
try { rp.model = GameCharacter.TryCreate(root.transform, variant); }
catch (System.Exception e) { MSCLoader.ModConsole.Warning("[MSCO] Game model failed: " + e.Message); }
if (rp.model != null)
foreach (Renderer r in root.GetComponentsInChildren<Renderer>(true))
if (!r.transform.IsChildOf(rp.model.Root)) r.enabled = false;
rp.headWorld = rp.targetHead;
rp.pitch = rp.targetPitch;
rp.view.rotation = rp.targetViewRot;
rp.lastPosition = root.transform.position;
if (rp.model == null) rp.Pose(0f);
return rp;
}
void Build()
{
Transform r = transform;
Color jacketDark = jacket * 0.75f;
jacketDark.a = 1f;
pelvis = Capsule("Pelvis", r, Jeans);
torso = Capsule("Torso", r, jacket);
belt = Capsule("Belt", r, Dark);
neck = Capsule("Neck", r, Skin);
for (int i = 0; i < 2; i++)
{
thigh[i] = Capsule("Thigh", r, Jeans);
shin[i] = Capsule("Shin", r, Jeans);
boot[i] = Box("Boot", r, Boots);
upperArm[i] = Capsule("UpperArm", r, jacket);
forearm[i] = Capsule("Forearm", r, jacketDark);
hand[i] = Sphere("Hand", r, Skin, 0.1f);
}
// Kopf: dreht mit Blick (hoch/runter), Gesicht nach +Z
headPivot = new GameObject("Head").transform;
headPivot.SetParent(r, false);
Transform skull = Sphere("Skull", headPivot, Skin, 0.24f);
skull.localScale = new Vector3(0.22f, 0.26f, 0.24f);
Transform hair = Sphere("Hair", headPivot, new Color(0.25f, 0.17f, 0.1f), 0.24f);
hair.localPosition = new Vector3(0f, 0.02f, -0.025f);
hair.localScale = new Vector3(0.23f, 0.25f, 0.23f);
Transform cap = Sphere("Cap", headPivot, jacketDark, 0.25f);
cap.localPosition = new Vector3(0f, 0.07f, -0.005f);
cap.localScale = new Vector3(0.245f, 0.16f, 0.255f);
Transform brim = Box("CapBrim", headPivot, jacketDark);
brim.localPosition = new Vector3(0f, 0.075f, 0.13f);
brim.localScale = new Vector3(0.2f, 0.02f, 0.11f);
brim.localRotation = Quaternion.Euler(-8f, 0f, 0f);
for (int i = 0; i < 2; i++)
{
Transform eye = Sphere("Eye", headPivot, Dark, 0.035f);
eye.localPosition = new Vector3(i == 0 ? -0.045f : 0.045f, 0.015f, 0.105f);
}
Transform nose = Box("Nose", headPivot, Skin * 0.95f);
nose.localPosition = new Vector3(0f, -0.02f, 0.12f);
nose.localScale = new Vector3(0.035f, 0.05f, 0.04f);
// Unsichtbarer "Blick" mit der exakten Kameradrehung - daran hängt das gehaltene Item
view = new GameObject("View").transform;
view.SetParent(r, false);
}
static Transform Capsule(string name, Transform parent, Color color) { return Primitive(PrimitiveType.Capsule, name, parent, color); }
static Transform Box(string name, Transform parent, Color color) { return Primitive(PrimitiveType.Cube, name, parent, color); }
static Transform Sphere(string name, Transform parent, Color color, float size)
{
Transform t = Primitive(PrimitiveType.Sphere, name, parent, color);
t.localScale = Vector3.one * size;
return t;
}
static Transform Primitive(PrimitiveType type, string name, Transform parent, Color color)
{
GameObject go = GameObject.CreatePrimitive(type);
go.name = name;
Destroy(go.GetComponent<Collider>()); // stört sonst Physik/Trigger
var renderer = go.GetComponent<Renderer>();
renderer.material.color = color;
renderer.receiveShadows = true;
go.transform.SetParent(parent, false);
return go.transform;
}
// ---------------------------------------------------------------- Zustand
public void SetTarget(PlayerState state)
{
targetPos = state.Position;
targetRotY = state.RotationY;
last = state;
targetHead = state.CamPos;
// Füße: Bodenhöhe vom Spieler, waagerecht an der Spielerposition (Lehnen = Kopf woanders als Füße).
// Liegt der Kopf unplausibel weit weg (andere Kamera), Füße unter den Kopf.
float feetY = state.FeetY != 0f ? state.FeetY : state.CamPos.y - StandingEyeHeight;
var feet = new Vector3(state.Position.x, feetY, state.Position.z);
var horizontal = new Vector3(state.CamPos.x - feet.x, 0f, state.CamPos.z - feet.z);
if (horizontal.sqrMagnitude > 0.8f * 0.8f || state.Seated) feet = new Vector3(state.CamPos.x, feetY, state.CamPos.z);
targetFeet = feet;
// Blickrichtung ohne seitliches Kippen
Vector3 forward = state.CamRot * Vector3.forward;
Vector3 flat = new Vector3(forward.x, 0f, forward.z);
targetYaw = flat.sqrMagnitude > 0.0001f ? Quaternion.LookRotation(flat).eulerAngles.y : state.RotationY;
targetPitch = Mathf.Clamp(-Mathf.Asin(Mathf.Clamp(forward.y, -1f, 1f)) * Mathf.Rad2Deg, -MaxHeadPitch, MaxHeadPitch);
targetViewRot = state.CamRot;
}
public void Tick(float dt)
{
// Bei großen Sprüngen (Teleport, Laden) direkt setzen statt gleiten
if ((transform.position - targetPos).sqrMagnitude > 100f)
transform.position = targetPos;
else
transform.position = Vector3.Lerp(transform.position, targetPos, dt * 15f);
bool snap = (transform.position - targetFeet).sqrMagnitude > 100f;
float t = snap ? 1f : Mathf.Clamp01(dt * Smoothing);
transform.rotation = Quaternion.Slerp(transform.rotation,
Quaternion.Euler(0f, targetRotY, 0f), dt * 15f);
transform.position = Vector3.Lerp(transform.position, targetFeet, t);
transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.Euler(0f, targetYaw, 0f), t);
headWorld = snap ? targetHead : Vector3.Lerp(headWorld, targetHead, t);
pitch = Mathf.Lerp(pitch, targetPitch, t);
view.position = headWorld;
view.rotation = Quaternion.Slerp(view.rotation, targetViewRot, t);
UpdateWalk(dt);
if (model != null) model.Animate(speed); // Spiel-Animation (Idle/Walk) läuft vor LateUpdate
else Pose(dt);
}
/// <summary>Spielmodell: nach der Animation Ducken/Lehnen/Kopf/Arme anpassen.</summary>
void LateUpdate()
{
if (model == null) return;
Vector3 heldPos;
Quaternion heldRot;
bool holding = TryGetHeldPose(out heldPos, out heldRot);
model.Pose(transform, headWorld, pitch, last.Seated, holding, heldPos);
}
void UpdateWalk(float dt)
{
Vector3 moved = transform.position - lastPosition;
lastPosition = transform.position;
moved.y = 0f;
speed = dt > 0f ? moved.magnitude / dt : 0f;
if (speed > 12f || last.Seated) speed = 0f; // Teleport oder im Auto
walkAmount = Mathf.Lerp(walkAmount, Mathf.Clamp01(speed / 2.5f), Mathf.Clamp01(dt * 8f));
walkPhase += speed * dt * 3.4f;
}
// ---------------------------------------------------------------- Pose (alles im lokalen Raum der Figur)
void Pose(float dt)
{
Vector3 head = transform.InverseTransformPoint(headWorld) + new Vector3(0f, -0.02f, -0.03f);
Vector3 neckTop = head + new Vector3(0f, -0.12f, -0.01f);
Vector3 neckBase = head + new Vector3(0f, -0.2f, -0.02f);
// Hüfte: beim Lehnen nach hinten ausweichen, beim Ducken absinken (Füße bleiben am Boden)
Vector3 hip;
if (last.Seated)
{
hip = neckBase + new Vector3(0f, -TorsoLength, -0.08f);
}
else
{
var lean = new Vector3(neckBase.x, 0f, neckBase.z);
hip = -lean * 0.25f;
float horizontal = (new Vector3(neckBase.x - hip.x, 0f, neckBase.z - hip.z)).magnitude;
float vertical = Mathf.Sqrt(Mathf.Max(0.04f, TorsoLength * TorsoLength - horizontal * horizontal));
hip.y = Mathf.Clamp(neckBase.y - vertical, 0.3f, ThighLength + ShinLength + AnkleHeight - 0.02f);
}
Vector3 up = (neckBase - hip).normalized;
Vector3 right = Vector3.right;
Vector3 forward = Vector3.Cross(right, up).normalized;
// Rumpf
Segment(torso, hip + up * 0.08f, neckBase, 0.38f, 0.24f);
Segment(belt, hip + up * 0.06f, hip + up * 0.1f, 0.37f, 0.23f);
Segment(pelvis, hip - right * HipWidth, hip + right * HipWidth, 0.2f, 0.22f);
Segment(neck, neckBase, neckTop, 0.09f, 0.09f);
// Kopf
headPivot.localPosition = head;
headPivot.localRotation = Quaternion.Euler(pitch, 0f, 0f);
float swing = Mathf.Sin(walkPhase) * walkAmount;
for (int i = 0; i < 2; i++)
{
float side = i == 0 ? -1f : 1f;
float phase = i == 0 ? swing : -swing;
// Beine
Vector3 hipJoint = hip + right * (HipWidth * side);
Vector3 ankle;
if (last.Seated)
ankle = hipJoint + new Vector3(0f, -0.4f, 0.48f);
else
ankle = new Vector3(HipWidth * side, AnkleHeight + Mathf.Max(0f, Mathf.Cos(walkPhase + i * Mathf.PI)) * 0.07f * walkAmount, phase * 0.3f);
Vector3 knee = Joint(hipJoint, ankle, ThighLength, ShinLength, Vector3.forward);
Segment(thigh[i], hipJoint, knee, 0.17f, 0.17f);
Segment(shin[i], knee, ankle, 0.14f, 0.14f);
boot[i].localPosition = ankle + new Vector3(0f, -0.02f, 0.05f);
boot[i].localRotation = Quaternion.identity;
boot[i].localScale = new Vector3(0.12f, 0.1f, 0.27f);
// Arme
Vector3 shoulder = neckBase - up * 0.06f + right * (ShoulderWidth * side);
Vector3 handTarget;
Vector3 heldPos;
Quaternion heldRot;
if (i == 1 && TryGetHeldPose(out heldPos, out heldRot))
handTarget = transform.InverseTransformPoint(heldPos);
else if (last.Seated)
handTarget = shoulder + new Vector3(-side * 0.05f, -0.3f, 0.38f); // Hände nach vorne (Lenkrad)
else
handTarget = shoulder + new Vector3(side * 0.03f, -(UpperArmLength + ForearmLength) + 0.04f, -phase * 0.22f);
// Nicht weiter als die Armlänge
Vector3 reach = handTarget - shoulder;
float maxReach = UpperArmLength + ForearmLength - 0.01f;
if (reach.magnitude > maxReach) handTarget = shoulder + reach.normalized * maxReach;
Vector3 elbow = Joint(shoulder, handTarget, UpperArmLength, ForearmLength, new Vector3(side * 0.4f, -0.2f, -1f));
Segment(upperArm[i], shoulder, elbow, 0.12f, 0.12f);
Segment(forearm[i], elbow, handTarget, 0.11f, 0.11f);
hand[i].localPosition = handTarget;
}
}
/// <summary>Zwei-Knochen-Gelenk (Knie/Ellbogen): Punkt zwischen a und b, zur Seite "bend" geknickt.</summary>
static Vector3 Joint(Vector3 a, Vector3 b, float lengthA, float lengthB, Vector3 bend)
{
Vector3 ab = b - a;
float d = Mathf.Clamp(ab.magnitude, 0.01f, lengthA + lengthB - 0.001f);
Vector3 dir = ab.normalized;
// Abstand vom Startpunkt entlang ab und seitlicher Abstand (Kosinussatz)
float along = (lengthA * lengthA - lengthB * lengthB + d * d) / (2f * d);
float sideways = Mathf.Sqrt(Mathf.Max(0f, lengthA * lengthA - along * along));
Vector3 bendDir = bend - dir * Vector3.Dot(bend, dir);
if (bendDir.sqrMagnitude < 0.0001f) bendDir = Vector3.forward - dir * Vector3.Dot(Vector3.forward, dir);
return a + dir * along + bendDir.normalized * sideways;
}
/// <summary>Kapsel von a nach b spannen (lokaler Raum der Figur).</summary>
static void Segment(Transform part, Vector3 a, Vector3 b, float width, float depth)
{
Vector3 dir = b - a;
float length = dir.magnitude;
part.localPosition = (a + b) * 0.5f;
part.localRotation = length > 0.0001f ? Quaternion.FromToRotation(Vector3.up, dir / length) : Quaternion.identity;
part.localScale = new Vector3(width, length * 0.5f + Mathf.Min(width, depth) * 0.5f, depth);
}
/// <summary>Wo das gehaltene Item beim Spieler gerade ist (relativ zum Blick).</summary>
public bool TryGetHeldPose(out Vector3 pos, out Quaternion rot)
{
pos = Vector3.zero;
rot = Quaternion.identity;
if (last.HeldId == 0) return false;
pos = view.TransformPoint(last.HeldLocalPos);
rot = view.rotation * last.HeldLocalRot;
return true;
}
}
}
}