protected override ThoughtState CurrentStateInternal( Pawn p )
 {
     return(
         ( p.IsPrisonerOfColony )&&
         ( !p.IsSlaveOfColony() )
     );
 }

 public static void PawnDestroyed(Pawn pawn)
 {
     if( OnPawnDestroyed != null )
     {
         OnPawnDestroyed(pawn);
     }
 }

        public override Job JobOnThing( Pawn pawn, Thing t )
        {
            if( !pawn.CanReserveAndReach( ( TargetInfo )t.Position, PathEndMode.Touch, DangerUtility.NormalMaxDanger( pawn ), 1 ) )
            {
                return (Job) null;
            }

            var hopperSgp = t as ISlotGroupParent;
            if( hopperSgp == null )
            {
                return (Job) null;
            }

            var resource = HopperGetCurrentResource( t.Position, hopperSgp );
            if(
                ( resource == null )||
                ( resource.stackCount <= ( resource.def.stackLimit / 2 ) )
            )
            {
                return WorkGiver_FillHopper.HopperFillJob( pawn, hopperSgp, resource );
            }

            JobFailReason.Is( "AlreadyFilledLower".Translate() );
            return (Job) null;
        }

 public static void AttackStateEnd(Pawn pawn)
 {
     if( OnAttackStateEnd != null )
     {
         OnAttackStateEnd(pawn);
     }
 }

 public static void CurrentEnemyUnset(Pawn pawn)
 {
     if( OnCurrentEnemyUnset != null )
     {
         OnCurrentEnemyUnset(pawn);
     }
 }

        // logic for accepting pawn by bodysize
        // RimWorld.Building_CryptosleepCasket
        public static new Building_CryptosleepCasket FindCryptosleepCasketFor(Pawn p, Pawn traveler)
        {
            try {
                IEnumerable<ThingDef> enumerable = from def in DefDatabase<ThingDef>.AllDefs
                                                   where typeof(Fluffy.Building_CryptosleepCasket).IsAssignableFrom(def.thingClass)
                                                   select def;

                foreach (ThingDef current in enumerable)
                {
                    Predicate<Thing> validator = (Thing x) => ((Building_CryptosleepCasket)x).GetContainer().Count == 0 && ((Building_CryptosleepCasket)x).TryGetComp<CompAnimalCrypto>().props.maxSizeAllowance >= traveler.BodySize;
                    Building_CryptosleepCasket building_CryptosleepCasket = (Building_CryptosleepCasket)GenClosest.ClosestThingReachable(p.Position, ThingRequest.ForDef(current), PathEndMode.InteractionCell, TraverseParms.For(traveler, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, validator, null, -1, false);

                    if (building_CryptosleepCasket != null)
                    {
                        return building_CryptosleepCasket;
                    }
                }
                return null;
            }
            finally
            {
            #if DEBUG
                Log.Message("Something odd happened.");
            #endif
            }
        }

        // disable initial readyness for trade and remove all but one muffalo, transferring all goods there
        public void ModifycaravanGroup(ref List<Pawn> pawns)
        {
            var muffaloChosen = false;
            var firstMuffalo = new Pawn();
            var removeList = new List<Pawn>();
            foreach (var pawn in pawns)
            {
                // disable initial readyness to trade
                pawn.mindState.wantsToTradeWithColony = false;

                // transfer all items from other muffaloes to the main one
                if (pawn.kindDef == PawnKindDef.Named("PackMuffalo"))
                {
                    if (!muffaloChosen)
                    {
                        firstMuffalo = pawn;
                        muffaloChosen = true;
                    }
                    else
                    {
                        for (var i = 0; i < pawn.inventory.container.Count; i++)
                        {
                            firstMuffalo.inventory.container.TryAdd(pawn.inventory.container[i]);
                        }
                        pawn.Destroy();
                        removeList.Add(pawn);
                    }
                }
            }
            pawns = new List<Pawn>(pawns.Except(removeList));
        }

 public override bool ActualUse(Pawn target)
 {
     foreach (AmmoBoxPicker abp in ammoList) {
         target.GetComponent<InventoryManager> ().AddAmmo (abp.ammo, abp.amount);
     }
     return base.ActualUse(target);
 }

        public static Building_MAD FindMADFor(Pawn sleeper, Pawn traveler, bool sleeperWillBePrisoner, bool checkSocialProperness, bool forceCheckMedBed = false)
        {
            Predicate<Thing> MADValidator = delegate(Thing t)
            {
                if (!traveler.CanReserveAndReach(t, PathEndMode.OnCell, Danger.Some, 1))
                {
                    return false;
                }

                Building_MAD Building_MAD3 = (Building_MAD)t;

                if (Building_MAD3.HasAnyContents)
                {
                    return false;
                }
                else
                {
                    if (Building_MAD3.Faction != traveler.Faction)
                    {
                        return false;
                    }
                }
                return (!Building_MAD3.IsForbidden(traveler) && !Building_MAD3.IsBurning());
            };
            Predicate<Thing> validator = (Thing b) => MADValidator(b);

            Building_MAD building_MAD = (Building_MAD)GenClosest.ClosestThingReachable(sleeper.Position, ThingRequest.ForDef(DefDatabase<ThingDef>.GetNamed("MindAlteringDevice")), PathEndMode.OnCell, TraverseParms.For(traveler, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, validator, null, -1, false);

            if (building_MAD != null)
            {
                return building_MAD;
            }

            return null;
        }

 public override bool BlocksPawn( Pawn p )
 {
     if( isOpen )
         return false;
     else
         return !WillOpenFor(p);
 }

 public override Job JobOnThing(Pawn pawn, Thing t)
 {
     Building_RepairStation rps = ListerDroids.ClosestRepairStationFor(pawn,t);
     Job job = new Job(ReactivateDroidJobDef, t, rps);
     job.maxNumToCarry = 1;
     return job;
 }

 // search things throught designations is faster than searching designations through all things
 public static List<TargetInfo> AvailableTargets(Pawn pawn)
 {
     return Find.ListerThings.AllThings.FindAll(thing => thing is Frame)
         .Where(thing => thing.Faction == pawn.Faction && GenConstruct.CanConstruct(thing, pawn) &&
                         (thing as Frame).MaterialsNeeded().Count == 0 &&
                         pawn.CanReserveAndReach(thing, PathEndMode.Touch, pawn.NormalMaxDanger())).Select(thing => new TargetInfo(thing)).ToList();
 }

		public override bool HasJobOnThing(Pawn pawn, Thing t)
		{
            if ((t is Building_AquacultureBasin) == false)
            {
                return false;
            }
            Building_AquacultureBasin aquacultureBasin = t as Building_AquacultureBasin;

            if (pawn.Dead
                || pawn.Downed
                || pawn.IsBurning())
            {
                return false;
            }
            if (pawn.CanReserveAndReach(aquacultureBasin, this.PathEndMode, Danger.Some) == false)
            {
                return false;
            }

            if (aquacultureBasin.breedingIsFinished)
            {
                return true;
            }
            return false;
		}

 public override Job NonScanJob(Pawn pawn)
 {
     if (ToolsForHaulUtility.TryGetBackpack(pawn) != null)
         return ToolsForHaulUtility.HaulWithTools(pawn);
     JobFailReason.Is(NoBackpack);
     return (Job)null;
 }

 /**
  * Event: Interact
  */
 public void OnInteract(Pawn pawn = null)
 {
     if(this.conversation.Value != null)
     {
         ConversationManager.StartConversation(this.conversation.Value);
     }
 }

 public override Job JobOnThing( Pawn pawn, Thing t )
 {
     var warden = pawn;
     var slave = t as Pawn;
     if(
         ( slave == null )||
         ( slave.guest == null )||
         ( slave.guest.interactionMode != Data.PIM.FreeSlave )||
         ( slave.Downed )||
         ( !slave.Awake() )||
         ( !warden.CanReserveAndReach(
             slave,
             PathEndMode.ClosestTouch,
             warden.NormalMaxDanger(),
             1 )
         )
     )
     {
         return null;
     }
     var collar = slave.WornCollar();
     if( collar == null )
     {   // Slave isn't wearing a collar, wut?
         return null;
     }
     IntVec3 result;
     if( !RCellFinder.TryFindPrisonerReleaseCell( slave, warden, out result ) )
     {
         return null;
     }
     var job = new Job( Data.JobDefOf.FreeSlave, slave, collar, result );
     job.maxNumToCarry = 1;
     return job;
 }

        public static Toil SipWater(Pawn drinker, Need_Water pawnNeed, CompWaterContainer waterContainer, bool wornByActor)
        {
            var toil = new Toil();
            toil.defaultCompleteMode = ToilCompleteMode.Delay;
            toil.defaultDuration = sipTicks;
            toil.initAction = delegate
            {
                bool fromThing = toil.actor.jobs.curJob.GetTarget(TargetIndex.A).HasThing;
                if (fromThing)
                {
                    toil.FailOnForbidden(TargetIndex.A);
                    if (!wornByActor)
                    {
                        toil.FailOnDespawned(TargetIndex.A);
                    }
                }

                float wantDrink = Math.Min(pawnNeed.HydrationWantedLitres, sipLitres);
                float didDrink = pawnNeed.DrinkFrom(waterContainer, wantDrink);
            };
            toil.FailOn(() => waterContainer.IsEmpty);

            // TODO: toil.WithEffect();
            toil.WithSustainer(delegate
            {
                if (drinker.RaceProps.Humanlike)
                {
                    return DefDatabase<SoundDef>.GetNamed(drinkSoundName);
                }
                return null;
            });
            return toil;
        }

        protected override Job TryGiveTerminalJob(Pawn pawn)
        {
            Pawn mindStateTarget = pawn.mindState.enemyTarget as Pawn;
            if (mindStateTarget == null)
            {
                return null;
            }

            // Check if target is still valid
            if (mindStateTarget.Destroyed || mindStateTarget.Downed ||
                Find.TickManager.TicksGame - pawn.mindState.lastEngageTargetTick > EnemyForgetTime ||
                (pawn.Position - mindStateTarget.Position).LengthHorizontalSquared > (MaxSearchDistance * MaxSearchDistance) ||
                !GenSight.LineOfSight(pawn.Position, mindStateTarget.Position, false))
            {
                pawn.mindState.enemyTarget = null;
                return null;
            }

            if (pawn.story != null && pawn.story.WorkTagIsDisabled(WorkTags.Violent))
            {
                return null;
            }
            Job job = new Job(JobDefOf.AttackMelee, mindStateTarget)
            {
                maxNumMeleeAttacks = 1,
                expiryInterval = Rand.Range(EnemyForgetTime, MaxMeleeChaseTicksMax)
            };
            return job;
        }

 public override bool HasJobOnThing(Pawn pawn, Thing t)
 {
     Fire fire = t as Fire;
     if (fire == null)
     {
         return false;
     }
     Area outpostArea = OG_Util.FindOutpostArea();
     Pawn pawn2 = fire.parent as Pawn;
     if (pawn2 != null)
     {
         if (pawn2 == pawn)
         {
             return false;
         }
         if ((pawn2.Faction == pawn.Faction || pawn2.HostFaction == pawn.Faction || pawn2.HostFaction == pawn.HostFaction)
             && ((outpostArea == null) || (outpostArea.ActiveCells.Contains(t.Position) == false))
             && IntVec3Utility.ManhattanDistanceFlat(pawn.Position, pawn2.Position) > 15)
         {
             return false;
         }
     }
     else if ((outpostArea == null)
         || (outpostArea.ActiveCells.Contains(t.Position) == false))
     {
         return false;
     }
     return ((pawn.Position - fire.Position).LengthHorizontalSquared <= 225f || pawn.CanReserve(fire, 1)) && !WorkGiver_FightFiresOutpost.FireIsBeingHandled(fire, pawn);
 }

 public static Corpse FindClosestCorpseFor(Predicate<Thing> pred, Pawn getter)
 {
     Predicate<Thing> predicate1 = (Thing c) => !c.IsForbidden(Faction.OfColony) && getter.AwareOf(c) && getter.CanReserve(c);
     Predicate<Thing> predicate = (Thing t) => pred(t) && predicate1(t);
     ThingRequest thingReq = ThingRequest.ForGroup(ThingRequestGroup.Corpse);
     return (Corpse)GenClosest.ClosestThingReachable(getter.Position, thingReq, PathEndMode.ClosestTouch, TraverseParms.For(getter), 9999f, predicate, null);
 }