public void DrawEquipmentAiming(Thing eq, Vector3 drawLoc, float aimAngle) { float num = aimAngle - 90f; Mesh mesh; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else if (aimAngle > 200f && aimAngle < 340f) { mesh = MeshPool.plane10Flip; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } num %= 360f; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Material matSingle; if (graphic_StackCount != null) { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { matSingle = eq.Graphic.MatSingle; } Graphics.DrawMesh(mesh, drawLoc, Quaternion.AngleAxis(num, Vector3.up), matSingle, 0); }
static void renderStaticEquipment(Pawn pawn, /*Mesh mesh,*/ Rot4 bodyFacing, Vector3 vector, Quaternion quaternion, bool portrait) { if (!Settings.corpse_display_equipment || portrait || !pawn.Dead || pawn.Spawned || pawn.equipment == null || pawn.equipment.Primary == null) { return; } var eq = pawn.equipment.Primary; var offset = eq.def.equippedAngleOffset % 360f; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Material matSingle; if (graphic_StackCount == null) { matSingle = eq.Graphic.MatSingle; } else { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } float an = 0; Vector3 ax = Vector3.up; quaternion.ToAngleAxis(out an, out ax); Graphics.DrawMesh(MeshPool.plane10, vector + quaternion * new Vector3(0, 0, -0.22f) + new Vector3(0f, 0.0367346928f, 0f), Quaternion.AngleAxis(-45f - (an - 180f) * 0.2f + offset, Vector3.up), matSingle, 0); }
public void DrawEquipmentAiming(Thing eq, Vector3 drawLoc, float aimAngle) { Mesh mesh = null; float num = aimAngle - 90f; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else if (aimAngle > 200f && aimAngle < 340f) { mesh = MeshPool.plane10Flip; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } num %= 360f; CompEquippable compEquippable = eq.TryGetComp <CompEquippable>(); if (compEquippable != null) { EquipmentUtility.Recoil(eq.def, EquipmentUtility.GetRecoilVerb(compEquippable.AllVerbs), out var drawOffset, out var angleOffset, aimAngle); drawLoc += drawOffset; num += angleOffset; } Material material = null; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Graphics.DrawMesh(material: (graphic_StackCount == null) ? eq.Graphic.MatSingle : graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle, mesh: mesh, position: drawLoc, rotation: Quaternion.AngleAxis(num, Vector3.up), layer: 0); }
public static bool DrawEquipmentAimingModded(Thing eq, Vector3 drawLoc, float aimAngle) { Pawn pawn; float num = aimAngle - 90f; Mesh mesh; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else if (aimAngle > 200f && aimAngle < 340f) { mesh = MeshPool.plane10Flip; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } num %= 360f; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Material matSingle; if (graphic_StackCount != null) { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { matSingle = eq.Graphic.MatSingle; } if (eq.GetType() == typeof(FactionItem)) { FactionItemDef facdef = eq.def as FactionItemDef; float scalePawn = 1f; Vector3 scale = facdef.ItemMeshSize * scalePawn; Material Mat = eq.Graphic.MatAt(eq.Rotation); Matrix4x4 matrix = default(Matrix4x4); matrix.SetTRS(drawLoc, Quaternion.AngleAxis(num, Vector3.up), scale * 1.2f); Graphics.DrawMesh(mesh, matrix, matSingle, 0); // Matrix4x4 matrix = default(Matrix4x4); // matrix.SetTRS(drawLoc, Quaternion.AngleAxis(num, Vector3.up), facdef.ItemMeshSize); // Graphics.DrawMesh(mesh, matrix, matSingle, 0); // Graphics.DrawMesh() } else { Graphics.DrawMesh(mesh, drawLoc, Quaternion.AngleAxis(num, Vector3.up), matSingle, 0); } return(false); }
static bool Prefix(Pawn ___pawn, Thing eq, Vector3 drawLoc, float aimAngle) { var comp = eq.TryGetCompOversizedWeapon(); if (comp == null) { return(true); } // Ultimately I think it is better to do this than try to use a transpiler. // In any solution I will have to check for the comp (which adds the overhead) // and beyond that there is no advantage of using a transpiler vs replacing the original // like this. float num = aimAngle - 90f; Mesh mesh; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else if (aimAngle > 200f && aimAngle < 340f) { mesh = MeshPool.plane10Flip; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } num %= 360f; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Material matSingle; if (graphic_StackCount != null) { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { matSingle = eq.Graphic.MatSingle; } // CHANGED Vector3 scale = new Vector3(eq.Graphic.drawSize.x, 1f, eq.Graphic.drawSize.y); var curOffset = comp.Props != null?OffsetFromRotation(___pawn.Rotation, comp.Props) : Vector3.zero; Graphics.DrawMesh(mesh, Matrix4x4.TRS(drawLoc + curOffset, Quaternion.AngleAxis(num, Vector3.up), scale), matSingle, 0); return(false); }
public static void Postfix(PawnRenderer __instance, Thing eq, Vector3 drawLoc, float aimAngle) { if (replaced) { if (!(pawn.stances.curStance is Stance_Busy && ((Stance_Busy)pawn.stances.curStance).focusTarg.IsValid)) { aimAngle = machine.turretAngle; } if (pawn.Rotation == Rot4.South) { drawLoc -= south; } else if (pawn.Rotation == Rot4.North) { drawLoc -= north; } else if (pawn.Rotation == Rot4.East) { drawLoc -= east; } else if (pawn.Rotation == Rot4.West) { drawLoc -= west; } Mesh mesh = null; float num = aimAngle - 90f; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane20; num += eq.def.equippedAngleOffset; } else if (aimAngle > 200f && aimAngle < 340f) { mesh = StaticConstructorClass.plane20Flip; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane20; num += eq.def.equippedAngleOffset; } num %= 360f; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Graphics.DrawMesh(material: (graphic_StackCount == null) ? eq.Graphic.MatSingle : graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle, mesh: mesh, position: drawLoc, rotation: Quaternion.AngleAxis(num, Vector3.up), layer: 0); } replaced = false; }
//=================================== COMPDEFLECTOR //public static void SpecialDisplayStatsPostFix(Thing __instance, ref IEnumerable<StatDrawEntry> __result) //{ // ////Log.Message("3"); // ThingWithComps thingWithComps = __instance as ThingWithComps; // if (thingWithComps != null) // { // CompDeflector compDeflector = thingWithComps.GetComp<CompDeflector>(); // if (compDeflector != null) // { // List<StatDrawEntry> origin = new List<StatDrawEntry>(); // foreach (StatDrawEntry entry in __result) // { // //Log.Message("Entry"); // origin.Add(entry); // } // List<StatDrawEntry> entries = new List<StatDrawEntry>(); // foreach (StatDrawEntry entry in compDeflector.PostSpecialDisplayStats()) // { // //Log.Message("Hey!"); // entries.Add(entry); // } // origin.Concat(entries); // __result = origin; // } // } //} public static void DrawEquipmentAimingPostFix(PawnRenderer __instance, Thing eq, Vector3 drawLoc, float aimAngle) { Pawn pawn = (Pawn)AccessTools.Field(typeof(PawnRenderer), "pawn").GetValue(__instance); if (pawn != null) { ////Log.Message("1"); Pawn_EquipmentTracker pawn_EquipmentTracker = pawn.equipment; if (pawn_EquipmentTracker != null) { ////Log.Message("2"); foreach (ThingWithComps thingWithComps in pawn_EquipmentTracker.AllEquipmentListForReading) { ////Log.Message("3"); if (thingWithComps != null) { ////Log.Message("4"); ////Log.Message("3"); CompDeflector compDeflector = thingWithComps.GetComp <CompDeflector>(); if (compDeflector != null) { ////Log.Message("5"); if (compDeflector.IsAnimatingNow) { bool flip = false; if (!Find.TickManager.Paused && compDeflector.IsAnimatingNow) { compDeflector.AnimationDeflectionTicks -= 20; } float offset = eq.def.equippedAngleOffset; float num = aimAngle - 90f; if (aimAngle > 20f && aimAngle < 160f) { //mesh = MeshPool.plane10; num += offset; if (compDeflector.IsAnimatingNow) { num += ((compDeflector.AnimationDeflectionTicks + 1) / 2); } } else if (aimAngle > 200f && aimAngle < 340f) { //mesh = MeshPool.plane10Flip; flip = true; num -= 180f; num -= offset; if (compDeflector.IsAnimatingNow) { num -= ((compDeflector.AnimationDeflectionTicks + 1) / 2); } } else { //mesh = MeshPool.plane10; num += offset; if (compDeflector.IsAnimatingNow) { num += ((compDeflector.AnimationDeflectionTicks + 1) / 2); } } num %= 360f; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Material matSingle; if (graphic_StackCount != null) { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { matSingle = eq.Graphic.MatSingle; } //mesh = MeshPool.GridPlane(thingWithComps.def.graphicData.drawSize); //Graphics.DrawMesh(mesh, drawLoc, Quaternion.AngleAxis(num, Vector3.up), matSingle, 0); Vector3 s = new Vector3(eq.def.graphicData.drawSize.x, 1f, eq.def.graphicData.drawSize.y); Matrix4x4 matrix = default(Matrix4x4); matrix.SetTRS(drawLoc, Quaternion.AngleAxis(num, Vector3.up), s); if (!flip) { Graphics.DrawMesh(MeshPool.plane10, matrix, matSingle, 0); } else { Graphics.DrawMesh(MeshPool.plane10Flip, matrix, matSingle, 0); } ////Log.Message("DeflectDraw"); } } } } } } }
public void DrawEquipmentAiming(Thing eq, Vector3 drawLoc, float aimAngle, int curLevel, int baseLevel) { float num = aimAngle - 90f; Mesh mesh; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else if (aimAngle > 200f && aimAngle < 340f) { mesh = MeshPool.plane10Flip; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } num %= 360f; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Material matSingle; var matrix = default(Matrix4x4); if (graphic_StackCount != null) { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { if (!cachedGraphics.TryGetValue(eq, out var graphics)) { graphics = new Dictionary <int, Graphic>(); cachedGraphics[eq] = graphics; } if (!graphics.TryGetValue(curLevel, out var graphic)) { if (eq.Graphic is Graphic_RandomRotated graphicRandomRotated) { Vector2 drawSize = graphicRandomRotated.subGraphic.drawSize; drawSize.x *= 1f - ((curLevel - baseLevel) / DrawDynamicThings.pawnDrawScale); drawSize.y *= 1f - ((curLevel - baseLevel) / DrawDynamicThings.pawnDrawScale); Log.Message("Get copy 1 from " + graphicRandomRotated.subGraphic); graphic = graphicRandomRotated.subGraphic.GetCopy(drawSize); } else { Vector2 drawSize = eq.Graphic.drawSize; drawSize.x *= 1f - ((curLevel - baseLevel) / DrawDynamicThings.pawnDrawScale); drawSize.y *= 1f - ((curLevel - baseLevel) / DrawDynamicThings.pawnDrawScale); Log.Message("Get copy 2 from " + eq.Graphic); graphic = eq.Graphic.GetCopy(drawSize); } graphics[curLevel] = graphic; } matrix.SetTRS(drawLoc, Quaternion.AngleAxis(num, Vector3.up), new Vector3(graphic.drawSize.x, 1f, graphic.drawSize.y)); matSingle = graphic.MatSingle; } Graphics.DrawMesh(mesh, matrix, matSingle, 0); }
public static void DrawEquipmentAimingOverride(Mesh mesh, Thing eq, Vector3 drawLoc, float aimAngle, CompOversizedWeapon compOversized, CompEquippable equippable, Pawn pawn, bool offhand = false) { float num = aimAngle - 90f; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else { if (aimAngle > 200f && aimAngle < 340f) { mesh = offhand ? (mesh == MeshPool.plane10 ? MeshPool.plane10Flip : MeshPool.plane10) : MeshPool.plane10Flip; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } } num %= 360f; Vector3 s; if (pawn.RaceProps.Humanlike) { if (HarmonyPatches_OversizedWeapon.enabled_AlienRaces) { Vector2 v = AlienRaceUtility.AlienRacesPatch(pawn, eq); float f = Mathf.Max(v.x, v.y); s = new Vector3(eq.def.graphicData.drawSize.x * f, 1f, eq.def.graphicData.drawSize.y * f); } else { s = new Vector3(eq.def.graphicData.drawSize.x, 1f, eq.def.graphicData.drawSize.y); } } else { Vector2 v = pawn.ageTracker.CurKindLifeStage.bodyGraphicData.drawSize; s = new Vector3(eq.def.graphicData.drawSize.x + v.x / 10, 1f, eq.def.graphicData.drawSize.y + v.y / 10); } Matrix4x4 matrix = default(Matrix4x4); Quaternion rotation = Quaternion.AngleAxis(num, Vector3.up); matrix.SetTRS(drawLoc, rotation, s); Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; bool flag3 = graphic_StackCount != null; Material matSingle; if (flag3) { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { matSingle = eq.Graphic.MatSingle; } OversizedUtil.Draw(mesh, matrix, matSingle, 0, eq, pawn, drawLoc, rotation); }
/// <summary> /// Adds another "layer" to the equipment aiming if they have a /// weapon with a CompActivatableEffect. /// </summary> /// <param name="__instance"></param> /// <param name="eq"></param> /// <param name="drawLoc"></param> /// <param name="aimAngle"></param> public static bool DrawEquipmentAimingPreFix(PawnRenderer __instance, Thing eq, Vector3 drawLoc, float aimAngle) { ThingWithComps thingWithComps = eq as ThingWithComps; if (thingWithComps != null) { //If the deflector is active, it's already using this code. var deflector = thingWithComps.AllComps.FirstOrDefault<ThingComp>((ThingComp y) => y.GetType().ToString() == "CompDeflector.CompDeflector" || y.GetType().BaseType.ToString() == "CompDeflector.CompDeflector"); if (deflector != null) { bool isAnimatingNow = Traverse.Create(deflector).Property("IsAnimatingNow").GetValue<bool>(); if (isAnimatingNow) { return false; } } CompOversizedWeapon compOversizedWeapon = thingWithComps.TryGetComp<CompOversizedWeapon>(); if (compOversizedWeapon != null) { bool flip = false; float num = aimAngle - 90f; Mesh mesh; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else if (aimAngle > 200f && aimAngle < 340f) { mesh = MeshPool.plane10Flip; flip = true; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } num %= 360f; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Material matSingle; if (graphic_StackCount != null) { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { matSingle = eq.Graphic.MatSingle; } Vector3 s = new Vector3(eq.def.graphicData.drawSize.x, 1f, eq.def.graphicData.drawSize.y); Matrix4x4 matrix = default(Matrix4x4); matrix.SetTRS(drawLoc, Quaternion.AngleAxis(num, Vector3.up), s); if (!flip) Graphics.DrawMesh(MeshPool.plane10, matrix, matSingle, 0); else Graphics.DrawMesh(MeshPool.plane10Flip, matrix, matSingle, 0); return false; } } //} return true; }
static bool Prefix(ref Thing eq, ref Vector3 drawLoc, ref float aimAngle, PawnRenderer __instance) { if (!Gunplay.settings.enableWeaponAnimations) { return(true); } CompGun comp = eq.TryGetComp <CompGun>(); if (comp == null) { return(true); } Pawn pawn = pawnField.GetValue(__instance) as Pawn; if (pawn == null) { return(true); } Stance_Busy stance_Busy = pawn.stances.curStance as Stance_Busy; if (stance_Busy != null && !stance_Busy.neverAimWeapon && stance_Busy.focusTarg.IsValid) { drawLoc -= equipmentDir.RotatedBy(aimAngle); aimAngle = (aimAngle + comp.RotationOffset) % 360; drawLoc += equipmentDir.RotatedBy(aimAngle); } GunPropDef prop = GunplaySetup.GunProp(eq); if (prop == null) { return(true); } float num = aimAngle - 90f; Mesh mesh; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else if (aimAngle > 200f && aimAngle < 340f) { mesh = MeshPool.plane10Flip; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } num %= 360f; drawingScale.x = drawingScale.z = prop.drawScale; CompPrimer primer = eq.TryGetComp <CompPrimer>(); if (primer != null) { primer.Draw(mesh, drawLoc, num, drawingScale); return(false); } if (prop.drawScale == 1f) { return(true); } Material mat; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; if (graphic_StackCount != null) { mat = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { mat = eq.Graphic.MatSingle; } drawingMatrix.SetTRS(drawLoc, Quaternion.AngleAxis(num, Vector3.up), drawingScale); Graphics.DrawMesh(mesh, drawingMatrix, mat, 0); return(false); }
public static bool DrawEquipmentAimingModded(Thing eq, Vector3 drawLoc, float aimAngle) { Pawn pawn; ThingDef_AlienRace alienRaceDef = HarmonyPatches.AlienDefFor(eq, out pawn); if (alienRaceDef != null) { switch (pawn.Rotation.AsInt) { case 1: { drawLoc.x += (alienRaceDef.alienRace.generalSettings.alienPartGenerator.CustomDrawSize.x - 1); break; } case 2: { drawLoc.z -= (alienRaceDef.alienRace.generalSettings.alienPartGenerator.CustomDrawSize.x - 1); break; } case 3: { drawLoc.x -= (alienRaceDef.alienRace.generalSettings.alienPartGenerator.CustomDrawSize.x - 1); break; } } } float num = aimAngle - 90f; Mesh mesh; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else if (aimAngle > 200f && aimAngle < 340f) { mesh = MeshPool.plane10Flip; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } num %= 360f; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Material matSingle; if (graphic_StackCount != null) { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { matSingle = eq.Graphic.MatSingle; } if (eq.GetType() == typeof(FactionItem)) { FactionItemDef facdef = eq.def as FactionItemDef; float scalePawn = alienRaceDef != null ? alienRaceDef.alienRace.generalSettings.alienPartGenerator.CustomDrawSize.x : 1f; Vector3 scale = facdef.ItemMeshSize * scalePawn; Material Mat = eq.Graphic.MatAt(eq.Rotation); Matrix4x4 matrix = default(Matrix4x4); matrix.SetTRS(drawLoc, Quaternion.AngleAxis(num, Vector3.up), scale * 1.2f); Graphics.DrawMesh(mesh, matrix, matSingle, 0); // Matrix4x4 matrix = default(Matrix4x4); // matrix.SetTRS(drawLoc, Quaternion.AngleAxis(num, Vector3.up), facdef.ItemMeshSize); // Graphics.DrawMesh(mesh, matrix, matSingle, 0); // Graphics.DrawMesh() } else { Graphics.DrawMesh(mesh, drawLoc, Quaternion.AngleAxis(num, Vector3.up), matSingle, 0); } return(false); }
// draws hands on equipment and adjusts aiming angle position, if corresponding Comp is specified public new void DrawEquipmentAiming(Thing equipment, Vector3 weaponDrawLoc, float aimAngle) { CompWeaponExtensions compWeaponExtensions = pawn.equipment.Primary.TryGetComp <CompWeaponExtensions>(); float weaponAngle; Vector3 weaponPositionOffset = Vector3.zero; Mesh weaponMesh; bool flipped; bool aiming = Aiming(); if (aimAngle > 110 && aimAngle < 250) { flipped = true; // flip weapon texture weaponMesh = MeshPool.GridPlaneFlip(equipment.Graphic.drawSize); if (!aiming && compWeaponExtensions != null) { weaponPositionOffset += compWeaponExtensions.WeaponPositionOffset; // flip x position offset weaponPositionOffset.x = -weaponPositionOffset.x; } weaponAngle = aimAngle - 180f; weaponAngle -= !aiming ? equipment.def.equippedAngleOffset : (compWeaponExtensions?.AttackAngleOffset ?? 0); } else { flipped = false; weaponMesh = MeshPool.GridPlane(equipment.Graphic.drawSize); if (!aiming && compWeaponExtensions != null) { weaponPositionOffset += compWeaponExtensions.WeaponPositionOffset; } weaponAngle = aimAngle; weaponAngle += !aiming ? equipment.def.equippedAngleOffset : (compWeaponExtensions?.AttackAngleOffset ?? 0); } if (pawn.Rotation == Rot4.West || pawn.Rotation == Rot4.North) { // draw weapon beneath the pawn weaponPositionOffset += new Vector3(0, -0.5f, 0); } // weapon angle and position offsets based on current attack animation sequence DoAttackAnimationOffsets(ref weaponAngle, ref weaponPositionOffset, flipped); Graphic_StackCount graphic_StackCount = equipment.Graphic as Graphic_StackCount; Material weaponMat = graphic_StackCount != null ? graphic_StackCount.SubGraphicForStackCount(1, equipment.def).MatSingle : equipment.Graphic.MatSingle; // draw weapon Graphics.DrawMesh(weaponMesh, weaponDrawLoc + weaponPositionOffset, Quaternion.AngleAxis(weaponAngle, Vector3.up), weaponMat, 0); // draw hands on equipment, if CompWeaponExtensions defines them if (compWeaponExtensions != null) { DrawHands(weaponAngle, weaponDrawLoc + weaponPositionOffset, compWeaponExtensions, flipped); } }
public static bool Prefix(PawnRenderer __instance, Thing eq, Vector3 drawLoc, float aimAngle) { Traverse traverse = Traverse.Create(__instance); Pawn pp = traverse.Field("pawn").GetValue <Pawn>(); if (pp.kindDef.defName.EqualsIgnoreCase("ra2_rhinotank") || pp.kindDef.defName.EqualsIgnoreCase("ra2_grizzlytank") || pp.kindDef.defName.EqualsIgnoreCase("ra2_apotank")) { Stance_Busy stance_Busy = pp.stances.curStance as Stance_Busy; if (stance_Busy != null && !stance_Busy.neverAimWeapon && stance_Busy.focusTarg.IsValid) { drawLoc -= new Vector3(0f, 0f, 0.4f).RotatedBy(aimAngle); } else { if (pp.Rotation == Rot4.South) { drawLoc -= new Vector3(0f, 0f, -0.22f); } else if (pp.Rotation == Rot4.North) { drawLoc -= new Vector3(0f, 0f, -0.11f); } else if (pp.Rotation == Rot4.East) { drawLoc -= new Vector3(0.2f, 0f, -0.22f); } else if (pp.Rotation == Rot4.West) { drawLoc -= new Vector3(-0.2f, 0f, -0.22f); } } float num = aimAngle - 90f; Mesh mesh; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else if (aimAngle > 200f && aimAngle < 340f) { mesh = MeshPool.plane10Flip; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } num %= 360f; if (!pp.TargetCurrentlyAimingAt.IsValid) { //Log.Warning(pp.Rotation+"/"); switch (pp.Rotation.AsInt) { case 0: num = -90f; break; case 1: num = 0f; break; case 2: num = 90f; break; case 3: num = 0f; break; default: num = 0; break; } // num =pp.Rotation.AsAngle- 90f; } Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Material matSingle; if (graphic_StackCount != null) { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { matSingle = eq.Graphic.MatSingle; } Matrix4x4 matrix = new Matrix4x4(); Vector3 s = new Vector3(pp.kindDef.lifeStages[0].bodyGraphicData.drawSize.x, 1, pp.kindDef.lifeStages[0].bodyGraphicData.drawSize.y); //new Vector3(5,1,5); matrix.SetTRS(drawLoc + new Vector3(0, 1, 0), num.ToQuat(), s); // Graphics.DrawMesh(mesh, drawLoc, Quaternion.AngleAxis(num, Vector3.up), matSingle, 0); Graphics.DrawMesh(mesh, matrix, matSingle, 0); return(false); } return(true); }
// Token: 0x0600000A RID: 10 RVA: 0x000022B0 File Offset: 0x000004B0 public static bool DrawEquipmentAimingPreFix(PawnRenderer __instance, Thing eq, Vector3 drawLoc, float aimAngle) { ThingWithComps thingWithComps = eq as ThingWithComps; bool flag = thingWithComps != null; if (flag) { ThingComp thingComp = thingWithComps.AllComps.FirstOrDefault((ThingComp y) => y.GetType().ToString() == "CompDeflector.CompDeflector" || y.GetType().BaseType.ToString() == "CompDeflector.CompDeflector"); bool flag2 = thingComp != null; if (flag2) { bool value = Traverse.Create(thingComp).Property("IsAnimatingNow", null).GetValue <bool>(); bool flag3 = value; if (flag3) { return(false); } } CompOversizedWeapon compOversizedWeapon = thingWithComps.TryGetComp <CompOversizedWeapon>(); bool flag4 = compOversizedWeapon != null; if (flag4) { bool flag5 = false; float num = aimAngle - 90f; Pawn value2 = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>(); bool flag6 = value2 == null; if (flag6) { return(true); } bool flag7 = aimAngle > 20f && aimAngle < 160f; if (flag7) { Mesh mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else { bool flag8 = aimAngle > 200f && aimAngle < 340f; if (flag8) { Mesh mesh = MeshPool.plane10Flip; flag5 = true; num -= 180f; num -= eq.def.equippedAngleOffset; } else { num = HarmonyCompOversizedWeapon.AdjustOffsetAtPeace(eq, value2, compOversizedWeapon, num); } } bool flag9 = compOversizedWeapon.Props != null && !value2.IsFighting() && compOversizedWeapon.Props.verticalFlipNorth && value2.Rotation == Rot4.North; if (flag9) { num += 180f; } bool flag10 = !value2.IsFighting(); if (flag10) { num = HarmonyCompOversizedWeapon.AdjustNonCombatRotation(value2, num, compOversizedWeapon); } num %= 360f; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; bool flag11 = graphic_StackCount != null; Material matSingle; if (flag11) { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { matSingle = eq.Graphic.MatSingle; } Vector3 vector = new Vector3(eq.def.graphicData.drawSize.x, 1f, eq.def.graphicData.drawSize.y); Matrix4x4 matrix4x = default(Matrix4x4); Vector3 vector2 = HarmonyCompOversizedWeapon.AdjustRenderOffsetFromDir(value2, compOversizedWeapon); matrix4x.SetTRS(drawLoc + vector2, Quaternion.AngleAxis(num, Vector3.up), vector); Graphics.DrawMesh((!flag5) ? MeshPool.plane10 : MeshPool.plane10Flip, matrix4x, matSingle, 0); bool flag12 = compOversizedWeapon.Props != null && compOversizedWeapon.Props.isDualWeapon; if (flag12) { vector2 = new Vector3(-1f * vector2.x, vector2.y, vector2.z); bool flag13 = value2.Rotation == Rot4.North || value2.Rotation == Rot4.South; Mesh mesh2; if (flag13) { num += 135f; num %= 360f; mesh2 = ((!flag5) ? MeshPool.plane10Flip : MeshPool.plane10); } else { vector2 = new Vector3(vector2.x, vector2.y - 0.1f, vector2.z + 0.15f); mesh2 = ((!flag5) ? MeshPool.plane10 : MeshPool.plane10Flip); } matrix4x.SetTRS(drawLoc + vector2, Quaternion.AngleAxis(num, Vector3.up), vector); Graphics.DrawMesh(mesh2, matrix4x, matSingle, 0); } return(false); } } return(true); }
//public static void DrawEquipmentAimingPostFix(PawnRenderer __instance, Thing eq, Vector3 drawLoc, float aimAngle) //{ // Pawn pawn = (Pawn)AccessTools.Field(typeof(PawnRenderer), "pawn").GetValue(__instance); // Pawn_EquipmentTracker pawn_EquipmentTracker = pawn.equipment; // if (pawn_EquipmentTracker != null) // { // ThingWithComps thingWithComps = (ThingWithComps)AccessTools.Field(typeof(Pawn_EquipmentTracker), "primaryInt").GetValue(pawn_EquipmentTracker); // if (thingWithComps != null) // { // CompOversizedWeapon compOversizedWeapon = thingWithComps.TryGetComp<CompOversizedWeapon>(); // if (compOversizedWeapon != null) // { // bool flip = false; // float num = aimAngle - 90f; // Mesh mesh; // if (aimAngle > 20f && aimAngle < 160f) // { // mesh = MeshPool.plane10; // num += eq.def.equippedAngleOffset; // } // else if (aimAngle > 200f && aimAngle < 340f) // { // mesh = MeshPool.plane10Flip; // flip = true; // num -= 180f; // num -= eq.def.equippedAngleOffset; // } // else // { // mesh = MeshPool.plane10; // num += eq.def.equippedAngleOffset; // } // num %= 360f; // Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; // Material matSingle; // if (graphic_StackCount != null) // { // matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; // } // else // { // matSingle = eq.Graphic.MatSingle; // } // //mesh = MeshPool.GridPlane(thingWithComps.def.graphicData.drawSize); // //Graphics.DrawMesh(mesh, drawLoc, Quaternion.AngleAxis(num, Vector3.up), matSingle, 0); // //Log.Message("Oversized Draw"); // //Vector3 s = new Vector3(eq.def.graphicData.drawSize.x, 1f, eq.def.graphicData.drawSize.y); // //Matrix4x4 matrix = default(Matrix4x4); // //matrix.SetTRS(drawLoc, Quaternion.AngleAxis(num, Vector3.up), s); // //if (!flip) Graphics.DrawMesh(MeshPool.plane10, matrix, matSingle, 0); // //else Graphics.DrawMesh(MeshPool.plane10Flip, matrix, matSingle, 0); // //Log.Message("Oversized Called"); // } // } // } //} /// <summary> /// Adds another "layer" to the equipment aiming if they have a /// weapon with a CompActivatableEffect. /// </summary> /// <param name="__instance"></param> /// <param name="eq"></param> /// <param name="drawLoc"></param> /// <param name="aimAngle"></param> public static bool DrawEquipmentAimingPreFix(PawnRenderer __instance, Thing eq, Vector3 drawLoc, float aimAngle) { Pawn pawn = (Pawn)AccessTools.Field(typeof(PawnRenderer), "pawn").GetValue(__instance); Pawn_EquipmentTracker pawn_EquipmentTracker = pawn.equipment; if (pawn_EquipmentTracker != null) { ThingWithComps thingWithComps = (ThingWithComps)AccessTools.Field(typeof(Pawn_EquipmentTracker), "primaryInt").GetValue(pawn_EquipmentTracker); if (thingWithComps != null) { //If the deflector is active, it's already using this code. ThingComp deflector = thingWithComps.AllComps.FirstOrDefault <ThingComp>((ThingComp y) => y.GetType().ToString().Contains("Deflect")); if (deflector != null) { //Log.Message("Prefix"); bool isAnimatingNow = (bool)AccessTools.Property(deflector.GetType(), "IsAnimatingNow").GetValue(deflector, null); if (isAnimatingNow) { return(false); } } } CompOversizedWeapon compOversizedWeapon = thingWithComps.TryGetComp <CompOversizedWeapon>(); if (compOversizedWeapon != null) { bool flip = false; float num = aimAngle - 90f; Mesh mesh; if (aimAngle > 20f && aimAngle < 160f) { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } else if (aimAngle > 200f && aimAngle < 340f) { mesh = MeshPool.plane10Flip; flip = true; num -= 180f; num -= eq.def.equippedAngleOffset; } else { mesh = MeshPool.plane10; num += eq.def.equippedAngleOffset; } num %= 360f; Graphic_StackCount graphic_StackCount = eq.Graphic as Graphic_StackCount; Material matSingle; if (graphic_StackCount != null) { matSingle = graphic_StackCount.SubGraphicForStackCount(1, eq.def).MatSingle; } else { matSingle = eq.Graphic.MatSingle; } //mesh = MeshPool.GridPlane(thingWithComps.def.graphicData.drawSize); //Graphics.DrawMesh(mesh, drawLoc, Quaternion.AngleAxis(num, Vector3.up), matSingle, 0); //Log.Message("Oversized Draw"); Vector3 s = new Vector3(eq.def.graphicData.drawSize.x, 1f, eq.def.graphicData.drawSize.y); Matrix4x4 matrix = default(Matrix4x4); matrix.SetTRS(drawLoc, Quaternion.AngleAxis(num, Vector3.up), s); if (!flip) { Graphics.DrawMesh(MeshPool.plane10, matrix, matSingle, 0); } else { Graphics.DrawMesh(MeshPool.plane10Flip, matrix, matSingle, 0); } return(false); //Log.Message("Oversized Called"); } } return(true); }