Inheritance: ChessPiece
        private static readonly string txtRecruitSuccess = "MessageRecruitSuccess".Translate(); // from core

        #endregion Fields

        #region Methods

        public static bool TryGuestImproveRelationship(Pawn recruiter, Pawn guest)
        {
            if (recruiter == null || guest == null || guest.guest == null) return false;

            recruiter.skills.Learn(SkillDefOf.Social, 25f);
            float chance = recruiter.GetStatValue(statOffendGuestChance);
            bool result = false;
            if (Rand.Value <= chance)
            {
                //Log.Message("textAnger");
                Messages.Message(string.Format(txtImproveFactionAnger, recruiter.Nickname, guest.Faction.name, chance.ToStringPercent()), MessageSound.Negative);
                float impact = -(Rand.Range(3, 8) * (1 - 0.0375f * recruiter.skills.GetSkill(SkillDefOf.Social).level)); //Social skill level 20 reduces negative impact by 75%, Skilllevel 0 results in full impact; linear
                guest.Faction.AffectGoodwillWith(Faction.OfColony, impact);
                guest.needs.mood.thoughts.TryGainThought(ThoughtDef.Named("GuestOffendedRelationship"));
                //Log.Message("Goodwill changed by : " + impact);
            }
            else
            {
                //Log.Message("textPlease");
                Messages.Message(string.Format(txtImproveFactionPlease, recruiter.Nickname, guest.Faction.name, (1 - chance).ToStringPercent()), MessageSound.Benefit);
                guest.Faction.AffectGoodwillWith(Faction.OfColony, 0.1f + 0.045f * recruiter.skills.GetSkill(SkillDefOf.Social).level); //Social skilllevel 20 results in +1 relationship, Skilllevel 0 results in +0.1 change, linear
                guest.needs.mood.thoughts.TryGainThought(ThoughtDef.Named("GuestPleasedRelationship"));
                result = true;
                //Log.Message("Goodwill changed by : " + (0.1f + 0.05f * recruiter.skills.GetSkill(SkillDefOf.Social).level));
            }

            if (Rand.Value <= GuestUtility.GetDismissiveChance(guest))
            {
                //Log.Message("DismissiveChance SUCCESS - " + guest.Name + " will not talk with you for a while!");
                //Message einbauen
                guest.needs.mood.thoughts.TryGainThought(ThoughtDef.Named("GuestDismissiveAttitude"));
            }
            //else Log.Message("DismissiveChance FAILED - " + guest.Name + " will continue to talk with you!");
            return result;
        }
 public static Thing FindFreeSupplyShipCryptosleepBay(Pawn rescuer)
 {
     List<Thing> leftBaysList = Find.ListerThings.ThingsOfDef(OG_Util.SupplyShipCryptosleepBayLeftDef);
     for (int bayIndex = 0; bayIndex < leftBaysList.Count; bayIndex++)
     {
         Thing potentialBay = leftBaysList[bayIndex];
         if ((potentialBay.Faction != null)
             && (potentialBay.Faction == rescuer.Faction))
         {
             Building_SupplyShipCryptosleepBay bay = potentialBay as Building_SupplyShipCryptosleepBay;
             if ((bay.GetContainer().Count == 0)
                 && (rescuer.CanReserveAndReach(bay, PathEndMode.InteractionCell, Danger.Deadly)))
             {
                 return bay;
             }
         }
     }
     List<Thing> rightBaysList = Find.ListerThings.ThingsOfDef(OG_Util.SupplyShipCryptosleepBayRightDef);
     for (int bayIndex = 0; bayIndex < rightBaysList.Count; bayIndex++)
     {
         Thing potentialBay = rightBaysList[bayIndex];
         if ((potentialBay.Faction != null)
             && (potentialBay.Faction == rescuer.Faction))
         {
             Building_SupplyShipCryptosleepBay bay = potentialBay as Building_SupplyShipCryptosleepBay;
             if ((bay.GetContainer().Count == 0)
                 && (rescuer.CanReserveAndReach(bay, PathEndMode.InteractionCell, Danger.Deadly)))
             {
                 return bay;
             }
         }
     }
     return null;
 }
