Accessory augmentation part 1. Skills generation not supported and disabled.

L2_GameServer/java/config/Character.properties

@@ -314,6 +314,8 @@ AugmentationNGSkillChance = 15
 AugmentationMidSkillChance = 30
 AugmentationHighSkillChance = 45
 AugmentationTopSkillChance = 60
+# Accessory augmentation skills currently disabled
+AugmentationAccSkillChance = 0
 
 # This controls the chance to get a base stat modifier in the augmentation process.
 # Notes:
@@ -330,6 +332,11 @@ AugmentationMidGlowChance = 40
 AugmentationHighGlowChance = 70
 AugmentationTopGlowChance = 100
 
+# List of non-augmentable items, currently contains only Grand Boss jewels
+# Shadow, common, time-limited, hero, pvp, wear items are hardcoded, as well as all etcitems.
+# Rods can't be augmented too.
+# Default: 6656,6657,6658,6659,6660,6661,6662,8191,10170,10314
+AugmentationBlackList = 6656,6657,6658,6659,6660,6661,6662,8191,10170,10314
 
 # ---------------------------------------------------------------------------
 # Karma

L2_GameServer/java/net/sf/l2j/Config.java

@@ -827,6 +827,8 @@ public final class Config
 	public static int AUGMENTATION_TOP_SKILL_CHANCE;
 	public static int AUGMENTATION_TOP_GLOW_CHANCE;
 	public static int AUGMENTATION_BASESTAT_CHANCE;
+	public static int AUGMENTATION_ACC_SKILL_CHANCE;
+	public static int[] AUGMENTATION_BLACKLIST;
 	public static double HP_REGEN_MULTIPLIER;
 	public static double MP_REGEN_MULTIPLIER;
 	public static double CP_REGEN_MULTIPLIER;
@@ -1251,6 +1253,16 @@ public final class Config
 					AUGMENTATION_TOP_SKILL_CHANCE = Integer.parseInt(Character.getProperty("AugmentationTopSkillChance", "60"));
 					AUGMENTATION_TOP_GLOW_CHANCE = Integer.parseInt(Character.getProperty("AugmentationTopGlowChance", "100"));
 					AUGMENTATION_BASESTAT_CHANCE = Integer.parseInt(Character.getProperty("AugmentationBaseStatChance", "1"));
+					AUGMENTATION_ACC_SKILL_CHANCE = Integer.parseInt(Character.getProperty("AugmentationAccSkillChance", "0"));
+
+					String[] array = Character.getProperty("AugmentationBlackList", "6656,6657,6658,6659,6660,6661,6662,8191,10170,10314").split(",");
+					AUGMENTATION_BLACKLIST = new int[array.length];
+					
+					for (int i = 0; i < array.length; i++)
+						AUGMENTATION_BLACKLIST[i] = Integer.parseInt(array[i]);
+					
+					Arrays.sort(AUGMENTATION_BLACKLIST);
+
 					ALT_GAME_KARMA_PLAYER_CAN_BE_KILLED_IN_PEACEZONE = Boolean.parseBoolean(Character.getProperty("AltKarmaPlayerCanBeKilledInPeaceZone", "false"));
 					ALT_GAME_KARMA_PLAYER_CAN_SHOP = Boolean.parseBoolean(Character.getProperty("AltKarmaPlayerCanShop", "true"));
 					ALT_GAME_KARMA_PLAYER_CAN_TELEPORT = Boolean.parseBoolean(Character.getProperty("AltKarmaPlayerCanTeleport", "true"));

L2_GameServer/java/net/sf/l2j/gameserver/datatables/AugmentationData.java

@@ -14,8 +14,10 @@
  */
 package net.sf.l2j.gameserver.datatables;
 
+import gnu.trove.TIntObjectHashMap;
+
 import java.io.File;
-import java.util.Map;
+import java.util.ArrayList;
 import java.util.StringTokenizer;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -23,11 +25,12 @@ import java.util.logging.Logger;
 import javax.xml.parsers.DocumentBuilderFactory;
 
 import javolution.util.FastList;
-import javolution.util.FastMap;
 import net.sf.l2j.Config;
 import net.sf.l2j.gameserver.model.L2Augmentation;
 import net.sf.l2j.gameserver.model.L2Skill;
+import net.sf.l2j.gameserver.network.clientpackets.AbstractRefinePacket;
 import net.sf.l2j.gameserver.skills.Stats;
+import net.sf.l2j.gameserver.templates.item.L2Item;
 import net.sf.l2j.util.Rnd;
 
 import org.w3c.dom.Document;
@@ -80,7 +83,7 @@ public class AugmentationData
 	private static final int ACC_START = 16669;
 	private static final int ACC_BLOCKS_NUM = 10;
 	private static final int ACC_STAT_SUBBLOCKSIZE = 21;
-	private static final int ACC_STAT_NUM = 6; 
+	private static final int ACC_STAT_NUM = 6;
 
 	private static final int ACC_RING_START = ACC_START;
 	private static final int ACC_RING_SKILLS = 18;
@@ -101,12 +104,15 @@ public class AugmentationData
 	private static final byte[] ACC_STATS1_MAP = new byte[ACC_STAT_SUBBLOCKSIZE];
 	private static final byte[] ACC_STATS2_MAP = new byte[ACC_STAT_SUBBLOCKSIZE];
 	
-	private FastList<?> _augmentationStats[];
-	private Map<Integer, FastList<augmentationSkill>> _blueSkills;
-	private Map<Integer, FastList<augmentationSkill>> _purpleSkills;
-	private Map<Integer, FastList<augmentationSkill>> _redSkills;
+	private ArrayList<?>[] _augStats = new ArrayList[4];
+	private ArrayList<?>[] _augAccStats = new ArrayList[4];
+
+	private ArrayList<?>[] _blueSkills = new ArrayList[10];
+	private ArrayList<?>[] _purpleSkills = new ArrayList[10];
+	private ArrayList<?>[] _redSkills = new ArrayList[10];
+	private ArrayList<?>[] _yellowSkills = new ArrayList[10];
 
-	private FastList<?> _augmentationAccStats[];
+	private TIntObjectHashMap<augmentationSkill> _allSkills = new TIntObjectHashMap<augmentationSkill>(); 
 
 	// =========================================================
 	// Constructor
@@ -114,17 +120,15 @@ public class AugmentationData
 	{
 		_log.info("Initializing AugmentationData.");
 		
-		_augmentationStats = new FastList[4];
-		_augmentationStats[0] = new FastList<augmentationStat>();
-		_augmentationStats[1] = new FastList<augmentationStat>();
-		_augmentationStats[2] = new FastList<augmentationStat>();
-		_augmentationStats[3] = new FastList<augmentationStat>();
+		_augStats[0] = new ArrayList<augmentationStat>();
+		_augStats[1] = new ArrayList<augmentationStat>();
+		_augStats[2] = new ArrayList<augmentationStat>();
+		_augStats[3] = new ArrayList<augmentationStat>();
 		
-		_augmentationAccStats = new FastList[4];
-		_augmentationAccStats[0] = new FastList<augmentationStat>();
-		_augmentationAccStats[1] = new FastList<augmentationStat>();
-		_augmentationAccStats[2] = new FastList<augmentationStat>();
-		_augmentationAccStats[3] = new FastList<augmentationStat>();
+		_augAccStats[0] = new ArrayList<augmentationStat>();
+		_augAccStats[1] = new ArrayList<augmentationStat>();
+		_augAccStats[2] = new ArrayList<augmentationStat>();
+		_augAccStats[3] = new ArrayList<augmentationStat>();
 
 		// Lookup tables structure: STAT1 represent first stat, STAT2 - second.
 		// If both values are the same - use solo stat, if different - combined.
@@ -159,10 +163,11 @@ public class AugmentationData
 		// 01-01,01-02,01-03,01-04,01-05
 		// 02-02,02-03,02-04,02-05
 		// 03-03,03-04,03-05
-		// 04-04,04-05
-		// 05-05
-		// First values always solo, next are combined
-		for (int i = 0; i < ACC_STAT_NUM; i++)
+		// 04-04 \
+		// 05-05 - order is changed here
+		// 04-05 /
+		// First values always solo, next are combined, except last 3 values
+		for (int i = 0; i < ACC_STAT_NUM - 2; i++)
 		{
 			for (int j = i; j < ACC_STAT_NUM; idx++, j++)
 			{
@@ -170,26 +175,30 @@ public class AugmentationData
 				ACC_STATS2_MAP[idx] = (byte)j;				
 			}
 		}
+		ACC_STATS1_MAP[idx] = 4;
+		ACC_STATS2_MAP[idx++] = 4;
+		ACC_STATS1_MAP[idx] = 5;
+		ACC_STATS2_MAP[idx++] = 5;
+		ACC_STATS1_MAP[idx] = 4;
+		ACC_STATS2_MAP[idx] = 5;
 
-		_blueSkills = new FastMap<Integer, FastList<augmentationSkill>>();
-		_purpleSkills = new FastMap<Integer, FastList<augmentationSkill>>();
-		_redSkills = new FastMap<Integer, FastList<augmentationSkill>>();
-		for (int i = 1; i <= 10; i++)
+		for (int i = 0; i < 10; i++)
 		{
-			_blueSkills.put(i, new FastList<augmentationSkill>());
-			_purpleSkills.put(i, new FastList<augmentationSkill>());
-			_redSkills.put(i, new FastList<augmentationSkill>());
+			_blueSkills[i] = new ArrayList<Integer>();
+			_purpleSkills[i] = new ArrayList<Integer>();
+			_redSkills[i] = new ArrayList<Integer>();
+			_yellowSkills[i] = new ArrayList<Integer>();
 		}
 		
 		load();
 		
 		// Use size*4: since theres 4 blocks of stat-data with equivalent size
-		_log.info("AugmentationData: Loaded: " + (_augmentationStats[0].size() * 4) + " augmentation stats.");
-		_log.info("AugmentationData: Loaded: " + (_augmentationAccStats[0].size() * 4) + " accessory augmentation stats.");
-		for (int i = 1; i <= 10; i++)
+		_log.info("AugmentationData: Loaded: " + (_augStats[0].size() * 4) + " augmentation stats.");
+		_log.info("AugmentationData: Loaded: " + (_augAccStats[0].size() * 4) + " accessory augmentation stats.");
+		for (int i = 0; i < 10; i++)
 		{
-			_log.info("AugmentationData: Loaded: " + _blueSkills.get(i).size() + " blue, " + _purpleSkills.get(i).size() + " purple and "
-					+ _redSkills.get(i).size() + " red skills for lifeStoneLevel " + i);
+			_log.info("AugmentationData: Loaded: " + _blueSkills[i].size() + " blue, " + _purpleSkills[i].size() + " purple and "
+					+ _redSkills[i].size() + " red skills for lifeStoneLevel " + i);
 		}
 	}
 	
