private void CreateOptionsForUser(List <FloatMenuOption> list)
        {
            IEnumerable <StoredApparelSet> sets;

            if (Settings.LinkGroupsToDresser)
            {
                sets = StoredApparelContainer.GetApparelSets(this.Dresser);
            }
            else
            {
                sets = StoredApparelContainer.GetAllApparelSets();
            }

            foreach (StoredApparelSet set in sets)
            {
                StringBuilder sb = new StringBuilder("ChangeDresser.EditApparelGroup".Translate());
                sb.Append(" ");
                sb.Append(set.Name);
                if (set.HasOwner)
                {
                    sb.Append(" - ");
                    sb.Append(set.OwnerName);
                }
                if (set.IsBeingWorn)
                {
                    sb.Append(" (");
                    sb.Append("ChangeDresser.BeingWorn".Translate());
                    sb.Append(")");
                }
                list.Add(new FloatMenuOption(sb.ToString(), delegate
                {
                    Find.WindowStack.Add(new StorageGroupUI(set, ApparelFromEnum.Storage, this.Dresser, null, false, true));
                }));
            }
        }
        public override void ExposeData()
        {
            base.ExposeData();

            if (Scribe.mode == LoadSaveMode.LoadingVars)
            {
                StoredApparelContainer.Clear();
            }

            List <StoredApparelSet> sets = null;

            if (!Settings.LinkGroupsToDresser && Scribe.mode == LoadSaveMode.Saving)
            {
                sets = new List <StoredApparelSet>(StoredApparelContainer.GetAllApparelSets());
            }

            Scribe_Collections.Look(ref sets, "storedApparelSet", LookMode.Deep, new object[0]);

            if (Scribe.mode == LoadSaveMode.LoadingVars)
            {
                if (sets != null && sets.Count > 0)
                {
                    StoredApparelContainer.AddApparelSets(sets);
                }
            }
        }
        public override void FinalizeInit()
        {
            base.FinalizeInit();
            Dictionary <string, Pawn> pawnIdToPawn = new Dictionary <string, Pawn>();

            foreach (Pawn p in PawnsFinder.AllMaps_SpawnedPawnsInFaction(Faction.OfPlayer))
            {
                pawnIdToPawn.Add(p.ThingID, p);
            }
            StoredApparelContainer.Initialize(pawnIdToPawn);
        }
        static void Postfix(Pawn_DraftController __instance)
        {
            StoredApparelSet set;

            if (StoredApparelContainer.TryGetBattleApparelSet(__instance.pawn, out set))
            {
                if ((__instance.Drafted && !set.IsBeingWorn) ||
                    (!__instance.Drafted && set.IsBeingWorn))
                {
                    set.SwapApparel(__instance.pawn);
                }
            }
        }
        private void Dispose()
        {
            if (this.storedApparel != null)
            {
                DropApparel(this.storedApparel);
                this.storedApparel.Clear();
            }

            if (Settings.LinkGroupsToDresser)
            {
                foreach (StoredApparelSet set in StoredApparelContainer.RemoveApparelSets(this))
                {
                    DropApparel(set.Apparel);
                }
            }
        }
        private void CreateOptionsForPawn(List <FloatMenuOption> list)
        {
            IEnumerable <StoredApparelSet> sets;

            if (Settings.LinkGroupsToDresser)
            {
                sets = StoredApparelContainer.GetApparelSets(this.Dresser);
            }
            else
            {
                sets = StoredApparelContainer.GetAllApparelSets();
            }

            foreach (StoredApparelSet set in sets)
            {
                string label = "";
                if (set.IsBeingWorn)
                {
                    label = label + " (" + "ChangeDresser.BeingWorn".Translate() + ")";
                }

                if (!set.IsOwnedBy(this.Pawn))
                {
                    string ownerName = "";
                    if (set.HasOwner)
                    {
                        ownerName = " - " + set.OwnerName;
                    }
                    list.Add(new FloatMenuOption("ChangeDresser.ClaimApparelGroup".Translate() + " " + set.Name + ownerName + label, delegate
                    {
                        set.SetOwner(this.Pawn);
                    }));
                }
                else
                {
                    list.Add(new FloatMenuOption("ChangeDresser.EditApparelGroup".Translate() + " " + set.Name + " " + "ChangeDresser.FromWorn".Translate() + label, delegate
                    {
                        Find.WindowStack.Add(new StorageGroupUI(set, ApparelFromEnum.Pawn, this.Dresser, this.Pawn, false, false));
                    }));
                    list.Add(new FloatMenuOption("ChangeDresser.EditApparelGroup".Translate() + " " + set.Name + " " + "ChangeDresser.FromStorage".Translate() + label, delegate
                    {
                        Find.WindowStack.Add(new StorageGroupUI(set, ApparelFromEnum.Storage, this.Dresser, this.Pawn, false, false));
                    }));
                }
            }
        }