示例#3
0
 public static void PawnSpawned(Pawn pawn)
 {
     if( OnPawnSpawned != null )
     {
         OnPawnSpawned(pawn);
     }
 }
 protected override ThoughtState CurrentStateInternal( Pawn p )
 {
     return(
         ( p.IsPrisonerOfColony )&&
         ( !p.IsSlaveOfColony() )
     );
 }
        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;
        }
示例#6
0
 public static void PawnDead(Pawn pawn)
 {
     if( OnPawndead != null )
     {
         OnPawndead(pawn);
     }
 }
示例#7
0
 public static void PawnDestroyed(Pawn pawn)
 {
     if( OnPawnDestroyed != null )
     {
         OnPawnDestroyed(pawn);
     }
 }
示例#8
0
 public static void AttackStateStart(Pawn pawn)
 {
     if( OnAttackStateStart != null )
     {
         OnAttackStateStart(pawn);
     }
 }
示例#9
0
 public static void CurrentEnemyUnset(Pawn pawn)
 {
     if( OnCurrentEnemyUnset != null )
     {
         OnCurrentEnemyUnset(pawn);
     }
 }
示例#10
0
        public virtual void EjectContents()
        {
            foreach (Thing current in this.container.Contents)
            {
                Pawn pawn = current as Pawn;
                if (pawn != null)
                {

                    if (pawn.health.hediffSet.HasHediff(HediffDefOf.Hypothermia))
                    {
                        Hediff hypo = pawn.health.hediffSet.GetFirstHediffOfDef(HediffDefOf.Hypothermia);
                        pawn.health.hediffSet.HealHediff(hypo, 1);
                    }
                    if (pawn.health.hediffSet.HasHediff(HediffDefOf.Heatstroke))
                    {
                        Hediff hypo = pawn.health.hediffSet.GetFirstHediffOfDef(HediffDefOf.Heatstroke);
                        pawn.health.hediffSet.HealHediff(hypo, 1);
                    }
                    //pawn.needs.mood.thoughts.DistinctThoughtDefs.Clear();

                }
            }
            ReEnterCouter = 100;
            this.container.TryDropAll(this.InteractionCell, ThingPlaceMode.Direct);
            if (!base.Destroyed)
            {
                SoundDef.Named("CryptosleepCasketEject").PlayOneShot(SoundInfo.InWorld(base.Position, MaintenanceType.None));
            }
            InContainer = null;
        }
示例#11
0
 public static void AttackStateEnd(Pawn pawn)
 {
     if( OnAttackStateEnd != null )
     {
         OnAttackStateEnd(pawn);
     }
 }
 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);
 }
        // 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));
        }
示例#14
0
        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;
        }
        // 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
            }
        }
示例#16
0
        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;
        }
示例#17
0
 /**
  * Event: Interact
  */
 public void OnInteract(Pawn pawn = null)
 {
     if(this.conversation.Value != null)
     {
         ConversationManager.StartConversation(this.conversation.Value);
     }
 }
示例#18
0
 public Dialog_RenamePet(Pawn pet)
 {
     _pet = pet;
     _curName = pet.Name.ToString();
     closeOnEscapeKey = true;
     absorbInputAroundWindow = true;
 }
示例#19
0
 public override bool filter(Pawn p)
 {
     if (state == FilterType.None) return true;
     if (state == FilterType.False && p.gender == Gender.Male) return true;
     if (state == FilterType.True && p.gender == Gender.Female) return true;
     return false;
 }
示例#20
0
 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);
 }
示例#21
0
        public void UsedBy(Pawn pawn)
        {
            Find.ResearchManager.currentProj = researchDef;
            Find.ResearchManager.InstantFinish(Find.ResearchManager.currentProj);

            Destroy();
        }
 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;
 }
