Ejemplo n.º 1
0
        public static bool AcceptableGameConditionsToStartCeremony(Map map)
        {
            bool result;

            if (!MarriageCeremonyUtility.AcceptableGameConditionsToContinueCeremony(map))
            {
                result = false;
            }
            else if (GenLocalDate.HourInteger(map) < 5 || GenLocalDate.HourInteger(map) > 16)
            {
                result = false;
            }
            else if (GatheringsUtility.AnyLordJobPreventsNewGatherings(map))
            {
                result = false;
            }
            else if (map.dangerWatcher.DangerRating != StoryDanger.None)
            {
                result = false;
            }
            else
            {
                int num = 0;
                foreach (Pawn pawn in map.mapPawns.FreeColonistsSpawned)
                {
                    if (pawn.Drafted)
                    {
                        num++;
                    }
                }
                result = ((float)num / (float)map.mapPawns.FreeColonistsSpawnedCount < 0.5f);
            }
            return(result);
        }
        protected override IEnumerable <Toil> MakeNewToils()
        {
            this.FailOnDespawnedOrNull(TargetIndex.A);
            this.FailOn(() => OtherFiance.Drafted || !pawn.Position.AdjacentTo8WayOrInside(OtherFiance));
            Toil toil = new Toil();

            toil.initAction = delegate
            {
                ticksLeftToMarry = 2500;
            };
            toil.tickAction = delegate
            {
                ticksLeftToMarry--;
                if (ticksLeftToMarry <= 0)
                {
                    ticksLeftToMarry = 0;
                    ReadyForNextToil();
                }
            };
            toil.defaultCompleteMode = ToilCompleteMode.Never;
            toil.FailOn(() => !pawn.relations.DirectRelationExists(PawnRelationDefOf.Fiance, OtherFiance));
            yield return(toil);

            Toil toil2 = new Toil();

            toil2.defaultCompleteMode = ToilCompleteMode.Instant;
            toil2.initAction          = delegate
            {
                if (pawn.thingIDNumber < OtherFiance.thingIDNumber)
                {
                    MarriageCeremonyUtility.Married(pawn, OtherFiance);
                }
            };
            yield return(toil2);
        }
 public override float VoluntaryJoinPriorityFor(Pawn p)
 {
     if (IsFiance(p))
     {
         if (!MarriageCeremonyUtility.FianceCanContinueCeremony(p, (p == firstPawn) ? secondPawn : firstPawn))
         {
             return(0f);
         }
         return(VoluntarilyJoinableLordJobJoinPriorities.MarriageCeremonyFiance);
     }
     if (IsGuest(p))
     {
         if (!MarriageCeremonyUtility.ShouldGuestKeepAttendingCeremony(p))
         {
             return(0f);
         }
         if (!lord.ownedPawns.Contains(p))
         {
             if (IsCeremonyAboutToEnd())
             {
                 return(0f);
             }
             LordToil_MarriageCeremony lordToil_MarriageCeremony = lord.CurLordToil as LordToil_MarriageCeremony;
             if (lordToil_MarriageCeremony != null && !SpectatorCellFinder.TryFindSpectatorCellFor(p, lordToil_MarriageCeremony.Data.spectateRect, base.Map, out var _, lordToil_MarriageCeremony.Data.spectateRectAllowedSides))
             {
                 return(0f);
             }
         }
         return(VoluntarilyJoinableLordJobJoinPriorities.MarriageCeremonyGuest);
     }
     return(0f);
 }
            public bool MoveNext()
            {
                uint num = (uint)this.$PC;

                this.$PC = -1;
                switch (num)
                {
                case 0u:
                    this.FailOnDespawnedOrNull(TargetIndex.A);
                    this.FailOn(() => base.OtherFiance.Drafted || !this.pawn.Position.AdjacentTo8WayOrInside(base.OtherFiance));
                    marry            = new Toil();
                    marry.initAction = delegate()
                    {
                        this.ticksLeftToMarry = 2500;
                    };
                    marry.tickAction = delegate()
                    {
                        this.ticksLeftToMarry--;
                        if (this.ticksLeftToMarry <= 0)
                        {
                            this.ticksLeftToMarry = 0;
                            base.ReadyForNextToil();
                        }
                    };
                    marry.defaultCompleteMode = ToilCompleteMode.Never;
                    marry.FailOn(() => !this.pawn.relations.DirectRelationExists(PawnRelationDefOf.Fiance, base.OtherFiance));
                    this.$current = marry;
                    if (!this.$disposing)
                    {
                        this.$PC = 1;
                    }
                    return(true);

                case 1u:
                {
                    Toil finalize = new Toil();
                    finalize.defaultCompleteMode = ToilCompleteMode.Instant;
                    finalize.initAction          = delegate()
                    {
                        if (this.pawn.thingIDNumber < base.OtherFiance.thingIDNumber)
                        {
                            MarriageCeremonyUtility.Married(this.pawn, base.OtherFiance);
                        }
                    };
                    this.$current = finalize;
                    if (!this.$disposing)
                    {
                        this.$PC = 2;
                    }
                    return(true);
                }

                case 2u:
                    this.$PC = -1;
                    break;
                }
                return(false);
            }
 public static void Married(Pawn firstPawn, Pawn secondPawn)
 {
     LovePartnerRelationUtility.ChangeSpouseRelationsToExSpouse(firstPawn);
     LovePartnerRelationUtility.ChangeSpouseRelationsToExSpouse(secondPawn);
     firstPawn.relations.RemoveDirectRelation(PawnRelationDefOf.Fiance, secondPawn);
     firstPawn.relations.TryRemoveDirectRelation(PawnRelationDefOf.ExSpouse, secondPawn);
     firstPawn.relations.AddDirectRelation(PawnRelationDefOf.Spouse, secondPawn);
     MarriageCeremonyUtility.AddNewlyMarriedThoughts(firstPawn, secondPawn);
     MarriageCeremonyUtility.AddNewlyMarriedThoughts(secondPawn, firstPawn);
     firstPawn.needs.mood.thoughts.memories.RemoveMemoriesOfDefWhereOtherPawnIs(ThoughtDefOf.DivorcedMe, secondPawn);
     secondPawn.needs.mood.thoughts.memories.RemoveMemoriesOfDefWhereOtherPawnIs(ThoughtDefOf.DivorcedMe, firstPawn);
     LovePartnerRelationUtility.TryToShareBed(firstPawn, secondPawn);
     TaleRecorder.RecordTale(TaleDefOf.Marriage, firstPawn, secondPawn);
 }
        public override float VoluntaryJoinPriorityFor(Pawn p)
        {
            float result;

            if (this.IsFiance(p))
            {
                if (!MarriageCeremonyUtility.FianceCanContinueCeremony(p))
                {
                    result = 0f;
                }
                else
                {
                    result = VoluntarilyJoinableLordJobJoinPriorities.MarriageCeremonyFiance;
                }
            }
            else if (this.IsGuest(p))
            {
                if (!MarriageCeremonyUtility.ShouldGuestKeepAttendingCeremony(p))
                {
                    result = 0f;
                }
                else
                {
                    if (!this.lord.ownedPawns.Contains(p))
                    {
                        if (this.IsCeremonyAboutToEnd())
                        {
                            return(0f);
                        }
                        LordToil_MarriageCeremony lordToil_MarriageCeremony = this.lord.CurLordToil as LordToil_MarriageCeremony;
                        IntVec3 intVec;
                        if (lordToil_MarriageCeremony != null && !SpectatorCellFinder.TryFindSpectatorCellFor(p, lordToil_MarriageCeremony.Data.spectateRect, base.Map, out intVec, lordToil_MarriageCeremony.Data.spectateRectAllowedSides, 1, null))
                        {
                            return(0f);
                        }
                    }
                    result = VoluntarilyJoinableLordJobJoinPriorities.MarriageCeremonyGuest;
                }
            }
            else
            {
                result = 0f;
            }
            return(result);
        }
