using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Scripting;

namespace NecromancerTome
{
	/// <summary>
	/// Дух-работник урны - «джинн из урны» (решение 16.10): кончик хвоста уходит в горлышко, дух вырастает над урной,
	/// без работы висит, чуть покачиваясь и медленно поворачиваясь. Этап 3 некротехнолога.
	///
	/// Не сущность игры, а видимая модель - дочерний объект модели блока урны, как каркас зоны (решение 16.10 вместо
	/// плана 15.10 «сущность на префабе медсестры»): хитбокса, ИИ и сохранения у неё нет, поэтому «убить нельзя»,
	/// «зомби не замечают», «сквозь стены» выходят сами, а сейвы дух не трогает - он появляется по черепу в урне
	/// (TEFeatureCinerarium.HasSkull) и пропадает без него. Сдвиги Origin и выгрузку чанка переживает с моделью урны.
	///
	/// Модель - бандл necrotechnologist (NecroTechnologistSetup.cs): своя сетка на своём скелете NT_rig в позе покоя,
	/// глаза - отдельные рендереры (в имени «eye»). Тело - светящаяся дымка (16.10: Fade давал пятна; сложение One/One,
	/// холодный оттенок Tint, своё слабое свечение Glow); текстура уже серая (сделана под обесцвечивание). Глаза - свой
	/// непрозрачный светящийся материал из бандла, очередь отрисовки 3100 - после тела.
	/// </summary>
	public static class CinerariumGenie
	{
		public const string ModelPath = "#@modfolder(NecromancerTome):Resources/necrotechnologist?necroTechnologistPrefab.prefab";

		/// <summary>Высота корня модели над низом блока урны, м. 16.10 в Blender по модели урны: -0.15 («духа чуть приподними»).
		/// Подгоняется командой necrogenie.</summary>
		public static float OffsetY = -0.15f;
		/// <summary>Сдвиг вперёд в системе самого духа, м (16.10: «чуть вперёд, чтобы хвост не просвечивал сквозь урну сзади»
		/// - загнутый назад кончик хвоста; в Blender 0.06 - ни одной вершины за стенкой, взято 0.07). Поворачивается вместе
		/// с духом, поэтому хвост всегда в горлышке. Знак проверить в игре: necrogenie fwd.</summary>
		public static float Forward = 0.07f;
		/// <summary>Поворот без работы, градусов в секунду.</summary>
		public static float TurnSpeed = 6f;
		/// <summary>Покачивание: размах (м) и период (с).</summary>
		public static float BobHeight = 0.04f;
		public static float BobPeriod = 4f;
		public static float Alpha = 0.3f;
		/// <summary>Засыпание (16.10): игрок дальше SleepDistance - дух замирает дома, огоньки нитей стоят. Работа идёт.</summary>
		public static float SleepDistance = 40f;
		public static bool Hidden;

		/// <summary>Далеко ли игрок от точки сцены (без Origin). Для засыпания духа и нитей.</summary>
		public static bool PlayerFar(Vector3 _scenePos)
		{
			EntityPlayerLocal pl = GameManager.Instance?.World?.GetPrimaryPlayer();
			if (pl == null)
			{
				return true;
			}
			return (pl.GetPosition() - Origin.position - _scenePos).sqrMagnitude > SleepDistance * SleepDistance;
		}
		/// <summary>Руки (16.10: «Т-поза бесит»): плечо от вертикали вбок и вперёд, локоть согнут вперёд, градусы.
		/// Модель в позе покоя, аниматора нет - кости ставятся один раз при появлении.</summary>
		public static float ArmOut = 12f;
		public static float ArmFwd = 15f;
		public static float Elbow = 35f;
		/// <summary>Покой (17.10: «в покое руки нужно скрестить на груди»): плечо вниз-вперёд на CrossFwd, предплечье поперёк
		/// груди к другому боку, одно на CrossLift выше другого, чтобы не проходили друг сквозь друга. Жест - из этой позы и назад.</summary>
		public static bool Cross = true;
		public static float CrossFwd = 25f;
		public static float CrossLift = 0.12f;

