hello,

im working on a combat system for a pali based server. this is what i got sofar.

now im looking for some things to improve this. and no i dont use entity.
i still need to create methods for : nvn,nvp
but then i finished up combat. like it should be and for me perfect usable for every revision.

so i would say give some feedback on how to improve.

Serenity.

Spoiler for combat.class:

Code:
package sds.rs2.content.Combat;
import sds.rs2.players.Player;
import sds.rs2.npcs.NPC;
import sds.rs2.util.Misc;
import sds.rs2.Engine;
import sds.rs2.content.Freeze;
/**
 * Created by IntelliJ IDEA.
 * User: Serenity
 * Date: 21-sep-2009
 * Time: 15:12:25
 * Usage : this class is used for the combat methods of all 3 types of magic.
 */
public class Combat {
    public static int requestMeleeHit(Player p, Player p2) {
        if (p == null || p2 == null) {
            ResetAttack(p);
            return 0;
        }
        if (Misc.getDistance(p.absX, p.absY, p2.absX, p2.absY) > (p.vars.attackIndex != -1 ? (Integer) Data.MeleeWeaponData[p.vars.attackIndex][2][2] : 1)) {
            WalkTo(p, p2);
            return 0;
        } else if (Misc.getDistance(p.absX, p.absY, p2.absX, p2.absY) > 7) {
            ResetAttack(p);
            return 0;
        } else {
            p.requestAnim(p.vars.attackIndex != -1 ?
                    (Integer) Data.MeleeWeaponData[p.vars.attackIndex][1][p.vars.attackStyle[3]] : 422, 0);
            p2.requestAnim(p2.vars.defenceShieldIndex != -1 ?
                    (Integer) Data.DefenceEmoteData[0][1][0] :
                    (p2.vars.defenceWeaponIndex != -1 ? (Integer) Data.MeleeWeaponData[p2.vars.defenceWeaponIndex][2][0] : 424), 1);
            FaceToRetaile(p, p2);
            int hit = CHit(p, p2);
            p2.appendHit(hit, 0);
            AddCombatExp(p, (byte) hit);
            return p.vars.attackIndex != -1 ? (Integer) Data.MeleeWeaponData[p.vars.attackIndex][2][1] : 4;
        }
    }
    public static int requestMeleeHit(Player p, NPC n) {
        if (p == null || n == null) {
            ResetAttack(p);
            return 0;
        }
        if (Misc.getDistance(p.absX, p.absY, n.absX, n.absY) > (p.vars.attackIndex != -1 ? (Integer) Data.MeleeWeaponData[p.vars.attackIndex][2][2] : 1)) {
            WalkTo(p, n);
            return 0;
        } else if (Misc.getDistance(p.absX, p.absY, n.absX, n.absY) > 7) {
            ResetAttack(p);
            return 0;
        } else {
            p.requestAnim(p.vars.attackIndex != -1 ?
                    (Integer) Data.MeleeWeaponData[p.vars.attackIndex][1][p.vars.attackStyle[3]] : 422, 0);
            //todo insert NpcAnimating
            FaceToRetaile(p, n);
            int hit = CHit(p, n);
            n.appendHit(hit, 0);
            AddCombatExp(p, (byte) hit);
            return p.vars.attackIndex != -1 ? (Integer) Data.MeleeWeaponData[p.vars.attackIndex][2][1] : 4;
        }
    }
    public static int requestRangeHit(Player p, Player p2) {
        if (p == null || p2 == null) {
            ResetAttack(p);
            return 0;
        }
        if (Misc.getDistance(p.absX, p.absY, p2.absX, p2.absY) > (p.vars.attackIndex != -1 ? (Integer) Data.RangeWeaponData[p.vars.attackIndex][1][3] : 7)) {
            WalkTo(p, p2);
            return 0;
        } else if (Misc.getDistance(p.absX, p.absY, p.absX, p.absY) > 10) {
            ResetAttack(p);
            return 0;
        } else {
            Engine.playerMovement.resetWalkingQueue(p);
            p.requestGFX((Integer) Data.RangeProjectyleData[0][0][1], 100);
            p.requestAnim((Integer) Data.RangeWeaponData[p.vars.attackIndex][1][0], 0);
            p.frames.createProjectile(p, p.absX, p.absY, ((p.absX - p2.absX) * -1), ((p.absY - p2.absY) * -1),
                    (Integer) Data.RangeProjectyleData[0][1][0],
                    (Integer) Data.RangeProjectyleData[0][1][1],
                    (Integer) Data.RangeProjectyleData[0][1][2],
                    (Integer) Data.RangeProjectyleData[0][1][3], p2.playerId);
            FaceToRetaile(p, p2);
            int hit = CHit(p, p2);
            p.appendHit(hit, 0);
            AddCombatExp(p, (byte) hit);
            return p.vars.attackIndex != -1 ? (Integer) Data.RangeWeaponData[p.vars.attackIndex][1][2] : 4;
        }
    }
    public static int requestRangeHit(Player p, NPC n) {
        if (p == null || n == null) {
            ResetAttack(p);
            return 0;
        }
        if (Misc.getDistance(p.absX, p.absY, n.absX, n.absY) > (p.vars.attackIndex != -1 ? (Integer) Data.RangeWeaponData[p.vars.attackIndex][1][3] : 7)) {
            WalkTo(p, n);
            return 0;
        } else if (Misc.getDistance(p.absX, p.absY, p.absX, p.absY) > 10) {
            ResetAttack(p);
            return 0;
        } else {
            Engine.playerMovement.resetWalkingQueue(p);
            p.requestGFX((Integer) Data.RangeProjectyleData[0][0][1], 100);
            p.requestAnim((Integer) Data.RangeWeaponData[p.vars.attackIndex][1][0], 0);
            p.frames.createProjectile(p, p.absX, p.absY, ((p.absX - n.absX) * -1), ((p.absY - n.absY) * -1),
                    (Integer) Data.RangeProjectyleData[0][1][0],
                    (Integer) Data.RangeProjectyleData[0][1][1],
                    (Integer) Data.RangeProjectyleData[0][1][2],
                    (Integer) Data.RangeProjectyleData[0][1][3], n.npcId);
            FaceToRetaile(p, n);
            int hit = CHit(p, n);
            p.appendHit(hit, 0);
            AddCombatExp(p, (byte) hit);
            return p.vars.attackIndex != -1 ? (Integer) Data.RangeWeaponData[p.vars.attackIndex][1][2] : 4;
        }
    }
    public static int requestMageHit(Player p, Player p2) {
        if (p == null || p2 == null) {
            ResetAttack(p);
            return 0;
        }
        if (Misc.getDistance(p.absX, p.absY, p2.absX, p2.absY) > (p.vars.attackIndex != -1 ? (Integer) Data.RangeWeaponData[p.vars.attackIndex][1][3] : 7)) {
            WalkTo(p, p2);
            return 0;
        } else if (Misc.getDistance(p.absX, p.absY, p.absX, p.absY) > 10) {
            ResetAttack(p);
            return 0;
        } else {
            if (!(p.skillLvl[6] >= 53)) {
                p.frames.sendMessage(p, "You need a magic level of 53 to cast this spell.");
                p.vars.attackStyle[0] = 1;
                return 5;
            } else if (!HasRequiredRunes(p, Data.MageProjectyle[0][1])) {
                p.frames.sendMessage(p, "You need have enough runes to cast this spell.");
                p.vars.attackStyle[0] = 1;
                return 5;
            } else {
                FaceToRetaile(p, p2);
                p.requestAnim(711, 0);
                p.requestGFX(138, 100);
                p.frames.createProjectile(p, p.absX, p.absY, ((p.absX - p2.absX) * -1), ((p.absY - p2.absY) * -1), 139, 43, 31, 80, p2.playerId);
                int hit = CHit(p, p2);
                p2.appendHit(hit, 0);
                AddCombatExp(p, (byte) hit);
                if ((Integer) Data.MageProjectyle[0][1][2] != -1) {
                    AddAffect(p2, (Integer) Data.MageProjectyle[0][1][2]);
                }
                return 5;
            }
        }
    }
    public static int requestMageHit(Player p, NPC n) {
        if (p == null || n == null) {
            ResetAttack(p);
            return 0;
        }
        if (Misc.getDistance(p.absX, p.absY, n.absX, n.absY) > (p.vars.attackIndex != -1 ? (Integer) Data.RangeWeaponData[p.vars.attackIndex][1][3] : 7)) {
            WalkTo(p, n);
            return 0;
        } else if (Misc.getDistance(p.absX, p.absY, p.absX, p.absY) > 10) {
            ResetAttack(p);
            return 0;
        } else {
            if (!(p.skillLvl[6] >= 53)) {
                p.frames.sendMessage(p, "You need a magic level of 53 to cast this spell.");
                p.vars.attackStyle[0] = 1;
                return 5;
            } else if (!HasRequiredRunes(p, Data.MageProjectyle[0][1])) {
                p.frames.sendMessage(p, "You need have enough runes to cast this spell.");
                p.vars.attackStyle[0] = 1;
                return 5;
            } else {
                FaceToRetaile(p, n);
                p.requestAnim(711, 0);
                p.requestGFX(138, 100);
                p.frames.createProjectile(p, p.absX, p.absY, ((p.absX - n.absX) * -1), ((p.absY - n.absY) * -1), 139, 43, 31, 80, n.npcId);
                int hit = CHit(p, n);
                n.appendHit(hit, 0);
                AddCombatExp(p, (byte) hit);
                if ((Integer) Data.MageProjectyle[0][1][2] != -1) {
                    AddAffect(n, (Integer) Data.MageProjectyle[0][1][2]);
                }
                return 5;
            }
        }
    }
    public static void setEmoteIndex(Player p) {
        String Weapon = Engine.items.getItemName(p.equipment[3]);
        String Arrow = Engine.items.getItemName(p.equipment[13]);
        String Shield = Engine.items.getItemName(p.equipment[5]);
        /*[DefenceIndex]*/
        for (int i = 0; i < Data.DefenceEmoteData.length; i++) {
            for (int j = 0; j < Data.DefenceEmoteData[i].length; j++) {
                if (Shield.endsWith((String) Data.DefenceEmoteData[i][0][j])
                        || Shield.startsWith((String) Data.DefenceEmoteData[i][0][j])) {
                    p.vars.defenceShieldIndex = i;
                }
            }
        }
        /*[DefenceIndex]*/
        /*[WeaponIndex]*/
        for (int i = 0; i < Data.MeleeWeaponData.length; i++) {
            for (int j = 0; j < Data.MeleeWeaponData[i].length; j++) {
                if (Weapon.endsWith((String) Data.MeleeWeaponData[i][0][j])
                        || Weapon.startsWith((String) Data.MeleeWeaponData[i][0][j])) {
                    p.vars.attackIndex = i;
                    if (p.vars.defenceShieldIndex == -1)
                        p.vars.defenceWeaponIndex = (Integer) Data.MeleeWeaponData[i][2][1];
                }
            }
        }
        /*[WeaponIndex]*/
        /*[ArrowIndex]*/
        for (int i = 0; i < Data.RangeProjectyleData.length; i++) {
            for (int j = 0; j < Data.RangeProjectyleData[i].length; j++) {
                if (Arrow.endsWith((String) Data.RangeProjectyleData[i][0][j])
                        || Arrow.startsWith((String) Data.RangeProjectyleData[i][0][j])) {
                    p.vars.arrowIndex = i;
                }
            }
        }
        /*[ArrowIndex]*/
        p.vars.maxHit = CaculateMaxHit(p);
        if (p.vars.combatStyle == 1) {
            if (Weapon.contains("+") || Weapon.contains("(p)")) {
                p.vars.PoisonLvl = 2;
            }
            if (Weapon.contains("p+")) {
                p.vars.PoisonLvl = 4;
            }
            if (Weapon.contains("p++") || Weapon.contains("(s)")) {
                p.vars.PoisonLvl = 6;
            }
        } else if (p.vars.combatStyle == 2) {
            if (Arrow.contains("+") || Arrow.contains("(p)")) {
                p.vars.PoisonLvl = 2;
            }
            if (Arrow.contains("p+")) {
                p.vars.PoisonLvl = 4;
            }
            if (Arrow.contains("p++") || Arrow.contains("(s)")) {
                p.vars.PoisonLvl = 6;
            }
        }
    }
    public static int CHit(Player p, Player p2) {
        int accurate;
        int AttackBonus = p.equipmentBonus[p.vars.attackStyle[1]];
        int DefenceBonus = p2.equipmentBonus[p.vars.attackStyle[1] + 5];
        int AttackBonusLvl = p.skillLvl[p.vars.attackStyle[1] == 3
                ? 6/*magic */ : p.vars.attackStyle[1] == 4
                ? 4/*range*/ : 0];
        int DefenceBonusLvl = p2.skillLvl[p.vars.attackStyle[1]];
        int bonusDiff = AttackBonus - DefenceBonus;
        int LvlDiff = AttackBonusLvl - DefenceBonusLvl;
        int Diff = ((LvlDiff * 2) + bonusDiff);
        if (p.prayers[p.vars.attackStyle[1] == 3
                ? 18/*magic */ : p.vars.attackStyle[1] == 4
                ? 19/*range*/ : 20] & Misc.random(1) == 0)
            return 0;
        if (Diff == 0) {
            if (Misc.random(100) > 50)
                return 0;
            else
                return Misc.random(p.vars.maxHit);
        } else {
            if (Diff < 0) {
                accurate = 100 - Math.abs((int) ((((double) (Math.abs(Diff)) / 100) - 1) * 100));
            } else {
                accurate = Diff;
            }
            if (accurate < 20) {
                accurate = 20;
            }
            //todo add prayer in. on style accurate.
            if (Misc.random(100) > accurate) {
                return 0;
            } else {
                return Misc.random(p.vars.maxHit);
            }
        }
    }
    public static int CHit(Player p, NPC n) {
        int accurate;
        int AttackBonus = p.equipmentBonus[p.vars.attackStyle[1]];
        int DefenceBonus = n.Bonus[p.vars.attackStyle[1] + 5];
        int AttackBonusLvl = p.skillLvl[p.vars.attackStyle[1] == 3
                ? 6/*magic */ : p.vars.attackStyle[1] == 4
                ? 4/*range*/ : 0];
        int DefenceBonusLvl = 100;
        int bonusDiff = AttackBonus - DefenceBonus;
        int LvlDiff = AttackBonusLvl - DefenceBonusLvl;
        int Diff = ((LvlDiff * 2) + bonusDiff);
        if (p.prayers[p.vars.attackStyle[1] == 3
                ? 18/*magic */ : p.vars.attackStyle[1] == 4
                ? 19/*range*/ : 20] & Misc.random(1) == 0)
            return 0;
        if (Diff == 0) {
            if (Misc.random(100) > 50)
                return 0;
            else
                return Misc.random(p.vars.maxHit);
        } else {
            if (Diff < 0) {
                accurate = 100 - Math.abs((int) ((((double) (Math.abs(Diff)) / 100) - 1) * 100));
            } else {
                accurate = Diff;
            }
            if (accurate < 20) {
                accurate = 20;
            }
            //todo add prayer in. on style accurate.
            if (Misc.random(100) > accurate) {
                return 0;
            } else {
                return Misc.random(p.vars.maxHit);
            }
        }
    }
    public static int CaculateMaxHit(Player p) {
        double maxHit;
        double baseStrengthLevelArray[] = new double[99];
        double baseStrengthWithBonus = 0;
        double baseStrengthWithBonusStyle = 0;
        int strLevel = p.skillLvl[1];
        double startStrength = 1.5;
        for (int i = 1; i <= 99; i++) {
            baseStrengthLevelArray[i] = startStrength;
            startStrength = startStrength + 0.1;
        }
        baseStrengthWithBonus = baseStrengthLevelArray[strLevel] + (0.16775 * p.equipmentBonus[10]);
        baseStrengthWithBonusStyle += baseStrengthWithBonus;
        switch (p.vars.attackStyle[2]) {
            case 2:
                baseStrengthWithBonusStyle += 0.3 + (p.equipmentBonus[10] * (0.3 + ((29 / 6000))));
                break;
            case 3:
                baseStrengthWithBonusStyle += 0.3 + (p.equipmentBonus[10] * (0.3 + ((29 / 6000))));
            default:
                baseStrengthWithBonusStyle += (p.equipmentBonus[10] * (0.1 + ((1 / 600))));
                break;
        }
        if (p.prayers[26]) {
            baseStrengthWithBonusStyle = baseStrengthWithBonusStyle * 1.23;
        }
        if (p.prayers[25]) {
            baseStrengthWithBonusStyle = baseStrengthWithBonusStyle * 1.18;
        }
        if (p.prayers[14]) {
            baseStrengthWithBonusStyle = baseStrengthWithBonusStyle * 1.15;
        }
        if (p.prayers[6]) {
            baseStrengthWithBonusStyle = baseStrengthWithBonusStyle * 1.10;
        }
        if (p.prayers[1]) {
            baseStrengthWithBonusStyle = baseStrengthWithBonusStyle * 1.05;
        }
        maxHit = Math.round(baseStrengthWithBonusStyle);
        return (int) maxHit;
    }
    public static void ResetAttack(Player p) {
        if (p == null) {
            return;
        }
        p.attackingPlayer = false;
        p.attackPlayer = -1;
        if (p.faceToReq != 65535) {
            p.requestFaceTo(65535);
        }
    }
    public static void ResetAttack(NPC n) {
        if (n == null) {
            return;
        }
        n.attackingPlayer = false;
        n.attackPlayer = -1;
        if (n.faceToRequest != 65535) {
            n.requestFaceTo(65535);
        }
    }
    //todo
    public static void WalkTo(Player p, Player p2) {
    }
    //todo
    public static void WalkTo(Player p, NPC n) {
    }
    public static void FaceToRetaile(Player p, Player p2) {
        if (p.faceToReq != p2.playerId + 32768)
            p.requestFaceTo(p2.playerId + 32768);
        if (p2.faceToReq != p.playerId + 32768)
            p2.requestFaceTo(p2.playerId + 32768);
        if ((p2.vars.autoRetaliete && p2.attackPlayer != p.playerId) ||
                !p2.attackingPlayer && p2.vars.autoRetaliete) {
            p2.attackPlayer = p.playerId;
            p2.attackingPlayer = true;
        }
    }
    private static void FaceToRetaile(Player p, NPC n) {
        if (n.faceToRequest != p.attackPlayer + 32768)
            n.requestFaceTo(p.attackPlayer + 32768);
        if (n.faceToRequest != p.playerId + 32768)
            n.requestFaceTo(p.playerId + 32768);
        if (n.attackPlayer != p.playerId) {
            n.attackPlayer = p.playerId;
            n.attackingPlayer = true;
        }
    }
    public static void AddCombatExp(Player p, byte hit) {
        for (int i = 1; i < Data.AddCombatXp[p.vars.attackStyle[2] - 1].length; i++) {
            p.addSkillXP(Data.AddCombatXp[p.vars.attackStyle[2] - 1][i][0] * hit,
                    (int) Data.AddCombatXp[p.vars.attackStyle[2] - 1][i][1]);
        }
    }
    //todo
    public static boolean HasRequiredRunes(Player p, Object[] Primary, Object[] Sucendary) {
        Object[] neededRunes = Primary;
        int ElemantalRunes[] = {556, 555, 557, 554, 560, 562, 565, 566};
        boolean Crunes = false;
        for (int i = 0; i < Sucendary.length / 2; i++) {
            if (!(Engine.playerItems.invItemCount(p, (Integer) Sucendary[i]) >= (Integer) Sucendary[(Sucendary.length / 2) + 1])) {
                p.frames.sendMessage(p, "You don't have enough runes to cast this spell.");
                p.vars.attackStyle[0] = 1;
                return false;
            }
        }
        for (int i = 0; i < Data.staffArguments.length; i++) {
            for (int j = 0; j < Data.staffArguments[i][0].length; j++) {
                if (p.equipment[3] == Data.staffArguments[i][0][j]) {
                    for (int k = 0; k < (neededRunes.length / 2); k++) {
                        for (int l = 0; l < Data.staffArguments[i][1].length; l++) {
                            if ((Integer) neededRunes[k] == Data.staffArguments[i][1][l]) {
                                neededRunes[neededRunes.length / 2 + k] = 0;
                                Primary[neededRunes.length / 2 + k] = -1;
                            }
                        }
                    }
                }
            }
        }
        for (int i = 0; i < (neededRunes.length / 2); i++) {
            for (int j = 0; j < ElemantalRunes.length; j++) {
                if (ElemantalRunes[j] == (Integer) neededRunes[i])
                    if (Engine.playerItems.invItemCount(p, (Integer) neededRunes[i]) >= (Integer) neededRunes[(neededRunes.length / 2) + i])
                        neededRunes[(neededRunes.length / 2) + i] = 0;
            }
        }
        for (int i = 0; i < neededRunes.length / 2; i++) {
            if (neededRunes.length / 2 + 1 > 0)
                Crunes = true;
        }
        if (Crunes) {
            //todo write mulitple support
        }
        for (int i = 0; i < neededRunes.length / 2; i++) {
            if (neededRunes.length / 2 + 1 > 0) {
                p.frames.sendMessage(p, "You don't have enough runes to cast this spell.");
                p.vars.attackStyle[0] = 1;
                return false;
            }
        }
        for (int i = 0; i < Primary.length / 2; i++) {
            Engine.playerItems.deleteItem(p, (Integer) Primary[i], Engine.playerItems.getItemSlot(p, (Integer) Primary[i]), (Integer) Primary[Primary.length / 2 + i]);
        }
        for (int i = 0; i < Sucendary.length / 2; i++) {
            Engine.playerItems.deleteItem(p, (Integer) Sucendary[i], Engine.playerItems.getItemSlot(p, (Integer) Sucendary[i]), (Integer) Sucendary[Sucendary.length / 2 + i]);
        }
        return true;
    }
    //todo
    public static void AddAffect(Player p, int AffectNo) {
        switch (AffectNo) {
            case 1:
                p.requestAnim(1979, 0);
                new Freeze(p, 5, true);
                break;
        }
    }
    //todo
    public static void AddAffect(NPC n, int AffectNo) {
        switch (AffectNo) {
            case 1:
                n.requestAnim(1979, 0);
                new Freeze(n, 5);
                break;
        }
    }
}