示例#23
0
 public override bool ActualUse(Pawn target)
 {
     foreach (AmmoBoxPicker abp in ammoList) {
         target.GetComponent<InventoryManager> ().AddAmmo (abp.ammo, abp.amount);
     }
     return base.ActualUse(target);
 }
示例#24
0
 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;
 }
		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;
		}
 // 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();
 }
示例#28
0
        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 Job NonScanJob(Pawn pawn)
 {
     if (ToolsForHaulUtility.TryGetBackpack(pawn) != null)
         return ToolsForHaulUtility.HaulWithTools(pawn);
     JobFailReason.Is(NoBackpack);
     return (Job)null;
 }
        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 void DoEffect(Pawn user)
        {
            ThingDef             tempPod    = null;
            IntVec3              currentPos = parent.PositionHeld;
            Map                  map        = parent.Map;
            CompAbilityUserMagic comp       = user.TryGetComp <CompAbilityUserMagic>();

            if (parent.def != null && comp != null && comp.customClass != null)
            {
                if (comp.customClass.tornScript != null)
                {
                    tempPod = comp.customClass.tornScript;
                }
                else
                {
                    tempPod = comp.customClass.fullScript;
                }
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.InnerFire))
            {
                tempPod = ThingDef.Named("Torn_BookOfInnerFire");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.HeartOfFrost))
            {
                tempPod = ThingDef.Named("Torn_BookOfHeartOfFrost");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.StormBorn))
            {
                tempPod = ThingDef.Named("Torn_BookOfStormBorn");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.Arcanist))
            {
                tempPod = ThingDef.Named("Torn_BookOfArcanist");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.Paladin))
            {
                tempPod = ThingDef.Named("Torn_BookOfValiant");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.Summoner))
            {
                tempPod = ThingDef.Named("Torn_BookOfSummoner");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.Druid))
            {
                tempPod = ThingDef.Named("Torn_BookOfNature");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && (user.story.traits.HasTrait(TorannMagicDefOf.Necromancer) || user.story.traits.HasTrait(TorannMagicDefOf.Lich)))
            {
                tempPod = ThingDef.Named("Torn_BookOfUndead");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.Priest))
            {
                tempPod = ThingDef.Named("Torn_BookOfPriest");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.TM_Bard))
            {
                tempPod = ThingDef.Named("Torn_BookOfBard");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && (user.story.traits.HasTrait(TorannMagicDefOf.Succubus) || user.story.traits.HasTrait(TorannMagicDefOf.Warlock)))
            {
                tempPod = ThingDef.Named("Torn_BookOfDemons");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.Geomancer))
            {
                tempPod = ThingDef.Named("Torn_BookOfEarth");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.Technomancer))
            {
                tempPod = TorannMagicDefOf.Torn_BookOfMagitech;
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.BloodMage))
            {
                tempPod = TorannMagicDefOf.Torn_BookOfHemomancy;
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.Enchanter))
            {
                tempPod = TorannMagicDefOf.Torn_BookOfEnchanter;
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.Chronomancer))
            {
                tempPod = TorannMagicDefOf.Torn_BookOfChronomancer;
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && user.story.traits.HasTrait(TorannMagicDefOf.ChaosMage))
            {
                tempPod = TorannMagicDefOf.Torn_BookOfChaos;
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else if (parent.def != null && (user.story.traits.HasTrait(TorannMagicDefOf.TM_Gifted) || user.story.traits.HasTrait(TorannMagicDefOf.TM_Wanderer)))
            {
                tempPod = ThingDef.Named("BookOfQuestion");
                this.parent.SplitOff(1).Destroy(DestroyMode.Vanish);
            }
            else
            {
                Messages.Message("NotGiftedPawn".Translate(
                                     user.LabelShort
                                     ), MessageTypeDefOf.RejectInput);
            }
            if (tempPod != null)
            {
                SihvSpawnThings.SpawnThingDefOfCountAt(tempPod, 1, new TargetInfo(currentPos, map));
            }
        }