Ejemplo n.º 7
0
 private bool ShouldCeremonyBeCalledOff()
 {
     if (firstPawn.Destroyed || secondPawn.Destroyed)
     {
         return(true);
     }
     if (!firstPawn.relations.DirectRelationExists(PawnRelationDefOf.Fiance, secondPawn))
     {
         return(true);
     }
     if (spot.GetDangerFor(firstPawn, base.Map) != Danger.None || spot.GetDangerFor(secondPawn, base.Map) != Danger.None)
     {
         return(true);
     }
     if (!MarriageCeremonyUtility.AcceptableGameConditionsToContinueCeremony(base.Map) || !MarriageCeremonyUtility.FianceCanContinueCeremony(firstPawn, secondPawn) || !MarriageCeremonyUtility.FianceCanContinueCeremony(secondPawn, firstPawn))
     {
         return(true);
     }
     return(false);
 }
Ejemplo n.º 8
0
 private bool ShouldCeremonyBeCalledOff()
 {
     if (!this.firstPawn.Destroyed && !this.secondPawn.Destroyed)
     {
         if (!this.firstPawn.relations.DirectRelationExists(PawnRelationDefOf.Fiance, this.secondPawn))
         {
             return(true);
         }
         if (this.spot.GetDangerFor(this.firstPawn, base.Map) == Danger.None && this.spot.GetDangerFor(this.secondPawn, base.Map) == Danger.None)
         {
             if (MarriageCeremonyUtility.AcceptableGameConditionsToContinueCeremony(base.Map) && MarriageCeremonyUtility.FianceCanContinueCeremony(this.firstPawn) && MarriageCeremonyUtility.FianceCanContinueCeremony(this.secondPawn))
             {
                 return(false);
             }
             return(true);
         }
         return(true);
     }
     return(true);
 }
        protected override IEnumerable <Toil> MakeNewToils()
        {
            this.FailOnDespawnedOrNull(TargetIndex.A);
            this.FailOn(() => this.OtherFiance.Drafted || !this.pawn.Position.AdjacentTo8WayOrInside(this.OtherFiance));
            Toil marry = new Toil();

            marry.initAction = delegate()
            {
                this.ticksLeftToMarry = 2500;
            };
            marry.tickAction = delegate()
            {
                this.ticksLeftToMarry--;
                if (this.ticksLeftToMarry <= 0)
                {
                    this.ticksLeftToMarry = 0;
                    base.ReadyForNextToil();
                }
            };
            marry.defaultCompleteMode = ToilCompleteMode.Never;
            marry.FailOn(() => !this.pawn.relations.DirectRelationExists(PawnRelationDefOf.Fiance, this.OtherFiance));
            yield return(marry);

            yield return(new Toil
            {
                defaultCompleteMode = ToilCompleteMode.Instant,
                initAction = delegate()
                {
                    if (this.pawn.thingIDNumber < this.OtherFiance.thingIDNumber)
                    {
                        MarriageCeremonyUtility.Married(this.pawn, this.OtherFiance);
                    }
                }
            });

            yield break;
        }
 private bool ShouldCeremonyBeCalledOff()
 {
     return(this.firstPawn.Destroyed || this.secondPawn.Destroyed || !this.firstPawn.relations.DirectRelationExists(PawnRelationDefOf.Fiance, this.secondPawn) || (this.spot.GetDangerFor(this.firstPawn, base.Map) != Danger.None || this.spot.GetDangerFor(this.secondPawn, base.Map) != Danger.None) || (!MarriageCeremonyUtility.AcceptableGameConditionsToContinueCeremony(base.Map) || !MarriageCeremonyUtility.FianceCanContinueCeremony(this.firstPawn, this.secondPawn) || !MarriageCeremonyUtility.FianceCanContinueCeremony(this.secondPawn, this.firstPawn)));
 }
 private void Tick_CheckStartMarriageCeremony()
 {
     if (this.pawn.Spawned && !this.pawn.RaceProps.Animal && this.pawn.IsHashIntervalTick(1017))
     {
         int ticksGame = Find.TickManager.TicksGame;
         for (int i = 0; i < this.directRelations.Count; i++)
         {
             float num = (float)((float)(ticksGame - this.directRelations[i].startTicks) / 60000.0);
             if (this.directRelations[i].def == PawnRelationDefOf.Fiance && this.pawn.thingIDNumber <this.directRelations[i].otherPawn.thingIDNumber && num> 10.0 && Rand.MTBEventOccurs(2f, 60000f, 1017f) && this.pawn.Map == this.directRelations[i].otherPawn.Map && this.pawn.Map.IsPlayerHome && MarriageCeremonyUtility.AcceptableGameConditionsToStartCeremony(this.pawn.Map) && MarriageCeremonyUtility.FianceReadyToStartCeremony(this.pawn) && MarriageCeremonyUtility.FianceReadyToStartCeremony(this.directRelations[i].otherPawn))
             {
                 this.pawn.Map.lordsStarter.TryStartMarriageCeremony(this.pawn, this.directRelations[i].otherPawn);
             }
         }
     }
 }