		static GameObject _prefab;
		static bool _tried;
		static readonly Dictionary<Material, Material> _ghostMats = new Dictionary<Material, Material>();
		/// <summary>Все джинны на сцене - команда necrogenie правит их сразу.</summary>
		public static readonly List<CinerariumGenieMotion> Live = new List<CinerariumGenieMotion>();

		static bool Load()
		{
			if (!_tried)
			{
				_tried = true;
				_prefab = DataLoader.LoadAsset<GameObject>(ModelPath);
				Debug.Log("[NecromancerTome] CinerariumGenie: модель " + (_prefab != null ? "загружена" : "НЕ загружена: " + ModelPath));
			}
			return _prefab != null;
		}

		public static GameObject Spawn(Transform _urnModel)
		{
			if (_urnModel == null || !Load())
			{
				return null;
			}
			GameObject g = Object.Instantiate(_prefab, _urnModel, false);
			g.name = "NecroCinerariumGenie";
			foreach (Renderer r in g.GetComponentsInChildren<Renderer>(true))
			{
				r.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
				r.receiveShadows = false;
				if (r is SkinnedMeshRenderer smr)
				{
					smr.updateWhenOffscreen = false;   // 16.10: вне экрана скелет не считать (экономия); границы - от сетки
				}
				if (r.name.Contains("eye"))
				{
					continue;
				}
				Material[] mats = r.sharedMaterials;
				for (int i = 0; i < mats.Length; i++)
				{
					mats[i] = Ghost(mats[i]);
				}
				r.sharedMaterials = mats;
			}
			foreach (Collider c in g.GetComponentsInChildren<Collider>(true))
			{
				Object.Destroy(c);
			}
			g.AddComponent<CinerariumGenieMotion>().Pose();
			return g;
		}

		/// <summary>Полупрозрачная копия материала тела - одна на исходный материал на всю игру.</summary>
		static Material Ghost(Material _src)
		{
			if (_src == null)
			{
				return null;
			}
			if (_ghostMats.TryGetValue(_src, out Material m) && m != null)
			{
				return m;
			}
			m = new Material(_src) { name = _src.name + "_ghost" };
			Shader std = Shader.Find("Standard");
			if (std != null && m.shader != std)
			{
				m.shader = std;
			}
			// 16.10: Fade (SrcAlpha/OneMinusSrcAlpha) давал «прозрачный, но какими-то пятнами» и «не выглядит бесплотным
			// духом»: без записи глубины треугольники одной сетки ложатся в случайном порядке. Свечение (One/One) от порядка
			// не зависит: дух только добавляет свет к тому, что за ним, - дымка. Альфа здесь не нужна, яркость - цветом.
			m.SetFloat("_Mode", 2f);
			m.SetOverrideTag("RenderType", "Transparent");
			m.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
			m.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
			m.SetInt("_ZWrite", 0);
			m.DisableKeyword("_ALPHATEST_ON");
			m.DisableKeyword("_ALPHABLEND_ON");
			m.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			if (m.HasProperty("_Glossiness"))
			{
				m.SetFloat("_Glossiness", 0f);   // без бликов: блик при сложении - белое пятно
			}
			if (m.HasProperty("_Metallic"))
			{
				m.SetFloat("_Metallic", 0f);
			}
			if (m.HasProperty("_EmissionMap") && m.HasProperty("_MainTex"))
			{
				m.SetTexture("_EmissionMap", m.GetTexture("_MainTex"));   // своё свечение - чтобы ночью не пропадал
				m.EnableKeyword("_EMISSION");
				m.globalIlluminationFlags = MaterialGlobalIlluminationFlags.None;
			}
			m.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
			SetLook(m);
			_ghostMats[_src] = m;
			return m;
		}

		/// <summary>Холодный бледный оттенок духа (умножается на серую текстуру).</summary>
		public static Color Tint = new Color(0.55f, 0.75f, 1f, 1f);
		/// <summary>Своё свечение тела, доля от Tint.</summary>
		public static float Glow = 0.35f;

