public void DoesNotSeeEnemy(HumanoidModel enemy)
{
EnemyTarget enemyTarget;
viewableEnemies.TryGetValue(enemy, out enemyTarget);
if (enemyTarget != null)
{
viewableEnemies.Remove(enemy);
EnemyMarker newMarker = new EnemyMarker(enemyTarget, this);
CommunicatableEnemyMarker newCMarker = new CommunicatableEnemyMarker(
newMarker,
checkHiddenEnemyRadius
);
// avoid clustering enemy markers in one spot
if (NoMarkerTooCloseTo(newCMarker))
{
AddHiddenEnemy(newCMarker);
HumanoidTargeterCommunication.Communicate(
new CommunicationPackage(
GetDeepCopyOfHiddenEnemies(),
this
)
);
}
}
}
public void setVisible(EnemyMarker marker)
{
this.marker = marker;
portrait.sprite = ImagesProvider.getMarkerSprite(marker.enemyType);
enemyName.setText(marker.enemyType.name());
fightResult.gameObject.SetActive(false);
attackBtn.setVisible(true);
gameObject.SetActive(true);
}
public CommunicatableEnemyMarker(EnemyMarker marker,
float radius)
{
this.enemyMarker = marker;
valid = true;
this.radius = radius;
CreateSecondaryLocations();
foreach (Vector3 location in secondaryLocations)
{
var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.transform.position = location;
}
}
private void WorldEventPublisher_SettingsLoaded(object sender, EventArgs e)
{
EnemyMarker.SetMarker(World.Default.Map.MarkerManager.EnemyMarkerSettings);
AbandonedMarker.SetMarker(World.Default.Map.MarkerManager.AbandonedMarkerSettings);
var viewsList = new GridEXValueListItemCollection();
string[] viewItems = World.Default.Views.GetBackgroundViews(false).ToArray();
viewsList.AddRange(viewItems.Select(x => new GridEXValueListItem(x, x)).ToArray());
MarkersGrid.RootTable.Columns["View"].EditValueList = viewsList;
MarkersGrid.RootTable.Columns["View"].DefaultValue = viewItems.FirstOrDefault();
SetMarkersGridDataSource();
}
public static void SuppressHiddenEnemy(EnemyMarker enemy)
{
AttackableObject <EnemyMarker> info = instance.markersForAttack.Find(m => {
return(m.GetObject() == enemy);
});
if (info == null)
{
Debug.LogError("No enemy marker found!");
}
else
{
info.AddSuppressor();
}
}
public static void NoLongerFlankLeftHiddenEnemy(EnemyMarker enemy)
{
AttackableObject <EnemyMarker> info = instance.markersForAttack.Find(m => {
return(m.GetObject() == enemy);
});
if (info == null)
{
Debug.LogError("No enemy marker found!");
}
else
{
info.RemoveLeftFlanker();
}
}
public static void AddCommunicatorSubscriber(CommunicatableEnemyMarker communicator)
{
Integer communicators = null;
EnemyMarker enemyMarker = communicator.GetEnemyMarker();
instance.enemyMarkers.TryGetValue(enemyMarker, out communicators);
if (communicators == null)
{
instance.enemyMarkers.Add(enemyMarker, new Integer(0));
instance.enemyMarkersPublic.Add(enemyMarker);
}
Integer existingCommunicator = instance.enemyMarkers[enemyMarker];
existingCommunicator.value++;
}
void Start()
{
amyTarget = HumanoidStore.GetAmyModel();
enemyMarkerLocations.ForEach(m =>
{
EnemyMarker newMarker = new EnemyMarker(amyTarget, m.position, null);
targeters.ForEach(t =>
{
CommunicatableEnemyMarker newCMarker = new CommunicatableEnemyMarker(
newMarker,
5
);
t.AddEnemyMarker(newCMarker);
});
});
}
public static void RemoveCommunicatorSubscriber(CommunicatableEnemyMarker communicator)
{
Integer communicators = null;
EnemyMarker enemyMarker = communicator.GetEnemyMarker();
instance.enemyMarkers.TryGetValue(enemyMarker, out communicators);
if (communicators != null)
{
communicators.value--;
if (communicators.value == 0)
{
instance.enemyMarkers.Remove(enemyMarker);
instance.enemyMarkersPublic.Remove(enemyMarker);
}
}
}
public static int GetSuppressorsOnHiddenEnemy(
EnemyMarker target
)
{
AttackableObject <EnemyMarker> info = instance.markersForAttack.Find(m => {
return(m.GetObject() == target);
});
if (info == null)
{
Debug.LogError("No enemy marker found!");
return(0);
}
else
{
return(info.GetCoveringFireAttackers());
}
}
public static void GenerateNewTimeline(TimelineAsset originTimeline, TimelineAsset dstTimeline)
{
dstTimeline.CreateMarkerTrack();
foreach (IMarker output in originTimeline.markerTrack.GetMarkers())
{
EnemyMarker marker = output as EnemyMarker;
if (marker == null)
{
Debug.Log("Marker added " + output.time);
continue;
}
double deltaTime = EnemyBase.Distance / marker.enemyParams.speed;
double creationTime = marker.time - deltaTime;
EnemyNotificationMarker copyMarker = dstTimeline.markerTrack.CreateMarker(typeof(EnemyNotificationMarker), creationTime) as EnemyNotificationMarker;
copyMarker.enemyParams = marker.enemyParams;
Debug.Log("Old time " + marker.time + ", New time " + creationTime);
}
}
private void ProcessHiddenEnemy(
EnemyMarker enemy
)
{
int leftFlankers =
HumanoidAttackPlannerCommunications.GetLeftFlankersOnHiddenEnemy(
enemy
);
int rightFlankers =
HumanoidAttackPlannerCommunications.GetRightFlankersOnHiddenEnemy(
enemy
);
int suppressors =
HumanoidAttackPlannerCommunications.GetSuppressorsOnHiddenEnemy(
enemy
);
bool canFlankLeft = leftFlankers < flankParticipationLimit;
bool canFlankRight = rightFlankers < flankParticipationLimit;
bool canSuppress = suppressors < suppressiveFireParticipationLimit;
CanDoAction flankLeftResult = new CanDoAction(
canFlankLeft,
leftFlankers,
AttackAction.FLANK_LEFT
);
CanDoAction flankRightResult = new CanDoAction(
canFlankRight,
rightFlankers,
AttackAction.FLANK_RIGHT
);
CanDoAction suppressorResult = new CanDoAction(
canSuppress,
suppressors,
AttackAction.SUPPRESS_FIRE
);
List <CanDoAction> potentialActions = new List <CanDoAction>();
potentialActions.Add(flankLeftResult);
potentialActions.Add(flankRightResult);
potentialActions.Add(suppressorResult);
potentialActions.OrderBy(pa => {
return(pa.number);
});
foreach (CanDoAction action in potentialActions)
{
if (action.canDo)
{
attackAction = action.action;
switch (action.action)
{
case AttackAction.FLANK_LEFT:
HumanoidAttackPlannerCommunications.FlankLeftHiddenEnemy(
enemy
);
break;
case AttackAction.FLANK_RIGHT:
HumanoidAttackPlannerCommunications.FlankRightHiddenEnemy(
enemy
);
break;
case AttackAction.SUPPRESS_FIRE:
HumanoidAttackPlannerCommunications.SuppressHiddenEnemy(
enemy
);
break;
}
return;
}
}
int rightRelocators =
HumanoidAttackPlannerCommunications.GetRightRelocators().Count;
int leftRelocators =
HumanoidAttackPlannerCommunications.GetLeftRelocators().Count;
if (rightRelocators < leftRelocators)
{
if (rightRelocators < relocateParticipationLimit)
{
attackAction = AttackAction.RELOCATE_RIGHT;
}
}
else
{
if (leftRelocators < relocateParticipationLimit)
{
attackAction = AttackAction.RELOCATE_LEFT;
}
}
}
public void FindNextAction()
{
var boundingEnemies = targeter.GetBoundingEnemies();
var boundingHiddenEnemies = boundingEnemies.Item1;
var boundingVisibleEnemies = boundingEnemies.Item2;
boundingMarkers = boundingHiddenEnemies.ToList();
boundingTargets = boundingVisibleEnemies.ToList();
var currentMarkersLocations = boundingMarkers.Select(m => {
return(m.GetLocation().To2D());
});
var currentTargetsLocations = boundingTargets.Select(m => {
return(m.GetLocation().To2D());
});
enemyBounds =
new ConvexPolygon(
currentMarkersLocations.Concat(
currentTargetsLocations
).ToList()
);
float closestHiddenEnemyDistance = float.MaxValue;
EnemyMarker closestHiddenEnemy = null;
foreach (var hiddenEnemy in boundingHiddenEnemies)
{
float currentDistanceFromPlanner =
Vector2.Distance(
hiddenEnemy.GetLocation().To2D(),
planner.InfoGetCenterBottom().To2D()
);
if (currentDistanceFromPlanner < closestHiddenEnemyDistance)
{
closestHiddenEnemy = hiddenEnemy;
closestHiddenEnemyDistance = currentDistanceFromPlanner;
}
}
float closestVisibleEnemyDistance = float.MaxValue;
EnemyTarget closestVisibleEnemy = null;
foreach (var visibleEnemy in boundingVisibleEnemies)
{
float currentDistanceFromPlanner =
Vector2.Distance(
visibleEnemy.GetLocation().To2D(),
planner.InfoGetCenterBottom().To2D()
);
if (currentDistanceFromPlanner < closestVisibleEnemyDistance)
{
closestVisibleEnemy = visibleEnemy;
closestVisibleEnemyDistance = currentDistanceFromPlanner;
}
}
if (closestVisibleEnemy != null)
{
ProcessVisibleEnemy(closestVisibleEnemy);
}
else if (closestHiddenEnemy != null)
{
ProcessHiddenEnemy(closestHiddenEnemy);
}
else
{
attackAction = AttackAction.NONE;
}
}
