public override bool ResolveLocation(MissionInProgress missionInProgress)
{
if (ResolveGenericLocation(missionInProgress))
{
return(base.ResolveLocation(missionInProgress));
}
return(false);
}
public override void ResolveLinks(MissionInProgress missionInProgress)
{
if (generateSecondaryDefinition)
{
LookUpSecondaryDefinitionOrSelectItem(missionInProgress);
}
base.ResolveLinks(missionInProgress);
}
protected void TryCopyDefinitionFromPrimaryLinkedTarget(MissionInProgress missionInProgress)
{
var primaryLinkedTarget = GetSourceTargetForPrimaryAndSolve(missionInProgress);
if (ValidPrimaryLinkSet)
{
primaryLinkedTarget?.myTarget.CopyMyPrimaryDefinitionToTarget(this);
}
}
public override void ResolveLinks(MissionInProgress missionInProgress)
{
if (!ValidDefinitionSet)
{
LookupPrimaryDefinitionOrSetFromPools(missionInProgress);
}
base.ResolveLinks(missionInProgress);
}
private void LookUpSecondaryDefinition(MissionInProgress missionInProgress)
{
var secondaryLinkedTarget = GetSourceTargetForSecondaryAndSolve(missionInProgress);
if (ValidSecondaryLinkSet)
{
secondaryLinkedTarget?.myTarget.CopyMySecondaryDefinitionToTarget(this);
}
}
public override bool ResolveLocation(MissionInProgress missionInProgress)
{
if (ResolveMissionStructureLocations(missionInProgress, Type))
{
return(base.ResolveLocation(missionInProgress));
}
return(false);
}
protected void LookUpPrimaryDefinitionOrSelectPlantMineralDefinition(MissionInProgress missionInProgress)
{
TryCopyDefinitionFromPrimaryLinkedTarget(missionInProgress);
if (!ValidDefinitionSet)
{
SetDefinitionAsPlantMineralFromPool(missionInProgress);
}
}
private void AdvanceBonusInGang(List <Character> charactersToSpread, MissionInProgress missionInProgress)
{
foreach (var character in charactersToSpread)
{
var missionBonus = MissionAdministrator.GetOrAddMissionBonus(character, missionInProgress.myMission.missionCategory, missionInProgress.MissionLevel, missionInProgress.myLocation.Agent);
missionBonus.AdvanceBonus();
MissionAdministrator.SetMissionBonus(missionBonus);
}
}
protected void LookupPrimaryDefinitionOrSetFromPools(MissionInProgress missionInProgress)
{
TryCopyDefinitionFromPrimaryLinkedTarget(missionInProgress);
if (!ValidDefinitionSet)
{
SetPrimaryDefinitionFromItemPools(missionInProgress);
}
}
/// <summary>
/// Sets the definition as one of the source items of a research - the item to researh
/// </summary>
/// <param name="missionInProgress"></param>
/// <param name="usePrimaryLink"></param>
protected bool TryGetResearchableItemFromResearchTarget(MissionInProgress missionInProgress, bool usePrimaryLink = true)
{
MissionTargetInProgress linkedTarget;
if (usePrimaryLink)
{
if (!ValidPrimaryLinkSet)
{
return(false);
}
linkedTarget = GetSourceTargetForPrimaryAndSolve(missionInProgress);
}
else
{
if (!ValidSecondaryLinkSet)
{
return(false);
}
linkedTarget = GetSourceTargetForSecondaryAndSolve(missionInProgress);
}
if (linkedTarget?.TargetType == MissionTargetType.research)
{
if (!linkedTarget.myTarget.ValidDefinitionSet)
{
Logger.Error("no valid cprg definition is set for " + linkedTarget.myTarget);
throw new PerpetuumException(ErrorCodes.ConsistencyError);
}
//this target is created to aid the research. It must spawn an original item
//and there must be a way to get the decoder as well along the mission
//cannot use selected definition exceptions
var itemDefinition = ProductionDataAccess.GetResultingDefinitionFromCalibrationDefinition(linkedTarget.myTarget.Definition);
missionInProgress.AddToSelectedItems(itemDefinition);
//as a side effect it may happen that previous targets choose this definition. dont be surprised!
//possible workaround
// position the spawn targets as the last/first items, so they will find the item amongst the choosen ones
// according to research targets in mission
definition = itemDefinition;
quantity = 1;
Log("researchable item resolved:" + PrimaryEntityDefault.Name + " from " + linkedTarget.myTarget);
return(true);
}
return(false);
}
protected override void ProcessMyQuantity(MissionInProgress missionInProgress)
{
if (!ValidQuantitySet)
{
TryCopyQuantityFromPrimaryLink(missionInProgress);
}
CheckPrimaryQuantityAndThrow();
base.ProcessMyQuantity(missionInProgress);
}
private void SetPrimaryDefinitionFromItemPools(MissionInProgress missionInProgress)
{
var categorFlags = CategoryFlags.cf_generic_random_items;
if (ValidPrimaryCategorySet)
{
categorFlags = PrimaryCategoryFlags;
}
definition = GetCombinedDefinitionFromPools(missionInProgress, categorFlags);
}
protected void SetSecondaryDefinitionFromMissionItemsPool(MissionInProgress missionInProgress)
{
var categoryFlags = CategoryFlags.cf_generic_random_items;
if (ValidSecondaryCategorySet)
{
categoryFlags = SecondaryCategoryFlags;
}
secondaryDefinition = GetCombinedDefinitionFromPools(missionInProgress, categoryFlags);
}
private List <MissionTarget> GetPossibleMissionSpots(MissionInProgress missionInProgress, double rangeExtension)
{
return(missionDataCache.GetAllMissionTargets.Where(t =>
(t.Type == MissionTargetType.rnd_point || t.Type == MissionTargetType.find_artifact || t.Type == MissionTargetType.pop_npc) &&
t.ValidPositionSet &&
t.ValidZoneSet &&
missionInProgress.myLocation.ZoneConfig.Id == t.ZoneId &&
missionInProgress.SearchOrigin.IsInRangeOf2D(t.targetPosition, t.FindRadius + rangeExtension) &&
missionDataCache.IsTargetSelectionValid(missionInProgress.myLocation.Zone, missionInProgress.SearchOrigin, t.targetPosition)
).ToList());
}
protected void ScaleNpcAmount(MissionInProgress missionInProgress)
{
var preValue = quantity;
var level = missionInProgress.ScaleMissionLevel;
var gangMemberCountMax = missionInProgress.GangMemberCountMaximized;
var randomAmount = GetRandomNpcAmountByLevel(missionInProgress.MissionLevel);
quantity = (Quantity + gangMemberCountMax + randomAmount).Clamp(0, int.MaxValue);
Log("npc amount scaled " + preValue + " -> " + quantity + " Gm:" + gangMemberCountMax + " lvl:" + level + " randAmount:" + randomAmount);
}
protected void TryScaleByTypeOrCopyPrimaryQuantity(MissionInProgress missionInProgress)
{
if (ValidQuantitySet)
{
//quantity manually set, try scaling it by type
ScalePrimaryQuantityByType(missionInProgress);
}
else
{
TryCopyQuantityFromPrimaryLink(missionInProgress);
}
}
public override void ResolveLinks(MissionInProgress missionInProgress)
{
TryCopyDefinitionFromPrimaryLinkedTarget(missionInProgress);
if (!ValidDefinitionSet)
{
Log("the primary link must be set on " + this + " missionId:" + MissionId);
throw new PerpetuumException(ErrorCodes.ConsistencyError);
}
base.ResolveLinks(missionInProgress);
}
public override void ResolveLinks(MissionInProgress missionInProgress)
{
//primary definition is ignored here
//deal with secondary, which is the 'gathered intel'
if (generateSecondaryDefinition)
{
//teh intel document
SetSecondaryDefinitionFromMissionItemsPool(missionInProgress);
}
base.ResolveLinks(missionInProgress);
}
protected void LookUpPrimaryDefinitionOrSelectNpcDefinition(MissionInProgress missionInProgress)
{
TryCopyDefinitionFromPrimaryLinkedTarget(missionInProgress);
if (!ValidDefinitionSet && !useQuantityOnly)
{
//this is a rare case, but it can handle it
//practically here we suppress the diversity and we only spawn a certain type N times
//can be aided later with extra npcs above these fixed ones as optional targets
SetDefinitionAsNpcFromPool(missionInProgress);
}
}
private bool ProcessQuantityOrSkip(MissionInProgress missionInProgress)
{
//links already processed?
if (!CheckIfLinksAreScaled(missionInProgress))
{
return(false);
}
//call the type related functions
ProcessMyQuantity(missionInProgress);
return(true);
}
private List <MissionTarget> GetPossibleStructureTargets(MissionInProgress missionInProgress, MissionTargetType targetType, double rangeExtension)
{
return(missionDataCache.GetAllMissionTargets
.Where(t => t.Type == targetType &&
t.ValidFindRadiusSet &&
t.ValidMissionStructureEidSet &&
t.ValidPositionSet &&
t.ValidZoneSet &&
t.ZoneId == missionInProgress.myLocation.ZoneConfig.Id &&
missionInProgress.SearchOrigin.IsInRangeOf2D(t.targetPosition, t.FindRadius + rangeExtension) &&
missionDataCache.IsTargetSelectionValid(missionInProgress.myLocation.Zone, missionInProgress.SearchOrigin, t.targetPosition)
).ToList());
}
protected override void ProcessMyQuantity(MissionInProgress missionInProgress)
{
ScaleArtifactRange(missionInProgress);
if (FindArtifactSpawnsNpcs)
{
ProcessPrimaryQuantityAsNpc(missionInProgress);
}
ProcessSecondaryQuantity(missionInProgress);
base.ProcessMyQuantity(missionInProgress);
}
private void ScaleArtifactRange(MissionInProgress missionInProgress)
{
var level = missionInProgress.ScaleMissionLevel;
var gangMemberCount = missionInProgress.GangMemberCountMaximized;
var rawRange = _artifactRanges[level];
var range = rawRange + rawRange * gangMemberCount * missionDataCache.ScaleArtifactLevelFractionForGangMember;
TargetPositionRange = (int)(range.Clamp(0, double.MaxValue));
Log("range scaled. " + TargetPositionRange + " G:" + gangMemberCount + " lvl:" + level);
}
protected override void ProcessMyQuantity(MissionInProgress missionInProgress)
{
TryScaleByTypeOrCopyPrimaryQuantity(missionInProgress);
if (generateSecondaryDefinition)
{
secondaryQuantity = 1;
}
CheckPrimaryQuantityAndThrow();
base.ProcessMyQuantity(missionInProgress);
}
protected MissionTargetInProgress GetSourceTargetForPrimaryAndSolve(MissionInProgress missionInProgress)
{
var definitionSourceTarget = GetSourceTargetForPrimaryDefinition(missionInProgress);
if (definitionSourceTarget != null)
{
if (!definitionSourceTarget.myTarget.IsResolved)
{
definitionSourceTarget.myTarget.ResolveLinks(missionInProgress);
}
}
return(definitionSourceTarget);
}
public override void ResolveLinks(MissionInProgress missionInProgress)
{
//ez persze csak extra, de lehet, talan kelleni fog
//tulajodonkeppen sosem lesz a presence hasznalva
if (!ValidPresenceSet)
{
//ha nincs beallitva neki fixen presence, akkor
//link resolve, if link set
//generate definition from pool
LookUpPrimaryDefinitionOrSelectNpcDefinition(missionInProgress);
}
base.ResolveLinks(missionInProgress);
}
protected void TryCopyQuantityFromPrimaryLink(MissionInProgress missionInProgress)
{
//process primary link
var preValue = quantity;
var primary = GetSourceTargetForPrimaryAndSolve(missionInProgress);
if (ValidPrimaryLinkSet && primary != null)
{
// primary link is used
if (!primary.myTarget.IsScaled)
{
Log("primary target not scaled yet. " + primary.TargetType);
return;
}
if (targetSecondaryAsMyPrimary)
{
//using the linked target's secondary quantity
if (primary.myTarget.ValidSecondaryQuantitySet)
{
quantity = primary.myTarget.SecondaryQuantity;
Log("setting priQty from primary link's secQty. " + preValue + " -> " + quantity + " from:" + primary.myTarget);
}
else
{
Logger.Error("the linked target's secondary quantity is not set. current:" + this + " linked as primary to " + primary.myTarget);
throw new PerpetuumException(ErrorCodes.ConsistencyError);
}
}
else
{
//default case : using the target's primary quantity
if (primary.myTarget.ValidQuantitySet)
{
quantity = primary.myTarget.Quantity;
Log("setting priQty from primary link's priQty. " + preValue + " -> " + quantity + " from:" + primary.myTarget);
}
else
{
Logger.Error("the linked target's primary quantity is not set. current:" + this + " linked as primary to " + primary.myTarget);
throw new PerpetuumException(ErrorCodes.ConsistencyError);
}
}
}
}
/// <summary>
/// This function makes sure that the resulting target is solved,
/// technically: when we are working with a target we can be sure that it is solved.
/// </summary>
/// <param name="missionInProgress"></param>
/// <returns></returns>
private MissionTargetInProgress GetSourceTargetForSecondaryAndSolve(MissionInProgress missionInProgress)
{
//get secondary target via mission in progress
var secondaryDefinitionSourceTarget = GetSourceTargetForSecondaryDefinition(missionInProgress);
if (secondaryDefinitionSourceTarget != null)
{
if (!secondaryDefinitionSourceTarget.myTarget.IsResolved)
{
secondaryDefinitionSourceTarget.myTarget.ResolveLinks(missionInProgress);
}
}
return(secondaryDefinitionSourceTarget);
}
private MissionTarget SearchForPossibleSpots(MissionInProgress missionInProgress)
{
var foundTargets = SearchForMinimalAmountOfSpots(missionInProgress, missionInProgress.SelectedTargets);
if (foundTargets.Count == 0)
{
Log("no possible location targets to select from. " + this + " " + missionInProgress);
return(null);
}
var selectedTarget = foundTargets.RandomElement();
missionInProgress.AddToSelectedTargets(selectedTarget);
return(selectedTarget);
}
protected MissionTarget SelectRandomMissionStructure(MissionInProgress missionInProgress, MissionTargetType targetType)
{
var structures = SearchForMinimalAmountOfStructures(missionInProgress, targetType, missionInProgress.SelectedTargets);
if (structures.Count == 0)
{
Log("no possible structure targets to select from. " + targetType + " " + this + " " + missionInProgress);
return(null);
}
var selectedTarget = structures.RandomElement();
missionInProgress.AddToSelectedTargets(selectedTarget);
return(selectedTarget);
}
