/*
  Skins: flat faces, 3D cube heads and the full 3D player model, painted from the 64×64 (or legacy
  64×32) skin texture with background-position. --skin is set by head.js once the texture loaded.
  Texture pixel (u, v) of a face is at background-position (-u·px, -v·px), background-size 64·px.
*/

/* ------------------------------------------------------------------ flat face */

.face {
  --s: 24px;
  position: relative;
  display: inline-block;
  flex: none;
  width: var(--s);
  height: var(--s);
  overflow: hidden;
  border-radius: max(2px, calc(var(--s) / 12));
  /* Placeholder: a quiet blank head with two pixel eyes (shown while loading, or when no skin works). */
  background:
    linear-gradient(var(--head-empty-ink), var(--head-empty-ink)) 25% 62.5% / 12.5% 12.5% no-repeat,
    linear-gradient(var(--head-empty-ink), var(--head-empty-ink)) 75% 62.5% / 12.5% 12.5% no-repeat,
    var(--head-empty);
  vertical-align: middle;
}

.face::before,
.face::after {
  content: "";
  position: absolute;
  inset: 0;
  background-image: var(--skin, none);
  background-repeat: no-repeat;
  background-size: calc(var(--s) * 8) auto;
  image-rendering: pixelated;
  opacity: 0;
  transition: opacity 220ms ease;
}

/* base face: texture (8, 8) */
.face::before {
  background-position: calc(var(--s) * -1) calc(var(--s) * -1);
}

/* hat layer: texture (40, 8) */
.face::after {
  background-position: calc(var(--s) * -5) calc(var(--s) * -1);
}

.face.is-ready::before,
.face.is-ready::after {
  opacity: 1;
}

.face.no-hat::after {
  display: none;
}

/* A hairline ring: a dark skin (black hair, a dark hood) keeps its edge on the dark background. */
.face.is-ready {
  box-shadow: inset 0 0 0 1px var(--face-ring);
}

.face.is-ready::after {
  z-index: 0;
}

.face--ring {
  box-shadow: 0 0 0 2px var(--bg);
}

.face-stack {
  display: inline-flex;
  align-items: center;
  padding-left: 6px;
}

.face-stack__item {
  margin-left: -6px;
}

/* ------------------------------------------------------------------ 3D cube head */

.cube {
  --s: 64px;
  --px: calc(var(--s) / 8);
  --rest: -28deg;
  position: relative;
  display: inline-block;
  flex: none;
  width: var(--s);
  height: var(--s);
  perspective: calc(var(--s) * 9);
  vertical-align: middle;
}

/* A drop shadow lifts dark skins off the background; a soft contact shadow grounds the head. */
/* (on the perspective box, not on a preserve-3d layer: a filter there would flatten the cube) */
.cube.is-ready {
  filter: drop-shadow(0 calc(var(--s) / 9) calc(var(--s) / 7) var(--cube-shadow));
}

.cube__shadow {
  position: absolute;
  left: 15%;
  right: 15%;
  bottom: calc(var(--s) * -0.2);
  height: calc(var(--s) * 0.16);
  border-radius: 50%;
  background: radial-gradient(closest-side, var(--cube-shadow), transparent);
  pointer-events: none;
}

.cube__spin,
.cube__rig,
.cube__layer {
  position: absolute;
  inset: 0;
  transform-style: preserve-3d;
}

.cube__spin {
  transform: rotateY(var(--rest));
}

.cube__rig {
  transform: rotateX(calc(-14deg + var(--tx, 0deg))) rotateY(var(--ty, 0deg));
  transition: transform 420ms var(--ease-out);
}

.cube--live .cube__spin {
  animation: cube-sway 9s ease-in-out infinite alternate;
}

.cube.is-hover .cube__spin,
.body.is-hover .body__spin {
  animation-play-state: paused;
}

@keyframes cube-sway {
  from {
    transform: rotateY(-36deg);
  }
  to {
    transform: rotateY(36deg);
  }
}

.cube__layer--hat {
  transform: scale3d(1.125, 1.125, 1.125);
}

.cf {
  position: absolute;
  inset: 0;
  background-image: var(--skin, none);
  background-repeat: no-repeat;
  background-size: calc(var(--s) * 8) auto;
  background-position: calc(var(--u) * var(--px) * -1) calc(var(--v) * var(--px) * -1);
  image-rendering: pixelated;
  backface-visibility: hidden;
}

.cube__layer--base .cf {
  background-color: var(--head-empty);
}

.cf--front { --u: 8; --v: 8; transform: translateZ(calc(var(--s) / 2)); }
.cf--back { --u: 24; --v: 8; transform: rotateY(180deg) translateZ(calc(var(--s) / 2)); }
.cf--right { --u: 0; --v: 8; transform: rotateY(-90deg) translateZ(calc(var(--s) / 2)); }
.cf--left { --u: 16; --v: 8; transform: rotateY(90deg) translateZ(calc(var(--s) / 2)); }
.cf--top { --u: 8; --v: 0; transform: rotateX(90deg) translateZ(calc(var(--s) / 2)); }
.cf--bottom { --u: 16; --v: 0; transform: rotateX(-90deg) translateZ(calc(var(--s) / 2)); }