		static void SetLook(Material _m)
		{
			if (_m == null)
			{
				return;
			}
			if (_m.HasProperty("_Color"))
			{
				_m.color = new Color(Tint.r * Alpha, Tint.g * Alpha, Tint.b * Alpha, 1f);
			}
			if (_m.HasProperty("_EmissionColor"))
			{
				_m.SetColor("_EmissionColor", new Color(Tint.r * Glow, Tint.g * Glow, Tint.b * Glow, 1f));
			}
		}

		public static void ApplyAlpha()
		{
			foreach (Material m in _ghostMats.Values)
			{
				SetLook(m);
			}
		}

		static readonly Dictionary<Material, Material> _stuckMats = new Dictionary<Material, Material>();

		/// <summary>Почерневший дух (класть некуда): свечением чёрное не нарисовать, поэтому обычная Fade-копия, тёмная.</summary>
		public static Material Stuck(Material _src)
		{
			if (_src == null)
			{
				return null;
			}
			if (_stuckMats.TryGetValue(_src, out Material m) && m != null)
			{
				return m;
			}
			m = new Material(_src) { name = _src.name + "_stuck" };
			Shader std = Shader.Find("Standard");
			if (std != null && m.shader != std)
			{
				m.shader = std;
			}
			m.SetFloat("_Mode", 2f);
			m.SetOverrideTag("RenderType", "Transparent");
			m.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
			m.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
			m.SetInt("_ZWrite", 1);   // с глубиной: пятен нет, тёмный и почти плотный
			m.DisableKeyword("_ALPHATEST_ON");
			m.EnableKeyword("_ALPHABLEND_ON");
			m.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			m.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
			if (m.HasProperty("_Color"))
			{
				m.color = new Color(0.04f, 0.035f, 0.045f, 0.8f);
			}
			_stuckMats[_src] = m;
			return m;
		}

		/// <summary>Исходный материал тела по его светящейся копии.</summary>
		public static Material Source(Material _ghost)
		{
			foreach (KeyValuePair<Material, Material> p in _ghostMats)
			{
				if (p.Value == _ghost)
				{
					return p.Key;
				}
			}
			return _ghost;
		}
	}

	/// <summary>Покачивание и поворот джинна над урной. Только вид - никакой логики.</summary>
	[Preserve]
	public class CinerariumGenieMotion : MonoBehaviour
	{
		float _yaw;
		float _phase;
		/// <summary>Полёт к месту работы и обратно (16.10: «возвращается задом», «делал действие не сразу, а хоть руками
		/// пошевелив»): туда - лицом к месту, над местом - жест руками (дело делается в его середине, см. Visit),
		/// обратно - развернувшись лицом к урне. Точка - в координатах модели урны; _t - время с начала полёта, -1 - дома.</summary>
		struct Stop
		{
			public Vector3 Hover, Look;   // в осях модели урны
			public float Fly;
		}

		readonly List<Stop> _stops = new List<Stop>();
		float _backFly;
		float _t = -1f;
		/// <summary>Скорость полёта, м/с: время перелёта - не меньше OutSeconds/BackSeconds, дальше - по расстоянию (нити до 15 м).</summary>
		public static float FlySpeed = 4f;
		public static float OutSeconds = 1.3f;
		public static float WorkSeconds = 1.6f;
		public static float BackSeconds = 1.3f;
		/// <summary>Жест: плечи вперёд до GestureFwd градусов, локти ходят на ±GestureWave вразнобой.</summary>
		public static float GestureFwd = 55f;
		public static float GestureWave = 30f;
		bool _gesturing;
		/// <summary>Почернел и замер (готовое класть некуда, решение 06.10).</summary>
		bool _stuck;
		/// <summary>Кости рук (плечо, предплечье, кисть по сторонам) и их поворот в позе покоя.</summary>
		Transform[] _arm;
		Quaternion[] _armRest;
		static bool _armLogged;