@@ -200,24 +209,17 @@ public class AugmentationData
 	{
 		private int _skillId;
 		private int _skillLevel;
-		private int _augmentationSkillId;
 		
-		public augmentationSkill(int skillId, int skillLevel, int augmentationSkillId)
+		public augmentationSkill(int skillId, int skillLevel)
 		{
 			_skillId = skillId;
 			_skillLevel = skillLevel;
-			_augmentationSkillId = augmentationSkillId;
 		}
 		
 		public L2Skill getSkill()
 		{
 			return SkillTable.getInstance().getInfo(_skillId, _skillLevel);
 		}
-		
-		public int getAugmentationSkillId()
-		{
-			return _augmentationSkillId;
-		}
 	}
 	
 	public class augmentationStat
@@ -267,9 +269,6 @@ public class AugmentationData
 		}
 	}
 	
-	// =========================================================
-	// Method - Private
-	
 	@SuppressWarnings("unchecked")
 	private final void load()
 	{
@@ -341,16 +340,16 @@ public class AugmentationData
 								badAugmantData++;
 								continue;
 							}
-							int k = 1;
-							while ((augmentationId - k * SKILLS_BLOCKSIZE) >= BLUE_START)
-								k++;
-							
+							int k = (augmentationId - BLUE_START) / SKILLS_BLOCKSIZE;
+
 							if (type.equalsIgnoreCase("blue"))
-								_blueSkills.get(k).add(new augmentationSkill(skillId, skillLvL, augmentationId));
+								((ArrayList<Integer>)_blueSkills[k]).add(augmentationId);
 							else if (type.equalsIgnoreCase("purple"))
-								_purpleSkills.get(k).add(new augmentationSkill(skillId, skillLvL, augmentationId));
+								((ArrayList<Integer>)_purpleSkills[k]).add(augmentationId);
 							else
-								_redSkills.get(k).add(new augmentationSkill(skillId, skillLvL, augmentationId));
+								((ArrayList<Integer>)_redSkills[k]).add(augmentationId);
+
+							_allSkills.put(augmentationId, new augmentationSkill(skillId, skillLvL));
 						}
 					}
 				}
@@ -424,7 +423,7 @@ public class AugmentationData
 									}
 								}
 								// store this stat
-								((FastList<augmentationStat>) _augmentationStats[(i - 1)]).add(new augmentationStat(Stats.valueOfXml(statName), soloValues, combinedValues));
+								((ArrayList<augmentationStat>) _augStats[(i - 1)]).add(new augmentationStat(Stats.valueOfXml(statName), soloValues, combinedValues));
 							}
 						}
 					}
@@ -494,7 +493,7 @@ public class AugmentationData
 									}
 								}
 								// store this stat
-								((FastList<augmentationStat>) _augmentationAccStats[(i - 1)]).add(new augmentationStat(Stats.valueOfXml(statName), soloValues, combinedValues));
+								((ArrayList<augmentationStat>) _augAccStats[(i - 1)]).add(new augmentationStat(Stats.valueOfXml(statName), soloValues, combinedValues));
 							}
 						}
 					}
@@ -508,17 +507,28 @@ public class AugmentationData
 		}
 	}
 	
-	// =========================================================
-	// Properties - Public
-
 	/**
 	 * Generate a new random augmentation
 	 * @param item
 	 * @param lifeStoneLevel
 	 * @param lifeSoneGrade
+	 * @param bodyPart
 	 * @return L2Augmentation
 	 */
