path: root/source/game/StarSky.cpp

#include "StarSky.hpp"
#include "StarJsonExtra.hpp"
#include "StarDataStreamExtra.hpp"
#include "StarRoot.hpp"
#include "StarCelestialDatabase.hpp"
#include "StarCelestialGraphics.hpp"
#include "StarAssets.hpp"
#include "StarTime.hpp"
#include "StarRandomPoint.hpp"
#include "StarMixer.hpp"
#include "StarCompression.hpp"

namespace Star {

Sky::Sky() {
  skyParametersUpdated();

  m_netInit = false;

  m_netGroup.addNetElement(&m_skyParametersNetState);
  m_netGroup.addNetElement(&m_skyTypeNetState);
  m_netGroup.addNetElement(&m_timeNetState);
  m_netGroup.addNetElement(&m_flyingTypeNetState);
  m_netGroup.addNetElement(&m_enterHyperspaceNetState);
  m_netGroup.addNetElement(&m_startInWarpNetState);
  m_netGroup.addNetElement(&m_worldMoveNetState);
  m_netGroup.addNetElement(&m_starMoveNetState);
  m_netGroup.addNetElement(&m_warpPhaseNetState);
  m_netGroup.addNetElement(&m_flyingTimerNetState);

  m_netGroup.setNeedsLoadCallback(bind(&Sky::readNetStates, this));
  m_netGroup.setNeedsStoreCallback(bind(&Sky::writeNetStates, this));
}

Sky::Sky(SkyParameters const& skyParameters, bool inOrbit) : Sky() {
  m_skyParameters = skyParameters;
  skyParametersUpdated();

  if (inOrbit)
    m_skyType = SkyType::Orbital;
  else
    m_skyType = m_skyParameters.skyType;
}

void Sky::startFlying(bool enterHyperspace, bool startInWarp, Json settings) {
  if (startInWarp)
    m_flyingType = FlyingType::Warp;
  else
    m_flyingType = FlyingType::Disembarking;

  m_flyingTimer = 0;
  m_enterHyperspace = enterHyperspace;
  m_startInWarp = startInWarp;
  if (settings.isType(Json::Type::Object)) {
    m_skyParameters.settings = settings;
    skyParametersUpdated();
  }
}

void Sky::stopFlyingAt(Maybe<SkyParameters> dest) {
  m_destWorld = dest;
}

void Sky::jumpTo(SkyParameters skyParameters) {
  m_skyParameters = skyParameters;
  skyParametersUpdated();
}

pair<ByteArray, uint64_t> Sky::writeUpdate(uint64_t fromVersion, NetCompatibilityRules rules) {
  return m_netGroup.writeNetState(fromVersion, rules);
}

void Sky::readUpdate(ByteArray data, NetCompatibilityRules rules) {
  m_netGroup.readNetState(std::move(data), 0.0f, rules);
}

void Sky::stateUpdate() {
  if (m_lastFlyingType != m_flyingType) {
    m_flyingTimer = 0.0f;

    if (m_flyingType == FlyingType::Warp) {
      m_warpPhase = WarpPhase::SpeedingUp;
      if (m_startInWarp) {
        if (m_enterHyperspace)
          m_warpPhase = WarpPhase::Maintain;
        else
          m_flyingTimer = speedupTime();

        m_lastWarpPhase = m_warpPhase;
      }

      float maxVelocity = m_settings.queryFloat("flyMaxVelocity");
      m_worldMoveOffset = Vec2F::withAngle(m_pathRotation, maxVelocity / 2.0 * speedupTime());
      m_starMoveOffset = Vec2F::withAngle(0, (maxVelocity * m_settings.queryFloat("starVelocityFactor")) / 2.0 * speedupTime());
    } else if (m_flyingType == FlyingType::Arriving) {
      m_sentSFX = false;

      m_worldOffset = {};
      m_starOffset = {};
    }
  }

  if (m_lastWarpPhase != m_warpPhase) {
    m_flyingTimer = 0.0f;

    if (m_warpPhase == WarpPhase::SpeedingUp)
      m_sentSFX = false;
    else if (m_warpPhase == WarpPhase::Maintain)
      enterHyperspace();
    else if (m_warpPhase == WarpPhase::SlowingDown)
      exitHyperspace();
  }

  m_lastFlyingType = m_flyingType;
  m_lastWarpPhase = m_warpPhase;
}

void Sky::update(double dt) {
  if (m_referenceClock) {
    m_time = m_referenceClock->time();
    if (!m_clockTrackingTime) {
      m_clockTrackingTime = m_time;
    } else {
      // If our reference clock is set, and we have a valid tracking time, then
      // the dt should be driven by the reference clock.
      dt = m_time - *m_clockTrackingTime;
      m_clockTrackingTime = m_time;
    }
  } else {
    m_time += dt;
  }

  m_flashTimer = std::max(0.0, m_flashTimer - dt);

  if (flying()) {
    m_flyingTimer += dt;

    if (m_flyingType == FlyingType::Disembarking) {
      bool finished;
      if (m_skyParameters.skyType == SkyType::Space)
        finished = controlledMovement(m_settings.getArray("spaceDisembarkPath"), m_settings.get("spaceDisembarkOrigin"), m_flyingTimer);
      else
        finished = controlledMovement(m_settings.getArray("disembarkPath"), m_settings.get("disembarkOrigin"), m_flyingTimer);

      if (finished) {
        m_flyingType = FlyingType::Warp;
      }
    } else if (m_flyingType == FlyingType::Arriving) {
      bool finished;
      if (m_skyParameters.skyType == SkyType::Space)
        finished = controlledMovement(m_settings.getArray("spaceArrivalPath"), m_settings.get("spaceArrivalOrigin"), m_flyingTimer);
      else
        finished = controlledMovement(m_settings.getArray("arrivalPath"), m_settings.get("arrivalOrigin"), m_flyingTimer);

      if (finished) {
        m_flyingType = FlyingType::None;
      }

      m_starOffset -= m_starOffset * m_settings.queryFloat("correctionPower");
      m_worldOffset -= m_worldOffset * m_settings.queryFloat("correctionPower");
    } else if (m_flyingType == FlyingType::Warp) {
      float percentage = 0.0;
      float dir = (int)m_warpPhase < 0 ? -1.0 : 1.0;
      if (m_warpPhase == WarpPhase::SpeedingUp)
        percentage = powf(m_flyingTimer / speedupTime(), 2.0);
      else if (m_warpPhase == WarpPhase::Maintain)
        percentage = 1.0;
      else if (m_warpPhase == WarpPhase::SlowingDown)
        percentage = powf(1 - m_flyingTimer / slowdownTime(), 2.0);

      if (percentage < 1.0) {
        m_starOffset = (dir * m_starMoveOffset * percentage).rotate(-getStarRotation());
        m_worldOffset = (dir * m_worldMoveOffset * percentage).rotate(-getWorldRotation());
      } else {
        m_starOffset += Vec2F::withAngle(-getStarRotation(), m_settings.queryFloat("flyMaxVelocity") * dt * m_settings.queryFloat("starVelocityFactor"));
        m_worldOffset = m_worldMoveOffset;
      }

      if (m_warpPhase == WarpPhase::SpeedingUp && m_flyingTimer >= speedupTime()
          && !m_enterHyperspace
          && m_destWorld) {
        jumpTo(m_destWorld.take());
        m_warpPhase = WarpPhase::SlowingDown;
      } else if (m_warpPhase == WarpPhase::SpeedingUp && m_flyingTimer >= speedupTime() && m_enterHyperspace) {
        m_warpPhase = WarpPhase::Maintain;
      } else if (m_warpPhase == WarpPhase::Maintain && m_flyingTimer >= m_settings.queryFloat("flyingTimer")
          && m_destWorld) {
        jumpTo(m_destWorld.take());
        m_warpPhase = WarpPhase::SlowingDown;
      } else if (m_warpPhase == WarpPhase::SlowingDown && m_flyingTimer >= slowdownTime()) {
        m_flyingType = FlyingType::Arriving;
      }
    }
  } else {
    m_starOffset = {};
    m_worldOffset = {};
    m_pathOffset = {};
    m_worldRotation = m_pathRotation = 0;
  }

  stateUpdate();

  if (!flying())
    m_starRotation = constrainAngle(m_starRotation + dt / dayLength() * 2 * Constants::pi);
  else
    m_starRotation = 0;
}

void Sky::setType(SkyType skyType) {
  m_skyType = skyType;
}

SkyType Sky::type() const {
  return m_skyType;
}

bool Sky::inSpace() const {
  return m_skyType == SkyType::Orbital || m_skyType == SkyType::Warp || m_skyType == SkyType::Space;
}

uint64_t Sky::seed() const {
  return m_skyParameters.seed;
}

float Sky::dayLength() const {
  return m_skyParameters.dayLength.value(DefaultDayLength);
}

uint32_t Sky::day() const {
  if (!m_skyParameters.dayLength)
    return 0;
  return floor(epochTime() / dayLength());
}

float Sky::timeOfDay() const {
  if (!m_skyParameters.dayLength)
    return 0;
  return fmod(epochTime(), (double)dayLength());
}

double Sky::epochTime() const {
  return m_time;
}

void Sky::setEpochTime(double epochTime) {
  m_time = epochTime;
}

float Sky::altitude() const {
  return m_altitude;
}

void Sky::setAltitude(float altitude) {
  m_altitude = altitude;
}

void Sky::setReferenceClock(ClockConstPtr const& referenceClock) {
  m_referenceClock = referenceClock;
  m_time = m_referenceClock->time();
  m_clockTrackingTime = {};
}

ClockConstPtr Sky::referenceClock() const {
  return m_referenceClock;
}

String Sky::ambientNoise() const {
  if (flying()) {
    if (m_flyingType == FlyingType::Warp && m_warpPhase == WarpPhase::Maintain) {
      return m_settings.queryString("hyperspaceAudio");
    } else {
      return m_settings.queryString("engineAudio");
    }
  }

  return "";
}

List<AudioInstancePtr> Sky::pullSounds() {
  List<AudioInstancePtr> res;
  if (m_flyingType == FlyingType::Warp) {
    if (m_warpPhase == WarpPhase::SpeedingUp && !m_sentSFX) {
      float triggerTime = speedupTime() - m_settings.queryFloat("enterHyperspaceAudioLeadIn");
      if (triggerTime < 0 || !m_enterHyperspace) {
        m_sentSFX = true;
        return res;
      }

      if (m_flyingTimer >= triggerTime) {
        auto assets = Root::singleton().assets();
        auto SFX = assets->audio(m_settings.queryString("enterHyperspaceAudio"));
        m_sentSFX = true;
        res.append(make_shared<AudioInstance>(*SFX));
        return res;
      }
    } else if (m_warpPhase == WarpPhase::Maintain && !m_sentSFX) {
      float triggerTime = m_settings.queryFloat("flyingTimer") - m_settings.queryFloat("exitHyperspaceAudioLeadIn");
      if (triggerTime < 0) {
        m_sentSFX = true;
        return res;
      }

      if (m_flyingTimer >= triggerTime) {
        auto assets = Root::singleton().assets();
        auto SFX = assets->audio(m_settings.queryString("exitHyperspaceAudio"));
        m_sentSFX = true;
        res.append(make_shared<AudioInstance>(*SFX));
        return res;
      }
    }
  } else if (m_flyingType == FlyingType::Arriving) {
    if (!m_sentSFX) {
      auto assets = Root::singleton().assets();
      auto SFX = assets->audio(m_settings.queryString("arrivalAudio"));
      m_sentSFX = true;
      res.append(make_shared<AudioInstance>(*SFX));
      return res;
    }
  }
  return res;
}

float Sky::spaceLevel() const {
  if (type() == SkyType::Atmospheric && m_skyParameters.spaceLevel && m_skyParameters.surfaceLevel) {
    float altitudeRange = *m_skyParameters.spaceLevel - *m_skyParameters.surfaceLevel;
    float relativeAltitude = m_altitude - *m_skyParameters.surfaceLevel;
    return clamp(relativeAltitude / altitudeRange, 0.0f, 1.0f);
  }
  return 1.0f;
}

float Sky::orbitAngle() const {
  // TODO: What should we do here?  Used to divide by zero.  Now is saved by
  // DefaultDayLength, but it's a hack
  return 2 * Constants::pi * timeOfDay() / dayLength();
}

bool Sky::isDayTime() const {
  return dayLevel() >= 0.5;
}

float Sky::dayLevel() const {
  // Turn the dayCycle value into a value that blends evenly between 0.0 at
  // mid-night and 1.0 at mid-day and then back again.

  float dayCycle = Sky::dayCycle();
  if (dayCycle < 1.0)
    return dayCycle / 2 + 0.5f;
  else if (dayCycle > 3.0)
    return (dayCycle - 3) / 2;
  else
    return 1.0 - (dayCycle - 1.0) / 2;
}

float Sky::dayCycle() const {
  // Always middle of the night in orbit or warp space.
  if (type() == SkyType::Orbital || type() == SkyType::Warp)
    return 3.0f;

  // This will misbehave badly if dayTransitionTime is greater than dayLength /
  // 2

  float transitionTime = m_settings.queryFloat("dayTransitionTime") / 2;
  float dayLength = Sky::dayLength();
  float timeOfDay = Sky::timeOfDay();

  // timeOfDay() is defined such that 0.0 is mid-dawn.  For convenience, shift
  // the time of day forwards such that 0.0 is the beginning of the morning.
  float shiftedTime = pfmod(timeOfDay + transitionTime / 2, dayLength);

  // There are 5 times here, beginning of the morning, end of the morning,
  // beginning of the evening, end of the evening, and then the beginning of
  // the morning again (wrapping around).
  Array<float, 5> transitionPositions = {
      0.0f, transitionTime, dayLength / 2, dayLength / 2 + transitionTime, dayLength};
  // The values here are mid-night, mid-day, mid-day, mid-night, mid-night.
  Array<float, 5> transitionValues = {-1.0f, 1.0f, 1.0f, 3.0f, 3.0f};

  return pfmod(parametricInterpolate2(
                   transitionPositions, transitionValues, shiftedTime, SinWeightOperator<float>(), BoundMode::Clamp),
      4.0f);
}

float Sky::skyAlpha() const {
  if (m_skyType != SkyType::Atmospheric) {
    return 0.0f;
  } else {
    float skyLevel = 1.0f - spaceLevel();
    return clamp(pow(skyLevel, m_settings.getFloat("skyLevelExponent")), 0.0f, 1.0f);
  }
}

Color Sky::environmentLight() const {
  if (m_skyType == SkyType::Orbital || m_skyType == SkyType::Warp)
    return Color::Black;

  if (m_skyParameters.skyColoring.isLeft()) {
    auto skyColoring = m_skyParameters.skyColoring.left();

    Array<Vec4F, 4> colors;
    colors[0] = skyColoring.morningLightColor.toRgbaF();
    colors[1] = skyColoring.dayLightColor.toRgbaF();
    colors[2] = skyColoring.eveningLightColor.toRgbaF();
    colors[3] = skyColoring.nightLightColor.toRgbaF();

    return Color::rgbaf(listInterpolate2(colors, dayCycle(), SinWeightOperator<float>(), BoundMode::Wrap));
  } else {
    return m_skyParameters.skyColoring.right();
  }
}

Color Sky::mainSkyColor() const {
  if (m_skyParameters.skyColoring.isLeft())
    return m_skyParameters.skyColoring.left().mainColor;

  return Color::Black;
}

pair<Color, Color> Sky::skyRectColors() const {
  if (m_skyParameters.skyColoring.isLeft()) {
    auto skyColoring = m_skyParameters.skyColoring.left();

    Array<Vec4F, 4> topColorList;
    topColorList[0] = skyColoring.morningColors.first.toRgbaF();
    topColorList[1] = skyColoring.dayColors.first.toRgbaF();
    topColorList[2] = skyColoring.eveningColors.first.toRgbaF();
    topColorList[3] = skyColoring.nightColors.first.toRgbaF();

    Array<Vec4F, 4> bottomColorList;
    bottomColorList[0] = skyColoring.morningColors.second.toRgbaF();
    bottomColorList[1] = skyColoring.dayColors.second.toRgbaF();
    bottomColorList[2] = skyColoring.eveningColors.second.toRgbaF();
    bottomColorList[3] = skyColoring.nightColors.second.toRgbaF();

    float cycle = dayCycle();
    auto topColor = Color::rgbaf(listInterpolate2(topColorList, cycle, SinWeightOperator<float>(), BoundMode::Wrap));
    auto bottomColor = Color::rgbaf(listInterpolate2(bottomColorList, cycle, SinWeightOperator<float>(), BoundMode::Wrap));

    float skyAlpha = Sky::skyAlpha();
    topColor.setAlpha(topColor.alpha() * skyAlpha);
    bottomColor.setAlpha(bottomColor.alpha() * skyAlpha);

    return {topColor, bottomColor};
  }

  return {Color::Clear, Color::Clear};
}

Color Sky::skyFlashColor() const {
  Color res = Color::White;
  res.setAlphaF(m_flashTimer / m_settings.queryFloat("flashTimer"));
  return res;
}

bool Sky::flying() const {
  if (m_flyingType == FlyingType::None)
    return false;
  return true;
}

FlyingType Sky::flyingType() const {
  return m_flyingType;
}

float Sky::warpProgress() const {
  if (m_flyingType == FlyingType::Warp) {
    auto warpTime = speedupTime() + m_settings.queryFloat("flyingTimer") + slowdownTime();
    auto timer = m_flyingTimer;
    if (m_warpPhase < WarpPhase::SpeedingUp)
      timer += speedupTime();
    if (m_warpPhase < WarpPhase::Maintain)
      timer += m_settings.queryFloat("flyingTimer");
    return timer / warpTime;
  }
  return 0.0;
}

WarpPhase Sky::warpPhase() const {
  return m_warpPhase;
}

bool Sky::inHyperspace() const {
  return m_flyingType == FlyingType::Warp && m_enterHyperspace;
}

SkyRenderData Sky::renderData() const {
  SkyRenderData renderData;
  renderData.settings = m_settings;
  renderData.skyParameters = m_skyParameters;
  renderData.type = m_skyType;
  renderData.dayLevel = dayLevel();
  renderData.skyAlpha = skyAlpha();

  renderData.dayLength = dayLength();
  renderData.timeOfDay = timeOfDay();
  renderData.epochTime = epochTime();

  renderData.starOffset = getStarOffset();
  renderData.starRotation = getStarRotation();
  renderData.worldOffset = getWorldOffset();
  renderData.worldRotation = getWorldRotation();
  renderData.orbitAngle = orbitAngle();

  renderData.starFrames = m_starFrames;
  renderData.starList = m_starList;
  renderData.hyperStarList = m_hyperStarList;

  renderData.environmentLight = environmentLight();
  renderData.mainSkyColor = mainSkyColor();
  tie(renderData.topRectColor, renderData.bottomRectColor) = skyRectColors();
  renderData.flashColor = skyFlashColor();

  return renderData;
}

void Sky::writeNetStates() {
  if (take(m_skyParametersUpdated))
    m_skyParametersNetState.set(DataStreamBuffer::serialize<Json>(m_skyParameters.toJson()));

  m_skyTypeNetState.set((int)m_skyType);
  m_timeNetState.set(m_time);
  m_enterHyperspaceNetState.set(m_enterHyperspace);
  m_startInWarpNetState.set(m_startInWarp);

  m_flyingTypeNetState.set((unsigned)m_flyingType);
  m_warpPhaseNetState.set((int)m_warpPhase);

  m_flyingTimerNetState.set(m_flyingTimer);
  m_worldMoveNetState.set(m_worldMoveOffset);
  m_starMoveNetState.set(m_starMoveOffset);
}

void Sky::readNetStates() {
  if (m_skyParametersNetState.pullUpdated()) {
    m_skyParameters = SkyParameters(DataStreamBuffer::deserialize<Json>(m_skyParametersNetState.get()));
    skyParametersUpdated();
  }

  m_skyType = (SkyType)m_skyTypeNetState.get();
  m_time = m_timeNetState.get();
  m_enterHyperspace = m_enterHyperspaceNetState.get();
  m_startInWarp = m_startInWarpNetState.get();

  m_flyingType = (FlyingType)m_flyingTypeNetState.get();
  m_warpPhase = (WarpPhase)m_warpPhaseNetState.get();
  stateUpdate();

  if (!m_netInit) {
    m_netInit = true;

    m_flyingTimer = m_flyingTimerNetState.get();
    m_worldMoveOffset = m_worldMoveNetState.get();
    m_starMoveOffset = m_starMoveNetState.get();
  }
}

void Sky::enterHyperspace() {
  m_flashTimer = m_settings.queryFloat("flashTimer");
  setType(SkyType::Warp);

  m_sentSFX = false;
}

void Sky::exitHyperspace() {
  m_flashTimer = m_settings.queryFloat("flashTimer");
  setType(SkyType::Orbital);

  m_sentSFX = false;
  Json originMap;
  Json destMap;
  if (m_skyParameters.skyType == SkyType::Space) {
    originMap = m_settings.getObject("spaceArrivalOrigin");
    destMap = m_settings.getArray("spaceArrivalPath")[0];
  } else {
    originMap = m_settings.getObject("arrivalOrigin");
    destMap = m_settings.getArray("arrivalPath")[0];
  }

  m_pathOffset = jsonToVec2F(originMap.get("offset"));
  m_pathRotation = originMap.get("rotation").toFloat() * Constants::deg2rad;

  float maxVelocity = m_settings.queryFloat("flyMaxVelocity");
  float exitDistance = maxVelocity / 2.0 * slowdownTime();
  m_worldMoveOffset = Vec2F::withAngle(0, exitDistance);
  m_worldOffset = m_worldMoveOffset;

  exitDistance = (maxVelocity * m_settings.queryFloat("starVelocityFactor")) / 2.0 * slowdownTime();
  m_starMoveOffset = Vec2F::withAngle(0, exitDistance);
  m_starOffset = m_starMoveOffset;

  m_worldRotation = m_starRotation = 0;
  m_flyingTimer = 0;
}

bool Sky::controlledMovement(JsonArray const& path, Json const& origin, float timeOffset) {
  float previousTime = 0;
  Vec2F previousOffset = jsonToVec2F(origin.get("offset"));
  float previousRotation = origin.getFloat("rotation") * Constants::deg2rad;

  float stepTime = 0;
  Vec2F stepOffset;
  float stepRotation;
  for (auto const& entry : path) {
    stepOffset = jsonToVec2F(entry.get("offset"));
    stepRotation = entry.getFloat("rotation") * Constants::deg2rad;
    stepTime += entry.getFloat("time");

    if (timeOffset <= stepTime) {
      float percentage = (timeOffset - previousTime) / (stepTime - previousTime);
      m_pathOffset = lerp(percentage, previousOffset, stepOffset);
      m_pathRotation = lerp(percentage, previousRotation, stepRotation);
      return false;
    }

    previousTime = stepTime;
    previousOffset = stepOffset;
    previousRotation = stepRotation;
  }
  // if loop wasn't broken
  // then we're done with this phase of controlled movement
  // signal that we're ready to head out of this system

  return true;
}

Vec2F Sky::getStarOffset() const {
  return (m_starOffset + m_pathOffset);
}

float Sky::getStarRotation() const {
  return m_starRotation + m_pathRotation;
}

Vec2F Sky::getWorldOffset() const {
  return m_worldOffset + m_pathOffset;
}

float Sky::getWorldRotation() const {
  return m_worldRotation + m_pathRotation;
}

float Sky::speedupTime() const {
  if (m_enterHyperspace)
    return m_settings.queryFloat("hyperspaceSpeedupTime");
  else
    return m_settings.queryFloat("speedupTime");
}

float Sky::slowdownTime() const {
  if (m_enterHyperspace)
    return m_settings.queryFloat("hyperspaceSlowdownTime");
  else
    return m_settings.queryFloat("slowdownTime");
}

void Sky::skyParametersUpdated() {
  m_skyParametersUpdated = true;
  m_settings = jsonMerge(Root::singleton().assets()->json("/sky.config"), m_skyParameters.settings);
  m_starFrames = m_settings.queryInt("stars.frames");
  m_starList = jsonToStringList(m_settings.query("stars.list"));
  m_hyperStarList = jsonToStringList(m_settings.query("stars.hyperlist"));
}

}