		/// <summary>Опустить руки из позы покоя: направление плеча и предплечья задаётся в осях модели (вперёд - +Z),
		/// поворот - от текущего направления кости к нужному, так что оси самих костей значения не имеют.</summary>
		public void Pose()
		{
			Pose(CinerariumGenie.ArmFwd, CinerariumGenie.Elbow, CinerariumGenie.Elbow, CinerariumGenie.Cross ? 1f : 0f);
		}

		/// <summary>_cross - доля скрещённой позы (1 - руки на груди, 0 - опущены/жест), направления смешиваются.</summary>
		void Pose(float _fwd, float _elbowL, float _elbowR, float _cross)
		{
			if (_arm == null)
			{
				string[] names = { "LeftArm", "LeftForeArm", "LeftHand", "RightArm", "RightForeArm", "RightHand" };
				_arm = new Transform[names.Length];
				_armRest = new Quaternion[names.Length];
				foreach (Transform t in GetComponentsInChildren<Transform>(true))
				{
					for (int i = 0; i < names.Length; i++)
					{
						if (_arm[i] == null && t.name.EndsWith(names[i]))
						{
							_arm[i] = t;
							_armRest[i] = t.localRotation;
						}
					}
				}
				if (!_armLogged)
				{
					_armLogged = true;
					System.Text.StringBuilder sb = new System.Text.StringBuilder();
					for (int i = 0; i < names.Length; i++)
					{
						sb.Append(names[i]).Append('=').Append(_arm[i] != null ? "ok" : "НЕТ").Append(' ');
					}
					Debug.Log("[NecromancerTome] CinerariumGenie: кости рук " + sb);
				}
			}
			for (int i = 0; i < _arm.Length; i++)
			{
				if (_arm[i] != null)
				{
					_arm[i].localRotation = _armRest[i];
				}
			}
			for (int side = 0; side < 2; side++)
			{
				Transform up = _arm[side * 3], fore = _arm[side * 3 + 1], hand = _arm[side * 3 + 2];
				if (up == null || fore == null || hand == null)
				{
					continue;
				}
				float sign = Mathf.Sign(transform.InverseTransformPoint(up.position).x);
				float o = CinerariumGenie.ArmOut * Mathf.Deg2Rad, f = _fwd * Mathf.Deg2Rad;
				Vector3 upDir = new Vector3(sign * Mathf.Sin(o), -Mathf.Cos(o) * Mathf.Cos(f), Mathf.Sin(f)).normalized;
				Vector3 foreDir = Vector3.RotateTowards(upDir, Vector3.forward, (side == 0 ? _elbowL : _elbowR) * Mathf.Deg2Rad, 0f);
				if (_cross > 0f)
				{
					float cf = CinerariumGenie.CrossFwd * Mathf.Deg2Rad;
					Vector3 crossUp = new Vector3(sign * 0.12f, -Mathf.Cos(cf), Mathf.Sin(cf)).normalized;
					Vector3 crossFore = new Vector3(-sign * 0.85f, side == 0 ? CinerariumGenie.CrossLift : -CinerariumGenie.CrossLift, 0.45f).normalized;
					upDir = Vector3.Slerp(upDir, crossUp, _cross);
					foreDir = Vector3.Slerp(foreDir, crossFore, _cross);
				}
				up.rotation = Quaternion.FromToRotation(fore.position - up.position, transform.TransformDirection(upDir)) * up.rotation;
				fore.rotation = Quaternion.FromToRotation(hand.position - fore.position, transform.TransformDirection(foreDir)) * fore.rotation;
			}
		}

		/// <summary>Светящиеся материалы рендереров - вернуть после почернения.</summary>
		readonly Dictionary<Renderer, Material[]> _glowing = new Dictionary<Renderer, Material[]>();

