C# Traits.PowerManager类代码示例

 public Building(ActorInitializer init)
 {
     this.self = init.self;
     this.topLeft = init.Get<LocationInit,int2>();
     this.Info = self.Info.Traits.Get<BuildingInfo>();
     this.PlayerPower = init.self.Owner.PlayerActor.Trait<PowerManager>();
 }

 public OreRefinery(Actor self, OreRefineryInfo info)
 {
     this.self = self;
     Info = info;
     PlayerResources = self.Owner.PlayerActor.Trait<PlayerResources>();
     PlayerPower = self.Owner.PlayerActor.Trait<PowerManager>();
 }

		public BaseBuilder(HackyAI ai, string category, Player p, PowerManager pm, PlayerResources pr)
		{
			this.ai = ai;
			world = p.World;
			player = p;
			playerPower = pm;
			playerResources = pr;
			this.category = category;
		}

 public ProductionItem(ProductionQueue queue, string item, int cost, PowerManager pm, Action onComplete)
 {
     Item = item;
     RemainingTime = TotalTime = 1;
     RemainingCost = TotalCost = cost;
     OnComplete = onComplete;
     Queue = queue;
     this.pm = pm;
 }

		public BaseBuilder(HackyAI ai, string category, Player p, PowerManager pm, PlayerResources pr)
		{
			this.ai = ai;
			world = p.World;
			player = p;
			playerPower = pm;
			playerResources = pr;
			this.category = category;
			failRetryTicks = ai.Info.StructureProductionResumeDelay;
		}

        public Building(ActorInitializer init)
        {
            this.self = init.self;
            this.topLeft = init.Get<LocationInit,int2>();
            Info = self.Info.Traits.Get<BuildingInfo>();
            self.CenterLocation = Game.CellSize
                * ((float2)topLeft + .5f * (float2)Info.Dimensions);

            PlayerPower = init.self.Owner.PlayerActor.Trait<PowerManager>();
        }

 public ProductionItem(ProductionQueue queue, string item, int cost, PowerManager pm, Action onComplete)
 {
     Item = item;
     RemainingTime = TotalTime = 1;
     RemainingCost = TotalCost = cost;
     OnComplete = onComplete;
     Queue = queue;
     this.pm = pm;
     ai = Queue.Actor.World.Map.Rules.Actors[Item];
     bi = ai.TraitInfo<BuildableInfo>();
 }

        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 void OnOwnerChanged(Actor self, Player oldOwner, Player newOwner)
 {
     power = newOwner.PlayerActor.Trait<PowerManager>();
 }

 public PowerMultiplier(Actor self, PowerMultiplierInfo info)
     : base(info, "PowerMultiplier", self.Info.Name)
 {
     power = self.Owner.PlayerActor.Trait<PowerManager>();
 }

        public ProductionQueue( Actor self, Actor playerActor, ProductionQueueInfo info )
        {
            this.self = self;
            this.Info = info;
            playerResources = playerActor.Trait<PlayerResources>();
            PlayerPower = playerActor.Trait<PowerManager>();

            Race = self.Owner.Country;
            Produceable = InitTech(playerActor);
        }

        public void OnCapture(Actor self, Actor captor, Player oldOwner, Player newOwner)
        {
            PlayerPower = newOwner.PlayerActor.Trait<PowerManager>();
            playerResources = newOwner.PlayerActor.Trait<PlayerResources>();
            ClearQueue();

            // Produceable contains the tech from the original owner - this is desired so we don't clear it.
            Produceable = InitTech(self.Owner.PlayerActor);

            // Force a third(!) tech tree update to ensure that prerequisites are correct.
            // The first two updates are triggered by adding/removing the actor when
            // changing ownership, *before* the new techtree watchers have been set up.
            // This is crap.
            self.Owner.PlayerActor.Trait<TechTree>().Update();
        }

 public PowerTooltip(Actor self)
 {
     this.self = self;
     powerManager = self.Owner.PlayerActor.Trait<PowerManager>();
     developerMode = self.Owner.PlayerActor.Trait<DeveloperMode>();
 }

		// Called by the host's player creation code
		public void Activate(Player p)
		{
			Player = 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);

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

			resourceTypeIndices = new BitArray(World.TileSet.TerrainInfo.Length); // Big enough
			foreach (var t in Map.Rules.Actors["world"].TraitInfos<ResourceTypeInfo>())
				resourceTypeIndices.Set(World.TileSet.GetTerrainIndex(t.TerrainType), true);
		}

        public ProductionQueue(ActorInitializer init, Actor playerActor, ProductionQueueInfo info)
        {
            self = init.Self;
            Info = info;
            playerResources = playerActor.Trait<PlayerResources>();
            playerPower = playerActor.Trait<PowerManager>();
            developerMode = playerActor.Trait<DeveloperMode>();

            Faction = init.Contains<FactionInit>() ? init.Get<FactionInit, string>() : self.Owner.Faction.InternalName;
            Enabled = !info.Factions.Any() || info.Factions.Contains(Faction);

            CacheProducibles(playerActor);
            allProducibles = producible.Where(a => a.Value.Buildable || a.Value.Visible).Select(a => a.Key);
            buildableProducibles = producible.Where(a => a.Value.Buildable).Select(a => a.Key);
        }