Calculator update

Signed-off-by: Rogiel <rogiel@rogiel.com>

src/main/java/com/l2jserver/model/template/EffectTemplate.java

@@ -17,6 +17,7 @@
 package com.l2jserver.model.template;
 
 import com.l2jserver.model.id.template.ItemTemplateID;
+import com.l2jserver.model.world.Actor;
 
 /**
  * Template for effects
@@ -33,6 +34,16 @@ public abstract class EffectTemplate extends AbstractTemplate<Object> {
 		return null;
 	}
 
+	/**
+	 * Adds this effect to the given <tt>actor</tt>
+	 * 
+	 * @param actor
+	 *            the actor
+	 */
+	public void apply(Actor actor) {
+
+	}
+
 	@Override
 	public ItemTemplateID getID() {
 		return (ItemTemplateID) super.getID();

src/main/java/com/l2jserver/model/world/NPC.java

@@ -99,6 +99,7 @@ public class NPC extends Actor {
 	/**
 	 * @return the NPC template ID
 	 */
+	@Override
 	public NPCTemplateID getTemplateID() {
 		return (NPCTemplateID) templateID;
 	}
@@ -106,6 +107,7 @@ public class NPC extends Actor {
 	/**
 	 * @return the NPC template
 	 */
+	@Override
 	public NPCTemplate getTemplate() {
 		return (NPCTemplate) templateID.getTemplate();
 	}

src/main/java/com/l2jserver/model/world/actor/stat/Stats.java

@@ -3,8 +3,8 @@ package com.l2jserver.model.world.actor.stat;
 import java.util.List;
 import java.util.Map;
 
+import com.l2jserver.model.world.Actor;
 import com.l2jserver.util.calculator.Calculator;
-import com.l2jserver.util.calculator.CalculatorContext;
 import com.l2jserver.util.calculator.DivisionFunction;
 import com.l2jserver.util.calculator.Function;
 import com.l2jserver.util.calculator.MultiplicationFunction;
@@ -136,7 +136,7 @@ public class Stats {
 		// PHYSICAL_ATTACK_SPEED;
 	}
 
-	private final Map<StatType, List<Function<CalculatorContext>>> operations = CollectionFactory
+	private final Map<StatType, List<Function<Actor>>> operations = CollectionFactory
 			.newMap();
 
 	/**
@@ -150,7 +150,7 @@ public class Stats {
 	 *            the value to set
 	 */
 	public void set(Stats.StatType type, int order, double value) {
-		func(type, new SetFunction(order, value));
+		func(type, new SetFunction<Actor>(order, value));
 	}
 
 	/**
@@ -164,7 +164,7 @@ public class Stats {
 	 *            the value to be summed
 	 */
 	public void add(Stats.StatType type, int order, double value) {
-		func(type, new SumFunction(order, value));
+		func(type, new SumFunction<Actor>(order, value));
 	}
 
 	/**
@@ -178,7 +178,7 @@ public class Stats {
 	 *            the value to be subtracted
 	 */
 	public void sub(Stats.StatType type, int order, double value) {
-		func(type, new SubtractFunction(order, value));
+		func(type, new SubtractFunction<Actor>(order, value));
 	}
 
 	/**
@@ -192,7 +192,7 @@ public class Stats {
 	 *            the value to be multiplied
 	 */
 	public void mult(Stats.StatType type, int order, double value) {
-		func(type, new MultiplicationFunction(order, value));
+		func(type, new MultiplicationFunction<Actor>(order, value));
 	}
 
 	/**
@@ -206,7 +206,7 @@ public class Stats {
 	 *            the value to be divided by
 	 */
 	public void div(Stats.StatType type, int order, double value) {
-		func(type, new DivisionFunction(order, value));
+		func(type, new DivisionFunction<Actor>(order, value));
 	}
 
 	/**
@@ -223,7 +223,7 @@ public class Stats {
 		// TODO enchant operation for weapon
 	}
 
-	public void func(StatType type, Function<CalculatorContext> function) {
+	public void func(StatType type, Function<Actor> function) {
 		getMap(type).add(function);
 	}
 
@@ -234,8 +234,8 @@ public class Stats {
 	 *            the type
 	 * @return the order-operation map
 	 */
-	private List<Function<CalculatorContext>> getMap(Stats.StatType type) {
-		List<Function<CalculatorContext>> list = operations.get(type);
+	private List<Function<Actor>> getMap(Stats.StatType type) {
+		List<Function<Actor>> list = operations.get(type);
 		if (list == null) {
 			list = CollectionFactory.newList();
 			operations.put(type, list);
@@ -251,13 +251,11 @@ public class Stats {
 	 * @param calculator
 	 *            the calculator
 	 */
-	public void calculator(Stats.StatType type,
-			Calculator<CalculatorContext> calculator) {
-		final List<Function<CalculatorContext>> operations = this.operations
-				.get(type);
+	public void calculator(Stats.StatType type, Calculator<Actor> calculator) {
+		final List<Function<Actor>> operations = this.operations.get(type);
 		if (operations == null || operations.size() == 0)
 			return;
-		for (final Function<CalculatorContext> func : operations) {
+		for (final Function<Actor> func : operations) {
 			calculator.add(func);
 		}
 	}

src/main/java/com/l2jserver/model/world/character/CharacterStats.java

@@ -77,13 +77,13 @@ public class CharacterStats {
 
 	private final L2Character character;
 	@SuppressWarnings("unchecked")
-	private final Calculator<CharacterCalculatorContext>[] calculators = new Calculator[StatType
+	private final Calculator<L2Character>[] calculators = new Calculator[StatType
 			.values().length];
 
 	public CharacterStats(L2Character character) {
 		this.character = character;
 		for (int i = 0; i < calculators.length; i++) {
-			calculators[i] = new Calculator<CharacterCalculatorContext>();
+			calculators[i] = new Calculator<L2Character>();
 		}
 
 		// bind default functions
@@ -217,14 +217,14 @@ public class CharacterStats {
 	// getCalculator(type).importFunctions(calculator);
 	// }
 
-	protected Calculator<CharacterCalculatorContext> getCalculator(StatType type) {
+	protected Calculator<L2Character> getCalculator(StatType type) {
 		return calculators[type.ordinal()];
 	}
 
 	public double calc(StatType type) {
 		final CharacterCalculatorContext ctx = new CharacterCalculatorContext(
 				character);
-		getCalculator(type).calculate(ctx);
+		getCalculator(type).calculate(character, ctx);
 		return ctx.result;
 	}
 }

src/main/java/com/l2jserver/model/world/character/calculator/BaseAttackAccuracyCalculator.java

@@ -20,6 +20,7 @@ import org.apache.commons.math.util.FastMath;
 
 import com.l2jserver.model.world.L2Character;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -28,15 +29,14 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseAttackAccuracyCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseAttackAccuracyCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getAccuracy();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getAccuracy();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x100) {
+		}, new AbstractFunction<L2Character>(0x100) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				final L2Character c = ctx.character;
+			public void calculate(L2Character c, CalculatorContext ctx) {
 				final int level = c.getLevel();
 
 				ctx.result += FastMath.sqrt(c.getStats().getDexterity()) * 6;

src/main/java/com/l2jserver/model/world/character/calculator/BaseAttackEvasionCalculator.java

@@ -20,6 +20,7 @@ import org.apache.commons.math.util.FastMath;
 
 import com.l2jserver.model.world.L2Character;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -28,15 +29,14 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseAttackEvasionCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseAttackEvasionCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getEvasionChance();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getEvasionChance();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x100) {
+		}, new AbstractFunction<L2Character>(0x100) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				final L2Character c = ctx.character;
+			public void calculate(L2Character c, CalculatorContext ctx) {
 				final int level = c.getLevel();
 
 				ctx.result += FastMath.sqrt(c.getStats().getDexterity()) * 6;

src/main/java/com/l2jserver/model/world/character/calculator/BaseCPCalculator.java

@@ -17,8 +17,10 @@
 package com.l2jserver.model.world.character.calculator;
 
 import com.l2jserver.model.template.CharacterTemplate;
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -27,28 +29,28 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseCPCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseCPCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getCpBase();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getCpBase();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x100) {
+		}, new AbstractFunction<L2Character>(0x100) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				final CharacterTemplate template = ctx.character.getTemplate();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				final CharacterTemplate template = c.getTemplate();
 
-				int lvl = ctx.character.getLevel() - template.getMinimumLevel();
+				int lvl = c.getLevel() - template.getMinimumLevel();
 				double mod = template.getCpMultiplier() * lvl;
 				double max = (template.getCpAdd() + mod) * lvl;
 				double min = (template.getCpAdd() * lvl) + mod;
 
 				ctx.result += (max + min) / 2;
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x200) {
+		}, new AbstractFunction<L2Character>(0x200) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result *= BaseStats.CON.calculateBonus(ctx.character
-						.getStats().getConcentration());
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result *= BaseStats.CON.calculateBonus(c.getStats()
+						.getConcentration());
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BaseConcentrationCalculator.java

@@ -16,7 +16,9 @@
  */
 package com.l2jserver.model.world.character.calculator;
 
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -24,10 +26,10 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseConcentrationCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseConcentrationCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getConcentration();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getConcentration();
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BaseDexterityCalculator.java

@@ -16,19 +16,20 @@
  */
 package com.l2jserver.model.world.character.calculator;
 
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
  */
-public class BaseDexterityCalculator extends
-CharacterCalculator {
+public class BaseDexterityCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseDexterityCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getDextry();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getDextry();
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BaseHPCalculator.java

@@ -17,8 +17,10 @@
 package com.l2jserver.model.world.character.calculator;
 
 import com.l2jserver.model.template.CharacterTemplate;
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -27,28 +29,28 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseHPCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseHPCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getHpBase();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getHpBase();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x100) {
+		}, new AbstractFunction<L2Character>(0x100) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				final CharacterTemplate template = ctx.character.getTemplate();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				final CharacterTemplate template = c.getTemplate();
 
-				int lvl = ctx.character.getLevel() - template.getMinimumLevel();
+				int lvl = c.getLevel() - template.getMinimumLevel();
 				double mod = template.getHpMultiplier() * lvl;
 				double max = (template.getHpAdd() + mod) * lvl;
 				double min = (template.getHpAdd() * lvl) + mod;
 
 				ctx.result += (max + min) / 2;
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x200) {
+		}, new AbstractFunction<L2Character>(0x200) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result *= BaseStats.CON.calculateBonus(ctx.character
-						.getStats().getConcentration());
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result *= BaseStats.CON.calculateBonus(c.getStats()
+						.getConcentration());
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BaseIntelligenceCalculator.java

@@ -16,7 +16,9 @@
  */
 package com.l2jserver.model.world.character.calculator;
 
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -24,10 +26,10 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseIntelligenceCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseIntelligenceCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getIntelligence();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getIntelligence();
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BaseMPCalculator.java

@@ -17,8 +17,10 @@
 package com.l2jserver.model.world.character.calculator;
 
 import com.l2jserver.model.template.CharacterTemplate;
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -27,28 +29,28 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseMPCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseMPCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getMpBase();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getMpBase();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x100) {
+		}, new AbstractFunction<L2Character>(0x100) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				final CharacterTemplate template = ctx.character.getTemplate();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				final CharacterTemplate template = c.getTemplate();
 
-				int lvl = ctx.character.getLevel() - template.getMinimumLevel();
+				int lvl = c.getLevel() - template.getMinimumLevel();
 				double mod = template.getMpMultiplier() * lvl;
 				double max = (template.getMpAdd() + mod) * lvl;
 				double min = (template.getMpAdd() * lvl) + mod;
 
 				ctx.result += (max + min) / 2;
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x200) {
+		}, new AbstractFunction<L2Character>(0x200) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result *= BaseStats.MEN.calculateBonus(ctx.character
-						.getStats().getMentality());
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result *= BaseStats.MEN.calculateBonus(c.getStats()
+						.getMentality());
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BaseMagicalAttackCalculator.java

@@ -19,6 +19,7 @@ package com.l2jserver.model.world.character.calculator;
 import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -27,15 +28,14 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseMagicalAttackCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseMagicalAttackCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getMagicalAttack();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getMagicalAttack();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x200) {
+		}, new AbstractFunction<L2Character>(0x200) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				final L2Character c = ctx.character;
+			public void calculate(L2Character c, CalculatorContext ctx) {
 				ctx.result *= Math
 						.pow(((100.0 - 11 + c.getLevel()) / 100.0), 2)
 						* Math.pow(BaseStats.INT.calculateBonus(c.getStats()

src/main/java/com/l2jserver/model/world/character/calculator/BaseMagicalAttackSpeedCalculator.java

@@ -16,8 +16,10 @@
  */
 package com.l2jserver.model.world.character.calculator;
 
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -26,16 +28,16 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseMagicalAttackSpeedCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseMagicalAttackSpeedCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getCastSpeed();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getCastSpeed();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x200) {
+		}, new AbstractFunction<L2Character>(0x200) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result *= BaseStats.WIT.calculateBonus(ctx.character
-						.getStats().getWitness());
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result *= BaseStats.WIT.calculateBonus(c.getStats()
+						.getWitness());
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BaseMagicalCriticalRateCalculator.java

@@ -19,6 +19,7 @@ package com.l2jserver.model.world.character.calculator;
 import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -26,17 +27,15 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseMagicalCriticalRateCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseMagicalCriticalRateCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
+			public void calculate(L2Character c, CalculatorContext ctx) {
 				// XXX is the same as physical????
-				ctx.result = ctx.character.getTemplate().getCriticalChance();
+				ctx.result = c.getTemplate().getCriticalChance();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x300) {
+		}, new AbstractFunction<L2Character>(0x300) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				final L2Character c = ctx.character;
-
+			public void calculate(L2Character c, CalculatorContext ctx) {
 				// TODO only apply if using a weapon
 				ctx.result *= BaseStats.WIT.calculateBonus(c.getStats()
 						.getWitness());

src/main/java/com/l2jserver/model/world/character/calculator/BaseMagicalDefenseCalculator.java

@@ -26,6 +26,7 @@ import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.model.world.character.CharacterInventory;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -33,15 +34,14 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseMagicalDefenseCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseMagicalDefenseCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getMagicalDefense();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getMagicalDefense();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x200) {
+		}, new AbstractFunction<L2Character>(0x200) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				final L2Character c = ctx.character;
+			public void calculate(L2Character c, CalculatorContext ctx) {
 				final CharacterInventory inv = c.getInventory();
 
 				if (inv.has(LEFT_FINGER))

src/main/java/com/l2jserver/model/world/character/calculator/BaseMentalityCalculator.java

@@ -16,7 +16,9 @@
  */
 package com.l2jserver.model.world.character.calculator;
 
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -24,10 +26,10 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseMentalityCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseMentalityCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getMentality();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getMentality();
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BasePhysicalAttackCalculator.java

@@ -19,6 +19,7 @@ package com.l2jserver.model.world.character.calculator;
 import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -27,15 +28,14 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BasePhysicalAttackCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BasePhysicalAttackCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getPhysicalAttack();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getPhysicalAttack();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x100) {
+		}, new AbstractFunction<L2Character>(0x100) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				final L2Character c = ctx.character;
+			public void calculate(L2Character c, CalculatorContext ctx) {
 				ctx.result *= BaseStats.STR.calculateBonus(c.getStats()
 						.getStrength()) * ((100.0 - 11 + c.getLevel()) / 100.0);
 			}

src/main/java/com/l2jserver/model/world/character/calculator/BasePhysicalAttackSpeedCalculator.java

@@ -16,8 +16,10 @@
  */
 package com.l2jserver.model.world.character.calculator;
 
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -26,16 +28,16 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BasePhysicalAttackSpeedCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BasePhysicalAttackSpeedCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getAttackSpeed();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getAttackSpeed();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x200) {
+		}, new AbstractFunction<L2Character>(0x200) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result *= BaseStats.DEX.calculateBonus(ctx.character
-						.getStats().getDexterity());
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result *= BaseStats.DEX.calculateBonus(c.getStats()
+						.getDexterity());
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BasePhysicalCriticalRateCalculator.java

@@ -19,6 +19,7 @@ package com.l2jserver.model.world.character.calculator;
 import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -26,16 +27,14 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BasePhysicalCriticalRateCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BasePhysicalCriticalRateCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getCriticalChance();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getCriticalChance();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x090) {
+		}, new AbstractFunction<L2Character>(0x090) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				final L2Character c = ctx.character;
-
+			public void calculate(L2Character c, CalculatorContext ctx) {
 				ctx.result *= BaseStats.DEX.calculateBonus(c.getStats()
 						.getDexterity());
 				ctx.result *= 10;

src/main/java/com/l2jserver/model/world/character/calculator/BasePhysicalDefenseCalculator.java

@@ -28,6 +28,7 @@ import com.l2jserver.model.world.character.CharacterClass;
 import com.l2jserver.model.world.character.CharacterClass.ClassType;
 import com.l2jserver.model.world.character.CharacterInventory;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -35,15 +36,14 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BasePhysicalDefenseCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BasePhysicalDefenseCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getPhysicalDefense();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getPhysicalDefense();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x200) {
+		}, new AbstractFunction<L2Character>(0x200) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				final L2Character c = ctx.character;
+			public void calculate(L2Character c, CalculatorContext ctx) {
 				final CharacterInventory inv = c.getInventory();
 
 				// orc mystics are a special case

src/main/java/com/l2jserver/model/world/character/calculator/BaseRunSpeedCalculator.java

@@ -16,8 +16,10 @@
  */
 package com.l2jserver.model.world.character.calculator;
 
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -26,16 +28,16 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseRunSpeedCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseRunSpeedCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getRunSpeed();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getRunSpeed();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x300) {
+		}, new AbstractFunction<L2Character>(0x300) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result *= BaseStats.DEX.calculateBonus(ctx.character
-						.getStats().getDexterity());
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result *= BaseStats.DEX.calculateBonus(c.getStats()
+						.getDexterity());
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BaseStrengthCalculator.java

@@ -16,7 +16,9 @@
  */
 package com.l2jserver.model.world.character.calculator;
 
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -24,10 +26,10 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseStrengthCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseStrengthCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getStrength();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getStrength();
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BaseWalkSpeedCalculator.java

@@ -16,8 +16,10 @@
  */
 package com.l2jserver.model.world.character.calculator;
 
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.model.world.actor.stat.BaseStats;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -26,16 +28,16 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseWalkSpeedCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseWalkSpeedCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getWalkSpeed();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getWalkSpeed();
 			}
-		}, new AbstractFunction<CharacterCalculatorContext>(0x300) {
+		}, new AbstractFunction<L2Character>(0x300) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result *= BaseStats.DEX.calculateBonus(ctx.character
-						.getStats().getDexterity());
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result *= BaseStats.DEX.calculateBonus(c.getStats()
+						.getDexterity());
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/BaseWitnessCalculator.java

@@ -16,7 +16,9 @@
  */
 package com.l2jserver.model.world.character.calculator;
 
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.util.calculator.AbstractFunction;
+import com.l2jserver.util.calculator.CalculatorContext;
 
 /**
  * @author <a href="http://www.rogiel.com">Rogiel</a>
@@ -24,10 +26,10 @@ import com.l2jserver.util.calculator.AbstractFunction;
 public class BaseWitnessCalculator extends CharacterCalculator {
 	@SuppressWarnings("unchecked")
 	public BaseWitnessCalculator() {
-		super(new AbstractFunction<CharacterCalculatorContext>(0x000) {
+		super(new AbstractFunction<L2Character>(0x000) {
 			@Override
-			public void calculate(CharacterCalculatorContext ctx) {
-				ctx.result = ctx.character.getTemplate().getMentality();
+			public void calculate(L2Character c, CalculatorContext ctx) {
+				ctx.result = c.getTemplate().getMentality();
 			}
 		});
 	}

src/main/java/com/l2jserver/model/world/character/calculator/CharacterCalculator.java

@@ -16,6 +16,7 @@
  */
 package com.l2jserver.model.world.character.calculator;
 
+import com.l2jserver.model.world.L2Character;
 import com.l2jserver.util.calculator.Calculator;
 import com.l2jserver.util.calculator.Function;
 
@@ -23,9 +24,9 @@ import com.l2jserver.util.calculator.Function;
  * @author <a href="http://www.rogiel.com">Rogiel</a>
  * 
  */
-public class CharacterCalculator extends Calculator<CharacterCalculatorContext> {
+public class CharacterCalculator extends Calculator<L2Character> {
 	public CharacterCalculator(
-			Function<CharacterCalculatorContext>... functions) {
+			Function<L2Character>... functions) {
 		super(functions);
 	}
 }