Method damageSources

source/game/StarMonster.cpp:279–351

}

List<DamageSource> Monster::damageSources() const {
  List<DamageSource> damageSources = m_damageSources.get();

  float levelPowerMultiplier = Root::singleton().functionDatabase()->function(m_monsterVariant.powerLevelFunction)->evaluate(*m_monsterLevel);
  if (m_damageOnTouch && !m_monsterVariant.touchDamageConfig.isNull()) {
    DamageSource damageSource(m_monsterVariant.touchDamageConfig);
    if (auto damagePoly = damageSource.damageArea.ptr<PolyF>())
      damagePoly->rotate(m_movementController->rotation());
    damageSource.damage *= m_monsterVariant.touchDamageMultiplier * levelPowerMultiplier * m_statusController->stat("powerMultiplier");
    damageSource.sourceEntityId = entityId();
    damageSource.team = getTeam();
    damageSources.append(damageSource);
  }

  auto animationDamageParts = m_monsterVariant.animationDamageParts;
  for (auto pair : m_monsterVariant.animationDamageParts) {
    if (!m_animationDamageParts.get().contains(pair.first))
      continue;

    String anchorPart = pair.second.getString("anchorPart");
    DamageSource ds = DamageSource(pair.second.get("damageSource"));
    ds.damage *= levelPowerMultiplier * m_statusController->stat("powerMultiplier");
    ds.damageArea.call([this,&anchorPart](auto& poly) {
      poly.transform(m_networkedAnimator.partTransformation(anchorPart));
      if (m_networkedAnimator.flipped())
        poly.flipHorizontal(m_networkedAnimator.flippedRelativeCenterLine());
    });
    if (ds.knockback.is<Vec2F>()) {
      Vec2F knockback = ds.knockback.get<Vec2F>();
      knockback = m_networkedAnimator.partTransformation(anchorPart).transformVec2(knockback);
      if (m_networkedAnimator.flipped())
        knockback = Vec2F(-knockback[0], knockback[1]);
      ds.knockback = knockback;
    }

    List<DamageSource> partSources;
    if (auto line = ds.damageArea.maybe<Line2F>()) {
      if (pair.second.getBool("checkLineCollision", false)) {
        Line2F worldLine = line.value().translated(position());
        float length = worldLine.length();

        auto bounces = pair.second.getInt("bounces", 0);
        while (auto collision = world()->lineTileCollisionPoint(worldLine.min(), worldLine.max())) {
          worldLine = Line2F(worldLine.min(), collision.value().first);
          ds.damageArea = worldLine.translated(-position());
          length = length - worldLine.length();

          if (--bounces >= 0 && length > 0.0f) {
            partSources.append(ds);
            ds = DamageSource(ds);
            Vec2F dir = worldLine.direction();
            Vec2F normal = Vec2F((*collision).second);
            Vec2F reflection = dir - (2 * dir.piecewiseMultiply(normal).sum() * normal);
            if (ds.knockback.is<Vec2F>())
              ds.knockback = ds.knockback.get<Vec2F>().rotate(reflection.angleBetween(worldLine.direction()));

            worldLine.min() = (*collision).first;
            worldLine.max() = worldLine.min() + (reflection * length);