Ejemplo n.º 12
0
 public static bool FianceReadyToStartCeremony(Pawn pawn)
 {
     return(MarriageCeremonyUtility.FianceCanContinueCeremony(pawn) && pawn.health.hediffSet.BleedRateTotal <= 0f && !HealthAIUtility.ShouldSeekMedicalRestUrgent(pawn) && !PawnUtility.WillSoonHaveBasicNeed(pawn) && !MarriageCeremonyUtility.IsCurrentlyMarryingSomeone(pawn) && pawn.GetLord() == null && (!pawn.Drafted && !pawn.InMentalState && pawn.Awake() && !pawn.IsBurning()) && !pawn.InBed());
 }
Ejemplo n.º 13
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="pawn"></param>
        /// <returns></returns>


        public static bool FianceReadyToStartCeremony(Pawn pawn)
        {
            return(MarriageCeremonyUtility.FianceCanContinueCeremony(pawn) && pawn.health.hediffSet.BleedingRate <= 0f && !pawn.health.NeedsMedicalRest && !PawnUtility.WillSoonHaveBasicNeed(pawn) && !MarriageCeremonyUtility.IsCurrentlyMarryingSomeone(pawn) && (!pawn.Drafted && !pawn.InMentalState && pawn.Awake()) && !pawn.IsBurning());
        }