-	public L2Augmentation generateRandomAugmentation(int lifeStoneLevel, int lifeStoneGrade)
+	public L2Augmentation generateRandomAugmentation(int lifeStoneLevel, int lifeStoneGrade, int bodyPart)
+	{
+		switch (bodyPart)
+		{
+			case L2Item.SLOT_LR_FINGER:
+			case L2Item.SLOT_LR_EAR:
+			case L2Item.SLOT_NECK:
+				return generateRandomAccessoryAugmentation(lifeStoneLevel, bodyPart);
+			default:
+				return generateRandomWeaponAugmentation(lifeStoneLevel, lifeStoneGrade);
+		}
+	}
+
+	private L2Augmentation generateRandomWeaponAugmentation(int lifeStoneLevel, int lifeStoneGrade)
 	{
 		// Note that stat12 stands for stat 1 AND 2 (same for stat34 ;p )
 		// this is because a value can contain up to 2 stat modifications
@@ -528,40 +538,46 @@ public class AugmentationData
 		// Note: lifeStoneGrade: (0 means low grade, 3 top grade)
 		// First: determine whether we will add a skill/baseStatModifier or not
 		// because this determine which color could be the result 
-		int skill_Chance = 0;
+		int stat12 = 0;
 		int stat34 = 0;
 		boolean generateSkill = false;
 		boolean generateGlow = false;
-		int resultColor = 0;
-		//lifestonelevel is used for stat Id and skill level, but here the max level is 10
-		if (lifeStoneLevel > 10)
-			lifeStoneLevel = 10;
+
+		//lifestonelevel is used for stat Id and skill level, but here the max level is 9
+		lifeStoneLevel = Math.min(lifeStoneLevel, 9);
+
 		switch (lifeStoneGrade)
 		{
-			case 0:
-				skill_Chance = Config.AUGMENTATION_NG_SKILL_CHANCE;
+			case AbstractRefinePacket.GRADE_NONE:
+				if (Rnd.get(1, 100) <= Config.AUGMENTATION_NG_SKILL_CHANCE)
+					generateSkill = true;
 				if (Rnd.get(1, 100) <= Config.AUGMENTATION_NG_GLOW_CHANCE)
 					generateGlow = true;
 				break;
-			case 1:
-				skill_Chance = Config.AUGMENTATION_MID_SKILL_CHANCE;
+			case AbstractRefinePacket.GRADE_MID:
+				if (Rnd.get(1, 100) <= Config.AUGMENTATION_MID_SKILL_CHANCE)
+					generateSkill = true;
 				if (Rnd.get(1, 100) <= Config.AUGMENTATION_MID_GLOW_CHANCE)
 					generateGlow = true;
 				break;
-			case 2:
-				skill_Chance = Config.AUGMENTATION_HIGH_SKILL_CHANCE;
+			case AbstractRefinePacket.GRADE_HIGH:
+				if (Rnd.get(1, 100) <= Config.AUGMENTATION_HIGH_SKILL_CHANCE)
+					generateSkill = true;
 				if (Rnd.get(1, 100) <= Config.AUGMENTATION_HIGH_GLOW_CHANCE)
 					generateGlow = true;
 				break;
-			case 3:
-				skill_Chance = Config.AUGMENTATION_TOP_SKILL_CHANCE;
+			case AbstractRefinePacket.GRADE_TOP:
+				if (Rnd.get(1, 100) <= Config.AUGMENTATION_TOP_SKILL_CHANCE)
+					generateSkill = true;
 				if (Rnd.get(1, 100) <= Config.AUGMENTATION_TOP_GLOW_CHANCE)
 					generateGlow = true;
+				break;
+			case AbstractRefinePacket.GRADE_ACC:
+				if (Rnd.get(1, 100) <= Config.AUGMENTATION_ACC_SKILL_CHANCE)
+					generateSkill = true;
 		}
 		
-		if (Rnd.get(1, 100) <= skill_Chance)
-			generateSkill = true;
-		else if (Rnd.get(1, 100) <= Config.AUGMENTATION_BASESTAT_CHANCE)
+		if (!generateSkill && Rnd.get(1, 100) <= Config.AUGMENTATION_BASESTAT_CHANCE)
 			stat34 = Rnd.get(BASESTAT_STR, BASESTAT_MEN);
 		
 		// Second: decide which grade the augmentation result is going to have:
@@ -569,9 +585,9 @@ public class AugmentationData
 		// The chances used here are most likely custom,
 		// whats known is: you cant have yellow with skill(or baseStatModifier)
 		// noGrade stone can not have glow, mid only with skill, high has a chance(custom), top allways glow
+		int resultColor = Rnd.get(0, 100);
 		if (stat34 == 0 && !generateSkill)
 		{
-			resultColor = Rnd.get(0, 100);
 			if (resultColor <= (15 * lifeStoneGrade) + 40)
 				resultColor = 1;
 			else
@@ -579,7 +595,6 @@ public class AugmentationData
 		}
 		else
 		{
-			resultColor = Rnd.get(0, 100);
 			if (resultColor <= (10 * lifeStoneGrade) + 5 || stat34 != 0)
 				resultColor = 3;
 			else if (resultColor <= (10 * lifeStoneGrade) + 10)
@@ -587,7 +602,26 @@ public class AugmentationData
 			else
 				resultColor = 2;
 		}
-		
+
+		// generate a skill if neccessary
+		L2Skill skill = null;
+		if (generateSkill)
+		{
+			switch (resultColor)
+			{
+				case 1: // blue skill
+					stat34 = ((Integer)_blueSkills[lifeStoneLevel].get(Rnd.get(0, _blueSkills[lifeStoneLevel].size() - 1)));
+					break;
+				case 2: // purple skill
+					stat34 = ((Integer)_purpleSkills[lifeStoneLevel].get(Rnd.get(0, _purpleSkills[lifeStoneLevel].size() - 1)));
+					break;
+				case 3: // red skill
+					stat34 = ((Integer)_redSkills[lifeStoneLevel].get(Rnd.get(0, _redSkills[lifeStoneLevel].size() - 1)));
+					break;
+			}
+			skill = _allSkills.get(stat34).getSkill();
+		}
+
 		// Third: Calculate the subblock offset for the choosen color,
 		// and the level of the lifeStone
 		// from large number of retail augmentations:
@@ -609,64 +643,97 @@ public class AugmentationData
 		// D - strong glow, top grade LS?
 		
 		// is neither a skill nor basestat used for stat34? then generate a normal stat
-		int stat12 = 0;
-		if (stat34 == 0 && !generateSkill)
+		int offset;
+		if (stat34 == 0)
 		{
 			int temp = Rnd.get(2, 3);
 			int colorOffset = resultColor * (10 * STAT_SUBBLOCKSIZE) + temp * STAT_BLOCKSIZE + 1;
-			int offset = ((lifeStoneLevel - 1) * STAT_SUBBLOCKSIZE) + colorOffset;
+			offset = (lifeStoneLevel * STAT_SUBBLOCKSIZE) + colorOffset;
 			
 			stat34 = Rnd.get(offset, offset + STAT_SUBBLOCKSIZE - 1);
 			if (generateGlow && lifeStoneGrade >= 2)
-				offset = ((lifeStoneLevel - 1) * STAT_SUBBLOCKSIZE) + (temp - 2) * STAT_BLOCKSIZE + lifeStoneGrade
+				offset = (lifeStoneLevel * STAT_SUBBLOCKSIZE) + (temp - 2) * STAT_BLOCKSIZE + lifeStoneGrade
 						* (10 * STAT_SUBBLOCKSIZE) + 1;
 			else
-				offset = ((lifeStoneLevel - 1) * STAT_SUBBLOCKSIZE) + (temp - 2) * STAT_BLOCKSIZE + Rnd.get(0, 1)
+				offset = (lifeStoneLevel * STAT_SUBBLOCKSIZE) + (temp - 2) * STAT_BLOCKSIZE + Rnd.get(0, 1)
 						* (10 * STAT_SUBBLOCKSIZE) + 1;
-			stat12 = Rnd.get(offset, offset + STAT_SUBBLOCKSIZE - 1);
 		}
 		else
 		{
-			int offset;
 			if (!generateGlow)
-				offset = ((lifeStoneLevel - 1) * STAT_SUBBLOCKSIZE) + Rnd.get(0, 1) * STAT_BLOCKSIZE + 1;
+				offset = (lifeStoneLevel * STAT_SUBBLOCKSIZE) + Rnd.get(0, 1) * STAT_BLOCKSIZE + 1;
 			else
-				offset = ((lifeStoneLevel - 1) * STAT_SUBBLOCKSIZE) + Rnd.get(0, 1) * STAT_BLOCKSIZE + (lifeStoneGrade + resultColor) / 2
+				offset = (lifeStoneLevel * STAT_SUBBLOCKSIZE) + Rnd.get(0, 1) * STAT_BLOCKSIZE + (lifeStoneGrade + resultColor) / 2
 						* (10 * STAT_SUBBLOCKSIZE) + 1;
-			stat12 = Rnd.get(offset, offset + STAT_SUBBLOCKSIZE - 1);
 		}
+		stat12 = Rnd.get(offset, offset + STAT_SUBBLOCKSIZE - 1);
 		
-		// generate a skill if neccessary
+		if (Config.DEBUG)
+			_log.info("Augmentation success: stat12=" + stat12 + "; stat34=" + stat34 + "; resultColor=" + resultColor + "; level="
+					+ lifeStoneLevel + "; grade=" + lifeStoneGrade);
+		return new L2Augmentation(((stat34 << 16) + stat12), skill);
+	}
+
+	private L2Augmentation generateRandomAccessoryAugmentation(int lifeStoneLevel, int bodyPart)
+	{
+		int stat12 = 0;
+		int stat34 = 0;
+		int base = 0;
+		int skillsLength = 0;
+
+		lifeStoneLevel = Math.min(lifeStoneLevel, 9);
+
+		switch (bodyPart)
+		{
+			case L2Item.SLOT_LR_FINGER:
+				base = ACC_RING_START + ACC_RING_BLOCKSIZE * lifeStoneLevel;
+				skillsLength = ACC_RING_SKILLS;
+				break;
+			case L2Item.SLOT_LR_EAR:
+				base = ACC_EAR_START + ACC_EAR_BLOCKSIZE * lifeStoneLevel;
+				skillsLength = ACC_EAR_SKILLS;
+				break;
+			case L2Item.SLOT_NECK:
+				base = ACC_NECK_START + ACC_NECK_BLOCKSIZE * lifeStoneLevel;
+				skillsLength = ACC_NECK_SKILLS;
+				break;
+			default:
+				return null;
+		}
+
+		int resultColor = Rnd.get(0, 3);
 		L2Skill skill = null;
-		if (generateSkill)
+
+		// first augmentation (stats only)
+		stat12 = Rnd.get(ACC_STAT_SUBBLOCKSIZE);
+
+		if (Rnd.get(1, 100) <= Config.AUGMENTATION_ACC_SKILL_CHANCE)
 		{
-			augmentationSkill temp = null;
-			switch (resultColor)
-			{
-				case 1: // blue skill
-					temp = _blueSkills.get(lifeStoneLevel).get(Rnd.get(0, _blueSkills.get(lifeStoneLevel).size() - 1));
-					skill = temp.getSkill();
-					stat34 = temp.getAugmentationSkillId();
-					break;
-				case 2: // purple skill
-					temp = _purpleSkills.get(lifeStoneLevel).get(Rnd.get(0, _purpleSkills.get(lifeStoneLevel).size() - 1));
-					skill = temp.getSkill();
-					stat34 = temp.getAugmentationSkillId();
-					break;
-				case 3: // red skill
-					temp = _redSkills.get(lifeStoneLevel).get(Rnd.get(0, _redSkills.get(lifeStoneLevel).size() - 1));
-					skill = temp.getSkill();
-					stat34 = temp.getAugmentationSkillId();
-					break;
-			}
+			// second augmentation (skill)
+			stat34 = base + Rnd.get(skillsLength);
+			if (_allSkills.contains(stat34))
+				skill = _allSkills.get(stat34).getSkill();
 		}
-		
+
+		if (skill == null)
+		{
+			// second augmentation (stats)
+			// calculating any different from stat12 value inside sub-block
+			// starting from next and wrapping over using remainder
+			stat34 = (stat12 + 1 + Rnd.get(ACC_STAT_SUBBLOCKSIZE - 1)) % ACC_STAT_SUBBLOCKSIZE;
+			// this is a stats - skipping skills
+			stat34 = base + skillsLength + ACC_STAT_SUBBLOCKSIZE * resultColor + stat34;
+		}
+
+		// stat12 has stats only
+		stat12 = base + skillsLength + ACC_STAT_SUBBLOCKSIZE * resultColor + stat12;
+
 		if (Config.DEBUG)
-			_log.info("Augmentation success: stat12=" + stat12 + "; stat34=" + stat34 + "; resultColor=" + resultColor + "; level="
-					+ lifeStoneLevel + "; grade=" + lifeStoneGrade);
+			_log.info("Accessory augmentation success: stat12=" + stat12 + "; stat34=" + stat34 + "; level="
+					+ lifeStoneLevel);
 		return new L2Augmentation(((stat34 << 16) + stat12), skill);
 	}
-	
+
 	public class AugStat
 	{
 		private final Stats _stat;
@@ -725,14 +792,14 @@ public class AugmentationData
 				byte stat2 = STATS2_MAP[stat];
 				if (stat1 == stat2) // solo stat
 				{
-					augmentationStat as = ((augmentationStat) _augmentationStats[color].get(stat1));
+					augmentationStat as = ((augmentationStat) _augStats[color].get(stat1));
 					temp.add(new AugStat(as.getStat(), as.getSingleStatValue(level)));
 				}
 				else // combined stat
 				{
-					augmentationStat as = ((augmentationStat) _augmentationStats[color].get(stat1));					
+					augmentationStat as = ((augmentationStat) _augStats[color].get(stat1));					
 					temp.add(new AugStat(as.getStat(), as.getCombinedStatValue(level)));
-					as = ((augmentationStat) _augmentationStats[color].get(stat2));
+					as = ((augmentationStat) _augStats[color].get(stat2));
 					temp.add(new AugStat(as.getStat(), as.getCombinedStatValue(level)));
 				}
 			}
