C# OpenRA.Actor类代码示例

 public static bool CanPlaceBuilding(this World world, string name, BuildingInfo building, int2 topLeft, Actor toIgnore)
 {
     var res = world.WorldActor.traits.Get<ResourceLayer>();
     return !Footprint.Tiles(name, building, topLeft).Any(
         t => !world.Map.IsInMap(t.X, t.Y) || res.GetResource(t) != null || !world.IsCellBuildable(t,
             building.WaterBound, toIgnore));
 }

        public Player( World world, Session.Client client )
        {
            World = world;
            Shroud = new ShroudRenderer(this, world.Map);

            PlayerActor = world.CreateActor("Player", new int2(int.MaxValue, int.MaxValue), this);

            if (client != null)
            {
                Index = client.Index;
                Palette = PlayerColors[client.PaletteIndex % PlayerColors.Count()].a;
                Color = PlayerColors[client.PaletteIndex % PlayerColors.Count()].c;
                PlayerName = client.Name;
                InternalName = "Multi{0}".F(client.Index);
            }
            else
            {
                Index = -1;
                PlayerName = InternalName = "Neutral";
                Palette = "neutral";
                Color = Color.Gray;	// HACK HACK
            }

            Country = world.GetCountries()
                .FirstOrDefault(c => client != null && client.Country == c.Name)
                ?? world.GetCountries().Random(world.SharedRandom);
        }

 public void Add(World w, Actor a)
 {
     actors.Add(a);
     foreach (var sel in a.TraitsImplementing<INotifySelected>())
         sel.Selected(a);
     foreach (var ns in w.WorldActor.TraitsImplementing<INotifySelection>())
         ns.SelectionChanged();
 }

 public PathSearch(Actor self)
 {
     this.self = self;
     world = self.World;
     cellInfo = InitCellInfo();
     mobile = self.Trait<Mobile>();
     queue = new PriorityQueue<PathDistance>();
 }

        public override Activity Tick(Actor self)
        {
            if (move == null || refuelsNear == null)
                return NextActivity;

            self.SetTargetLine(target, Color.Green);

            return ActivityUtils.SequenceActivities(move.MoveWithinRange(target, refuelsNear.Info.Range), NextActivity);
        }

		public static PathSearch Search(World world, MobileInfo mi, Actor self, bool checkForBlocked)
		{
			var search = new PathSearch(world, mi, self)
			{
				CheckForBlocked = checkForBlocked
			};

			return search;
		}

 public Order(string orderString, Actor subject, 
     Actor targetActor, int2 targetLocation, string targetString)
 {
     this.OrderString = orderString;
     this.Subject = subject;
     this.TargetActor = targetActor;
     this.TargetLocation = targetLocation;
     this.TargetString = targetString;
 }

        public static PathSearch FromPoint( Actor self, int2 from, int2 target, bool checkForBlocked )
        {
            var search = new PathSearch(self) {
                heuristic = DefaultEstimator( target ),
                checkForBlocked = checkForBlocked };

            search.AddInitialCell( self.World, from );
            return search;
        }

        Order(string orderString, Actor subject,
			Actor targetActor, int2 targetLocation, string targetString, bool queued, int2 extraLocation)
        {
            this.OrderString = orderString;
            this.Subject = subject;
            this.TargetActor = targetActor;
            this.TargetLocation = targetLocation;
            this.TargetString = targetString;
            this.Queued = queued;
            this.ExtraLocation = extraLocation;
        }

		public static PathSearch FromPoint(World world, MobileInfo mi, Actor self, CPos from, CPos target, bool checkForBlocked)
		{
			var search = new PathSearch(world, mi, self)
			{
				Heuristic = DefaultEstimator(target),
				CheckForBlocked = checkForBlocked
			};

			search.AddInitialCell(from);
			return search;
		}

		public PathSearch(World world, MobileInfo mobileInfo, Actor self)
		{
			this.self = self;
			CellInfo = InitCellInfo();
			this.mobileInfo = mobileInfo;
			this.self = self;
			customCost = null;
			Queue = new PriorityQueue<PathDistance>();
			Considered = new HashSet<CPos>();
			MaxCost = 0;
			nextDirections = CVec.directions.Select(d => new Pair<CVec, int>(d, 0)).ToArray();
		}

        Order(string orderString, Actor subject,
			Actor targetActor, CPos targetLocation, string targetString, bool queued, CPos extraLocation, uint extraData)
        {
            this.OrderString = orderString;
            this.Subject = subject;
            this.TargetActor = targetActor;
            this.TargetLocation = targetLocation;
            this.TargetString = targetString;
            this.Queued = queued;
            this.ExtraLocation = extraLocation;
            this.ExtraData = extraData;
        }

        Order(string orderString, Actor subject,
			Actor targetActor, CPos targetLocation, string targetString, bool queued, CPos extraLocation, uint extraData)
        {
            OrderString = orderString;
            Subject = subject;
            TargetActor = targetActor;
            TargetLocation = targetLocation;
            TargetString = targetString;
            Queued = queued;
            ExtraLocation = extraLocation;
            ExtraData = extraData;
        }

		public static PathSearch FromPoints(World world, MobileInfo mi, Actor self, IEnumerable<CPos> froms, CPos target, bool checkForBlocked)
		{
			var search = new PathSearch(world, mi, self)
			{
				Heuristic = DefaultEstimator(target),
				CheckForBlocked = checkForBlocked
			};

			foreach (var sl in froms)
				search.AddInitialCell(sl);

			return search;
		}

        public static void DoExplosion(Actor attacker, string weapontype, int2 location, int altitude)
        {
            var args = new ProjectileArgs
            {
                src = location,
                dest = location,
                srcAltitude = altitude,
                destAltitude = altitude,
                firedBy = attacker,
                target = null,
                weapon = Rules.Weapons[ weapontype.ToLowerInvariant() ],
                facing = 0
            };

            DoImpacts(args, location);
        }