		/// <summary>Облёт мест работы по порядку (у перевозки по нити - ящик «откуда», потом «куда»), у каждого - жест, затем
		/// назад к урне. Точки - в координатах сцены (без Origin): stand - где встать (низ клетки), look - низ клетки места,
		/// beside - встал сбоку, а не над местом. Возвращает, через сколько секунд дело (середина последнего жеста).</summary>
		public float Visit(List<(Vector3 stand, Vector3 look, bool beside)> _list)
		{
			if (transform.parent == null || _list == null || _list.Count == 0)
			{
				return 0f;
			}
			_stops.Clear();
			Vector3 home = Home();
			Vector3 prev = home;
			float delay = 0f;
			foreach ((Vector3 stand, Vector3 look, bool beside) in _list)
			{
				Stop st = new Stop
				{
					Hover = transform.parent.InverseTransformPoint(stand) + new Vector3(0f, CinerariumGenie.OffsetY + (beside ? 0.15f : 0.8f), 0f),
					Look = transform.parent.InverseTransformPoint(look)
				};
				st.Fly = Mathf.Max(OutSeconds, Vector3.Distance(prev, st.Hover) / FlySpeed);
				delay += st.Fly + WorkSeconds;
				prev = st.Hover;
				_stops.Add(st);
			}
			_backFly = Mathf.Max(BackSeconds, Vector3.Distance(prev, home) / FlySpeed);
			_t = 0f;
			return delay - WorkSeconds * 0.5f;
		}

		Vector3 Home()
		{
			return new Vector3(0f, CinerariumGenie.OffsetY, 0f) + Quaternion.Euler(0f, _yaw, 0f) * new Vector3(0f, 0f, CinerariumGenie.Forward);
		}

		/// <summary>Повернуться лицом по направлению _dir (горизонтально), не быстрее 300°/с.</summary>
		void Face(Vector3 _dir)
		{
			if (_dir.x * _dir.x + _dir.z * _dir.z > 0.01f)
			{
				_yaw = Mathf.MoveTowardsAngle(_yaw, Mathf.Atan2(_dir.x, _dir.z) * Mathf.Rad2Deg, 300f * Time.deltaTime) % 360f;
			}
		}

		void Gesture(float _w)
		{
			if (_w > 0f)
			{
				float wave = Mathf.Sin(_t * Mathf.PI * 2f * 1.5f) * GestureWave * _w;
				Pose(Mathf.Lerp(CinerariumGenie.ArmFwd, GestureFwd, _w), CinerariumGenie.Elbow + 15f * _w + wave, CinerariumGenie.Elbow + 15f * _w - wave,
				     CinerariumGenie.Cross ? 1f - _w : 0f);
				_gesturing = true;
			}
			else if (_gesturing)
			{
				Pose();
				_gesturing = false;
			}
		}

		public void SetStuck(bool _on)
		{
			if (_stuck == _on)
			{
				return;
			}
			_stuck = _on;
			foreach (Renderer r in GetComponentsInChildren<Renderer>(true))
			{
				if (r.name.Contains("eye"))
				{
					continue;
				}
				if (!_glowing.ContainsKey(r))
				{
					_glowing[r] = r.sharedMaterials;
				}
				Material[] glow = _glowing[r];
				if (_on)
				{
					Material[] dark = new Material[glow.Length];
					for (int i = 0; i < glow.Length; i++)
					{
						dark[i] = CinerariumGenie.Stuck(CinerariumGenie.Source(glow[i]));
					}
					r.sharedMaterials = dark;
				}
				else
				{
					r.sharedMaterials = glow;
				}
			}
		}

		void OnEnable()
		{
			CinerariumGenie.Live.Add(this);
			_phase = Random.value * 10f;
			_yaw = Random.value * 360f;
		}

		void OnDisable()
		{
			CinerariumGenie.Live.Remove(this);
		}

		float _nextSleepCheck;
		bool _asleep;
		bool _hiddenApplied;