@@ -791,14 +858,14 @@ public class AugmentationData
 					byte stat2 = ACC_STATS2_MAP[stat];
 					if (stat1 == stat2) // solo
 					{
-						augmentationStat as = ((augmentationStat) _augmentationAccStats[color].get(stat1));					
+						augmentationStat as = ((augmentationStat) _augAccStats[color].get(stat1));					
 						temp.add(new AugStat(as.getStat(), as.getSingleStatValue(level)));
 					}
 					else // combined
 					{
-						augmentationStat as = ((augmentationStat) _augmentationAccStats[color].get(stat1));					
+						augmentationStat as = ((augmentationStat) _augAccStats[color].get(stat1));					
 						temp.add(new AugStat(as.getStat(), as.getCombinedStatValue(level)));
-						as = ((augmentationStat) _augmentationAccStats[color].get(stat2));
+						as = ((augmentationStat) _augAccStats[color].get(stat2));
 						temp.add(new AugStat(as.getStat(), as.getCombinedStatValue(level)));
 					}
 				}
@@ -807,7 +874,19 @@ public class AugmentationData
 		
 		return temp;
 	}
-	
+
+	/*
+	 * Returns skill by augmentation Id or null if not valid or not found
+	 */
+	public L2Skill getAugSkillById(int augmentationId)
+	{
+		final augmentationSkill temp = _allSkills.get(augmentationId); 
+		if (temp == null)
+			return null;
+
+		return temp.getSkill();
+	}
+
 	@SuppressWarnings("synthetic-access")
 	private static class SingletonHolder
 	{

L2_GameServer/java/net/sf/l2j/gameserver/network/clientpackets/AbstractRefinePacket.java

@@ -0,0 +1,398 @@
+/*
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package net.sf.l2j.gameserver.network.clientpackets;
+
+import java.util.Arrays;
+import java.util.Map;
+
+import javolution.util.FastMap;
+
+import net.sf.l2j.Config;
+import net.sf.l2j.gameserver.model.L2ItemInstance;
+import net.sf.l2j.gameserver.model.actor.instance.L2PcInstance;
+import net.sf.l2j.gameserver.network.SystemMessageId;
+import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
+import net.sf.l2j.gameserver.templates.item.L2Armor;
+import net.sf.l2j.gameserver.templates.item.L2Item;
+import net.sf.l2j.gameserver.templates.item.L2Weapon;
+import net.sf.l2j.gameserver.templates.item.L2WeaponType;
+
+public abstract class AbstractRefinePacket extends L2GameClientPacket
+{
+	public static final int GRADE_NONE = 0;
+	public static final int GRADE_MID = 1;
+	public static final int GRADE_HIGH = 2;
+	public static final int GRADE_TOP = 3;
+	public static final int GRADE_ACC = 4; // Accessory LS
+
+	protected static final int GEMSTONE_D = 2130;
+	protected static final int GEMSTONE_C = 2131;
+	protected static final int GEMSTONE_B = 2132;
+
+	private static final Map<Integer, LifeStone> _lifeStones = new FastMap<Integer, LifeStone>();
+
+	protected static final class LifeStone
+	{
+		// lifestone level to player level table
+		private static final int[] LEVELS = {46, 49, 52, 55, 58, 61, 64, 67, 70, 76, 80, 82, 84};
+		private final int _grade;
+		private final int _level;
+
+		public LifeStone(int grade, int level)
+		{
+			_grade = grade;
+			_level = level;
+		}
+
+		public final int getLevel()
+		{
+			return _level;
+		}
+
+		public final int getGrade()
+		{
+			return _grade;
+		}
+
+		public final int getPlayerLevel()
+		{
+			return LEVELS[_level];
+		}
+	}
+
+	static
+	{
+		// itemId, (LS grade, LS level) 
+		_lifeStones.put(8723, new LifeStone(GRADE_NONE, 0));
+		_lifeStones.put(8724, new LifeStone(GRADE_NONE, 1));
+		_lifeStones.put(8725, new LifeStone(GRADE_NONE, 2));
+		_lifeStones.put(8726, new LifeStone(GRADE_NONE, 3));
+		_lifeStones.put(8727, new LifeStone(GRADE_NONE, 4));
+		_lifeStones.put(8728, new LifeStone(GRADE_NONE, 5));
+		_lifeStones.put(8729, new LifeStone(GRADE_NONE, 6));
+		_lifeStones.put(8730, new LifeStone(GRADE_NONE, 7));
+		_lifeStones.put(8731, new LifeStone(GRADE_NONE, 8));
+		_lifeStones.put(8732, new LifeStone(GRADE_NONE, 9));
+
+		_lifeStones.put(8733, new LifeStone(GRADE_MID, 0));
+		_lifeStones.put(8734, new LifeStone(GRADE_MID, 1));
+		_lifeStones.put(8735, new LifeStone(GRADE_MID, 2));
+		_lifeStones.put(8736, new LifeStone(GRADE_MID, 3));
+		_lifeStones.put(8737, new LifeStone(GRADE_MID, 4));
+		_lifeStones.put(8738, new LifeStone(GRADE_MID, 5));
+		_lifeStones.put(8739, new LifeStone(GRADE_MID, 6));
+		_lifeStones.put(8740, new LifeStone(GRADE_MID, 7));
+		_lifeStones.put(8741, new LifeStone(GRADE_MID, 8));
+		_lifeStones.put(8742, new LifeStone(GRADE_MID, 9));
+
+		_lifeStones.put(8743, new LifeStone(GRADE_HIGH, 0));
+		_lifeStones.put(8744, new LifeStone(GRADE_HIGH, 1));
+		_lifeStones.put(8745, new LifeStone(GRADE_HIGH, 2));
+		_lifeStones.put(8746, new LifeStone(GRADE_HIGH, 3));
+		_lifeStones.put(8747, new LifeStone(GRADE_HIGH, 4));
+		_lifeStones.put(8748, new LifeStone(GRADE_HIGH, 5));
+		_lifeStones.put(8749, new LifeStone(GRADE_HIGH, 6));
+		_lifeStones.put(8750, new LifeStone(GRADE_HIGH, 7));
+		_lifeStones.put(8751, new LifeStone(GRADE_HIGH, 8));
+		_lifeStones.put(8752, new LifeStone(GRADE_HIGH, 9));
+
+		_lifeStones.put(8753, new LifeStone(GRADE_TOP, 0));
+		_lifeStones.put(8754, new LifeStone(GRADE_TOP, 1));
+		_lifeStones.put(8755, new LifeStone(GRADE_TOP, 2));
+		_lifeStones.put(8756, new LifeStone(GRADE_TOP, 3));
+		_lifeStones.put(8757, new LifeStone(GRADE_TOP, 4));
+		_lifeStones.put(8758, new LifeStone(GRADE_TOP, 5));
+		_lifeStones.put(8759, new LifeStone(GRADE_TOP, 6));
+		_lifeStones.put(8760, new LifeStone(GRADE_TOP, 7));
+		_lifeStones.put(8761, new LifeStone(GRADE_TOP, 8));
+		_lifeStones.put(8762, new LifeStone(GRADE_TOP, 9));
+
+		_lifeStones.put(9573, new LifeStone(GRADE_NONE, 10));
+		_lifeStones.put(9574, new LifeStone(GRADE_MID, 10));
+		_lifeStones.put(9575, new LifeStone(GRADE_HIGH, 10));
+		_lifeStones.put(9576, new LifeStone(GRADE_TOP, 10));
+
+		_lifeStones.put(10483, new LifeStone(GRADE_NONE, 11));
+		_lifeStones.put(10484, new LifeStone(GRADE_MID, 11));
+		_lifeStones.put(10485, new LifeStone(GRADE_HIGH, 11));
+		_lifeStones.put(10486, new LifeStone(GRADE_TOP, 11));
+
+		_lifeStones.put(12754, new LifeStone(GRADE_ACC, 0));
+		_lifeStones.put(12755, new LifeStone(GRADE_ACC, 1));
+		_lifeStones.put(12756, new LifeStone(GRADE_ACC, 2));
+		_lifeStones.put(12757, new LifeStone(GRADE_ACC, 3));
+		_lifeStones.put(12758, new LifeStone(GRADE_ACC, 4));
+		_lifeStones.put(12759, new LifeStone(GRADE_ACC, 5));
+		_lifeStones.put(12760, new LifeStone(GRADE_ACC, 6));
+		_lifeStones.put(12761, new LifeStone(GRADE_ACC, 7));
+		_lifeStones.put(12762, new LifeStone(GRADE_ACC, 8));
+		_lifeStones.put(12763, new LifeStone(GRADE_ACC, 9));
+
+		_lifeStones.put(12821, new LifeStone(GRADE_ACC, 10));
+		_lifeStones.put(12822, new LifeStone(GRADE_ACC, 11));
+
+		_lifeStones.put(12840, new LifeStone(GRADE_ACC, 0));
+		_lifeStones.put(12841, new LifeStone(GRADE_ACC, 1));
+		_lifeStones.put(12842, new LifeStone(GRADE_ACC, 2));
+		_lifeStones.put(12843, new LifeStone(GRADE_ACC, 3));
+		_lifeStones.put(12844, new LifeStone(GRADE_ACC, 4));
+		_lifeStones.put(12845, new LifeStone(GRADE_ACC, 5));
+		_lifeStones.put(12846, new LifeStone(GRADE_ACC, 6));
+		_lifeStones.put(12847, new LifeStone(GRADE_ACC, 7));
+		_lifeStones.put(12848, new LifeStone(GRADE_ACC, 8));
+		_lifeStones.put(12849, new LifeStone(GRADE_ACC, 9));
+		_lifeStones.put(12850, new LifeStone(GRADE_ACC, 10));
+		_lifeStones.put(12851, new LifeStone(GRADE_ACC, 11));
+
+		_lifeStones.put(14008, new LifeStone(GRADE_ACC, 12));
+
+		_lifeStones.put(14166, new LifeStone(GRADE_NONE, 12));
+		_lifeStones.put(14167, new LifeStone(GRADE_MID, 12));
+		_lifeStones.put(14168, new LifeStone(GRADE_HIGH, 12));
+		_lifeStones.put(14169, new LifeStone(GRADE_TOP, 12));
+	}
+
+	protected static final LifeStone getLifeStone(int itemId)
+	{
+		return _lifeStones.get(itemId);
+	}
+
+	/*
+	 * Checks player, source item, lifestone and gemstone validity for augmentation process
+	 */
+	protected static final boolean isValid(L2PcInstance player, L2ItemInstance item, L2ItemInstance refinerItem, L2ItemInstance gemStones)
+	{
+		if (!isValid(player, item, refinerItem))
+			return false;
+
+		// GemStones must belong to owner
+		if (gemStones.getOwnerId() != player.getObjectId())
+			return false;
+		// .. and located in inventory
+		if (gemStones.getLocation() != L2ItemInstance.ItemLocation.INVENTORY)
+			return false;
+
+		final int grade = item.getItem().getItemGrade();
+		final LifeStone ls = getLifeStone(refinerItem.getItemId());
+
+		// Check for item id
+		if (getGemStoneId(grade) != gemStones.getItemId())
+			return false;
+		// Count must be greater or equal of required number
+		if (getGemStoneCount(grade, ls.getGrade()) > gemStones.getCount())
+			return false;
+
+		return true;
+	}
+
+	/*
+	 * Checks player, source item and lifestone validity for augmentation process
+	 */
+	protected static final boolean isValid(L2PcInstance player, L2ItemInstance item, L2ItemInstance refinerItem)
+	{
+		if (!isValid(player, item))
+			return false;
+
+		// Item must belong to owner
+		if (refinerItem.getOwnerId() != player.getObjectId())
+			return false;
+		// Lifestone must be located in inventory
+		if (refinerItem.getLocation() != L2ItemInstance.ItemLocation.INVENTORY)
+			return false;
+
+		final LifeStone ls = getLifeStone(refinerItem.getItemId());
+		if (ls == null)
+			return false;
+		// weapons can't be augmented with accessory ls
+		if (item.getItem() instanceof L2Weapon && ls.getGrade() == GRADE_ACC)
+			return false;
+		// and accessory can't be augmented with weapon ls
+		if (item.getItem() instanceof L2Armor && ls.getGrade() != GRADE_ACC)
+			return false;
+		// check for level of the lifestone
+		if (player.getLevel() < ls.getPlayerLevel())
+			return false;
+
+		return true;
+	}
+
+	/*
+	 * Check both player and source item conditions for augmentation process
+	 */
+	protected static final boolean isValid(L2PcInstance player, L2ItemInstance item)
+	{
+		if (!isValid(player))
+			return false;
+
+		// Item must belong to owner
+		if (item.getOwnerId() != player.getObjectId())
+			return false;
+		if (item.isAugmented())
+			return false;
+		if (item.isHeroItem())
+			return false;
+		if (item.isShadowItem())
+			return false;
+		if (item.isCommonItem())
+			return false;
+		if (item.isEtcItem())
+			return false;
+		if (item.isTimeLimitedItem())
+			return false;
+		if (item.isWear())
+			return false;
+		if (item.isPvp())
+			return false;
+		if (item.getItem().getCrystalType() < L2Item.CRYSTAL_C)
+			return false;
+		if (item.getItem().getItemType() == L2WeaponType.ROD)
+			return false;
+
+		// Source item can be equipped or in inventory
+		if (item.getLocation() != L2ItemInstance.ItemLocation.INVENTORY
+				&& item.getLocation() != L2ItemInstance.ItemLocation.PAPERDOLL)
+			return false;
+
+		if (item.getItem() instanceof L2Armor)
+		{
+			// only accessories can be augmented
+			switch (item.getItem().getBodyPart())
+			{
+				case L2Item.SLOT_LR_FINGER:
+				case L2Item.SLOT_LR_EAR:
+				case L2Item.SLOT_NECK:
+					break;
+				default:
+					return false;
+			}
+		}
+
+		// blacklist check
+		if (Arrays.binarySearch(Config.AUGMENTATION_BLACKLIST, item.getItemId()) >= 0)
+			return false;
+
+		return true;
+	}
+
+	/*
+	 * Check if player's conditions valid for augmentation process
+	 */
+	protected static final boolean isValid(L2PcInstance player)
+	{
+		if (player.getPrivateStoreType() != L2PcInstance.STORE_PRIVATE_NONE)
+		{
+			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_A_PRIVATE_STORE_OR_PRIVATE_WORKSHOP_IS_IN_OPERATION));
+			return false;
+		}
+		if (player.getActiveTradeList() != null)
+		{
+			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_TRADING));
+			return false;
+		}
+		if (player.isDead())
+		{
+			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_DEAD));
+			return false;
+		}
+		if (player.isParalyzed())
+		{
+			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_PARALYZED));
+			return false;
+		}
+		if (player.isFishing())
+		{
+			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_FISHING));
+			return false;
+		}
+		if (player.isSitting())
+		{
+			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_SITTING_DOWN));
+			return false;
+		}
+		if (player.isCursedWeaponEquipped())
+			return false;
+		if (player.isEnchanting() || player.isProcessingTransaction())
+			return false;
+
+		return true;
+	}
+
+	/*
+	 * Returns GemStone itemId based on item grade
+	 */
+	protected static final int getGemStoneId(int itemGrade)
+	{
+		switch (itemGrade)
+		{
+			case L2Item.CRYSTAL_C:
+			case L2Item.CRYSTAL_B:
+				return GEMSTONE_D;
+			case L2Item.CRYSTAL_A:
+			case L2Item.CRYSTAL_S:
+				return GEMSTONE_C;
+			case L2Item.CRYSTAL_S80:
+			case L2Item.CRYSTAL_S84:
+				return GEMSTONE_B;
+			default:
+				return 0;
+		}
+	}
+
+	/*
+	 * Returns GemStone count based on item grade and lifestone grade
+	 * (different for weapon and accessory augmentation)
+	 */
+	protected static final int getGemStoneCount(int itemGrade, int lifeStoneGrade)
+	{
+		switch (lifeStoneGrade)
+		{
+			case GRADE_ACC:
+				switch (itemGrade)
+				{
+					case L2Item.CRYSTAL_C:
+						return 200;
+					case L2Item.CRYSTAL_B:
+						return 300;
+					case L2Item.CRYSTAL_A:
+						return 200;
+					case L2Item.CRYSTAL_S:
+						return 250;
+					case L2Item.CRYSTAL_S80:
+						return 360;
+					case L2Item.CRYSTAL_S84:
+						return 480;
+					default:
+						return 0;
+				}
+			default:
+				switch (itemGrade)
+				{
+					case L2Item.CRYSTAL_C:
+						return 20;
+					case L2Item.CRYSTAL_B:
+						return 30;
+					case L2Item.CRYSTAL_A:
+						return 20;
+					case L2Item.CRYSTAL_S:
+						return 25;
+					case L2Item.CRYSTAL_S80:
+					case L2Item.CRYSTAL_S84:
+						return 36;
+					default:
+						return 0;
+				}
+		}
+	}
+}

