C++ Hits::push_back方法代码示例

ShipBattle::Hits ShipBattle::GetHitsToDestroy(const Group& group, Dice& dice, int toHit) const
{
	const auto shipIndices = GetShipIndicesWeakestFirst(group);

	Hits hits;
	for (int shipIndex : shipIndices)
	{
		int lives = group.lifeCounts[shipIndex];
		Dice used = dice.Remove(lives, toHit);
		if (used.empty())
			break; // Can't destroy any more ships in this group. 

		// We can destroy this ship. 
		int damage = used.GetDamage();
		if (damage > lives) // Don't want to waste damage. Can we destroy a healthier ship? 
		{
			for (int shipIndex2 : shipIndices)
				if (group.lifeCounts[shipIndex2] == damage)
				{
					// We can destroy this one with no waste. 
					shipIndex = shipIndex2;
					lives = damage;
					break;
				}
		}

		hits.push_back(Hit(group.shipType, shipIndex, used));
	}
	return hits;
}

ShipBattle::Hits ShipBattle::AutoAssignHits(const Dice& dice, const Game& game) const
{
	Hits hits;

	Dice remainingDice = dice;

	std::map<int, std::set<int>> destroyedShips; // group index, ship indices.

	// Try to destroy ships (biggest type and most damaged ship first.) 
	std::vector<int> groupIndices = GetTargetGroupIndicesBiggestFirst();
	for (int groupIndex : groupIndices)
	{
		if (remainingDice.empty())
			break;

		const Group& group = m_groups[groupIndex];
		int toHit = GetToHitRoll(group.shipType, game);

		Hits groupHits = GetHitsToDestroy(group, remainingDice, toHit);
		hits.insert(hits.begin(), groupHits.begin(), groupHits.end());

		// Remember destroyed ships so we don't try to damage them. 
		for (auto& hit : groupHits)
			destroyedShips[groupIndex].insert(hit.shipIndex);
	}

	// Try to damage remaining ships. Only need to consider the weakest ship of each group. 
	for (int groupIndex : groupIndices)
	{
		if (remainingDice.empty())
			break;

		const Group& group = m_groups[groupIndex];
		const auto shipIndices = GetShipIndicesWeakestFirst(group);

		// Check if the whole group has been destroyed. 
		// We can't just check if shipIndices is empty, because the damamge hasn't been applied yet. 
		if (destroyedShips[groupIndex].size() == shipIndices.size())
			continue;

		int toHit = GetToHitRoll(group.shipType, game);

		for (int shipIndex : shipIndices)
		{
			if (destroyedShips[groupIndex].count(shipIndex) == 0) // Still alive.
			{
				Dice used = remainingDice.RemoveAll(toHit);
				if (!used.empty())
					hits.push_back(Hit(group.shipType, shipIndex, used));

				break; // No point checking healthier ships. 
			}
		}
	}

	return hits;
}

void Cluster::merge(Cluster* anotherCluster){
	
	//Merge the hits
	Hits::iterator i = hits.end();
	Hits a;
	a.push_back(Hit(0,0,0,0));
	
	anotherCluster->get_hits()->splice(i,hits);
	//Reset cluster properties
	checkIsAtEdge = false;
	size = 0;
	width = 0;
	length = 0;
	tot = 0;
	centreOfCharge.first = -1;
	centreOfCharge.second = -1;
	nMissingHits = -1;

}