public override bool canBeUsedOn(HandSlot primary_hand_slot, HandSlot secondary_hand_slot, bool use_two_handed) { if (use_two_handed) { return(false); } var weapon = primary_hand_slot?.MaybeWeapon; var weapon2 = secondary_hand_slot?.MaybeWeapon; if (weapon == null || weapon.EnchantmentsCollection == null) { return(false); } if (weapon.Blueprint.Double && weapon.EnchantmentsCollection.HasFact(required_enchant)) { return(true); } if (weapon2 == null || weapon2.EnchantmentsCollection == null) { return(false); } return(weapon.EnchantmentsCollection.HasFact(required_enchant) && weapon2.EnchantmentsCollection.HasFact(required_enchant)); }
public override bool canBeUsedOn(ItemEntityWeapon weapon) { if (!weapon.Blueprint.IsTwoHanded) { return(false); } HandSlot holding_slot = weapon?.HoldingSlot as HandSlot; if (holding_slot == null) { return(false); } if (!holding_slot.PairSlot.HasItem) { return(false); } if (holding_slot.PairSlot.MaybeShield == null) { return(false); } var shield_proficiency = holding_slot.PairSlot.MaybeShield.ArmorComponent.Blueprint.ProficiencyGroup; if (shield_proficiency == Kingmaker.Blueprints.Items.Armors.ArmorProficiencyGroup.Buckler) { return(false); } return(weapon.Blueprint.FighterGroup == WeaponFighterGroup.Spears || weapon.Blueprint.FighterGroup == WeaponFighterGroup.Polearms); }
/// <summary> /// /// </summary> /// <param name="performer">The gameobject of the player performing the aimed interaction</param> /// <param name="handObject">Object in the player's active hand. Null if player's hand is empty.</param> /// <param name="handSlot">slot of the active hand</param> /// <param name="buttonState">state of the mouse button, indicating whether it is being initiated /// or ending.</param> /// <param name="targetVector">vector pointing from shooter to the spot they are targeting - should NOT be normalized. Set to /// Vector2.zero if aiming at self.</param> private AimApply(GameObject performer, GameObject handObject, HandSlot handSlot, MouseButtonState buttonState, Vector2 targetVector) : base(performer, handObject) { this.targetVector = targetVector; this.handSlot = handSlot; this.mouseButtonState = buttonState; }
internal static bool has2hWeapon(HandSlot hand_slot) { if (hand_slot == null) { return(false); } if (!hand_slot.HasItem) { return(false); } var weapon = hand_slot.MaybeWeapon; if (weapon == null) { return(false); } if (weapon.Blueprint.IsTwoHanded) { return(true); } return(weapon.Blueprint.Double); }
public bool canBeUsedAs2h(ItemEntityWeapon weapon) { bool can_use_at_all = false; foreach (var b in buffs) { bool can_use = false; bool can_2h = false; b.CallComponents <CanUse2hWeaponAs1hBase>(c => { can_2h = c.canBeUsedAs2h(weapon); can_use = c.canBeUsedOn(weapon); }); if (can_use && can_2h) { return(true); } can_use_at_all = can_use_at_all || can_use; } if (!can_use_at_all) { HandSlot pair_slot = (weapon?.HoldingSlot as HandSlot)?.PairSlot; if (pair_slot != null) { return(!pair_slot.HasItem); } return(false); } else { return(false); } }
void Start() { player = GameObject.FindWithTag("Player"); handslot = FindObjectOfType <HandSlot>(); itemDetail = GameObject.Find("itemDetail"); inputAmountUI = FindObjectOfType <InputAmountUI>(); }
private GameObject item; // item in hand slot private void Awake() { if (instance != null) { Debug.LogWarning("More than one instance of handslot"); return; } instance = this; // instantiates itself }
void Start() { inventoryUI = InventoryUI.instance; handSlot = HandSlot.instance; status_script = this.GetComponent <player_status>(); inventory_script = this.GetComponent <inventory>(); fartherOrCloserFactor = 1.0f; itemPlaced = 0; itemExist = 0; }
public override bool canBeUsedOn(HandSlot primary_hand_slot, HandSlot secondary_hand_slot, bool use_two_handed) { if (use_two_handed) { return(false); } var shield = secondary_hand_slot?.MaybeShield; return(shield != null); }
public override bool canBeUsedAs2h(ItemEntityWeapon weapon) { HandSlot holding_slot = weapon?.HoldingSlot as HandSlot; if (holding_slot == null) { return(false); } return(Helpers.hasFreeHand(holding_slot.PairSlot)); }
public override IEnumerator Process() { yield return(WaitFor(ProcessorObject)); var processorObj = NetworkObject; var performerObj = SentByPlayer.GameObject; //look up item in active hand slot var clientPNA = SentByPlayer.Script.playerNetworkActions; var handSlot = HandSlot.ForName(clientPNA.activeHand); var activatedObject = clientPNA.Inventory[handSlot.equipSlot].Item; ProcessActivate(activatedObject, processorObj, performerObj, handSlot); }
static void ShowHandslotInfo(HandSlot handSlot) { GUILayout.BeginHorizontal(); var pItem = handSlot != null && handSlot.HasItem ? handSlot.Item : null; GUILayout.Label(string.Format("Slot {0}, {1}, Active {2}", pItem?.Name, pItem?.GetType(), handSlot?.Active), GUILayout.Width(500)); if (GUILayout.Button("Remove", GUILayout.ExpandWidth(false))) { handSlot.RemoveItem(); } GUILayout.EndHorizontal(); }
public override IEnumerator Process() { //look up item in active hand slot var clientPNA = SentByPlayer.Script.playerNetworkActions; var usedSlot = HandSlot.ForName(clientPNA.activeHand); var usedObject = clientPNA.Inventory[usedSlot.equipSlot].Item; yield return(WaitFor(ProcessorObject)); var processorObj = NetworkObject; var performerObj = SentByPlayer.GameObject; ProcessAimApply(usedObject, TargetVector, processorObj, performerObj, usedSlot, MouseButtonState); }
internal static bool hasFreeHandOr1hWeapon(HandSlot hand_slot) { if (hasFreeHand(hand_slot)) { return(true); } var weapon = hand_slot.Weapon; if (weapon == null) { return(true); } return(!weapon.Blueprint.IsTwoHanded && (!weapon.Blueprint.Double)); }
internal static bool hasFreeHand(HandSlot hand_slot) { if (!hand_slot.HasItem) { return(true); } var shield = hand_slot.MaybeShield; if (shield == null) { return(false); } return(shield.ArmorComponent.Blueprint.ProficiencyGroup == Kingmaker.Blueprints.Items.Armors.ArmorProficiencyGroup.Buckler && hand_slot.Owner.HasFact(NewFeats.unhindering_shield)); }
public override IEnumerator Process() { //look up item in active hand slot var clientPNA = SentByPlayer.Script.playerNetworkActions; var usedSlot = HandSlot.ForName(clientPNA.activeHand); var usedObject = clientPNA.Inventory[usedSlot.SlotName].Item; yield return(WaitFor(TargetObject, ProcessorObject)); var targetObj = NetworkObjects[0]; var processorObj = NetworkObjects[1]; var performerObj = SentByPlayer.GameObject; ProcessHandApply(usedObject, targetObj, processorObj, performerObj, usedSlot); }
private void ProcessCombine(HandSlot usedSlot, GameObject handObject, InventorySlot targetSlot, GameObject processorObj, GameObject performerObj) { //try to look up the components on the processor that can handle this interaction var processorComponents = InteractionMessageUtils.TryGetProcessors <InventoryApply>(processorObj); //invoke each component that can handle this interaction var combine = InventoryApply.ByClient(performerObj, targetSlot, handObject, usedSlot); foreach (var processorComponent in processorComponents) { if (processorComponent.ServerProcessInteraction(combine)) { //something happened, don't check further components return; } } }
public override bool canBeUsedOn(HandSlot primary_hand_slot, HandSlot secondary_hand_slot, bool use_two_handed) { var weapon = primary_hand_slot?.MaybeWeapon; if (weapon == null || weapon.EnchantmentsCollection == null) { return(false); } if (secondary_hand_slot != null && !Helpers.hasFreeHand(secondary_hand_slot)) { return(false); } return(weapon.EnchantmentsCollection.HasFact(required_enchant)); }
private void ProcessAimApply(GameObject handObject, Vector2 targetVector, GameObject processorObj, GameObject performerObj, HandSlot usedSlot, MouseButtonState buttonState) { //try to look up the components on the processor that can handle this interaction var processorComponents = InteractionMessageUtils.TryGetProcessors <AimApply>(processorObj); //invoke each component that can handle this interaction var aimApply = AimApply.ByClient(performerObj, targetVector, handObject, usedSlot, buttonState); foreach (var processorComponent in processorComponents) { if (processorComponent.ServerProcessInteraction(aimApply)) { //something happened, don't check further components return; } } }
void PlaySlot(int slotIndex) { HandSlot handSlotAtIndex = this.handSlots[slotIndex]; if (!handSlotAtIndex.HasObject()) { return; } ClothesLine._instance.HangUpLaundryItem(handSlotAtIndex.GetObject()); if (!this.isSuspended && GameManager._instance.AreNoCardsLeft()) { // Game hasn't ended, but no cards left in play // There are cards on the Clothesline GameManager._instance.LevelSuccess(); } }
void Start() { // Instantiate references Cursor.lockState = CursorLockMode.Locked; Cursor.visible = false; inv = inventory.instance; // When inventory changes, add an update request to UI inv.onItemChangedCallback += UpdateUI; handSlot = HandSlot.instance; // Set slots to children of the parent class slots = itemsParent.GetComponentsInChildren <InventorySlot>(); player_situation = player.GetComponent <player_status>(); UIActive = false; }
static bool Prefix(UnitViewHandsEquipment __instance, HandSlot slot, ItemEntity previousItem) { var tr = Harmony12.Traverse.Create(__instance); if (!tr.Property("Active").GetValue <bool>() || tr.Method("GetSlotData", slot).GetValue <UnitViewHandSlotData>() == null) { return(true); } if (Helpers.isSummoned(slot.MaybeWeapon) || Helpers.isSummoned(previousItem) && __instance.InCombat && (__instance.Owner.Descriptor.State.CanAct || __instance.IsDollRoom) && slot.Active) { tr.Method("ChangeEquipmentWithoutAnimation").GetValue(); return(false); } return(true); }
public bool canBeUsedOn(HandSlot primary_hand, HandSlot secondary_hand, bool use_two_handed) { if (buffs.Empty()) { return(false); } foreach (var b in buffs) { bool result = false; b.CallComponents <CanUseSpellCombatBase>(c => result = c.canBeUsedOn(primary_hand, secondary_hand, use_two_handed)); if (result) { return(true); } } return(false); }
static bool Prefix(UnitViewHandsEquipment __instance, HandSlot slot, ItemEntity previousItem) { MethodInfo getHandSlotMethod = __instance.GetType().GetMethod("GetSlotData", BindingFlags.NonPublic | BindingFlags.Instance); UnitViewHandSlotData slotDataCheck = (UnitViewHandSlotData)getHandSlotMethod.Invoke(__instance, new object[] { slot }); if (!(bool)unitViewHandsEquipment_get_Active(__instance) || slotDataCheck == null) { return(true); } if (__instance.Owner.IsFreeEquipmentChange() && __instance.InCombat && (__instance.Owner.Descriptor.State.CanAct || __instance.IsDollRoom) && slot.Active) { MethodInfo changeEquipmentWithoutAnimation = __instance.GetType().GetMethod("ChangeEquipmentWithoutAnimation", BindingFlags.NonPublic | BindingFlags.Instance); changeEquipmentWithoutAnimation.Invoke(__instance, new object[0]); return(false); } return(true); }
internal static bool hasFreeHandOrBuckler(HandSlot hand_slot) { if (hand_slot == null) { return(true); } if (!hand_slot.HasItem) { return(true); } var shield = hand_slot.MaybeShield; if (shield == null) { return(false); } return(shield.ArmorComponent.Blueprint.ProficiencyGroup == Kingmaker.Blueprints.Items.Armors.ArmorProficiencyGroup.Buckler); }
public override bool canBeUsedOn(ItemEntityWeapon weapon) { HandSlot holding_slot = weapon?.HoldingSlot as HandSlot; if (holding_slot == null) { return(false); } if (!holding_slot.PairSlot.HasItem) { return(false); } if (holding_slot.PairSlot.MaybeShield == null) { return(false); } return(holding_slot.PairSlot.MaybeShield.ArmorComponent.Blueprint.ProficiencyGroup == Kingmaker.Blueprints.Items.Armors.ArmorProficiencyGroup.Buckler); }
/*static IEnumerable<Harmony12.CodeInstruction> Transpiler(IEnumerable<Harmony12.CodeInstruction> instructions) * { * var codes = instructions.ToList(); * var check_is_unarmed = codes.FindIndex(x => x.opcode == System.Reflection.Emit.OpCodes.Callvirt && x.operand.ToString().Contains("IsUnarmed")); //checking is unarmed on weapon on primary hand * * codes[check_is_unarmed] = new Harmony12.CodeInstruction(System.Reflection.Emit.OpCodes.Ldarg_0); * codes.Insert(check_is_unarmed + 1, new Harmony12.CodeInstruction(System.Reflection.Emit.OpCodes.Call, new Func<BlueprintItemWeapon, RuleCalculateAttacksCount, bool>(considerUnarmedAndIgnore).Method)); * * check_is_unarmed = codes.IndexOf(codes.FindAll(x => x.opcode == System.Reflection.Emit.OpCodes.Callvirt && x.operand.ToString().Contains("IsUnarmed"))[2]); * codes[check_is_unarmed] = new Harmony12.CodeInstruction(System.Reflection.Emit.OpCodes.Ldarg_0); * codes.Insert(check_is_unarmed + 1, new Harmony12.CodeInstruction(System.Reflection.Emit.OpCodes.Call, new Func<BlueprintItemWeapon, RuleCalculateAttacksCount, bool>(considerUnarmedAndIgnoreOffHand).Method)); * return codes.AsEnumerable(); * }*/ static bool Prefix(RuleCalculateAttacksCount __instance, RulebookEventContext context) { int bab = (int)__instance.Initiator.Stats.BaseAttackBonus; int num_penalized_attacks = Math.Min(Math.Max(0, bab / 5 - (bab % 5 == 0 ? 1 : 0)), 3); HandSlot primary_hand = __instance.Initiator.Body.PrimaryHand; HandSlot secondary_hand = __instance.Initiator.Body.SecondaryHand; BlueprintItemWeapon blueprint1 = primary_hand.MaybeWeapon?.Blueprint; BlueprintItemWeapon blueprint2 = secondary_hand.MaybeShield != null ? ((bool)__instance.Initiator.Descriptor.State.Features.ShieldBash ? secondary_hand.MaybeShield.WeaponComponent?.Blueprint : null) : secondary_hand.MaybeWeapon?.Blueprint; int num = primary_hand.MaybeWeapon == null ? 0 : (primary_hand.MaybeWeapon.HoldInTwoHands ? 1 : 0); if ((secondary_hand.MaybeWeapon?.HoldInTwoHands).GetValueOrDefault() == false && (blueprint1 != null) && (!considerUnarmedAndIgnore(blueprint1, __instance) || blueprint2 == null || blueprint2.IsUnarmed) ) { ++__instance.PrimaryHand.MainAttacks; if (!blueprint1.IsNatural || (bool)__instance.Initiator.Descriptor.State.Features.IterativeNaturalAttacks || __instance.ForceIterativeNaturealAttacks || blueprint1.IsUnarmed) { __instance.PrimaryHand.PenalizedAttacks += Math.Max(0, num_penalized_attacks); } } if ((secondary_hand.MaybeWeapon?.HoldInTwoHands).GetValueOrDefault() == true || (blueprint2 == null) || considerUnarmedAndIgnoreOffHand(blueprint2, __instance) && (blueprint1 != null) || (primary_hand.MaybeWeapon?.HoldInTwoHands).GetValueOrDefault() == true ) { return(false); } ++__instance.SecondaryHand.MainAttacks; if (blueprint1 == null || !considerUnarmedAndIgnore(blueprint1, __instance) && (blueprint1 == null || !blueprint1.IsNatural || !(bool)__instance.Initiator.Descriptor.State.Features.IterativeNaturalAttacks && !__instance.ForceIterativeNaturealAttacks) || (blueprint2.IsUnarmed) ) { return(false); } __instance.SecondaryHand.PenalizedAttacks += Math.Max(0, num_penalized_attacks); return(false); }
static bool Prefix(HandSlot __instance) { var unit_part = __instance.Owner?.Get <UnitPartCanHold2hWeaponIn1h>(); if (unit_part == null) { return(true); } if (!__instance.IsPrimaryHand) { HandSlot primaryHand = __instance.HandsEquipmentSet.PrimaryHand; ItemEntityWeapon maybeItem = primaryHand.MaybeItem as ItemEntityWeapon; if (maybeItem != null && ((maybeItem.Blueprint.IsTwoHanded && !unit_part.canBeUsedOn(maybeItem)) || maybeItem.Blueprint.Double)) { primaryHand.RemoveItem(); } } ItemEntityWeapon maybeItem1 = __instance.MaybeItem as ItemEntityWeapon; if (maybeItem1 != null && ((maybeItem1.Blueprint.IsTwoHanded && !unit_part.canBeUsedOn(maybeItem1)) || maybeItem1.Blueprint.Double)) { if (__instance.IsPrimaryHand) { __instance.PairSlot.RemoveItem(); } else { __instance.RemoveItem(); __instance.PairSlot.InsertItem((ItemEntity)maybeItem1); } } __instance.IsDirty = true; return(false); }
public override IEnumerator Process() { yield return(WaitFor(ProcessorObject)); var processorObj = NetworkObject; var performerObj = SentByPlayer.GameObject; //look up item in active hand slot var clientPNA = SentByPlayer.Script.playerNetworkActions; var usedSlot = HandSlot.ForName(clientPNA.activeHand); var usedObject = clientPNA.Inventory[usedSlot.SlotName].Item; var targetSlot = InventoryManager.GetSlotFromUUID(TargetSlotUUID, true); //can only combine in their own slots if (targetSlot.Owner.gameObject != performerObj) { Logger.LogWarningFormat("Player {0} attempted to InventoryApply to a slot that isn't theirs! Possible" + " hacking attempt. targetSlot {1} (owner {2})", Category.Security, SentByPlayer.Name, targetSlot.SlotName, targetSlot.Owner.playerName); } else { ProcessCombine(usedSlot, usedObject, targetSlot, processorObj, performerObj); } }
static bool DontCostAction(HandSlot slot, ItemEntity previousItem) { return(Mod.Enabled && FixActionTypeOfKineticBlade && ((slot.MaybeItem.IsKineticBlast() && previousItem == null) || (slot.MaybeItem == null && previousItem.IsKineticBlast()))); }