		void Update()
		{
			if (Time.time >= _nextSleepCheck)
			{
				_nextSleepCheck = Time.time + 0.5f;
				bool asleep = CinerariumGenie.PlayerFar(transform.position);
				if (asleep && !_asleep)
				{
					_t = -1f;   // полёт прерван - дело всё равно выполнится
					Gesture(0f);
					transform.localPosition = Home();
				}
				_asleep = asleep;
				if (_hiddenApplied != CinerariumGenie.Hidden)
				{
					// Только при смене (16.10, проверка на утечки: раньше список рендереров собирался каждые 0.5 с - мусор для GC).
					_hiddenApplied = CinerariumGenie.Hidden;
					foreach (Renderer r in GetComponentsInChildren<Renderer>(true))
					{
						r.enabled = !_hiddenApplied;
					}
				}
			}
			if (_stuck || _asleep)
			{
				return;   // замер как был
			}
			float yawTarget = _yaw + CinerariumGenie.TurnSpeed * Time.deltaTime;
			Vector3 home = Home();
			if (_t >= 0f && _stops.Count > 0)
			{
				_t += Time.deltaTime;
				float acc = 0f;
				Vector3 from = home;
				foreach (Stop st in _stops)
				{
					if (_t < acc + st.Fly)
					{
						transform.localPosition = Vector3.Lerp(from, st.Hover, Mathf.SmoothStep(0f, 1f, (_t - acc) / st.Fly));
						Face(st.Hover - from);
						Gesture(0f);
						transform.localRotation = Quaternion.Euler(0f, _yaw, 0f);
						return;
					}
					acc += st.Fly;
					if (_t < acc + WorkSeconds)
					{
						transform.localPosition = st.Hover;
						Face(st.Look - st.Hover);   // за работой - лицом к месту
						Gesture(Mathf.Sin((_t - acc) / WorkSeconds * Mathf.PI));
						transform.localRotation = Quaternion.Euler(0f, _yaw, 0f);
						return;
					}
					acc += WorkSeconds;
					from = st.Hover;
				}
				if (_t < acc + _backFly)
				{
					transform.localPosition = Vector3.Lerp(from, home, Mathf.SmoothStep(0f, 1f, (_t - acc) / _backFly));
					Face(home - from);   // назад - лицом к урне
					Gesture(0f);
					transform.localRotation = Quaternion.Euler(0f, _yaw, 0f);
					return;
				}
				_t = -1f;
				Gesture(0f);
			}
			_yaw = yawTarget % 360f;
			float bob = CinerariumGenie.BobPeriod > 0.01f
				? Mathf.Sin((Time.time + _phase) * Mathf.PI * 2f / CinerariumGenie.BobPeriod) * CinerariumGenie.BobHeight
				: 0f;
			transform.localPosition = home + new Vector3(0f, bob, 0f);
			transform.localRotation = Quaternion.Euler(0f, _yaw, 0f);
		}
	}

	/// <summary>Подгонка джинна в игре: высота над урной, скорость поворота, покачивание, прозрачность. Не сохраняется -
	/// найденные значения переносятся в константы CinerariumGenie.</summary>
	[Preserve]
	public class ConsoleCmdNecroGenie : ConsoleCmdAbstract
	{
		public override bool IsExecuteOnClient => true;

		public override bool AllowedInMainMenu => false;

		public override string[] getCommands()
		{
			return new string[] { "necrogenie" };
		}

		public override string getDescription()
		{
			return "Necromancer's Tome: tune the cinerarium spirit (height over the urn, turning, bobbing, transparency).";
		}

		public override string getHelp()
		{
			return "necrogenie              - show the current values and how many spirits are on screen\n" +
			       "necrogenie y <m>        - model root height above the urn block's bottom (tail tip is 0.47 m above the root)\n" +
			       "necrogenie fwd <m>      - shift along the spirit's own forward (keeps the curled tail inside the neck)\n" +
			       "necrogenie turn <deg/s> - idle turning speed\n" +
			       "necrogenie bob <m> <s>  - bobbing height and period\n" +
			       "necrogenie alpha <0-1>  - body brightness (the body adds light, it is not alpha-blended)\n" +
			       "necrogenie glow <0-1>   - body's own glow (visible at night)\n" +
			       "necrogenie tint <r> <g> <b> - body colour\n" +
			       "necrogenie arms <out> <fwd> <elbow> - arm pose, degrees: upper arm from vertical sideways and forward, elbow bend\n" +
			       "necrogenie cross <0|1> [fwd] [lift] - arms crossed on the chest at rest (1) or hanging (0); upper arm forward, degrees; forearm height offset\n" +
			       "necrogenie sleep <m>    - spirits and threads freeze when the player is farther (work goes on)\n" +
			       "necrogenie hide|show    - hide all spirits (weak PCs, video), work goes on";
		}