Spoiler for Data.class:
Code:
package sds.rs2.content.Combat;
/**
 * Created by IntelliJ IDEA.
 * User: -
 * Date: 21-sep-2009
 * Time: 15:11:16
 * To change this template use File | Settings | File Templates.
 */
public class Data {
    private static final int EARTH = 554;
    private static final int WATER = 555;
    private static final int AIR = 556;
    private static final int FIRE = 557;
    private static final int MIND = 555;
    private static final int CHAOS = 562;
    private static final int DEATH = 560;
    private static final int BLOOD = 565;
    private static final int SOUL = 566;
 
    //todo : implent these :  "spear", "spear(s)", "spear(kp)","staff", "Staff",
    //todo : implent these :  "axe", "flail",  "Torags hammers","spear(p)", "spear(+)",
    public static final Object[][][] MeleeWeaponData = {
            //  {{""/*Weapon arguments*/}, {0/*Stab*/, 0/*slash*/, 0/*crush*/}, {0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"Unarmed"}, {422, 422, 422}, {424, 0, 1}},
            {{"flail"}, {-1, -1, 1665}, {1666, 4, 1}},
            {{"maul"}, {-1, -1, 1665}, {1666, 4, 1}},
            {{"godsword"}, {-1, 407, 406}, {410, 4, 1}},
            {{"Abyssal whip"}, {-1, 1658, -1}, {1659, 4, 1}},
            {{"halberd"}, {-1, 440, -1}, {-1, 4, 2}},
            {{"dagger"}, {386, 390, -1}, {388, 4, 1}},
            {{"scimitar"}, {386, 390, -1}, {388, 4, 1}},
            {{"mace"}, {400, -1, 401}, {403, 4, 1}},
            {{"longsword"}, {386, 390, -1}, {388, 4, 1}},
            {{"sword"}, {386, 390, -1}, {388, 4, 1}},
            {{"battleaxe"}, {-1, 395, 401}, {397, 4, 1}},
            {{" axe"}, {-1, 395, 401}, {397, 4, 1}},
            {{"warhammer"}, {-1, -1, 401}, {403, 4, 1}},
            {{"2h sword"}, {-1, 7041, 7048}, {7050, 4, 1}},
    };
    public static final Object[][][] RangeWeaponData = {
            //     {{"argumetns "}{"/*pullback*/},, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"dart", "dart(p)"}, {0/*pullback*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"Longbow", "longbow"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"Shortbow", "shortbow"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"javelin", "javelin(p)"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"knife", "knife(p)"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"crossbow", "Crossbow", "c'bow"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"Toktz-xil"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"Toktz-mej"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"Tzhaar-ket"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"Crystal bow"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"Dark bow"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"Ogre bow", "Comp ogre bow"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"Seercull"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
            {{"Training bow"}, {0/*AttackEmote*/, 0/*DefEmote*/, 0/*delay*/, 0/*distance*/}},
    };
    public static final Object[][][] RangeProjectyleData = {
            // gfx moving,startheight,endhieght,speed
            {{"bronze arrow"}, {18, 0, 0, 35}},
            {{"Iron arrow"}, {17}},
            {{"steel arrow"}, {20}},
            {{"mithril arrow"},},
            {{"adamant arrow"},},
            {{"rune arrow"},},
            {{"dragon arrow"},},
            {{"Iron knife"}, { /*gfx moving*/}},
            {{"Bronze knife"}, { /*gfx moving*/}},
            {{"Steel knife"}, { /*gfx moving*/}},
            {{"Black knife"}, { /*gfx moving*/}},
            {{"Mithril knife"}, { /*gfx moving*/}},
            {{"Adamant knife"}, { /*gfx moving*/}},
            {{"Rune knife"}, { /*pullback*/}},
 
    };
    //todo: add {"kiteshield", "sq shield", "Toktz-ket", "books", "book","kiteshield (t)", "kiteshield (g)", "kiteshield(h)", "defender", "shield"};
    public static final Object[][][] DefenceEmoteData = {
            {{"kiteshield", "sq shield", "kiteshield (t)", "kiteshield (g)", "kiteshield(h)"}, {424}}
    };
    public static final Object[][][] MageProjectyle = {
            /* description  */     /*lvl,minxp,affect*/    /*runes*/         /*projectyle*/
            {{"Earth Blast"}, {1, 10, -1}, {AIR,1},{MIND,1}, {139, 43, 31, 80}}     
    };
 