L2_GameServer/java/net/sf/l2j/gameserver/network/clientpackets/RequestConfirmGemStone.java

@@ -14,28 +14,24 @@
  */
 package net.sf.l2j.gameserver.network.clientpackets;
 
-import net.sf.l2j.Config;
 import net.sf.l2j.gameserver.model.L2ItemInstance;
 import net.sf.l2j.gameserver.model.L2World;
 import net.sf.l2j.gameserver.model.actor.instance.L2PcInstance;
 import net.sf.l2j.gameserver.network.SystemMessageId;
 import net.sf.l2j.gameserver.network.serverpackets.ExPutCommissionResultForVariationMake;
 import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
-import net.sf.l2j.gameserver.templates.item.L2Item;
-import net.sf.l2j.gameserver.util.Util;
 
 /**
  * Format:(ch) dddd
  * @author  -Wooden-
  */
-public final class RequestConfirmGemStone extends L2GameClientPacket
+public final class RequestConfirmGemStone extends AbstractRefinePacket
 {
 	private static final String _C__D0_2B_REQUESTCONFIRMGEMSTONE = "[C] D0:2B RequestConfirmGemStone";
 	private int _targetItemObjId;
 	private int _refinerItemObjId;
 	private int _gemstoneItemObjId;
-	private long _gemstoneCount;
-
+	private long _gemStoneCount;
 
 	/**
 	 * @param buf
@@ -47,7 +43,7 @@ public final class RequestConfirmGemStone extends L2GameClientPacket
 		_targetItemObjId = readD();
 		_refinerItemObjId = readD();
 		_gemstoneItemObjId = readD();
-		_gemstoneCount= readQ();
+		_gemStoneCount= readQ();
 	}
 
 	/**
@@ -57,69 +53,38 @@ public final class RequestConfirmGemStone extends L2GameClientPacket
 	protected
 	void runImpl()
 	{
-		L2PcInstance activeChar = getClient().getActiveChar();
+		final L2PcInstance activeChar = getClient().getActiveChar();
+		if (activeChar == null)
+			return;
 		L2ItemInstance targetItem = (L2ItemInstance)L2World.getInstance().findObject(_targetItemObjId);
+		if (targetItem == null)
+			return;
 		L2ItemInstance refinerItem = (L2ItemInstance)L2World.getInstance().findObject(_refinerItemObjId);
-		L2ItemInstance gemstoneItem = (L2ItemInstance)L2World.getInstance().findObject(_gemstoneItemObjId);
-
-		if (targetItem == null || refinerItem == null || gemstoneItem == null) return;
-		if (targetItem.getOwnerId() != activeChar.getObjectId()
-			|| refinerItem.getOwnerId() != activeChar.getObjectId()
-			|| gemstoneItem.getOwnerId() != activeChar.getObjectId())
-		{
-			Util.handleIllegalPlayerAction(getClient().getActiveChar(),"Warning!! Character "+getClient().getActiveChar().getName()+" of account "+getClient().getActiveChar().getAccountName()+" tryied to use gemstones on augment that doesn't own.",Config.DEFAULT_PUNISH);
+		if (refinerItem == null)
 			return;
-		}
+		L2ItemInstance gemStoneItem = (L2ItemInstance)L2World.getInstance().findObject(_gemstoneItemObjId);
+		if (gemStoneItem == null)
+			return;
+
 		// Make sure the item is a gemstone
-		int gemstoneItemId = gemstoneItem.getItem().getItemId();
-		if (gemstoneItemId != 2130 && gemstoneItemId != 2131 && gemstoneItemId != 2132)
+		if (!isValid(activeChar, targetItem, refinerItem, gemStoneItem))
 		{
 			activeChar.sendPacket(new SystemMessage(SystemMessageId.THIS_IS_NOT_A_SUITABLE_ITEM));
 			return;
 		}
 
-		// Check if the gemstoneCount is sufficant
-		switch (targetItem.getItem().getCrystalType())
+		// Check for gemstone count
+		final LifeStone ls = getLifeStone(refinerItem.getItemId());
+		if (ls == null)
+			return;
+
+		if (_gemStoneCount != getGemStoneCount(targetItem.getItem().getItemGrade(), ls.getGrade()))
 		{
-			case L2Item.CRYSTAL_C:
-				if (_gemstoneCount != 20 || gemstoneItemId != 2130)
-				{
-					activeChar.sendPacket(new SystemMessage(SystemMessageId.GEMSTONE_QUANTITY_IS_INCORRECT));
-					return;
-				}
-				break;
-			case L2Item.CRYSTAL_B:
-				if (_gemstoneCount != 30 || gemstoneItemId != 2130)
-				{
-					activeChar.sendPacket(new SystemMessage(SystemMessageId.GEMSTONE_QUANTITY_IS_INCORRECT));
-					return;
-				}
-				break;
-			case L2Item.CRYSTAL_A:
-				if (_gemstoneCount != 20 || gemstoneItemId != 2131)
-				{
-					activeChar.sendPacket(new SystemMessage(SystemMessageId.GEMSTONE_QUANTITY_IS_INCORRECT));
-					return;
-				}
-				break;
-			case L2Item.CRYSTAL_S:
-				if (_gemstoneCount != 25 || gemstoneItemId != 2131)
-				{
-					activeChar.sendPacket(new SystemMessage(SystemMessageId.GEMSTONE_QUANTITY_IS_INCORRECT));
-					return;
-				}
-				break;
-			case L2Item.CRYSTAL_S80:
-			case L2Item.CRYSTAL_S84:
-				if (_gemstoneCount != 36 || gemstoneItemId != 2132)
-				{
-					activeChar.sendPacket(new SystemMessage(SystemMessageId.GEMSTONE_QUANTITY_IS_INCORRECT));
-					return;
-				}
-				break;
+			activeChar.sendPacket(new SystemMessage(SystemMessageId.GEMSTONE_QUANTITY_IS_INCORRECT));
+			return;
 		}
 
-		activeChar.sendPacket(new ExPutCommissionResultForVariationMake(_gemstoneItemObjId, _gemstoneCount, gemstoneItemId));
+		activeChar.sendPacket(new ExPutCommissionResultForVariationMake(_gemstoneItemObjId, _gemStoneCount, gemStoneItem.getItemId()));
 		activeChar.sendPacket(new SystemMessage(SystemMessageId.PRESS_THE_AUGMENT_BUTTON_TO_BEGIN));
 	}
 
@@ -131,5 +96,4 @@ public final class RequestConfirmGemStone extends L2GameClientPacket
 	{
 		return _C__D0_2B_REQUESTCONFIRMGEMSTONE;
 	}
-
 }

L2_GameServer/java/net/sf/l2j/gameserver/network/clientpackets/RequestConfirmRefinerItem.java

@@ -14,35 +14,24 @@
  */
 package net.sf.l2j.gameserver.network.clientpackets;
 
-import net.sf.l2j.Config;
 import net.sf.l2j.gameserver.model.L2ItemInstance;
 import net.sf.l2j.gameserver.model.L2World;
 import net.sf.l2j.gameserver.model.actor.instance.L2PcInstance;
 import net.sf.l2j.gameserver.network.SystemMessageId;
 import net.sf.l2j.gameserver.network.serverpackets.ExPutIntensiveResultForVariationMake;
 import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
-import net.sf.l2j.gameserver.templates.item.L2Item;
-import net.sf.l2j.gameserver.util.Util;
 
 /**
  * Fromat(ch) dd
  * @author  -Wooden-
  */
-public class RequestConfirmRefinerItem extends L2GameClientPacket
+public class RequestConfirmRefinerItem extends AbstractRefinePacket
 {
 	private static final String _C__D0_2A_REQUESTCONFIRMREFINERITEM = "[C] D0:2A RequestConfirmRefinerItem";
 
-	private static final int GEMSTONE_D = 2130;
-	private static final int GEMSTONE_C = 2131;
-	private static final int GEMSTONE_B = 2132;
-
 	private int _targetItemObjId;
 	private int _refinerItemObjId;
 
-	/**
-	 * @param buf
-	 * @param client
-	 */
 	@Override
 	protected void readImpl()
 	{
@@ -50,79 +39,38 @@ public class RequestConfirmRefinerItem extends L2GameClientPacket
 		_refinerItemObjId = readD();
 	}
 
-	/**
-	 * @see net.sf.l2j.gameserver.clientpackets.ClientBasePacket#runImpl()
-	 */
 	@Override
 	protected
 	void runImpl()
 	{
-		L2PcInstance activeChar = getClient().getActiveChar();
-		L2ItemInstance targetItem = (L2ItemInstance)L2World.getInstance().findObject(_targetItemObjId);
-		L2ItemInstance refinerItem = (L2ItemInstance)L2World.getInstance().findObject(_refinerItemObjId);
+		final L2PcInstance activeChar = getClient().getActiveChar();
+		if (activeChar == null)
+			return;
 
-		if (targetItem == null || refinerItem == null) return;
-		if (targetItem.getOwnerId() != activeChar.getObjectId()
-				|| refinerItem.getOwnerId() != activeChar.getObjectId())
-		{
-			Util.handleIllegalPlayerAction(getClient().getActiveChar(),"Warning!! Character "+getClient().getActiveChar().getName()+" of account "+getClient().getActiveChar().getAccountName()+" tryied to augment item that doesn't own.",Config.DEFAULT_PUNISH);
+		final L2ItemInstance targetItem = (L2ItemInstance)L2World.getInstance().findObject(_targetItemObjId);
+		if (targetItem == null)
 			return;
-		}
-		int refinerItemId = refinerItem.getItem().getItemId();
 
-		// is the item a life stone?
-		if (refinerItemId < 8723 || (refinerItemId > 8762 && refinerItemId < 9573) || (refinerItemId > 9576 && refinerItemId < 10483) || (refinerItemId > 10486 && refinerItemId < 14166) || refinerItemId > 14169)
-		{
-			activeChar.sendPacket(new SystemMessage(SystemMessageId.THIS_IS_NOT_A_SUITABLE_ITEM));
+		final L2ItemInstance refinerItem = (L2ItemInstance)L2World.getInstance().findObject(_refinerItemObjId);
+		if (refinerItem == null)
 			return;
-		}
-		// check if target is common item
-		if (targetItem.isCommonItem())
+
+		if (!isValid(activeChar, targetItem, refinerItem))
 		{
 			activeChar.sendPacket(new SystemMessage(SystemMessageId.THIS_IS_NOT_A_SUITABLE_ITEM));
 			return;
 		}
 
-		int gemstoneCount = 0;
-		int gemstoneItemId = 0;
+		final int refinerItemId = refinerItem.getItem().getItemId();
+		final int grade = targetItem.getItem().getItemGrade();
+		final LifeStone ls = getLifeStone(refinerItemId);
+		final int gemStoneId = getGemStoneId(grade);
+		final int gemStoneCount = getGemStoneCount(grade, ls.getGrade());
 		SystemMessage sm = new SystemMessage(SystemMessageId.REQUIRES_S1_S2);
-		switch (targetItem.getItem().getCrystalType())
-		{
-			case L2Item.CRYSTAL_C:
-				gemstoneCount = 20;
-				gemstoneItemId = GEMSTONE_D;
-				sm.addItemNumber(gemstoneCount);
-				sm.addString("Gemstone D");
-				break;
-			case L2Item.CRYSTAL_B:
-				gemstoneCount = 30;
-				gemstoneItemId = GEMSTONE_D;
-				sm.addItemNumber(gemstoneCount);
-				sm.addString("Gemstone D");
-				break;
-			case L2Item.CRYSTAL_A:
-				gemstoneCount = 20;
-				gemstoneItemId = GEMSTONE_C;
-				sm.addItemNumber(gemstoneCount);
-				sm.addString("Gemstone C");
-				break;
-			case L2Item.CRYSTAL_S:
-				gemstoneCount = 25;
-				gemstoneItemId = GEMSTONE_C;
-				sm.addItemNumber(gemstoneCount);
-				sm.addString("Gemstone C");
-				break;
-			case L2Item.CRYSTAL_S80:
-			case L2Item.CRYSTAL_S84:
-				gemstoneCount = 36;
-				gemstoneItemId = GEMSTONE_B;
-				sm.addItemNumber(gemstoneCount);
-				sm.addString("Gemstone B");
-				break;
-		}
-
-		activeChar.sendPacket(new ExPutIntensiveResultForVariationMake(_refinerItemObjId, refinerItemId, gemstoneItemId, gemstoneCount));
+		sm.addItemNumber(gemStoneCount);
+		sm.addItemName(gemStoneId);
 
+		activeChar.sendPacket(new ExPutIntensiveResultForVariationMake(_refinerItemObjId, refinerItemId, gemStoneId, gemStoneCount));
 		activeChar.sendPacket(sm);
 	}
 

L2_GameServer/java/net/sf/l2j/gameserver/network/clientpackets/RequestConfirmTargetItem.java

@@ -14,92 +14,49 @@
  */
 package net.sf.l2j.gameserver.network.clientpackets;
 
-import net.sf.l2j.Config;
 import net.sf.l2j.gameserver.model.L2ItemInstance;
 import net.sf.l2j.gameserver.model.L2World;
 import net.sf.l2j.gameserver.model.actor.instance.L2PcInstance;
 import net.sf.l2j.gameserver.network.SystemMessageId;
 import net.sf.l2j.gameserver.network.serverpackets.ExPutItemResultForVariationMake;
 import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
-import net.sf.l2j.gameserver.templates.item.L2Item;
-import net.sf.l2j.gameserver.util.Util;
 
 /**
  * Format:(ch) d
  * @author  -Wooden-
  */
-public final class RequestConfirmTargetItem extends L2GameClientPacket
+public final class RequestConfirmTargetItem extends AbstractRefinePacket
 {
 	private static final String _C__D0_29_REQUESTCONFIRMTARGETITEM = "[C] D0:29 RequestConfirmTargetItem";
 	private int _itemObjId;
 
-	/**
-	 * @param buf
-	 * @param client
-	 */
 	@Override
 	protected void readImpl()
 	{
 		_itemObjId = readD();
 	}
 
-	/**
-	 * @see net.sf.l2j.gameserver.clientpackets.ClientBasePacket#runImpl()
-	 */
 	@Override
 	protected void runImpl()
 	{
-		L2PcInstance activeChar = getClient().getActiveChar();
-		L2ItemInstance item = (L2ItemInstance)L2World.getInstance().findObject(_itemObjId);
-
-		if (item == null) return;
-		if (item.getOwnerId() != activeChar.getObjectId())
-		{
-			Util.handleIllegalPlayerAction(getClient().getActiveChar(),"Warning!! Character "+getClient().getActiveChar().getName()+" of account "+getClient().getActiveChar().getAccountName()+" tryied to use augment on weapon that doesn't own.",Config.DEFAULT_PUNISH);
+		final L2PcInstance activeChar = getClient().getActiveChar();
+		if (activeChar == null)
 			return;
-		}
-
-		// check if the item is augmentable
-		int itemGrade = item.getItem().getItemGrade();
-		int itemType = item.getItem().getType2();
 
-		if (item.isAugmented())
-		{
-			activeChar.sendPacket(new SystemMessage(SystemMessageId.ONCE_AN_ITEM_IS_AUGMENTED_IT_CANNOT_BE_AUGMENTED_AGAIN));
+		final L2ItemInstance item = (L2ItemInstance)L2World.getInstance().findObject(_itemObjId);
+		if (item == null)
 			return;
-		}
-		//TODO: can do better? : currently: using isdestroyable() as a check for hero / cursed weapons
-		else if (itemGrade < L2Item.CRYSTAL_C || itemType != L2Item.TYPE2_WEAPON || !item.isDestroyable() ||
-				item.isShadowItem() || item.isTimeLimitedItem() || item.isPvp())
-		{
-			activeChar.sendPacket(new SystemMessage(SystemMessageId.THIS_IS_NOT_A_SUITABLE_ITEM));
-			return;
-		}
 
-		// check if the player can augment
-		if (activeChar.getPrivateStoreType() != L2PcInstance.STORE_PRIVATE_NONE)
+		if (!isValid(activeChar, item))
 		{
-			activeChar.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_A_PRIVATE_STORE_OR_PRIVATE_WORKSHOP_IS_IN_OPERATION));
-			return;
-		}
-		if (activeChar.isDead())
-		{
-			activeChar.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_DEAD));
-			return;
-		}
-		if (activeChar.isParalyzed())
-		{
-			activeChar.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_PARALYZED));
-			return;
-		}
-		if (activeChar.isFishing())
-		{
-			activeChar.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_FISHING));
-			return;
-		}
-		if (activeChar.isSitting())
-		{
-			activeChar.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_SITTING_DOWN));
+			// Different system message here
+			if (item.isAugmented())
+			{
+				activeChar.sendPacket(new SystemMessage(SystemMessageId.ONCE_AN_ITEM_IS_AUGMENTED_IT_CANNOT_BE_AUGMENTED_AGAIN));
+				return;
+			}
+
+			activeChar.sendPacket(new SystemMessage(SystemMessageId.THIS_IS_NOT_A_SUITABLE_ITEM));
 			return;
 		}
 