示例#32
0
 public override Job JobOnThing(Pawn pawn, Thing t, bool forced = false)
 {
     return(JobMaker.MakeJob(JobDefOf.OperateScanner, t, 1500, checkOverrideOnExpiry: true));
 }
示例#33
0
 public override Danger MaxPathDanger(Pawn pawn)
 {
     return(Danger.Deadly);
 }
示例#34
0
	void Update() {
		if (_uiInvalid) {
			updateUI(_initialUpdateUI);
			_uiInvalid = false;
			_initialUpdateUI = false;
		}

		if (_paused) {
			return;
		}

		if (_gameState == GameState.WaitingPutPawn) {
			bool waitInput = false;
			if (_turn == Side.Opposite) {
				if (_waitingForOppoSide) {
					return;
				}

				stepBegin();
				if (_gameMode == GameMode.AI) {
					performAIMove();
				} else if (_gameMode == GameMode.Self){
					waitInput = true;
				}
			} else {
				waitInput = true;
			}

			if (waitInput) {
				if (_pawns.Count == 0) {
					stepEnd();
					return;
				} else if (_pawns.Count >= _grids.Length) {
					gameOver();
					return;
				}

				if (Input.GetMouseButtonDown(0)) {
					Vector2 gridIndice;
					if (_chessBoard.getGridIndexByScreenPosition(Input.mousePosition, out gridIndice)) {
						Pawn pawn = getPawnAtPos((int)gridIndice.x, (int)gridIndice.y);
						Debug.Log("select grid pos " + gridIndice + ", pawn" + pawn);
						if (pawn != null) {
							if (_selectingPawn == pawn) {
								if (!_selectingPawn.dragging) {
									_selectingPawn.selected = false;
									_selectingPawn = null;
								}
							} else {
								if (_selectingPawn != null) {
									_selectingPawn.selected = false;
									_selectingPawn.dragging = true;
								}

								_selectingPawn = pawn;
								_selectingPawn.selected = true;
								_selectingPawn.dragging = true;
								_selectTimeStamp = Time.time;
								SoundHub.instance().play("MoveBegin");
							}
						} else {
							putSelectingPawn(gridIndice);
						}
					} else {
						if (_selectingPawn != null) {
							_selectingPawn.selected = false;
							_selectingPawn.dragging = false;
							_selectingPawn = null;
						}
					}
				} else if (Input.GetMouseButton(0)) {
					if (Time.time - _selectTimeStamp < 0.1) {
						return;
					}

					if (_selectingPawn != null && _selectingPawn.dragging) {
						Vector3 posInBoard = _chessBoard.screenPosToPosInBoard(Input.mousePosition);
						posInBoard.z = 0;
						_selectingPawn.setLocalPosition(posInBoard);
					}
				} else if (Input.GetMouseButtonUp(0)) {
					if (_selectingPawn != null && _selectingPawn.dragging) {
						Vector2 gridIndice;
						if (_chessBoard.getGridIndexByScreenPosition(Input.mousePosition, out gridIndice)) {
							Pawn pawn = getPawnAtPos((int)gridIndice.x, (int)gridIndice.y);
							if (pawn != null) {
								cancelDrag();
							} else {
								putSelectingPawn(gridIndice);
							}
						} else {
							cancelDrag();
						}
					}
				}
			}
		} else if (_gameState == GameState.SelectingPawnToTrash) {
			if (Input.GetMouseButtonDown(0)) {
				Vector2 gridIndice;
				if (_chessBoard.getGridIndexByScreenPosition(Input.mousePosition, out gridIndice)) {
					Pawn pawn = getPawnAtPos((int)gridIndice.x, (int)gridIndice.y);
					if (pawn != null) {
						if (_selectingPawn == pawn) {
							if (!_selectingPawn.dragging) {
								_selectingPawn.selected = false;
								_selectingPawn = null;
							}
						} else {
							if (_selectingPawn != null) {
								_selectingPawn.selected = false;
								_selectingPawn.dragging = true;
							}
							
							_selectingPawn = pawn;
							_selectingPawn.selected = true;
							_selectingPawn.dragging = true;
							_selectTimeStamp = Time.time;
							SoundHub.instance().play("MoveBegin");
						}
					}
				} else if (_selectingPawn != null) {
					putPawnToTrash();
				}
			} else if (Input.GetMouseButton(0)) {
				if (Time.time - _selectTimeStamp < 0.1) {
					return;
				}
				
				if (_selectingPawn != null && _selectingPawn.dragging) {
					Vector3 posInBoard = _chessBoard.screenPosToPosInBoard(Input.mousePosition);
					posInBoard.z = 0;
					_selectingPawn.setLocalPosition(posInBoard);
				}
			} else if (Input.GetMouseButtonUp(0)) {
				if (_selectingPawn != null && _selectingPawn.dragging) {
					Vector2 gridIndice;
					if (_chessBoard.getGridIndexByScreenPosition(Input.mousePosition, out gridIndice)) {
						cancelDrag();
					} else {
						putPawnToTrash();
					}
				}
			}
		} else if (_gameState == GameState.GameOver) {

		}
	}
 public override bool ShouldSkip(Pawn pawn, bool forced = false)
 {
     return(pawn.Map.areaManager.SnowClear.TrueCount == 0);
 }
 public override IEnumerable <IntVec3> PotentialWorkCellsGlobal(Pawn pawn)
 {
     return(pawn.Map.areaManager.SnowClear.ActiveCells);
 }
