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 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 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); }; }