mirror of
https://github.com/2006-Scape/2006Scape.git
synced 2026-07-03 00:31:51 +00:00
RedSparr0w
2048 lines
59 KiB
Java
2048 lines
59 KiB
Java
package redone.game.players;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import redone.Constants;
|
|
import redone.Server;
|
|
import redone.game.content.combat.prayer.PrayerDrain;
|
|
import redone.game.content.minigames.castlewars.CastleWars;
|
|
import redone.game.items.Item;
|
|
import redone.game.items.ItemAssistant;
|
|
import redone.game.npcs.Npc;
|
|
import redone.game.npcs.NpcHandler;
|
|
import redone.game.npcs.impl.Pets;
|
|
import redone.util.ISAACRandomGen;
|
|
import redone.util.Misc;
|
|
import redone.util.Stream;
|
|
|
|
public abstract class Player {
|
|
|
|
public String currentTime, date, creationAddress = "", slayerMaster;
|
|
|
|
public boolean lostCannon = false, refresh = false, isBot = false;
|
|
|
|
public ArrayList<String> killedPlayers = new ArrayList<String>();
|
|
public ArrayList<Integer> attackedPlayers = new ArrayList<Integer>();
|
|
public ArrayList<String> lastKilledPlayers = new ArrayList<String>();
|
|
|
|
public int CraftInt, Dcolor, FletchInt, clanId = -1;
|
|
|
|
public int[][] barrowCrypt = {
|
|
{4921, 0},
|
|
{2035, 0}
|
|
};
|
|
|
|
public long homeTele, lastDesert, eventTimer, lastRunRecovery,
|
|
lastButton, lastFire, lastLight, muteTime, waitTime, miscTimer,
|
|
ladderTimer, webSlashDelay, climbDelay, lastReport = 0,
|
|
lastPlayerMove, lastPoison, lastPoisonSip, poisonImmune, lastSpear,
|
|
lastProtItem, dfsDelay, lastVeng, lastYell, teleGrabDelay,
|
|
protMageDelay, protMeleeDelay, protRangeDelay, lastAction,
|
|
lastThieve, lastLockPick, alchDelay, specDelay = System.currentTimeMillis(), duelDelay, teleBlockDelay,
|
|
godSpellDelay, singleCombatDelay, singleCombatDelay2, reduceStat,
|
|
restoreStatsDelay, logoutDelay, buryDelay, foodDelay, potDelay,
|
|
doorDelay, doubleDoorDelay, buySlayerTimer, lastIncrease,
|
|
boneDelay, botAttempts, leverDelay = 0, farmTime, searchObjectDelay = 0;
|
|
|
|
|
|
private Npc specialTarget = null;
|
|
public void setSpecialTarget(Npc target) {
|
|
this.specialTarget = target;
|
|
}
|
|
public Npc getSpecialTarget() {
|
|
return specialTarget;
|
|
}
|
|
|
|
public boolean initialized = false, musicOn = true, luthas,
|
|
playerIsCooking, disconnected = false, ruleAgreeButton = false,
|
|
RebuildNPCList = false, isActive = false, isKicked = false,
|
|
isSkulled = false, friendUpdate = false, newPlayer = false,
|
|
hasMultiSign = false, saveCharacter = false, mouseButton = false,
|
|
chatEffects = true, acceptAid = false, recievedMask,
|
|
nextDialogue = false, autocasting = false, usedSpecial = false,
|
|
mageFollow = false, dbowSpec = false, craftingLeather = false,
|
|
properLogout = false, secDbow = false, maxNextHit = false,
|
|
ssSpec = false, vengOn = false, addStarter = false,
|
|
accountFlagged = false, inPartyRoom = false, msbSpec = false,
|
|
hasBankPin, enterdBankpin, firstPinEnter, requestPinDelete,
|
|
secondPinEnter, thirdPinEnter, fourthPinEnter, hasBankpin,
|
|
isBanking, isTeleporting = false, desertWarning,
|
|
isPotionMaking = false, isGrinding = false, hasStarter, isSpinning,
|
|
clickedSpinning, hasPaidBrim, isHerblore, herbloreI, secondHerb,
|
|
playerStun, playerFletch, isWoodcutting, playerIsFiremaking,
|
|
hasNpc = false, playerIsFishing = false, isOperate, below459 = true,
|
|
splitChat, strongHold, village, needsNewTask = false,
|
|
canSpeak = true, ignoreFrog, ratdied2 = false,
|
|
fishingWhirlPool, lostDuel, diedOnTut = false, storing = false, rope, rope2,
|
|
canWalkTutorial, closeTutorialInterface, isCrafting, showedUnfire,
|
|
showedFire, isPotCrafting, isFiremaking, playerIsFletching, milking,
|
|
stopPlayerPacket, spiritTree = false, isSmelting,
|
|
hasPaifAnTeleport = false, isSmithing, doingAgility = false,
|
|
hasPaid, canTeleport, magicCharge, isBanned = false, fletchNerfed,
|
|
clickedVamp = false, allowFading, isBotting = false, otherBank = false,
|
|
recievedReward = false, poison, golemSpawned = false, zombieSpawned = false, shadeSpawned = false,
|
|
treeSpiritSpawned = false, chickenSpawned = false, clickedTree = false, filter = true,
|
|
stopPlayer = false, npcCanAttack = true, gliderOpen = false, hasSandwhichLady = false,
|
|
isHarvesting, openDuel = false, killedJad = false, canHealersRespawn = true, playerIsBusy = false, miningRock,
|
|
randomEventsEnabled = false, debugMode = false, clickToTele = false;
|
|
|
|
public int votePoints, thankedForDonation, saveDelay, playerKilled, gertCat, restGhost,
|
|
romeojuliet, runeMist, vampSlayer, cookAss, doricQuest, blackKnight, shieldArrav,
|
|
dragonSlayerQuestStage, sheepShear, impsC, randomActions, pkPoints,
|
|
totalPlayerDamageDealt, killedBy, lastChatId = 1, privateChat,
|
|
friendSlot = 0, dialogueId, randomCoffin, newLocation, specEffect,
|
|
specBarId, attackLevelReq, defenceLevelReq, strengthLevelReq,
|
|
rangeLevelReq, magicLevelReq, slayerLevelReq, agilityLevelReq,
|
|
followId, skullTimer, nextChat = 0, talkingNpc = -1,
|
|
dialogueAction = 0, autocastId, followDistance, followId2,
|
|
barrageCount = 0, delayedDamage = 0, delayedDamage2 = 0,
|
|
pcPoints = 0, magePoints = 0, desertTreasure = 0,
|
|
lastArrowUsed = -1, autoRet = 1, pcDamage = 0, xInterfaceId = 0,
|
|
xRemoveId = 0, xRemoveSlot = 0, tzhaarToKill = 0, tzhaarKilled = 0,
|
|
waveId, frozenBy = 0, poisonDamage = 0, teleAction = 0,
|
|
bonusAttack = 0, lastNpcAttacked = 0, killCount = 0, witchspot,
|
|
pirateTreasure, ptjob, cwKills, cwDeaths, cwGames, tzKekSpawn = 0,
|
|
playerBankPin, recoveryDelay = 3, attemptsRemaining = 3,
|
|
lastPinSettings = -1, setPinDate = -1, changePinDate = -1,
|
|
deletePinDate = -1, firstPin, secondPin, thirdPin, fourthPin,
|
|
bankPin1, bankPin2, bankPin3, bankPin4, pinDeleteDateRequested,
|
|
rememberNpcIndex, lastLoginDate, selectedSkill, log = -1, newHerb,
|
|
newItem, newXp, doingHerb, herbAmount, treeX, treeY, lastH,
|
|
cookingItem, cookingObject, summonId, npcId2 = 0, leatherType = -1,
|
|
weightCarried, teleotherType, rockX, rockY, itemUsing, tzKekTimer,
|
|
bananas, flourAmount, grain, questPoints, questStages,
|
|
teleGrabItem, teleGrabX, teleGrabY, duelCount, underAttackBy,
|
|
underAttackBy2, wildLevel, teleTimer, respawnTimer, saveTimer = 0,
|
|
teleBlockLength, poisonDelay, slayerPoints, blackMarks,
|
|
SlayerMaster, teleOtherTimer = 0,
|
|
teleOtherSlot = -1, tutorialProgress, Cookstage1 = 1,
|
|
woodcuttingTree, smeltAmount, knightS, otherDirection,
|
|
brightness = 3, recoilHits, droppedItem = -1,
|
|
spawnedHealers, cannonX = 0, cannonY = 0,
|
|
playerShopId;
|
|
|
|
public double playerEnergy = 100;
|
|
|
|
public Pets getSummon() {
|
|
return pets;
|
|
}
|
|
|
|
private final Pets pets = new Pets();
|
|
|
|
public int removedTasks[] = { -1, -1, -1, -1 };
|
|
|
|
public boolean isRunning() {
|
|
return isNewWalkCmdIsRunning() || isRunning2 && isMoving;
|
|
}
|
|
|
|
public void faceNpc(int npc) {
|
|
face = npc;
|
|
faceUpdateRequired = true;
|
|
updateRequired = true;
|
|
}
|
|
|
|
public void faceNPC(int index) {
|
|
faceNPC = index;
|
|
faceNPCupdate = true;
|
|
updateRequired = true;
|
|
}
|
|
|
|
protected boolean faceNPCupdate = false;
|
|
public int faceNPC = -1;
|
|
|
|
public void appendFaceNPCUpdate(Stream str) {
|
|
str.writeWordBigEndian(faceNPC);
|
|
}
|
|
|
|
public int getLocalX() {
|
|
return getX() - 8 * getMapRegionX();
|
|
}
|
|
|
|
public int getLocalY() {
|
|
return getY() - 8 * getMapRegionY();
|
|
}
|
|
|
|
public int getKillCount() {
|
|
return barrowsKillCount;
|
|
}
|
|
|
|
/**
|
|
* @param randomGrave
|
|
* the randomGrave to set
|
|
*/
|
|
public void setRandomGrave(int randomGrave) {
|
|
this.randomGrave = randomGrave;
|
|
}
|
|
|
|
/**
|
|
* @return the randomGrave
|
|
*/
|
|
public int getRandomGrave() {
|
|
return randomGrave;
|
|
}
|
|
|
|
private int randomGrave;
|
|
|
|
public void setBarrowsNpcDead(int index, boolean dead) {
|
|
barrowsNpcDead[index] = dead;
|
|
}
|
|
|
|
/**
|
|
* @return the barrowsNpcDead
|
|
*/
|
|
public boolean[] getBarrowsNpcDead() {
|
|
return barrowsNpcDead;
|
|
}
|
|
|
|
/**
|
|
* @return the barrowsNpcDead
|
|
*/
|
|
public boolean getBarrowsNpcDead(int id) {
|
|
return barrowsNpcDead[id];
|
|
}
|
|
|
|
private final boolean barrowsNpcDead[] = new boolean[6];
|
|
|
|
public abstract void updateWalkEntities();
|
|
|
|
public boolean membership = false, awardedmembership = false;
|
|
public Client teleporter = null;
|
|
public int[] miningSettings = new int[10];
|
|
public int[] fishingProp = new int[13];
|
|
public int[] party = new int[8];
|
|
public int[] partyN = new int[8];
|
|
public int[] cookingProp = new int[7];
|
|
public int[] cookingCoords = new int[2];
|
|
public String lastReported = "";
|
|
public String bankPin = "";
|
|
public int attempts = 3;
|
|
public boolean setPin = false;
|
|
public int[][] playerSkillProp = new int[20][15];
|
|
public boolean[] playerSkilling = new boolean[20];
|
|
public boolean stopPlayerSkill;
|
|
public int doAmount, addAmount;
|
|
public int lastNpcClickIndex;
|
|
public boolean[] killedPheasant = new boolean[5];
|
|
public boolean playerHasRandomEvent;
|
|
public boolean canLeaveArea;
|
|
public int pieSelect = 0, getPheasent, kebabSelect = 0, breadID,
|
|
chocSelect = 0, bagelSelect = 0, triangleSandwich = 0,
|
|
squareSandwich = 0, breadSelect = 0;
|
|
public String clanName, properName;
|
|
public int lastX, lastY;
|
|
public int[] voidStatus = new int[5];
|
|
public int[] itemKeptId = new int[4];
|
|
public int[] pouches = new int[4];
|
|
public final int[] POUCH_SIZE = { 3, 6, 9, 12 };
|
|
public boolean[] invSlot = new boolean[28], equipSlot = new boolean[14];
|
|
public long friends[] = new long[200], ignores[] = new long[200];
|
|
public double specAmount = 0;
|
|
public double specAccuracy = 1;
|
|
public double specDamage = 1;
|
|
public boolean isFletching;
|
|
public double weight = 0.0;
|
|
|
|
public boolean canChangeAppearance = false;
|
|
public boolean mageAllowed;
|
|
public int poisonMask;
|
|
|
|
public Npc getCloseRandomNpc(int distance) {
|
|
ArrayList<Npc> npcs = new ArrayList<Npc>();
|
|
for (Npc npc : NpcHandler.npcs) {
|
|
if (npc != null) {
|
|
Npc n = npc;
|
|
if (distanceToPoint(n.getX(), n.getY()) <= distance) {
|
|
if (!n.underAttack) {
|
|
if (n.heightLevel == heightLevel) {
|
|
npcs.add(n);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (npcs.size() > 0) {
|
|
return npcs.get(Misc.random(npcs.size() - 1));
|
|
} else {
|
|
return null; // No near npcs :C
|
|
}
|
|
}
|
|
|
|
public boolean isAutoButton(int button) {
|
|
for (int j = 0; j < autocastIds.length; j += 2) {
|
|
if (autocastIds[j] == button) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public int[] autocastIds = { 51133, 32, 51185, 33, 51091, 34, 24018, 35,
|
|
51159, 36, 51211, 37, 51111, 38, 51069, 39, 51146, 40, 51198, 41,
|
|
51102, 42, 51058, 43, 51172, 44, 51224, 45, 51122, 46, 51080, 47,
|
|
7038, 0, 7039, 1, 7040, 2, 7041, 3, 7042, 4, 7043, 5, 7044, 6,
|
|
7045, 7, 7046, 8, 7047, 9, 7048, 10, 7049, 11, 7050, 12, 7051, 13,
|
|
7052, 14, 7053, 15, 47019, 27, 47020, 25, 47021, 12, 47022, 13,
|
|
47023, 14, 47024, 15 };
|
|
|
|
// public String spellName = "Select Spell";
|
|
public void assignAutocast(int button) {
|
|
for (int j = 0; j < autocastIds.length; j++) {
|
|
if (autocastIds[j] == button) {
|
|
Client c = (Client) PlayerHandler.players[playerId];
|
|
autocasting = true;
|
|
autocastId = autocastIds[j + 1];
|
|
c.getPlayerAssistant().sendConfig(108, 1);
|
|
c.getActionSender().setSidebarInterface(0, 328);
|
|
// spellName = getSpellName(autocastId);
|
|
// spellName = spellName;
|
|
// c.getPA().sendString(spellName, 354);
|
|
c = null;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean inCWsaraBase() {
|
|
if (absX > 2422 && absX < 2432 && absY > 3071 && absY < 3081
|
|
&& heightLevel == 1) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean inCWzammyBase() {
|
|
if (absX > 2367 && absX < 2377 && absY > 3126 && absY < 3136
|
|
&& heightLevel == 1) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean saraTeam() {
|
|
return playerEquipment[Constants.CAPE] == 4041;
|
|
}
|
|
|
|
public boolean zammyTeam() {
|
|
return playerEquipment[Constants.CAPE] == 4042;
|
|
}
|
|
|
|
public boolean inCwSafe() {
|
|
return (isInAreaxxyy(2423, 2431, 3072, 3080) || isInAreaxxyy(2368, 2376, 3127, 3135))
|
|
&& heightLevel == 1;
|
|
}
|
|
|
|
public boolean inZammyWait() {
|
|
return isInAreaxxyy(2409, 2431, 9511, 9535);
|
|
}
|
|
|
|
public boolean inSaraWait() {
|
|
return isInAreaxxyy(2368, 2392, 9479, 9498);
|
|
}
|
|
|
|
public boolean inCwGame() {
|
|
return isInAreaxxyy(2368, 2431, 9479, 9535) || isInAreaxxyy(2368, 2431, 3072, 3135)
|
|
&& !inSaraWait() && !inZammyWait();
|
|
}
|
|
|
|
public boolean inCwUnderground() {
|
|
return isInAreaxxyy(2368, 2431, 9479, 9535) && !inSaraWait() && !inZammyWait();
|
|
}
|
|
|
|
public boolean inZammyBase() {
|
|
return isInAreaxxyy(2368, 2384, 3118, 3135);
|
|
}
|
|
|
|
public boolean inSaraBase() {
|
|
return isInAreaxxyy(2414, 2431, 3072, 3088);
|
|
}
|
|
|
|
public void gameInterface(int id) {
|
|
if (gameInterface != id) {
|
|
gameInterface = id;
|
|
}
|
|
}
|
|
|
|
public int gameInterface;
|
|
public int lastGame;
|
|
|
|
|
|
public int[][] barrowsNpcs = { { 2030, 0 }, // verac
|
|
{ 2029, 0 }, // toarg
|
|
{ 2028, 0 }, // karil
|
|
{ 2027, 0 }, // guthan
|
|
{ 2026, 0 }, // dharok
|
|
{ 2025, 0 } // ahrim
|
|
};
|
|
|
|
public int barrowsKillCount;
|
|
|
|
public int reduceSpellId;
|
|
public final int[] REDUCE_SPELL_TIME = { 250000, 250000, 250000, 500000,
|
|
500000, 500000 }; // how long does the other player stay immune to
|
|
// the spell
|
|
public long[] reduceSpellDelay = new long[6];
|
|
public final int[] REDUCE_SPELLS = { 1153, 1157, 1161, 1542, 1543, 1562 };
|
|
public boolean[] canUseReducingSpell = { true, true, true, true, true, true };
|
|
|
|
public int slayerTask, taskAmount;
|
|
|
|
public int duelTimer, duelTeleX, duelTeleY, duelSlot, duelSpaceReq,
|
|
duelOption, duelingWith, duelStatus;
|
|
public int headIconPk = -1, headIconHints;
|
|
public boolean duelRequested;
|
|
public boolean[] duelRule = new boolean[22];
|
|
public final int[] DUEL_RULE_ID = { 1, 2, 16, 32, 64, 128, 256, 512, 1024,
|
|
4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 2097152,
|
|
8388608, 16777216, 67108864, 134217728 };
|
|
|
|
public boolean doubleHit, usingSpecial, npcDroppingItems, usingRangeWeapon,
|
|
usingBow, usingMagic, castingMagic;
|
|
public int npcIndex, npcClickIndex, npcType, castingSpellId, oldSpellId,
|
|
spellId, hitDelay;
|
|
public int specMaxHitIncrease, freezeDelay, freezeTimer = -6, killerId,
|
|
playerIndex, oldPlayerIndex, lastWeaponUsed, projectileStage,
|
|
crystalBowArrowCount, playerMagicBook, teleGfx, teleEndAnimation,
|
|
teleHeight, teleX, teleY, rangeItemUsed, killingNpcIndex,
|
|
totalDamageDealt, globalDamageDealt, oldNpcIndex, fightMode, attackTimer;
|
|
public boolean magicFailed, oldMagicFailed;
|
|
public int bowSpecShot, clickNpcType, clickObjectType, objectId, objectX,
|
|
objectY;
|
|
public int pItemX, pItemY, pItemId;
|
|
public boolean isMoving, walkingToItem;
|
|
public boolean isShopping, updateShop;
|
|
public int myShopId;
|
|
public int tradeStatus, tradeWith;
|
|
public boolean forcedChatUpdateRequired, inDuel, tradeAccepted, goodTrade,
|
|
inTrade, tradeRequested, tradeResetNeeded, tradeConfirmed,
|
|
tradeConfirmed2, acceptTrade, acceptedTrade;
|
|
public int attackAnim, animationRequest = -1, animationWaitCycles;
|
|
public int[] playerBonus = new int[12];
|
|
public boolean isRunning2 = true;
|
|
public boolean takeAsNote;
|
|
public int combatLevel;
|
|
public boolean saveFile = false;
|
|
public int playerAppearance[] = new int[13];
|
|
public int apset;
|
|
public int actionID;
|
|
public int wearItemTimer, wearId, wearSlot, interfaceId;
|
|
public int XremoveSlot, XinterfaceID, XremoveID, Xamount;
|
|
|
|
// public int tutorial;
|
|
public boolean usingGlory = false;
|
|
public int[] woodcut = new int[7];
|
|
public int wcTimer = 0;
|
|
public int miningTick = 0;
|
|
public int miningAnimTick = 0;
|
|
public int miningRockId = -1;
|
|
public int miningX = -1;
|
|
public int miningY = -1;
|
|
public boolean fishing = false;
|
|
public int fishTimer = 0;
|
|
public boolean isMining;
|
|
public int smeltType; // 1 = bronze, 2 = iron, 3 = steel, 4 = gold, 5 =
|
|
// mith, 6 = addy, 7 = rune
|
|
public int smeltTimer = 0;
|
|
public boolean smeltInterface;
|
|
public boolean patchCleared;
|
|
public int[] farmData = new int[2];
|
|
|
|
public boolean antiFirePot = false;
|
|
|
|
public boolean underWater = false;
|
|
public boolean prevRunning2;
|
|
public int prevPrevPlayerRunIndex;
|
|
public int prevPlayerStandIndex;
|
|
public int prevplayerWalkIndex;
|
|
public int prevPlayerTurnIndex;
|
|
public int prevPlayerTurn90CWIndex;
|
|
public int prevPlayerTurn90CCWIndex;
|
|
public int prevPlayerTurn180Index;
|
|
|
|
public Client asClient() {
|
|
return (Client) this;
|
|
}
|
|
|
|
private Player player;
|
|
public Player asPlayer() {
|
|
return (Player) player;
|
|
}
|
|
|
|
public boolean inTrawlerBoat() {
|
|
if(inArea(2808, 2811,3415,3425)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean inTrawlerGame() {
|
|
if(inArea(2808, 2811,3415,3425)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public long lastFishingTrawlerInteraction;
|
|
public boolean inFishingTrawlerRewardsInterface;
|
|
|
|
/**
|
|
* Castle Wars
|
|
*/
|
|
public int castleWarsTeam;
|
|
public boolean inCwGame;
|
|
public boolean inCwWait;
|
|
|
|
/**
|
|
* Fight Pits
|
|
*/
|
|
public boolean inPits = false;
|
|
public int pitsStatus = 0;
|
|
|
|
/**
|
|
* SouthWest, NorthEast, SouthWest, NorthEast
|
|
*/
|
|
|
|
public boolean inCw() {
|
|
Client c = (Client) this;
|
|
if (CastleWars.isInCwWait(c)) {
|
|
return true;
|
|
}
|
|
if (CastleWars.isInCw(c)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isInTut() {
|
|
if (absX >= 2625 && absX <= 2687 && absY >= 4670 && absY <= 4735) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean FightPitsArea() {
|
|
return absX >= 2378 && absX <= 2415 && absY >= 5133 && absY <= 5167
|
|
|| absX >= 2394 && absX <= 2404 && absY >= 5169 && absY <= 5174;
|
|
}
|
|
|
|
public boolean fightPitsArea() {
|
|
return absX >= 2378 && absX <= 2415 && absY >= 5133 && absY <= 5167;
|
|
}
|
|
|
|
public boolean inBarrows() {
|
|
if (absX > 3520 && absX < 3598 && absY > 9653 && absY < 9750) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean inArea(int x, int y, int x1, int y1) {
|
|
if (absX > x && absX < x1 && absY < y && absY > y1) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean inMulti() {
|
|
if (absX >= 3136
|
|
&& absX <= 3327
|
|
&& absY >= 3519
|
|
&& absY <= 3607// duel?
|
|
|| absX >= 2360
|
|
&& absX <= 2445
|
|
&& absY >= 5045
|
|
&& absY <= 5125
|
|
|| absX >= 3190
|
|
&& absX <= 3327
|
|
&& absY >= 3648
|
|
&& absY <= 3839// duel?
|
|
|| absX >= 3200 && absX <= 3390 && absY >= 3840 && absY <= 3967
|
|
|| absX >= 2992 && absX <= 3007 && absY >= 3912 && absY <= 3967
|
|
|| absX >= 2946 && absX <= 2959 && absY >= 3816 && absY <= 3831
|
|
|| absX >= 3008 && absX <= 3199 && absY >= 3856 && absY <= 3903
|
|
|| absX >= 3008 && absX <= 3071 && absY >= 3600 && absY <= 3711
|
|
|| absX >= 3072 && absX <= 3327 && absY >= 3608 && absY <= 3647
|
|
|| absX >= 2624
|
|
&& absX <= 2690
|
|
&& absY >= 2550
|
|
&& absY <= 2619
|
|
|| absX >= 2667
|
|
&& absX <= 2685
|
|
&& absY >= 3712
|
|
&& absY <= 3730 // rock
|
|
// crabs
|
|
|| absX >= 2371 && absX <= 2422 && absY >= 5062 && absY <= 5117
|
|
|| absX >= 2896 && absX <= 2927 && absY >= 3595 && absY <= 3630
|
|
|| absX >= 2892 && absX <= 2932 && absY >= 4435 && absY <= 4464
|
|
|| absX >= 2256 && absX <= 2287 && absY >= 4680 && absY <= 4711) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean inWild() {
|
|
if (inCw()) {
|
|
return true;
|
|
}
|
|
if (absX > 2941 && absX < 3392 && absY > 3518 && absY < 3966
|
|
|| absX > 2941 && absX < 3392 && absY > 9918 && absY < 10366) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean inBankArea() {
|
|
return isInArea(3205,3226,3214,3211) && heightLevel == 2|| //Lumbridge Bank
|
|
isInArea(3266,3171,3272,3162) || //Al Kharid Bank
|
|
isInArea(2436,5186,2453,5174) || //Tzhaar area
|
|
isInArea(2842,2957,2860,2950) || //Shilo Bank
|
|
isInArea(3492,3215,3456,3200) || //Burgh d rott
|
|
isInArea(3377,3275,3386,3266) || //Clan Wars
|
|
isInArea(3087,3248,3098,3239) || //Draynor
|
|
isInArea(3248,3423,3260,3414) || //Varrock East
|
|
isInArea(3183,3446,3193,3432) || //Varrock West
|
|
isInArea(3088,3501,3100,3486) || //Edgeville
|
|
isInArea(3009,3358,3020,3352) || //Falador East
|
|
isInArea(2942,3374,2950,3365) || //Falador West
|
|
isInArea(2839,3547,2844,3540) || //Warriors guild
|
|
isInArea(2804,3447,2815,3438) || //Catherby
|
|
isInArea(2718,3500,2733,3485) || //Seer's village
|
|
isInArea(2610,3338,2622,3326) || //North ardy
|
|
isInArea(2645,3288,2660,3281) || //South ardy
|
|
isInArea(2658,3165,2670,3158) || //Khazard
|
|
isInArea(2607,3098,2618,3087) || //Yanille
|
|
isInArea(2442,3084,2444,3081) || //Castle Wars
|
|
isInArea(2348,3168,2358,3159) || //Lleyta
|
|
isInArea(2324,3694,2334,3685) || //Piscatoris
|
|
isInArea(2527,3581,2539,3563) || //Barbarian Assault
|
|
isInArea(2448,3420,2442,3430) || //Tree Gnome Stronghold
|
|
isInArea(2453,3491,2440,3478) && heightLevel == 1 || //Grand Tree Area
|
|
isInArea(2843,2958,2816,2944) || //Shilo Village
|
|
isInArea(3113,3131,3131,3118) || //Tutorial Island
|
|
isInArea(3422,2895,3433,2885) || //Nardah
|
|
isInArea(3685,3473,3694,3461) || //Phasmatys
|
|
isInArea(2530,4725,2550,4705) || //Phasmatys
|
|
isInArea(2834, 10215, 2841, 10204) || // Keldagrim
|
|
isInArea(2379, 4453, 2386, 4462) || // Zanaris
|
|
false;
|
|
}
|
|
|
|
public boolean inPlayerShopArea() {
|
|
return isInArea(2938, 3389, 3059, 3329) || // Falador
|
|
isInArea(3172, 3449, 3270, 3384) || // Varrock
|
|
isInArea(3200, 3256, 3237, 3201) || // Lumbridge
|
|
isInArea(2716, 3498, 2735, 3480) ||
|
|
isInArea(3075, 3513, 3106, 3466) ||
|
|
isInArea(3074, 3262, 3102, 3239) ||
|
|
isInArea(2435, 3101, 2459, 3080) ||
|
|
isInArea(2618, 3075, 2598, 3108) ||
|
|
isInArea(2678, 3267, 2601, 3341) ||
|
|
isInArea(3265, 3157, 3324, 3215) ||
|
|
isInArea(3386, 3264, 3348, 3286) ||
|
|
isInArea(2797, 3454, 2838, 3430) ||
|
|
isInArea(2546, 3157, 2512, 3176) ||
|
|
isInArea(2451, 3408, 2425, 3437) ||
|
|
false;
|
|
}
|
|
|
|
public boolean inDesert() {
|
|
return absX >= 3137 && absX <= 3321 && absY >= 2880 && absY <= 3115;
|
|
}
|
|
|
|
public boolean duelingArena() {
|
|
if (absX > 3331 && absX < 3391 && absY > 3242 && absY < 3260) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
public boolean playerIsBusy() {
|
|
if(isShopping || inTrade || openDuel || isBanking || duelStatus == 1) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isInBarrows() {
|
|
if(absX > 3543 && absX < 3584 && absY > 3265 && absY < 3311) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isInBarrows2() {
|
|
if(absX > 3529 && absX < 3581 && absY > 9673 && absY < 9722) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean inPcBoat() {
|
|
return absX >= 2660 && absX <= 2663 && absY >= 2638 && absY <= 2643;
|
|
}
|
|
|
|
public boolean inPcGame() {
|
|
return absX >= 2624 && absX <= 2690 && absY >= 2550 && absY <= 2619;
|
|
}
|
|
|
|
public boolean inDuelArena() {
|
|
if (absX > 3322 && absX < 3394 && absY > 3195 && absY < 3291 || absX > 3311 && absX < 3323 && absY > 3223 && absY < 3248) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean inBank() { // Area(top left X, bottom right X, bottom right Y, top left Y)
|
|
return isInAreaxxyy(3090, 3099, 3487, 3500) || isInAreaxxyy(3089, 3090, 3492, 3498) || isInAreaxxyy(3249, 3258, 3413, 3428) || isInAreaxxyy(3180, 3191, 3432, 3448) || isInAreaxxyy(2945, 2948, 3365, 3374) ||
|
|
isInAreaxxyy(2943, 2948, 3367, 3374) || isInAreaxxyy(2945, 2950, 3365, 3370) || isInAreaxxyy(3009, 3018, 3352, 3359) || isInAreaxxyy(3017, 3022, 3353, 3357);
|
|
}
|
|
|
|
public boolean inLumbBuilding() {
|
|
return isInAreaxxyy(3205, 3216, 3209, 3228) || isInAreaxxyy(3229, 3233, 3206, 3208) || isInAreaxxyy(3228, 3233, 3201, 3205) || isInAreaxxyy(3230, 3237, 3195, 3198) || isInAreaxxyy(3238, 3229, 3209, 3211) ||
|
|
isInAreaxxyy(3240, 3247, 3204, 3215) || isInAreaxxyy(3247, 3252, 3190, 3195) || isInAreaxxyy(3227, 3230, 3212, 3216) || isInAreaxxyy(3227, 3230, 3221, 3225) || isInAreaxxyy(3229, 3232, 3236, 3241) ||
|
|
isInAreaxxyy(3209, 3213, 3243, 3250) || isInAreaxxyy(3222, 3229, 3252, 3257) || isInAreaxxyy(3184, 3192, 3270, 3275) || isInAreaxxyy(3222, 3224, 3292, 3294) || isInAreaxxyy(3225, 3230, 3287, 3228) ||
|
|
isInAreaxxyy(3243, 3248, 3244, 3248) || isInAreaxxyy(3202, 3205, 3167, 3170) || isInAreaxxyy(3231, 3238, 3151, 3155) || isInAreaxxyy(3233, 3234, 3156, 3156) || isInAreaxxyy(3163, 3170, 3305, 3308) ||
|
|
isInAreaxxyy(3165, 3168, 3303, 3310);
|
|
}
|
|
|
|
public boolean inDraynorBuilding() {
|
|
return isInAreaxxyy(3097, 3102, 3277, 3281) || isInAreaxxyy(3088, 3092, 3273, 3276) || isInAreaxxyy(3096, 3102, 3266, 3270) || isInAreaxxyy(3089, 3095, 3265, 3268) || isInAreaxxyy(3083, 3088, 3256, 3261) ||
|
|
isInAreaxxyy(3087, 3094, 3251, 3255) || isInAreaxxyy(3121, 3130, 3240, 3246) || isInAreaxxyy(3102, 3112, 3162, 3165) || isInAreaxxyy(3107, 3111, 3166, 3166) || isInAreaxxyy(3103, 3115, 3157, 3161) ||
|
|
isInAreaxxyy(3105, 3114, 3156, 3156) || isInAreaxxyy(3105, 3113, 3155, 3155) || isInAreaxxyy(3106, 3112, 3154, 3154) || isInAreaxxyy(3092, 3097, 3240, 3246);
|
|
}
|
|
|
|
public boolean isInArea(final int x1, final int y1, final int x2, final int y2) {
|
|
return (absX >= x1 && absX <= x2 || absX <= x1 && absX >= x2) && (absY >= y1 && absY <= y2 || absY <= y1 && absY >= y2);
|
|
}
|
|
|
|
public boolean isInAreaxxyy(final int x1, final int x2, final int y1, final int y2) {
|
|
return absX >= x1 && absX <= x2 && absY >= y1 && absY <= y2;
|
|
}
|
|
|
|
public boolean altars() {
|
|
return safeAreas(3090, 3506, 3097, 3506);
|
|
}
|
|
|
|
public boolean safeAreas(int x, int y, int x1, int y1) {
|
|
return absX >= x && absX <= x1 && absY >= y && absY <= y1;
|
|
}
|
|
|
|
public boolean inFightCaves() {
|
|
return absX >= 2360 && absX <= 2445 && absY >= 5045 && absY <= 5125;
|
|
}
|
|
|
|
public boolean inPirateHouse() {
|
|
return absX >= 3038 && absX <= 3044 && absY >= 3949 && absY <= 3959;
|
|
}
|
|
|
|
public String connectedFrom = "";
|
|
public String globalMessage = "";
|
|
|
|
public abstract void initialize();
|
|
|
|
public abstract void update();
|
|
|
|
public int playerId = -1;
|
|
public String playerName = null;
|
|
public String playerName2 = null;
|
|
public String playerPass = null;
|
|
public int playerRights;
|
|
public PlayerHandler handler = null;
|
|
public int playerItems[] = new int[28];
|
|
public int playerItemsN[] = new int[28];
|
|
public int bankItems[] = new int[Constants.BANK_SIZE];
|
|
public int bankItemsN[] = new int[Constants.BANK_SIZE];
|
|
// used for player owned shops
|
|
public int bankItemsV[] = new int[Constants.BANK_SIZE];
|
|
public boolean bankNotes = false;
|
|
public boolean shouldSave = false;
|
|
|
|
public int playerStandIndex = 0x328;
|
|
public int playerTurnIndex = 0x337;
|
|
public int playerWalkIndex = 0x333;
|
|
public int playerTurn180Index = 0x334;
|
|
public int playerTurn90CWIndex = 0x335;
|
|
public int playerTurn90CCWIndex = 0x336;
|
|
public int playerRunIndex = 0x338;
|
|
|
|
public int playerHat = 0;
|
|
public int playerCape = 1;
|
|
public int playerAmulet = 2;
|
|
public int playerWeapon = 3;
|
|
public int playerChest = 4;
|
|
public int playerShield = 5;
|
|
public int playerLegs = 7;
|
|
public int playerHands = 9;
|
|
public int playerFeet = 10;
|
|
public int playerRing = 12;
|
|
public int playerArrows = 13;
|
|
|
|
public int playerAttack = 0;
|
|
public int playerDefence = 1;
|
|
public int playerStrength = 2;
|
|
public int playerHitpoints = 3;
|
|
public int playerRanged = 4;
|
|
public int playerPrayer = 5;
|
|
public int playerMagic = 6;
|
|
public int playerCooking = 7;
|
|
public int playerWoodcutting = 8;
|
|
public int playerFletching = 9;
|
|
public int playerFishing = 10;
|
|
public int playerFiremaking = 11;
|
|
public int playerCrafting = 12;
|
|
public int playerSmithing = 13;
|
|
public int playerMining = 14;
|
|
public int playerHerblore = 15;
|
|
public int playerAgility = 16;
|
|
public int playerThieving = 17;
|
|
public int playerSlayer = 18;
|
|
public int playerFarming = 19;
|
|
public int playerRunecrafting = 20;
|
|
|
|
public int[] playerEquipment = new int[14];
|
|
public int[] playerEquipmentN = new int[14];
|
|
public int[] playerLevel = new int[25];
|
|
public int[] playerXP = new int[25];
|
|
|
|
public void updateshop(int i) {
|
|
Client p = (Client) PlayerHandler.players[playerId];
|
|
p.getShopAssistant().resetShop(i);
|
|
}
|
|
|
|
public void println_debug(String str) {
|
|
System.out.println("[player-" + playerId + "]: " + str);
|
|
}
|
|
|
|
public void println(String str) {
|
|
System.out.println("[player-" + playerId + "]: " + str);
|
|
}
|
|
|
|
public Player(int _playerId) {
|
|
playerId = _playerId;
|
|
playerRights = 0;
|
|
|
|
for (int i = 0; i < playerItems.length; i++) {
|
|
playerItems[i] = 0;
|
|
}
|
|
for (int i = 0; i < playerItemsN.length; i++) {
|
|
playerItemsN[i] = 0;
|
|
}
|
|
|
|
for (int i = 0; i < playerLevel.length; i++) {
|
|
if (i == 3) {
|
|
playerLevel[i] = 10;
|
|
} else {
|
|
playerLevel[i] = 1;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < playerXP.length; i++) {
|
|
if (i == 3) {
|
|
playerXP[i] = 1300;
|
|
} else {
|
|
playerXP[i] = 0;
|
|
}
|
|
}
|
|
for (int i = 0; i < Constants.BANK_SIZE; i++) {
|
|
bankItems[i] = 0;
|
|
}
|
|
|
|
for (int i = 0; i < Constants.BANK_SIZE; i++) {
|
|
bankItemsN[i] = 0;
|
|
}
|
|
|
|
playerAppearance[0] = 0; // gender
|
|
playerAppearance[1] = 7; // head
|
|
playerAppearance[2] = 25;// Torso
|
|
playerAppearance[3] = 29; // arms
|
|
playerAppearance[4] = 35; // hands
|
|
playerAppearance[5] = 39; // legs
|
|
playerAppearance[6] = 44; // feet
|
|
playerAppearance[7] = 14; // beard
|
|
playerAppearance[8] = 7; // hair colour
|
|
playerAppearance[9] = 8; // torso colour
|
|
playerAppearance[10] = 9; // legs colour
|
|
playerAppearance[11] = 5; // feet colour
|
|
playerAppearance[12] = 0; // skin colour
|
|
|
|
apset = 0;
|
|
actionID = 0;
|
|
|
|
playerEquipment[playerHat] = -1;
|
|
playerEquipment[playerCape] = -1;
|
|
playerEquipment[playerAmulet] = -1;
|
|
playerEquipment[playerChest] = -1;
|
|
playerEquipment[playerShield] = -1;
|
|
playerEquipment[playerLegs] = -1;
|
|
playerEquipment[playerHands] = -1;
|
|
playerEquipment[playerFeet] = -1;
|
|
playerEquipment[playerRing] = -1;
|
|
playerEquipment[playerArrows] = -1;
|
|
playerEquipment[playerWeapon] = -1;
|
|
|
|
heightLevel = 0;
|
|
|
|
if (Constants.TUTORIAL_ISLAND) {
|
|
teleportToX = 3094;
|
|
teleportToY = 3107;
|
|
} else {
|
|
teleportToX = 3233;
|
|
teleportToY = 3229;
|
|
}
|
|
|
|
absX = absY = -1;
|
|
mapRegionX = mapRegionY = -1;
|
|
currentX = currentY = 0;
|
|
resetWalkingQueue();
|
|
}
|
|
|
|
void destruct() {
|
|
playerListSize = 0;
|
|
for (int i = 0; i < maxPlayerListSize; i++) {
|
|
playerList[i] = null;
|
|
}
|
|
absX = absY = -1;
|
|
mapRegionX = mapRegionY = -1;
|
|
currentX = currentY = 0;
|
|
resetWalkingQueue();
|
|
}
|
|
|
|
public static final int maxPlayerListSize = Constants.MAX_PLAYERS;
|
|
public Player playerList[] = new Player[maxPlayerListSize];
|
|
public int playerListSize = 0;
|
|
|
|
public byte playerInListBitmap[] = new byte[Constants.MAX_PLAYERS + 7 >> 3];
|
|
|
|
public static final int maxNPCListSize = NpcHandler.MAX_NPCS;
|
|
public Npc npcList[] = new Npc[maxNPCListSize];
|
|
public int npcListSize = 0;
|
|
|
|
public byte npcInListBitmap[] = new byte[NpcHandler.MAX_NPCS + 7 >> 3];
|
|
|
|
public boolean withinDistance(Player otherPlr) {
|
|
if (heightLevel != otherPlr.heightLevel) {
|
|
return false;
|
|
}
|
|
int deltaX = otherPlr.absX - absX, deltaY = otherPlr.absY - absY;
|
|
return deltaX <= 15 && deltaX >= -16 && deltaY <= 15 && deltaY >= -16;
|
|
}
|
|
|
|
public boolean withinDistance(Npc npc) {
|
|
if (heightLevel != npc.heightLevel) {
|
|
return false;
|
|
}
|
|
if (npc.needRespawn == true) {
|
|
return false;
|
|
}
|
|
int deltaX = npc.absX - absX, deltaY = npc.absY - absY;
|
|
return deltaX <= 15 && deltaX >= -16 && deltaY <= 15 && deltaY >= -16;
|
|
}
|
|
|
|
public boolean withinDistance(int absX, int getY, int getHeightLevel) {
|
|
if (heightLevel != getHeightLevel) {
|
|
return false;
|
|
}
|
|
if (objectId == 2242) {
|
|
System.out.println("not within distance");
|
|
return false;
|
|
}
|
|
int deltaX = getX() - absX, deltaY = getY() - getY;
|
|
return deltaX <= 15 && deltaX >= -16 && deltaY <= 15 && deltaY >= -16;
|
|
}
|
|
|
|
public int distanceToPoint(int pointX, int pointY) {
|
|
return (int) Math.sqrt(Math.pow(absX - pointX, 2)
|
|
+ Math.pow(absY - pointY, 2));
|
|
}
|
|
|
|
public int mapRegionX, mapRegionY;
|
|
public int absX;
|
|
|
|
public int absY;
|
|
public int currentX, currentY;
|
|
|
|
public int heightLevel;
|
|
public int playerSE = 0x328;
|
|
public int playerSEW = 0x333;
|
|
public int playerSER = 0x334;
|
|
|
|
public boolean updateRequired = true;
|
|
|
|
public final int walkingQueueSize = 50;
|
|
public int walkingQueueX[] = new int[walkingQueueSize],
|
|
walkingQueueY[] = new int[walkingQueueSize];
|
|
public int wQueueReadPtr = 0;
|
|
public int wQueueWritePtr = 0;
|
|
public boolean isRunning = true;
|
|
public int teleportToX = -1, teleportToY = -1;
|
|
|
|
public void resetWalkingQueue() {
|
|
wQueueReadPtr = wQueueWritePtr = 0;
|
|
for (int i = 0; i < walkingQueueSize; i++) {
|
|
walkingQueueX[i] = currentX;
|
|
walkingQueueY[i] = currentY;
|
|
}
|
|
}
|
|
|
|
public void addToWalkingQueue(int x, int y) {
|
|
// if (VirtualWorld.I(heightLevel, absX, absY, x, y, 0)) {
|
|
int next = (wQueueWritePtr + 1) % walkingQueueSize;
|
|
if (next == wQueueWritePtr) {
|
|
return;
|
|
}
|
|
walkingQueueX[wQueueWritePtr] = x;
|
|
walkingQueueY[wQueueWritePtr] = y;
|
|
wQueueWritePtr = next;
|
|
// }
|
|
}
|
|
public boolean goodDistance(int objectX, int objectY, int playerX, int playerY, int distance) {
|
|
return ((objectX-playerX <= distance && objectX-playerX >= -distance) && (objectY-playerY <= distance && objectY-playerY >= -distance));
|
|
}
|
|
|
|
public int getNextWalkingDirection() {
|
|
if (wQueueReadPtr == wQueueWritePtr) {
|
|
return -1;
|
|
}
|
|
int dir;
|
|
do {
|
|
dir = Misc.direction(currentX, currentY,
|
|
walkingQueueX[wQueueReadPtr], walkingQueueY[wQueueReadPtr]);
|
|
if (dir == -1) {
|
|
wQueueReadPtr = (wQueueReadPtr + 1) % walkingQueueSize;
|
|
} else if ((dir & 1) != 0) {
|
|
println_debug("Invalid waypoint in walking queue!");
|
|
resetWalkingQueue();
|
|
return -1;
|
|
}
|
|
} while (dir == -1 && wQueueReadPtr != wQueueWritePtr);
|
|
if (dir == -1) {
|
|
return -1;
|
|
}
|
|
dir >>= 1;
|
|
currentX += Misc.directionDeltaX[dir];
|
|
currentY += Misc.directionDeltaY[dir];
|
|
/*if (!Region.canMove(absX, absY, (absX + Misc.directionDeltaX[dir]), (absY + Misc.directionDeltaY[dir]), heightLevel, 1, 1))
|
|
return -1;*/
|
|
absX += Misc.directionDeltaX[dir];
|
|
absY += Misc.directionDeltaY[dir];
|
|
updateWalkEntities();
|
|
return dir;
|
|
}
|
|
|
|
public boolean didTeleport = false;
|
|
public boolean mapRegionDidChange = false;
|
|
public int dir1 = -1, dir2 = -1;
|
|
public boolean createItems = false;
|
|
public int poimiX = 0, poimiY = 0;
|
|
|
|
public synchronized void getNextPlayerMovement() {
|
|
mapRegionDidChange = false;
|
|
didTeleport = false;
|
|
dir1 = dir2 = -1;
|
|
|
|
if (teleportToX != -1 && teleportToY != -1) {
|
|
mapRegionDidChange = true;
|
|
if (mapRegionX != -1 && mapRegionY != -1) {
|
|
int relX = teleportToX - mapRegionX * 8, relY = teleportToY
|
|
- mapRegionY * 8;
|
|
if (relX >= 2 * 8 && relX < 11 * 8 && relY >= 2 * 8
|
|
&& relY < 11 * 8) {
|
|
mapRegionDidChange = false;
|
|
}
|
|
}
|
|
if (mapRegionDidChange) {
|
|
mapRegionX = (teleportToX >> 3) - 6;
|
|
mapRegionY = (teleportToY >> 3) - 6;
|
|
}
|
|
currentX = teleportToX - 8 * mapRegionX;
|
|
currentY = teleportToY - 8 * mapRegionY;
|
|
absX = teleportToX;
|
|
absY = teleportToY;
|
|
resetWalkingQueue();
|
|
|
|
teleportToX = teleportToY = -1;
|
|
didTeleport = true;
|
|
updateWalkEntities();
|
|
} else {
|
|
dir1 = getNextWalkingDirection();
|
|
if (dir1 == -1) {
|
|
return;
|
|
}
|
|
if (isRunning) {
|
|
dir2 = getNextWalkingDirection();
|
|
}
|
|
// c.sendMessage("Cycle Ended");
|
|
int deltaX = 0, deltaY = 0;
|
|
if (currentX < 2 * 8) {
|
|
deltaX = 4 * 8;
|
|
mapRegionX -= 4;
|
|
mapRegionDidChange = true;
|
|
} else if (currentX >= 11 * 8) {
|
|
deltaX = -4 * 8;
|
|
mapRegionX += 4;
|
|
mapRegionDidChange = true;
|
|
}
|
|
if (currentY < 2 * 8) {
|
|
deltaY = 4 * 8;
|
|
mapRegionY -= 4;
|
|
mapRegionDidChange = true;
|
|
} else if (currentY >= 11 * 8) {
|
|
deltaY = -4 * 8;
|
|
mapRegionY += 4;
|
|
mapRegionDidChange = true;
|
|
}
|
|
|
|
if (mapRegionDidChange) {
|
|
currentX += deltaX;
|
|
currentY += deltaY;
|
|
for (int i = 0; i < walkingQueueSize; i++) {
|
|
walkingQueueX[i] += deltaX;
|
|
walkingQueueY[i] += deltaY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updateThisPlayerMovement(Stream str) {
|
|
|
|
if (str != null) {
|
|
if (mapRegionDidChange) {
|
|
str.createFrame(73);
|
|
str.writeWordA(mapRegionX + 6);
|
|
str.writeWord(mapRegionY + 6);
|
|
}
|
|
|
|
if (didTeleport) {
|
|
str.createFrameVarSizeWord(81);
|
|
str.initBitAccess();
|
|
str.writeBits(1, 1);
|
|
str.writeBits(2, 3);
|
|
str.writeBits(2, heightLevel);
|
|
str.writeBits(1, 1);
|
|
str.writeBits(1, updateRequired ? 1 : 0);
|
|
str.writeBits(7, currentY);
|
|
str.writeBits(7, currentX);
|
|
return;
|
|
}
|
|
}
|
|
if (dir1 == -1) {
|
|
// don't have to update the character position, because we're
|
|
// just standing
|
|
if (str != null){
|
|
str.createFrameVarSizeWord(81);
|
|
str.initBitAccess();
|
|
isMoving = false;
|
|
if (updateRequired) {
|
|
// tell client there's an update block appended at the end
|
|
str.writeBits(1, 1);
|
|
str.writeBits(2, 0);
|
|
} else {
|
|
str.writeBits(1, 0);
|
|
}
|
|
}
|
|
if (DirectionCount < 50) {
|
|
DirectionCount++;
|
|
}
|
|
} else {
|
|
DirectionCount = 0;
|
|
if (str != null) {
|
|
str.createFrameVarSizeWord(81);
|
|
str.initBitAccess();
|
|
str.writeBits(1, 1);
|
|
}
|
|
|
|
if (dir2 == -1) {
|
|
isMoving = true;
|
|
if (str != null) {
|
|
str.writeBits(2, 1);
|
|
str.writeBits(3, Misc.xlateDirectionToClient[dir1]);
|
|
if (updateRequired) {
|
|
str.writeBits(1, 1);
|
|
} else {
|
|
str.writeBits(1, 0);
|
|
}
|
|
}
|
|
} else {
|
|
isMoving = true;
|
|
if (str != null) {
|
|
str.writeBits(2, 2);
|
|
str.writeBits(3, Misc.xlateDirectionToClient[dir1]);
|
|
str.writeBits(3, Misc.xlateDirectionToClient[dir2]);
|
|
if (updateRequired) {
|
|
str.writeBits(1, 1);
|
|
} else {
|
|
str.writeBits(1, 0);
|
|
}
|
|
}
|
|
if (playerEnergy > 0 && playerRights < 2) {
|
|
// calculations from https://oldschool.runescape.wiki/w/Energy
|
|
playerEnergy -= 0.64;
|
|
if (weight > 0.0)
|
|
playerEnergy -= Math.min(weight, 64) / 100;
|
|
} else if (playerRights >= 2) {
|
|
playerEnergy = 100;
|
|
isRunning2 = true;
|
|
} else if (playerEnergy <= 0) {
|
|
playerEnergy = 0;
|
|
isRunning2 = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updatePlayerMovement(Stream str) {
|
|
if (str == null)
|
|
return;
|
|
|
|
if (dir1 == -1) {
|
|
if (updateRequired || isChatTextUpdateRequired()) {
|
|
str.writeBits(1, 1);
|
|
str.writeBits(2, 0);
|
|
} else {
|
|
str.writeBits(1, 0);
|
|
}
|
|
} else if (dir2 == -1) {
|
|
|
|
str.writeBits(1, 1);
|
|
str.writeBits(2, 1);
|
|
str.writeBits(3, Misc.xlateDirectionToClient[dir1]);
|
|
str.writeBits(1, updateRequired || isChatTextUpdateRequired() ? 1 : 0);
|
|
} else {
|
|
|
|
str.writeBits(1, 1);
|
|
str.writeBits(2, 2);
|
|
str.writeBits(3, Misc.xlateDirectionToClient[dir1]);
|
|
str.writeBits(3, Misc.xlateDirectionToClient[dir2]);
|
|
str.writeBits(1, updateRequired || isChatTextUpdateRequired() ? 1 : 0);
|
|
}
|
|
}
|
|
|
|
public byte cachedPropertiesBitmap[] = new byte[Constants.MAX_PLAYERS + 7 >> 3];
|
|
|
|
public void addNewNPC(Npc npc, Stream str, Stream updateBlock) {
|
|
int id = npc.npcId;
|
|
npcInListBitmap[id >> 3] |= 1 << (id & 7);
|
|
npcList[npcListSize++] = npc;
|
|
|
|
if (str != null) {
|
|
str.writeBits(14, id);
|
|
}
|
|
|
|
int z = npc.absY - absY;
|
|
if (z < 0) {
|
|
z += 32;
|
|
}
|
|
|
|
if (str != null) {
|
|
str.writeBits(5, z);
|
|
}
|
|
|
|
z = npc.absX - absX;
|
|
if (z < 0) {
|
|
z += 32;
|
|
}
|
|
|
|
if (str != null) {
|
|
str.writeBits(5, z);
|
|
|
|
str.writeBits(1, 0);
|
|
str.writeBits(12, npc.npcType);
|
|
}
|
|
|
|
boolean savedUpdateRequired = npc.updateRequired;
|
|
npc.updateRequired = true;
|
|
npc.appendNPCUpdateBlock(updateBlock);
|
|
npc.updateRequired = savedUpdateRequired;
|
|
|
|
if (str != null) {
|
|
str.writeBits(1, 1);
|
|
}
|
|
}
|
|
|
|
public void addNewPlayer(Player plr, Stream str, Stream updateBlock) {
|
|
int id = plr.playerId;
|
|
playerInListBitmap[id >> 3] |= 1 << (id & 7);
|
|
playerList[playerListSize++] = plr;
|
|
|
|
if (str != null) {
|
|
str.writeBits(11, id);
|
|
str.writeBits(1, 1);
|
|
}
|
|
boolean savedFlag = plr.isAppearanceUpdateRequired();
|
|
boolean savedUpdateRequired = plr.updateRequired;
|
|
plr.setAppearanceUpdateRequired(true);
|
|
plr.updateRequired = true;
|
|
plr.appendPlayerUpdateBlock(updateBlock);
|
|
plr.setAppearanceUpdateRequired(savedFlag);
|
|
plr.updateRequired = savedUpdateRequired;
|
|
if (str != null) {
|
|
str.writeBits(1, 1);
|
|
}
|
|
int z = plr.absY - absY;
|
|
if (z < 0) {
|
|
z += 32;
|
|
}
|
|
|
|
if (str != null) {
|
|
str.writeBits(5, z);
|
|
}
|
|
|
|
z = plr.absX - absX;
|
|
if (z < 0) {
|
|
z += 32;
|
|
}
|
|
|
|
if (str != null) {
|
|
str.writeBits(5, z);
|
|
}
|
|
}
|
|
|
|
public int headIcon = -1, bountyIcon = 0;
|
|
|
|
public int DirectionCount = 0;
|
|
public boolean appearanceUpdateRequired = true;
|
|
public int hitDiff2;
|
|
public int hitDiff = 0;
|
|
public boolean hitUpdateRequired2;
|
|
public boolean hitUpdateRequired = false;
|
|
public boolean isDead = false;
|
|
|
|
protected static Stream playerProps;
|
|
static {
|
|
playerProps = new Stream(new byte[100]);
|
|
}
|
|
|
|
protected void appendPlayerAppearance(Stream str) {
|
|
playerProps.currentOffset = 0;
|
|
|
|
playerProps.writeByte(playerAppearance[0]);
|
|
|
|
playerProps.writeByte(headIcon);
|
|
playerProps.writeByte(headIconPk);
|
|
// playerProps.writeByte(headIconHints);
|
|
// playerProps.writeByte(bountyIcon);
|
|
|
|
if (playerEquipment[playerHat] > 1) {
|
|
playerProps.writeWord(0x200 + playerEquipment[playerHat]);
|
|
} else {
|
|
playerProps.writeByte(0);
|
|
}
|
|
|
|
if (playerEquipment[playerCape] > 1) {
|
|
playerProps.writeWord(0x200 + playerEquipment[playerCape]);
|
|
} else {
|
|
playerProps.writeByte(0);
|
|
}
|
|
|
|
if (playerEquipment[playerAmulet] > 1) {
|
|
playerProps.writeWord(0x200 + playerEquipment[playerAmulet]);
|
|
} else {
|
|
playerProps.writeByte(0);
|
|
}
|
|
|
|
if (playerEquipment[playerWeapon] > 1) {
|
|
playerProps.writeWord(0x200 + playerEquipment[playerWeapon]);
|
|
} else {
|
|
playerProps.writeByte(0);
|
|
}
|
|
|
|
if (playerEquipment[playerChest] > 1) {
|
|
playerProps.writeWord(0x200 + playerEquipment[playerChest]);
|
|
} else {
|
|
playerProps.writeWord(0x100 + playerAppearance[2]);
|
|
}
|
|
|
|
if (playerEquipment[playerShield] > 1) {
|
|
playerProps.writeWord(0x200 + playerEquipment[playerShield]);
|
|
} else {
|
|
playerProps.writeByte(0);
|
|
}
|
|
|
|
if (!Item.isFullBody(playerEquipment[playerChest])) {
|
|
playerProps.writeWord(0x100 + playerAppearance[3]);
|
|
} else {
|
|
playerProps.writeByte(0);
|
|
}
|
|
|
|
if (playerEquipment[playerLegs] > 1) {
|
|
playerProps.writeWord(0x200 + playerEquipment[playerLegs]);
|
|
} else {
|
|
playerProps.writeWord(0x100 + playerAppearance[5]);
|
|
}
|
|
|
|
if (!Item.isFullHelm(playerEquipment[playerHat])
|
|
&& !Item.isFullMask(playerEquipment[playerHat])) {
|
|
playerProps.writeWord(0x100 + playerAppearance[1]);
|
|
} else {
|
|
playerProps.writeByte(0);
|
|
}
|
|
|
|
if (playerEquipment[playerHands] > 1) {
|
|
playerProps.writeWord(0x200 + playerEquipment[playerHands]);
|
|
} else {
|
|
playerProps.writeWord(0x100 + playerAppearance[4]);
|
|
}
|
|
|
|
if (playerEquipment[playerFeet] > 1) {
|
|
playerProps.writeWord(0x200 + playerEquipment[playerFeet]);
|
|
} else {
|
|
playerProps.writeWord(0x100 + playerAppearance[6]);
|
|
}
|
|
|
|
if (playerAppearance[0] != 1
|
|
&& !Item.isFullMask(playerEquipment[playerHat])) {
|
|
playerProps.writeWord(0x100 + playerAppearance[7]);
|
|
} else {
|
|
playerProps.writeByte(0);
|
|
}
|
|
|
|
playerProps.writeByte(playerAppearance[8]);
|
|
playerProps.writeByte(playerAppearance[9]);
|
|
playerProps.writeByte(playerAppearance[10]);
|
|
playerProps.writeByte(playerAppearance[11]);
|
|
playerProps.writeByte(playerAppearance[12]);
|
|
playerProps.writeWord(playerStandIndex); // standAnimIndex
|
|
playerProps.writeWord(playerTurnIndex); // standTurnAnimIndex
|
|
playerProps.writeWord(playerWalkIndex); // walkAnimIndex
|
|
playerProps.writeWord(playerTurn180Index); // turn180AnimIndex
|
|
playerProps.writeWord(playerTurn90CWIndex); // turn90CWAnimIndex
|
|
playerProps.writeWord(playerTurn90CCWIndex); // turn90CCWAnimIndex
|
|
playerProps.writeWord(playerRunIndex); // runAnimIndex
|
|
playerProps.writeQWord(Misc.playerNameToInt64(playerName));
|
|
combatLevel = calculateCombatLevel();
|
|
playerProps.writeByte(combatLevel); // combat level
|
|
playerProps.writeWord(0);
|
|
str.writeByteC(playerProps.currentOffset);
|
|
str.writeBytes(playerProps.buffer, playerProps.currentOffset, 0);
|
|
}
|
|
|
|
public int calculateCombatLevel() {
|
|
int j = getLevelForXP(playerXP[playerAttack]);
|
|
int k = getLevelForXP(playerXP[playerDefence]);
|
|
int l = getLevelForXP(playerXP[playerStrength]);
|
|
int i1 = getLevelForXP(playerXP[playerHitpoints]);
|
|
int j1 = getLevelForXP(playerXP[playerPrayer]);
|
|
int k1 = getLevelForXP(playerXP[playerRanged]);
|
|
int l1 = getLevelForXP(playerXP[playerMagic]);
|
|
int combatLevel = (int) ((k + i1 + Math.floor(j1 / 2)) * 0.25D) + 1;
|
|
double d = (j + l) * 0.32500000000000001D;
|
|
double d1 = Math.floor(k1 * 1.5D) * 0.32500000000000001D;
|
|
double d2 = Math.floor(l1 * 1.5D) * 0.32500000000000001D;
|
|
if (d >= d1 && d >= d2) {
|
|
combatLevel += d;
|
|
} else if (d1 >= d && d1 >= d2) {
|
|
combatLevel += d1;
|
|
} else if (d2 >= d && d2 >= d1) {
|
|
combatLevel += d2;
|
|
}
|
|
return combatLevel;
|
|
}
|
|
|
|
public int getLevelForXP(int exp) {
|
|
if (exp > 13034430) {
|
|
return 99;
|
|
} else {
|
|
int points = 0;
|
|
for (int lvl = 1; lvl <= 99; ++lvl) {
|
|
points = (int) (points + Math.floor(lvl + 300.0D
|
|
* Math.pow(2.0D, lvl / 7.0D)));
|
|
int var5 = (int) Math.floor(points / 4);
|
|
if (var5 >= exp) {
|
|
return lvl;
|
|
}
|
|
}
|
|
|
|
return 99;
|
|
}
|
|
}
|
|
|
|
private boolean chatTextUpdateRequired = false;
|
|
private byte chatText[] = new byte[4096];
|
|
private byte chatTextSize = 0;
|
|
private int chatTextColor = 0;
|
|
private int chatTextEffects = 0;
|
|
|
|
protected void appendPlayerChatText(Stream str) {
|
|
if (str == null) return;
|
|
str.writeWordBigEndian(((getChatTextColor() & 0xFF) << 8) + (getChatTextEffects() & 0xFF));
|
|
str.writeByte(playerRights);
|
|
str.writeByteC(getChatTextSize());
|
|
str.writeBytes_reverse(getChatText(), getChatTextSize(), 0);
|
|
}
|
|
|
|
public void forcedChat(String text) {
|
|
forcedText = text;
|
|
forcedChatUpdateRequired = true;
|
|
updateRequired = true;
|
|
setAppearanceUpdateRequired(true);
|
|
}
|
|
|
|
public String forcedText = "null";
|
|
|
|
public void appendForcedChat(Stream str) {
|
|
if (str != null)
|
|
str.writeString(forcedText);
|
|
}
|
|
|
|
/**
|
|
* Graphics
|
|
**/
|
|
|
|
public int mask100var1 = 0;
|
|
public int mask100var2 = 0;
|
|
protected boolean mask100update = false;
|
|
|
|
public void appendMask100Update(Stream str) {
|
|
str.writeWordBigEndian(mask100var1);
|
|
str.writeDWord(mask100var2);
|
|
}
|
|
|
|
public void gfx100(int gfx) {
|
|
mask100var1 = gfx;
|
|
mask100var2 = 6553600;
|
|
mask100update = true;
|
|
updateRequired = true;
|
|
}
|
|
|
|
public void gfx0(int gfx) {
|
|
mask100var1 = gfx;
|
|
mask100var2 = 65536;
|
|
mask100update = true;
|
|
updateRequired = true;
|
|
}
|
|
|
|
public boolean wearing2h() {
|
|
Client c = (Client) this;
|
|
String s = ItemAssistant.getItemName(c.playerEquipment[c.playerWeapon]);
|
|
if (s.contains("2h")) {
|
|
return true;
|
|
} else if (s.contains("godsword")) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Animations
|
|
**/
|
|
public void startAnimation(int animId) {
|
|
if (wearing2h() && animId == 829) {
|
|
return;
|
|
}
|
|
if (animId == -1) {
|
|
animId = 65535;
|
|
}
|
|
if (isBotting == true) {
|
|
animId = 65535;
|
|
}
|
|
animationRequest = animId;
|
|
animationWaitCycles = 0;
|
|
updateRequired = true;
|
|
}
|
|
|
|
public void startAnimation(int animId, int time) {
|
|
animationRequest = animId;
|
|
animationWaitCycles = time;
|
|
updateRequired = true;
|
|
}
|
|
|
|
public void appendAnimationRequest(Stream str) {
|
|
str.writeWordBigEndian(animationRequest == -1 ? 65535
|
|
: animationRequest);
|
|
str.writeByteC(animationWaitCycles);
|
|
}
|
|
|
|
/**
|
|
* Face Update
|
|
**/
|
|
|
|
protected boolean faceUpdateRequired = false;
|
|
public int face = -1;
|
|
public int FocusPointX = -1, FocusPointY = -1;
|
|
|
|
public void faceUpdate(int index) {
|
|
face = index;
|
|
faceUpdateRequired = true;
|
|
updateRequired = true;
|
|
}
|
|
|
|
public void appendFaceUpdate(Stream str) {
|
|
str.writeWordBigEndian(face);
|
|
}
|
|
|
|
public void turnPlayerTo(int pointX, int pointY) {
|
|
FocusPointX = 2 * pointX + 1;
|
|
FocusPointY = 2 * pointY + 1;
|
|
updateRequired = true;
|
|
}
|
|
|
|
private void appendSetFocusDestination(Stream str) {
|
|
str.writeWordBigEndianA(FocusPointX);
|
|
str.writeWordBigEndian(FocusPointY);
|
|
}
|
|
|
|
/**
|
|
* Hit Update
|
|
**/
|
|
|
|
protected void appendHitUpdate(Stream str) {
|
|
str.writeByte(getHitDiff()); // What the person got 'hit' for
|
|
if (poisonMask == 1) {
|
|
str.writeByteA(2);
|
|
} else if (getHitDiff() > 0) {
|
|
str.writeByteA(1); // 0: red hitting - 1: blue hitting
|
|
} else {
|
|
str.writeByteA(0); // 0: red hitting - 1: blue hitting
|
|
}
|
|
if (playerLevel[3] <= 0) {
|
|
playerLevel[3] = 0;
|
|
isDead = true;
|
|
}
|
|
str.writeByteC(playerLevel[3]); // Their current hp, for HP bar
|
|
str.writeByte(getLevelForXP(playerXP[3]));
|
|
}
|
|
|
|
protected void appendHitUpdate2(Stream str) {
|
|
str.writeByte(hitDiff2); // What the perseon got 'hit' for
|
|
if (poisonMask == 2) {
|
|
str.writeByteS(2);
|
|
poisonMask = -1;
|
|
} else if (hitDiff2 > 0) {
|
|
str.writeByteS(1); // 0: red hitting - 1: blue hitting
|
|
} else {
|
|
str.writeByteS(0); // 0: red hitting - 1: blue hitting
|
|
}
|
|
if (playerLevel[3] <= 0) {
|
|
playerLevel[3] = 0;
|
|
isDead = true;
|
|
}
|
|
str.writeByte(playerLevel[3]); // Their current hp, for HP bar
|
|
str.writeByteC(getLevelForXP(playerXP[3])); // Their max hp, for HP
|
|
}
|
|
|
|
public void appendPlayerUpdateBlock(Stream str) {
|
|
if (!updateRequired && !isChatTextUpdateRequired()) {
|
|
return; // nothing required
|
|
}
|
|
int updateMask = 0;
|
|
if (mask100update) {
|
|
updateMask |= 0x100;
|
|
}
|
|
if (animationRequest != -1) {
|
|
updateMask |= 8;
|
|
}
|
|
if (forcedChatUpdateRequired) {
|
|
updateMask |= 4;
|
|
}
|
|
if (isChatTextUpdateRequired()) {
|
|
updateMask |= 0x80;
|
|
}
|
|
if (isAppearanceUpdateRequired()) {
|
|
updateMask |= 0x10;
|
|
}
|
|
if (faceUpdateRequired) {
|
|
updateMask |= 1;
|
|
}
|
|
if (FocusPointX != -1) {
|
|
updateMask |= 2;
|
|
}
|
|
if (isHitUpdateRequired()) {
|
|
updateMask |= 0x20;
|
|
}
|
|
|
|
if (hitUpdateRequired2) {
|
|
updateMask |= 0x200;
|
|
}
|
|
|
|
if (updateMask >= 0x100) {
|
|
updateMask |= 0x40;
|
|
str.writeByte(updateMask & 0xFF);
|
|
str.writeByte(updateMask >> 8);
|
|
} else {
|
|
str.writeByte(updateMask);
|
|
}
|
|
|
|
// now writing the various update blocks itself - note that their
|
|
// order crucial
|
|
if (mask100update) {
|
|
appendMask100Update(str);
|
|
}
|
|
if (animationRequest != -1) {
|
|
appendAnimationRequest(str);
|
|
}
|
|
if (forcedChatUpdateRequired) {
|
|
appendForcedChat(str);
|
|
}
|
|
if (isChatTextUpdateRequired()) {
|
|
appendPlayerChatText(str);
|
|
}
|
|
if (faceUpdateRequired) {
|
|
appendFaceUpdate(str);
|
|
}
|
|
if (isAppearanceUpdateRequired()) {
|
|
appendPlayerAppearance(str);
|
|
}
|
|
if (FocusPointX != -1) {
|
|
appendSetFocusDestination(str);
|
|
}
|
|
if (isHitUpdateRequired()) {
|
|
appendHitUpdate(str);
|
|
}
|
|
if (hitUpdateRequired2) {
|
|
appendHitUpdate2(str);
|
|
}
|
|
}
|
|
|
|
public void clearUpdateFlags() {
|
|
updateRequired = false;
|
|
setChatTextUpdateRequired(false);
|
|
setAppearanceUpdateRequired(false);
|
|
setHitUpdateRequired(false);
|
|
hitUpdateRequired2 = false;
|
|
forcedChatUpdateRequired = false;
|
|
mask100update = false;
|
|
animationRequest = -1;
|
|
FocusPointX = -1;
|
|
FocusPointY = -1;
|
|
poisonMask = -1;
|
|
faceUpdateRequired = false;
|
|
face = 65535;
|
|
}
|
|
|
|
public void stopMovement() {
|
|
if (teleportToX <= 0 && teleportToY <= 0) {
|
|
teleportToX = absX;
|
|
teleportToY = absY;
|
|
}
|
|
newWalkCmdSteps = 0;
|
|
getNewWalkCmdX()[0] = getNewWalkCmdY()[0] = travelBackX[0] = travelBackY[0] = 0;
|
|
getNextPlayerMovement();
|
|
}
|
|
|
|
private int newWalkCmdX[] = new int[walkingQueueSize];
|
|
private int newWalkCmdY[] = new int[walkingQueueSize];
|
|
public int newWalkCmdSteps = 0;
|
|
private boolean newWalkCmdIsRunning = false;
|
|
protected int travelBackX[] = new int[walkingQueueSize];
|
|
protected int travelBackY[] = new int[walkingQueueSize];
|
|
protected int numTravelBackSteps = 0;
|
|
|
|
public void preProcessing() {
|
|
newWalkCmdSteps = 0;
|
|
}
|
|
|
|
public abstract void process();
|
|
|
|
public abstract boolean processQueuedPackets();
|
|
|
|
public void postProcessing() {
|
|
if (newWalkCmdSteps > 0) {
|
|
int firstX = getNewWalkCmdX()[0];
|
|
int firstY = getNewWalkCmdY()[0];
|
|
boolean found = false;
|
|
numTravelBackSteps = 0;
|
|
int ptr = wQueueReadPtr;
|
|
int dir = Misc.direction(currentX, currentY, firstX, firstY);
|
|
if (dir != -1 && (dir & 1) != 0) {
|
|
do {
|
|
int var13 = dir;
|
|
--ptr;
|
|
if (ptr < 0) {
|
|
ptr = 49;
|
|
}
|
|
|
|
travelBackX[numTravelBackSteps] = walkingQueueX[ptr];
|
|
travelBackY[numTravelBackSteps++] = walkingQueueY[ptr];
|
|
dir = Misc.direction(walkingQueueX[ptr],
|
|
walkingQueueY[ptr], firstX, firstY);
|
|
if (var13 != dir) {
|
|
found = true;
|
|
break;
|
|
}
|
|
} while (ptr != wQueueWritePtr);
|
|
} else {
|
|
found = true;
|
|
}
|
|
|
|
if (found) {
|
|
wQueueWritePtr = wQueueReadPtr;
|
|
addToWalkingQueue(currentX, currentY);
|
|
int i;
|
|
if (dir != -1 && (dir & 1) != 0) {
|
|
for (i = 0; i < numTravelBackSteps - 1; ++i) {
|
|
addToWalkingQueue(travelBackX[i], travelBackY[i]);
|
|
}
|
|
|
|
i = travelBackX[numTravelBackSteps - 1];
|
|
int wayPointY2 = travelBackY[numTravelBackSteps - 1];
|
|
int wayPointX1;
|
|
int wayPointY1;
|
|
if (numTravelBackSteps == 1) {
|
|
wayPointX1 = currentX;
|
|
wayPointY1 = currentY;
|
|
} else {
|
|
wayPointX1 = travelBackX[numTravelBackSteps - 2];
|
|
wayPointY1 = travelBackY[numTravelBackSteps - 2];
|
|
}
|
|
|
|
dir = Misc.direction(wayPointX1, wayPointY1, i, wayPointY2);
|
|
if (dir != -1 && (dir & 1) == 0) {
|
|
dir >>= 1;
|
|
found = false;
|
|
int x = wayPointX1;
|
|
int y = wayPointY1;
|
|
|
|
while (x != i || y != wayPointY2) {
|
|
x += Misc.directionDeltaX[dir];
|
|
y += Misc.directionDeltaY[dir];
|
|
if ((Misc.direction(x, y, firstX, firstY) & 1) == 0) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
println_debug("Fatal: Internal error: unable to determine connection vertex! wp1=("
|
|
+ wayPointX1
|
|
+ ", "
|
|
+ wayPointY1
|
|
+ "), wp2=("
|
|
+ i
|
|
+ ", "
|
|
+ wayPointY2
|
|
+ "), "
|
|
+ "first=("
|
|
+ firstX
|
|
+ ", "
|
|
+ firstY + ")");
|
|
} else {
|
|
addToWalkingQueue(wayPointX1, wayPointY1);
|
|
}
|
|
} else {
|
|
println_debug("Fatal: The walking queue is corrupt! wp1=("
|
|
+ wayPointX1
|
|
+ ", "
|
|
+ wayPointY1
|
|
+ "), "
|
|
+ "wp2=(" + i + ", " + wayPointY2 + ")");
|
|
}
|
|
} else {
|
|
for (i = 0; i < numTravelBackSteps; ++i) {
|
|
addToWalkingQueue(travelBackX[i], travelBackY[i]);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < newWalkCmdSteps; ++i) {
|
|
addToWalkingQueue(getNewWalkCmdX()[i], getNewWalkCmdY()[i]);
|
|
}
|
|
}
|
|
|
|
isRunning = isNewWalkCmdIsRunning() || isRunning2;
|
|
}
|
|
}
|
|
|
|
public int getMapRegionX() {
|
|
return mapRegionX;
|
|
}
|
|
|
|
public int getMapRegionY() {
|
|
return mapRegionY;
|
|
}
|
|
|
|
public int getX() {
|
|
return absX;
|
|
}
|
|
|
|
public int getY() {
|
|
return absY;
|
|
}
|
|
|
|
public int getH() {
|
|
return heightLevel;
|
|
}
|
|
|
|
public int getId() {
|
|
return playerId;
|
|
}
|
|
|
|
public void setHitDiff(int hitDiff) {
|
|
this.hitDiff = hitDiff;
|
|
}
|
|
|
|
public void setHitDiff2(int hitDiff2) {
|
|
this.hitDiff2 = hitDiff2;
|
|
}
|
|
|
|
public int getHitDiff() {
|
|
return hitDiff;
|
|
}
|
|
|
|
public void setHitUpdateRequired(boolean hitUpdateRequired) {
|
|
this.hitUpdateRequired = hitUpdateRequired;
|
|
}
|
|
|
|
public void setHitUpdateRequired2(boolean hitUpdateRequired2) {
|
|
this.hitUpdateRequired2 = hitUpdateRequired2;
|
|
}
|
|
|
|
public boolean isHitUpdateRequired() {
|
|
return hitUpdateRequired;
|
|
}
|
|
|
|
public boolean getHitUpdateRequired() {
|
|
return hitUpdateRequired;
|
|
}
|
|
|
|
public boolean getHitUpdateRequired2() {
|
|
return hitUpdateRequired2;
|
|
}
|
|
|
|
public void setAppearanceUpdateRequired(boolean appearanceUpdateRequired) {
|
|
this.appearanceUpdateRequired = appearanceUpdateRequired;
|
|
}
|
|
|
|
public boolean isAppearanceUpdateRequired() {
|
|
return appearanceUpdateRequired;
|
|
}
|
|
|
|
public void setChatTextEffects(int chatTextEffects) {
|
|
this.chatTextEffects = chatTextEffects;
|
|
}
|
|
|
|
public int getChatTextEffects() {
|
|
return chatTextEffects;
|
|
}
|
|
|
|
public void setChatTextSize(byte chatTextSize) {
|
|
this.chatTextSize = chatTextSize;
|
|
}
|
|
|
|
public byte getChatTextSize() {
|
|
return chatTextSize;
|
|
}
|
|
|
|
public void setChatTextUpdateRequired(boolean chatTextUpdateRequired) {
|
|
this.chatTextUpdateRequired = chatTextUpdateRequired;
|
|
}
|
|
|
|
public boolean isChatTextUpdateRequired() {
|
|
return chatTextUpdateRequired;
|
|
}
|
|
|
|
public void setChatText(byte chatText[]) {
|
|
this.chatText = chatText;
|
|
}
|
|
|
|
public byte[] getChatText() {
|
|
return chatText;
|
|
}
|
|
|
|
public void setChatTextColor(int chatTextColor) {
|
|
this.chatTextColor = chatTextColor;
|
|
}
|
|
|
|
public int getChatTextColor() {
|
|
return chatTextColor;
|
|
}
|
|
|
|
public void setNewWalkCmdX(int newWalkCmdX[]) {
|
|
this.newWalkCmdX = newWalkCmdX;
|
|
}
|
|
|
|
public int[] getNewWalkCmdX() {
|
|
return newWalkCmdX;
|
|
}
|
|
|
|
public void setNewWalkCmdY(int newWalkCmdY[]) {
|
|
this.newWalkCmdY = newWalkCmdY;
|
|
}
|
|
|
|
public int[] getNewWalkCmdY() {
|
|
return newWalkCmdY;
|
|
}
|
|
|
|
public void setNewWalkCmdIsRunning(boolean newWalkCmdIsRunning) {
|
|
this.newWalkCmdIsRunning = newWalkCmdIsRunning;
|
|
}
|
|
|
|
public boolean isNewWalkCmdIsRunning() {
|
|
return newWalkCmdIsRunning;
|
|
}
|
|
|
|
public void setInStreamDecryption(ISAACRandomGen inStreamDecryption) {
|
|
}
|
|
|
|
public void setOutStreamDecryption(ISAACRandomGen outStreamDecryption) {
|
|
}
|
|
|
|
public boolean samePlayer() {
|
|
for (int j = 0; j < PlayerHandler.players.length; j++) {
|
|
if (j == playerId) {
|
|
continue;
|
|
}
|
|
if (PlayerHandler.players[j] != null) {
|
|
if (PlayerHandler.players[j].playerName.equalsIgnoreCase(playerName)) {
|
|
disconnected = true;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void putInCombat(int attacker) {
|
|
underAttackBy = attacker;
|
|
logoutDelay = System.currentTimeMillis();
|
|
singleCombatDelay = System.currentTimeMillis();
|
|
}
|
|
|
|
|
|
public void dealDamage(int damage) {
|
|
if (teleTimer <= 0) {
|
|
playerLevel[3] -= damage;
|
|
int difference = playerLevel[3] - damage;
|
|
if (difference <= getLevelForXP(playerXP[3]) / 10 && difference > 0)
|
|
appendRedemption();
|
|
} else {
|
|
if (hitUpdateRequired) {
|
|
hitUpdateRequired = false;
|
|
}
|
|
if (hitUpdateRequired2) {
|
|
hitUpdateRequired2 = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void appendRedemption() {
|
|
Client c = (Client) PlayerHandler.players[playerId];
|
|
if (c.getPrayer().prayerActive[22]) {
|
|
int added = c.playerLevel[3] += (int)(c.getLevelForXP(c.playerXP[5]) * .25);
|
|
if (added > c.getLevelForXP(c.playerXP[3])) {
|
|
c.playerLevel[3] = c.getLevelForXP(c.playerXP[3]);
|
|
} else {
|
|
c.playerLevel[3] += (int)(getLevelForXP(c.playerXP[5]) * .25);
|
|
}
|
|
c.playerLevel[5] = 0;
|
|
c.getPlayerAssistant().refreshSkill(3);
|
|
c.getPlayerAssistant().refreshSkill(5);
|
|
c.gfx0(436);
|
|
PrayerDrain.resetPrayers(c);
|
|
}
|
|
}
|
|
|
|
|
|
public int[] damageTaken = new int[PlayerHandler.players.length];
|
|
|
|
public void handleHitMask(int damage) {
|
|
if (!hitUpdateRequired) {
|
|
hitUpdateRequired = true;
|
|
hitDiff = damage;
|
|
} else if (!hitUpdateRequired2) {
|
|
hitUpdateRequired2 = true;
|
|
hitDiff2 = damage;
|
|
}
|
|
updateRequired = true;
|
|
}
|
|
|
|
}
|