示例#37
0
 public static bool IsValidMarriageSpotFor(IntVec3 cell, Pawn firstFiance, Pawn secondFiance, StringBuilder outFailReason = null)
 {
     if (!firstFiance.Spawned || !secondFiance.Spawned)
     {
         Log.Warning("Can't check if a marriage spot is valid because one of the fiances isn't spawned.");
         return(false);
     }
     if (firstFiance.Map != secondFiance.Map)
     {
         return(false);
     }
     if (!MarriageSpotUtility.IsValidMarriageSpot(cell, firstFiance.Map, outFailReason))
     {
         return(false);
     }
     if (!cell.Roofed(firstFiance.Map))
     {
         if (!JoyUtility.EnjoyableOutsideNow(firstFiance, outFailReason))
         {
             return(false);
         }
         if (!JoyUtility.EnjoyableOutsideNow(secondFiance, outFailReason))
         {
             return(false);
         }
     }
     if (cell.GetDangerFor(firstFiance, firstFiance.Map) != Danger.None)
     {
         if (outFailReason != null)
         {
             outFailReason.Append("MarriageSpotDangerous".Translate(new object[]
             {
                 firstFiance.LabelShort
             }));
         }
         return(false);
     }
     if (cell.GetDangerFor(secondFiance, secondFiance.Map) != Danger.None)
     {
         if (outFailReason != null)
         {
             outFailReason.Append("MarriageSpotDangerous".Translate(new object[]
             {
                 secondFiance.LabelShort
             }));
         }
         return(false);
     }
     if (cell.IsForbidden(firstFiance))
     {
         if (outFailReason != null)
         {
             outFailReason.Append("MarriageSpotForbidden".Translate(new object[]
             {
                 firstFiance.LabelShort
             }));
         }
         return(false);
     }
     if (cell.IsForbidden(secondFiance))
     {
         if (outFailReason != null)
         {
             outFailReason.Append("MarriageSpotForbidden".Translate(new object[]
             {
                 secondFiance.LabelShort
             }));
         }
         return(false);
     }
     if (!firstFiance.CanReserve(cell, 1, -1, null, false) || !secondFiance.CanReserve(cell, 1, -1, null, false))
     {
         if (outFailReason != null)
         {
             outFailReason.Append("MarriageSpotReserved".Translate());
         }
         return(false);
     }
     if (!firstFiance.CanReach(cell, PathEndMode.OnCell, Danger.None, false, TraverseMode.ByPawn))
     {
         if (outFailReason != null)
         {
             outFailReason.Append("MarriageSpotUnreachable".Translate(new object[]
             {
                 firstFiance.LabelShort
             }));
         }
         return(false);
     }
     if (!secondFiance.CanReach(cell, PathEndMode.OnCell, Danger.None, false, TraverseMode.ByPawn))
     {
         if (outFailReason != null)
         {
             outFailReason.Append("MarriageSpotUnreachable".Translate(new object[]
             {
                 secondFiance.LabelShort
             }));
         }
         return(false);
     }
     if (!firstFiance.IsPrisoner && !secondFiance.IsPrisoner)
     {
         Room room = cell.GetRoom(firstFiance.Map, RegionType.Set_Passable);
         if (room != null && room.isPrisonCell)
         {
             if (outFailReason != null)
             {
                 outFailReason.Append("MarriageSpotInPrisonCell".Translate());
             }
             return(false);
         }
     }
     return(true);
 }
