From 1bd20564fd0d59a5468b4ebb48c2abc180996244 Mon Sep 17 00:00:00 2001 From: Oskar Wiksten Date: Sat, 23 Jun 2012 21:15:44 +0200 Subject: [PATCH 1/7] Added weapon proficiency & fighting style skills. --- AndorsTrail/res/values/strings.xml | 51 ++++ .../activity/SkillInfoActivity.java | 32 +++ .../controller/SkillController.java | 219 +++++++++++++++++- .../model/ability/SkillCollection.java | 49 +++- .../AndorsTrail/view/SkillListAdapter.java | 16 ++ 5 files changed, 365 insertions(+), 2 deletions(-) diff --git a/AndorsTrail/res/values/strings.xml b/AndorsTrail/res/values/strings.xml index 40920c11c..ea29806fb 100644 --- a/AndorsTrail/res/values/strings.xml +++ b/AndorsTrail/res/values/strings.xml @@ -566,4 +566,55 @@ [Quest completed: \"%1$s\"] [Quest updated: \"%1$s\"] + Dagger proficiency + One-handed sword proficiency + Two-handed sword proficiency + Axe proficiency + Bludgeoning weapon proficiency + Unarmed fighting + Shield proficiency + Armour proficiency: unarmored + Light armor proficiency + Heavy armor proficiency + Fighting style: Dual wield + Fighting style: Two handed weapon + Fighting style: Weapon and shield + Specialization: Dual wield + Specialization: Two handed weapon + Specialization: Weapon and shield + + Dagger proficiency + One-handed sword proficiency + Two-handed sword proficiency + Axe proficiency + Bludgeoning weapon proficiency + Unarmed fighting + Shield proficiency + Armour proficiency: unarmored + Light armor proficiency + Heavy armor proficiency + Fighting style: Dual wield + Fighting style: Two handed weapon + Fighting style: Weapon and shield + Specialization: Dual wield + Specialization: Two handed weapon + Specialization: Weapon and shield + + Dagger proficiency + One-handed sword proficiency + Two-handed sword proficiency + Axe proficiency + Bludgeoning weapon proficiency + Unarmed fighting + Shield proficiency + Armour proficiency: unarmored + Light armor proficiency + Heavy armor proficiency + Fighting style: Dual wield + Fighting style: Two handed weapon + Fighting style: Weapon and shield + Specialization: Dual wield + Specialization: Two handed weapon + Specialization: Weapon and shield + diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/activity/SkillInfoActivity.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/activity/SkillInfoActivity.java index 1811967de..d39d48d15 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/activity/SkillInfoActivity.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/activity/SkillInfoActivity.java @@ -133,6 +133,22 @@ public final class SkillInfoActivity extends Activity { case SkillCollection.SKILL_REJUVENATION: return R.string.skill_title_rejuvenation; case SkillCollection.SKILL_TAUNT: return R.string.skill_title_taunt; case SkillCollection.SKILL_CONCUSSION: return R.string.skill_title_concussion; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_DAGGER: return R.string.skill_title_weapon_prof_dagger; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_1HSWORD: return R.string.skill_title_weapon_prof_1hsword; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_2HSWORD: return R.string.skill_title_weapon_prof_2hsword; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_AXE: return R.string.skill_title_weapon_prof_axe; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_BLUNT: return R.string.skill_title_weapon_prof_blunt; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_UNARMED: return R.string.skill_title_weapon_prof_unarmed; + case SkillCollection.SKILL_ARMOR_PROFICIENCY_SHIELD: return R.string.skill_title_armor_prof_shield; + case SkillCollection.SKILL_ARMOR_PROFICIENCY_UNARMORED: return R.string.skill_title_armor_prof_unarmored; + case SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT: return R.string.skill_title_armor_prof_light; + case SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY: return R.string.skill_title_armor_prof_heavy; + case SkillCollection.SKILL_FIGHTSTYLE_DUAL_WIELD: return R.string.skill_title_fightstyle_dualwield; + case SkillCollection.SKILL_FIGHTSTYLE_2HAND: return R.string.skill_title_fightstyle_2hand; + case SkillCollection.SKILL_FIGHTSTYLE_WEAPON_SHIELD: return R.string.skill_title_fightstyle_weapon_shield; + case SkillCollection.SKILL_SPECIALIZATION_DUAL_WIELD: return R.string.skill_title_specialization_dualwield; + case SkillCollection.SKILL_SPECIALIZATION_2HAND: return R.string.skill_title_specialization_2hand; + case SkillCollection.SKILL_SPECIALIZATION_WEAPON_SHIELD: return R.string.skill_title_specialization_weapon_shield; default: return -1; } @@ -166,6 +182,22 @@ public final class SkillInfoActivity extends Activity { case SkillCollection.SKILL_REJUVENATION: return res.getString(R.string.skill_longdescription_rejuvenation, SkillCollection.PER_SKILLPOINT_INCREASE_REJUVENATION_CHANCE); case SkillCollection.SKILL_TAUNT: return res.getString(R.string.skill_longdescription_taunt, SkillCollection.PER_SKILLPOINT_INCREASE_TAUNT_CHANCE, SkillCollection.TAUNT_AP_LOSS); case SkillCollection.SKILL_CONCUSSION: return res.getString(R.string.skill_longdescription_concussion, SkillCollection.CONCUSSION_THRESHOLD, SkillCollection.PER_SKILLPOINT_INCREASE_CONCUSSION_CHANCE); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_DAGGER: return res.getString(R.string.skill_longdescription_weapon_prof_dagger); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_1HSWORD: return res.getString(R.string.skill_longdescription_weapon_prof_1hsword); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_2HSWORD: return res.getString(R.string.skill_longdescription_weapon_prof_2hsword); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_AXE: return res.getString(R.string.skill_longdescription_weapon_prof_axe); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_BLUNT: return res.getString(R.string.skill_longdescription_weapon_prof_blunt); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_UNARMED: return res.getString(R.string.skill_longdescription_weapon_prof_unarmed); + case SkillCollection.SKILL_ARMOR_PROFICIENCY_SHIELD: return res.getString(R.string.skill_longdescription_armor_prof_shield); + case SkillCollection.SKILL_ARMOR_PROFICIENCY_UNARMORED: return res.getString(R.string.skill_longdescription_armor_prof_unarmored); + case SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT: return res.getString(R.string.skill_longdescription_armor_prof_light); + case SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY: return res.getString(R.string.skill_longdescription_armor_prof_heavy); + case SkillCollection.SKILL_FIGHTSTYLE_DUAL_WIELD: return res.getString(R.string.skill_longdescription_fightstyle_dualwield); + case SkillCollection.SKILL_FIGHTSTYLE_2HAND: return res.getString(R.string.skill_longdescription_fightstyle_2hand); + case SkillCollection.SKILL_FIGHTSTYLE_WEAPON_SHIELD: return res.getString(R.string.skill_longdescription_fightstyle_weapon_shield); + case SkillCollection.SKILL_SPECIALIZATION_DUAL_WIELD: return res.getString(R.string.skill_longdescription_specialization_dualwield); + case SkillCollection.SKILL_SPECIALIZATION_2HAND: return res.getString(R.string.skill_longdescription_specialization_2hand); + case SkillCollection.SKILL_SPECIALIZATION_WEAPON_SHIELD: return res.getString(R.string.skill_longdescription_specialization_weapon_shield); default: return ""; } diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java index 5b8052752..184b2dbd1 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java @@ -1,6 +1,8 @@ package com.gpl.rpg.AndorsTrail.controller; import com.gpl.rpg.AndorsTrail.context.ControllerContext; +import android.util.FloatMath; + import com.gpl.rpg.AndorsTrail.context.WorldContext; import com.gpl.rpg.AndorsTrail.model.AttackResult; import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionEffect; @@ -10,6 +12,8 @@ import com.gpl.rpg.AndorsTrail.model.ability.SkillInfo; import com.gpl.rpg.AndorsTrail.model.actor.Actor; import com.gpl.rpg.AndorsTrail.model.actor.Monster; import com.gpl.rpg.AndorsTrail.model.actor.Player; +import com.gpl.rpg.AndorsTrail.model.item.Inventory; +import com.gpl.rpg.AndorsTrail.model.item.ItemCategory; import com.gpl.rpg.AndorsTrail.model.item.ItemType; import com.gpl.rpg.AndorsTrail.model.item.ItemTypeCollection; import com.gpl.rpg.AndorsTrail.model.item.DropList.DropItem; @@ -187,12 +191,225 @@ public final class SkillController { } public static void applySkillEffectsFromItemProficiencies(Player player) { + player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_DAGGER); + player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_1HSWORD); + player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_2HSWORD); + player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_AXE); + player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_BLUNT); + player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_UNARMED); + + final int unarmedLevel = player.getSkillLevel(SkillCollection.SKILL_WEAPON_PROFICIENCY_UNARMED); + if (unarmedLevel > 0) { + if (isUnarmed(player)) { + player.combatTraits.attackChance += 20 * unarmedLevel; + player.combatTraits.damagePotential.addToMax(2 * unarmedLevel); + player.combatTraits.damagePotential.add(2 * unarmedLevel, false); + player.combatTraits.blockChance += 5 * unarmedLevel; + } + } + + player.combatTraits.damageResistance += getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_ARMOR_PROFICIENCY_SHIELD); + + final int unarmoredLevel = player.getSkillLevel(SkillCollection.SKILL_ARMOR_PROFICIENCY_UNARMORED); + if (unarmoredLevel > 0) { + if (isUnarmored(player)) { + player.combatTraits.blockChance += 10 * unarmoredLevel; + } + } + + int skillLevelLightArmor = player.getSkillLevel(SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT); + int skillLevelHeavyArmor = player.getSkillLevel(SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY); + for (int slot = 0; slot < Inventory.NUM_WORN_SLOTS; ++slot) { + if (!Inventory.isArmorSlot(slot)) continue; + + ItemType itemType = player.inventory.wear[slot]; + if (itemType == null) continue; + if (itemType.effects_equip == null) continue; + if (skillLevelLightArmor > 0) { + if (isSkillForItemCategory(SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT, itemType.category)) { + player.combatTraits.blockChance += FloatMath.floor(itemType.effects_equip.combatProficiency.blockChance * 30 * skillLevelLightArmor / 100.0f); + } + } + if (skillLevelHeavyArmor > 0) { + if (isSkillForItemCategory(SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY, itemType.category)) { + player.combatTraits.blockChance += FloatMath.floor(itemType.effects_equip.combatProficiency.blockChance * 10 * skillLevelHeavyArmor / 100.0f); + player.actorTraits.moveCost -= FloatMath.floor(itemType.effects_equip.moveCostPenalty * 25 * skillLevelHeavyArmor / 100.0f); + player.combatTraits.attackCost -= FloatMath.floor(itemType.effects_equip.combatProficiency.attackCost * 25 * skillLevelHeavyArmor / 100.0f); + } + } + } + } + + private static boolean isUnarmed(Player player) { + if (hasItemWithWeight(player, Inventory.WEARSLOT_WEAPON)) return false; + if (hasItemWithWeight(player, Inventory.WEARSLOT_SHIELD)) return false; + return true; + } + private static boolean isUnarmored(Player player) { + for (int slot = 0; slot < Inventory.NUM_WORN_SLOTS; ++slot) { + if (!Inventory.isArmorSlot(slot)) continue; + if (hasItemWithWeight(player, slot)) return false; + } + return true; + } + private static boolean hasItemWithWeight(Player player, int slot) { + ItemType itemType = player.inventory.wear[slot]; + if (itemType == null) return false; + if (itemType.category.size == ItemCategory.SIZE_NONE) return false; + return true; + } + + private static int getItemProficiencySkillEffectFactor(final Player player, final int skill) { + int skillLevel = player.getSkillLevel(skill); + if (skillLevel <= 0) return 0; + + int numItems = 0; + for (int slot = 0; slot < Inventory.NUM_WORN_SLOTS; ++slot) { + ItemType itemType = player.inventory.wear[slot]; + if (itemType == null) continue; + if (isSkillForItemCategory(skill, itemType.category)) ++numItems; + } + return numItems * skillLevel; + } + + private static boolean isSkillForItemCategory(final int skill, ItemCategory category) { + final String itemCategoryID = category.id; + switch (skill) { + case SkillCollection.SKILL_WEAPON_PROFICIENCY_DAGGER: + if (itemCategoryID.equals("dagger")) return true; + if (itemCategoryID.equals("ssword")) return true; + return false; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_1HSWORD: + if (itemCategoryID.equals("lsword")) return true; + if (itemCategoryID.equals("bsword")) return true; + return false; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_2HSWORD: + if (itemCategoryID.equals("2hsword")) return true; + return false; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_AXE: + if (itemCategoryID.equals("axe")) return true; + if (itemCategoryID.equals("axe2h")) return true; + return false; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_BLUNT: + if (itemCategoryID.equals("club")) return true; + if (itemCategoryID.equals("staff")) return true; + if (itemCategoryID.equals("mace")) return true; + if (itemCategoryID.equals("scepter")) return true; + if (itemCategoryID.equals("hammer")) return true; + if (itemCategoryID.equals("hammer2h")) return true; + return false; + case SkillCollection.SKILL_ARMOR_PROFICIENCY_SHIELD: + if (category.isShield()) return true; + return false; + case SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT: + if (!category.isArmor()) return false; + if (category.size == ItemCategory.SIZE_LIGHT) return true; + if (category.size == ItemCategory.SIZE_STD) return true; + return false; + case SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY: + if (!category.isArmor()) return false; + if (category.size == ItemCategory.SIZE_LARGE) return true; + return false; + } + return false; } public static void applySkillEffectsFromFightingStyles(Player player) { + ItemType mainHandItem = player.inventory.wear[Inventory.WEARSLOT_WEAPON]; + ItemType offHandItem = player.inventory.wear[Inventory.WEARSLOT_SHIELD]; + + if (isWielding2HandItem(mainHandItem, offHandItem)) { + int skillLevelFightStyle = player.getSkillLevel(SkillCollection.SKILL_FIGHTSTYLE_2HAND); + int skillLevelSpecialization = player.getSkillLevel(SkillCollection.SKILL_SPECIALIZATION_2HAND); + addPercentDamage(player, mainHandItem, skillLevelFightStyle * 50); + addPercentDamage(player, mainHandItem, skillLevelSpecialization * 50); + addPercentAttackChance(player, mainHandItem, skillLevelSpecialization * 20); + } + + if (isWieldingWeaponAndShield(mainHandItem, offHandItem)) { + int skillLevelFightStyle = player.getSkillLevel(SkillCollection.SKILL_FIGHTSTYLE_WEAPON_SHIELD); + int skillLevelSpecialization = player.getSkillLevel(SkillCollection.SKILL_SPECIALIZATION_WEAPON_SHIELD); + addPercentAttackChance(player, mainHandItem, skillLevelFightStyle * 50); + addPercentBlockChance(player, offHandItem, skillLevelFightStyle * 50); + addPercentAttackChance(player, mainHandItem, skillLevelSpecialization * 20); + addPercentBlockChance(player, mainHandItem, skillLevelSpecialization * 50); + } + + if (isDualWielding(mainHandItem, offHandItem)) { + int skillLevelFightStyle = player.getSkillLevel(SkillCollection.SKILL_FIGHTSTYLE_DUAL_WIELD); + if (offHandItem.effects_equip != null) { + int attackCostMainHand = mainHandItem.effects_equip.combatProficiency.attackCost; + int attackCostOffHand = offHandItem.effects_equip.combatProficiency.attackCost; + int percent; + if (skillLevelFightStyle == 2) { + percent = 100; + player.combatTraits.attackCost = Math.max(attackCostMainHand, attackCostOffHand); + } else if (skillLevelFightStyle == 1) { + percent = 50; + player.combatTraits.attackCost = attackCostMainHand + getPercentage(attackCostOffHand, 50); + } else { + percent = 25; + player.combatTraits.attackCost = attackCostMainHand + attackCostOffHand; + } + addPercentAttackChance(player, offHandItem, percent); + addPercentBlockChance(player, offHandItem, percent); + addPercentDamage(player, offHandItem, percent); + addPercentCriticalSkill(player, offHandItem, percent); + } + + int skillLevelSpecialization = player.getSkillLevel(SkillCollection.SKILL_SPECIALIZATION_DUAL_WIELD); + addPercentAttackChance(player, mainHandItem, skillLevelSpecialization * 50); + addPercentBlockChance(player, mainHandItem, skillLevelSpecialization * 50); + addPercentAttackChance(player, offHandItem, skillLevelSpecialization * 50); + addPercentBlockChance(player, offHandItem, skillLevelSpecialization * 50); + } + } + + private static void addPercentAttackChance(Player player, ItemType itemType, int percentToAdd) { + if (itemType.effects_equip == null) return; + if (percentToAdd == 0) return; + player.combatTraits.attackChance += getPercentage(itemType.effects_equip.combatProficiency.attackChance, percentToAdd); + } + + private static void addPercentBlockChance(Player player, ItemType itemType, int percentToAdd) { + if (itemType.effects_equip == null) return; + if (percentToAdd == 0) return; + player.combatTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, percentToAdd); + } + + private static void addPercentCriticalSkill(Player player, ItemType itemType, int percentToAdd) { + if (itemType.effects_equip == null) return; + if (percentToAdd == 0) return; + player.combatTraits.criticalSkill += getPercentage(itemType.effects_equip.combatProficiency.criticalSkill, percentToAdd); + } + + private static void addPercentDamage(Player player, ItemType itemType, int percentToAdd) { + if (itemType.effects_equip == null) return; + if (percentToAdd == 0) return; + player.combatTraits.damagePotential.addToMax(getPercentage(itemType.effects_equip.combatProficiency.damagePotential.max, percentToAdd)); + player.combatTraits.damagePotential.add(getPercentage(itemType.effects_equip.combatProficiency.damagePotential.current, percentToAdd), false); + } + + private static int getPercentage(int originalValue, int percentToAdd) { + if (originalValue <= 0) return 0; + return (int) FloatMath.floor(originalValue * percentToAdd / 100.0f); } public static boolean isDualWielding(ItemType mainHandItem, ItemType offHandItem) { - return false; + if (mainHandItem == null) return false; + if (offHandItem == null) return false; + return mainHandItem.isWeapon() && offHandItem.isWeapon(); + } + + private static boolean isWielding2HandItem(ItemType mainHandItem, ItemType offHandItem) { + if (mainHandItem == null) return false; + if (offHandItem != null) return false; + return mainHandItem.isTwohandWeapon(); + } + + private static boolean isWieldingWeaponAndShield(ItemType mainHandItem, ItemType offHandItem) { + if (mainHandItem == null) return false; + if (offHandItem == null) return false; + return mainHandItem.isWeapon() && offHandItem.isShield(); } } diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java index 9a93f55e5..f5e0d1aab 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java @@ -36,8 +36,24 @@ public final class SkillCollection { public static final int SKILL_REJUVENATION = 23; // Reduces magnitudes of conditions public static final int SKILL_TAUNT = 24; // Causes AP loss of attackers that miss public static final int SKILL_CONCUSSION = 25; // AC loss for monsters with (AC-BC)>N + public static final int SKILL_WEAPON_PROFICIENCY_DAGGER = 26; + public static final int SKILL_WEAPON_PROFICIENCY_1HSWORD = 27; + public static final int SKILL_WEAPON_PROFICIENCY_2HSWORD = 28; + public static final int SKILL_WEAPON_PROFICIENCY_AXE = 29; + public static final int SKILL_WEAPON_PROFICIENCY_BLUNT = 30; + public static final int SKILL_WEAPON_PROFICIENCY_UNARMED = 31; + public static final int SKILL_ARMOR_PROFICIENCY_SHIELD = 32; + public static final int SKILL_ARMOR_PROFICIENCY_UNARMORED = 33; + public static final int SKILL_ARMOR_PROFICIENCY_LIGHT = 34; + public static final int SKILL_ARMOR_PROFICIENCY_HEAVY = 35; + public static final int SKILL_FIGHTSTYLE_DUAL_WIELD = 36; + public static final int SKILL_FIGHTSTYLE_2HAND = 37; + public static final int SKILL_FIGHTSTYLE_WEAPON_SHIELD = 38; + public static final int SKILL_SPECIALIZATION_DUAL_WIELD = 39; + public static final int SKILL_SPECIALIZATION_2HAND = 40; + public static final int SKILL_SPECIALIZATION_WEAPON_SHIELD = 41; - public static final int NUM_SKILLS = SKILL_CONCUSSION + 1; + public static final int NUM_SKILLS = SKILL_SPECIALIZATION_WEAPON_SHIELD + 1; public static final int PER_SKILLPOINT_INCREASE_WEAPON_CHANCE = 12; public static final int PER_SKILLPOINT_INCREASE_WEAPON_DAMAGE_MAX = 1; @@ -145,6 +161,37 @@ public final class SkillCollection { ,SkillLevelRequirement.requireOtherSkill(SKILL_WEAPON_CHANCE, 3) ,SkillLevelRequirement.requireOtherSkill(SKILL_WEAPON_DMG, 5) })); + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_DAGGER, 3, false, null)); + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_1HSWORD, 3, false, null)); + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_2HSWORD, 3, false, null)); + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_AXE, 3, false, null)); + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_BLUNT, 3, false, null)); + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_UNARMED, 3, false, null)); + initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_SHIELD, 2, false, null)); + initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_UNARMORED, 3, false, null)); + initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_LIGHT, 3, false, null)); + initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_HEAVY, 4, false, null)); + initializeSkill(new SkillInfo(SKILL_FIGHTSTYLE_DUAL_WIELD, 2, false, new SkillLevelRequirement[] { + SkillLevelRequirement.requireExperienceLevels(15, 0) + })); + initializeSkill(new SkillInfo(SKILL_FIGHTSTYLE_2HAND, 2, false, new SkillLevelRequirement[] { + SkillLevelRequirement.requireExperienceLevels(15, 0) + })); + initializeSkill(new SkillInfo(SKILL_FIGHTSTYLE_WEAPON_SHIELD, 2, false, new SkillLevelRequirement[] { + SkillLevelRequirement.requireExperienceLevels(15, 0) + })); + initializeSkill(new SkillInfo(SKILL_SPECIALIZATION_DUAL_WIELD, 1, false, new SkillLevelRequirement[] { + SkillLevelRequirement.requireExperienceLevels(45, 0) + ,SkillLevelRequirement.requireOtherSkill(SKILL_FIGHTSTYLE_DUAL_WIELD, 2) + })); + initializeSkill(new SkillInfo(SKILL_SPECIALIZATION_2HAND, 1, false, new SkillLevelRequirement[] { + SkillLevelRequirement.requireExperienceLevels(45, 0) + ,SkillLevelRequirement.requireOtherSkill(SKILL_FIGHTSTYLE_2HAND, 2) + })); + initializeSkill(new SkillInfo(SKILL_SPECIALIZATION_WEAPON_SHIELD, 1, false, new SkillLevelRequirement[] { + SkillLevelRequirement.requireExperienceLevels(45, 0) + ,SkillLevelRequirement.requireOtherSkill(SKILL_FIGHTSTYLE_WEAPON_SHIELD, 2) + })); } public SkillInfo getSkill(int skillID) { diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/view/SkillListAdapter.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/view/SkillListAdapter.java index 9d3810de3..21b1e4984 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/view/SkillListAdapter.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/view/SkillListAdapter.java @@ -119,6 +119,22 @@ public final class SkillListAdapter extends ArrayAdapter { case SkillCollection.SKILL_REJUVENATION: return R.string.skill_shortdescription_rejuvenation; case SkillCollection.SKILL_TAUNT: return R.string.skill_shortdescription_taunt; case SkillCollection.SKILL_CONCUSSION: return R.string.skill_shortdescription_concussion; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_DAGGER: return R.string.skill_shortdescription_weapon_prof_dagger; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_1HSWORD: return R.string.skill_shortdescription_weapon_prof_1hsword; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_2HSWORD: return R.string.skill_shortdescription_weapon_prof_2hsword; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_AXE: return R.string.skill_shortdescription_weapon_prof_axe; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_BLUNT: return R.string.skill_shortdescription_weapon_prof_blunt; + case SkillCollection.SKILL_WEAPON_PROFICIENCY_UNARMED: return R.string.skill_shortdescription_weapon_prof_unarmed; + case SkillCollection.SKILL_ARMOR_PROFICIENCY_SHIELD: return R.string.skill_shortdescription_armor_prof_shield; + case SkillCollection.SKILL_ARMOR_PROFICIENCY_UNARMORED: return R.string.skill_shortdescription_armor_prof_unarmored; + case SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT: return R.string.skill_shortdescription_armor_prof_light; + case SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY: return R.string.skill_shortdescription_armor_prof_heavy; + case SkillCollection.SKILL_FIGHTSTYLE_DUAL_WIELD: return R.string.skill_shortdescription_fightstyle_dualwield; + case SkillCollection.SKILL_FIGHTSTYLE_2HAND: return R.string.skill_shortdescription_fightstyle_2hand; + case SkillCollection.SKILL_FIGHTSTYLE_WEAPON_SHIELD: return R.string.skill_shortdescription_fightstyle_weapon_shield; + case SkillCollection.SKILL_SPECIALIZATION_DUAL_WIELD: return R.string.skill_shortdescription_specialization_dualwield; + case SkillCollection.SKILL_SPECIALIZATION_2HAND: return R.string.skill_shortdescription_specialization_2hand; + case SkillCollection.SKILL_SPECIALIZATION_WEAPON_SHIELD: return R.string.skill_shortdescription_specialization_weapon_shield; default: return -1; } From 83af64b4a3d624904ab263c1d5a474ab0c073491 Mon Sep 17 00:00:00 2001 From: Oskar Wiksten Date: Sun, 24 Jun 2012 01:11:33 +0200 Subject: [PATCH 2/7] Fixed issue with critical multipliers from main-hand weapons. Fixed issues with weapon proficiency being applied after dual wielding bonuses (should be before dual-wielding bonuses) Fixed issues with negative AC in offhand weapons not being taken into account when dual-wielding. Equipping a regular weapon should replace two-hand weapon. --- .../controller/SkillController.java | 181 ++++++++---------- 1 file changed, 80 insertions(+), 101 deletions(-) diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java index 184b2dbd1..6223c0015 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java @@ -191,29 +191,32 @@ public final class SkillController { } public static void applySkillEffectsFromItemProficiencies(Player player) { - player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_DAGGER); - player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_1HSWORD); - player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_2HSWORD); - player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_AXE); - player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_BLUNT); - player.combatTraits.attackChance += 10 * getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_WEAPON_PROFICIENCY_UNARMED); + CombatTraits playerTraits = player.combatTraits; + + ItemType mainWeapon = ItemController.getMainWeapon(player); + if (mainWeapon != null) { + playerTraits.attackChance += 10 * getSkillLevelForItemType(player, mainWeapon); + } final int unarmedLevel = player.getSkillLevel(SkillCollection.SKILL_WEAPON_PROFICIENCY_UNARMED); if (unarmedLevel > 0) { if (isUnarmed(player)) { - player.combatTraits.attackChance += 20 * unarmedLevel; - player.combatTraits.damagePotential.addToMax(2 * unarmedLevel); - player.combatTraits.damagePotential.add(2 * unarmedLevel, false); - player.combatTraits.blockChance += 5 * unarmedLevel; + playerTraits.attackChance += 20 * unarmedLevel; + playerTraits.damagePotential.addToMax(2 * unarmedLevel); + playerTraits.damagePotential.add(2 * unarmedLevel, false); + playerTraits.blockChance += 5 * unarmedLevel; } } - player.combatTraits.damageResistance += getItemProficiencySkillEffectFactor(player, SkillCollection.SKILL_ARMOR_PROFICIENCY_SHIELD); + ItemType shield = player.inventory.wear[Inventory.WEARSLOT_SHIELD]; + if (shield != null && shield.isShield()) { + playerTraits.damageResistance += getSkillLevelForItemType(player, shield); + } final int unarmoredLevel = player.getSkillLevel(SkillCollection.SKILL_ARMOR_PROFICIENCY_UNARMORED); if (unarmoredLevel > 0) { if (isUnarmored(player)) { - player.combatTraits.blockChance += 10 * unarmoredLevel; + playerTraits.blockChance += 10 * unarmoredLevel; } } @@ -225,16 +228,17 @@ public final class SkillController { ItemType itemType = player.inventory.wear[slot]; if (itemType == null) continue; if (itemType.effects_equip == null) continue; - if (skillLevelLightArmor > 0) { - if (isSkillForItemCategory(SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT, itemType.category)) { - player.combatTraits.blockChance += FloatMath.floor(itemType.effects_equip.combatProficiency.blockChance * 30 * skillLevelLightArmor / 100.0f); + + int skill = getProficiencySkillForItemCategory(itemType.category); + if (skill == SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT) { + if (skillLevelLightArmor > 0) { + playerTraits.blockChance += FloatMath.floor(itemType.effects_equip.combatProficiency.blockChance * 30 * skillLevelLightArmor / 100.0f); } - } - if (skillLevelHeavyArmor > 0) { - if (isSkillForItemCategory(SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY, itemType.category)) { - player.combatTraits.blockChance += FloatMath.floor(itemType.effects_equip.combatProficiency.blockChance * 10 * skillLevelHeavyArmor / 100.0f); + } else if (skill == SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY) { + if (skillLevelHeavyArmor > 0) { + playerTraits.blockChance += FloatMath.floor(itemType.effects_equip.combatProficiency.blockChance * 10 * skillLevelHeavyArmor / 100.0f); player.actorTraits.moveCost -= FloatMath.floor(itemType.effects_equip.moveCostPenalty * 25 * skillLevelHeavyArmor / 100.0f); - player.combatTraits.attackCost -= FloatMath.floor(itemType.effects_equip.combatProficiency.attackCost * 25 * skillLevelHeavyArmor / 100.0f); + playerTraits.attackCost -= FloatMath.floor(itemType.effects_equip.combatProficiency.attackCost * 25 * skillLevelHeavyArmor / 100.0f); } } } @@ -259,135 +263,110 @@ public final class SkillController { return true; } - private static int getItemProficiencySkillEffectFactor(final Player player, final int skill) { - int skillLevel = player.getSkillLevel(skill); - if (skillLevel <= 0) return 0; - - int numItems = 0; - for (int slot = 0; slot < Inventory.NUM_WORN_SLOTS; ++slot) { - ItemType itemType = player.inventory.wear[slot]; - if (itemType == null) continue; - if (isSkillForItemCategory(skill, itemType.category)) ++numItems; - } - return numItems * skillLevel; + private static int getSkillLevelForItemType(final Player player, ItemType itemType) { + int skill = getProficiencySkillForItemCategory(itemType.category); + if (skill == -1) return 0; + return player.getSkillLevel(skill); } - private static boolean isSkillForItemCategory(final int skill, ItemCategory category) { + private static int getProficiencySkillForItemCategory(ItemCategory category) { final String itemCategoryID = category.id; - switch (skill) { - case SkillCollection.SKILL_WEAPON_PROFICIENCY_DAGGER: - if (itemCategoryID.equals("dagger")) return true; - if (itemCategoryID.equals("ssword")) return true; - return false; - case SkillCollection.SKILL_WEAPON_PROFICIENCY_1HSWORD: - if (itemCategoryID.equals("lsword")) return true; - if (itemCategoryID.equals("bsword")) return true; - return false; - case SkillCollection.SKILL_WEAPON_PROFICIENCY_2HSWORD: - if (itemCategoryID.equals("2hsword")) return true; - return false; - case SkillCollection.SKILL_WEAPON_PROFICIENCY_AXE: - if (itemCategoryID.equals("axe")) return true; - if (itemCategoryID.equals("axe2h")) return true; - return false; - case SkillCollection.SKILL_WEAPON_PROFICIENCY_BLUNT: - if (itemCategoryID.equals("club")) return true; - if (itemCategoryID.equals("staff")) return true; - if (itemCategoryID.equals("mace")) return true; - if (itemCategoryID.equals("scepter")) return true; - if (itemCategoryID.equals("hammer")) return true; - if (itemCategoryID.equals("hammer2h")) return true; - return false; - case SkillCollection.SKILL_ARMOR_PROFICIENCY_SHIELD: - if (category.isShield()) return true; - return false; - case SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT: - if (!category.isArmor()) return false; - if (category.size == ItemCategory.SIZE_LIGHT) return true; - if (category.size == ItemCategory.SIZE_STD) return true; - return false; - case SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY: - if (!category.isArmor()) return false; - if (category.size == ItemCategory.SIZE_LARGE) return true; - return false; + if (category.isWeapon()) { + if (itemCategoryID.equals("dagger") || itemCategoryID.equals("ssword")) + return SkillCollection.SKILL_WEAPON_PROFICIENCY_DAGGER; + else if (itemCategoryID.equals("lsword") || itemCategoryID.equals("bsword")) + return SkillCollection.SKILL_WEAPON_PROFICIENCY_1HSWORD; + else if (itemCategoryID.equals("2hsword")) + return SkillCollection.SKILL_WEAPON_PROFICIENCY_2HSWORD; + else if (itemCategoryID.equals("axe") || itemCategoryID.equals("axe2h")) + return SkillCollection.SKILL_WEAPON_PROFICIENCY_AXE; + else if (itemCategoryID.equals("club") || itemCategoryID.equals("staff") || itemCategoryID.equals("mace") + || itemCategoryID.equals("scepter") || itemCategoryID.equals("hammer") || itemCategoryID.equals("hammer2h")) + return SkillCollection.SKILL_WEAPON_PROFICIENCY_BLUNT; + } else if (category.isShield()) { + return SkillCollection.SKILL_ARMOR_PROFICIENCY_SHIELD; + } else if (category.isArmor()) { + if (category.size == ItemCategory.SIZE_LIGHT) return SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT; + if (category.size == ItemCategory.SIZE_STD) return SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT; + if (category.size == ItemCategory.SIZE_LARGE) return SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY; } - return false; + return -1; } public static void applySkillEffectsFromFightingStyles(Player player) { + CombatTraits playerTraits = player.combatTraits; ItemType mainHandItem = player.inventory.wear[Inventory.WEARSLOT_WEAPON]; ItemType offHandItem = player.inventory.wear[Inventory.WEARSLOT_SHIELD]; if (isWielding2HandItem(mainHandItem, offHandItem)) { int skillLevelFightStyle = player.getSkillLevel(SkillCollection.SKILL_FIGHTSTYLE_2HAND); int skillLevelSpecialization = player.getSkillLevel(SkillCollection.SKILL_SPECIALIZATION_2HAND); - addPercentDamage(player, mainHandItem, skillLevelFightStyle * 50); - addPercentDamage(player, mainHandItem, skillLevelSpecialization * 50); - addPercentAttackChance(player, mainHandItem, skillLevelSpecialization * 20); + addPercentDamage(playerTraits, mainHandItem, skillLevelFightStyle * 50); + addPercentDamage(playerTraits, mainHandItem, skillLevelSpecialization * 50); + addPercentAttackChance(playerTraits, mainHandItem, skillLevelSpecialization * 20); } if (isWieldingWeaponAndShield(mainHandItem, offHandItem)) { int skillLevelFightStyle = player.getSkillLevel(SkillCollection.SKILL_FIGHTSTYLE_WEAPON_SHIELD); int skillLevelSpecialization = player.getSkillLevel(SkillCollection.SKILL_SPECIALIZATION_WEAPON_SHIELD); - addPercentAttackChance(player, mainHandItem, skillLevelFightStyle * 50); - addPercentBlockChance(player, offHandItem, skillLevelFightStyle * 50); - addPercentAttackChance(player, mainHandItem, skillLevelSpecialization * 20); - addPercentBlockChance(player, mainHandItem, skillLevelSpecialization * 50); + addPercentAttackChance(playerTraits, mainHandItem, skillLevelFightStyle * 50); + addPercentBlockChance(playerTraits, offHandItem, skillLevelFightStyle * 50); + addPercentAttackChance(playerTraits, mainHandItem, skillLevelSpecialization * 20); + addPercentBlockChance(playerTraits, mainHandItem, skillLevelSpecialization * 50); } if (isDualWielding(mainHandItem, offHandItem)) { int skillLevelFightStyle = player.getSkillLevel(SkillCollection.SKILL_FIGHTSTYLE_DUAL_WIELD); if (offHandItem.effects_equip != null) { + CombatTraits offHandCombatTraits = offHandItem.effects_equip.combatProficiency; int attackCostMainHand = mainHandItem.effects_equip.combatProficiency.attackCost; - int attackCostOffHand = offHandItem.effects_equip.combatProficiency.attackCost; int percent; if (skillLevelFightStyle == 2) { percent = 100; - player.combatTraits.attackCost = Math.max(attackCostMainHand, attackCostOffHand); + playerTraits.attackCost = Math.max(attackCostMainHand, offHandCombatTraits.attackCost); } else if (skillLevelFightStyle == 1) { percent = 50; - player.combatTraits.attackCost = attackCostMainHand + getPercentage(attackCostOffHand, 50); + playerTraits.attackCost = attackCostMainHand + getPercentage(offHandCombatTraits.attackCost, 50); } else { percent = 25; - player.combatTraits.attackCost = attackCostMainHand + attackCostOffHand; + playerTraits.attackCost = attackCostMainHand + offHandCombatTraits.attackCost; } - addPercentAttackChance(player, offHandItem, percent); - addPercentBlockChance(player, offHandItem, percent); - addPercentDamage(player, offHandItem, percent); - addPercentCriticalSkill(player, offHandItem, percent); + + int attackChance = offHandCombatTraits.attackChance; + attackChance += 10 * getSkillLevelForItemType(player, offHandItem); + + playerTraits.attackChance += (int) FloatMath.floor(attackChance * percent / 100.0f); + playerTraits.blockChance += (int) FloatMath.floor(offHandCombatTraits.blockChance * percent / 100.0f); + playerTraits.damagePotential.addToMax((int) FloatMath.floor(offHandCombatTraits.damagePotential.max * percent / 100.0f)); + playerTraits.damagePotential.add((int) FloatMath.floor(offHandCombatTraits.damagePotential.current * percent / 100.0f), false); + playerTraits.criticalSkill += (int) FloatMath.floor(offHandCombatTraits.criticalSkill * percent / 100.0f); } int skillLevelSpecialization = player.getSkillLevel(SkillCollection.SKILL_SPECIALIZATION_DUAL_WIELD); - addPercentAttackChance(player, mainHandItem, skillLevelSpecialization * 50); - addPercentBlockChance(player, mainHandItem, skillLevelSpecialization * 50); - addPercentAttackChance(player, offHandItem, skillLevelSpecialization * 50); - addPercentBlockChance(player, offHandItem, skillLevelSpecialization * 50); + addPercentAttackChance(playerTraits, mainHandItem, skillLevelSpecialization * 50); + addPercentBlockChance(playerTraits, mainHandItem, skillLevelSpecialization * 50); + addPercentAttackChance(playerTraits, offHandItem, skillLevelSpecialization * 50); + addPercentBlockChance(playerTraits, offHandItem, skillLevelSpecialization * 50); } } - private static void addPercentAttackChance(Player player, ItemType itemType, int percentToAdd) { + private static void addPercentAttackChance(CombatTraits combatTraits, ItemType itemType, int percentToAdd) { if (itemType.effects_equip == null) return; if (percentToAdd == 0) return; - player.combatTraits.attackChance += getPercentage(itemType.effects_equip.combatProficiency.attackChance, percentToAdd); + combatTraits.attackChance += getPercentage(itemType.effects_equip.combatProficiency.attackChance, percentToAdd); } - private static void addPercentBlockChance(Player player, ItemType itemType, int percentToAdd) { + private static void addPercentBlockChance(CombatTraits combatTraits, ItemType itemType, int percentToAdd) { if (itemType.effects_equip == null) return; if (percentToAdd == 0) return; - player.combatTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, percentToAdd); + combatTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, percentToAdd); } - private static void addPercentCriticalSkill(Player player, ItemType itemType, int percentToAdd) { + private static void addPercentDamage(CombatTraits combatTraits, ItemType itemType, int percentToAdd) { if (itemType.effects_equip == null) return; if (percentToAdd == 0) return; - player.combatTraits.criticalSkill += getPercentage(itemType.effects_equip.combatProficiency.criticalSkill, percentToAdd); - } - - private static void addPercentDamage(Player player, ItemType itemType, int percentToAdd) { - if (itemType.effects_equip == null) return; - if (percentToAdd == 0) return; - player.combatTraits.damagePotential.addToMax(getPercentage(itemType.effects_equip.combatProficiency.damagePotential.max, percentToAdd)); - player.combatTraits.damagePotential.add(getPercentage(itemType.effects_equip.combatProficiency.damagePotential.current, percentToAdd), false); + combatTraits.damagePotential.addToMax(getPercentage(itemType.effects_equip.combatProficiency.damagePotential.max, percentToAdd)); + combatTraits.damagePotential.add(getPercentage(itemType.effects_equip.combatProficiency.damagePotential.current, percentToAdd), false); } private static int getPercentage(int originalValue, int percentToAdd) { From 0c376442bb76abfcdc351fcbdbf9da4c64dade14 Mon Sep 17 00:00:00 2001 From: Oskar Wiksten Date: Sun, 24 Jun 2012 09:51:25 +0200 Subject: [PATCH 3/7] Armor proficiencies should not affect items with negative stats. --- .../gpl/rpg/AndorsTrail/controller/SkillController.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java index 6223c0015..9106d6ddf 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java @@ -232,13 +232,13 @@ public final class SkillController { int skill = getProficiencySkillForItemCategory(itemType.category); if (skill == SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT) { if (skillLevelLightArmor > 0) { - playerTraits.blockChance += FloatMath.floor(itemType.effects_equip.combatProficiency.blockChance * 30 * skillLevelLightArmor / 100.0f); + playerTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, 30 * skillLevelLightArmor); } } else if (skill == SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY) { if (skillLevelHeavyArmor > 0) { - playerTraits.blockChance += FloatMath.floor(itemType.effects_equip.combatProficiency.blockChance * 10 * skillLevelHeavyArmor / 100.0f); - player.actorTraits.moveCost -= FloatMath.floor(itemType.effects_equip.moveCostPenalty * 25 * skillLevelHeavyArmor / 100.0f); - playerTraits.attackCost -= FloatMath.floor(itemType.effects_equip.combatProficiency.attackCost * 25 * skillLevelHeavyArmor / 100.0f); + playerTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, 10 * skillLevelHeavyArmor); + player.actorTraits.moveCost -= getPercentage(itemType.effects_equip.moveCostPenalty, 25 * skillLevelHeavyArmor); + playerTraits.attackCost -= getPercentage(itemType.effects_equip.combatProficiency.attackCost, 25 * skillLevelHeavyArmor); } } } From dfff586d7dacb6b3ea9129020194f203c2f3b4d2 Mon Sep 17 00:00:00 2001 From: Oskar Wiksten Date: Sun, 24 Jun 2012 23:19:49 +0200 Subject: [PATCH 4/7] Better descriptions for some of the new skills. --- AndorsTrail/res/values/strings.xml | 52 +++++++++++++++--------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/AndorsTrail/res/values/strings.xml b/AndorsTrail/res/values/strings.xml index ea29806fb..09ef9398f 100644 --- a/AndorsTrail/res/values/strings.xml +++ b/AndorsTrail/res/values/strings.xml @@ -583,33 +583,33 @@ Specialization: Two handed weapon Specialization: Weapon and shield - Dagger proficiency - One-handed sword proficiency - Two-handed sword proficiency - Axe proficiency - Bludgeoning weapon proficiency - Unarmed fighting - Shield proficiency - Armour proficiency: unarmored - Light armor proficiency - Heavy armor proficiency - Fighting style: Dual wield - Fighting style: Two handed weapon - Fighting style: Weapon and shield - Specialization: Dual wield - Specialization: Two handed weapon - Specialization: Weapon and shield + Better at fighting with daggers + Better at fighting with one-handed swords + Better at fighting with two-handed swords + Better at fighting with axes + Better at fighting with bludgeoning weapons + Better at fighting with bare hands + Make better use of shields + Better at fighting without armor + Make better use of light armor + Make better use of heavy armor + Wield two weapons at the same time + Make better use of weapons that require both hands + Better at fighting with weapon and shield + Expert at dual wielding + Expert at two-handed weapons + Expert at fighting with weapon and shield - Dagger proficiency - One-handed sword proficiency - Two-handed sword proficiency - Axe proficiency - Bludgeoning weapon proficiency - Unarmed fighting - Shield proficiency - Armour proficiency: unarmored - Light armor proficiency - Heavy armor proficiency + Increases attack chance of daggers and shortswords by %1$d for each level. + Increases attack chance of longswords and broadswords by %1$d for each level. + Increases attack chance of two-handed swords by %1$d for each level. + Increases attack chance of axes and greataxes by %1$d for each level. + Increases attack chance of bludgeoning weapons by %1$d for each level. This includes clubs, quarterstaves, maces, scepters, warhammers and giant hammers. + When fighting without a weapon and shield, gain %1$d attack chance, %2$d damage potential and %3$d block chance per skill level. + Increase damage resistance by %1$d per skill level while having a shield equipped. + While fighting without having any armor equipped, gain %1$d block chance per skill level. Items made of cloth are not considered as being armor. + Increases block chance of every piece of light armor being worn by %1$d %% per skill level. Light armors include leather and light metal. + Increases block chance of every piece of heavy armor being worn by %1$d %% per skill level. Pieces of heavy armor have their movement penalties reduced by %2$d %% per skill level, and their attack speed penalties reduced by %3$d %% per skill level. Heavy armors include metal armors, chain mail and plate mail. Fighting style: Dual wield Fighting style: Two handed weapon Fighting style: Weapon and shield From 8b6aafc5bd359a9e8e9559d4399cdfd96988e1be Mon Sep 17 00:00:00 2001 From: Oskar Wiksten Date: Mon, 25 Jun 2012 21:47:32 +0200 Subject: [PATCH 5/7] Added better descriptions for the new skills. --- AndorsTrail/res/values/strings.xml | 32 +++++++---- .../activity/SkillInfoActivity.java | 33 ++++++------ .../controller/SkillController.java | 54 +++++++++---------- .../model/ability/SkillCollection.java | 23 ++++++++ 4 files changed, 88 insertions(+), 54 deletions(-) diff --git a/AndorsTrail/res/values/strings.xml b/AndorsTrail/res/values/strings.xml index 09ef9398f..837d8871b 100644 --- a/AndorsTrail/res/values/strings.xml +++ b/AndorsTrail/res/values/strings.xml @@ -573,14 +573,14 @@ Bludgeoning weapon proficiency Unarmed fighting Shield proficiency - Armour proficiency: unarmored + Unarmored fighting Light armor proficiency Heavy armor proficiency Fighting style: Dual wield - Fighting style: Two handed weapon + Fighting style: Two-handed weapon Fighting style: Weapon and shield Specialization: Dual wield - Specialization: Two handed weapon + Specialization: Two-handed weapon Specialization: Weapon and shield Better at fighting with daggers @@ -608,13 +608,23 @@ When fighting without a weapon and shield, gain %1$d attack chance, %2$d damage potential and %3$d block chance per skill level. Increase damage resistance by %1$d per skill level while having a shield equipped. While fighting without having any armor equipped, gain %1$d block chance per skill level. Items made of cloth are not considered as being armor. - Increases block chance of every piece of light armor being worn by %1$d %% per skill level. Light armors include leather and light metal. - Increases block chance of every piece of heavy armor being worn by %1$d %% per skill level. Pieces of heavy armor have their movement penalties reduced by %2$d %% per skill level, and their attack speed penalties reduced by %3$d %% per skill level. Heavy armors include metal armors, chain mail and plate mail. - Fighting style: Dual wield - Fighting style: Two handed weapon - Fighting style: Weapon and shield - Specialization: Dual wield - Specialization: Two handed weapon - Specialization: Weapon and shield + For every skill level, increases the block chance of every piece of light armor being worn by %1$d %% of their original block chances. Light armors include leather and light metal. + For every skill level, increases the block chance of every piece of heavy armor being worn by %1$d %% of their original block chances. Pieces of heavy armor have their movement penalties reduced by %2$d %% per skill level, and their attack speed penalties reduced by %3$d %% per skill level. Heavy armors include metal armors, chain mail and plate mail. + "Gives benefits when fighting with two weapons at the same time, one in the main hand and one in the off-hand. + +Without this skill, only %1$d %% of a weapon\'s qualities may be used when equipped in the off-hand. This includes attack chance, critical skill, damage potential and block chance. Without this skill, attack speed (AP cost) of making an attack is the sum of the attack speed of the main weapon and that of the weapon used in the off-hand. + +With one level of this skill, %2$d %% of the off-hand\'s weapon\'s qualities may be used, and the attack speed is the attack speed of the weapon in the main hand plus %3$d %% of the attack speed of the weapon in the off-hand. + +With two levels of this skill, %4$d %% of the off-hand\'s weapon\'s qualities may be used, and the attack speed equals the highest of the attack speeds of the two equipped weapons." + "Gives benefits when using weapons that require both hands to wield, such as two-handed swords, greataxes or giant hammers. + +Every skill level increases damage potential of two-handed weapons with %1$d %% of the original damage potential." + "Gives benefits when fighting with a weapon in the main hand and having a shield equipped in the off-hand. + +Every skill level increases the attack chance of weapons with %1$d %% of their original attack chances, and the block chance of shields by %2$d %% of their original block chances." + Increases the attack chance of both wielded weapons by an additional %1$d %% of their original attack chances, in addition to the benefis given by the weapon style skill. The block chances of both wielded weapons are also increased by %2$d %% of their original block chances. + Increases damage potential of two-handed weapons by an additional %1$d %% of the original damage potential, in addition to the benefis given by the weapon style skill. The attack chances of two-handed weapons are also increased by %2$d %% of their original attack chances. + Increases both attack chances and damage potential of weapons. The attack chance is increased by %1$d %% of the original attack chance, and the damage potential is increased by %2$d %% of the original damage potential. diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/activity/SkillInfoActivity.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/activity/SkillInfoActivity.java index d39d48d15..d0d36168f 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/activity/SkillInfoActivity.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/activity/SkillInfoActivity.java @@ -13,6 +13,7 @@ import android.app.Activity; import android.content.Intent; import android.content.res.Resources; import android.os.Bundle; +import android.text.Html; import android.view.View; import android.view.ViewGroup; import android.view.View.OnClickListener; @@ -182,22 +183,22 @@ public final class SkillInfoActivity extends Activity { case SkillCollection.SKILL_REJUVENATION: return res.getString(R.string.skill_longdescription_rejuvenation, SkillCollection.PER_SKILLPOINT_INCREASE_REJUVENATION_CHANCE); case SkillCollection.SKILL_TAUNT: return res.getString(R.string.skill_longdescription_taunt, SkillCollection.PER_SKILLPOINT_INCREASE_TAUNT_CHANCE, SkillCollection.TAUNT_AP_LOSS); case SkillCollection.SKILL_CONCUSSION: return res.getString(R.string.skill_longdescription_concussion, SkillCollection.CONCUSSION_THRESHOLD, SkillCollection.PER_SKILLPOINT_INCREASE_CONCUSSION_CHANCE); - case SkillCollection.SKILL_WEAPON_PROFICIENCY_DAGGER: return res.getString(R.string.skill_longdescription_weapon_prof_dagger); - case SkillCollection.SKILL_WEAPON_PROFICIENCY_1HSWORD: return res.getString(R.string.skill_longdescription_weapon_prof_1hsword); - case SkillCollection.SKILL_WEAPON_PROFICIENCY_2HSWORD: return res.getString(R.string.skill_longdescription_weapon_prof_2hsword); - case SkillCollection.SKILL_WEAPON_PROFICIENCY_AXE: return res.getString(R.string.skill_longdescription_weapon_prof_axe); - case SkillCollection.SKILL_WEAPON_PROFICIENCY_BLUNT: return res.getString(R.string.skill_longdescription_weapon_prof_blunt); - case SkillCollection.SKILL_WEAPON_PROFICIENCY_UNARMED: return res.getString(R.string.skill_longdescription_weapon_prof_unarmed); - case SkillCollection.SKILL_ARMOR_PROFICIENCY_SHIELD: return res.getString(R.string.skill_longdescription_armor_prof_shield); - case SkillCollection.SKILL_ARMOR_PROFICIENCY_UNARMORED: return res.getString(R.string.skill_longdescription_armor_prof_unarmored); - case SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT: return res.getString(R.string.skill_longdescription_armor_prof_light); - case SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY: return res.getString(R.string.skill_longdescription_armor_prof_heavy); - case SkillCollection.SKILL_FIGHTSTYLE_DUAL_WIELD: return res.getString(R.string.skill_longdescription_fightstyle_dualwield); - case SkillCollection.SKILL_FIGHTSTYLE_2HAND: return res.getString(R.string.skill_longdescription_fightstyle_2hand); - case SkillCollection.SKILL_FIGHTSTYLE_WEAPON_SHIELD: return res.getString(R.string.skill_longdescription_fightstyle_weapon_shield); - case SkillCollection.SKILL_SPECIALIZATION_DUAL_WIELD: return res.getString(R.string.skill_longdescription_specialization_dualwield); - case SkillCollection.SKILL_SPECIALIZATION_2HAND: return res.getString(R.string.skill_longdescription_specialization_2hand); - case SkillCollection.SKILL_SPECIALIZATION_WEAPON_SHIELD: return res.getString(R.string.skill_longdescription_specialization_weapon_shield); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_DAGGER: return res.getString(R.string.skill_longdescription_weapon_prof_dagger, SkillCollection.PER_SKILLPOINT_INCREASE_WEAPON_PROF_AC); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_1HSWORD: return res.getString(R.string.skill_longdescription_weapon_prof_1hsword, SkillCollection.PER_SKILLPOINT_INCREASE_WEAPON_PROF_AC); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_2HSWORD: return res.getString(R.string.skill_longdescription_weapon_prof_2hsword, SkillCollection.PER_SKILLPOINT_INCREASE_WEAPON_PROF_AC); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_AXE: return res.getString(R.string.skill_longdescription_weapon_prof_axe, SkillCollection.PER_SKILLPOINT_INCREASE_WEAPON_PROF_AC); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_BLUNT: return res.getString(R.string.skill_longdescription_weapon_prof_blunt, SkillCollection.PER_SKILLPOINT_INCREASE_WEAPON_PROF_AC); + case SkillCollection.SKILL_WEAPON_PROFICIENCY_UNARMED: return res.getString(R.string.skill_longdescription_weapon_prof_unarmed, SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_AC, SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_DMG, SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_BC); + case SkillCollection.SKILL_ARMOR_PROFICIENCY_SHIELD: return res.getString(R.string.skill_longdescription_armor_prof_shield, SkillCollection.PER_SKILLPOINT_INCREASE_SHIELD_PROF_DR); + case SkillCollection.SKILL_ARMOR_PROFICIENCY_UNARMORED: return res.getString(R.string.skill_longdescription_armor_prof_unarmored, SkillCollection.PER_SKILLPOINT_INCREASE_UNARMORED_BC); + case SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT: return res.getString(R.string.skill_longdescription_armor_prof_light, SkillCollection.PER_SKILLPOINT_INCREASE_LIGHT_ARMOR_BC_PERCENT); + case SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY: return res.getString(R.string.skill_longdescription_armor_prof_heavy, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_BC_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_MOVECOST_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_ATKCOST_PERCENT); + case SkillCollection.SKILL_FIGHTSTYLE_DUAL_WIELD: return res.getString(R.string.skill_longdescription_fightstyle_dualwield, SkillCollection.DUALWIELD_EFFICIENCY_LEVEL0, SkillCollection.DUALWIELD_EFFICIENCY_LEVEL1, SkillCollection.DUALWIELD_LEVEL1_OFFHAND_AP_COST_PERCENT, SkillCollection.DUALWIELD_EFFICIENCY_LEVEL2); + case SkillCollection.SKILL_FIGHTSTYLE_2HAND: return res.getString(R.string.skill_longdescription_fightstyle_2hand, SkillCollection.PER_SKILLPOINT_INCREASE_FIGHTSTYLE_2HAND_DMG_PERCENT); + case SkillCollection.SKILL_FIGHTSTYLE_WEAPON_SHIELD: return res.getString(R.string.skill_longdescription_fightstyle_weapon_shield, SkillCollection.PER_SKILLPOINT_INCREASE_FIGHTSTYLE_WEAPON_AC_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_FIGHTSTYLE_SHIELD_BC_PERCENT); + case SkillCollection.SKILL_SPECIALIZATION_DUAL_WIELD: return res.getString(R.string.skill_longdescription_specialization_dualwield, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_DUALWIELD_AC_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_DUALWIELD_BC_PERCENT); + case SkillCollection.SKILL_SPECIALIZATION_2HAND: return res.getString(R.string.skill_longdescription_specialization_2hand, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_2HAND_DMG_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_2HAND_AC_PERCENT); + case SkillCollection.SKILL_SPECIALIZATION_WEAPON_SHIELD: return res.getString(R.string.skill_longdescription_specialization_weapon_shield, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_WEAPON_AC_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_WEAPON_DMG_PERCENT); default: return ""; } diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java index 9106d6ddf..51510a916 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java @@ -195,28 +195,28 @@ public final class SkillController { ItemType mainWeapon = ItemController.getMainWeapon(player); if (mainWeapon != null) { - playerTraits.attackChance += 10 * getSkillLevelForItemType(player, mainWeapon); + playerTraits.attackChance += SkillCollection.PER_SKILLPOINT_INCREASE_WEAPON_PROF_AC * getSkillLevelForItemType(player, mainWeapon); } final int unarmedLevel = player.getSkillLevel(SkillCollection.SKILL_WEAPON_PROFICIENCY_UNARMED); if (unarmedLevel > 0) { if (isUnarmed(player)) { - playerTraits.attackChance += 20 * unarmedLevel; - playerTraits.damagePotential.addToMax(2 * unarmedLevel); - playerTraits.damagePotential.add(2 * unarmedLevel, false); - playerTraits.blockChance += 5 * unarmedLevel; + playerTraits.attackChance += SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_AC * unarmedLevel; + playerTraits.damagePotential.addToMax(SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_DMG * unarmedLevel); + playerTraits.damagePotential.add(SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_DMG * unarmedLevel, false); + playerTraits.blockChance += SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_BC * unarmedLevel; } } ItemType shield = player.inventory.wear[Inventory.WEARSLOT_SHIELD]; if (shield != null && shield.isShield()) { - playerTraits.damageResistance += getSkillLevelForItemType(player, shield); + playerTraits.damageResistance += SkillCollection.PER_SKILLPOINT_INCREASE_SHIELD_PROF_DR * getSkillLevelForItemType(player, shield); } final int unarmoredLevel = player.getSkillLevel(SkillCollection.SKILL_ARMOR_PROFICIENCY_UNARMORED); if (unarmoredLevel > 0) { if (isUnarmored(player)) { - playerTraits.blockChance += 10 * unarmoredLevel; + playerTraits.blockChance += SkillCollection.PER_SKILLPOINT_INCREASE_UNARMORED_BC * unarmoredLevel; } } @@ -232,13 +232,13 @@ public final class SkillController { int skill = getProficiencySkillForItemCategory(itemType.category); if (skill == SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT) { if (skillLevelLightArmor > 0) { - playerTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, 30 * skillLevelLightArmor); + playerTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, SkillCollection.PER_SKILLPOINT_INCREASE_LIGHT_ARMOR_BC_PERCENT * skillLevelLightArmor); } } else if (skill == SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY) { if (skillLevelHeavyArmor > 0) { - playerTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, 10 * skillLevelHeavyArmor); - player.actorTraits.moveCost -= getPercentage(itemType.effects_equip.moveCostPenalty, 25 * skillLevelHeavyArmor); - playerTraits.attackCost -= getPercentage(itemType.effects_equip.combatProficiency.attackCost, 25 * skillLevelHeavyArmor); + playerTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_BC_PERCENT * skillLevelHeavyArmor); + player.actorTraits.moveCost -= getPercentage(itemType.effects_equip.moveCostPenalty, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_MOVECOST_PERCENT * skillLevelHeavyArmor); + playerTraits.attackCost -= getPercentage(itemType.effects_equip.combatProficiency.attackCost, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_ATKCOST_PERCENT * skillLevelHeavyArmor); } } } @@ -301,18 +301,18 @@ public final class SkillController { if (isWielding2HandItem(mainHandItem, offHandItem)) { int skillLevelFightStyle = player.getSkillLevel(SkillCollection.SKILL_FIGHTSTYLE_2HAND); int skillLevelSpecialization = player.getSkillLevel(SkillCollection.SKILL_SPECIALIZATION_2HAND); - addPercentDamage(playerTraits, mainHandItem, skillLevelFightStyle * 50); - addPercentDamage(playerTraits, mainHandItem, skillLevelSpecialization * 50); - addPercentAttackChance(playerTraits, mainHandItem, skillLevelSpecialization * 20); + addPercentDamage(playerTraits, mainHandItem, skillLevelFightStyle * SkillCollection.PER_SKILLPOINT_INCREASE_FIGHTSTYLE_2HAND_DMG_PERCENT); + addPercentDamage(playerTraits, mainHandItem, skillLevelSpecialization * SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_2HAND_DMG_PERCENT); + addPercentAttackChance(playerTraits, mainHandItem, skillLevelSpecialization * SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_2HAND_AC_PERCENT); } if (isWieldingWeaponAndShield(mainHandItem, offHandItem)) { int skillLevelFightStyle = player.getSkillLevel(SkillCollection.SKILL_FIGHTSTYLE_WEAPON_SHIELD); int skillLevelSpecialization = player.getSkillLevel(SkillCollection.SKILL_SPECIALIZATION_WEAPON_SHIELD); - addPercentAttackChance(playerTraits, mainHandItem, skillLevelFightStyle * 50); - addPercentBlockChance(playerTraits, offHandItem, skillLevelFightStyle * 50); - addPercentAttackChance(playerTraits, mainHandItem, skillLevelSpecialization * 20); - addPercentBlockChance(playerTraits, mainHandItem, skillLevelSpecialization * 50); + addPercentAttackChance(playerTraits, mainHandItem, skillLevelFightStyle * SkillCollection.PER_SKILLPOINT_INCREASE_FIGHTSTYLE_WEAPON_AC_PERCENT); + addPercentBlockChance(playerTraits, offHandItem, skillLevelFightStyle * SkillCollection.PER_SKILLPOINT_INCREASE_FIGHTSTYLE_SHIELD_BC_PERCENT); + addPercentAttackChance(playerTraits, mainHandItem, skillLevelSpecialization * SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_WEAPON_AC_PERCENT); + addPercentDamage(playerTraits, mainHandItem, skillLevelSpecialization * SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_WEAPON_DMG_PERCENT); } if (isDualWielding(mainHandItem, offHandItem)) { @@ -322,18 +322,18 @@ public final class SkillController { int attackCostMainHand = mainHandItem.effects_equip.combatProficiency.attackCost; int percent; if (skillLevelFightStyle == 2) { - percent = 100; + percent = SkillCollection.DUALWIELD_EFFICIENCY_LEVEL2; playerTraits.attackCost = Math.max(attackCostMainHand, offHandCombatTraits.attackCost); } else if (skillLevelFightStyle == 1) { - percent = 50; - playerTraits.attackCost = attackCostMainHand + getPercentage(offHandCombatTraits.attackCost, 50); + percent = SkillCollection.DUALWIELD_EFFICIENCY_LEVEL1; + playerTraits.attackCost = attackCostMainHand + getPercentage(offHandCombatTraits.attackCost, SkillCollection.DUALWIELD_LEVEL1_OFFHAND_AP_COST_PERCENT); } else { - percent = 25; + percent = SkillCollection.DUALWIELD_EFFICIENCY_LEVEL0; playerTraits.attackCost = attackCostMainHand + offHandCombatTraits.attackCost; } int attackChance = offHandCombatTraits.attackChance; - attackChance += 10 * getSkillLevelForItemType(player, offHandItem); + attackChance += SkillCollection.PER_SKILLPOINT_INCREASE_WEAPON_PROF_AC * getSkillLevelForItemType(player, offHandItem); playerTraits.attackChance += (int) FloatMath.floor(attackChance * percent / 100.0f); playerTraits.blockChance += (int) FloatMath.floor(offHandCombatTraits.blockChance * percent / 100.0f); @@ -343,10 +343,10 @@ public final class SkillController { } int skillLevelSpecialization = player.getSkillLevel(SkillCollection.SKILL_SPECIALIZATION_DUAL_WIELD); - addPercentAttackChance(playerTraits, mainHandItem, skillLevelSpecialization * 50); - addPercentBlockChance(playerTraits, mainHandItem, skillLevelSpecialization * 50); - addPercentAttackChance(playerTraits, offHandItem, skillLevelSpecialization * 50); - addPercentBlockChance(playerTraits, offHandItem, skillLevelSpecialization * 50); + addPercentAttackChance(playerTraits, mainHandItem, skillLevelSpecialization * SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_DUALWIELD_AC_PERCENT); + addPercentBlockChance(playerTraits, mainHandItem, skillLevelSpecialization * SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_DUALWIELD_BC_PERCENT); + addPercentAttackChance(playerTraits, offHandItem, skillLevelSpecialization * SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_DUALWIELD_AC_PERCENT); + addPercentBlockChance(playerTraits, offHandItem, skillLevelSpecialization * SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_DUALWIELD_BC_PERCENT); } } diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java index f5e0d1aab..fcd0f6975 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java @@ -84,6 +84,29 @@ public final class SkillCollection { public static final int TAUNT_AP_LOSS = 2; public static final int CONCUSSION_THRESHOLD = 50; public static final int PER_SKILLPOINT_INCREASE_CONCUSSION_CHANCE = 15; + public static final int PER_SKILLPOINT_INCREASE_WEAPON_PROF_AC = 10; + public static final int PER_SKILLPOINT_INCREASE_UNARMED_AC = 20; + public static final int PER_SKILLPOINT_INCREASE_UNARMED_DMG = 2; + public static final int PER_SKILLPOINT_INCREASE_UNARMED_BC = 5; + public static final int PER_SKILLPOINT_INCREASE_SHIELD_PROF_DR = 1; + public static final int PER_SKILLPOINT_INCREASE_UNARMORED_BC = 10; + public static final int PER_SKILLPOINT_INCREASE_LIGHT_ARMOR_BC_PERCENT = 30; + public static final int PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_BC_PERCENT = 10; + public static final int PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_MOVECOST_PERCENT = 25; + public static final int PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_ATKCOST_PERCENT = 25; + public static final int PER_SKILLPOINT_INCREASE_FIGHTSTYLE_2HAND_DMG_PERCENT = 50; + public static final int PER_SKILLPOINT_INCREASE_SPECIALIZATION_2HAND_DMG_PERCENT = 50; + public static final int PER_SKILLPOINT_INCREASE_SPECIALIZATION_2HAND_AC_PERCENT = 20; + public static final int PER_SKILLPOINT_INCREASE_FIGHTSTYLE_WEAPON_AC_PERCENT = 50; + public static final int PER_SKILLPOINT_INCREASE_FIGHTSTYLE_SHIELD_BC_PERCENT = 50; + public static final int PER_SKILLPOINT_INCREASE_SPECIALIZATION_WEAPON_AC_PERCENT = 50; + public static final int PER_SKILLPOINT_INCREASE_SPECIALIZATION_WEAPON_DMG_PERCENT = 20; + public static final int DUALWIELD_EFFICIENCY_LEVEL2 = 100; + public static final int DUALWIELD_EFFICIENCY_LEVEL1 = 50; + public static final int DUALWIELD_EFFICIENCY_LEVEL0 = 25; + public static final int DUALWIELD_LEVEL1_OFFHAND_AP_COST_PERCENT = 50; + public static final int PER_SKILLPOINT_INCREASE_SPECIALIZATION_DUALWIELD_AC_PERCENT = 50; + public static final int PER_SKILLPOINT_INCREASE_SPECIALIZATION_DUALWIELD_BC_PERCENT = 50; private static final int MAX_LEVEL_BARTER = (int) Math.floor((float) Constants.MARKET_PRICEFACTOR_PERCENT / PER_SKILLPOINT_INCREASE_BARTER_PRICEFACTOR_PERCENTAGE); private static final int MAX_LEVEL_BARKSKIN = 5; From 61cbd29878dd1eb93798284d0ec435750eb72c5f Mon Sep 17 00:00:00 2001 From: Oskar Wiksten Date: Mon, 1 Apr 2013 13:34:29 +0200 Subject: [PATCH 6/7] Fightstyles: Fix merge issues from master. --- .../controller/ItemController.java | 2 +- .../controller/SkillController.java | 56 ++++++++++--------- .../model/ability/SkillCollection.java | 32 +++++------ .../AndorsTrail/model/item/ItemCategory.java | 9 +-- 4 files changed, 51 insertions(+), 48 deletions(-) diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/ItemController.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/ItemController.java index f700a6bfe..01ee573fa 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/ItemController.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/ItemController.java @@ -144,7 +144,7 @@ public final class ItemController { SkillController.applySkillEffectsFromItemProficiencies(player); SkillController.applySkillEffectsFromFightingStyles(player); } - private static ItemType getMainWeapon(Player player) { + public static ItemType getMainWeapon(Player player) { ItemType itemType = player.inventory.wear[Inventory.WEARSLOT_WEAPON]; if (itemType != null) return itemType; itemType = player.inventory.wear[Inventory.WEARSLOT_SHIELD]; diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java index 51510a916..22ac33e40 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java @@ -9,6 +9,7 @@ import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionEffect; import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionType; import com.gpl.rpg.AndorsTrail.model.ability.SkillCollection; import com.gpl.rpg.AndorsTrail.model.ability.SkillInfo; +import com.gpl.rpg.AndorsTrail.model.ability.traits.AbilityModifierTraits; import com.gpl.rpg.AndorsTrail.model.actor.Actor; import com.gpl.rpg.AndorsTrail.model.actor.Monster; import com.gpl.rpg.AndorsTrail.model.actor.Player; @@ -191,7 +192,7 @@ public final class SkillController { } public static void applySkillEffectsFromItemProficiencies(Player player) { - CombatTraits playerTraits = player.combatTraits; + Player playerTraits = player; ItemType mainWeapon = ItemController.getMainWeapon(player); if (mainWeapon != null) { @@ -232,13 +233,13 @@ public final class SkillController { int skill = getProficiencySkillForItemCategory(itemType.category); if (skill == SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT) { if (skillLevelLightArmor > 0) { - playerTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, SkillCollection.PER_SKILLPOINT_INCREASE_LIGHT_ARMOR_BC_PERCENT * skillLevelLightArmor); + playerTraits.blockChance += getPercentage(itemType.effects_equip.stats.increaseBlockChance, SkillCollection.PER_SKILLPOINT_INCREASE_LIGHT_ARMOR_BC_PERCENT * skillLevelLightArmor); } } else if (skill == SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY) { if (skillLevelHeavyArmor > 0) { - playerTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_BC_PERCENT * skillLevelHeavyArmor); - player.actorTraits.moveCost -= getPercentage(itemType.effects_equip.moveCostPenalty, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_MOVECOST_PERCENT * skillLevelHeavyArmor); - playerTraits.attackCost -= getPercentage(itemType.effects_equip.combatProficiency.attackCost, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_ATKCOST_PERCENT * skillLevelHeavyArmor); + playerTraits.blockChance += getPercentage(itemType.effects_equip.stats.increaseBlockChance, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_BC_PERCENT * skillLevelHeavyArmor); + playerTraits.moveCost -= getPercentage(itemType.effects_equip.stats.increaseMoveCost, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_MOVECOST_PERCENT * skillLevelHeavyArmor); + playerTraits.attackCost -= getPercentage(itemType.effects_equip.stats.increaseAttackCost, SkillCollection.PER_SKILLPOINT_INCREASE_HEAVY_ARMOR_ATKCOST_PERCENT * skillLevelHeavyArmor); } } } @@ -259,7 +260,7 @@ public final class SkillController { private static boolean hasItemWithWeight(Player player, int slot) { ItemType itemType = player.inventory.wear[slot]; if (itemType == null) return false; - if (itemType.category.size == ItemCategory.SIZE_NONE) return false; + if (itemType.category.getSize() == ItemCategory.SIZE_NONE) return false; return true; } @@ -286,15 +287,16 @@ public final class SkillController { } else if (category.isShield()) { return SkillCollection.SKILL_ARMOR_PROFICIENCY_SHIELD; } else if (category.isArmor()) { - if (category.size == ItemCategory.SIZE_LIGHT) return SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT; - if (category.size == ItemCategory.SIZE_STD) return SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT; - if (category.size == ItemCategory.SIZE_LARGE) return SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY; + int size = category.getSize(); + if (size == ItemCategory.SIZE_LIGHT) return SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT; + if (size == ItemCategory.SIZE_STD) return SkillCollection.SKILL_ARMOR_PROFICIENCY_LIGHT; + if (size == ItemCategory.SIZE_LARGE) return SkillCollection.SKILL_ARMOR_PROFICIENCY_HEAVY; } return -1; } public static void applySkillEffectsFromFightingStyles(Player player) { - CombatTraits playerTraits = player.combatTraits; + Player playerTraits = player; ItemType mainHandItem = player.inventory.wear[Inventory.WEARSLOT_WEAPON]; ItemType offHandItem = player.inventory.wear[Inventory.WEARSLOT_SHIELD]; @@ -318,28 +320,28 @@ public final class SkillController { if (isDualWielding(mainHandItem, offHandItem)) { int skillLevelFightStyle = player.getSkillLevel(SkillCollection.SKILL_FIGHTSTYLE_DUAL_WIELD); if (offHandItem.effects_equip != null) { - CombatTraits offHandCombatTraits = offHandItem.effects_equip.combatProficiency; - int attackCostMainHand = mainHandItem.effects_equip.combatProficiency.attackCost; + AbilityModifierTraits offHandCombatTraits = offHandItem.effects_equip.stats; + int attackCostMainHand = mainHandItem.effects_equip.stats.increaseAttackCost; int percent; if (skillLevelFightStyle == 2) { percent = SkillCollection.DUALWIELD_EFFICIENCY_LEVEL2; - playerTraits.attackCost = Math.max(attackCostMainHand, offHandCombatTraits.attackCost); + playerTraits.attackCost = Math.max(attackCostMainHand, offHandCombatTraits.increaseAttackCost); } else if (skillLevelFightStyle == 1) { percent = SkillCollection.DUALWIELD_EFFICIENCY_LEVEL1; - playerTraits.attackCost = attackCostMainHand + getPercentage(offHandCombatTraits.attackCost, SkillCollection.DUALWIELD_LEVEL1_OFFHAND_AP_COST_PERCENT); + playerTraits.attackCost = attackCostMainHand + getPercentage(offHandCombatTraits.increaseAttackCost, SkillCollection.DUALWIELD_LEVEL1_OFFHAND_AP_COST_PERCENT); } else { percent = SkillCollection.DUALWIELD_EFFICIENCY_LEVEL0; - playerTraits.attackCost = attackCostMainHand + offHandCombatTraits.attackCost; + playerTraits.attackCost = attackCostMainHand + offHandCombatTraits.increaseAttackCost; } - int attackChance = offHandCombatTraits.attackChance; + int attackChance = offHandCombatTraits.increaseAttackChance; attackChance += SkillCollection.PER_SKILLPOINT_INCREASE_WEAPON_PROF_AC * getSkillLevelForItemType(player, offHandItem); playerTraits.attackChance += (int) FloatMath.floor(attackChance * percent / 100.0f); - playerTraits.blockChance += (int) FloatMath.floor(offHandCombatTraits.blockChance * percent / 100.0f); - playerTraits.damagePotential.addToMax((int) FloatMath.floor(offHandCombatTraits.damagePotential.max * percent / 100.0f)); - playerTraits.damagePotential.add((int) FloatMath.floor(offHandCombatTraits.damagePotential.current * percent / 100.0f), false); - playerTraits.criticalSkill += (int) FloatMath.floor(offHandCombatTraits.criticalSkill * percent / 100.0f); + playerTraits.blockChance += (int) FloatMath.floor(offHandCombatTraits.increaseBlockChance * percent / 100.0f); + playerTraits.damagePotential.addToMax((int) FloatMath.floor(offHandCombatTraits.increaseMaxDamage * percent / 100.0f)); + playerTraits.damagePotential.add((int) FloatMath.floor(offHandCombatTraits.increaseMinDamage * percent / 100.0f), false); + playerTraits.criticalSkill += (int) FloatMath.floor(offHandCombatTraits.increaseCriticalSkill * percent / 100.0f); } int skillLevelSpecialization = player.getSkillLevel(SkillCollection.SKILL_SPECIALIZATION_DUAL_WIELD); @@ -350,23 +352,23 @@ public final class SkillController { } } - private static void addPercentAttackChance(CombatTraits combatTraits, ItemType itemType, int percentToAdd) { + private static void addPercentAttackChance(Player player, ItemType itemType, int percentToAdd) { if (itemType.effects_equip == null) return; if (percentToAdd == 0) return; - combatTraits.attackChance += getPercentage(itemType.effects_equip.combatProficiency.attackChance, percentToAdd); + player.attackChance += getPercentage(itemType.effects_equip.stats.increaseAttackChance, percentToAdd); } - private static void addPercentBlockChance(CombatTraits combatTraits, ItemType itemType, int percentToAdd) { + private static void addPercentBlockChance(Player player, ItemType itemType, int percentToAdd) { if (itemType.effects_equip == null) return; if (percentToAdd == 0) return; - combatTraits.blockChance += getPercentage(itemType.effects_equip.combatProficiency.blockChance, percentToAdd); + player.blockChance += getPercentage(itemType.effects_equip.stats.increaseBlockChance, percentToAdd); } - private static void addPercentDamage(CombatTraits combatTraits, ItemType itemType, int percentToAdd) { + private static void addPercentDamage(Player player, ItemType itemType, int percentToAdd) { if (itemType.effects_equip == null) return; if (percentToAdd == 0) return; - combatTraits.damagePotential.addToMax(getPercentage(itemType.effects_equip.combatProficiency.damagePotential.max, percentToAdd)); - combatTraits.damagePotential.add(getPercentage(itemType.effects_equip.combatProficiency.damagePotential.current, percentToAdd), false); + player.damagePotential.addToMax(getPercentage(itemType.effects_equip.stats.increaseMaxDamage, percentToAdd)); + player.damagePotential.add(getPercentage(itemType.effects_equip.stats.increaseMinDamage, percentToAdd), false); } private static int getPercentage(int originalValue, int percentToAdd) { diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java index fcd0f6975..9146a9b39 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/ability/SkillCollection.java @@ -184,34 +184,34 @@ public final class SkillCollection { ,SkillLevelRequirement.requireOtherSkill(SKILL_WEAPON_CHANCE, 3) ,SkillLevelRequirement.requireOtherSkill(SKILL_WEAPON_DMG, 5) })); - initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_DAGGER, 3, false, null)); - initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_1HSWORD, 3, false, null)); - initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_2HSWORD, 3, false, null)); - initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_AXE, 3, false, null)); - initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_BLUNT, 3, false, null)); - initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_UNARMED, 3, false, null)); - initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_SHIELD, 2, false, null)); - initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_UNARMORED, 3, false, null)); - initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_LIGHT, 3, false, null)); - initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_HEAVY, 4, false, null)); - initializeSkill(new SkillInfo(SKILL_FIGHTSTYLE_DUAL_WIELD, 2, false, new SkillLevelRequirement[] { + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_DAGGER, 3, SkillInfo.LEVELUP_TYPE_FIRST_LEVEL_REQUIRES_QUEST, null)); + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_1HSWORD, 3, SkillInfo.LEVELUP_TYPE_FIRST_LEVEL_REQUIRES_QUEST, null)); + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_2HSWORD, 3, SkillInfo.LEVELUP_TYPE_FIRST_LEVEL_REQUIRES_QUEST, null)); + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_AXE, 3, SkillInfo.LEVELUP_TYPE_FIRST_LEVEL_REQUIRES_QUEST, null)); + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_BLUNT, 3, SkillInfo.LEVELUP_TYPE_FIRST_LEVEL_REQUIRES_QUEST, null)); + initializeSkill(new SkillInfo(SKILL_WEAPON_PROFICIENCY_UNARMED, 3, SkillInfo.LEVELUP_TYPE_FIRST_LEVEL_REQUIRES_QUEST, null)); + initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_SHIELD, 2, SkillInfo.LEVELUP_TYPE_FIRST_LEVEL_REQUIRES_QUEST, null)); + initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_UNARMORED, 3, SkillInfo.LEVELUP_TYPE_FIRST_LEVEL_REQUIRES_QUEST, null)); + initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_LIGHT, 3, SkillInfo.LEVELUP_TYPE_FIRST_LEVEL_REQUIRES_QUEST, null)); + initializeSkill(new SkillInfo(SKILL_ARMOR_PROFICIENCY_HEAVY, 4, SkillInfo.LEVELUP_TYPE_FIRST_LEVEL_REQUIRES_QUEST, null)); + initializeSkill(new SkillInfo(SKILL_FIGHTSTYLE_DUAL_WIELD, 2, SkillInfo.LEVELUP_TYPE_ALWAYS_SHOWN, new SkillLevelRequirement[] { SkillLevelRequirement.requireExperienceLevels(15, 0) })); - initializeSkill(new SkillInfo(SKILL_FIGHTSTYLE_2HAND, 2, false, new SkillLevelRequirement[] { + initializeSkill(new SkillInfo(SKILL_FIGHTSTYLE_2HAND, 2, SkillInfo.LEVELUP_TYPE_ALWAYS_SHOWN, new SkillLevelRequirement[] { SkillLevelRequirement.requireExperienceLevels(15, 0) })); - initializeSkill(new SkillInfo(SKILL_FIGHTSTYLE_WEAPON_SHIELD, 2, false, new SkillLevelRequirement[] { + initializeSkill(new SkillInfo(SKILL_FIGHTSTYLE_WEAPON_SHIELD, 2, SkillInfo.LEVELUP_TYPE_ALWAYS_SHOWN, new SkillLevelRequirement[] { SkillLevelRequirement.requireExperienceLevels(15, 0) })); - initializeSkill(new SkillInfo(SKILL_SPECIALIZATION_DUAL_WIELD, 1, false, new SkillLevelRequirement[] { + initializeSkill(new SkillInfo(SKILL_SPECIALIZATION_DUAL_WIELD, 1, SkillInfo.LEVELUP_TYPE_ALWAYS_SHOWN, new SkillLevelRequirement[] { SkillLevelRequirement.requireExperienceLevels(45, 0) ,SkillLevelRequirement.requireOtherSkill(SKILL_FIGHTSTYLE_DUAL_WIELD, 2) })); - initializeSkill(new SkillInfo(SKILL_SPECIALIZATION_2HAND, 1, false, new SkillLevelRequirement[] { + initializeSkill(new SkillInfo(SKILL_SPECIALIZATION_2HAND, 1, SkillInfo.LEVELUP_TYPE_ALWAYS_SHOWN, new SkillLevelRequirement[] { SkillLevelRequirement.requireExperienceLevels(45, 0) ,SkillLevelRequirement.requireOtherSkill(SKILL_FIGHTSTYLE_2HAND, 2) })); - initializeSkill(new SkillInfo(SKILL_SPECIALIZATION_WEAPON_SHIELD, 1, false, new SkillLevelRequirement[] { + initializeSkill(new SkillInfo(SKILL_SPECIALIZATION_WEAPON_SHIELD, 1, SkillInfo.LEVELUP_TYPE_ALWAYS_SHOWN, new SkillLevelRequirement[] { SkillLevelRequirement.requireExperienceLevels(45, 0) ,SkillLevelRequirement.requireOtherSkill(SKILL_FIGHTSTYLE_WEAPON_SHIELD, 2) })); diff --git a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/item/ItemCategory.java b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/item/ItemCategory.java index 824b26058..8dc37ab9e 100644 --- a/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/item/ItemCategory.java +++ b/AndorsTrail/src/com/gpl/rpg/AndorsTrail/model/item/ItemCategory.java @@ -23,20 +23,21 @@ public final class ItemCategory { private static final int ACTIONTYPE_NONE = 0; private static final int ACTIONTYPE_USE = 1; private static final int ACTIONTYPE_EQUIP = 2; + public int getSize() { return size; } public boolean isEquippable() { return actionType == ACTIONTYPE_EQUIP; } public boolean isUsable() { return actionType == ACTIONTYPE_USE; } public boolean isWeapon() { return inventorySlot == Inventory.WEARSLOT_WEAPON; } public boolean isShield() { return inventorySlot == Inventory.WEARSLOT_SHIELD; } public boolean isArmor() { return Inventory.isArmorSlot(inventorySlot); } public boolean isTwohandWeapon() { - /*if (!isWeapon()) return false; + if (!isWeapon()) return false; else if (size == SIZE_LARGE) return true; - else*/ return false; + else return false; } public boolean isOffhandCapableWeapon() { - /*if (!isWeapon()) return false; + if (!isWeapon()) return false; else if (size == SIZE_LIGHT) return true; else if (size == SIZE_STD) return true; - else*/ return false; + else return false; } } From 9d1720e19d16970d8da478d5f77138f7a947d68b Mon Sep 17 00:00:00 2001 From: Oskar Wiksten Date: Wed, 12 Jun 2013 23:46:36 +0200 Subject: [PATCH 7/7] Change "fighting bare hands" to "fighting unarmed". --- AndorsTrail/res/values/strings.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/AndorsTrail/res/values/strings.xml b/AndorsTrail/res/values/strings.xml index 837d8871b..08ac9aaa2 100644 --- a/AndorsTrail/res/values/strings.xml +++ b/AndorsTrail/res/values/strings.xml @@ -588,7 +588,7 @@ Better at fighting with two-handed swords Better at fighting with axes Better at fighting with bludgeoning weapons - Better at fighting with bare hands + Better at fighting without weapons Make better use of shields Better at fighting without armor Make better use of light armor