@@ -115,5 +72,4 @@ public final class RequestConfirmTargetItem extends L2GameClientPacket
 	{
 		return _C__D0_29_REQUESTCONFIRMTARGETITEM;
 	}
-
 }

L2_GameServer/java/net/sf/l2j/gameserver/network/clientpackets/RequestRefine.java

@@ -14,8 +14,8 @@
  */
 package net.sf.l2j.gameserver.network.clientpackets;
 
-import net.sf.l2j.Config;
 import net.sf.l2j.gameserver.datatables.AugmentationData;
+import net.sf.l2j.gameserver.model.L2Augmentation;
 import net.sf.l2j.gameserver.model.L2ItemInstance;
 import net.sf.l2j.gameserver.model.L2World;
 import net.sf.l2j.gameserver.model.actor.instance.L2PcInstance;
@@ -24,29 +24,26 @@ import net.sf.l2j.gameserver.network.serverpackets.ExVariationResult;
 import net.sf.l2j.gameserver.network.serverpackets.InventoryUpdate;
 import net.sf.l2j.gameserver.network.serverpackets.StatusUpdate;
 import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
-import net.sf.l2j.gameserver.templates.item.L2Item;
-import net.sf.l2j.gameserver.templates.item.L2WeaponType;
-import net.sf.l2j.gameserver.util.Util;
 
 /**
  * Format:(ch) dddd
  * @author  -Wooden-
  */
