Exemple #1
0
        private void WeaponCompsNew()
        {
            // ReSharper disable once PossibleNullReferenceException
            foreach (WeaponExtensionDef weaponExtensionDef in DefDatabase <WeaponExtensionDef> .AllDefsListForReading)
            {
                ThingDef thingDef = ThingDef.Named(weaponExtensionDef.weapon);

                if (thingDef == null)
                {
                    continue;
                }

                if (thingDef.HasComp(typeof(CompProperties_WeaponExtensions)))
                {
                    return;
                }

                CompProperties_WeaponExtensions weaponExtensions =
                    new CompProperties_WeaponExtensions
                {
                    compClass                 = typeof(CompWeaponExtensions),
                    AttackAngleOffset         = weaponExtensionDef.attackAngleOffset,
                    WeaponPositionOffset      = weaponExtensionDef.weaponPositionOffset,
                    AimedWeaponPositionOffset = weaponExtensionDef.aimedWeaponPositionOffset,
                    RightHandPosition         = weaponExtensionDef.firstHandPosition,
                    LeftHandPosition          = weaponExtensionDef.secondHandPosition
                };

                thingDef.comps?.Add(weaponExtensions);
            }

            this.LaserLoad();
        }
Exemple #2
0
 private void LaserLoad()
 {
     if (this.HandCheck())
     {
         ThingDef wepzie = ThingDef.Named("LaserRifle");
         if (wepzie != null)
         {
             CompProperties_WeaponExtensions extensions =
                 new CompProperties_WeaponExtensions
             {
                 compClass         = typeof(CompWeaponExtensions),
                 RightHandPosition = new Vector3(-0.2f, 0.3f, -0.05f),
                 LeftHandPosition  = new Vector3(0.25f, 0f, -0.05f)
             };
             wepzie.comps.Add(extensions);
         }
     }
 }
