public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
var info = Info as SpawnActorPowerInfo;
if (info.Actor != null)
{
self.World.AddFrameEndTask(w =>
{
var location = self.World.Map.CenterOfCell(order.TargetLocation);
Game.Sound.Play(info.DeploySound, location);
if (!string.IsNullOrEmpty(info.EffectSequence) && !string.IsNullOrEmpty(info.EffectPalette))
w.Add(new SpriteEffect(location, w, info.EffectImage, info.EffectSequence, info.EffectPalette));
var actor = w.CreateActor(info.Actor, new TypeDictionary
{
new LocationInit(order.TargetLocation),
new OwnerInit(self.Owner),
});
if (info.LifeTime > -1)
{
actor.QueueActivity(new Wait(info.LifeTime));
actor.QueueActivity(new RemoveSelf());
}
});
}
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
self.Trait<RenderBuilding>().PlayCustomAnim(self, "active");
Sound.Play(info.GrantUpgradeSound, self.World.Map.CenterOfCell(order.TargetLocation));
foreach (var a in UnitsInRange(order.TargetLocation))
{
var um = a.TraitOrDefault<UpgradeManager>();
if (um == null)
continue;
foreach (var u in info.Upgrades)
{
if (info.Duration > 0)
{
if (um.AcknowledgesUpgrade(a, u))
um.GrantTimedUpgrade(a, u, info.Duration);
}
else
{
if (um.AcceptsUpgrade(a, u))
um.GrantUpgrade(a, u, this);
}
}
}
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
var wsb = self.TraitOrDefault<WithSpriteBody>();
if (wsb != null && wsb.DefaultAnimation.HasSequence(info.GrantUpgradeSequence))
wsb.PlayCustomAnimation(self, info.GrantUpgradeSequence);
Game.Sound.Play(info.GrantUpgradeSound, self.World.Map.CenterOfCell(order.TargetLocation));
foreach (var a in UnitsInRange(order.TargetLocation))
{
var um = a.TraitOrDefault<UpgradeManager>();
if (um == null)
continue;
foreach (var u in info.Upgrades)
{
if (info.Duration > 0)
{
if (um.AcknowledgesUpgrade(a, u))
um.GrantTimedUpgrade(a, u, info.Duration);
}
else
{
if (um.AcceptsUpgrade(a, u))
um.GrantUpgrade(a, u, this);
}
}
}
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
var enterCell = self.World.ChooseRandomEdgeCell();
var altitude = self.World.Map.Rules.Actors["u2"].Traits.Get<PlaneInfo>().CruiseAltitude;
var plane = self.World.CreateActor("u2", new TypeDictionary
{
new CenterPositionInit(enterCell.CenterPosition + new WVec(WRange.Zero, WRange.Zero, altitude)),
new OwnerInit(self.Owner),
new FacingInit(Util.GetFacing(order.TargetLocation - enterCell, 0))
});
plane.CancelActivity();
plane.QueueActivity(new Fly(plane, Target.FromCell(order.TargetLocation)));
plane.QueueActivity(new CallFunc(() => plane.World.AddFrameEndTask( w =>
{
var camera = w.CreateActor("camera", new TypeDictionary
{
new LocationInit( order.TargetLocation ),
new OwnerInit( self.Owner ),
});
camera.QueueActivity(new Wait(25 * ((SpyPlanePowerInfo)Info).RevealTime));
camera.QueueActivity(new RemoveSelf());
})));
plane.QueueActivity(new FlyOffMap());
plane.QueueActivity(new RemoveSelf());
}
public SelectTarget(string order, SupportPowerManager manager, IronCurtainPower power)
{
this.manager = manager;
this.order = order;
this.power = power;
this.range = (power.Info as IronCurtainPowerInfo).Range;
tile = UiOverlay.SynthesizeTile(0x04);
}
public SelectTarget(string order, SupportPowerManager manager, IronCurtainPower power)
{
this.manager = manager;
this.order = order;
this.power = power;
this.range = (power.Info as IronCurtainPowerInfo).Range;
tile = SequenceProvider.GetSequence("overlay", "target-select").GetSprite(0);
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
// TODO: Reveal submarines
// Should this play for all players?
Sound.Play("sonpulse.aud");
}
public override IOrderGenerator OrderGenerator(string order, SupportPowerManager manager)
{
// Clear selection if using Left-Click Orders
if (Game.Settings.Game.UseClassicMouseStyle)
manager.Self.World.Selection.Clear();
Sound.PlayToPlayer(manager.Self.Owner, Info.SelectTargetSound);
var info = Info as IonCannonPowerInfo;
return new SelectGenericPowerTarget(order, manager, info.Cursor, MouseButton.Left);
}
public SupportPowersWidget(World world, WorldRenderer worldRenderer)
{
this.worldRenderer = worldRenderer;
spm = world.LocalPlayer.PlayerActor.Trait<SupportPowerManager>();
tooltipContainer = Exts.Lazy(() =>
Ui.Root.Get<TooltipContainerWidget>(TooltipContainer));
icon = new Animation(world, "icon");
clock = new Animation(world, ClockAnimation);
}
public virtual void Activate(Actor self, Order order, SupportPowerManager manager)
{
if (Info.DisplayRadarPing && manager.RadarPings != null)
{
ping = manager.RadarPings.Value.Add(
() => order.Player.IsAlliedWith(self.World.RenderPlayer),
order.TargetLocation.CenterPosition,
order.Player.Color.RGB,
Info.RadarPingDuration);
}
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
self.Trait<RenderBuilding>().PlayCustomAnim(self, "active");
Sound.Play(info.IronCurtainSound, self.World.Map.CenterOfCell(order.TargetLocation));
foreach (var target in UnitsInRange(order.TargetLocation)
.Where(a => a.Owner.Stances[self.Owner] == Stance.Ally))
target.Trait<IronCurtainable>().Activate(target, ((IronCurtainPowerInfo)Info).Duration * 25);
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
self.World.AddFrameEndTask(w =>
{
Sound.PlayToPlayer(self.Owner, Info.LaunchSound);
w.Add(new SatelliteLaunch(self));
owner.Launch(self, Info);
});
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
self.World.AddFrameEndTask(w =>
{
Game.Sound.PlayToPlayer(SoundType.World, self.Owner, Info.LaunchSound);
Game.Sound.PlayNotification(self.World.Map.Rules, self.Owner, "Speech",
Info.LaunchSpeechNotification, self.Owner.Faction.InternalName);
w.Add(new SatelliteLaunch(self, info));
});
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
foreach (var target in UnitsInRange(order.ExtraLocation))
{
var cs = target.Trait<Chronoshiftable>();
var targetCell = target.Location + (order.TargetLocation - order.ExtraLocation);
var cpi = Info as ChronoshiftPowerInfo;
if (self.Owner.Shroud.IsExplored(targetCell) && cs.CanChronoshiftTo(target, targetCell))
cs.Teleport(target, targetCell, cpi.Duration * 25, cpi.KillCargo, self);
}
}
public SupportPowersWidget(World world, WorldRenderer worldRenderer)
{
this.worldRenderer = worldRenderer;
spm = world.LocalPlayer.PlayerActor.Trait<SupportPowerManager>();
tooltipContainer = Lazy.New(() =>
Ui.Root.Get<TooltipContainerWidget>(TooltipContainer));
iconSprites = Rules.Info.Values.SelectMany( u => u.Traits.WithInterface<SupportPowerInfo>() )
.Select(u => u.Image).Distinct()
.ToDictionary(
u => u,
u => Game.modData.SpriteLoader.LoadAllSprites(u)[0]);
clock = new Animation("clock");
}
public SelectAttackPowerTarget(Actor self, string order, SupportPowerManager manager, string cursor, MouseButton button, AttackBase attack)
{
// Clear selection if using Left-Click Orders
if (Game.Settings.Game.UseClassicMouseStyle)
{
manager.Self.World.Selection.Clear();
}
instance = manager.GetPowersForActor(self).FirstOrDefault();
this.manager = manager;
this.order = order;
this.cursor = cursor;
expectedButton = button;
this.attack = attack;
cursorBlocked = cursor + "-blocked";
}
public override void SelectTarget(Actor self, string order, SupportPowerManager manager)
{
if (info.UseDirectionalTarget)
{
Game.Sound.PlayToPlayer(SoundType.UI, manager.Self.Owner, Info.SelectTargetSound);
Game.Sound.PlayNotification(self.World.Map.Rules, self.Owner, "Speech",
Info.SelectTargetSpeechNotification, self.Owner.Faction.InternalName);
self.World.OrderGenerator = new SelectDirectionalTarget(self.World, order, manager, Info.Cursor,
info.DirectionArrowAnimation, info.DirectionArrowPalette);
}
else
{
base.SelectTarget(self, order, manager);
}
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
self.World.AddFrameEndTask(w =>
{
PlayLaunchSounds();
w.Add(new SatelliteLaunchCA(self, info));
if (conditionToken == ConditionManager.InvalidConditionToken)
{
conditionToken = conditionManager.GrantCondition(self, info.Condition);
}
});
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
PlayLaunchSounds();
from = order.ExtraLocation;
to = self.World.Map.CellContaining(order.Target.CenterPosition);
foreach (var notify in self.TraitsImplementing <INotifyChronosphere>())
{
notify.Teleporting(self.World.Map.CenterOfCell(order.ExtraLocation), order.Target.CenterPosition);
}
ticks = ((ChronoshiftPowerCAInfo)Info).Delay;
activated = true;
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
var info = (ChronoshiftPowerInfo)Info;
var targetDelta = self.World.Map.CellContaining(order.Target.CenterPosition) - order.ExtraLocation;
foreach (var target in UnitsInRange(order.ExtraLocation))
{
var cs = target.TraitsImplementing <Chronoshiftable>()
.FirstEnabledTraitOrDefault();
if (cs == null)
{
continue;
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
foreach (var target in UnitsInRange(order.ExtraLocation))
{
var cs = target.Trait <Chronoshiftable>();
var targetCell = target.Location + (order.TargetLocation - order.ExtraLocation);
var cpi = Info as ChronoshiftPowerInfo;
if (self.Owner.Shroud.IsExplored(targetCell) && cs.CanChronoshiftTo(target, targetCell))
{
cs.Teleport(target, targetCell, cpi.Duration, cpi.KillCargo, self);
}
}
}
// Called by the host's player creation code
public void Activate(Player p)
{
this.p = p;
enabled = true;
playerPower = p.PlayerActor.Trait <PowerManager>();
supportPowerMngr = p.PlayerActor.Trait <SupportPowerManager>();
playerResource = p.PlayerActor.Trait <PlayerResources>();
builders = new BaseBuilder[] {
new BaseBuilder(this, "Building", q => ChooseBuildingToBuild(q, false)),
new BaseBuilder(this, "Defense", q => ChooseBuildingToBuild(q, true))
};
random = new XRandom((int)p.PlayerActor.ActorID);
resourceTypes = Rules.Info["world"].Traits.WithInterface <ResourceTypeInfo>()
.Select(t => t.TerrainType).ToArray();
}
public SelectDestination(World world, string order, SupportPowerManager manager, ChronoshiftPower power, CPos sourceLocation)
{
this.manager = manager;
this.order = order;
this.power = power;
this.sourceLocation = sourceLocation;
var info = (ChronoshiftPowerInfo)power.Info;
range = info.Range;
var tileset = world.Map.Tileset.ToLowerInvariant();
validTile = world.Map.Rules.Sequences.GetSequence(info.OverlaySpriteGroup, info.ValidTileSequencePrefix + tileset).GetSprite(0);
invalidTile = world.Map.Rules.Sequences.GetSequence(info.OverlaySpriteGroup, info.InvalidTileSequence).GetSprite(0);
sourceTile = world.Map.Rules.Sequences.GetSequence(info.OverlaySpriteGroup, info.SourceTileSequence).GetSprite(0);
}
public SelectChronoshiftTarget(World world, string order, SupportPowerManager manager, ChronoshiftPower power)
{
// Clear selection if using Left-Click Orders
if (Game.Settings.Game.UseClassicMouseStyle)
{
manager.Self.World.Selection.Clear();
}
this.manager = manager;
this.order = order;
this.power = power;
var info = (ChronoshiftPowerInfo)power.Info;
range = info.Range;
tile = world.Map.Rules.Sequences.GetSequence(info.FootprintImage, info.SourceFootprintSequence).GetSprite(0);
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
var info = Info as ProduceActorPowerCAInfo;
var producers = self.World.ActorsWithTrait <Production>()
.Where(x => x.Actor.Owner == self.Owner &&
!x.Trait.IsTraitDisabled &&
x.Trait.Info.Produces.Contains(info.Type))
.OrderByDescending(x => x.Actor.Exits())
.ThenByDescending(x => x.Actor.ActorID);
// TODO: The power should not reset if the production fails.
// Fixing this will require a larger rework of the support power code
var activated = false;
foreach (var p in producers)
{
foreach (var name in info.Actors)
{
var ai = self.World.Map.Rules.Actors[name];
var inits = new TypeDictionary
{
new OwnerInit(self.Owner),
new FactionInit(BuildableInfo.GetInitialFaction(ai, faction))
};
activated |= p.Trait.Produce(p.Actor, ai, info.Type, inits);
}
if (activated)
{
break;
}
}
if (activated)
{
Game.Sound.PlayNotification(self.World.Map.Rules, manager.Self.Owner, "Speech", info.ReadyAudio, self.Owner.Faction.InternalName);
}
else
{
Game.Sound.PlayNotification(self.World.Map.Rules, manager.Self.Owner, "Speech", info.BlockedAudio, self.Owner.Faction.InternalName);
}
}
public SelectChronoshiftTarget(World world, string order, SupportPowerManager manager, ChronoshiftPower power)
{
// Clear selection if using Left-Click Orders
if (Game.Settings.Game.UseClassicMouseStyle)
{
manager.Self.World.Selection.Clear();
}
this.manager = manager;
this.order = order;
this.power = power;
var info = (ChronoshiftPowerInfo)power.Info;
footprint = info.Footprint.Where(c => !char.IsWhiteSpace(c)).ToArray();
dimensions = info.Dimensions;
tile = world.Map.Rules.Sequences.GetSequence(info.FootprintImage, info.SourceFootprintSequence).GetSprite(0);
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
var wsb = self.TraitOrDefault<WithSpriteBody>();
if (wsb != null && wsb.DefaultAnimation.HasSequence(info.Sequence))
wsb.PlayCustomAnimation(self, info.Sequence, () => wsb.CancelCustomAnimation(self));
Game.Sound.Play(SoundType.World, info.OnFireSound, self.World.Map.CenterOfCell(order.TargetLocation));
foreach (var a in UnitsInRange(order.TargetLocation))
{
var um = a.TraitOrDefault<UpgradeManager>();
// Condition token is ignored because we never revoke this condition.
if (um != null)
um.GrantCondition(a, info.Condition, true, info.Duration);
}
}
public void Activate(Player p)
{
Player = p;
IsEnabled = true;
playerPower = p.PlayerActor.Trait <PowerManager>();
supportPowerMngr = p.PlayerActor.Trait <SupportPowerManager>();
playerResource = p.PlayerActor.Trait <PlayerResources>();
froenLayer = p.PlayerActor.Trait <FrozenActorLayer>();
foreach (var building in Info.BuildingQueues)
{
builders.Add(new BaseBuilder(this, building, p, playerPower, playerResource));
}
foreach (var defense in Info.DefenseQueues)
{
builders.Add(new BaseBuilder(this, defense, p, playerPower, playerResource));
}
Random = new MersenneTwister(WarGame.CosmeticRandom.Next());
//Avoid all AIs trying to rush in the same tick, randomize their initial rush a little.
var smallFractionOfRushInterval = Info.RushInterval / 20;
rushTicks = Random.Next(Info.RushInterval - smallFractionOfRushInterval, Info.RushInterval + smallFractionOfRushInterval);
//Avoid all AIs reevaluating assignments on the same tick, randomize their initial evaluation delay.
assignRolesTicks = Random.Next(0, Info.AssignRolesInterval);
attackForceTicks = Random.Next(0, Info.AttackForceInterval);
minAttackForceDelayTicks = Random.Next(0, Info.MinimumAttackForceDelay);
minCaptureDelayTicks = Random.Next(0, Info.MinimumCaptureDelay);
var tileset = World.Map.Rules.TileSet;
resourceTypeIndices = new BitArray(tileset.TerrainInfo.Length);//Big enough
foreach (var t in Map.Rules.Actors["world"].TraitInfos <ResourceTypeInfo>())
{
resourceTypeIndices.Set(tileset.GetTerrainIndex(t.TerrainType), true);
}
}
public SupportPowersWidget(World world, WorldRenderer worldRenderer)
{
this.worldRenderer = worldRenderer;
spm = world.LocalPlayer.PlayerActor.Trait <SupportPowerManager>();
tooltipContainer = Lazy.New(() =>
Ui.Root.GetWidget <TooltipContainerWidget>(TooltipContainer));
iconSprites = Rules.Info.Values.SelectMany(u => u.Traits.WithInterface <SupportPowerInfo>())
.Select(u => u.Image).Distinct()
.ToDictionary(
u => u,
u => Game.modData.SpriteLoader.LoadAllSprites(u)[0]);
clock = new Animation("clock");
overlayFont = Game.Renderer.Fonts["TinyBold"];
holdOffset = new float2(32, 24) - overlayFont.Measure("On Hold") / 2;
readyOffset = new float2(32, 24) - overlayFont.Measure("Ready") / 2;
timeOffset = new float2(32, 24) - overlayFont.Measure(WidgetUtils.FormatTime(0)) / 2;
}
public SupportPowersWidget(World world, WorldRenderer worldRenderer)
{
this.worldRenderer = worldRenderer;
spm = world.LocalPlayer.PlayerActor.Trait<SupportPowerManager>();
tooltipContainer = Lazy.New(() =>
Ui.Root.Get<TooltipContainerWidget>(TooltipContainer));
iconSprites = Rules.Info.Values.SelectMany( u => u.Traits.WithInterface<SupportPowerInfo>() )
.Select(u => u.Image).Distinct()
.ToDictionary(
u => u,
u => Game.modData.SpriteLoader.LoadAllSprites(u)[0]);
clock = new Animation("clock");
overlayFont = Game.Renderer.Fonts["TinyBold"];
holdOffset = new float2(32,24) - overlayFont.Measure("On Hold") / 2;
readyOffset = new float2(32,24) - overlayFont.Measure("Ready") / 2;
timeOffset = new float2(32,24) - overlayFont.Measure(WidgetUtils.FormatTime(0)) / 2;
}
public WithSupportPowerOverlay(Actor self, WithSupportPowerOverlayInfo info) : base(info)
{
this.info = info;
this.self = self;
var rs = self.Trait <RenderSprites>();
var body = self.Trait <BodyOrientation>();
supportPowerManager = self.Owner.PlayerActor.Trait <SupportPowerManager>();
powers = supportPowerManager.GetPowersForActor(self);
buildComplete = !self.Info.HasTraitInfo <BuildingInfo>(); // always render instantly for units
overlay = new Animation(self.World, rs.GetImage(self));
var anim = new AnimationWithOffset(overlay,
() => body.LocalToWorld(WVec.Zero.Rotate(body.QuantizeOrientation(self, self.Orientation))),
() => !visible || !buildComplete);
rs.Add(anim, info.Palette, info.IsPlayerPalette);
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
var info = Info as ProduceActorPowerInfo;
var sp = self.TraitsImplementing<Production>()
.FirstOrDefault(p => p.Info.Produces.Contains(info.Type));
// TODO: The power should not reset if the production fails.
// Fixing this will require a larger rework of the support power code
var activated = false;
if (sp != null)
foreach (var name in info.Actors)
activated |= sp.Produce(self, self.World.Map.Rules.Actors[name], faction);
if (activated)
Game.Sound.PlayNotification(self.World.Map.Rules, manager.Self.Owner, "Speech", info.ReadyAudio, self.Owner.Faction.InternalName);
else
Game.Sound.PlayNotification(self.World.Map.Rules, manager.Self.Owner, "Speech", info.BlockedAudio, self.Owner.Faction.InternalName);
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
var info = (ParatroopersPowerInfo)Info;
var items = info.DropItems;
var startPos = self.World.ChooseRandomEdgeCell();
self.World.AddFrameEndTask(w =>
{
var flare = info.FlareType != null ? w.CreateActor(info.FlareType, new TypeDictionary
{
new LocationInit( order.TargetLocation ),
new OwnerInit( self.Owner ),
}) : null;
if (flare != null)
{
flare.QueueActivity(new Wait(info.FlareTime));
flare.QueueActivity(new RemoveSelf());
}
var altitude = self.World.Map.Rules.Actors[info.UnitType].Traits.Get<PlaneInfo>().CruiseAltitude;
var a = w.CreateActor(info.UnitType, new TypeDictionary
{
new CenterPositionInit(startPos.CenterPosition + new WVec(WRange.Zero, WRange.Zero, altitude)),
new OwnerInit(self.Owner),
new FacingInit(Util.GetFacing(order.TargetLocation - startPos, 0))
});
a.CancelActivity();
a.QueueActivity(new FlyAttack(Target.FromOrder(order)));
a.Trait<ParaDrop>().SetLZ(order.TargetLocation);
var cargo = a.Trait<Cargo>();
foreach (var i in items)
cargo.Load(a, self.World.CreateActor(false, i.ToLowerInvariant(),
new TypeDictionary { new OwnerInit( a.Owner ) }));
});
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
self.World.AddFrameEndTask(w =>
{
Game.Sound.Play(Info.LaunchSound, self.World.Map.CenterOfCell(order.TargetLocation));
w.Add(new IonCannon(self.Owner, info.WeaponInfo, w, order.TargetLocation, info.Effect, info.EffectPalette, info.WeaponDelay));
if (info.CameraActor == null)
return;
var camera = w.CreateActor(info.CameraActor, new TypeDictionary
{
new LocationInit(order.TargetLocation),
new OwnerInit(self.Owner),
});
camera.QueueActivity(new Wait(info.CameraRemoveDelay));
camera.QueueActivity(new RemoveSelf());
});
}
public void Activate(Player p)
{
this.p = p;
this.world = p.World;
GameStarted = true;
random = new XRandom((int)p.PlayerActor.ActorID);
SpecialPowers = p.PlayerActor.Trait<SupportPowerManager>();
Power = p.PlayerActor.Trait<PowerManager>();
Resources = p.PlayerActor.Trait<PlayerResources>();
squadmanager = new SquadManager(this);
// Initialize builders
Builders = new List<IAIBuilder>() { new BaseBuilder(this), new DefenseBuilder(this),
new InfantryBuilder(this), new VehicleBuilder(this),
new AircraftBuilder(this), new ShipBuilder(this) };
// Have the bot cheat, gets free 500 000 credits at the start of the match
Resources.GiveCash(500000);
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
var wsb = self.TraitOrDefault <WithSpriteBody>();
if (wsb != null && wsb.DefaultAnimation.HasSequence(info.Sequence))
{
wsb.PlayCustomAnimation(self, info.Sequence);
}
Game.Sound.Play(SoundType.World, info.OnFireSound, order.Target.CenterPosition);
IEnumerable <Actor> actors = null;
if (!info.EffectToAll)
{
actors = UnitsInRange(self.World.Map.CellContaining(order.Target.CenterPosition));
}
else
{
actors = self.World.Actors.Where(o => o.Owner == self.Owner);
}
foreach (var actor in actors)
{
var external = actor.TraitsImplementing <ExternalCondition>()
.FirstOrDefault(t => t.Info.Condition == info.Condition && t.CanGrantCondition(actor, self));
if (external != null)
{
external.GrantCondition(actor, self, info.Duration);
}
}
if (info.LowPower)
{
powerMgr.TriggerPowerOutage(info.LowPowerDuration);
}
}
public SelectDestination(World world, string order, SupportPowerManager manager, ChronoshiftPower power, CPos sourceLocation)
{
this.manager = manager;
this.order = order;
this.power = power;
this.sourceLocation = sourceLocation;
var info = (ChronoshiftPowerInfo)power.Info;
footprint = info.Footprint.Where(c => !char.IsWhiteSpace(c)).ToArray();
dimensions = info.Dimensions;
var sequences = world.Map.Rules.Sequences;
var tilesetValid = info.ValidFootprintSequence + "-" + world.Map.Tileset.ToLowerInvariant();
if (sequences.HasSequence(info.FootprintImage, tilesetValid))
{
var validSequence = sequences.GetSequence(info.FootprintImage, tilesetValid);
validTile = validSequence.GetSprite(0);
validAlpha = validSequence.GetAlpha(0);
}
else
{
var validSequence = sequences.GetSequence(info.FootprintImage, info.ValidFootprintSequence);
validTile = validSequence.GetSprite(0);
validAlpha = validSequence.GetAlpha(0);
}
var invalidSequence = sequences.GetSequence(info.FootprintImage, info.InvalidFootprintSequence);
invalidTile = invalidSequence.GetSprite(0);
invalidAlpha = invalidSequence.GetAlpha(0);
var sourceSequence = sequences.GetSequence(info.FootprintImage, info.SourceFootprintSequence);
sourceTile = sourceSequence.GetSprite(0);
sourceAlpha = sourceSequence.GetAlpha(0);
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
targetPos = order.Target.CenterPosition;
self.World.AddFrameEndTask(w =>
{
PlayLaunchSounds();
launched = true;
duration = info.Duration;
if (!string.IsNullOrEmpty(info.PaletteEffectType))
{
var paletteEffects = w.WorldActor.TraitsImplementing <WeatherPaletteEffect>().Where(p => p.Info.Type == info.PaletteEffectType);
foreach (var paletteEffect in paletteEffects)
{
paletteEffect.Enable(-1);
}
}
});
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
PlayLaunchSounds();
if (!string.IsNullOrEmpty(info.ActiveCondition) && activeToken == Actor.InvalidConditionToken)
{
Ticks = info.Duration;
activeToken = self.GrantCondition(info.ActiveCondition);
}
var wsb = self.TraitOrDefault <WithSpriteBody>();
if (wsb != null && wsb.DefaultAnimation.HasSequence(info.Sequence))
{
wsb.PlayCustomAnimation(self, info.Sequence);
}
Game.Sound.Play(SoundType.World, info.OnFireSound, order.Target.CenterPosition);
foreach (var a in UnitsInRange(self.World.Map.CellContaining(order.Target.CenterPosition)))
{
a.TraitsImplementing <ExternalCondition>()
.FirstOrDefault(t => t.Info.Condition == info.Condition && t.CanGrantCondition(a, self))
?.GrantCondition(a, self, info.Duration);
}
if (info.Weapon != null)
{
var targetPosition = order.Target.CenterPosition + new WVec(WDist.Zero, WDist.Zero, info.AirburstAltitude);
Action detonateWeapon = () => self.World.AddFrameEndTask(w => info.WeaponInfo.Impact(Target.FromPos(targetPosition), self));
self.World.AddFrameEndTask(w => w.Add(new DelayedAction(info.ActivationDelay, detonateWeapon)));
}
}
// Called by the host's player creation code
public void Activate(Player p)
{
this.p = p;
enabled = true;
playerPower = p.PlayerActor.Trait <PowerManager>();
supportPowerMngr = p.PlayerActor.Trait <SupportPowerManager>();
playerResource = p.PlayerActor.Trait <PlayerResources>();
foreach (var building in Info.BuildingQueues)
{
builders.Add(new BaseBuilder(this, building, p, playerPower, playerResource));
}
foreach (var defense in Info.DefenseQueues)
{
builders.Add(new BaseBuilder(this, defense, p, playerPower, playerResource));
}
random = new MersenneTwister((int)p.PlayerActor.ActorID);
resourceTypeIndices = new HashSet <int>(
Map.Rules.Actors["world"].Traits
.WithInterface <ResourceTypeInfo>()
.Select(t => world.TileSet.GetTerrainIndex(t.TerrainType)));
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
self.World.AddFrameEndTask(w =>
{
Game.Sound.Play(Info.LaunchSound, self.World.Map.CenterOfCell(order.TargetLocation));
w.Add(new IonCannon(self.Owner, info.WeaponInfo, w, order.TargetLocation, info.Effect, info.EffectPalette, info.WeaponDelay));
if (info.CameraActor == null)
{
return;
}
var camera = w.CreateActor(info.CameraActor, new TypeDictionary
{
new LocationInit(order.TargetLocation),
new OwnerInit(self.Owner),
});
camera.QueueActivity(new Wait(info.CameraRemoveDelay));
camera.QueueActivity(new RemoveSelf());
});
}
public SelectDestination(string order, SupportPowerManager manager, ChronoshiftPower power, int2 sourceLocation)
{
this.manager = manager;
this.order = order;
this.power = power;
this.sourceLocation = sourceLocation;
this.range = (power.Info as ChronoshiftPowerInfo).Range;
// todo: this burns up more texture space every time someone uses chronoshift.
validTile = UiOverlay.SynthesizeTile(0x0f);
invalidTile = UiOverlay.SynthesizeTile(0x08);
sourceTile = UiOverlay.SynthesizeTile(0x04);
}
public override IOrderGenerator OrderGenerator(string order, SupportPowerManager manager)
{
Sound.PlayToPlayer(manager.self.Owner, Info.SelectTargetSound);
return new SelectTarget(order, manager, this);
}
public override void SelectTarget(Actor self, string order, SupportPowerManager manager)
{
Game.Sound.PlayToPlayer(SoundType.UI, manager.Self.Owner, Info.SelectTargetSound);
self.World.OrderGenerator = new SelectChronoshiftTarget(Self.World, order, manager, this);
}
public SelectDestination(World world, string order, SupportPowerManager manager, ChronoshiftPower power, CPos sourceLocation)
{
this.manager = manager;
this.order = order;
this.power = power;
this.sourceLocation = sourceLocation;
var info = (ChronoshiftPowerInfo)power.Info;
range = info.Range;
var tileset = world.Map.Tileset.ToLowerInvariant();
validTile = world.Map.Rules.Sequences.GetSequence(info.OverlaySpriteGroup, info.ValidTileSequencePrefix + tileset).GetSprite(0);
invalidTile = world.Map.Rules.Sequences.GetSequence(info.OverlaySpriteGroup, info.InvalidTileSequence).GetSprite(0);
sourceTile = world.Map.Rules.Sequences.GetSequence(info.OverlaySpriteGroup, info.SourceTileSequence).GetSprite(0);
}
public SelectChronoshiftTarget(World world, string order, SupportPowerManager manager, ChronoshiftPower power)
{
// Clear selection if using Left-Click Orders
if (Game.Settings.Game.UseClassicMouseStyle)
manager.Self.World.Selection.Clear();
this.manager = manager;
this.order = order;
this.power = power;
var info = (ChronoshiftPowerInfo)power.Info;
range = info.Range;
tile = world.Map.Rules.Sequences.GetSequence(info.OverlaySpriteGroup, info.SourceTileSequence).GetSprite(0);
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
Activate(self, order.TargetLocation);
}
public SelectDestination(string order, SupportPowerManager manager, ChronoshiftPower power, CPos sourceLocation)
{
this.manager = manager;
this.order = order;
this.power = power;
this.sourceLocation = sourceLocation;
this.range = (power.Info as ChronoshiftPowerInfo).Range;
validTile = SequenceProvider.GetSequence("overlay", "target-valid").GetSprite(0);
invalidTile = SequenceProvider.GetSequence("overlay", "target-invalid").GetSprite(0);
sourceTile = SequenceProvider.GetSequence("overlay", "target-select").GetSprite(0);
}
public override void SelectTarget(Actor self, string order, SupportPowerManager manager)
{
self.World.OrderGenerator = new SelectConditionTarget(Self.World, order, manager, this);
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
var info = Info as ParatroopersPowerInfo;
var dropFacing = Util.QuantizeFacing(self.World.SharedRandom.Next(256), info.QuantizedFacings) * (256 / info.QuantizedFacings);
var dropRotation = WRot.FromFacing(dropFacing);
var delta = new WVec(0, -1024, 0).Rotate(dropRotation);
var altitude = self.World.Map.Rules.Actors[info.UnitType].Traits.Get<PlaneInfo>().CruiseAltitude.Range;
var target = self.World.Map.CenterOfCell(order.TargetLocation) + new WVec(0, 0, altitude);
var startEdge = target - (self.World.Map.DistanceToEdge(target, -delta) + info.Cordon).Range * delta / 1024;
var finishEdge = target + (self.World.Map.DistanceToEdge(target, delta) + info.Cordon).Range * delta / 1024;
Actor camera = null;
Beacon beacon = null;
var aircraftInRange = new Dictionary<Actor, bool>();
Action<Actor> onEnterRange = a =>
{
// Spawn a camera and remove the beacon when the first plane enters the target area
if (info.CameraActor != null && !aircraftInRange.Any(kv => kv.Value))
{
self.World.AddFrameEndTask(w =>
{
camera = w.CreateActor(info.CameraActor, new TypeDictionary
{
new LocationInit(order.TargetLocation),
new OwnerInit(self.Owner),
});
});
}
if (beacon != null)
{
self.World.AddFrameEndTask(w =>
{
w.Remove(beacon);
beacon = null;
});
}
aircraftInRange[a] = true;
};
Action<Actor> onExitRange = a =>
{
aircraftInRange[a] = false;
// Remove the camera when the final plane leaves the target area
if (!aircraftInRange.Any(kv => kv.Value))
{
if (camera != null)
{
camera.QueueActivity(new Wait(info.CameraRemoveDelay));
camera.QueueActivity(new RemoveSelf());
}
camera = null;
if (beacon != null)
{
self.World.AddFrameEndTask(w =>
{
w.Remove(beacon);
beacon = null;
});
}
}
};
self.World.AddFrameEndTask(w =>
{
var notification = self.Owner.IsAlliedWith(self.World.RenderPlayer) ? Info.LaunchSound : Info.IncomingSound;
Sound.Play(notification);
Actor distanceTestActor = null;
var passengersPerPlane = (info.DropItems.Length + info.SquadSize - 1) / info.SquadSize;
var added = 0;
for (var i = -info.SquadSize / 2; i <= info.SquadSize / 2; i++)
{
// Even-sized squads skip the lead plane
if (i == 0 && (info.SquadSize & 1) == 0)
continue;
// Includes the 90 degree rotation between body and world coordinates
var so = info.SquadOffset;
var spawnOffset = new WVec(i * so.Y, -Math.Abs(i) * so.X, 0).Rotate(dropRotation);
var targetOffset = new WVec(i * so.Y, 0, 0).Rotate(dropRotation);
var a = w.CreateActor(info.UnitType, new TypeDictionary
{
new CenterPositionInit(startEdge + spawnOffset),
new OwnerInit(self.Owner),
new FacingInit(dropFacing),
});
var drop = a.Trait<ParaDrop>();
drop.SetLZ(w.Map.CellContaining(target + targetOffset), !info.AllowImpassableCells);
drop.OnEnteredDropRange += onEnterRange;
drop.OnExitedDropRange += onExitRange;
drop.OnRemovedFromWorld += onExitRange;
var cargo = a.Trait<Cargo>();
var passengers = info.DropItems.Skip(added).Take(passengersPerPlane);
added += passengersPerPlane;
foreach (var p in passengers)
cargo.Load(a, self.World.CreateActor(false, p.ToLowerInvariant(),
new TypeDictionary { new OwnerInit(a.Owner) }));
a.QueueActivity(new Fly(a, Target.FromPos(finishEdge + spawnOffset)));
a.QueueActivity(new RemoveSelf());
aircraftInRange.Add(a, false);
distanceTestActor = a;
}
if (Info.DisplayBeacon)
{
var distance = (target - startEdge).HorizontalLength;
beacon = new Beacon(
order.Player,
self.World.Map.CenterOfCell(order.TargetLocation),
Info.BeaconPalettePrefix,
Info.BeaconPoster,
Info.BeaconPosterPalette,
() => 1 - ((distanceTestActor.CenterPosition - target).HorizontalLength - info.BeaconDistanceOffset.Range) * 1f / distance
);
w.Add(beacon);
}
});
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
SendDropPods(self, order, info.PodFacing);
}
public SelectUpgradeTarget(World world, string order, SupportPowerManager manager, GrantUpgradePower power)
{
// Clear selection if using Left-Click Orders
if (Game.Settings.Game.UseClassicMouseStyle)
manager.Self.World.Selection.Clear();
this.manager = manager;
this.order = order;
this.power = power;
this.range = power.info.Range;
tile = world.Map.SequenceProvider.GetSequence("overlay", "target-select").GetSprite(0);
}
public DischargeableSupportPowerInstance(string key, GrantPrerequisiteChargeDrainPowerInfo info, SupportPowerManager manager)
: base(key, info, manager)
{
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
attack.AttackTarget(Target.FromCell(self.World, order.TargetLocation), false, false, true);
}
public override SupportPowerInstance CreateInstance(string key, SupportPowerManager manager)
{
return(new DischargeableSupportPowerInstance(key, info, manager));
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
base.Activate(self, order, manager);
SendParatroopers(self, self.World.Map.CenterOfCell(order.TargetLocation));
}
public override void SelectTarget(Actor self, string order, SupportPowerManager manager)
{
Game.Sound.PlayToPlayer(manager.Self.Owner, Info.SelectTargetSound);
self.World.OrderGenerator = new SelectAttackPowerTarget(self, order, manager, info.Cursor, MouseButton.Left, attack);
}
public override void SelectTarget(Actor self, string order, SupportPowerManager manager)
{
Game.Sound.PlayToPlayer(SoundType.UI, manager.Self.Owner, Info.SelectTargetSound);
self.World.OrderGenerator = new SelectChronoshiftTarget(Self.World, order, manager, this);
}
public override void Activate(Actor self, Order order, SupportPowerManager manager)
{
var target = order.Target.Positions.FirstOrDefault();
this.SendAirstrike(self, target, (target - self.CenterPosition).Yaw);
}
Action<MouseInput> HandleSupportPower(string key, SupportPowerManager manager)
{
return mi => { if (mi.Button == MouseButton.Left) manager.Target(key); };
}
