ase_costs.cpp

A*算法的演示程序

    return costs;
  }


float ASE_Costs::CellBasedDistanceBasedAimingCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    //! \note: assumes weapon effectivity decreases with linear distance, not with cell distance
    return VectorBasedDistanceBasedAimingCosts(aFromNode, aToNode);
  }


float ASE_Costs::VectorBasedCountBasedSimpleCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    assert( ASE_ThreatBoard::eMinLineOfFireCount == m_ThreatBoard->GetRiskModus() );

    const float kThreatCostFactor = 8;

    float traveltime;
    traveltime = m_TerrainBoard->GetTravelTime(aFromNode->GetX(), aFromNode->GetY(), 
                                               aToNode->GetX(),   aToNode->GetY());

    float risk;
    risk  = m_ThreatBoard->GetRiskValue(aToNode->GetX(), aToNode->GetY());
    risk += m_ThreatBoard->GetRiskValue(aFromNode->GetX(), aFromNode->GetY());
    risk *= kThreatCostFactor;

    float costs;
    costs = risk * traveltime;

    return costs;
  }


float ASE_Costs::CellBasedCountBasedSimpleCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    return VectorBasedCountBasedSimpleCosts(aFromNode, aToNode);
  }


float ASE_Costs::VectorBasedCountBasedAimingCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    assert( ASE_ThreatBoard::eMinLineOfFireCount == m_ThreatBoard->GetRiskModus() );

    const float kThreatCostFactor = 1.2f;
    const float kMaxAim           = 5;
    const float kAimDecay         = 0.8f;

    float traveltime;
    traveltime = m_TerrainBoard->GetTravelTime(aFromNode->GetX(), aFromNode->GetY(), 
                                               aToNode->GetX(),   aToNode->GetY());

    float risk;
    risk  = m_ThreatBoard->GetRiskValue(aToNode->GetX(), aToNode->GetY());
    risk += m_ThreatBoard->GetRiskValue(aFromNode->GetX(), aFromNode->GetY());
    risk *= kThreatCostFactor;

    float aim;
    aim = aFromNode->GetThreatAimQuality();
    if ( risk == 0 )
      {
        // just do decay, travel time based
        aim *= static_cast<float>(pow(kAimDecay, traveltime));
      }    
    else
      {
        aim = min(kMaxAim, aim + traveltime); 
      }
    aToNode->SetThreatAimQuality(aim);

    float costs;
    costs = risk * traveltime * (1 + aim);

    return costs;
  }


float ASE_Costs::CellBasedCountBasedAimingCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    return VectorBasedCountBasedAimingCosts(aFromNode, aToNode);
  }


float ASE_Costs::CellBasedDistanceAndCountBasedSimpleCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    return VectorBasedDistanceAndCountBasedSimpleCosts(aFromNode, aToNode);
  }


float ASE_Costs::VectorBasedDistanceAndCountBasedSimpleCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    assert( ASE_ThreatBoard::eMinLineOfFireCountAndDistance == m_ThreatBoard->GetRiskModus() );

    const float kThreatCostFactor = 4;

    float traveltime;
    traveltime = m_TerrainBoard->GetTravelTime(aFromNode->GetX(), aFromNode->GetY(), 
                                               aToNode->GetX(),   aToNode->GetY());

    float risk;
    risk  = m_ThreatBoard->GetRiskValue(aToNode->GetX(), aToNode->GetY());
    risk += m_ThreatBoard->GetRiskValue(aFromNode->GetX(), aFromNode->GetY());
    risk *= kThreatCostFactor;

    float costs;
    costs = risk * traveltime;

    return costs;
  }


float ASE_Costs::CellBasedDistanceAndCountBasedAimingCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    return VectorBasedDistanceAndCountBasedAimingCosts(aFromNode, aToNode);
  }