示例#38
0
 public static bool IsClean(Pawn pawn, BodyPartRecord part)
 {
     return(!pawn.Dead && !(from x in pawn.health.hediffSet.hediffs
                            where x.Part == part
                            select x).Any());
 }
示例#39
0
 public static bool CanDeploy(Pawn pawn, IShield shield)
 {
     return(pawn.RaceProps.baseBodySize >= shield.DeploymentSize);
 }
示例#40
0
 public override string GetLabelWhenUsedOn(Pawn pawn, BodyPartRecord part)
 {
     return(recipe.LabelCap + " (" + BloodTypeUtility.BloodType(pawn).GetLabel() + ")" + ((BloodItemUtility.ExtractionWillKill(pawn, BloodExtractType.Wine)) ? " (" + ("ROMV_DeadlyOperationShort".Translate()).RawText + ")"  : ""));
 }
 protected override void Notify_DesignationAdded(Pawn pawn)
 {
     SlaughterDesignatorUtility.CheckWarnAboutBondedAnimal(pawn);
 }
        /// <summary>
        /// Checks for cover along the flight path of the bullet, doesn't check for walls or trees, only intended for cover with partial fillPercent
        /// </summary>
        /// <param name="target">The target of which to find cover of</param>
        /// <param name="cover">Output parameter, filled with the highest cover object found</param>
        /// <returns>True if cover was found, false otherwise</returns>
        private bool GetHighestCoverAndSmokeForTarget(LocalTargetInfo target, out Thing cover, out float smokeDensity)
        {
            Map   map                = caster.Map;
            Thing targetThing        = target.Thing;
            Thing highestCover       = null;
            float highestCoverHeight = 0f;

            smokeDensity = 0;

            // Iterate through all cells on line of sight and check for cover and smoke
            var cells = GenSight.PointsOnLineOfSight(target.Cell, caster.Position).ToArray();

            if (cells.Length < 3)
            {
                cover = null;
                return(false);
            }
            for (int i = 0; i <= cells.Length / 2; i++)
            {
                var cell = cells[i];

                if (cell.AdjacentTo8Way(caster.Position))
                {
                    continue;
                }

                // Check for smoke
                var gas = cell.GetGas(map);
                if (gas != null)
                {
                    smokeDensity += gas.def.gas.accuracyPenalty;
                }

                // Check for cover in the second half of LoS
                if (i <= cells.Length / 2)
                {
                    Pawn  pawn     = cell.GetFirstPawn(map);
                    Thing newCover = pawn == null?cell.GetCover(map) : pawn;

                    float newCoverHeight = new CollisionVertical(newCover).Max;

                    // Cover check, if cell has cover compare collision height and get the highest piece of cover, ignore if cover is the target (e.g. solar panels, crashed ship, etc)
                    if (newCover != null &&
                        (targetThing == null || !newCover.Equals(targetThing)) &&
                        (highestCover == null || highestCoverHeight < newCoverHeight) &&
                        newCover.def.Fillage == FillCategory.Partial &&
                        !newCover.IsPlant())
                    {
                        highestCover       = newCover;
                        highestCoverHeight = newCoverHeight;
                        if (Controller.settings.DebugDrawTargetCoverChecks)
                        {
                            map.debugDrawer.FlashCell(cell, highestCoverHeight, highestCoverHeight.ToString());
                        }
                    }
                }
            }
            cover = highestCover;

            //Report success if found cover
            return(cover != null);
        }
 protected override string GetTip(Pawn pawn)
 {
     return("DesignatorSlaughterDesc".Translate());
 }