    public static final double[][][] AddCombatXp = {
            {{1}, {4, 0}, {1.33, 3}}, {{2}, {4, 2}, {1.33, 3}},
            {{3}, {4, 1}, {1.33, 3}}, {{4}, {1.33, 0}, {1.33, 1}, {1.33, 2}, {1.33, 3}},
            {{5}, {4, 5}, {1.33, 3}}, {{6}, {2, 5}, {2, 1}, {1.33, 3}},
            {{7}, {2, 6}, {1.33, 3}}, {{7}, {2, 6}, {2, 1}, {1.33, 3}}};
 
       public static final int[][][] staffArguments = {
            {{1405, 1381, 1397}, {AIR}},
            {{1403, 1383, 1395}, {WATER}},
            {{1407, 1385, 1399}, {EARTH}},
            {{1401, 1397, 1393}, {FIRE}},
            {{3054, 3053}, {FIRE, EARTH}},
            {{6562, 6563}, {FIRE, WATER}},
    };
}


Spoiler for PlayerCombat.class:

Code:
/*
 * Class PlayerCombat
 *
 * Version 1.0
 *
 * Thursday, August 28, 2008
 *
 * Created by Palidino76
 */
package sds.rs2.players.combat;
import sds.rs2.Engine;
import sds.rs2.content.Hit;
import sds.rs2.content.Specials;
import sds.rs2.content.Combat.Combat;
import sds.rs2.players.Player;

public class PlayerCombat {
    public void attackPlayer(Player p) {
        if (p.attackPlayer <= 0 || p.attackPlayer >= Engine.players.length || Engine.players[p.attackPlayer] == null ||
                Engine.players[p.attackPlayer].isDead) {
            Combat.ResetAttack(p);
        }
        if (p.combatDelay > 0) {
            return;
        }
        Player p2 = Engine.players[p.attackPlayer];
        if (p.usingSpecial) {
            new Specials(p, p2);
        } else {
            switch (p.vars.attackStyle[0]) {
                case 1:
                    p.combatDelay = Combat.requestMeleeHit(p, p2);
                    break;
                case 2:
                    p.combatDelay = Combat.requestRangeHit(p, p2);
                    break;
                case 3:
                    p.combatDelay = Combat.requestMageHit(p, p2);
                    break;
            }
        }
    }
}