public static void TryDropEquipment_Postfix(Pawn_EquipmentTracker __instance, ThingWithComps eq)
 {
     if (eq != null)
     {
         CompActivatableEffect.CompActivatableEffect comp = eq.TryGetComp <CompActivatableEffect.CompActivatableEffect>();
         bool flag = __instance != null && comp != null && comp.CurrentState == CompActivatableEffect.CompActivatableEffect.State.Activated;
         if (flag)
         {
             comp.TryDeactivate();
         }
     }
 }
 public static bool PawnRenderer_DrawEquipmentAiming_Postfix(ref PawnRenderer __instance, Thing eq, Vector3 drawLoc, float aimAngle)
 {
     if (!AdeptusIntergrationUtil.enabled_rooloDualWield)
     {
         Pawn pawn = eq.TryGetComp <CompEquippable>().PrimaryVerb.CasterPawn;
         if (pawn != null)
         {
             Pawn value2 = pawn;
             CompActivatableEffect.CompActivatableEffect compActivatableEffect = eq.TryGetComp <CompActivatableEffect.CompActivatableEffect>();
             CompOversizedWeapon.CompOversizedWeapon     compOversizedWeapon   = eq.TryGetComp <CompOversizedWeapon.CompOversizedWeapon>();
             if (compActivatableEffect != null && compOversizedWeapon != null)
             {
                 return(false);
             }
         }
     }
     return(true);
 }
Ejemplo n.º 3
0
        // CompActivatableEffect.HarmonyCompActivatableEffect
        /// <summary>
        ///     Adds another "layer" to the equipment aiming if they have a
        ///     weapon with a CompActivatableEffect.
        /// </summary>
        /// <param name="eq"></param>
        /// <param name="drawLoc"></param>
        /// <param name="aimAngle"></param>
        /// <param name="pawn"></param>
        /// <param name="__instance"></param>
        public static void DrawEquipmentAimingPostFix(HumanBipedDrawer __instance, Thing equipment,
                                                      ref Vector3 weaponDrawLoc,
                                                      ref float aimAngle,
                                                      bool portrait, ref bool flipped)
        {
            Pawn pawn = __instance.Pawn;

            ThingWithComps primary = pawn.equipment?.Primary;

            //Log.Message("2");
            //ThingWithComps thingWithComps = (ThingWithComps)AccessTools.Field(typeof(Pawn_EquipmentTracker), "primaryInt").GetValue(pawn_EquipmentTracker);
            //(ThingWithComps)AccessTools.Field(typeof(Pawn_EquipmentTracker), "primaryInt").GetValue(pawn_EquipmentTracker);

            //Log.Message("3");
            CompActivatableEffect.CompActivatableEffect compActivatableEffect =
                primary?.GetComp <CompActivatableEffect.CompActivatableEffect>();
            if (compActivatableEffect?.Graphic == null)
            {
                return;
            }

            if (compActivatableEffect.CurrentState !=
                CompActivatableEffect.CompActivatableEffect.State.Activated)
            {
                return;
            }

            if (equipment is ThingWithComps eqComps)
            {
                ThingComp deflector = eqComps.AllComps.FirstOrDefault(y =>
                                                                      y.GetType().ToString().Contains("Deflect"));
                if (deflector != null)
                {
                    bool isActive = (bool)AccessTools
                                    .Property(deflector.GetType(), "IsAnimatingNow").GetValue(deflector, null);
                    if (isActive)
                    {
                        float numMod = (int)AccessTools
                                       .Property(deflector.GetType(), "AnimationDeflectionTicks")
                                       .GetValue(deflector, null);
                        //float numMod2 = new float();
                        //numMod2 = numMod;
                        if (numMod > 0)
                        {
                            if (!flipped)
                            {
                                aimAngle += (numMod + 1) / 2;
                            }
                            else
                            {
                                aimAngle -= (numMod + 1) / 2;
                            }
                        }
                    }
                }
            }

            aimAngle %= 360f;

            //ThingWithComps eqComps = eq as ThingWithComps;
            //if (eqComps != null)
            //{
            //    ThingComp deflector = eqComps.AllComps.FirstOrDefault<ThingComp>((ThingComp y) => y.GetType().ToString() == "CompDeflector.CompDeflector");
            //    if (deflector != null)
            //    {
            //        float numMod = (float)((int)AccessTools.Property(deflector.GetType(), "AnimationDeflectionTicks").GetValue(deflector, null));
            //        //Log.ErrorOnce("NumMod " + numMod.ToString(), 1239);
            //numMod = (numMod + 1) / 2;
            //if (subtract) num -= numMod;
            //else num += numMod;
            //    }
            //}

            Material matSingle = compActivatableEffect.Graphic.MatSingle;
            //if (mesh == null) mesh = MeshPool.GridPlane(thingWithComps.def.graphicData.drawSize);

            Vector3   s      = new Vector3(equipment.def.graphicData.drawSize.x, 1f, equipment.def.graphicData.drawSize.y);
            Matrix4x4 matrix = default(Matrix4x4);

            matrix.SetTRS(weaponDrawLoc, Quaternion.AngleAxis(aimAngle, Vector3.up), s);
            Graphics.DrawMesh(!flipped ? MeshPool.plane10 : MeshPool.plane10Flip, matrix, matSingle, 0);

            //Graphics.DrawMesh(mesh, drawLoc, Quaternion.AngleAxis(num, Vector3.up), matSingle, 0);
        }