float ASE_Costs::VectorBasedDistanceAndCountBasedAimingCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    assert( ASE_ThreatBoard::eMinLineOfFireCountAndDistance == m_ThreatBoard->GetRiskModus() );

    const float kThreatCostFactor = 0.6f;
    const float kMaxAim           = 5;
    const float kAimDecay         = 0.8f;

    float traveltime;
    traveltime = m_TerrainBoard->GetTravelTime(aFromNode->GetX(), aFromNode->GetY(), 
                                               aToNode->GetX(),   aToNode->GetY());

    float risk;
    risk  = m_ThreatBoard->GetRiskValue(aToNode->GetX(), aToNode->GetY());
    risk += m_ThreatBoard->GetRiskValue(aFromNode->GetX(), aFromNode->GetY());
    risk *= kThreatCostFactor;

    float aim;
    aim = aFromNode->GetThreatAimQuality();
    if ( risk == 0 )
      {
        // just do decay, travel time based
        aim *= static_cast<float>(pow(kAimDecay, traveltime));
      }    
    else
      {
        aim = min(kMaxAim, aim + traveltime); 
      }
    aToNode->SetThreatAimQuality(aim);

    float costs;
    costs = risk * traveltime * (1 + aim);

    return costs;
  }


float ASE_Costs::CellBasedThreatsApproximateLOFSimpleCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    return VectorBasedThreatsApproximateLOFSimpleCosts(aFromNode, aToNode);
  }


float ASE_Costs::VectorBasedThreatsApproximateLOFSimpleCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    const float kThreatCostFactor = 4;

    float traveltime;
    traveltime = m_TerrainBoard->GetTravelTime(aFromNode->GetX(), aFromNode->GetY(), 
                                               aToNode->GetX(),   aToNode->GetY());

    float risk;
    risk  = m_LOFApproxBoard->GetRiskValue(aToNode->GetX(), aToNode->GetY());
    risk += m_LOFApproxBoard->GetRiskValue(aFromNode->GetX(), aFromNode->GetY());
    risk *= kThreatCostFactor;

    float costs;
    costs = risk * traveltime;

    return costs;
  }


float ASE_Costs::CellBasedThreatsApproximateLOFAimingCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    return VectorBasedThreatsApproximateLOFAimingCosts(aFromNode, aToNode);
  }


float ASE_Costs::VectorBasedThreatsApproximateLOFAimingCosts(_asNode* aFromNode, _asNode* aToNode)
  {
    const float kThreatCostFactor = 0.6f;
    const float kMaxAim           = 5;
    const float kAimDecay         = 0.8f;

    float traveltime;
    traveltime = m_TerrainBoard->GetTravelTime(aFromNode->GetX(), aFromNode->GetY(), 
                                               aToNode->GetX(),   aToNode->GetY());

    float risk;
    risk  = m_LOFApproxBoard->GetRiskValue(aToNode->GetX(), aToNode->GetY());
    risk += m_LOFApproxBoard->GetRiskValue(aFromNode->GetX(), aFromNode->GetY());
    risk *= kThreatCostFactor;

    float aim;
    aim = aFromNode->GetThreatAimQuality();
    if ( risk == 0 )
      {
        // just do decay, travel time based
        aim *= static_cast<float>(pow(kAimDecay, traveltime));
      }    
    else
      {
        aim = min(kMaxAim, aim + traveltime); 
      }
    aToNode->SetThreatAimQuality(aim);

    float costs;
    costs = risk * traveltime * (1 + aim);

    return costs;
  }


float ASE_Costs::CellBasedNormalMovementHeuristic(_asNode* aFromNode, _asNode* aToNode)
  {
    int manhattandist;
    manhattandist =   abs(aFromNode->GetX() - aToNode->GetX())
                    + abs(aFromNode->GetY() - aToNode->GetY());
    return static_cast<float>(manhattandist);
  }


float ASE_Costs::CellBasedRelativeMovementHeuristic(_asNode* aFromNode, _asNode* aToNode)
  {
    return CellBasedNormalMovementHeuristic(aFromNode, aToNode);
  }


float ASE_Costs::VectorBasedNormalMovementHeuristic(_asNode* aFromNode, _asNode* aToNode)
  {
    float distx;
    float disty;
    distx  = static_cast<float>(aToNode->GetX() - aFromNode->GetX());
    distx *= distx;
    disty  = static_cast<float>(aToNode->GetY() - aFromNode->GetY());
    disty *= disty;
    return static_cast<float>(sqrt(distx + disty));
  }


float ASE_Costs::ThreatsAnyModeAnyMovementHeuristic(_asNode* aFromNode, _asNode* aToNode)
  {
    return 0;
  }