C# Thing.TryGetComp方法代码示例

        public override bool HasJobOnThing( Pawn pawn, Thing t )
        {
#if DEBUG_WORKGIVER
            Log.Message("Checking " + t.LabelCap + " for job.");
            Log.Message("ManagerStation" + ((t as Building_ManagerStation) != null));
            Log.Message("Comp" + (t.TryGetComp<Comp_ManagerStation>() != null));
            Log.Message("Incap" + (!pawn.Dead && !pawn.Downed && !pawn.IsBurning() && !t.IsBurning()));
            Log.Message("CanReserve and reach" + (pawn.CanReserveAndReach(t, PathEndMode, Danger.Some)));
            CompPowerTrader powera = t.TryGetComp<CompPowerTrader>();
            Log.Message("Power" + (powera == null || powera.PowerOn));
            Log.Message("Job" + (Manager.Get.JobStack.NextJob != null));
#endif
            if ( !( t is Building_ManagerStation ) )
            {
                return false;
            }

            if ( t.TryGetComp<Comp_ManagerStation>() == null )
            {
                return false;
            }

            if ( pawn.Dead ||
                 pawn.Downed ||
                 pawn.IsBurning() ||
                 t.IsBurning() )
            {
                return false;
            }

            if ( !pawn.CanReserveAndReach( t, PathEndMode, Danger.Some ) )
            {
                return false;
            }

            CompPowerTrader power = t.TryGetComp<CompPowerTrader>();
            if ( power != null &&
                 !power.PowerOn )
            {
                return false;
            }

            if ( Manager.Get.JobStack.NextJob != null )
            {
                return true;
            }

            return false;
        }

        public override bool HasJobOnThing(Pawn pawn, Thing t)
        {
            var wc = t.TryGetComp<CompWaterContainer>();
            if (wc == null) { return false; }

            return wc.ManuallyFillable && wc.FreeSpaceLitres >= MinimumFill && t.IsSociallyProper(pawn);
        }

        public override void SpawnSetup()
        {
            base.SpawnSetup();
            vecNorth = Position + IntVec3.North.RotatedBy( Rotation );

            glower = GenSpawn.Spawn( ThingDef.Named( "RedistHeat_HeaterGlower" ), vecNorth );
            compGlower = glower.TryGetComp< CompGlower >();
            compGlower.Lit = false;
        }

        public override bool ShouldLinkWith( IntVec3 c, Thing parent )
        {
            var compAir = parent.TryGetComp< CompAir >();
            if ( compAir == null )
                return false;

            var lowerFlag = AirNetGrid.NetAt( c, NetLayer.Lower ) != null && compAir.IsLayerOf( NetLayer.Lower );
            var upperFlag = AirNetGrid.NetAt( c, NetLayer.Upper ) != null && compAir.IsLayerOf( NetLayer.Upper );

            return c.InBounds() && (lowerFlag || upperFlag);
        }

        static bool CheckThing( Thing thing )
        {
            var p = thing.TryGetComp< CompPowerTrader >();

            // Only check for power traders
            // That are connected to a power network
            // Which aren't powered on
            // But want to be powered on
            return
                ( p != null )&&
                ( p.PowerNet != null )&&
                ( !p.PowerOn )&&
                ( p.DesirePowerOn );
        }

 public override Job JobOnThing( Pawn pawn, Thing t )
 {
     if( !pawn.CanReserveAndReach( t, PathEndMode.InteractionCell, pawn.NormalMaxDanger(), 1 ) )
     {
         return null;
     }
     var compPower = t.TryGetComp<CompPowerTrader>();
     if(
         ( compPower != null ) &&
         ( !compPower.PowerOn )
     )
     {   // Power is off on thing
         return null;
     }
     if( !Data.AllRoomMarkersOfColony().Any( marker => marker.AllowRemoteMonitoring ) )
     {   // No markers which can be remotely monitored
         return null;
     }
     return new Job( Data.JobDefOf.MonitorSecurityStation, t, pawn );
 }

        public override void Print( SectionLayer layer, Thing parent )
        {
            base.Print( layer, parent );
            var compAir = parent.TryGetComp< CompAir >();
            if ( compAir == null )
                return;

            for ( var i = 0; i < 4; i++ )
            {
                var neighCell = parent.Position + GenAdj.CardinalDirections[i];
                if ( !neighCell.InBounds() )
                {
                    continue;
                }

                Material mat;
                if ( compAir.IsLayerOf( NetLayer.Lower ) )
                {
                    var lowerTransmitter = neighCell.GetAirTransmitter( NetLayer.Lower );
                    if ( lowerTransmitter != null && !lowerTransmitter.def.graphicData.Linked )
                    {
                        mat = LinkedDrawMatFrom(parent, neighCell);
                        Printer_Plane.PrintPlane(layer, neighCell.ToVector3ShiftedWithAltitude(parent.def.Altitude),
                            Vector2.one, mat, 0f);
                    }
                }

                else if ( compAir.IsLayerOf( NetLayer.Upper ) )
                {
                    var upperTransmitter = neighCell.GetAirTransmitter( NetLayer.Upper );
                    if ( upperTransmitter != null && !upperTransmitter.def.graphicData.Linked )
                    {
                        mat = LinkedDrawMatFrom(parent, neighCell);
                        Printer_Plane.PrintPlane(layer, neighCell.ToVector3ShiftedWithAltitude(parent.def.Altitude),
                            Vector2.one, mat, 0f);
                    }
                }
            }
        }

 public static void RegisterCharger(Thing charger)
 {
     if (charger != null && charger.TryGetComp<CompDroidCharger>() != null && !listerDroids.chargers.Contains(charger))
     {
         listerDroids.chargers.Add(charger);
     }
 }

 // same as Research WorkGiver
 public override bool HasJobOnThing(Pawn pawn, Thing t)
 {
     return t.TryGetComp<CompResearcher>() != null && pawn.CanReserve(t);
 }

 public static bool ShouldReserveWaterSource(Thing thing, float wantedLitres)
 {
     var wc = thing.TryGetComp<CompWaterContainer>();
     return (wc != null && wc.StoredLitres <= wantedLitres);
 }

 public void SetGlowRadius(Thing caveWell, float glowradius)
 {
     CompGlower glowerComp = caveWell.TryGetComp<CompGlower>();
     if (glowerComp != null)
     {
         glowerComp.Props.glowRadius = glowradius;
         glowerComp.Props.overlightRadius = glowradius;
         Find.GlowGrid.MarkGlowGridDirty(caveWell.Position);
     }
 }

        public override Job JobOnThing(Pawn pawn, Thing t)
        {
            var toWc = t.TryGetComp<CompWaterContainer>();
            if (toWc == null)
            {
                Log.Error("Thing has no CompWaterContainer");
                return null;
            }

            IntVec3 waterNear = t.Position;

            Thing tool = WaterUtility.HaulingToolInInventory(pawn);
            if (tool == null)
            {
                tool = WaterUtility.NearestHaulingTool(pawn);
                if (tool == null)
                {
                    JobFailReason.Is("nothing to haul with");
                    return null;
                }
            }

            var toolWc = tool.TryGetComp<CompWaterContainer>();
            float collectLitres = toWc.FreeSpaceLitres - toolWc.StoredLitres;
            if (collectLitres > toolWc.FreeSpaceLitres)
            {
                collectLitres = toolWc.FreeSpaceLitres;
            }

            // If we already have enough water in the tool, can just haul it now.
            if (collectLitres <= 0)
            {
                return MakeHaulJob(TargetInfo.NullThing, t, tool);
            }
            // Otherwise we need to find more.
            else
            {
                // Wells, water carriers on the ground, etc.
                Predicate<Thing> validator = (Thing candidate) =>
                {
                    // Don't take water from the target Thing.
                    if (candidate.Equals(t)) { return false; }

                    var candidateWc = candidate.TryGetComp<CompWaterContainer>();
                    if (candidateWc == null) { return false; }

                    // Only take from containers with a lower priority.
                    if (candidateWc.ManuallyFillable && candidateWc.Priority >= toWc.Priority)
                    {
                        return false;
                    }
                    // Don't haul if the source has too little water.
                    return candidateWc.StoredLitres > MinimumFill;
                };
                var thingWater = WaterUtility.BestWaterSpawnedFor(pawn, collectLitres, validator, waterNear);

                // Rivers, lakes, other terrain-based water sources.
                var terrainWaterVec = WaterUtility.BestTerrainWaterFor(pawn, waterNear);

                // Pick the nearest of the water sources.
                if (thingWater != null && terrainWaterVec != null)
                {
                    float thingDist = (pawn.Position - thingWater.Position).LengthHorizontalSquared;
                    float terrainDist = (pawn.Position - terrainWaterVec.Value).LengthHorizontalSquared;
                    if (thingDist <= terrainDist)
                    {
                        terrainWaterVec = null;
                    }
                    else
                    {
                        thingWater = null;
                    }
                }

                if (thingWater != null)
                {
                    return MakeHaulJob(thingWater, t, tool);
                }
                else if (terrainWaterVec != null)
                {
                    return MakeHaulJob(terrainWaterVec.Value, t, tool);
                }
                else
                {
                    JobFailReason.Is("nowhere to haul from");
                    return null;
                }
            }
        }