Exemple #7
0
        protected override IEnumerable <Toil> MakeNewToils()
        {
            yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnDespawnedOrNull(TargetIndex.A));

            yield return(new Toil
            {
                initAction = delegate
                {
                    Building_Dresser dresser = (Building_Dresser)base.CurJob.targetA;
                    string apparelGroupName = ((SwapApparelJob)base.CurJob).ApparelGroupName;
                    Pawn pawn = this.GetActor();

                    StoredApparelSet setToGet = null;

                    IEnumerable <StoredApparelSet> sets;
                    if (Settings.LinkGroupsToDresser)
                    {
                        sets = StoredApparelContainer.GetApparelSets(dresser);
                    }
                    else
                    {
                        sets = StoredApparelContainer.GetAllApparelSets();
                    }

                    foreach (StoredApparelSet set in sets)
                    {
                        if (set.IsOwnedBy(pawn) && set.Name.Equals(apparelGroupName))
                        {
                            setToGet = set;
                            break;
                        }
                    }
                    if (setToGet == null)
                    {
                        Messages.Message(pawn.Name.ToStringShort + " " + "ChangeDresser.UnableToWearApparelGroup".Translate() + " " + apparelGroupName + ".", MessageSound.Negative);
                    }
                    else
                    {
                        setToGet.SwapApparel(pawn);
                    }
                }
            });

            yield break;
        }
        public override string GetInspectString()
        {
            this.Tick();
            StringBuilder sb = new StringBuilder(base.GetInspectString());

            sb.Append("ChangeDresser.StoragePriority".Translate());
            sb.Append(": ");
            sb.Append(("StoragePriority" + base.settings.Priority).Translate());
            sb.Append("\n");
            sb.Append("ChangeDresser.ApparelCount".Translate());
            sb.Append(": ");
            sb.Append(this.StoredApparel.Count);
            if (Settings.LinkGroupsToDresser)
            {
                sb.Append("\n");
                sb.Append("ChangeDresser.ApparelGroupCount".Translate());
                sb.Append(": ");
                sb.Append(StoredApparelContainer.GetApparelSets(this).Count);
            }
            return(sb.ToString());
        }
        public override void ExposeData()
        {
            base.ExposeData();

            List <StoredApparelSet> sets = null;

            if (Settings.LinkGroupsToDresser && Scribe.mode == LoadSaveMode.Saving)
            {
                sets = StoredApparelContainer.GetApparelSets(this);
            }

            Scribe_Collections.Look(ref this.storedApparel, "storedApparel", LookMode.Deep, new object[0]);
            Scribe_Collections.Look(ref sets, "storedApparelSet", LookMode.Deep, new object[0]);

            if (Scribe.mode == LoadSaveMode.LoadingVars)
            {
                if (sets != null && sets.Count > 0)
                {
                    StoredApparelContainer.AddApparelSets(sets);
                }
            }

            if (Scribe.mode == LoadSaveMode.LoadingVars)
            {
                if (groups != null && groups.Count > 0)
                {
                    sets = this.GetStoredApparelSetsFromStorageGroupDTOs();
                    groups.Clear();
                    groups = null;
                    if (sets != null && sets.Count > 0)
                    {
                        StoredApparelContainer.AddApparelSets(sets);
                    }
                }
            }
        }
        public override void DoWindowContents(Rect inRect)
        {
            try
            {
                Text.Font   = GameFont.Medium;
                Text.Anchor = TextAnchor.MiddleCenter;
                Widgets.Label(new Rect(0, 0, 200, 50), "ChangeDresser.ApparelGroupLabel".Translate());

                Text.Font = GameFont.Small;
                if (!this.FromGizmo)
                {
                    Widgets.Label(new Rect(250, 0, 200, 50), "ChangeDresser.ApparelGroupOwner".Translate() + ": " + this.Pawn.Name.ToStringShort);
                }
                else if (this.FromGizmo && this.isRestricted)
                {
                    string label;
                    if (this.set.HasOwner)
                    {
                        label = this.set.OwnerName;
                    }
                    else
                    {
                        label = "ChangeDresser.ApparelGroupOwner".Translate();
                    }

                    if (Widgets.ButtonText(new Rect(275, 10, 150, 30), label))
                    {
                        List <FloatMenuOption> options = new List <FloatMenuOption>();
                        foreach (Pawn p in this.PlayerPawns)
                        {
                            options.Add(new FloatMenuOption(p.Name.ToStringShort, delegate
                            {
                                StoredApparelSet tempSet;
                                if (this.set.SwitchForBattle && p != this.set.Owner &&
                                    StoredApparelContainer.TryGetBattleApparelSet(p, out tempSet))
                                {
                                    Messages.Message(p.Name.ToStringShort + " " + "ChangeDresser.AlreadyHasCombatApparel".Translate(), MessageSound.Negative);
                                }
                                else
                                {
                                    this.set.SetOwner(p);
                                }
                            }, MenuOptionPriority.Default, null, null, 0f, null, null));
                        }
                        Find.WindowStack.Add(new FloatMenu(options));
                    }
                }

                Rect rect = new Rect(0, 50, inRect.width, 30);
                Text.Font = GameFont.Small;
                GUI.BeginGroup(rect);
                GUI.Label(new Rect(0, 0, 100, rect.height), "ChangeDresser.ApparelGroupName".Translate() + ":", WidgetUtil.MiddleCenter);
                this.set.Name = Widgets.TextField(new Rect(110, 0, 150, rect.height), this.set.Name);

                GUI.Label(new Rect(280, 0, 120, rect.height), "ChangeDresser.ApparelGroupRestrictToPawnCheckBox".Translate() + ":", WidgetUtil.MiddleCenter);
                bool temp = this.set.HasOwner || (this.FromGizmo && this.isRestricted);
                temp = GUI.Toggle(new Rect(410, 7, rect.height, rect.height), temp, "");
                if (this.isRestricted != temp)
                {
                    this.isRestricted = temp;
                    if (this.isRestricted && !this.FromGizmo)
                    {
                        this.set.SetOwner(this.Pawn);
                    }
                    else
                    {
                        this.set.SetOwner(null);
                        this.set.SwitchForBattle = false;
                    }
                }

                if (!this.FromGizmo || (this.FromGizmo && this.set.HasOwner))
                {
                    GUI.Label(new Rect(440, 0, 150, rect.height), "ChangeDresser.ForceSwitchCombat".Translate() + ":", WidgetUtil.MiddleCenter);
                    bool forceSwitch = GUI.Toggle(new Rect(600, 7, rect.height, rect.height), this.set.SwitchForBattle, "");
                    if (forceSwitch != this.set.SwitchForBattle)
                    {
                        if (forceSwitch)
                        {
                            StoredApparelSet tempSet;
                            if (this.Pawn != null && StoredApparelContainer.TryGetBattleApparelSet(this.Pawn, out tempSet))
                            {
                                Messages.Message(this.Pawn.Name.ToStringShort + " " + "ChangeDresser.AlreadyHasCombatApparel".Translate(), MessageSound.Negative);
                            }
                            else
                            {
                                this.set.SwitchForBattle = forceSwitch;
                                if (!this.set.HasOwner)
                                {
                                    this.set.SetOwner(this.Pawn);
                                }
                            }
                        }
                    }
                }

                GUI.EndGroup();

                List <Apparel> possibleApparel  = (this.ApparelFrom == ApparelFromEnum.Pawn && this.Pawn != null) ? this.Pawn.apparel.WornApparel : this.Dresser.StoredApparel;
                List <Apparel> groupApparel     = this.set.Apparel;
                List <string>  forcedApparelIds = this.set.ForcedApparelIds;

                GUI.BeginGroup(new Rect(0, 90, inRect.width, 30));
                GUI.Label(new Rect(0, 0, 100, 30), ((string)((this.ApparelFrom == ApparelFromEnum.Pawn) ? "ChangeDresser.Worn" : "ChangeDresser.Storage")).Translate(), WidgetUtil.MiddleCenter);
                GUI.Label(new Rect(inRect.width * 0.5f, 0, 100, 30), "ChangeDresser.ApparelGroup".Translate(), WidgetUtil.MiddleCenter);
                GUI.EndGroup();

                const float cellHeight        = 40f;
                float       apparelListWidth  = inRect.width * 0.5f - 10f;
                Rect        apparelListRect   = new Rect(0, 120, apparelListWidth, inRect.height - 150);
                Rect        apparelScrollRect = new Rect(0f, 0f, apparelListRect.width - 16f, possibleApparel.Count * cellHeight);

                GUI.BeginGroup(apparelListRect);
                this.scrollPosLeft = GUI.BeginScrollView(new Rect(GenUI.AtZero(apparelListRect)), this.scrollPosLeft, apparelScrollRect);

                GUI.color = Color.white;
                Text.Font = GameFont.Medium;
                Pawn pawnToUse = this.Pawn;
                if (pawnToUse == null && this.FromGizmo && this.set.HasOwner)
                {
                    pawnToUse = set.Owner;
                }
                for (int i = 0; i < possibleApparel.Count; ++i)
                {
                    Apparel apparel = possibleApparel[i];
                    Rect    rowRect = new Rect(0, 2f + i * cellHeight, apparelListRect.width, cellHeight);
                    GUI.BeginGroup(rowRect);

                    Widgets.ThingIcon(new Rect(0f, 0f, cellHeight, cellHeight), apparel);

                    Text.Font = GameFont.Small;
                    Widgets.Label(new Rect(cellHeight + 5f, 0f, rowRect.width - 40f - cellHeight, cellHeight), apparel.Label);

                    GUI.color = Color.white;

                    Rect buttonRect = new Rect(rowRect.width - 35f, 10, 20, 20);

                    if (pawnToUse != null && this.CanWear(groupApparel, apparel))
                    {
                        if (Widgets.ButtonImage(buttonRect, WidgetUtil.nextTexture))
                        {
                            this.RemoveApparelFromSender(apparel);
                            pawnToUse.apparel.Remove(apparel);
                            groupApparel.Add(apparel);
                            GUI.EndGroup();
                            break;
                        }
                    }
                    else
                    {
                        Widgets.ButtonImage(buttonRect, WidgetUtil.cantTexture);
                    }
                    GUI.EndGroup();
                }
                GUI.EndScrollView();
                GUI.EndGroup();


                apparelListRect   = new Rect(inRect.width * 0.5f + 10f, 120, apparelListWidth, inRect.height - 150);
                apparelScrollRect = new Rect(0f, 0f, apparelListRect.width - 16f, groupApparel.Count * cellHeight);

                GUI.BeginGroup(apparelListRect);
                this.scrollPosRight = GUI.BeginScrollView(new Rect(GenUI.AtZero(apparelListRect)), this.scrollPosRight, apparelScrollRect);

                GUI.color = Color.white;
                Text.Font = GameFont.Medium;
                for (int i = 0; i < groupApparel.Count; ++i)
                {
                    Apparel apparel = groupApparel[i];
                    Rect    rowRect = new Rect(0, 2f + i * cellHeight, apparelListRect.width, cellHeight);
                    GUI.BeginGroup(rowRect);

                    if (Widgets.ButtonImage(new Rect(5, 10, 20, 20), WidgetUtil.previousTexture))
                    {
                        this.AddApparelToSender(apparel, forcedApparelIds.Contains(apparel.ThingID));
                        groupApparel.RemoveAt(i);
                        GUI.EndGroup();
                        break;
                    }

                    Widgets.ThingIcon(new Rect(35f, 0f, cellHeight, cellHeight), apparel);
                    Text.Font   = GameFont.Small;
                    Text.Anchor = TextAnchor.MiddleCenter;
                    string label = apparel.Label;
                    if (forcedApparelIds.Contains(apparel.ThingID))
                    {
                        label += "(" + "ApparelForcedLower".Translate() + ")";
                    }
                    Widgets.Label(new Rect(cellHeight + 45f, 0f, rowRect.width - cellHeight - 45f, cellHeight), label);

                    GUI.EndGroup();
                }
                GUI.EndScrollView();
                GUI.EndGroup();

                Text.Font = GameFont.Small;
                GUI.BeginGroup(new Rect(0, inRect.height - 35, inRect.width, 30));
                float middle = inRect.width / 2;
                if (Widgets.ButtonText(new Rect(middle - 110, 0, 100, 30), "ChangeDresser.Save".Translate(), true, false, this.set.HasName))
                {
                    this.set.ClearWornBy();
                    if (IsNew)
                    {
                        StoredApparelContainer.AddApparelSet(this.set);
                    }
                    this.Close();
                }
                Rect rightButton = new Rect(middle + 10, 0, 100, 30);
                if (IsNew && this.Pawn != null && Widgets.ButtonText(rightButton, "ChangeDresser.Cancel".Translate()))
                {
                    for (int i = 0; i < this.set.Apparel.Count; ++i)
                    {
                        Apparel apparel = this.set.Apparel[i];
                        this.AddApparelToSender(apparel, this.set.ForcedApparelIds.Contains(apparel.ThingID));
                    }
                    this.Close();
                }
                if (!IsNew)
                {
                    if (this.set.Apparel.Count > 0)
                    {
                        Text.Font         = GameFont.Small;
                        rightButton.width = 300;
                        GUI.Label(rightButton, "ChangeDresser.RemoveToEnableDelete".Translate(), WidgetUtil.MiddleCenter);
                    }
                    else if (Widgets.ButtonText(rightButton, "ChangeDresser.Delete".Translate(), true, false, this.set.Apparel.Count == 0))
                    {
                        StoredApparelContainer.RemoveApparelSet(this.set);
                        this.Close();
                    }
                }
                GUI.EndGroup();
            }
            catch (Exception e)
            {
                Log.Error(this.GetType().Name + " closed due to: " + e.GetType().Name + " " + e.Message);
                Messages.Message(this.GetType().Name + " closed due to: " + e.GetType().Name + " " + e.Message, MessageSound.Negative);
                base.Close();
            }
            finally
            {
                Text.Anchor = TextAnchor.UpperLeft;
                GUI.color   = Color.white;
            }
        }
        public override IEnumerable <FloatMenuOption> GetFloatMenuOptions(Pawn pawn)
        {
            List <FloatMenuOption> list = new List <FloatMenuOption>();

            if (pawn.apparel.WornApparel.Count > 0)
            {
                list.Add(new FloatMenuOption(
                             "ChangeDresser.ChangeApparelColors".Translate(),
                             delegate
                {
                    Job job = new Job(this.changeApparelColorJobDef, this);
                    pawn.jobs.TryTakeOrderedJob(job);
                }));
            }

            list.Add(new FloatMenuOption(
                         "ChangeDresser.ChangeHair".Translate(),
                         delegate
            {
                Job job = new Job(this.changeHairStyleJobDef, this);
                pawn.jobs.TryTakeOrderedJob(job);
            }));
            if (Settings.ShowBodyChange)
            {
                list.Add(new FloatMenuOption(
                             "ChangeDresser.ChangeBody".Translate(),
                             delegate
                {
                    Job job = new Job(this.changeBodyJobDef, this);
                    pawn.jobs.TryTakeOrderedJob(job);
                }));
            }
            list.Add(new FloatMenuOption(
                         "ChangeDresser.StoreApparel".Translate(),
                         delegate
            {
                Job job = new Job(this.storeApparelJobDef, this);
                pawn.jobs.TryTakeOrderedJob(job);
            }));

            StoredApparelSet wornSet;

            if (StoredApparelContainer.TryGetWornApparelSet(pawn, out wornSet))
            {
                list.Add(new FloatMenuOption(
                             "ChangeDresser.UnwearGroup".Translate() + " \"" + wornSet.Name + "\"",
                             delegate
                {
                    Job job = new SwapApparelJob(this.wearApparelGroupJobDef, this, wornSet.Name);
                    pawn.jobs.TryTakeOrderedJob(job);
                }));
            }
            else
            {
                IEnumerable <StoredApparelSet> sets;
                if (Settings.LinkGroupsToDresser)
                {
                    sets = StoredApparelContainer.GetApparelSets(this);
                }
                else
                {
                    sets = StoredApparelContainer.GetAllApparelSets();
                }

                foreach (StoredApparelSet set in sets)
                {
                    if (set.IsOwnedBy(pawn))
                    {
                        list.Add(new FloatMenuOption(
                                     "ChangeDresser.WearGroup".Translate() + " \"" + set.Name + "\"",
                                     delegate
                        {
                            Job job = new SwapApparelJob(this.wearApparelGroupJobDef, this, set.Name);
                            pawn.jobs.TryTakeOrderedJob(job);
                        }));
                    }
                }
            }
            return(list);
        }
 public void Remove(StoredApparelSet set)
 {
     StoredApparelContainer.RemoveApparelSet(set);
 }