Exemple #3
0
        protected override void FillTab()
        {
            if (this.pawn != this.SelPawn)
            {
                this.pawn = this.SelPawn;
            }

            bool horizontal = this.pawn.Rotation.IsHorizontal;

            if (!this.SelPawn.GetCompFace(out CompFace compFace))
            {
                return;
            }

            Rect rect = new Rect(10f, 10f, 330f, 530f);

            Listing_Standard listing = new Listing_Standard();

            listing.Begin(rect);


            this.SelPawn.GetCompAnim(out CompBodyAnimator _);


            listing.CheckboxLabeled("Ignore renderer", ref compFace.IgnoreRenderer);
            if (GUI.changed)
            {
                IgnoreRenderer = compFace.IgnoreRenderer;
            }

            ThingWithComps primary = this.SelPawn.equipment?.Primary;

            if (primary == null)
            {
                return;
            }

            weaponExtensions = primary?.def.GetCompProperties <CompProperties_WeaponExtensions>();

            if (weaponExtensions == null)
            {
                weaponExtensions = new CompProperties_WeaponExtensions
                {
                    compClass = typeof(CompWeaponExtensions)
                };

                primary.def.comps?.Add(weaponExtensions);
            }

            if (this.SelPawn.Drafted)
            {
                listing.Label(this.pawn.equipment.Primary.def.defName);

                Vector3 weaponOffset = weaponExtensions.WeaponPositionOffset;

                listing.Label("Offset: " +
                              (weaponOffset.x).ToString("N2") + " / " +
                              (weaponOffset.y).ToString("N2") + " / " +
                              (weaponOffset.z).ToString("N2"));
                if (horizontal)
                {
                    weaponOffset.y = listing.Slider(weaponOffset.y, -1f, 1f, label: "Horizontal x");
                }
                else
                {
                    weaponOffset.x = listing.Slider(weaponOffset.x, -1f, 1f, label: "Vertical x");
                }
                weaponOffset.z = listing.Slider(weaponOffset.z, -1f, 1f, label: "z");

                Vector3 aimedOffset = weaponExtensions.AimedWeaponPositionOffset;
                listing.Label("OffsetAiming: " +
                              (aimedOffset.x).ToString("N2") + " / " +
                              (aimedOffset.y).ToString("N2") + " / " +
                              (aimedOffset.z).ToString("N2"));
                if (horizontal)
                {
                    aimedOffset.y = listing.Slider(aimedOffset.y, -1f, 1f, label: "Horizontal x");
                }
                else
                {
                    aimedOffset.x = listing.Slider(aimedOffset.x, -1f, 1f, label: "Vertical x");
                }
                aimedOffset.z = listing.Slider(aimedOffset.z, -1f, 1f, label: "z");

                Vector3 rightHandPosition = weaponExtensions.RightHandPosition;
                listing.Label("RH: " +
                              (rightHandPosition.x).ToString("N2") + " / " +
                              (rightHandPosition.z).ToString("N2"));

                listing.Gap();
                rightHandPosition.y =
                    listing.Slider(rightHandPosition.y, -YOffset_HandsFeet, YOffset_HandsFeet, leftAlignedLabel: "behind",
                                   rightAlignedLabel: "front", roundTo: YOffset_HandsFeet);

                rightHandPosition.x = listing.Slider(rightHandPosition.x, -1f, 1f);
                rightHandPosition.z = listing.Slider(rightHandPosition.z, -1f, 1f);

                Vector3 leftHandPosition = weaponExtensions.LeftHandPosition;
                listing.Label("LH: " +
                              (leftHandPosition.x).ToString("N2") + " / " +
                              (leftHandPosition.z).ToString("N2"));

                listing.Gap();
                leftHandPosition.y =
                    listing.Slider(leftHandPosition.y, -YOffset_HandsFeet,
                                   YOffset_HandsFeet, leftAlignedLabel: "behind",
                                   rightAlignedLabel: "front", roundTo: YOffset_HandsFeet);

                leftHandPosition.x = listing.Slider(leftHandPosition.x, -1f, 1f);
                leftHandPosition.z = listing.Slider(leftHandPosition.z, -1f, 1f);

                if (leftHandPosition != Vector3.zero)
                {
                    if (listing.ButtonText("Remove left hand position"))
                    {
                        leftHandPosition = Vector3.zero;
                    }
                }

                listing.Gap();

                if (listing.ButtonText("Export WeaponExtensionDef"))
                {
                    string defName = "WeaponExtensionDef_" + primary?.def.defName;

                    WeaponExtensionDef wepDef;
                    if (!DefDatabase <WeaponExtensionDef> .AllDefsListForReading.Any(x => x.defName == defName))
                    {
                        wepDef = new WeaponExtensionDef
                        {
                            defName = defName,
                            label   = defName,
                            weapon  = primary.def.defName
                        };
                        DefDatabase <WeaponExtensionDef> .Add(wepDef);
                    }
                    else
                    {
                        wepDef = DefDatabase <WeaponExtensionDef> .GetNamed(defName);
                    }

                    wepDef.weaponPositionOffset      = weaponOffset;
                    wepDef.aimedWeaponPositionOffset = aimedOffset;
                    wepDef.firstHandPosition         = rightHandPosition;
                    wepDef.secondHandPosition        = leftHandPosition;

                    string configFolder = MainTabWindow_BaseAnimator.DefPath;
                    string path         = configFolder + "/WeaponExtensionDefs/" + wepDef.defName + ".xml";


                    Find.WindowStack.Add(
                        Dialog_MessageBox.CreateConfirmation(
                            "Confirm overwriting: " + path,
                            delegate
                    {
                        ExportWeaponExtensionDefs.Defs cycle =
                            new ExportWeaponExtensionDefs.Defs(wepDef);

                        DirectXmlSaver.SaveDataObject(
                            cycle,
                            path);
                    },
                            true));
                }

                if (GUI.changed)
                {
                    weaponExtensions.WeaponPositionOffset      = weaponOffset;
                    weaponExtensions.AimedWeaponPositionOffset = aimedOffset;
                    weaponExtensions.LeftHandPosition          = leftHandPosition;
                    weaponExtensions.RightHandPosition         = rightHandPosition;
                }
            }


            listing.End();
            // NeedsCardUtility.DoNeedsMoodAndThoughts(new Rect(0f, 0f, this.size.x, this.size.y), base.SelPawn, ref this.thoughtScrollPosition);
        }