public override AcceptanceReport CanDesignateThing( Thing t )
 {
     var building = t.GetInnerIfMinified() as Building;
     if (building?.def.category != ThingCategory.Building)
     {
         return false;
     }
     if (!Game.GodMode)
     {
         if (!building.def.building.IsDeconstructible)
         {
             return false;
         }
         if (building.Faction != Faction.OfColony)
         {
             if (building.Faction != null)
             {
                 return false;
             }
             if (!building.ClaimableBy( Faction.OfColony ))
             {
                 return false;
             }
         }
     }
     if (Find.DesignationManager.DesignationOn( t, DesignationDefOf.Deconstruct ) != null)
     {
         return false;
     }
     return Find.DesignationManager.DesignationOn( t, DesignationDefOf.Uninstall ) == null;
 }

 public async Task<Comment> InitAsync(Reddit reddit, JToken json, IWebAgent webAgent, Thing sender)
 {
     var data = CommonInit(reddit, json, webAgent, sender);
     await ParseCommentsAsync(reddit, json, webAgent, sender);
     await Task.Factory.StartNew(() => JsonConvert.PopulateObject(data.ToString(), this, reddit.JsonSerializerSettings));
     return this;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="WieldUnwieldEvent"/> class.
 /// </summary>
 /// <param name="wieldedItem">The thing being affected by this event.</param>
 /// <param name="isBeingWielded">Whether the thing is being wielded (true) or unwielded (false).</param>
 /// <param name="activeThing">The actor causing the event (if applicable).</param>
 /// <param name="sensoryMessage">The message to display to those who can perceive the change.</param>
 public WieldUnwieldEvent(Thing wieldedItem, bool isBeingWielded, Thing activeThing, SensoryMessage sensoryMessage)
     : base(activeThing, sensoryMessage)
 {
     this.WieldedItem = wieldedItem;
     this.IsBeingWielded = isBeingWielded;
     sensoryMessage.Context.Add("WieldedItem", this.WieldedItem);
 }

        public static void save(List<Thing> thingsToSave, string fileLocation, Thing source)
        {
            Scribe.InitWriting(fileLocation,"Stargate");

            //Log.Message("Starting Save");
            //Save Pawn

            //Scribe_Collections.LookList<Thing>(ref thingsToSave, "things", LookMode.Deep, (object)null);

            //Scribe.EnterNode("map");
            //Scribe.EnterNode("things");
            //source.ExposeData();
            Scribe_Collections.LookList<Thing>(ref thingsToSave, "things", LookMode.Deep, (object)null);
            //Scribe.ExitNode();

            //Scribe.ExitNode();

            /*
            for (int i = 0; i < thingsToSave.Count; i++)
            {
                Scribe_Deep.LookDeep<Thing>(ref thingsToSave[i], thingsToSave[i].ThingID);
            }*/

            Scribe.FinalizeWriting();
            Scribe.mode = LoadSaveMode.Inactive;
            //Log.Message("End Save");
        }

    public override void UpdateContributor(Thing contributor)
    {
        base.UpdateContributor (contributor);

        //On(contributor, SensorType.OnSensorEnter, OnSensorEnter);
        //On(contributor, SensorType.OnSensorExit, OnSensorExit);
    }

        public CommentViewModel(IBaconProvider baconProvider, Thing comment, string linkId, bool oddNesting, int depth = 0)
        {
            _isMinimized = false;
            _comment = new TypedThing<Comment>(comment);
            _baconProvider = baconProvider;
            _redditService = _baconProvider.GetService<IRedditService>();
            _navigationService = _baconProvider.GetService<INavigationService>();
            _userService = _baconProvider.GetService<IUserService>();
            _dynamicViewLocator = _baconProvider.GetService<IDynamicViewLocator>();
            _markdownProcessor = _baconProvider.GetService<IMarkdownProcessor>();
            _linkId = linkId;
            OddNesting = oddNesting;
			Depth = depth;
            AuthorFlair = _redditService.GetUsernameModifiers(_comment.Data.Author, _linkId, _comment.Data.Subreddit);
            AuthorFlairText = _comment.Data.AuthorFlairText;
            _showExtendedView = new RelayCommand(ShowExtendedViewImpl);
            _gotoReply = new RelayCommand(GotoReplyImpl);
            _save = new RelayCommand(SaveImpl);
            _report = new RelayCommand(ReportImpl);
            _gotoFullLink = new RelayCommand(GotoFullLinkImpl);
            _gotoContext = new RelayCommand(GotoContextImpl);
            _gotoUserDetails = new RelayCommand(GotoUserDetailsImpl);
            _gotoEdit = new RelayCommand(GotoEditImpl);
            _minimizeCommand = new RelayCommand(() => IsMinimized = !IsMinimized);
            Body = _comment.Data.Body;
        }

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

        /// <summary>
        /// Loads this instance.
        /// </summary>
        public void Load()
        {
            var areaRepository = new AreaRepository();

            // @@@ TODO: Fix hack: http://www.wheelmud.net/tabid/59/aft/1622/Default.aspx
            string areaNumber = this.Parent.ID.Replace("area/", string.Empty);
            long persistedAreaID = long.Parse(areaNumber);
            ICollection<RoomRecord> rooms = areaRepository.GetRoomsForArea(persistedAreaID);

            foreach (var roomRecord in rooms)
            {
                // @@@ TODO: Fix hack: http://www.wheelmud.net/tabid/59/aft/1622/Default.aspx
                var roomBehavior = new RoomBehavior()
                {
                    ID = roomRecord.ID,
                };
                var currRoom = new Thing(roomBehavior)
                {
                    Name = roomRecord.Name,
                    Description = roomRecord.Description,
                    ID = "room/" + roomRecord.ID,
                };

                // Load this room and it's children.
                roomBehavior.Load();
                this.Parent.Add(currRoom);
            }
        }

 public override Job JobOnThing(Pawn pawn, Thing t)
 {
     Vehicle_Cart cart = t as Vehicle_Cart;
     if (cart == null)
         return (Job)null;
     if (cart.IsForbidden(pawn.Faction) || !ReservationUtility.CanReserveAndReach(pawn, cart, PathEndMode.ClosestTouch, DangerUtility.NormalMaxDanger(pawn)))
         return (Job)null;
     if (FireUtility.IsBurning(cart))
     {
         JobFailReason.Is(ToolsForHaulUtility.BurningLowerTrans);
         return (Job)null;
     }
     if (ListerHaulables.ThingsPotentiallyNeedingHauling().Count == 0 && cart.storage.Count == 0)
     {
         JobFailReason.Is(ToolsForHaulUtility.NoHaulable);
         return (Job)null;
     }
     if (Find.SlotGroupManager.AllGroupsListInPriorityOrder.Count == 0)
     {
         JobFailReason.Is(ToolsForHaulUtility.NoEmptyPlaceLowerTrans);
         return (Job)null;
     }
     if (ToolsForHaulUtility.AvailableAnimalCart(cart) || ToolsForHaulUtility.AvailableCart(cart, pawn))
         return ToolsForHaulUtility.HaulWithTools(pawn, cart);
     JobFailReason.Is(ToolsForHaulUtility.NoAvailableCart);
     return (Job)null;
 }

        /// <summary>
        /// Better version of base AnimalAwareOf that works for Things with passability XML
        /// set to Impassable. 
        /// </summary>
        public static bool AnimalAwareOfEx(this Pawn p, Thing t)
        {
            if (p.RaceProps.ToolUser || p.Faction != null)
            {
                return true;
            }

            var pRoom = p.GetRoom();
            List<Room> thingRooms = new List<Room>();
            if (t.def.passability != Traversability.Impassable)
            {
                thingRooms.Add(t.GetRoom());
            }
            else
            {
                // Find the rooms that are adjacent to the impassable Thing.
                foreach (IntVec3 pos in GenAdj.CellsAdjacent8Way(t))
                {
                    var room = pos.GetRoom();
                    if (room == null) continue;
                    thingRooms.Add(room);
                }
            }

            return ((p.Position - t.Position).LengthHorizontalSquared <= 900f &&
                thingRooms.Any(tRoom => tRoom == pRoom) &&
                GenSight.LineOfSight(p.Position, t.Position, false));
        }

        public override void SpawnSetup()
        {
            base.SpawnSetup();

            // Initialize take-off tick.
            takeOffTick = Find.TickManager.TicksGame + ressuplyDuration;

            // Spawn cryptosleep bays.
            if (this.cryptosleepBay1 == null)
            {
                cryptosleepBay1 = ThingMaker.MakeThing(OG_Util.SupplyShipCryptosleepBayLeftDef);
                cryptosleepBay1.SetFactionDirect(this.Faction);
                GenSpawn.Spawn(cryptosleepBay1, this.Position + new IntVec3(-4, 0, -2).RotatedBy(this.Rotation), this.Rotation);
            }
            if (this.cryptosleepBay2 == null)
            {
                cryptosleepBay2 = ThingMaker.MakeThing(OG_Util.SupplyShipCryptosleepBayRightDef);
                cryptosleepBay2.SetFactionDirect(this.Faction);
                GenSpawn.Spawn(cryptosleepBay2, this.Position + new IntVec3(3, 0, -2).RotatedBy(this.Rotation), this.Rotation);
            }
            // Spawn cargo bays.
            if (this.cargoBay1 == null)
            {
                cargoBay1 = ThingMaker.MakeThing(OG_Util.SupplyShipCargoBayLeftDef);
                cargoBay1.SetFactionDirect(this.Faction);
                GenSpawn.Spawn(cargoBay1, this.Position + new IntVec3(-4, 0, 1).RotatedBy(this.Rotation), this.Rotation);
            }
            if (this.cargoBay2 == null)
            {
                cargoBay2 = ThingMaker.MakeThing(OG_Util.SupplyShipCargoBayRightDef);
                cargoBay2.SetFactionDirect(this.Faction);
                GenSpawn.Spawn(cargoBay2, this.Position + new IntVec3(4, 0, 1).RotatedBy(this.Rotation), this.Rotation);
            }
        }

 public FloatMenuOption_Group(string label, Action action, Designator designator,
     MenuOptionPriority priority = MenuOptionPriority.Medium, Action mouseoverGuiAction = null,
     Thing revalidateClickTarget = null)
     : base(label, action, priority, mouseoverGuiAction, revalidateClickTarget)
 {
     this.designator = designator;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="EnterEvent"/> class.
 /// </summary>
 /// <param name="thingEntered">The thing entered.</param>
 /// <param name="activeThing">The active thing.</param>
 /// <param name="sensoryMessage">The sensory message.</param>
 /// <param name="startLocation">The start location.</param>
 /// <param name="endLocation">The end location.</param>
 public EnterEvent(Thing thingEntered, Thing activeThing, SensoryMessage sensoryMessage, Thing startLocation, Thing endLocation)
     : base(activeThing, sensoryMessage)
 {
     this.ThingEntered = thingEntered;
     this.StartLocation = startLocation;
     this.EndLocation = endLocation;
 }

 private Toil Ignite(Thing target)
 {
     Toil toil = new Toil();
     toil.initAction = delegate
     {
         Pawn feenix = this.pawn;
         if (target.FlammableNow && !target.IsBurning())
         {
             if (target.CanEverAttachFire())
             {
                 target.TryAttachFire(1f);
             }
             else
             {
                 FireUtility.TryStartFireIn(target.Position, 1f);
             }
             PawnUtility.ForceWait(feenix, 250, target);
         }
         else
         {
             return;
         }
     };
     toil.defaultCompleteMode = ToilCompleteMode.Delay;
     toil.defaultDuration = 250;
     return toil;
 }

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

 public override AcceptanceReport AllowsPlacing(BuildableDef checkingDef, IntVec3 loc, Rot4 rot, Thing thingToIgnore = null)
 {
     IEnumerable<IntVec3> cells = GenAdj.CellsAdjacent8Way(loc, rot, checkingDef.Size).Union<IntVec3>(GenAdj.CellsOccupiedBy(loc, rot, checkingDef.Size));
     foreach (IntVec3 cell in cells)
     {
         List<Thing> things = Map.thingGrid.ThingsListAt(cell);
         foreach (Thing thing in things)
         {
             if (thing.TryGetComp<CompRTQuantumStockpile>() != null
                 || thing.TryGetComp<CompRTQuantumChunkSilo>() != null)
             {
                 return "PlaceWorker_RTNoQSOverlap".Translate();
             }
             else if (thing.def.entityDefToBuild != null)
             {
                 ThingDef thingDef = thing.def.entityDefToBuild as ThingDef;
                 if (null != thingDef &&
                     null != thingDef.comps &&
                     null != thingDef.comps.Find(x => typeof(CompRTQuantumStockpile) == x.compClass))
                 {
                     return "PlaceWorker_RTNoQSOverlap".Translate();
                 }
             }
         }
     }
     return true;
 }

        // Look for a receiver and lock it.
        public override IntVec3 GetDestinationForThing( Thing thing )
        {
            // Already targetted
            if( ( Receiver != null )&&
                ( Receiver.CanAcceptSomething() ) )
                return Receiver.parent.Position;

            // Find a new target
            var pos = parent.Position.ToVector3();

            // Get only only receivers on my channel and return them in order of
            // closest to furthest.
            var recv = Manager.GetReceivers( Channel )
                              .Where( r => r.CanAcceptFrom( this ) )
                              .OrderBy( r => ( r.parent.Position.ToVector3() - pos ).sqrMagnitude );

            try{
                // This will be the closest unlocked receiver, try to lock it
                var target = recv.First();
                if( LockTarget( target ) ){
                    return target.parent.Position;
                } else{
                    return IntVec3.Invalid;
                }

            } catch( InvalidOperationException ){
                // If nothing was acceptable, return IntVec3.Invalid
                return IntVec3.Invalid;
            }
        }

        public override bool HasJobOnThing( Pawn pawn, Thing thing )
        {
            if ( thing.Faction != pawn.Faction )
                return false;

            if ( pawn.Faction == Faction.OfColony && !Find.AreaHome[thing.Position] )
                return false;

            if ( thing.IsBurning() )
                return false;

            if ( Find.DesignationManager.DesignationOn( thing, DesignationDefOf.Deconstruct ) != null )
                return false;

            ThingWithComps twc = thing as ThingWithComps;
            if ( twc == null )
                return false;

            var comp = twc.TryGetComp<CompBreakdownable>();
            if ( comp == null )
                return false;

            if ( !MapComponent_Durability.RequiresMaintenance( comp ) )
                return false;

            if ( !pawn.CanReserveAndReach( thing, PathEndMode.Touch, pawn.NormalMaxDanger() ) )
                return false;

            return true;
        }

 static void Plucky(out Thing t)
 {
     Thing r = new Thing();
     r.whatever = 8;
     // Can't do this: Console.Write("t was " + t);
     t = r;
 }