示例#44
0
 //ERROR MESSAGES
 public void Error_TriedDecayNullRelationship(Pawn pawn, Pawn other, PawnRelationDef pawnRelationDef)
 {
     this.Logger.Error("Tried to decay a null relationship {2} between {0} and {1}".Formatted(pawn.Name.ToStringShort, other.Name.ToStringShort, pawnRelationDef.defName));
 }
示例#45
0
 public virtual void PrePreTraded(TradeAction action, Pawn playerNegotiator, ITrader trader)
 {
 }
 protected override bool HasCheckbox(Pawn pawn)
 {
     return(pawn.RaceProps.Animal && pawn.RaceProps.IsFlesh && pawn.Faction == Faction.OfPlayer && pawn.SpawnedOrAnyParentSpawned);
 }
 private static bool <ExposeData> m__0(Pawn x)
 {
     return(x.Destroyed);
 }
示例#48
0
 public virtual void PostIngested(Pawn ingester)
 {
 }
示例#49
0
 public void addPawnOwnership(Pawn pawn)
 {
     pawns.Add(pawn);
     pawn.setCurrentChunk(this);
 }
示例#50
0
 public virtual IEnumerable <FloatMenuOption> CompFloatMenuOptions(Pawn selPawn)
 {
     yield break;
 }
示例#51
0
        public static void EatVirtualPlants(Pawn p)
        {
            float num = ThingDefOf.Plant_Grass.GetStatValueAbstract(StatDefOf.Nutrition) * VirtualPlantNutritionRandomFactor.RandomInRange;

            p.needs.food.CurLevel += num;
        }
示例#52
0
 public void removePawnOwnership(Pawn pawn)
 {
     pawns.Remove(pawn);
     pawn.setCurrentChunk(null);
 }
示例#53
0
 public static bool CanEatVirtualPlantsNow(Pawn p)
 {
     return(CanEatVirtualPlants(p, GenTicks.TicksAbs));
 }
示例#54
0
 public BattleLogEntry_DamageTaken(Pawn recipient, RulePackDef ruleDef, Pawn initiator = null)
 {
     initiatorPawn = initiator;
     recipientPawn = recipient;
     this.ruleDef  = ruleDef;
 }
示例#55
0
            internal bool <> m__0(Thing t)
            {
                Pawn pawn = (Pawn)t;

                return(pawn.Downed && pawn.Faction == this.pawn.Faction && !pawn.InBed() && this.pawn.CanReserve(pawn, 1, -1, null, false) && !pawn.IsForbidden(this.pawn) && !GenAI.EnemyIsNear(pawn, 25f));
            }
示例#56
0
 public static bool CanEatVirtualPlants(Pawn p, int ticksAbs)
 {
     return(p.Tile >= 0 && !p.Dead && p.IsWorldPawn() && CanEverEatVirtualPlants(p) && EnvironmentAllowsEatingVirtualPlantsAt(p.Tile, ticksAbs));
 }
