OMGeeky/andors-trail
1
0
Fork 0
mirror of https://github.com/OMGeeky/andors-trail.git synced 2026-02-23 15:38:29 +01:00
Code Issues 1 Packages Projects Releases Wiki Activity

Fixed issue with critical multipliers from main-hand weapons.

Browse Source 
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.
This commit is contained in:
Oskar Wiksten
2012-06-24 01:11:33 +02:00
parent 1bd20564fd
commit 83af64b4a3
1 changed files with 80 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

181
AndorsTrail/src/com/gpl/rpg/AndorsTrail/controller/SkillController.java
View File

@@ -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) {