-public final class RequestRefine extends L2GameClientPacket
+public final class RequestRefine extends AbstractRefinePacket
 {
 	private static final String _C__D0_2C_REQUESTREFINE = "[C] D0:2C RequestRefine";
 	private int _targetItemObjId;
 	private int _refinerItemObjId;
-	private int _gemstoneItemObjId;
-	private long _gemstoneCount;
+	private int _gemStoneItemObjId;
+	private long _gemStoneCount;
 
 	@Override
 	protected void readImpl()
 	{
 		_targetItemObjId = readD();
 		_refinerItemObjId = readD();
-		_gemstoneItemObjId = readD();
-		_gemstoneCount = readQ();
+		_gemStoneItemObjId = readD();
+		_gemStoneCount = readQ();
 	}
 
 	/**
@@ -56,244 +53,74 @@ public final class RequestRefine extends L2GameClientPacket
 	protected
 	void runImpl()
 	{
-		L2PcInstance activeChar = getClient().getActiveChar();
-		if (activeChar == null) return;
+		final L2PcInstance activeChar = getClient().getActiveChar();
+		if (activeChar == null)
+			return;
 		L2ItemInstance targetItem = (L2ItemInstance)L2World.getInstance().findObject(_targetItemObjId);
+		if (targetItem == null)
+			return;
 		L2ItemInstance refinerItem = (L2ItemInstance)L2World.getInstance().findObject(_refinerItemObjId);
-		L2ItemInstance gemstoneItem = (L2ItemInstance)L2World.getInstance().findObject(_gemstoneItemObjId);
+		if (refinerItem == null)
+			return;
+		L2ItemInstance gemStoneItem = (L2ItemInstance)L2World.getInstance().findObject(_gemStoneItemObjId);
+		if (gemStoneItem == null)
+			return;
 
-		if (targetItem == null || refinerItem == null || gemstoneItem == null ||
-				targetItem.getOwnerId() != activeChar.getObjectId() ||
-				refinerItem.getOwnerId() != activeChar.getObjectId() ||
-				gemstoneItem.getOwnerId() != activeChar.getObjectId() ||
-				activeChar.getLevel() < 46) // must be lvl 46
+		if (!isValid(activeChar, targetItem, refinerItem, gemStoneItem))
 		{
 			activeChar.sendPacket(new ExVariationResult(0,0,0));
 			activeChar.sendPacket(new SystemMessage(SystemMessageId.AUGMENTATION_FAILED_DUE_TO_INAPPROPRIATE_CONDITIONS));
 			return;
 		}
 
-		// unequip item
-		if (targetItem.isEquipped()) activeChar.disarmWeapons();
-
-		if (tryAugmentItem(activeChar, targetItem, refinerItem, gemstoneItem))
-		{
-			int stat12 = 0x0000FFFF&targetItem.getAugmentation().getAugmentationId();
-			int stat34 = targetItem.getAugmentation().getAugmentationId()>>16;
-			activeChar.sendPacket(new ExVariationResult(stat12,stat34,1));
-			activeChar.sendPacket(new SystemMessage(SystemMessageId.THE_ITEM_WAS_SUCCESSFULLY_AUGMENTED));
-		}
-		else
+		final LifeStone ls = getLifeStone(refinerItem.getItemId());
+		if (ls == null)
+			return;
+		final int lifeStoneLevel = ls.getLevel();
+		final int lifeStoneGrade = ls.getGrade();
+		if (_gemStoneCount != getGemStoneCount(targetItem.getItem().getItemGrade(), lifeStoneGrade))
 		{
 			activeChar.sendPacket(new ExVariationResult(0,0,0));
 			activeChar.sendPacket(new SystemMessage(SystemMessageId.AUGMENTATION_FAILED_DUE_TO_INAPPROPRIATE_CONDITIONS));
-		}
-	}
-
-	boolean tryAugmentItem(L2PcInstance player, L2ItemInstance targetItem,L2ItemInstance refinerItem, L2ItemInstance gemstoneItem)
-	{
-		if (targetItem.isAugmented()
-				|| targetItem.isWear()
-				|| targetItem.isTimeLimitedItem()
-				|| targetItem.isCommonItem()
-				|| targetItem.isShadowItem()
-				|| targetItem.getItem().getItemType() == L2WeaponType.ROD)
-			return false;
-		
-		if (player.isDead())
-		{
-			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_DEAD));
-			return false;
-		}
-		if (player.isSitting())
-		{
-			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_SITTING_DOWN));
-			return false;
-		}
-		if (player.isFishing())
-		{
-			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_FISHING));
-			return false;
-		}
-		if (player.isParalyzed())
-		{
-			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_PARALYZED));
-			return false;
-		}
-		if (player.getActiveTradeList() != null)
-		{
-			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_TRADING));
-			return false;
-		}
-		if (player.getPrivateStoreType() != L2PcInstance.STORE_PRIVATE_NONE)
-		{
-			player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_AUGMENT_ITEMS_WHILE_A_PRIVATE_STORE_OR_PRIVATE_WORKSHOP_IS_IN_OPERATION));
-			return false;
-		}
-		
-		// check for the items to be in the inventory of the owner
-		if (player.getInventory().getItemByObjectId(refinerItem.getObjectId()) == null)
-		{
-			Util.handleIllegalPlayerAction(player, "Warning!! Character "
-			        + player.getName() + " of account "
-			        + player.getAccountName()
-			        + " tried to refine an item with wrong LifeStone-id.", Config.DEFAULT_PUNISH);
-			return false;
-		}
-		if (player.getInventory().getItemByObjectId(targetItem.getObjectId()) == null)
-		{
-			Util.handleIllegalPlayerAction(player, "Warning!! Character "
-			        + player.getName() + " of account "
-			        + player.getAccountName()
-			        + " tried to refine an item with wrong Weapon-id.", Config.DEFAULT_PUNISH);
-			return false;
-		}
-		if (player.getInventory().getItemByObjectId(gemstoneItem.getObjectId()) == null)
-		{
-			Util.handleIllegalPlayerAction(player, "Warning!! Character "
-			        + player.getName() + " of account "
-			        + player.getAccountName()
-			        + " tried to refine an item with wrong Gemstone-id.", Config.DEFAULT_PUNISH);
-			return false;
-		}
-
-		int itemGrade = targetItem.getItem().getItemGrade();
-		int itemType = targetItem.getItem().getType2();
-		int lifeStoneId = refinerItem.getItemId();
-		int gemstoneItemId = gemstoneItem.getItemId();
-
-		// is the refiner Item a life stone?
-		if (lifeStoneId < 8723 || (lifeStoneId > 8762 &&  lifeStoneId < 9573)
-				|| (lifeStoneId > 9576 && lifeStoneId < 10483)
-				|| (lifeStoneId > 10486 && lifeStoneId < 14166)
-				|| lifeStoneId > 14169) return false;
-
-		// must be a weapon, must be > d grade
-		// TODO: can do better? : currently: using isdestroyable() as a check for hero / cursed weapons
-		if (itemGrade < L2Item.CRYSTAL_C || itemType != L2Item.TYPE2_WEAPON || !targetItem.isDestroyable()) return false;
-
-		// player must be able to use augmentation
-		if (player.getPrivateStoreType() != L2PcInstance.STORE_PRIVATE_NONE || player.isDead()
-				|| player.isParalyzed() || player.isFishing() || player.isSitting()) return false;
-
-		long modifyGemstoneCount = _gemstoneCount;
-		int lifeStoneLevel = getLifeStoneLevel(lifeStoneId);
-		int lifeStoneGrade = getLifeStoneGrade(lifeStoneId);
-		switch (itemGrade)
-		{
-			case L2Item.CRYSTAL_C:
-				if (player.getLevel() < 46 || gemstoneItemId != 2130) return false;
-				modifyGemstoneCount = 20;
-				break;
-			case L2Item.CRYSTAL_B:
-				if (player.getLevel() < 52 || gemstoneItemId != 2130) return false;
-				modifyGemstoneCount = 30;
-				break;
-			case L2Item.CRYSTAL_A:
-				if (player.getLevel() < 61 || gemstoneItemId != 2131) return false;
-				modifyGemstoneCount = 20;
-				break;
-			case L2Item.CRYSTAL_S:
-				if (player.getLevel() < 76 || gemstoneItemId != 2131) return false;
-				modifyGemstoneCount = 25;
-				break;
-			case L2Item.CRYSTAL_S80:
-				if (player.getLevel() < 80 || gemstoneItemId != 2132) return false;
-				modifyGemstoneCount = 36;
-				break;
-			case L2Item.CRYSTAL_S84:
-				if (player.getLevel() < 84 || gemstoneItemId != 2132) return false;
-				modifyGemstoneCount = 36;
-				break;
+			return;
 		}
 
-		// check if the lifestone is appropriate for this player
-		switch (lifeStoneLevel)
+		// unequip item
+		if (targetItem.isEquipped())
 		{
-			case 1:
-				if (player.getLevel() < 46) return false;
-				break;
-			case 2:
-				if (player.getLevel() < 49) return false;
-				break;
-			case 3:
-				if (player.getLevel() < 52) return false;
-				break;
-			case 4:
-				if (player.getLevel() < 55) return false;
-				break;
-			case 5:
-				if (player.getLevel() < 58) return false;
-				break;
-			case 6:
-				if (player.getLevel() < 61) return false;
-				break;
-			case 7:
-				if (player.getLevel() < 64) return false;
-				break;
-			case 8:
-				if (player.getLevel() < 67) return false;
-				break;
-			case 9:
-				if (player.getLevel() < 70) return false;
-				break;
-			case 10:
-				if (player.getLevel() < 76) return false;
-				break;
-			case 11:
-				if (player.getLevel() < 80) return false;
-				break;
-			case 12:
-				if (player.getLevel() < 82) return false;
-				break;
-			case 13:
-				if (player.getLevel() < 84) return false;
-				break;
+			L2ItemInstance[] unequiped = activeChar.getInventory().unEquipItemInSlotAndRecord(targetItem.getLocationSlot());
+			InventoryUpdate iu = new InventoryUpdate();
+			for (L2ItemInstance itm : unequiped)
+			{
+				iu.addModifiedItem(itm);
+			}
+			activeChar.sendPacket(iu);
+			activeChar.broadcastUserInfo();
 		}
 
 		// consume the life stone
-		if (!player.destroyItem("RequestRefine", refinerItem, 1, null, false))
-			return false;
+		if (!activeChar.destroyItem("RequestRefine", refinerItem, 1, null, false))
+			return;
 
 		// consume the gemstones
-		if (!player.destroyItem("RequestRefine", gemstoneItem, modifyGemstoneCount, null, false))
-			return false;
+		if (!activeChar.destroyItem("RequestRefine", gemStoneItem, _gemStoneCount, null, false))
+			return;
+
+		final L2Augmentation aug = AugmentationData.getInstance().generateRandomAugmentation(lifeStoneLevel, lifeStoneGrade, targetItem.getItem().getBodyPart());
+		targetItem.setAugmentation(aug);
 
-		// generate augmentation
-		targetItem.setAugmentation(AugmentationData.getInstance().generateRandomAugmentation(lifeStoneLevel, lifeStoneGrade));
+		final int stat12 = 0x0000FFFF & aug.getAugmentationId();
+		final int stat34 = aug.getAugmentationId() >> 16;
+		activeChar.sendPacket(new ExVariationResult(stat12,stat34,1));
+		activeChar.sendPacket(new SystemMessage(SystemMessageId.THE_ITEM_WAS_SUCCESSFULLY_AUGMENTED));
 
-		// finish and send the inventory update packet
 		InventoryUpdate iu = new InventoryUpdate();
 		iu.addModifiedItem(targetItem);
-		player.sendPacket(iu);
-
-		StatusUpdate su = new StatusUpdate(player.getObjectId());
-		su.addAttribute(StatusUpdate.CUR_LOAD, player.getCurrentLoad());
-		player.sendPacket(su);
+		activeChar.sendPacket(iu);
 
-		return true;
-	}
-
-	private int getLifeStoneGrade(int itemId)
-	{
-		itemId -= 8723;
-		if (itemId < 10 || itemId == 850
-				|| itemId == 1760 || itemId == 5443) return 0; // normal grade
-		if (itemId < 20 || itemId == 851
-				|| itemId == 1761 || itemId == 5444) return 1; // mid grade
-		if (itemId < 30 || itemId == 852
-				|| itemId == 1762 || itemId == 5445) return 2; // high grade
-		return 3; // top grade
-	}
-
-	private int getLifeStoneLevel(int itemId)
-	{
-        itemId -= 10 * getLifeStoneGrade(itemId);
-        itemId -= 8722;
-        if (itemId > 823 && itemId < 852) return 11;
-        if (itemId > 833 && itemId < 1762) return 12;
-        if (itemId > 5416 && itemId < 5445) return 13;
-        return itemId;
+		StatusUpdate su = new StatusUpdate(activeChar.getObjectId());
+		su.addAttribute(StatusUpdate.CUR_LOAD, activeChar.getCurrentLoad());
+		activeChar.sendPacket(su);
 	}
 
 	/**