示例#57
0
 public virtual bool InspirationCanOccur(Pawn pawn)
 {
     if (!this.def.allowedOnAnimals && pawn.RaceProps.Animal)
     {
         return(false);
     }
     if (!this.def.allowedOnNonColonists && !pawn.IsColonist)
     {
         return(false);
     }
     if (this.def.requiredNonDisabledStats != null)
     {
         for (int i = 0; i < this.def.requiredNonDisabledStats.Count; i++)
         {
             if (this.def.requiredNonDisabledStats[i].Worker.IsDisabledFor(pawn))
             {
                 return(false);
             }
         }
     }
     if (this.def.requiredSkills != null)
     {
         for (int j = 0; j < this.def.requiredSkills.Count; j++)
         {
             if (!this.def.requiredSkills[j].PawnSatisfies(pawn))
             {
                 return(false);
             }
         }
     }
     if (!this.def.requiredAnySkill.NullOrEmpty <SkillRequirement>())
     {
         bool flag = false;
         for (int k = 0; k < this.def.requiredAnySkill.Count; k++)
         {
             if (this.def.requiredAnySkill[k].PawnSatisfies(pawn))
             {
                 flag = true;
                 break;
             }
         }
         if (!flag)
         {
             return(false);
         }
     }
     if (this.def.requiredNonDisabledWorkTypes != null)
     {
         for (int l = 0; l < this.def.requiredNonDisabledWorkTypes.Count; l++)
         {
             if (pawn.story == null || pawn.story.WorkTypeIsDisabled(this.def.requiredNonDisabledWorkTypes[l]))
             {
                 return(false);
             }
         }
     }
     if (!this.def.requiredAnyNonDisabledWorkType.NullOrEmpty <WorkTypeDef>())
     {
         bool flag2 = false;
         for (int m = 0; m < this.def.requiredAnyNonDisabledWorkType.Count; m++)
         {
             if (pawn.story != null && !pawn.story.WorkTypeIsDisabled(this.def.requiredAnyNonDisabledWorkType[m]))
             {
                 flag2 = true;
                 break;
             }
         }
         if (!flag2)
         {
             return(false);
         }
     }
     if (this.def.requiredCapacities != null)
     {
         for (int n = 0; n < this.def.requiredCapacities.Count; n++)
         {
             if (!pawn.health.capacities.CapableOf(this.def.requiredCapacities[n]))
             {
                 return(false);
             }
         }
     }
     if (pawn.story != null)
     {
         for (int num = 0; num < pawn.story.traits.allTraits.Count; num++)
         {
             Trait trait = pawn.story.traits.allTraits[num];
             if (trait.CurrentData.disallowedInspirations != null && trait.CurrentData.disallowedInspirations.Contains(this.def))
             {
                 return(false);
             }
         }
     }
     return(true);
 }
示例#58
0
 public static bool CanEverEatVirtualPlants(Pawn p)
 {
     return(p.RaceProps.Eats(FoodTypeFlags.Plant));
 }
 public override int Compare(Pawn a, Pawn b)
 {
     return(Genes.GetGene(a, statDef).CompareTo(Genes.GetGene(b, statDef)));
 }
示例#60
0
        // Token: 0x06000077 RID: 119 RVA: 0x00004568 File Offset: 0x00002768
        internal static void HediffEffect(HediffDef hediffdef, float SeverityToApply, Pawn pawn, BodyPartRecord part,
                                          out bool immune)
        {
            immune = false;
            if (pawn.RaceProps.IsMechanoid || hediffdef == null)
            {
                return;
            }

            if (!ImmuneTo(pawn, hediffdef))
            {
                if (pawn.health.WouldDieAfterAddingHediff(hediffdef, part, SeverityToApply))
                {
                    return;
                }

                var    health = pawn.health;
                Hediff hediff;
                if (health == null)
                {
                    hediff = null;
                }
                else
                {
                    var hediffSet = health.hediffSet;
                    hediff = hediffSet?.GetFirstHediffOfDef(hediffdef);
                }

                var hashediff = hediff;
                if (hashediff != null)
                {
                    hashediff.Severity += SeverityToApply;
                    return;
                }

                var addhediff = HediffMaker.MakeHediff(hediffdef, pawn, part);
                addhediff.Severity = SeverityToApply;
                pawn.health.AddHediff(addhediff, part);
            }
            else
            {
                immune = true;
            }
        }