public DotState(Actor a, GpsWatcher watcher, FrozenActorLayer frozenLayer)
{
Watcher = watcher;
if (frozenLayer != null)
{
FrozenActor = frozenLayer.FromID(a.ActorID);
}
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var c = target.Info.Traits.GetOrDefault <ExternalCapturableInfo>();
var canTargetActor = c != null && c.CanBeTargetedBy(self, target.Owner);
cursor = canTargetActor ? "ability" : "move-blocked";
return(canTargetActor);
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
if (target.Info.HasTraitInfo <GarrisonableInfo>())
{
return(true);
}
return(false);
}
public void Tick(Actor self)
{
if (self.Disposed)
{
return;
}
VisibilityHash = 0;
foreach (var player in self.World.Players)
{
FrozenActor frozenActor;
bool isVisible;
if (!initialized)
{
frozenActor = new FrozenActor(self, footprint, player.Shroud, startsRevealed);
isVisible = startsRevealed;
stateByPlayer.Add(player, new FrozenState(frozenActor)
{
IsVisible = isVisible
});
player.PlayerActor.Trait <FrozenActorLayer>().Add(frozenActor);
}
else
{
var state = stateByPlayer[player];
frozenActor = state.FrozenActor;
isVisible = !frozenActor.Visible;
state.IsVisible = isVisible;
}
if (isVisible)
{
VisibilityHash += player.ClientIndex;
}
else
{
continue;
}
frozenActor.Owner = self.Owner;
if (health.Value != null)
{
frozenActor.HP = health.Value.HP;
frozenActor.DamageState = health.Value.DamageState;
}
if (tooltip.Value != null)
{
frozenActor.TooltipInfo = tooltip.Value.TooltipInfo;
frozenActor.TooltipOwner = tooltip.Value.Owner;
}
}
initialized = true;
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
// TODO: Bridges don't yet support FrozenUnderFog.
if (target.Actor != null && target.Actor.HasTrait <BridgeHut>())
{
return(false);
}
return(true);
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var c = target.Info.TraitInfoOrDefault <ExternalCapturableInfo>();
var canTargetActor = c != null && c.CanBeTargetedBy(self, target.Owner);
var capturesInfo = self.Trait <ExternalCaptures>().Info;
cursor = canTargetActor ? capturesInfo.CaptureCursor : capturesInfo.CaptureBlockedCursor;
return(canTargetActor);
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var type = self.Info.TraitInfo <DeliversCashInfo>().Type;
var targetInfo = target.Info.TraitInfoOrDefault <AcceptsDeliveredCashInfo>();
return(targetInfo != null &&
targetInfo.ValidStances.HasStance(target.Owner.Stances[self.Owner]) &&
(targetInfo.ValidTypes.Count == 0 ||
(!string.IsNullOrEmpty(type) && targetInfo.ValidTypes.Contains(type))));
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var stance = self.Owner.RelationshipWith(target.Owner);
if (!info.ValidRelationships.HasRelationship(stance))
{
return(false);
}
return(info.Types.Overlaps(target.Info.GetAllTargetTypes()));
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var stance = self.Owner.Stances[target.Owner];
if (!info.ValidStances.HasStance(stance))
{
return(false);
}
return(info.TargetTypes.Overlaps(target.Info.TraitInfos <ITargetableInfo>().SelectMany(ti => ti.GetTargetTypes())));
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var stance = self.Owner.Stances[target.Owner];
if (!info.ValidStances.HasStance(stance))
{
return(false);
}
return(info.Types.Overlaps(target.Info.GetAllTargetTypes()));
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var stance = self.Owner.Stances[target.Owner];
if (!info.ValidStances.HasStance(stance))
{
return(false);
}
return(target.Info.Traits.WithInterface <ITargetableInfo>().Any(t => t.GetTargetTypes().Intersect(info.Types).Any()));
}
void INotifyCreated.Created(Actor self)
{
frozenStates = new PlayerDictionary <FrozenState>(self.World, (player, playerIndex) =>
{
var frozenActor = new FrozenActor(self, this, footprint, player, startsRevealed);
player.PlayerActor.Trait <FrozenActorLayer>().Add(frozenActor);
return(new FrozenState(frozenActor)
{
IsVisible = startsRevealed
});
});
}
void ICreatesFrozenActors.OnVisibilityChanged(FrozenActor frozen)
{
// Ignore callbacks during initial setup
if (!created)
{
return;
}
// Update state visibility to match the frozen actor to ensure consistency within the tick
// The rest of the state will be updated by ITick.Tick below
frozenStates[frozen.Viewer].IsVisible = !frozen.Visible;
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
// TODO: This doesn't account for disabled traits.
// Actors with FrozenUnderFog should not disable the ExternalCapturable trait.
var c = target.Info.TraitInfoOrDefault <ExternalCapturableInfo>();
var canTargetActor = c != null && c.CanBeTargetedBy(self, target.Owner);
var capturesInfo = self.Trait <ExternalCaptures>().Info;
cursor = canTargetActor ? capturesInfo.CaptureCursor : capturesInfo.CaptureBlockedCursor;
return(canTargetActor);
}
public void Tick(Actor self)
{
if (self.Destroyed)
{
return;
}
VisibilityHash = 0;
foreach (var p in self.World.Players)
{
var isVisible = footprint.Any(p.Shroud.IsVisibleTest(footprintRegion));
visible[p] = isVisible;
if (isVisible)
{
VisibilityHash += p.ClientIndex;
}
}
if (!initialized)
{
foreach (var p in self.World.Players)
{
visible[p] |= startsRevealed;
p.PlayerActor.Trait <FrozenActorLayer>().Add(frozen[p] = new FrozenActor(self, footprint, footprintRegion));
}
initialized = true;
}
foreach (var player in self.World.Players)
{
if (!visible[player])
{
continue;
}
var actor = frozen[player];
actor.Owner = self.Owner;
if (health.Value != null)
{
actor.HP = health.Value.HP;
actor.DamageState = health.Value.DamageState;
}
if (tooltip.Value != null)
{
actor.TooltipInfo = tooltip.Value.TooltipInfo;
actor.TooltipOwner = tooltip.Value.Owner;
}
}
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
if (!target.Info.Traits.Contains<EngineerRepairable>())
return false;
if (self.Owner.Stances[target.Owner] != Stance.Ally)
return false;
if (target.DamageState == DamageState.Undamaged)
cursor = "goldwrench-blocked";
return true;
}
public void Tick(Actor self)
{
if (self.Destroyed)
{
return;
}
VisibilityHash = 0;
foreach (var p in self.World.Players)
{
visible[p] = footprint.Any(c => p.Shroud.IsVisible(c));
if (visible[p])
{
VisibilityHash += p.ClientIndex;
}
}
if (!initialized)
{
foreach (var p in self.World.Players)
{
visible[p] |= startsRevealed;
frozen[p] = new FrozenActor(self, footprint);
p.PlayerActor.Trait <FrozenActorLayer>().Add(frozen[p]);
}
initialized = true;
}
foreach (var player in self.World.Players)
{
if (!visible[player])
{
continue;
}
frozen[player].Owner = self.Owner;
if (health.Value != null)
{
frozen[player].HP = health.Value.HP;
frozen[player].DamageState = health.Value.DamageState;
}
if (tooltip.Value != null)
{
frozen[player].TooltipName = tooltip.Value.Name();
frozen[player].TooltipOwner = tooltip.Value.Owner();
}
}
}
public void Tick(Actor self)
{
if (self.Disposed)
{
return;
}
VisibilityHash = 0;
foreach (var player in self.World.Players)
{
bool isVisible;
FrozenActor frozenActor;
if (!initialized)
{
frozen[player] = frozenActor = new FrozenActor(self, footprint, player.Shroud);
frozen[player].NeedRenderables = frozenActor.NeedRenderables = startsRevealed;
player.PlayerActor.Trait <FrozenActorLayer>().Add(frozenActor);
isVisible = visible[player] |= startsRevealed;
}
else
{
frozenActor = frozen[player];
isVisible = visible[player] = !frozenActor.Visible;
}
if (isVisible)
{
VisibilityHash += player.ClientIndex;
}
else
{
continue;
}
frozenActor.Owner = self.Owner;
if (health.Value != null)
{
frozenActor.HP = health.Value.HP;
frozenActor.DamageState = health.Value.DamageState;
}
if (tooltip.Value != null)
{
frozenActor.TooltipInfo = tooltip.Value.TooltipInfo;
frozenActor.TooltipOwner = tooltip.Value.Owner;
}
}
initialized = true;
}
public void UpdateMouseover()
{
TooltipType = WorldTooltipType.None;
ActorTooltipExtra = null;
var cell = worldRenderer.Viewport.ViewToWorld(Viewport.LastMousePos);
if (!world.Map.Contains(cell))
{
return;
}
if (world.ShroudObscures(cell))
{
TooltipType = WorldTooltipType.Unexplored;
return;
}
var worldPixel = worldRenderer.Viewport.ViewToWorldPx(Viewport.LastMousePos);
var underCursor = world.ScreenMap.ActorsAt(worldPixel)
.Where(a => !world.FogObscures(a) && a.Info.HasTraitInfo <ITooltipInfo>())
.WithHighestSelectionPriority(worldPixel);
if (underCursor != null)
{
ActorTooltip = underCursor.TraitsImplementing <ITooltip>().First();
ActorTooltipExtra = underCursor.TraitsImplementing <IProvideTooltipInfo>().ToArray();
TooltipType = WorldTooltipType.Actor;
return;
}
var frozen = world.ScreenMap.FrozenActorsAt(world.RenderPlayer, worldPixel)
.Where(a => a.TooltipInfo != null && a.IsValid)
.WithHighestSelectionPriority(worldPixel);
if (frozen != null)
{
var actor = frozen.Actor;
if (actor != null && actor.TraitsImplementing <IVisibilityModifier>().Any(t => !t.IsVisible(actor, world.RenderPlayer)))
{
return;
}
FrozenActorTooltip = frozen;
if (frozen.Actor != null)
{
ActorTooltipExtra = frozen.Actor.TraitsImplementing <IProvideTooltipInfo>().ToArray();
}
TooltipType = WorldTooltipType.FrozenActor;
}
}
/// <summary>Checks if the weapon is valid against (can target) the frozen actor.</summary>
public bool IsValidAgainst(FrozenActor victim, Actor firedBy)
{
if (!IsValidTarget(victim.TargetTypes))
{
return(false);
}
if (!Warheads.Any(w => w.IsValidAgainst(victim, firedBy)))
{
return(false);
}
return(true);
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var trait = self.Info.TraitInfo <AcolytePreyInfo>();
if (!trait.TargetActors.Contains(target.Info.Name))
{
return(false);
}
if (target.Info.HasTraitInfo <ValidPreyTargetInfo>() && !target.Actor.TraitOrDefault <ValidPreyTarget>().Actors.Any())
{
return(false);
}
return(true);
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var relationship = self.Owner.RelationshipWith(target.Owner);
if (!info.TargetRelationships.HasRelationship(relationship) && !modifiers.HasModifier(TargetModifiers.ForceAttack))
{
return(false);
}
if (!info.ForceTargetRelationships.HasRelationship(relationship) && modifiers.HasModifier(TargetModifiers.ForceAttack))
{
return(false);
}
return(info.Types.Overlaps(target.Info.GetAllTargetTypes()));
}
public bool CanBeTargetedBy(FrozenActor frozenActor, Actor captor, Captures captures)
{
if (captures.IsTraitDisabled)
{
return(false);
}
// TODO: FrozenActors don't yet have a way of caching conditions, so we can't filter disabled traits
// This therefore assumes that all Capturable traits are enabled, which is probably wrong.
// Actors with FrozenUnderFog should therefore not disable the Capturable trait.
var stance = captor.Owner.RelationshipWith(frozenActor.Owner);
return(frozenActor.Info.TraitInfos <CapturableInfo>()
.Any(c => c.ValidRelationships.HasStance(stance) && captures.Info.CaptureTypes.Overlaps(c.Types)));
}
public bool IsValidAgainst(FrozenActor a)
{
var targetable = a.Info.Traits.GetOrDefault <ITargetableInfo>();
if (targetable == null || !ValidTargets.Intersect(targetable.GetTargetTypes()).Any())
{
return(false);
}
if (Warheads.All(w => w.EffectivenessAgainst(a.Info) <= 0))
{
return(false);
}
return(true);
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var stance = target.Owner.RelationshipWith(self.Owner);
if (!info.TargetRelationships.HasStance(stance) && !modifiers.HasModifier(TargetModifiers.ForceAttack))
{
return(false);
}
if (!info.ForceTargetRelationships.HasStance(stance) && modifiers.HasModifier(TargetModifiers.ForceAttack))
{
return(false);
}
return(target.Info.TraitInfos <IDemolishableInfo>().Any(i => i.IsValidTarget(target.Info, self)));
}
public void Created(Actor self)
{
frozenStates = new PlayerDictionary <FrozenState>(self.World, (player, playerIndex) =>
{
var frozenActor = new FrozenActor(self, footprint, player.Shroud, startsRevealed);
if (startsRevealed)
{
UpdateFrozenActor(self, frozenActor, playerIndex);
}
player.PlayerActor.Trait <FrozenActorLayer>().Add(frozenActor);
return(new FrozenState(frozenActor)
{
IsVisible = startsRevealed
});
});
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var info = target.Info.Traits.GetOrDefault <InfiltratableInfo>();
if (info == null)
{
return(false);
}
if (!infiltrationTypes.Contains(info.Type))
{
cursor = "enter-blocked";
}
return(true);
}
/// <summary>Checks if the weapon is valid against (can target) the frozen actor.</summary>
public bool IsValidAgainst(FrozenActor victim, Actor firedBy)
{
var targetable = victim.Info.Traits.GetOrDefault <ITargetableInfo>();
if (targetable == null || !IsValidTarget(targetable.GetTargetTypes()))
{
return(false);
}
if (!Warheads.Any(w => w.IsValidAgainst(victim, firedBy)))
{
return(false);
}
return(true);
}
public bool IsValidAgainst(FrozenActor victim, Actor firedBy)
{
var stance = firedBy.Owner.Stances[victim.Owner];
if (!ValidStances.HasStance(stance))
{
return(false);
}
if (!IsValidTarget(victim.TargetTypes))
{
return(false);
}
return(true);
}
public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
{
var c = target.Info.TraitInfoOrDefault <CapturableInfo>();
if (c == null || !c.CanBeTargetedBy(self, target.Owner))
{
cursor = "enter-blocked";
return(false);
}
var health = target.Info.TraitInfoOrDefault <HealthInfo>();
var lowEnoughHealth = target.HP <= c.CaptureThreshold * health.HP;
cursor = !sabotage || lowEnoughHealth || target.Owner.NonCombatant
? "enter" : "capture";
return(true);
}
