The cyan bars stood on the faces and lost part of their length to the face on one side of the world, lit or unlit. The seam is now a line in the faces' own glow map, with a shallow channel in a new normal map. The plates take grain and blotches from the black metal and iron beam textures, and shine less.
217 lines
10 KiB
C#
217 lines
10 KiB
C#
using Jotunn.Managers;
|
|
using UnityEngine;
|
|
|
|
namespace RacesOfValheim
|
|
{
|
|
/// <summary>
|
|
/// The Ljoskjarne's body: a stone pyramid, 2 m to a side and 2 m tall, floating 0.5 m above the
|
|
/// ground. Dark steel carved with Valheim's own runes (the Ashlands rune tile's glyphs, laid out by
|
|
/// scripts/paint_nexus.py), and a cyan seam down the middle of each face.
|
|
///
|
|
/// The seam is painted into the faces' glow map, not built. Bars standing on the faces, lit or
|
|
/// unlit, lost part of their length to the face on whichever side looked one way in the world,
|
|
/// as the pyramid turned; a line in the face's own pixels has nothing to hide behind.
|
|
///
|
|
/// Only the look moves. The piece keeps one still collider from the ground up, so building on it,
|
|
/// support, hovering and the E key behave as before; the pyramid bobs and turns on each client by
|
|
/// itself, nothing over the network. The seam breathes, and burns brighter while crystals wait.
|
|
/// </summary>
|
|
public static class AlfarNexusLook
|
|
{
|
|
private const float Height = 2f;
|
|
private const float HalfBase = 1f;
|
|
private const float Lift = 0.5f;
|
|
private const string SourceMaterialPrefab = "piece_cartographytable";
|
|
private const string EmbersSource = "fx_Torch_Carried";
|
|
|
|
private static readonly Color Seam = new Color(0.35f, 0.75f, 1f);
|
|
|
|
/// <summary>Strips the cartography table's body and puts the pyramid in its place. False leaves
|
|
/// the table, with a warning, so the Nexus is never invisible.</summary>
|
|
public static bool Build(GameObject prefab)
|
|
{
|
|
Texture2D face = PieceLook.LoadTexture("AlfarNexus_face.png");
|
|
Texture2D glow = PieceLook.LoadTexture("AlfarNexus_glow.png");
|
|
Texture2D bumps = PieceLook.LoadTexture("AlfarNexus_n.png", true);
|
|
Renderer tableRenderer = prefab.transform.Find("new/high")?.GetComponent<Renderer>();
|
|
if (face == null || glow == null || tableRenderer == null || tableRenderer.sharedMaterial == null)
|
|
{
|
|
Jotunn.Logger.LogWarning("[Alfar] Could not build the Ljoskjarne's pyramid; it keeps the cartography table's look.");
|
|
return false;
|
|
}
|
|
|
|
Material stone = new Material(tableRenderer.sharedMaterial) { name = "AlfarNexus_stone" };
|
|
stone.color = Color.white;
|
|
stone.SetTexture("_MainTex", face);
|
|
// Forged, not polished: the plate's own grain in the normal map, and a dull sheen.
|
|
stone.SetTexture("_BumpMap", bumps);
|
|
if (bumps != null) stone.EnableKeyword("_NORMALMAP");
|
|
else stone.DisableKeyword("_NORMALMAP");
|
|
if (stone.HasProperty("_MetallicGlossMap")) stone.SetTexture("_MetallicGlossMap", null);
|
|
if (stone.HasProperty("_Metallic")) stone.SetFloat("_Metallic", 0.6f);
|
|
if (stone.HasProperty("_Glossiness")) stone.SetFloat("_Glossiness", 0.3f);
|
|
// Custom/Piece samples its noise in world space unless told the object moves, as boats and
|
|
// carts do; on a turning pyramid the blotches would slide across the faces.
|
|
stone.EnableKeyword("_MOVEABLEOBJECT_ON");
|
|
if (stone.HasProperty("_MoveableObject")) stone.SetFloat("_MoveableObject", 1f);
|
|
stone.SetTexture("_EmissionMap", glow);
|
|
stone.EnableKeyword("_EMISSION");
|
|
stone.SetColor("_EmissionColor", Seam);
|
|
|
|
// The table goes whole: its meshes, its damage states, its fragments and its four colliders.
|
|
for (int i = prefab.transform.childCount - 1; i >= 0; i--)
|
|
Object.DestroyImmediate(prefab.transform.GetChild(i).gameObject);
|
|
WearNTear wear = prefab.GetComponent<WearNTear>();
|
|
if (wear != null)
|
|
{
|
|
wear.m_new = null;
|
|
wear.m_worn = null;
|
|
wear.m_broken = null;
|
|
wear.m_fragmentRoots = new GameObject[0];
|
|
}
|
|
|
|
// One still collider, from the ground to the tip, a little inside the faces.
|
|
GameObject solid = new GameObject("collider") { layer = prefab.layer };
|
|
solid.transform.SetParent(prefab.transform, false);
|
|
BoxCollider box = solid.AddComponent<BoxCollider>();
|
|
box.center = new Vector3(0f, (Lift + Height) / 2f, 0f);
|
|
box.size = new Vector3(HalfBase * 1.4f, Lift + Height, HalfBase * 1.4f);
|
|
|
|
Transform floating = new GameObject("float").transform;
|
|
floating.SetParent(prefab.transform, false);
|
|
floating.gameObject.layer = prefab.layer;
|
|
|
|
MeshRenderer pyramid = Part(floating, "pyramid", PyramidMesh(), stone).GetComponent<MeshRenderer>();
|
|
|
|
NexusLook look = prefab.AddComponent<NexusLook>();
|
|
look.Float = floating;
|
|
look.SeamRenderer = pyramid;
|
|
look.Motes = AddMotes(prefab.transform);
|
|
return true;
|
|
}
|
|
|
|
private static GameObject Part(Transform parent, string name, Mesh mesh, Material material)
|
|
{
|
|
GameObject part = new GameObject(name) { layer = parent.gameObject.layer };
|
|
part.transform.SetParent(parent, false);
|
|
part.AddComponent<MeshFilter>().sharedMesh = mesh;
|
|
part.AddComponent<MeshRenderer>().sharedMaterial = material;
|
|
return part;
|
|
}
|
|
|
|
private static Vector3 Apex => new Vector3(0f, Lift + Height, 0f);
|
|
|
|
private static Vector3[] BaseCorners => new[]
|
|
{
|
|
new Vector3(-HalfBase, Lift, -HalfBase), new Vector3(HalfBase, Lift, -HalfBase),
|
|
new Vector3(HalfBase, Lift, HalfBase), new Vector3(-HalfBase, Lift, HalfBase),
|
|
};
|
|
|
|
/// <summary>Four faces, each with its own three corners so the shading stays flat and every face
|
|
/// shows the whole carving (u along the base, v = 1 at the tip), and the underside.</summary>
|
|
private static Mesh PyramidMesh()
|
|
{
|
|
Vector3[] c = BaseCorners;
|
|
var vertices = new Vector3[16];
|
|
var uvs = new Vector2[16];
|
|
var triangles = new int[18];
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
// Wound clockwise seen from outside, which is Unity's front face.
|
|
vertices[i * 3] = c[(i + 1) % 4];
|
|
vertices[i * 3 + 1] = c[i];
|
|
vertices[i * 3 + 2] = Apex;
|
|
uvs[i * 3] = new Vector2(1f, 0f);
|
|
uvs[i * 3 + 1] = new Vector2(0f, 0f);
|
|
uvs[i * 3 + 2] = new Vector2(0.5f, 1f);
|
|
triangles[i * 3] = i * 3;
|
|
triangles[i * 3 + 1] = i * 3 + 1;
|
|
triangles[i * 3 + 2] = i * 3 + 2;
|
|
}
|
|
for (int i = 0; i < 4; i++) { vertices[12 + i] = c[i]; uvs[12 + i] = new Vector2(0.1f, 0.02f); }
|
|
int[] under = { 12, 13, 14, 12, 14, 15 };
|
|
System.Array.Copy(under, 0, triangles, 12, 6);
|
|
|
|
Mesh mesh = new Mesh { name = "AlfarNexus_pyramid", vertices = vertices, uv = uvs, triangles = triangles };
|
|
mesh.RecalculateNormals();
|
|
mesh.RecalculateBounds();
|
|
return mesh;
|
|
}
|
|
|
|
/// <summary>A few cyan motes drifting up from the ground under it: the torch's embers, recoloured,
|
|
/// spread over the pyramid's shadow and slowed down.</summary>
|
|
private static ParticleSystem AddMotes(Transform root)
|
|
{
|
|
GameObject torch = PrefabManager.Cache.GetPrefab<GameObject>(EmbersSource);
|
|
Transform source = torch != null ? torch.transform.Find("Embers") : null;
|
|
if (source == null) return null;
|
|
|
|
GameObject motes = Object.Instantiate(source.gameObject, root, false);
|
|
motes.name = "motes";
|
|
motes.transform.localPosition = new Vector3(0f, 0.05f, 0f);
|
|
motes.transform.localRotation = Quaternion.identity;
|
|
PieceLook.Rehue(motes.transform, Seam * 2f);
|
|
|
|
ParticleSystem particles = motes.GetComponent<ParticleSystem>();
|
|
if (particles != null)
|
|
{
|
|
ParticleSystem.ShapeModule shape = particles.shape;
|
|
shape.enabled = true;
|
|
shape.shapeType = ParticleSystemShapeType.Circle;
|
|
shape.radius = HalfBase;
|
|
shape.rotation = new Vector3(-90f, 0f, 0f);
|
|
ParticleSystem.MainModule main = particles.main;
|
|
main.simulationSpeed = 0.5f;
|
|
}
|
|
return particles;
|
|
}
|
|
|
|
/// <summary>The motion and the seam's light, per client.</summary>
|
|
public class NexusLook : MonoBehaviour
|
|
{
|
|
public Transform Float;
|
|
public Renderer SeamRenderer;
|
|
public ParticleSystem Motes;
|
|
|
|
private const float BobHeight = 0.08f;
|
|
private const float BobSeconds = 4.5f;
|
|
private const float TurnSeconds = 40f;
|
|
private const float BreathSeconds = 3.5f;
|
|
|
|
private AlfarNexusBehaviour m_nexus;
|
|
private Material m_seam;
|
|
private float m_phase;
|
|
private float m_ready; // eases between 0 (no crystals) and 1, so the brightening is not a jump
|
|
|
|
private void Awake()
|
|
{
|
|
m_nexus = GetComponent<AlfarNexusBehaviour>();
|
|
if (SeamRenderer != null) m_seam = SeamRenderer.material; // this one's own copy, to animate
|
|
// Two Nexuses side by side must not bob in step.
|
|
m_phase = (Mathf.Abs(transform.position.x * 0.37f + transform.position.z * 0.71f)) % 10f;
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
float t = Time.time + m_phase;
|
|
if (Float != null)
|
|
{
|
|
Float.localPosition = new Vector3(0f, Mathf.Sin(t * 2f * Mathf.PI / BobSeconds) * BobHeight, 0f);
|
|
Float.localRotation = Quaternion.Euler(0f, t * 360f / TurnSeconds, 0f);
|
|
}
|
|
|
|
if (m_seam == null) return;
|
|
bool ready = m_nexus != null && m_nexus.Crystals > 0;
|
|
m_ready = Mathf.MoveTowards(m_ready, ready ? 1f : 0f, Time.deltaTime * 0.5f);
|
|
float breath = 0.75f + 0.25f * Mathf.Sin(t * 2f * Mathf.PI / BreathSeconds);
|
|
Color glow = Seam * breath * Mathf.Lerp(1f, 2.2f, m_ready);
|
|
m_seam.SetColor("_EmissionColor", glow);
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if (m_seam != null) Destroy(m_seam);
|
|
}
|
|
}
|
|
}
|
|
}
|