.cube__layer--hat .cf--front { --u: 40; }
.cube__layer--hat .cf--back { --u: 56; }
.cube__layer--hat .cf--right { --u: 32; }
.cube__layer--hat .cf--left { --u: 48; }
.cube__layer--hat .cf--top { --u: 40; }
.cube__layer--hat .cf--bottom { --u: 48; }

/* Light from above, like in-game: sides a little darker, the underside darkest. */
.cf--right,
.cf--left,
.bf--right,
.bf--left {
  filter: brightness(0.8);
}

.cf--back,
.bf--back {
  filter: brightness(0.7);
}

.cf--top,
.bf--top {
  filter: brightness(1.08);
}

.cf--bottom,
.bf--bottom {
  filter: brightness(0.55);
}

.cube:not(.is-ready) .cube__layer--hat,
.cube.no-hat .cube__layer--hat {
  display: none;
}

/* ------------------------------------------------------------------ 3D player model */

.body {
  --px: 7px;
  --rest: -24deg;
  position: relative;
  display: inline-block;
  flex: none;
  width: calc(var(--px) * 16);
  height: calc(var(--px) * 32);
  perspective: calc(var(--px) * 180);
}

.body__spin,
.body__rig {
  position: absolute;
  inset: 0;
  transform-style: preserve-3d;
}

.body__spin {
  transform: rotateY(var(--rest));
}

.body--live .body__spin {
  animation: body-sway 14s ease-in-out infinite alternate;
}

@keyframes body-sway {
  from {
    transform: rotateY(-40deg);
  }
  to {
    transform: rotateY(40deg);
  }
}

.body__rig {
  transform: rotateX(calc(-6deg + var(--tx, 0deg))) rotateY(var(--ty, 0deg));
  transition: transform 480ms var(--ease-out);
}

.body__shadow {
  position: absolute;
  left: 4%;
  right: 4%;
  bottom: calc(var(--px) * -2.2);
  height: calc(var(--px) * 3.4);
  border-radius: 50%;
  background: radial-gradient(closest-side, rgb(0 0 0 / 0.5), rgb(0 0 0 / 0));
}

:root[data-theme="light"] .body__shadow {
  background: radial-gradient(closest-side, rgb(40 20 70 / 0.22), rgb(40 20 70 / 0));
}

.bp {
  position: absolute;
  left: calc(var(--x) * var(--px));
  top: calc(var(--y) * var(--px));
  width: calc(var(--w) * var(--px));
  height: calc(var(--h) * var(--px));
  transform-style: preserve-3d;
}

/* A relaxed idle pose: arms a few degrees out from the shoulders. */
.bp--arm-r {
  transform: rotateZ(5deg);
  transform-origin: 100% 0;
}

.bp--arm-l {
  transform: rotateZ(-5deg);
  transform-origin: 0 0;
}

.bl {
  position: absolute;
  inset: 0;
  transform-style: preserve-3d;
}

.bl--outer {
  transform: scale3d(var(--sx), var(--sy), var(--sz));
}

.bf {
  position: absolute;
  left: 0;
  top: 0;
  width: calc(var(--fw) * var(--px));
  height: calc(var(--fh) * var(--px));
  background-image: var(--skin, none);
  background-repeat: no-repeat;
  background-size: calc(var(--px) * 64) auto;
  background-position: calc(var(--fu) * var(--px) * -1) calc(var(--fv) * var(--px) * -1);
  image-rendering: pixelated;
  backface-visibility: hidden;
}

.bl--base .bf {
  background-color: var(--head-empty);
}

.bf--front { transform: translateZ(calc(var(--d) * var(--px) / 2)); }
.bf--back { transform: rotateY(180deg) translateZ(calc(var(--d) * var(--px) / 2)); }
.bf--right { left: calc((var(--w) - var(--d)) * var(--px) / 2); transform: rotateY(-90deg) translateZ(calc(var(--w) * var(--px) / 2)); }
.bf--left { left: calc((var(--w) - var(--d)) * var(--px) / 2); transform: rotateY(90deg) translateZ(calc(var(--w) * var(--px) / 2)); }
.bf--top { top: calc((var(--h) - var(--d)) * var(--px) / 2); transform: rotateX(90deg) translateZ(calc(var(--h) * var(--px) / 2)); }
.bf--bottom { top: calc((var(--h) - var(--d)) * var(--px) / 2); transform: rotateX(-90deg) translateZ(calc(var(--h) * var(--px) / 2)); }

/* Legacy 64×32 skins: left limbs reuse the right ones, and only the hat has an outer layer. */
.body.is-legacy .bf {
  background-position: calc(var(--lu) * var(--px) * -1) calc(var(--lv) * var(--px) * -1);
}

.body:not(.is-ready) .bl--outer,
.body.is-legacy .bp:not(.bp--head) .bl--outer,
.body.no-hat .bp--head .bl--outer {
  display: none;
}

@media (prefers-reduced-motion: reduce) {
  .cube__spin {
    transform: rotateY(var(--rest)) !important;
  }

  .body__spin {
    transform: rotateY(var(--rest)) !important;
  }
}