		public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
		{
			SdtdConsole con = SingletonMonoBehaviour<SdtdConsole>.Instance;
			if (_params.Count == 1 && (_params[0] == "hide" || _params[0] == "show"))
			{
				CinerariumGenie.Hidden = _params[0] == "hide";
			}
			if (_params.Count >= 2 && float.TryParse(_params[1], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out float v))
			{
				switch (_params[0].ToLowerInvariant())
				{
					case "y":
						CinerariumGenie.OffsetY = v;
						break;
					case "fwd":
						CinerariumGenie.Forward = v;
						break;
					case "turn":
						CinerariumGenie.TurnSpeed = v;
						break;
					case "bob":
						CinerariumGenie.BobHeight = v;
						if (_params.Count >= 3 && float.TryParse(_params[2], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out float per))
						{
							CinerariumGenie.BobPeriod = per;
						}
						break;
					case "alpha":
						CinerariumGenie.Alpha = Mathf.Clamp01(v);
						CinerariumGenie.ApplyAlpha();
						break;
					case "glow":
						CinerariumGenie.Glow = Mathf.Clamp01(v);
						CinerariumGenie.ApplyAlpha();
						break;
					case "sleep":
						CinerariumGenie.SleepDistance = Mathf.Max(5f, v);
						break;
					case "arms":
						CinerariumGenie.ArmOut = v;
						if (_params.Count >= 3 && float.TryParse(_params[2], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out float af))
						{
							CinerariumGenie.ArmFwd = af;
						}
						if (_params.Count >= 4 && float.TryParse(_params[3], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out float ae))
						{
							CinerariumGenie.Elbow = ae;
						}
						foreach (CinerariumGenieMotion m in CinerariumGenie.Live)
						{
							m.Pose();
						}
						break;
					case "cross":
						CinerariumGenie.Cross = v != 0f;
						if (_params.Count >= 3 && float.TryParse(_params[2], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out float cf))
						{
							CinerariumGenie.CrossFwd = cf;
						}
						if (_params.Count >= 4 && float.TryParse(_params[3], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out float cl))
						{
							CinerariumGenie.CrossLift = cl;
						}
						foreach (CinerariumGenieMotion m in CinerariumGenie.Live)
						{
							m.Pose();
						}
						break;
					case "tint":
						if (_params.Count >= 4 &&
						    float.TryParse(_params[2], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out float g) &&
						    float.TryParse(_params[3], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out float b))
						{
							CinerariumGenie.Tint = new Color(v, g, b, 1f);
							CinerariumGenie.ApplyAlpha();
						}
						break;
					default:
						con.Output("necrogenie: unknown '" + _params[0] + "' - see 'help necrogenie'");
						return;
				}
			}
			con.Output("necrogenie: y " + CinerariumGenie.OffsetY.ToString("F2") + ", fwd " + CinerariumGenie.Forward.ToString("F2") + ", turn " + CinerariumGenie.TurnSpeed.ToString("F1") +
			           ", bob " + CinerariumGenie.BobHeight.ToString("F2") + " / " + CinerariumGenie.BobPeriod.ToString("F1") + " s, alpha " +
			           CinerariumGenie.Alpha.ToString("F2") + ", glow " + CinerariumGenie.Glow.ToString("F2") + ", tint " +
			           CinerariumGenie.Tint.r.ToString("F2") + " " + CinerariumGenie.Tint.g.ToString("F2") + " " + CinerariumGenie.Tint.b.ToString("F2") + ", arms " + CinerariumGenie.ArmOut.ToString("F0") + " " +
			           CinerariumGenie.ArmFwd.ToString("F0") + " " + CinerariumGenie.Elbow.ToString("F0") + ", sleep " + CinerariumGenie.SleepDistance.ToString("F0") + " m" + (CinerariumGenie.Hidden ? ", HIDDEN" : "") + "; spirits on screen: " + CinerariumGenie.Live.Count);
		}
	}
}