mirror of
https://github.com/2006-Scape/2006Scape.git
synced 2026-07-08 00:32:12 +00:00
init, thx MrExtremez
This commit is contained in:
Nicola Paolucci
@@ -0,0 +1,281 @@
|
||||
package redone.game.content.minigames;
|
||||
|
||||
import redone.game.content.quests.QuestRewards;
|
||||
import redone.game.npcs.NpcHandler;
|
||||
import redone.game.players.Client;
|
||||
import redone.util.Misc;
|
||||
|
||||
public class Barrows {
|
||||
|
||||
public Barrows(Client c) {
|
||||
this.c = c;
|
||||
}
|
||||
|
||||
private Client c;
|
||||
|
||||
/**
|
||||
* Variables used for reward.
|
||||
*/
|
||||
public static int Barrows[] = {4708, 4710, 4712, 4714, 4716, 4718, 4720, 4722, 4724, 4726, 4728, 4730, 4732, 4734, 4736, 4738, 4745, 4747, 4749, 4751, 4753, 4755, 4757, 4759};
|
||||
public static int Runes[] = {554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565};
|
||||
public static int Pots[] = {121, 123, 125, 127, 119, 2428, 2430, 2434, 2432, 2444};
|
||||
/**
|
||||
* Getting random barrow pieces.
|
||||
* @return
|
||||
*/
|
||||
public int randomBarrows() {
|
||||
return Barrows[(int)(Math.random()*Barrows.length)];
|
||||
}
|
||||
|
||||
/**
|
||||
* Getting random runes.
|
||||
* @return
|
||||
*/
|
||||
public int randomRunes() {
|
||||
return Runes[(int) (Math.random()*Runes.length)];
|
||||
}
|
||||
|
||||
/**
|
||||
* Getting random pots.
|
||||
* @return
|
||||
*/
|
||||
public int randomPots() {
|
||||
return Pots[(int) (Math.random()*Pots.length)];
|
||||
}
|
||||
|
||||
/**
|
||||
* All of the barrow data.
|
||||
*/
|
||||
public static int[][] barrowData = {
|
||||
/** ID Coffin X Y Stair X Y */
|
||||
{2026, 6771, 3556, 9716, 6703, 3574, 3297}, /**Dharoks*/
|
||||
{2030, 6823, 3575, 9706, 6707, 3557, 3297}, /**Veracs*/
|
||||
{2025, 6821, 3557, 9700, 6702, 3565, 3288}, /**Ahrims*/
|
||||
{2029, 6772, 3568, 9685, 6706, 3554, 3282}, /**Torags*/
|
||||
{2027, 6773, 3537, 9703, 6704, 3577, 3282}, /**Guthans*/
|
||||
{2028, 6822, 3549, 9682, 6705, 3566, 3275} /**Karils*/
|
||||
};
|
||||
|
||||
/**
|
||||
* All of the spade data
|
||||
*/
|
||||
public int[][] spadeData = {
|
||||
/** X Y X1 Y1 toX toY */
|
||||
{3553, 3301, 3561, 3294, 3578, 9706},
|
||||
{3550, 3287, 3557, 3278, 3568, 9683},
|
||||
{3561, 3292, 3568, 3285, 3557, 9703},
|
||||
{3570, 3302, 3579, 3293, 3556, 9718},
|
||||
{3571, 3285, 3582, 3278, 3534, 9704},
|
||||
{3562, 3279, 3569, 3273, 3546, 9684},
|
||||
};
|
||||
|
||||
/**
|
||||
* Spade digging data
|
||||
*/
|
||||
public void spadeDigging() {
|
||||
if(c.inArea(spadeData[0][0], spadeData[0][1], spadeData[0][2], spadeData[0][3])) {
|
||||
c.getPlayerAssistant().movePlayer(spadeData[0][4], spadeData[0][5], 3);
|
||||
} else if(c.inArea(spadeData[1][0], spadeData[1][1], spadeData[1][2], spadeData[1][3])) {
|
||||
c.getPlayerAssistant().movePlayer(spadeData[1][4], spadeData[1][5], 3);
|
||||
} else if(c.inArea(spadeData[2][0], spadeData[2][1], spadeData[2][2], spadeData[2][3])) {
|
||||
c.getPlayerAssistant().movePlayer(spadeData[2][4], spadeData[2][5], 3);
|
||||
} else if(c.inArea(spadeData[3][0], spadeData[3][1], spadeData[3][2], spadeData[3][3])) {
|
||||
c.getPlayerAssistant().movePlayer(spadeData[3][4], spadeData[3][5], 3);
|
||||
} else if(c.inArea(spadeData[4][0], spadeData[4][1], spadeData[4][2], spadeData[4][3])) {
|
||||
c.getPlayerAssistant().movePlayer(spadeData[4][4], spadeData[4][5], 3);
|
||||
} else if(c.inArea(spadeData[5][0], spadeData[5][1], spadeData[5][2], spadeData[5][3])) {
|
||||
c.getPlayerAssistant().movePlayer(spadeData[5][4], spadeData[5][5], 3);
|
||||
} else if (c.absX == 2999 && c.absY == 3375) {
|
||||
c.getDialogueHandler().sendDialogues(1007, c.npcType);
|
||||
} else if (c.absX == 2996 && c.absY == 3377) {
|
||||
c.getDialogueHandler().sendDialogues(1007, c.npcType);
|
||||
} else if (c.absX == 3005 && c.absY == 3376) {
|
||||
c.getDialogueHandler().sendDialogues(1007, c.npcType);
|
||||
} else if (c.absX == 2999 && c.absY == 3383 && c.pirateTreasure == 4) {
|
||||
NpcHandler.spawnNpc(c, 1217, c.absX + Misc.random(1), c.absY + Misc.random(1), c.heightLevel, 0, 10, 2, 5, 5, true, true);
|
||||
c.getDialogueHandler().sendNpcChat1("First moles, now this! Take this, vanda!", c.talkingNpc, "Gardener");
|
||||
c.pirateTreasure = 5;
|
||||
} else if (c.absX == 2999 && c.absY == 3383 && c.pirateTreasure == 5) {
|
||||
QuestRewards.pirateFinish(c);
|
||||
} else {
|
||||
c.getActionSender().sendMessage("You don't find anything...");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stair data
|
||||
*/
|
||||
public void useStairs() {
|
||||
if (c.isInBarrows2()) {
|
||||
switch(c.objectId) {
|
||||
case 6703:
|
||||
c.getPlayerAssistant().movePlayer(barrowData[0][5], barrowData[0][6], 0);
|
||||
break;
|
||||
case 6707:
|
||||
c.getPlayerAssistant().movePlayer(barrowData[1][5], barrowData[1][6], 0);
|
||||
break;
|
||||
case 6702:
|
||||
c.getPlayerAssistant().movePlayer(barrowData[2][5], barrowData[2][6], 0);
|
||||
break;
|
||||
case 6706:
|
||||
c.getPlayerAssistant().movePlayer(barrowData[3][5], barrowData[3][6], 0);
|
||||
break;
|
||||
case 6704:
|
||||
c.getPlayerAssistant().movePlayer(barrowData[4][5], barrowData[4][6], 0);
|
||||
break;
|
||||
case 6705:
|
||||
c.getPlayerAssistant().movePlayer(barrowData[5][5], barrowData[5][6], 0);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
c.getActionSender().sendMessage("You have to be in barrows to do this!");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public void checkCoffins() {
|
||||
if (c.isInBarrows2()) {
|
||||
if (c.barrowsKillCount < 5) {
|
||||
c.getActionSender().sendMessage("You still have to kill the following brothers:");
|
||||
if (c.barrowsNpcs[2][1] == 0) {
|
||||
c.getActionSender().sendMessage("- Karils");
|
||||
}
|
||||
if (c.barrowsNpcs[3][1] == 0) {
|
||||
c.getActionSender().sendMessage("- Guthans");
|
||||
}
|
||||
if (c.barrowsNpcs[1][1] == 0) {
|
||||
c.getActionSender().sendMessage("- Torags");
|
||||
}
|
||||
if (c.barrowsNpcs[5][1] == 0) {
|
||||
c.getActionSender().sendMessage("- Ahrims");
|
||||
}
|
||||
if (c.barrowsNpcs[0][1] == 0) {
|
||||
c.getActionSender().sendMessage("- Veracs");
|
||||
}
|
||||
c.getPlayerAssistant().removeAllWindows();
|
||||
} else if (c.barrowsKillCount == 5) {
|
||||
NpcHandler.spawnNpc(c, 2026, c.getX(), c.getY()-1, 3, 0, 120, 25, 200, 200, true, true);
|
||||
c.getPlayerAssistant().removeAllWindows();
|
||||
} else if (c.barrowsKillCount > 5) {
|
||||
c.getPlayerAssistant().movePlayer(3551, 9694, 0);
|
||||
c.getActionSender().sendMessage("You teleport to the chest.");
|
||||
c.getPlayerAssistant().removeAllWindows();
|
||||
}
|
||||
} else {
|
||||
c.getActionSender().sendMessage("You have to be in barrows to do this!");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Grabs the reward based on random chance depending on what your killcount is.
|
||||
*/
|
||||
public void reward() {
|
||||
if (c.isInBarrows2()) {
|
||||
c.getItemAssistant().addItem(randomRunes(), Misc.random(150) + 100);
|
||||
c.getItemAssistant().addItem(randomRunes(), Misc.random(150) + 100);
|
||||
c.getItemAssistant().addItem(randomPots(), 1);
|
||||
if (c.barrowsKillCount >= 6 && c.barrowsKillCount <= 24) {
|
||||
if (Misc.random(10) == 1)
|
||||
c.getItemAssistant().addItem(randomBarrows(), 1);
|
||||
} else if (c.barrowsKillCount >= 25 && c.barrowsKillCount <= 49) {
|
||||
if (Misc.random(8) == 1)
|
||||
c.getItemAssistant().addItem(randomBarrows(), 1);
|
||||
} else if (c.barrowsKillCount >= 50 && c.barrowsKillCount <= 99) {
|
||||
if (Misc.random(5) == 1)
|
||||
c.getItemAssistant().addItem(randomBarrows(), 1);
|
||||
} else if (c.barrowsKillCount >= 100 && c.barrowsKillCount <= 149) {
|
||||
if (Misc.random(2) == 1)
|
||||
c.getItemAssistant().addItem(randomBarrows(), 1);
|
||||
} else if (c.barrowsKillCount >= 150) {
|
||||
c.getItemAssistant().addItem(randomBarrows(), 1);
|
||||
}
|
||||
} else {
|
||||
c.getActionSender().sendMessage("You have to be in barrows to do this!");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checking if you have killed all of the brothers.
|
||||
* @return
|
||||
*/
|
||||
public boolean checkBarrows() {
|
||||
if (c.barrowsNpcs[2][1] == 2 ||
|
||||
c.barrowsNpcs[3][1] == 2 ||
|
||||
c.barrowsNpcs[1][1] == 2 ||
|
||||
c.barrowsNpcs[5][1] == 2 ||
|
||||
c.barrowsNpcs[0][1] == 2 ||
|
||||
c.barrowsNpcs[4][1] == 2) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Using the chest.
|
||||
*/
|
||||
public void useChest() {
|
||||
if (c.isInBarrows2()) {
|
||||
if (!checkBarrows()) {
|
||||
c.getActionSender().sendMessage("You haven't killed all the brothers!");
|
||||
return;
|
||||
}
|
||||
if (c.barrowsKillCount == 5) {
|
||||
if (c.barrowsNpcs[4][1] == 0) {
|
||||
NpcHandler.spawnNpc(c, 2026, c.getX(), c.getY()-1, 0, 0, 120, 25, 200, 200, true, true);
|
||||
}
|
||||
c.barrowsNpcs[4][1] = 1;
|
||||
}
|
||||
if (c.barrowsKillCount > 5 && checkBarrows()) {
|
||||
if (c.getItemAssistant().freeSlots() >= 4) {
|
||||
reward();
|
||||
resetBarrows();
|
||||
} else {
|
||||
c.getActionSender().sendMessage("You need more inventory slots to open the chest.");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
c.getActionSender().sendMessage("You have to be in barrows to do this!");
|
||||
}
|
||||
}
|
||||
|
||||
public void fixAllBarrows() {
|
||||
int totalCost = 0;
|
||||
int cashAmount = c.getItemAssistant().getItemAmount(995);
|
||||
for (int j = 0; j < c.playerItems.length; j++) {
|
||||
boolean breakOut = false;
|
||||
for (int i = 0; i < c.getItemAssistant().brokenBarrows.length; i++) {
|
||||
if (c.playerItems[j] - 1 == c.getItemAssistant().brokenBarrows[i][1]) {
|
||||
if (totalCost + 80000 > cashAmount) {
|
||||
breakOut = true;
|
||||
c.getActionSender().sendMessage("You have run out of money.");
|
||||
break;
|
||||
} else {
|
||||
totalCost += 80000;
|
||||
}
|
||||
c.playerItems[j] = c.getItemAssistant().brokenBarrows[i][0] + 1;
|
||||
}
|
||||
}
|
||||
if (breakOut)
|
||||
break;
|
||||
}
|
||||
if (totalCost > 0)
|
||||
c.getItemAssistant().deleteItem(995, c.getItemAssistant().getItemSlot(995),
|
||||
totalCost);
|
||||
}
|
||||
|
||||
/**
|
||||
* Resetting the minigame.
|
||||
*/
|
||||
public void resetBarrows() {
|
||||
c.barrowsNpcs[0][1] = 0;
|
||||
c.barrowsNpcs[1][1] = 0;
|
||||
c.barrowsNpcs[2][1] = 0;
|
||||
c.barrowsNpcs[3][1] = 0;
|
||||
c.barrowsNpcs[4][1] = 0;
|
||||
c.barrowsNpcs[5][1] = 0;
|
||||
c.barrowsKillCount = 0;
|
||||
c.getPlayerAssistant().movePlayer(3565, 3288, 0);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -0,0 +1,853 @@
|
||||
package redone.game.content.minigames;
|
||||
|
||||
import java.util.concurrent.CopyOnWriteArrayList;
|
||||
|
||||
import redone.Constants;
|
||||
import redone.Server;
|
||||
import redone.game.content.combat.prayer.PrayerDrain;
|
||||
import redone.game.content.minigames.castlewars.CastleWars;
|
||||
import redone.game.items.GameItem;
|
||||
import redone.game.items.Item;
|
||||
import redone.game.items.ItemAssistant;
|
||||
import redone.game.items.impl.RareProtection;
|
||||
import redone.game.players.Client;
|
||||
import redone.game.players.PlayerHandler;
|
||||
import redone.game.players.PlayerSave;
|
||||
import redone.util.GameLogger;
|
||||
import redone.util.Misc;
|
||||
|
||||
public class Dueling {
|
||||
|
||||
private final Client player;
|
||||
|
||||
public Dueling(Client Client) {
|
||||
player = Client;
|
||||
}
|
||||
|
||||
public CopyOnWriteArrayList<GameItem> otherStakedItems = new CopyOnWriteArrayList<GameItem>();
|
||||
public CopyOnWriteArrayList<GameItem> stakedItems = new CopyOnWriteArrayList<GameItem>();
|
||||
|
||||
public void requestDuel(int id) {
|
||||
try {
|
||||
if (id == player.playerId) {
|
||||
return;
|
||||
}
|
||||
if (!CastleWars.deleteCastleWarsItems(player, id)) {
|
||||
return;
|
||||
}
|
||||
if (player.inTrade || player.isShopping) {
|
||||
player.getActionSender().sendMessage("You can not stake currently.");
|
||||
return;
|
||||
}
|
||||
if (!player.inDuelArena()) {
|
||||
player.getActionSender().sendMessage("You must be in the duel arena to do that.");
|
||||
return;
|
||||
}
|
||||
resetDuel();
|
||||
resetDuelItems();
|
||||
player.duelingWith = id;
|
||||
Client o = (Client) PlayerHandler.players[id];
|
||||
if (o == null) {
|
||||
return;
|
||||
}
|
||||
/*if (player.connectedFrom.equals(o.connectedFrom)) {
|
||||
player.getActionSender().sendMessage("You can't duel your own IP.");
|
||||
return;
|
||||
}*/
|
||||
player.duelRequested = true;
|
||||
if (player.duelStatus == 0 && o.duelStatus == 0 && player.duelRequested
|
||||
&& o.duelRequested && player.duelingWith == o.getId()
|
||||
&& o.duelingWith == player.getId()) {
|
||||
if (player.goodDistance(player.getX(), player.getY(), o.getX(), o.getY(), 2)) {
|
||||
player.getDueling().openDuel();
|
||||
o.getDueling().openDuel();
|
||||
} else {
|
||||
player.getActionSender()
|
||||
.sendMessage(
|
||||
"You need to get closer to your opponent to start the duel.");
|
||||
}
|
||||
|
||||
} else {
|
||||
player.getActionSender().sendMessage("Sending duel request...");
|
||||
o.getActionSender().sendMessage(player.playerName + ":duelreq:");
|
||||
}
|
||||
} catch (Exception e) {
|
||||
Misc.println("Error requesting duel.");
|
||||
}
|
||||
}
|
||||
|
||||
public void openDuel() {
|
||||
Client o = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if (o == null) {
|
||||
return;
|
||||
}
|
||||
if (player.inTrade || player.isShopping) {
|
||||
player.getActionSender().sendMessage("You can not stake currently.");
|
||||
return;
|
||||
}
|
||||
if (!player.inDuelArena()) {
|
||||
player.getActionSender().sendMessage("You must be in the duel arena to do that.");
|
||||
return;
|
||||
}
|
||||
if (player.duelingArena()) {
|
||||
player.getActionSender().sendMessage("You can't do that in a duel!");
|
||||
return;
|
||||
}
|
||||
player.duelStatus = 1;
|
||||
refreshduelRules();
|
||||
refreshDuelScreen();
|
||||
player.openDuel = true;
|
||||
o.openDuel = true;
|
||||
for (int i = 0; i < player.playerEquipment.length; i++) {
|
||||
sendDuelEquipment(player.playerEquipment[i], player.playerEquipmentN[i], i);
|
||||
}
|
||||
player.getPlayerAssistant().sendFrame126("Dueling with: " + o.playerName + " (level-" + o.combatLevel + ")", 6671);
|
||||
player.getPlayerAssistant().sendFrame126("", 6684);
|
||||
player.getPlayerAssistant().sendFrame248(6575, 3321);
|
||||
player.getItemAssistant().resetItems(3322);
|
||||
}
|
||||
|
||||
public void sendDuelEquipment(int itemId, int amount, int slot) {
|
||||
synchronized (player) {
|
||||
if (itemId != 0) {
|
||||
player.getOutStream().createFrameVarSizeWord(34);
|
||||
player.getOutStream().writeWord(13824);
|
||||
player.getOutStream().writeByte(slot);
|
||||
player.getOutStream().writeWord(itemId + 1);
|
||||
|
||||
if (amount > 254) {
|
||||
player.getOutStream().writeByte(255);
|
||||
player.getOutStream().writeDWord(amount);
|
||||
} else {
|
||||
player.getOutStream().writeByte(amount);
|
||||
}
|
||||
player.getOutStream().endFrameVarSizeWord();
|
||||
player.flushOutStream();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void refreshduelRules() {
|
||||
for (int i = 0; i < player.duelRule.length; i++) {
|
||||
player.duelRule[i] = false;
|
||||
}
|
||||
player.getPlayerAssistant().sendFrame87(286, 0);
|
||||
player.duelOption = 0;
|
||||
}
|
||||
|
||||
public void refreshDuelScreen() {
|
||||
synchronized (player) {
|
||||
Client o = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if (o == null) {
|
||||
return;
|
||||
}
|
||||
if(!player.openDuel && !o.openDuel) {
|
||||
declineDuel();
|
||||
return;
|
||||
}
|
||||
player.getOutStream().createFrameVarSizeWord(53);
|
||||
player.getOutStream().writeWord(6669);
|
||||
player.getOutStream().writeWord(stakedItems.toArray().length);
|
||||
int current = 0;
|
||||
for (GameItem item : stakedItems) {
|
||||
if (item.amount > 254) {
|
||||
player.getOutStream().writeByte(255);
|
||||
player.getOutStream().writeDWord_v2(item.amount);
|
||||
} else {
|
||||
player.getOutStream().writeByte(item.amount);
|
||||
}
|
||||
if (item.id > Constants.ITEM_LIMIT || item.id < 0) {
|
||||
item.id = Constants.ITEM_LIMIT;
|
||||
}
|
||||
player.getOutStream().writeWordBigEndianA(item.id + 1);
|
||||
|
||||
current++;
|
||||
}
|
||||
|
||||
if (current < 27) {
|
||||
for (int i = current; i < 28; i++) {
|
||||
player.getOutStream().writeByte(1);
|
||||
player.getOutStream().writeWordBigEndianA(-1);
|
||||
}
|
||||
}
|
||||
player.getOutStream().endFrameVarSizeWord();
|
||||
player.flushOutStream();
|
||||
|
||||
player.getOutStream().createFrameVarSizeWord(53);
|
||||
player.getOutStream().writeWord(6670);
|
||||
player.getOutStream().writeWord(
|
||||
o.getDueling().stakedItems.toArray().length);
|
||||
current = 0;
|
||||
for (GameItem item : o.getDueling().stakedItems) {
|
||||
if (item.amount > 254) {
|
||||
player.getOutStream().writeByte(255);
|
||||
player.getOutStream().writeDWord_v2(item.amount);
|
||||
} else {
|
||||
player.getOutStream().writeByte(item.amount);
|
||||
}
|
||||
if (item.id > Constants.ITEM_LIMIT || item.id < 0) {
|
||||
item.id = Constants.ITEM_LIMIT;
|
||||
}
|
||||
player.getOutStream().writeWordBigEndianA(item.id + 1);
|
||||
current++;
|
||||
}
|
||||
|
||||
if (current < 27) {
|
||||
for (int i = current; i < 28; i++) {
|
||||
player.getOutStream().writeByte(1);
|
||||
player.getOutStream().writeWordBigEndianA(-1);
|
||||
}
|
||||
}
|
||||
player.getOutStream().endFrameVarSizeWord();
|
||||
player.flushOutStream();
|
||||
}
|
||||
}
|
||||
|
||||
public boolean stakeItem(int itemID, int fromSlot, int amount) {
|
||||
|
||||
for (int i : Constants.ITEM_TRADEABLE) {
|
||||
if (i == itemID || itemID >= 6864 && itemID <= 6882) {
|
||||
player.getActionSender().sendMessage(
|
||||
"You can't stake this item.");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (player.inTrade || player.isShopping) {
|
||||
player.getActionSender().sendMessage("You can not stake currently.");
|
||||
return false;
|
||||
}
|
||||
if (!player.inDuelArena()) {
|
||||
player.getActionSender().sendMessage("You must be in the duel arena to do that.");
|
||||
return false;
|
||||
}
|
||||
if (player.duelingArena()) {
|
||||
player.getActionSender().sendMessage("You can't do that in a duel!");
|
||||
return false;
|
||||
}
|
||||
if (!RareProtection.doOtherDupe(player, itemID)) {
|
||||
return false;
|
||||
}
|
||||
if (amount <= 0) {
|
||||
return false;
|
||||
}
|
||||
Client o = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if(!player.openDuel && !o.openDuel) {
|
||||
declineDuel();
|
||||
return false;
|
||||
}
|
||||
if(!player.getItemAssistant().playerHasItem(itemID, amount))
|
||||
return false;
|
||||
if (amount <= 0)
|
||||
return false;
|
||||
if (o == null) {
|
||||
declineDuel();
|
||||
return false;
|
||||
}
|
||||
if (o.duelStatus <= 0 || player.duelStatus <= 0) {
|
||||
declineDuel();
|
||||
o.getDueling().declineDuel();
|
||||
return false;
|
||||
}
|
||||
changeDuelStuff();
|
||||
if (!Item.itemStackable[itemID]) {
|
||||
for (int a = 0; a < amount; a++) {
|
||||
if (player.getItemAssistant().playerHasItem(itemID, 1)) {
|
||||
stakedItems.add(new GameItem(itemID, 1));
|
||||
player.getItemAssistant().deleteItem(itemID,
|
||||
player.getItemAssistant().getItemSlot(itemID), 1);
|
||||
}
|
||||
}
|
||||
player.getItemAssistant().resetItems(3214);
|
||||
player.getItemAssistant().resetItems(3322);
|
||||
o.getItemAssistant().resetItems(3214);
|
||||
o.getItemAssistant().resetItems(3322);
|
||||
refreshDuelScreen();
|
||||
o.getDueling().refreshDuelScreen();
|
||||
player.getPlayerAssistant().sendFrame126("", 6684);
|
||||
o.getPlayerAssistant().sendFrame126("", 6684);
|
||||
}
|
||||
if (Item.itemStackable[itemID] || Item.itemIsNote[itemID]) {
|
||||
boolean found = false;
|
||||
for (GameItem item : stakedItems) {
|
||||
if (item.id == itemID) {
|
||||
found = true;
|
||||
item.amount += amount;
|
||||
player.getItemAssistant().deleteItem(itemID, fromSlot, amount);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
player.getItemAssistant().deleteItem(itemID, fromSlot, amount);
|
||||
stakedItems.add(new GameItem(itemID, amount));
|
||||
}
|
||||
}
|
||||
|
||||
player.getItemAssistant().resetItems(3214);
|
||||
player.getItemAssistant().resetItems(3322);
|
||||
o.getItemAssistant().resetItems(3214);
|
||||
o.getItemAssistant().resetItems(3322);
|
||||
refreshDuelScreen();
|
||||
o.getDueling().refreshDuelScreen();
|
||||
player.getPlayerAssistant().sendFrame126("", 6684);
|
||||
o.getPlayerAssistant().sendFrame126("", 6684);
|
||||
return true;
|
||||
}
|
||||
|
||||
public boolean fromDuel(int itemID, int fromSlot, int amount) {
|
||||
Client o = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if (o == null) {
|
||||
declineDuel();
|
||||
return false;
|
||||
}
|
||||
if(!player.openDuel && !o.openDuel) {
|
||||
declineDuel();
|
||||
return false;
|
||||
}
|
||||
if (player.inTrade || player.isShopping) {
|
||||
player.getActionSender().sendMessage("You can not stake currently.");
|
||||
return false;
|
||||
}
|
||||
if (!player.inDuelArena()) {
|
||||
player.getActionSender().sendMessage("You must be in the duel arena to do that.");
|
||||
return false;
|
||||
}
|
||||
if (player.duelingArena()) {
|
||||
player.getActionSender().sendMessage("You can't do that in a duel!");
|
||||
return false;
|
||||
}
|
||||
if (o.duelStatus <= 0 || player.duelStatus <= 0) {
|
||||
declineDuel();
|
||||
o.getDueling().declineDuel();
|
||||
return false;
|
||||
}
|
||||
if (Item.itemStackable[itemID]) {
|
||||
if (player.getItemAssistant().freeSlots() - 1 < player.duelSpaceReq) {
|
||||
player.getActionSender().sendMessage(
|
||||
"You have too many rules set to remove that item.");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
changeDuelStuff();
|
||||
boolean goodSpace = true;
|
||||
if (!Item.itemStackable[itemID]) {
|
||||
for (int a = 0; a < amount; a++) {
|
||||
for (GameItem item : stakedItems) {
|
||||
if (item.id == itemID) {
|
||||
if (!item.stackable) {
|
||||
if (player.getItemAssistant().freeSlots() - 1 < player.duelSpaceReq) {
|
||||
goodSpace = false;
|
||||
break;
|
||||
}
|
||||
stakedItems.remove(item);
|
||||
player.getItemAssistant().addItem(itemID, 1);
|
||||
} else {
|
||||
if (player.getItemAssistant().freeSlots() - 1 < player.duelSpaceReq) {
|
||||
goodSpace = false;
|
||||
break;
|
||||
}
|
||||
if (item.amount > amount) {
|
||||
item.amount -= amount;
|
||||
player.getItemAssistant().addItem(itemID, amount);
|
||||
} else {
|
||||
if (player.getItemAssistant().freeSlots() - 1 < player.duelSpaceReq) {
|
||||
goodSpace = false;
|
||||
break;
|
||||
}
|
||||
amount = item.amount;
|
||||
stakedItems.remove(item);
|
||||
player.getItemAssistant().addItem(itemID, amount);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
o.duelStatus = 1;
|
||||
player.duelStatus = 1;
|
||||
player.getItemAssistant().resetItems(3214);
|
||||
player.getItemAssistant().resetItems(3322);
|
||||
o.getItemAssistant().resetItems(3214);
|
||||
o.getItemAssistant().resetItems(3322);
|
||||
player.getDueling().refreshDuelScreen();
|
||||
o.getDueling().refreshDuelScreen();
|
||||
o.getPlayerAssistant().sendFrame126("", 6684);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (GameItem item : stakedItems) {
|
||||
if (item.id == itemID) {
|
||||
if (!item.stackable) {
|
||||
} else {
|
||||
if (item.amount > amount) {
|
||||
item.amount -= amount;
|
||||
player.getItemAssistant().addItem(itemID, amount);
|
||||
} else {
|
||||
amount = item.amount;
|
||||
stakedItems.remove(item);
|
||||
player.getItemAssistant().addItem(itemID, amount);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
o.duelStatus = 1;
|
||||
player.duelStatus = 1;
|
||||
player.getItemAssistant().resetItems(3214);
|
||||
player.getItemAssistant().resetItems(3322);
|
||||
o.getItemAssistant().resetItems(3214);
|
||||
o.getItemAssistant().resetItems(3322);
|
||||
player.getDueling().refreshDuelScreen();
|
||||
o.getDueling().refreshDuelScreen();
|
||||
o.getPlayerAssistant().sendFrame126("", 6684);
|
||||
if (!goodSpace) {
|
||||
player.getActionSender().sendMessage(
|
||||
"You have too many rules set to remove that item.");
|
||||
return true;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public void confirmDuel() {
|
||||
Client o = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if (o == null) {
|
||||
declineDuel();
|
||||
return;
|
||||
}
|
||||
if (player.inTrade || player.isShopping) {
|
||||
player.getActionSender().sendMessage("You can not stake currently.");
|
||||
return;
|
||||
}
|
||||
if (!player.inDuelArena()) {
|
||||
player.getActionSender().sendMessage("You must be in the duel arena to confirm a duel.");
|
||||
return;
|
||||
}
|
||||
if (player.duelingArena()) {
|
||||
player.getActionSender().sendMessage("You can't do that in a duel!");
|
||||
return;
|
||||
}
|
||||
String itemId = "";
|
||||
for (GameItem item : stakedItems) {
|
||||
if (Item.itemStackable[item.id] || Item.itemIsNote[item.id]) {
|
||||
itemId += ItemAssistant.getItemName(item.id) + " x "
|
||||
+ Misc.format(item.amount) + "\\n";
|
||||
} else {
|
||||
itemId += ItemAssistant.getItemName(item.id) + "\\n";
|
||||
}
|
||||
}
|
||||
player.getPlayerAssistant().sendFrame126(itemId, 6516);
|
||||
itemId = "";
|
||||
for (GameItem item : o.getDueling().stakedItems) {
|
||||
if (Item.itemStackable[item.id] || Item.itemIsNote[item.id]) {
|
||||
itemId += ItemAssistant.getItemName(item.id) + " x "
|
||||
+ Misc.format(item.amount) + "\\n";
|
||||
} else {
|
||||
itemId += ItemAssistant.getItemName(item.id) + "\\n";
|
||||
}
|
||||
}
|
||||
player.getPlayerAssistant().sendFrame126(itemId, 6517);
|
||||
player.getPlayerAssistant().sendFrame126("", 8242);
|
||||
for (int i = 8238; i <= 8253; i++) {
|
||||
player.getPlayerAssistant().sendFrame126("", i);
|
||||
}
|
||||
player.getPlayerAssistant().sendFrame126("Hitpoints will be restored.", 8250);
|
||||
player.getPlayerAssistant().sendFrame126("Boosted stats will be restored.",
|
||||
8238);
|
||||
if (player.duelRule[8]) {
|
||||
player.getPlayerAssistant().sendFrame126(
|
||||
"There will be obstacles in the arena.", 8239);
|
||||
}
|
||||
player.getPlayerAssistant().sendFrame126("", 8240);
|
||||
player.getPlayerAssistant().sendFrame126("", 8241);
|
||||
|
||||
String[] rulesOption = { "Players cannot forfeit!",
|
||||
"Players cannot move.", "Players cannot use range.",
|
||||
"Players cannot use melee.", "Players cannot use magic.",
|
||||
"Players cannot drink pots.", "Players cannot eat food.",
|
||||
"Players cannot use prayer." };
|
||||
|
||||
int lineNumber = 8242;
|
||||
for (int i = 0; i < 8; i++) {
|
||||
if (player.duelRule[i]) {
|
||||
player.getPlayerAssistant().sendFrame126("" + rulesOption[i],
|
||||
lineNumber);
|
||||
lineNumber++;
|
||||
}
|
||||
}
|
||||
player.getPlayerAssistant().sendFrame126("", 6571);
|
||||
player.getPlayerAssistant().sendFrame248(6412, 197);
|
||||
// c.getPA().showInterface(6412);
|
||||
}
|
||||
|
||||
public void startDuel() {
|
||||
Client o = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if (!player.inDuelArena()) {
|
||||
player.getActionSender().sendMessage("You must be in the duel arena to start a duel.");
|
||||
return;
|
||||
}
|
||||
if (player.inTrade || player.isShopping) {
|
||||
player.getActionSender().sendMessage("You can not stake currently.");
|
||||
return;
|
||||
}
|
||||
if (player.duelingArena()) {
|
||||
player.getActionSender().sendMessage("You can't do that in a duel!");
|
||||
return;
|
||||
}
|
||||
if (o == null || o.disconnected) {
|
||||
duelVictory();
|
||||
}
|
||||
player.headIconHints = 2;
|
||||
|
||||
if (player.duelRule[7]) {
|
||||
for (int p = 0; p < player.getPrayer().PRAYER.length; p++) { // reset
|
||||
// prayer
|
||||
// glows
|
||||
player.getPrayer().prayerActive[p] = false;
|
||||
player.getPlayerAssistant().sendConfig(player.getPrayer().PRAYER_GLOW[p],
|
||||
0);
|
||||
}
|
||||
player.headIcon = -1;
|
||||
player.getPlayerAssistant().requestUpdates();
|
||||
}
|
||||
if (player.duelRule[11]) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[0], 0);
|
||||
}
|
||||
if (player.duelRule[12]) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[1], 1);
|
||||
}
|
||||
if (player.duelRule[13]) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[2], 2);
|
||||
}
|
||||
if (player.duelRule[14]) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[3], 3);
|
||||
}
|
||||
if (player.duelRule[15]) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[4], 4);
|
||||
}
|
||||
if (player.duelRule[16]) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[5], 5);
|
||||
}
|
||||
if (player.duelRule[17]) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[7], 7);
|
||||
}
|
||||
if (player.duelRule[18]) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[9], 9);
|
||||
}
|
||||
if (player.duelRule[19]) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[10], 10);
|
||||
}
|
||||
if (player.duelRule[20]) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[12], 12);
|
||||
}
|
||||
if (player.duelRule[21]) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[13], 13);
|
||||
}
|
||||
player.duelStatus = 5;
|
||||
player.getPlayerAssistant().removeAllWindows();
|
||||
player.specAmount = 10;
|
||||
player.getItemAssistant().addSpecialBar(player.playerEquipment[player.playerWeapon]);
|
||||
|
||||
if (player.duelRule[8]) {
|
||||
if (player.duelRule[1]) {
|
||||
player.getPlayerAssistant().movePlayer(player.duelTeleX, player.duelTeleY, 0);
|
||||
} else {
|
||||
player.getPlayerAssistant().movePlayer(3366 + Misc.random(12),
|
||||
3246 + Misc.random(6), 0);
|
||||
}
|
||||
} else {
|
||||
if (player.duelRule[1]) {
|
||||
player.getPlayerAssistant().movePlayer(player.duelTeleX, player.duelTeleY, 0);
|
||||
} else {
|
||||
player.getPlayerAssistant().movePlayer(3335 + Misc.random(12),
|
||||
3246 + Misc.random(6), 0);
|
||||
}
|
||||
}
|
||||
|
||||
player.getActionSender().createPlayerHints(10, o.playerId);
|
||||
player.getActionSender().showOption(3, 0, "Attack", 1);
|
||||
for (int i = 0; i < 20; i++) {
|
||||
player.playerLevel[i] = player.getPlayerAssistant().getLevelForXP(
|
||||
player.playerXP[i]);
|
||||
player.getPlayerAssistant().refreshSkill(i);
|
||||
}
|
||||
for (GameItem item : o.getDueling().stakedItems) {
|
||||
otherStakedItems.add(new GameItem(item.id, item.amount));
|
||||
}
|
||||
PlayerSave.saveGame(player);
|
||||
player.getPlayerAssistant().requestUpdates();
|
||||
}
|
||||
|
||||
public void duelVictory() {
|
||||
Client opponent = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if (opponent != null) {
|
||||
player.getPlayerAssistant().sendFrame126("" + opponent.combatLevel, 6839);
|
||||
player.getPlayerAssistant().sendFrame126(opponent.playerName, 6840);
|
||||
opponent.duelStatus = 0;
|
||||
} else {
|
||||
player.getPlayerAssistant().sendFrame126("", 6839);
|
||||
player.getPlayerAssistant().sendFrame126("", 6840);
|
||||
}
|
||||
PrayerDrain.resetPrayers(player);
|
||||
for (int i = 0; i < 20; i++) {
|
||||
player.playerLevel[i] = player.getPlayerAssistant().getLevelForXP(
|
||||
player.playerXP[i]);
|
||||
player.getPlayerAssistant().refreshSkill(i);
|
||||
}
|
||||
// c.getPacketDispatcher().sendSound(Sound.DUEL_WON, 100, 0);
|
||||
player.duelStatus = 6;
|
||||
if (player.isSkulled) {
|
||||
player.isSkulled = false;
|
||||
player.skullTimer = 0;
|
||||
player.headIconPk = -1;
|
||||
player.getPlayerAssistant().requestUpdates();
|
||||
}
|
||||
player.getPlayerAssistant().refreshSkill(3);
|
||||
duelRewardInterface();
|
||||
player.getPlayerAssistant().showInterface(6733);
|
||||
player.getActionSender().sendMessage("You have won the duel!");
|
||||
if (player.getPlayerAssistant().isPlayer()) {
|
||||
GameLogger.writeLog(player.playerName, "duelingkiller", player.playerName + " killed " + opponent.playerName + " in the duel arena.");
|
||||
}
|
||||
player.getPlayerAssistant().movePlayer(Constants.DUELING_RESPAWN_X + Misc.random(5), Constants.DUELING_RESPAWN_Y + Misc.random(5), 0);
|
||||
player.getPlayerAssistant().requestUpdates();
|
||||
player.getActionSender().showOption(3, 0, "Challenge", 3);
|
||||
player.getActionSender().createPlayerHints(10, -1);
|
||||
player.duelSpaceReq = 0;
|
||||
player.openDuel = false;
|
||||
opponent.openDuel = false;
|
||||
player.duelingWith = 0;
|
||||
player.getCombatAssistant().resetPlayerAttack();
|
||||
player.duelRequested = false;
|
||||
PlayerSave.saveGame(player);
|
||||
if (opponent != null) {
|
||||
PlayerSave.saveGame(opponent);
|
||||
}
|
||||
}
|
||||
|
||||
public void duelRewardInterface() {
|
||||
synchronized (player) {
|
||||
player.getOutStream().createFrameVarSizeWord(53);
|
||||
player.getOutStream().writeWord(6822);
|
||||
player.getOutStream().writeWord(otherStakedItems.toArray().length);
|
||||
for (GameItem item : otherStakedItems) {
|
||||
if (item.amount > 254) {
|
||||
player.getOutStream().writeByte(255);
|
||||
player.getOutStream().writeDWord_v2(item.amount);
|
||||
} else {
|
||||
player.getOutStream().writeByte(item.amount);
|
||||
}
|
||||
if (item.id > Constants.ITEM_LIMIT || item.id < 0) {
|
||||
item.id = Constants.ITEM_LIMIT;
|
||||
}
|
||||
player.getOutStream().writeWordBigEndianA(item.id + 1);
|
||||
}
|
||||
player.getOutStream().endFrameVarSizeWord();
|
||||
player.flushOutStream();
|
||||
}
|
||||
}
|
||||
|
||||
public void claimStakedItems() {
|
||||
for (GameItem item : otherStakedItems) {
|
||||
if (item.id > 0 && item.amount > 0) {
|
||||
if (Item.itemStackable[item.id]) {
|
||||
if (!player.getItemAssistant().addItem(item.id, item.amount)) {
|
||||
Server.itemHandler.createGroundItem(player, item.id,
|
||||
player.getX(), player.getY(), item.amount, player.getId());
|
||||
}
|
||||
} else {
|
||||
int amount = item.amount;
|
||||
for (int a = 1; a <= amount; a++) {
|
||||
if (!player.getItemAssistant().addItem(item.id, 1)) {
|
||||
Server.itemHandler.createGroundItem(player, item.id,
|
||||
player.getX(), player.getY(), 1, player.getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (GameItem item : stakedItems) {
|
||||
if (item.id > 0 && item.amount > 0) {
|
||||
if (Item.itemStackable[item.id]) {
|
||||
if (!player.getItemAssistant().addItem(item.id, item.amount)) {
|
||||
Server.itemHandler.createGroundItem(player, item.id,
|
||||
player.getX(), player.getY(), item.amount, player.getId());
|
||||
}
|
||||
} else {
|
||||
int amount = item.amount;
|
||||
for (int a = 1; a <= amount; a++) {
|
||||
if (!player.getItemAssistant().addItem(item.id, 1)) {
|
||||
Server.itemHandler.createGroundItem(player, item.id,
|
||||
player.getX(), player.getY(), 1, player.getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
resetDuel();
|
||||
resetDuelItems();
|
||||
PlayerSave.saveGame(player);
|
||||
player.duelStatus = 0;
|
||||
}
|
||||
|
||||
public void declineDuel() {
|
||||
Client o = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if (!player.inDuelArena()) {
|
||||
player.getActionSender().sendMessage("You must be in the duel arena to do that.");
|
||||
return;
|
||||
}
|
||||
if (player.duelingArena()) {
|
||||
player.getActionSender().sendMessage("You can't do that in a duel!");
|
||||
return;
|
||||
}
|
||||
player.getPlayerAssistant().removeAllWindows();
|
||||
player.duelStatus = 0;
|
||||
player.openDuel = false;
|
||||
o.openDuel = false;
|
||||
player.duelingWith = 0;
|
||||
player.duelSpaceReq = 0;
|
||||
player.duelRequested = false;
|
||||
for (GameItem item : stakedItems) {
|
||||
if (item.amount < 1) {
|
||||
continue;
|
||||
}
|
||||
if (Item.itemStackable[item.id] || Item.itemIsNote[item.id]) {
|
||||
player.getItemAssistant().addItem(item.id, item.amount);
|
||||
} else {
|
||||
player.getItemAssistant().addItem(item.id, 1);
|
||||
}
|
||||
}
|
||||
stakedItems.clear();
|
||||
for (int i = 0; i < player.duelRule.length; i++) {
|
||||
player.duelRule[i] = false;
|
||||
}
|
||||
}
|
||||
|
||||
public void checkDuelWalk() {
|
||||
Client o = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if (player.duelStatus == 5 && o.duelStatus == 5 && o.duelingArena() && !player.duelingArena()) {
|
||||
o.getDueling().duelVictory();
|
||||
player.getDueling().resetDuel();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
public void resetDuel() {
|
||||
//Client o = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if (player.isDead) {
|
||||
player.lostDuel = true;
|
||||
}
|
||||
player.getActionSender().showOption(3, 0, "Challenge", 3);
|
||||
player.headIconHints = 0;
|
||||
for (int i = 0; i < player.duelRule.length; i++) {
|
||||
player.duelRule[i] = false;
|
||||
}
|
||||
player.getActionSender().createPlayerHints(10, -1);
|
||||
player.duelStatus = 0;
|
||||
player.duelSpaceReq = 0;
|
||||
//player.openDuel = false;
|
||||
//o.openDuel = false;
|
||||
player.duelingWith = 0;
|
||||
player.getPlayerAssistant().requestUpdates();
|
||||
player.getCombatAssistant().resetPlayerAttack();
|
||||
player.duelRequested = false;
|
||||
}
|
||||
|
||||
public void resetDuelItems() {
|
||||
stakedItems.clear();
|
||||
otherStakedItems.clear();
|
||||
}
|
||||
|
||||
public void changeDuelStuff() {
|
||||
Client o = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if (o == null) {
|
||||
return;
|
||||
}
|
||||
o.duelStatus = 1;
|
||||
player.duelStatus = 1;
|
||||
o.getPlayerAssistant().sendFrame126("", 6684);
|
||||
player.getPlayerAssistant().sendFrame126("", 6684);
|
||||
}
|
||||
|
||||
public void selectRule(int i) { // rules
|
||||
Client o = (Client) PlayerHandler.players[player.duelingWith];
|
||||
if (!player.inDuelArena()) {
|
||||
player.getActionSender().sendMessage("You must be in the duel arena to change your rules.");
|
||||
return;
|
||||
}
|
||||
if (player.duelingArena()) {
|
||||
player.getActionSender().sendMessage("You can't do that in a duel!");
|
||||
return;
|
||||
}
|
||||
if (o == null) {
|
||||
return;
|
||||
}
|
||||
changeDuelStuff();
|
||||
o.duelSlot = player.duelSlot;
|
||||
if (i >= 11 && player.duelSlot > -1) {
|
||||
if (player.playerEquipment[player.duelSlot] > 0) {
|
||||
if (!player.duelRule[i]) {
|
||||
player.duelSpaceReq++;
|
||||
} else {
|
||||
player.duelSpaceReq--;
|
||||
}
|
||||
}
|
||||
if (o.playerEquipment[o.duelSlot] > 0) {
|
||||
if (!o.duelRule[i]) {
|
||||
o.duelSpaceReq++;
|
||||
} else {
|
||||
o.duelSpaceReq--;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (i == 16 && (player.getItemAssistant().is2handed(ItemAssistant.getItemName(player.playerEquipment[player.playerWeapon]).toLowerCase(), player.playerEquipment[player.playerWeapon])
|
||||
&& player.getItemAssistant().freeSlots() == 0) || (o.getItemAssistant().is2handed(ItemAssistant.getItemName(player.playerEquipment[player.playerWeapon]).toLowerCase(), player.playerEquipment[player.playerWeapon])
|
||||
&& o.getItemAssistant().freeSlots() == 0)) {
|
||||
player.getActionSender().sendMessage("You or your opponent don't have the required space to set this rule.");
|
||||
return;
|
||||
}
|
||||
|
||||
if (i >= 11) {
|
||||
if (player.getItemAssistant().freeSlots() < player.duelSpaceReq
|
||||
|| o.getItemAssistant().freeSlots() < o.duelSpaceReq) {
|
||||
player.getActionSender()
|
||||
.sendMessage(
|
||||
"You or your opponent don't have the required space to set this rule.");
|
||||
if (player.playerEquipment[player.duelSlot] > 0) {
|
||||
player.duelSpaceReq--;
|
||||
}
|
||||
if (o.playerEquipment[o.duelSlot] > 0) {
|
||||
o.duelSpaceReq--;
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (!player.duelRule[i]) {
|
||||
player.duelRule[i] = true;
|
||||
player.duelOption += player.DUEL_RULE_ID[i];
|
||||
} else {
|
||||
player.duelRule[i] = false;
|
||||
player.duelOption -= player.DUEL_RULE_ID[i];
|
||||
}
|
||||
|
||||
player.getPlayerAssistant().sendFrame87(286, player.duelOption);
|
||||
o.duelOption = player.duelOption;
|
||||
o.duelRule[i] = player.duelRule[i];
|
||||
o.getPlayerAssistant().sendFrame87(286, o.duelOption);
|
||||
|
||||
if (player.duelRule[8]) {
|
||||
if (player.duelRule[1]) {
|
||||
player.duelTeleX = 3366 + Misc.random(12);
|
||||
o.duelTeleX = player.duelTeleX - 1;
|
||||
player.duelTeleY = 3246 + Misc.random(6);
|
||||
o.duelTeleY = player.duelTeleY;
|
||||
}
|
||||
} else {
|
||||
if (player.duelRule[1]) {
|
||||
player.duelTeleX = 3335 + Misc.random(12);
|
||||
o.duelTeleX = player.duelTeleX - 1;
|
||||
player.duelTeleY = 3246 + Misc.random(6);
|
||||
o.duelTeleY = player.duelTeleY;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,392 @@
|
||||
package redone.game.content.minigames;
|
||||
|
||||
import redone.Server;
|
||||
import redone.event.CycleEvent;
|
||||
import redone.event.CycleEventContainer;
|
||||
import redone.event.CycleEventHandler;
|
||||
import redone.game.npcs.Npc;
|
||||
import redone.game.npcs.NpcHandler;
|
||||
import redone.game.players.Client;
|
||||
import redone.game.players.PlayerHandler;
|
||||
import redone.util.Misc;
|
||||
|
||||
public class FightCaves {
|
||||
|
||||
public static final int TZ_KIH = 2627, TZ_KEK_SPAWN = 2738, TZ_KEK = 2630,
|
||||
TOK_XIL = 2631, YT_MEJKOT = 2741, KET_ZEK = 2743, TZTOK_JAD = 2745, YT_HURKOT = 2746;
|
||||
|
||||
/**
|
||||
* Holds the data for the 63 waves fight cave.
|
||||
*/
|
||||
private final int[][] WAVES = { { TZ_KIH }, { TZ_KIH, TZ_KIH }, { TZ_KEK },
|
||||
{ TZ_KEK, TZ_KIH }, { TZ_KEK, TZ_KIH, TZ_KIH }, { TZ_KEK, TZ_KEK },
|
||||
{ TOK_XIL }, { TOK_XIL, TZ_KIH }, { TOK_XIL, TZ_KIH, TZ_KIH },
|
||||
{ TOK_XIL, TZ_KEK }, { TOK_XIL, TZ_KEK, TZ_KIH },
|
||||
{ TOK_XIL, TZ_KEK, TZ_KIH, TZ_KIH }, { TOK_XIL, TZ_KEK, TZ_KEK },
|
||||
{ TOK_XIL, TOK_XIL }, { YT_MEJKOT }, { YT_MEJKOT, TZ_KIH },
|
||||
{ YT_MEJKOT, TZ_KIH, TZ_KIH }, { YT_MEJKOT, TZ_KEK },
|
||||
{ YT_MEJKOT, TZ_KEK, TZ_KIH },
|
||||
{ YT_MEJKOT, TZ_KEK, TZ_KIH, TZ_KIH },
|
||||
{ YT_MEJKOT, TZ_KEK, TZ_KEK }, { YT_MEJKOT, TOK_XIL },
|
||||
{ YT_MEJKOT, TOK_XIL, TZ_KIH },
|
||||
{ YT_MEJKOT, TOK_XIL, TZ_KIH, TZ_KIH },
|
||||
{ YT_MEJKOT, TOK_XIL, TZ_KEK },
|
||||
{ YT_MEJKOT, TOK_XIL, TZ_KEK, TZ_KIH },
|
||||
{ YT_MEJKOT, TOK_XIL, TZ_KEK, TZ_KIH, TZ_KIH },
|
||||
{ YT_MEJKOT, TOK_XIL, TZ_KEK, TZ_KEK },
|
||||
{ YT_MEJKOT, TOK_XIL, TOK_XIL }, { YT_MEJKOT, YT_MEJKOT },
|
||||
{ KET_ZEK }, { KET_ZEK, TZ_KIH }, { KET_ZEK, TZ_KIH, TZ_KIH },
|
||||
{ KET_ZEK, TZ_KEK }, { KET_ZEK, TZ_KEK, TZ_KIH },
|
||||
{ KET_ZEK, TZ_KEK, TZ_KIH, TZ_KIH }, { KET_ZEK, TZ_KEK, TZ_KEK },
|
||||
{ KET_ZEK, TOK_XIL }, { KET_ZEK, TOK_XIL, TZ_KIH },
|
||||
{ KET_ZEK, TOK_XIL, TZ_KIH, TZ_KIH }, { KET_ZEK, TOK_XIL, TZ_KEK },
|
||||
{ KET_ZEK, TOK_XIL, TZ_KEK, TZ_KIH },
|
||||
{ KET_ZEK, TOK_XIL, TZ_KEK, TZ_KIH, TZ_KIH },
|
||||
{ KET_ZEK, TOK_XIL, TZ_KEK, TZ_KEK },
|
||||
{ KET_ZEK, TOK_XIL, TOK_XIL }, { KET_ZEK, YT_MEJKOT },
|
||||
{ KET_ZEK, YT_MEJKOT, TZ_KIH },
|
||||
{ KET_ZEK, YT_MEJKOT, TZ_KIH, TZ_KIH },
|
||||
{ KET_ZEK, YT_MEJKOT, TZ_KEK },
|
||||
{ KET_ZEK, YT_MEJKOT, TZ_KEK, TZ_KIH },
|
||||
{ KET_ZEK, YT_MEJKOT, TZ_KEK, TZ_KIH, TZ_KIH },
|
||||
{ KET_ZEK, YT_MEJKOT, TZ_KEK, TZ_KEK },
|
||||
{ KET_ZEK, YT_MEJKOT, TOK_XIL },
|
||||
{ KET_ZEK, YT_MEJKOT, TOK_XIL, TZ_KIH },
|
||||
{ KET_ZEK, YT_MEJKOT, TOK_XIL, TZ_KIH, TZ_KIH },
|
||||
{ KET_ZEK, YT_MEJKOT, TOK_XIL, TZ_KEK },
|
||||
{ KET_ZEK, YT_MEJKOT, TOK_XIL, TZ_KEK, TZ_KIH },
|
||||
{ KET_ZEK, YT_MEJKOT, TOK_XIL, TZ_KEK, TZ_KIH, TZ_KIH },
|
||||
{ KET_ZEK, YT_MEJKOT, TOK_XIL, TZ_KEK, TZ_KEK },
|
||||
{ KET_ZEK, YT_MEJKOT, TOK_XIL, TOK_XIL },
|
||||
{ KET_ZEK, YT_MEJKOT, YT_MEJKOT }, { KET_ZEK, KET_ZEK },
|
||||
{ TZTOK_JAD } };
|
||||
|
||||
private static final int[][] JAD_SPAWNS = {{2400, 5090},{2419, 5080}};
|
||||
private static final int[][] HEALER_COORDS = {{2390, 5101}, {2391, 5077}, {2411, 5084}, {2398, 5091}};
|
||||
private final static int[][] COORDINATES = {{2403, 5094}, {2390, 5096}, {2392, 5077}, {2408, 5080}, {2413, 5108}, {2381, 5106}, {2379, 5072}, {2420, 5082}};
|
||||
|
||||
/**
|
||||
* Handles spawning the next fightcave wave.
|
||||
*
|
||||
* @param player
|
||||
* The player.
|
||||
*/
|
||||
public void spawnNextWave(Client player) {
|
||||
if (player != null) {
|
||||
if (player.waveId >= WAVES.length) {
|
||||
player.waveId = 0;
|
||||
return;
|
||||
}
|
||||
if (player.waveId < 0) {
|
||||
player.waveId = 0;
|
||||
return;
|
||||
}
|
||||
int npcAmount = WAVES[player.waveId].length;
|
||||
int wave = player.waveId +1;
|
||||
if (player.waveId < 62 && player.waveId > -1) {
|
||||
for (int j = 0; j < npcAmount; j++) {
|
||||
int npc = WAVES[player.waveId][j];
|
||||
int X = COORDINATES[j][0];
|
||||
int Y = COORDINATES[j][1];
|
||||
int H = player.heightLevel;
|
||||
int hp = getHp(npc);
|
||||
int max = getMax(npc);
|
||||
int atk = getAtk(npc);
|
||||
int def = getDef(npc);
|
||||
NpcHandler.spawnNpc(player, npc, X, Y, H, 0, hp, max, atk, def, true, false);
|
||||
}
|
||||
player.getActionSender().sendMessage("You are now on wave @red@" + wave + "@bla@.");
|
||||
} else if (player.waveId == 62) {
|
||||
player.getDialogueHandler().sendDialogues(102, 2617);
|
||||
int a = Misc.random(1);
|
||||
int npc = WAVES[62][0];
|
||||
int X = JAD_SPAWNS[a][0];
|
||||
int Y = JAD_SPAWNS[a][1];
|
||||
int H = player.heightLevel;
|
||||
int hp = getHp(npc);
|
||||
int max = getMax(npc);
|
||||
int atk = getAtk(npc);
|
||||
int def = getDef(npc);
|
||||
NpcHandler.spawnNpc(player, npc, X, Y, H, 0, hp, max, atk, def, true, false);
|
||||
player.getActionSender().sendMessage("You are now on wave @red@63@bla@.");
|
||||
}
|
||||
player.tzhaarToKill = npcAmount;
|
||||
player.tzhaarKilled = 0;
|
||||
}
|
||||
}
|
||||
|
||||
public static void ytMejKotEffect(Client player, int i) {
|
||||
if(NpcHandler.npcs[i].npcType == YT_MEJKOT) {
|
||||
if (NpcHandler.npcs[i].hitsToHeal < 2) {
|
||||
NpcHandler.npcs[i].hitsToHeal += 1;
|
||||
if (NpcHandler.npcs[i].hitsToHeal == 2) {
|
||||
NpcHandler.npcs[i].hitsToHeal = 0;
|
||||
NpcHandler.npcs[i].gfx0(444);
|
||||
NpcHandler.npcs[i].startAnimation(2639, i);
|
||||
NpcHandler.npcs[i].HP += 1+Misc.random(7);
|
||||
if (NpcHandler.npcs[i].HP > getHp(YT_MEJKOT))
|
||||
NpcHandler.npcs[i].HP = getHp(YT_MEJKOT);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void spawnHealers(Client player, int i, int amount) {
|
||||
if (player.spawnedHealers < 4) {
|
||||
int hp = getHp(YT_HURKOT);
|
||||
int max = getMax(YT_HURKOT);
|
||||
int atk = getAtk(YT_HURKOT);
|
||||
int def = getDef(YT_HURKOT);
|
||||
for (int i1 = 0; i1 < amount; i1++) {
|
||||
NpcHandler.spawnNpc(player, YT_HURKOT, HEALER_COORDS[i1][0], HEALER_COORDS[i1][1], player.heightLevel, 0, hp, max, atk, def, false, false);
|
||||
}
|
||||
player.spawnedHealers = amount;
|
||||
player.canHealersRespawn = false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles the correct tz-kih effect; prayer is drained by the formula:
|
||||
* drain = damage + 1
|
||||
*
|
||||
* @param player
|
||||
* The player
|
||||
* @param i
|
||||
* The npcId
|
||||
* @param damage
|
||||
* What the npchit
|
||||
*/
|
||||
public static void tzKihEffect(Client player, int i, int damage) {
|
||||
if (NpcHandler.npcs[i].npcType == TZ_KIH) {
|
||||
if (player != null) {
|
||||
if (player.playerLevel[5] > 0) {
|
||||
player.playerLevel[5] -= 1 + damage;
|
||||
player.getPlayerAssistant().refreshSkill(5);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void tzKekEffect(Client player, int i) {
|
||||
if (NpcHandler.npcs[i].npcType == TZ_KEK) {
|
||||
|
||||
int x = NpcHandler.npcs[i].absX + 2;
|
||||
int y = NpcHandler.npcs[i].absY + 2;
|
||||
int x1 = NpcHandler.npcs[i].absX - 2;
|
||||
int y1 = NpcHandler.npcs[i].absY - 2;
|
||||
|
||||
int hp = getHp(TZ_KEK_SPAWN);
|
||||
int max = getMax(TZ_KEK_SPAWN);
|
||||
int atk = getAtk(TZ_KEK_SPAWN);
|
||||
int def = getDef(TZ_KEK_SPAWN);
|
||||
|
||||
if (player != null) {
|
||||
if (player.tzKekTimer == 0) {
|
||||
if (NpcHandler.npcs[i].isDead) {
|
||||
NpcHandler.spawnNpc(player, TZ_KEK_SPAWN, x, y,
|
||||
player.heightLevel, 0, hp, max, atk, def, true,
|
||||
false);
|
||||
NpcHandler.spawnNpc(player, TZ_KEK_SPAWN, x1, y1,
|
||||
player.heightLevel, 0, hp, max, atk, def, true,
|
||||
false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static int getHp(int npc) {
|
||||
switch (npc) {
|
||||
case TZ_KIH:
|
||||
case TZ_KEK_SPAWN:
|
||||
return 10;
|
||||
case TZ_KEK:
|
||||
return 20;
|
||||
case TOK_XIL:
|
||||
return 40;
|
||||
case YT_MEJKOT:
|
||||
return 80;
|
||||
case KET_ZEK:
|
||||
return 150;
|
||||
case YT_HURKOT:
|
||||
return 80;
|
||||
case TZTOK_JAD:
|
||||
return 250;
|
||||
}
|
||||
return 100;
|
||||
}
|
||||
|
||||
public static int getMax(int npc) {
|
||||
switch (npc) {
|
||||
case TZ_KIH:
|
||||
case TZ_KEK_SPAWN:
|
||||
return 4;
|
||||
case TZ_KEK:
|
||||
return 7;
|
||||
case TOK_XIL:
|
||||
return 13;
|
||||
case YT_MEJKOT:
|
||||
return 28;
|
||||
case KET_ZEK:
|
||||
return 54;
|
||||
case TZTOK_JAD:
|
||||
return 97;
|
||||
case YT_HURKOT:
|
||||
return 16;
|
||||
}
|
||||
return 5;
|
||||
}
|
||||
|
||||
public static int getAtk(int npc) {
|
||||
switch (npc) {
|
||||
case TZ_KIH:
|
||||
case TZ_KEK_SPAWN:
|
||||
return 30;
|
||||
case TZ_KEK:
|
||||
return 50;
|
||||
case TOK_XIL:
|
||||
return 100;
|
||||
case YT_MEJKOT:
|
||||
return 150;
|
||||
case KET_ZEK:
|
||||
return 450;
|
||||
case TZTOK_JAD:
|
||||
return 650;
|
||||
case YT_HURKOT:
|
||||
return 120;
|
||||
}
|
||||
return 100;
|
||||
}
|
||||
|
||||
public static int getDef(int npc) {
|
||||
switch (npc) {
|
||||
case TZ_KIH:
|
||||
case TZ_KEK_SPAWN:
|
||||
return 30;
|
||||
case TZ_KEK:
|
||||
return 50;
|
||||
case TOK_XIL:
|
||||
return 100;
|
||||
case YT_MEJKOT:
|
||||
return 150;
|
||||
case KET_ZEK:
|
||||
return 300;
|
||||
case TZTOK_JAD:
|
||||
return 500;
|
||||
case YT_HURKOT:
|
||||
return 125;
|
||||
}
|
||||
return 100;
|
||||
}
|
||||
|
||||
private static void killedTzhaar(int i) {
|
||||
final Client c2 = (Client) PlayerHandler.players[NpcHandler.npcs[i].spawnedBy];
|
||||
c2.tzhaarKilled++;
|
||||
if (c2.tzhaarKilled == c2.tzhaarToKill) {
|
||||
c2.waveId++;
|
||||
CycleEventHandler.getSingleton().addEvent(c2, new CycleEvent() {
|
||||
@Override
|
||||
public void execute(CycleEventContainer container) {
|
||||
if (c2 != null) {
|
||||
Server.fightCaves.spawnNextWave(c2);
|
||||
}
|
||||
container.stop();
|
||||
}
|
||||
@Override
|
||||
public void stop() {
|
||||
|
||||
}
|
||||
}, 15);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
public static void handleJadDeath(int i) {
|
||||
Client c = (Client) PlayerHandler.players[NpcHandler.npcs[i].spawnedBy];
|
||||
if (c.inFightCaves()) {
|
||||
c.getItemAssistant().addItem(6570, 1);
|
||||
c.getItemAssistant().addItem(6529, 8032);
|
||||
c.getDialogueHandler().sendDialogues(103, 2617);
|
||||
c.getActionSender().sendMessage("You were victorious!");
|
||||
c.getPlayerAssistant().resetTzhaar();
|
||||
c.killedJad = true;
|
||||
c.waveId = 300;
|
||||
c.setSpecialTarget(null);
|
||||
} else {
|
||||
c.getActionSender().sendMessage("You must be in the fight caves to do this.");
|
||||
}
|
||||
}
|
||||
|
||||
public static void healJad(Client player, int i) {
|
||||
if (NpcHandler.npcs[i].npcType == YT_HURKOT && !NpcHandler.npcs[i].isDead) {
|
||||
if (player.getSpecialTarget() != null) {
|
||||
if (player.getSpecialTarget().npcType == TZTOK_JAD) {
|
||||
Npc jad = player.getSpecialTarget();
|
||||
NpcHandler.npcs[i].gfx0(444);
|
||||
NpcHandler.npcs[i].startAnimation(2639, i);
|
||||
jad.HP += 1+Misc.random(8);
|
||||
if (jad.HP >= getHp(TZTOK_JAD)) {
|
||||
jad.HP = getHp(TZTOK_JAD);
|
||||
if (player.spawnedHealers < 4)
|
||||
spawnHealers(player, i, 4-player.spawnedHealers);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if a tzhaar npc has been killed, if so then it checks if it needs
|
||||
* to do the tz-kek effect. If tzKek spawn has been killed twice or didn't
|
||||
* need to be killed it calls killedTzhaar.
|
||||
*
|
||||
* @param i
|
||||
* The npc.
|
||||
*/
|
||||
public static void tzhaarDeathHandler(int i) {
|
||||
if (isFightCaveNpc(i) && NpcHandler.npcs[i].npcType != FightCaves.TZ_KEK && NpcHandler.npcs[i].npcType != FightCaves.YT_HURKOT) {
|
||||
killedTzhaar(i);
|
||||
}
|
||||
if (NpcHandler.npcs[i].npcType == FightCaves.TZ_KEK_SPAWN) {
|
||||
int p = NpcHandler.npcs[i].killerId;
|
||||
if (PlayerHandler.players[p] != null) {
|
||||
Client c = (Client) PlayerHandler.players[p];
|
||||
c.tzKekSpawn += 1;
|
||||
if (c.tzKekSpawn == 2) {
|
||||
killedTzhaar(i);
|
||||
c.tzKekSpawn = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (NpcHandler.npcs[i].npcType == FightCaves.TZ_KEK) {
|
||||
int p = NpcHandler.npcs[i].killerId;
|
||||
if (PlayerHandler.players[p] != null) {
|
||||
Client c = (Client) PlayerHandler.players[p];
|
||||
FightCaves.tzKekEffect(c, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if something is a fight cave npc.
|
||||
*
|
||||
* @param i
|
||||
* The npc.
|
||||
* @return Whether or not it is a fight caves npc.
|
||||
*/
|
||||
public static boolean isFightCaveNpc(int i) {
|
||||
switch (NpcHandler.npcs[i].npcType) {
|
||||
case FightCaves.TZ_KIH:
|
||||
case FightCaves.TZ_KEK:
|
||||
case FightCaves.TZ_KEK_SPAWN:
|
||||
case FightCaves.TOK_XIL:
|
||||
case FightCaves.YT_MEJKOT:
|
||||
case FightCaves.KET_ZEK:
|
||||
case FightCaves.TZTOK_JAD:
|
||||
case FightCaves.YT_HURKOT:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,237 @@
|
||||
package redone.game.content.minigames;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import redone.game.players.Client;
|
||||
import redone.util.Misc;
|
||||
|
||||
/**
|
||||
* @author ArrowzFtw
|
||||
*/
|
||||
public class FightPits {
|
||||
|
||||
/**
|
||||
* @note States of minigames
|
||||
*/
|
||||
private static final String PLAYING = "PLAYING";
|
||||
private static final String WAITING = "WAITING";
|
||||
/**
|
||||
* @note Current fight pits champion
|
||||
*/
|
||||
private static String pitsChampion = "None";
|
||||
/**
|
||||
* @note Countdown for game to start
|
||||
*/
|
||||
private static int gameStartTimer = 80;
|
||||
/**
|
||||
* @note Elapsed Game start time
|
||||
*/
|
||||
private static int elapsedGameTime = 0;
|
||||
private static final int END_GAME_TIME = 400;
|
||||
/*
|
||||
* @note Game started or not?
|
||||
*/
|
||||
private static boolean gameStarted = false;
|
||||
/**
|
||||
* @note Stores player and State
|
||||
*/
|
||||
private static Map<Client, String> playerMap = Collections
|
||||
.synchronizedMap(new HashMap<Client, String>());
|
||||
|
||||
/**
|
||||
* @note Where to spawn when pits game starts
|
||||
*/
|
||||
private static final int MINIGAME_START_POINT_X = 2392;
|
||||
private static final int MINIGAME_START_POINT_Y = 5139;
|
||||
/**
|
||||
* @note Exit game area
|
||||
*/
|
||||
private static final int EXIT_GAME_X = 2399;
|
||||
private static final int EXIT_GAME_Y = 5169;
|
||||
/**
|
||||
* @note Exit waiting room
|
||||
*/
|
||||
public static final int EXIT_WAITING_X = 2399;
|
||||
public static final int EXIT_WAITING_Y = 5177;
|
||||
/**
|
||||
* @note Waiting room coordinates
|
||||
*/
|
||||
private static final int WAITING_ROOM_X = 2399;
|
||||
private static final int WAITING_ROOM_Y = 5175;
|
||||
|
||||
/**
|
||||
* @return HashMap Value
|
||||
*/
|
||||
public static String getState(Client c) {
|
||||
return playerMap.get(c);
|
||||
}
|
||||
|
||||
private static final int TOKKUL_ID = 6529;
|
||||
|
||||
/**
|
||||
* @note Adds player to waiting room.
|
||||
*/
|
||||
public static void addPlayer(Client c) {
|
||||
playerMap.put(c, WAITING);
|
||||
c.getPlayerAssistant().movePlayer(WAITING_ROOM_X, WAITING_ROOM_Y, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @note Starts the game and moves players to arena
|
||||
*/
|
||||
private static void enterGame(Client c) {
|
||||
playerMap.put(c, PLAYING);
|
||||
int teleportToX = MINIGAME_START_POINT_X + Misc.random(12);
|
||||
int teleportToY = MINIGAME_START_POINT_Y + Misc.random(12);
|
||||
c.getPlayerAssistant().movePlayer(teleportToX, teleportToY, 0);
|
||||
c.inPits = true;
|
||||
// c.getPA().showOption(3, 0, "Attack", 1);
|
||||
// c.getPA().showOption(3, 0, "Null", 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @note Removes player from pits if there in waiting or in game
|
||||
*/
|
||||
public static void removePlayer(Client c, boolean forceRemove) {
|
||||
c.inPits = false;
|
||||
if (forceRemove) {
|
||||
c.getPlayerAssistant()
|
||||
.movePlayer(EXIT_WAITING_X, EXIT_WAITING_Y, 0);
|
||||
playerMap.remove(c);
|
||||
return;
|
||||
}
|
||||
String state = playerMap.get(c);
|
||||
if (state == null) {
|
||||
c.getPlayerAssistant()
|
||||
.movePlayer(EXIT_WAITING_X, EXIT_WAITING_Y, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
if (state.equals(PLAYING)) {
|
||||
if (getListCount(PLAYING) - 1 == 0 && !forceRemove) {
|
||||
pitsChampion = c.playerName;
|
||||
c.headIcon = 21;
|
||||
c.updateRequired = true;
|
||||
c.getItemAssistant()
|
||||
.addItem(TOKKUL_ID, 1500 + Misc.random(500));
|
||||
|
||||
}
|
||||
c.getPlayerAssistant().movePlayer(EXIT_GAME_X, EXIT_GAME_Y, 0);
|
||||
} else if (state.equals(WAITING)) {
|
||||
c.getPlayerAssistant()
|
||||
.movePlayer(EXIT_WAITING_X, EXIT_WAITING_Y, 0);
|
||||
c.getPlayerAssistant().walkableInterface(-1);
|
||||
}
|
||||
playerMap.remove(c);
|
||||
|
||||
if (state.equals(PLAYING)) {
|
||||
if (!forceRemove) {
|
||||
playerMap.put(c, WAITING);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @return Players playing fight pits
|
||||
*/
|
||||
public static int getListCount(String state) {
|
||||
int count = 0;
|
||||
for (String s : playerMap.values()) {
|
||||
if (state == s) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/**
|
||||
* @note Updates players
|
||||
*/
|
||||
private static void update() {
|
||||
for (Client c : playerMap.keySet()) {
|
||||
String status = playerMap.get(c);
|
||||
@SuppressWarnings("unused")
|
||||
boolean updated = status == WAITING ? updateWaitingRoom(c)
|
||||
: updateGame(c);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @note Updates waiting room interfaces etc.
|
||||
*/
|
||||
public static boolean updateWaitingRoom(Client c) {
|
||||
c.getPlayerAssistant().sendFrame126(
|
||||
"Next Game Begins In : " + gameStartTimer, 2805);
|
||||
c.getPlayerAssistant().sendFrame126(
|
||||
"Champion: JalYt-Ket-" + pitsChampion, 2806);
|
||||
c.getPlayerAssistant().sendConfig(560, 1);
|
||||
c.getPlayerAssistant().walkableInterface(2804);
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @note Updates players in game interfaces etc.
|
||||
*/
|
||||
public static boolean updateGame(Client c) {
|
||||
c.getPlayerAssistant().sendFrame126(
|
||||
"Foes Remaining: " + getListCount(PLAYING), 2805);
|
||||
c.getPlayerAssistant().sendFrame126(
|
||||
"Champion: JalYt-Ket-" + pitsChampion, 2806);
|
||||
c.getPlayerAssistant().sendConfig(560, 1);
|
||||
c.getPlayerAssistant().walkableInterface(2804);
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @note Handles death and respawn rubbish.
|
||||
*/
|
||||
public static void handleDeath(Client c) {
|
||||
removePlayer(c, true);
|
||||
}
|
||||
|
||||
/*
|
||||
* @process 600ms Tick
|
||||
*/
|
||||
public static void process() {
|
||||
update();
|
||||
if (!gameStarted) {
|
||||
if (gameStartTimer > 0) {
|
||||
gameStartTimer--;
|
||||
} else if (gameStartTimer == 0) {
|
||||
if (getListCount(WAITING) > 4) {
|
||||
beginGame();
|
||||
}
|
||||
gameStartTimer = 80;
|
||||
}
|
||||
}
|
||||
if (gameStarted) {
|
||||
elapsedGameTime++;
|
||||
if (elapsedGameTime == END_GAME_TIME) {
|
||||
endGame();
|
||||
elapsedGameTime = 0;
|
||||
gameStarted = false;
|
||||
gameStartTimer = 80;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @note Starts game for the players in waiting room
|
||||
*/
|
||||
private static void beginGame() {
|
||||
for (Client c : playerMap.keySet()) {
|
||||
enterGame(c);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @note Ends game and returns player to their normal spot.
|
||||
*/
|
||||
private static void endGame() {
|
||||
for (Client c : playerMap.keySet()) {
|
||||
removePlayer(c, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,267 @@
|
||||
/*
|
||||
* To change this template, choose Tools | Templates and open the template in
|
||||
* the editor.
|
||||
*/
|
||||
|
||||
package redone.game.content.minigames;
|
||||
|
||||
import redone.game.items.ItemAssistant;
|
||||
import redone.game.players.Client;
|
||||
|
||||
/**
|
||||
* @author D
|
||||
*/
|
||||
public class MageArena {
|
||||
|
||||
private final Client c;
|
||||
|
||||
public MageArena(Client c) {
|
||||
this.c = c;
|
||||
}
|
||||
|
||||
private final int telePoints = 0;
|
||||
private final int enchantPoints = 0;
|
||||
private final int gravePoints = 0;
|
||||
private final int alchPoints = 0;
|
||||
|
||||
private final int[] shopItems = { 6908, 6910, 6912, 6914, 6916, 6918, 6920,
|
||||
6922, 6924, 6889, 6926, 1391, 4695, 4696, 4698, 4697, 4694, 4699,
|
||||
564, 561, 560, 563, 565, 6891 };
|
||||
|
||||
private final String[] interfaceText = { "Magic Training Arena Shop",
|
||||
"Telekinetic Pizazz Points", "Enchantment Pizazz Points",
|
||||
"Graveyard Pizazz Points", "Alchemist Pizazz Points" };
|
||||
|
||||
public void openShop() {
|
||||
|
||||
for (int i = 0; i < shopItems.length; i++) {
|
||||
c.getPlayerAssistant().sendFrame34(15948, shopItems[i], i, 100);
|
||||
}
|
||||
|
||||
for (int i = 15950; i < interfaceText.length; i++) {
|
||||
c.getPlayerAssistant().sendFrame126(interfaceText[i - 15950], i);
|
||||
}
|
||||
|
||||
c.getPlayerAssistant().sendFrame126(Integer.toString(telePoints), 15955);
|
||||
c.getPlayerAssistant().sendFrame126(Integer.toString(enchantPoints),
|
||||
15956);
|
||||
c.getPlayerAssistant().sendFrame126(Integer.toString(gravePoints), 15957);
|
||||
c.getPlayerAssistant().sendFrame126(Integer.toString(alchPoints), 15958);
|
||||
c.getPlayerAssistant().showInterface(15944);
|
||||
}
|
||||
|
||||
public int getTelVal(int itemId) {
|
||||
|
||||
switch (itemId) {
|
||||
case 6922:
|
||||
return 175;
|
||||
case 6918:
|
||||
return 350;
|
||||
case 6916:
|
||||
return 400;
|
||||
case 6924:
|
||||
return 450;
|
||||
case 6920:
|
||||
return 120;
|
||||
case 1391:
|
||||
return 1;
|
||||
case 6908:
|
||||
return 30;
|
||||
case 6910:
|
||||
return 60;
|
||||
case 6912:
|
||||
return 60;
|
||||
case 6914:
|
||||
return 150;
|
||||
case 6889:
|
||||
return 500;
|
||||
case 6926:
|
||||
return 200;
|
||||
|
||||
case 4695:
|
||||
case 4694:
|
||||
case 4696:
|
||||
case 4697:
|
||||
case 4698:
|
||||
case 4699:
|
||||
return 1;
|
||||
|
||||
case 564:
|
||||
case 561:
|
||||
return 0;
|
||||
|
||||
case 560:
|
||||
case 563:
|
||||
case 565:
|
||||
return 2;
|
||||
|
||||
default:
|
||||
return 1;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
public int getAlchVal(int itemId) {
|
||||
|
||||
switch (itemId) {
|
||||
case 6922:
|
||||
return 225;
|
||||
case 6918:
|
||||
return 400;
|
||||
case 6916:
|
||||
return 450;
|
||||
case 6924:
|
||||
return 500;
|
||||
case 6920:
|
||||
return 120;
|
||||
case 1391:
|
||||
return 2;
|
||||
case 6908:
|
||||
return 30;
|
||||
case 6910:
|
||||
return 60;
|
||||
case 6912:
|
||||
return 200;
|
||||
case 6914:
|
||||
return 240;
|
||||
case 6889:
|
||||
return 550;
|
||||
case 6926:
|
||||
return 300;
|
||||
|
||||
case 4695:
|
||||
case 4694:
|
||||
case 4696:
|
||||
case 4697:
|
||||
case 4698:
|
||||
case 4699:
|
||||
return 1;
|
||||
|
||||
case 564:
|
||||
case 561:
|
||||
return 1;
|
||||
|
||||
case 560:
|
||||
case 563:
|
||||
case 565:
|
||||
return 2;
|
||||
|
||||
default:
|
||||
return 1;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
public int getEnchVal(int itemId) {
|
||||
|
||||
switch (itemId) {
|
||||
case 6922:
|
||||
return 1300;
|
||||
case 6918:
|
||||
return 3000;
|
||||
case 6916:
|
||||
return 4000;
|
||||
case 6924:
|
||||
return 5000;
|
||||
case 6920:
|
||||
return 1200;
|
||||
case 1391:
|
||||
return 20;
|
||||
case 6908:
|
||||
return 300;
|
||||
case 6910:
|
||||
return 600;
|
||||
case 6912:
|
||||
return 1500;
|
||||
case 6914:
|
||||
return 2400;
|
||||
case 6889:
|
||||
return 6000;
|
||||
case 6926:
|
||||
return 2000;
|
||||
|
||||
case 4695:
|
||||
case 4694:
|
||||
case 4696:
|
||||
case 4697:
|
||||
case 4698:
|
||||
case 4699:
|
||||
return 15;
|
||||
|
||||
case 564:
|
||||
case 561:
|
||||
return 5;
|
||||
|
||||
case 560:
|
||||
case 563:
|
||||
case 565:
|
||||
return 25;
|
||||
|
||||
default:
|
||||
return 1;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
public int getGraveValue(int itemId) {
|
||||
|
||||
switch (itemId) {
|
||||
case 6922:
|
||||
return 175;
|
||||
case 6918:
|
||||
return 350;
|
||||
case 6916:
|
||||
return 400;
|
||||
case 6924:
|
||||
return 450;
|
||||
case 6920:
|
||||
return 120;
|
||||
case 1391:
|
||||
return 2;
|
||||
case 6908:
|
||||
return 30;
|
||||
case 6910:
|
||||
return 60;
|
||||
case 6912:
|
||||
return 150;
|
||||
case 6914:
|
||||
return 240;
|
||||
case 6889:
|
||||
return 500;
|
||||
case 6926:
|
||||
return 200;
|
||||
|
||||
case 4695:
|
||||
case 4694:
|
||||
case 4696:
|
||||
case 4697:
|
||||
case 4698:
|
||||
case 4699:
|
||||
return 1;
|
||||
|
||||
case 564:
|
||||
case 561:
|
||||
return 1;
|
||||
|
||||
case 560:
|
||||
case 563:
|
||||
case 565:
|
||||
return 2;
|
||||
|
||||
default:
|
||||
return 1;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
public void sendMessage(int itemId) {
|
||||
c.getActionSender().sendMessage(
|
||||
ItemAssistant.getItemName(itemId) + " costs "
|
||||
+ getGraveValue(itemId) + " Graveyard points, "
|
||||
+ getAlchVal(itemId) + " Alchemy points,");
|
||||
c.getActionSender().sendMessage(
|
||||
"" + getEnchVal(itemId) + " Enchantment points, and "
|
||||
+ getTelVal(itemId) + " Telekinetic points.");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,450 @@
|
||||
package redone.game.content.minigames;
|
||||
|
||||
import java.util.HashMap;
|
||||
|
||||
import redone.Server;
|
||||
import redone.game.content.combat.prayer.PrayerDrain;
|
||||
import redone.game.npcs.Npc;
|
||||
import redone.game.npcs.NpcHandler;
|
||||
import redone.game.players.Client;
|
||||
import redone.util.Misc;
|
||||
|
||||
/**
|
||||
* @author Harlan Credits to Sanity
|
||||
*/
|
||||
|
||||
public class PestControl {
|
||||
|
||||
/**
|
||||
* /** how long before were put into the game from lobby
|
||||
*/
|
||||
private static final int WAIT_TIMER = 60;
|
||||
/**
|
||||
* How many players we need to start a game
|
||||
*/
|
||||
private final static int PLAYERS_REQUIRED = 1;
|
||||
/**
|
||||
* Hashmap for the players in lobby
|
||||
*/
|
||||
public static HashMap<Client, Integer> waitingBoat = new HashMap<Client, Integer>();
|
||||
private static HashMap<Client, Integer> gamePlayers = new HashMap<Client, Integer>();
|
||||
|
||||
private static int gameTimer = -1;
|
||||
private static int waitTimer = 60;
|
||||
public static boolean gameStarted = false;
|
||||
private int properTimer = 0;
|
||||
public static int KNIGHTS_HEALTH = -1;
|
||||
|
||||
/**
|
||||
* Array used for storing the portals health
|
||||
*/
|
||||
public static int[] portalHealth = { 200, 200, 200, 200 };
|
||||
public static int[] portals = { 3777, 3778, 3779, 3780 };
|
||||
/**
|
||||
* array used for storing the npcs used in the minigame
|
||||
*
|
||||
* @order npcId, xSpawn, ySpawn, health
|
||||
*/
|
||||
|
||||
public int shifter = 3732 + Misc.random(9);
|
||||
public int brawler = 3772 + Misc.random(4);
|
||||
public int defiler = 3762 + Misc.random(9);
|
||||
public int ravager = 3742 + Misc.random(4);
|
||||
public int torcher = 3752 + Misc.random(7);
|
||||
public int splater = 3727 + Misc.random(4);
|
||||
|
||||
private final int[][] pcNPCData = { { 3777, 2628, 2591 }, // portal
|
||||
{ 3778, 2680, 2588 }, // portal
|
||||
{ 3779, 2669, 2570 }, // portal
|
||||
{ 3780, 2645, 2569 }, // portal
|
||||
{ 3782, 2656, 2592 }, // knight
|
||||
};
|
||||
|
||||
private final int[][] voidMonsterData = {
|
||||
{ shifter, 2660 + Misc.random(4), 2592 + Misc.random(4) },
|
||||
{ brawler, 2663 + Misc.random(4), 2575 + Misc.random(4) },
|
||||
{ defiler, 2656 + Misc.random(4), 2572 + Misc.random(4) },
|
||||
{ ravager, 2664 + Misc.random(4), 2574 + Misc.random(4) },
|
||||
{ torcher, 2656 + Misc.random(4), 2595 + Misc.random(4) },
|
||||
{ ravager, 2634 + Misc.random(4), 2596 + Misc.random(4) },
|
||||
{ brawler, 2638 + Misc.random(4), 2588 + Misc.random(4) },
|
||||
{ shifter, 2637 + Misc.random(4), 2598 + Misc.random(4) },
|
||||
{ ravager, 2677 + Misc.random(4), 2579 + Misc.random(4) },
|
||||
{ defiler, 2673 + Misc.random(4), 2584 + Misc.random(4) },
|
||||
{ defiler, 2673 + Misc.random(4), 2584 + Misc.random(4) },
|
||||
{ defiler, 2675 + Misc.random(4), 2591 + Misc.random(4) },
|
||||
{ splater, 2644 + Misc.random(4), 2575 + Misc.random(4) },
|
||||
{ splater, 2633 + Misc.random(4), 2595 + Misc.random(4) }};
|
||||
|
||||
public void process() {
|
||||
try {
|
||||
if (properTimer > 0) {
|
||||
properTimer--;
|
||||
return;
|
||||
} else {
|
||||
properTimer = 1;
|
||||
}
|
||||
waitBoat();
|
||||
if (waitTimer > 0) {
|
||||
waitTimer--;
|
||||
} else if (waitTimer == 0) {
|
||||
startGame();
|
||||
}
|
||||
if (KNIGHTS_HEALTH == 0) {
|
||||
endGame(false);
|
||||
}
|
||||
if (gameStarted && playersInGame() < 1) {
|
||||
endGame(false);
|
||||
}
|
||||
if (gameTimer > 0 && gameStarted) {
|
||||
gameTimer--;
|
||||
setGameInterface();
|
||||
if (allPortalsDead() || allPortalsDead3()) {
|
||||
endGame(true);
|
||||
}
|
||||
} else if (gameTimer <= 0 && gameStarted) {
|
||||
endGame(false);
|
||||
}
|
||||
} catch (RuntimeException e) {
|
||||
System.out.println("Failed to set process");
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use for removing a player from the pc game
|
||||
*
|
||||
* @param player
|
||||
* The Player.
|
||||
*/
|
||||
public static void removePlayerGame(Client player) {
|
||||
if (gamePlayers.containsKey(player)) {
|
||||
player.getPlayerAssistant().movePlayer(2657, 2639, 0);
|
||||
gamePlayers.remove(player);
|
||||
}
|
||||
}
|
||||
|
||||
private static void waitBoat() {
|
||||
for (final Client c : waitingBoat.keySet()) {
|
||||
if (c != null) {
|
||||
if (gameStarted && isInPcBoat(c)) {
|
||||
c.getActionSender().sendMessage("Next Departure: " + (waitTimer + gameTimer) / 60 + " minutes");
|
||||
} else {
|
||||
c.getActionSender().sendMessage("Next Departure: " + waitTimer + " seconds.");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void setGameInterface() {
|
||||
for (final Client player : gamePlayers.keySet()) {
|
||||
if (player != null) {
|
||||
if (gameTimer > 60) {
|
||||
player.getActionSender().sendMessage("Time remaining: " + gameTimer / 60 + " minutes");
|
||||
} else if (gameTimer < 60) {
|
||||
player.getActionSender().sendMessage("Time remaining: " + gameTimer + " seconds");
|
||||
}
|
||||
player.getActionSender().sendMessage("The knights current health is " + KNIGHTS_HEALTH + ".");
|
||||
player.getActionSender().sendMessage("Your current pc damage is " + player.pcDamage + ".");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* private void setBoatInterface() { try { for (Client c :
|
||||
* waitingBoat.keySet()) { if (c != null) { try { if (gameStarted) {
|
||||
* c.getPlayerAssistant().sendString("Next Departure: " + (waitTimer +
|
||||
* gameTimer)/60 + " minutes", 21120); } else {
|
||||
* c.getPlayerAssistant().sendString("Next Departure: " + waitTimer + "",
|
||||
* 21120); } c.getPlayerAssistant().sendString("Players Ready: " +
|
||||
* playersInBoat() + "", 21121); c.getPlayerAssistant().sendString("(Need "
|
||||
* + PLAYERS_REQUIRED + " to 25 players)", 21122);
|
||||
* c.getPlayerAssistant().sendString("Points: " + c.pcPoints + "", 21123);
|
||||
* switch (waitTimer) { case 60: c.getPacketDispatcher
|
||||
* ().sendMessage("Next game will start in: 60 seconds."); break; case 30:
|
||||
* c.
|
||||
* getPacketDispatcher().sendMessage("Next game will start in: 30 seconds."
|
||||
* ); break; } } catch (RuntimeException e) { // TODO Auto-generated catch
|
||||
* block e.printStackTrace(); } } } } catch (RuntimeException e) {
|
||||
* System.out.println("Failed to set interfaces"); e.printStackTrace(); } }
|
||||
*/
|
||||
|
||||
/*
|
||||
* private void setGameInterface() { for (Client player :
|
||||
* gamePlayers.keySet()) { if (player != null) { for (int i = 0; i <
|
||||
* portalHealth.length; i++) { if (portalHealth[i] > 0) {
|
||||
* player.getPlayerAssistant().sendString("" + portalHealth[i] + "", 21111 +
|
||||
* i); } else player.getPlayerAssistant().sendString("Dead", 21111 + i); }
|
||||
* player.getPlayerAssistant().sendString("" + KNIGHTS_HEALTH, 21115);
|
||||
* player.getPlayerAssistant().sendString("" + player.pcDamage, 21116); if
|
||||
* (gameTimer > 60) {
|
||||
* player.getPlayerAssistant().sendString("Time remaining: " +
|
||||
* (gameTimer/60) + " minutes", 21117); } else {
|
||||
* player.getPlayerAssistant().sendString("Time remaining: " + gameTimer +
|
||||
* " seconds", 21117); } } } }
|
||||
*/
|
||||
|
||||
/***
|
||||
* Moving players to arena if there's enough players
|
||||
*/
|
||||
private void startGame() {
|
||||
if (playersInBoat() < PLAYERS_REQUIRED) {
|
||||
waitTimer = WAIT_TIMER;
|
||||
return;
|
||||
}
|
||||
for (int i = 0; i < portalHealth.length; i++) {
|
||||
portalHealth[i] = 200;
|
||||
}
|
||||
gameStarted = true;
|
||||
gameTimer = 400;
|
||||
KNIGHTS_HEALTH = 250;
|
||||
waitTimer = -1;
|
||||
spawnNPC();
|
||||
setGameInterface();
|
||||
for (Client player : waitingBoat.keySet()) {
|
||||
int team = waitingBoat.get(player);
|
||||
if (player == null) {
|
||||
continue;
|
||||
}
|
||||
player.getPlayerAssistant().movePlayer(2656 + Misc.random3(3),
|
||||
2614 - Misc.random3(4), 0);
|
||||
player.getDialogueHandler().sendDialogues(599, 3790);
|
||||
player.getActionSender().sendMessage(
|
||||
"The Pest Control Game has begun!");
|
||||
gamePlayers.put(player, team);
|
||||
}
|
||||
|
||||
waitingBoat.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks how many players are in the waiting lobby
|
||||
*
|
||||
* @return players waiting
|
||||
*/
|
||||
private static int playersInBoat() {
|
||||
int players = 0;
|
||||
for (Client player : waitingBoat.keySet()) {
|
||||
if (player != null) {
|
||||
players++;
|
||||
}
|
||||
if (player == null) {
|
||||
players--;
|
||||
}
|
||||
}
|
||||
return players;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks how many players are in the game
|
||||
*
|
||||
* @return players in the game
|
||||
*/
|
||||
private int playersInGame() {
|
||||
int players = 0;
|
||||
for (Client player : gamePlayers.keySet()) {
|
||||
if (player != null) {
|
||||
players++;
|
||||
}
|
||||
if (player == null) {
|
||||
players--;
|
||||
}
|
||||
}
|
||||
return players;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ends the game
|
||||
*
|
||||
* @param won
|
||||
* Did you win?
|
||||
*/
|
||||
private void endGame(boolean won) {
|
||||
for (Client player : gamePlayers.keySet()) {
|
||||
if (player == null) {
|
||||
continue;
|
||||
}
|
||||
player.getPlayerAssistant().movePlayer(2657, 2639, 0);
|
||||
if (won && player.pcDamage > 50) {
|
||||
player.getDialogueHandler().sendDialogues(598, 3790);
|
||||
int POINT_REWARD = 4;
|
||||
player.getActionSender().sendMessage(
|
||||
"You have won the pest control game and have been awarded "
|
||||
+ POINT_REWARD + " Pest Control points.");
|
||||
player.pcPoints += POINT_REWARD;
|
||||
player.getItemAssistant().addItem(995, player.combatLevel * 10);
|
||||
} else if (won) {
|
||||
player.getDialogueHandler().sendDialogues(596, 3790);
|
||||
int POINT_REWARD2 = 2;
|
||||
player.pcPoints += POINT_REWARD2;
|
||||
player.getActionSender().sendMessage(
|
||||
"The void knights notice your lack of zeal. You only gain "
|
||||
+ POINT_REWARD2 + " points.");
|
||||
} else {
|
||||
player.getDialogueHandler().sendDialogues(597, 3790);
|
||||
player.getActionSender()
|
||||
.sendMessage(
|
||||
"You failed to kill all the portals in 3 minutes and have not been awarded points.");
|
||||
}
|
||||
}
|
||||
cleanUpPlayer();
|
||||
cleanUp();
|
||||
}
|
||||
|
||||
/**
|
||||
* Resets the game variables and map
|
||||
*/
|
||||
private void cleanUp() {
|
||||
gameTimer = -1;
|
||||
KNIGHTS_HEALTH = -1;
|
||||
waitTimer = WAIT_TIMER;
|
||||
gameStarted = false;
|
||||
gamePlayers.clear();
|
||||
/*
|
||||
* Removes the npcs from the game if any left over for whatever reason
|
||||
*/
|
||||
for (int[] aPcNPCData : pcNPCData) {
|
||||
for (int j = 0; j < NpcHandler.npcs.length; j++) {
|
||||
if (NpcHandler.npcs[j] != null) {
|
||||
if (NpcHandler.npcs[j].npcType == aPcNPCData[0]) {
|
||||
NpcHandler.npcs[j] = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int[] aPcNPCData : voidMonsterData) {
|
||||
for (int j = 0; j < NpcHandler.npcs.length; j++) {
|
||||
if (NpcHandler.npcs[j] != null) {
|
||||
if (NpcHandler.npcs[j].npcType == aPcNPCData[0]) {
|
||||
NpcHandler.npcs[j] = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleans the player of any damage, loss they may of received
|
||||
*/
|
||||
private void cleanUpPlayer() {
|
||||
for (Client player : gamePlayers.keySet()) {
|
||||
player.poisonDamage = 0;
|
||||
PrayerDrain.resetPrayers(player);
|
||||
for (int i = 0; i < 24; i++) {
|
||||
player.playerLevel[i] = player.getPlayerAssistant()
|
||||
.getLevelForXP(player.playerXP[i]);
|
||||
player.getPlayerAssistant().refreshSkill(i);
|
||||
}
|
||||
player.specAmount = 10;
|
||||
player.pcDamage = 0;
|
||||
player.getItemAssistant().addSpecialBar(
|
||||
player.playerEquipment[player.playerWeapon]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the portals are dead
|
||||
*
|
||||
* @return players dead
|
||||
*/
|
||||
private static boolean allPortalsDead() {
|
||||
int count = 0;
|
||||
for (int aPortalHealth : portalHealth) {
|
||||
if (aPortalHealth <= 0) {
|
||||
count++;
|
||||
// System.out.println("Portal Health++" + count);
|
||||
}
|
||||
}
|
||||
return count >= 4;
|
||||
}
|
||||
|
||||
public boolean allPortalsDead3() {
|
||||
int count = 0;
|
||||
for (Npc npc : NpcHandler.npcs) {
|
||||
if (npc != null) {
|
||||
if (npc.npcType > 3777 && npc.npcType < 3780) {
|
||||
if (npc.needRespawn) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return count >= 4;
|
||||
}
|
||||
|
||||
/**
|
||||
* Moves a player out of the waiting boat
|
||||
*
|
||||
* @param c
|
||||
* Client c
|
||||
*/
|
||||
public static void leaveWaitingBoat(Client c) {
|
||||
if (waitingBoat.containsKey(c)) {
|
||||
waitingBoat.remove(c);
|
||||
c.getPlayerAssistant().movePlayer(2657, 2639, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Moves a player into the hash and into the lobby
|
||||
*
|
||||
* @param player
|
||||
* The player
|
||||
*/
|
||||
public static void addToWaitRoom(Client player) {
|
||||
if (player != null && player.combatLevel > 39) {
|
||||
waitingBoat.put(player, 1);
|
||||
player.getActionSender().sendMessage(
|
||||
"You have joined the Pest Control boat.");
|
||||
player.getActionSender().sendMessage(
|
||||
"You currently have " + player.pcPoints
|
||||
+ " Pest Control Points.");
|
||||
player.getActionSender().sendMessage(
|
||||
"There are currently " + playersInBoat()
|
||||
+ " players ready in the boat.");
|
||||
player.getActionSender().sendMessage(
|
||||
"Players needed: " + PLAYERS_REQUIRED + " to 25 players.");
|
||||
player.getPlayerAssistant().movePlayer(2661, 2639, 0);
|
||||
waitBoat();
|
||||
} else if (player.combatLevel < 40) {
|
||||
player.getActionSender().sendMessage("You need 40 combat to play pest control.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if a player is in the game
|
||||
*
|
||||
* @param player
|
||||
* The player
|
||||
* @return return
|
||||
*/
|
||||
public static boolean isInGame(Client player) {
|
||||
return gamePlayers.containsKey(player);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if a player is in the pc boat (lobby)
|
||||
*
|
||||
* @param player
|
||||
* The player
|
||||
* @return return
|
||||
*/
|
||||
public static boolean isInPcBoat(Client player) {
|
||||
return waitingBoat.containsKey(player);
|
||||
}
|
||||
|
||||
public static boolean npcIsPCMonster(int npcType) {
|
||||
return npcType >= 3727 && npcType <= 3776;
|
||||
}
|
||||
|
||||
private void spawnNPC() {
|
||||
//npcid, npcx, npcy, heightlevel, walking type, hp, att, def
|
||||
for (int[] aPcNPCData : pcNPCData) {
|
||||
Server.npcHandler.spawnNpc2(aPcNPCData[0], aPcNPCData[1], aPcNPCData[2], 0, 0, 200, 0, 0, playersInGame() * 200);
|
||||
}
|
||||
for (int[] voidMonsters : voidMonsterData) {
|
||||
//Server.npcHandler.spawnNpc2(voidMonsters[0], voidMonsters[1], voidMonsters[2], 0, 1, voidMonsters[NpcHandler.getNpcListHP(voidMonsters[0])], NpcHandler.getNpcListCombat(voidMonsters[0])/10, NpcHandler.getNpcListCombat(voidMonsters[0]), playersInGame() * 200);
|
||||
Server.npcHandler.spawnNpc2(voidMonsters[0], voidMonsters[1], voidMonsters[2], 0, 1, 500, 20, 200, 25);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
package redone.game.content.minigames;
|
||||
|
||||
import redone.game.players.Client;
|
||||
import redone.util.Misc;
|
||||
|
||||
public class TreasureTrails {
|
||||
|
||||
public static int lowLevelReward[] = { 1077, 1125, 1165, 1195, 1297, 1367,
|
||||
853, 7390, 7392, 7394, 7396, 7386, 7388, 1099, 1135, 1065, 851 };
|
||||
public static int mediemLevelReward[] = { 1073, 1123, 1161, 1199, 1301,
|
||||
1371, 857, 2577, 2579, 2487, 2493, 2499, 2631, 855 };
|
||||
public static int highLevelReward[] = { 1079, 1093, 1113, 1127, 1147, 1163,
|
||||
1185, 1201, 1275, 1303, 1319, 1333, 1359, 1373, 2491, 2497, 2503,
|
||||
861, 859, 2581, 2651, 1079, 1093, 1113, 1127, 1147, 1163, 1185,
|
||||
1201, 1275, 1303, 1319, 1333, 1359, 1373, 2491, 2497, 2503, 861,
|
||||
859, 2581, 2651, };
|
||||
|
||||
public static int lowLevelStacks[] = { 995, 380, 561, 886, };
|
||||
public static int mediumLevelStacks[] = { 995, 374, 561, 563, 890, };
|
||||
public static int highLevelStacks[] = { 995, 386, 561, 563, 560, 892 };
|
||||
public static int allStacks[] = { 995, 380, 561, 886, 374, 561, 563, 890,
|
||||
386, 561, 563, 560, 892 };
|
||||
|
||||
public static void addClueReward(Client c, int clueLevel) {
|
||||
int chanceReward = Misc.random(2);
|
||||
if (clueLevel == 0) {
|
||||
switch (chanceReward) {
|
||||
case 0:
|
||||
displayReward(c, lowLevelReward[Misc.random(16)], 1,
|
||||
lowLevelReward[Misc.random(16)], 1,
|
||||
lowLevelStacks[Misc.random(3)], 1 + Misc.random(150));
|
||||
break;
|
||||
case 1:
|
||||
displayReward(c, lowLevelReward[Misc.random(16)], 1,
|
||||
lowLevelStacks[Misc.random(3)], 1 + Misc.random(150),
|
||||
-1, 1);
|
||||
break;
|
||||
case 2:
|
||||
displayReward(c, lowLevelReward[Misc.random(16)], 1, -1, 1, -1,
|
||||
1);
|
||||
break;
|
||||
}
|
||||
} else if (clueLevel == 1) {
|
||||
switch (chanceReward) {
|
||||
case 0:
|
||||
displayReward(c, mediemLevelReward[Misc.random(13)], 1,
|
||||
mediemLevelReward[Misc.random(13)], 1,
|
||||
mediumLevelStacks[Misc.random(4)], 1 + Misc.random(200));
|
||||
break;
|
||||
case 1:
|
||||
displayReward(c, mediemLevelReward[Misc.random(13)], 1,
|
||||
mediumLevelStacks[Misc.random(4)],
|
||||
1 + Misc.random(200), -1, 1);
|
||||
break;
|
||||
case 2:
|
||||
displayReward(c, mediemLevelReward[Misc.random(13)], 1, -1, 1,
|
||||
-1, 1);
|
||||
break;
|
||||
}
|
||||
} else if (clueLevel == 2) {
|
||||
switch (chanceReward) {
|
||||
case 0:
|
||||
displayReward(c, highLevelReward[Misc.random(52)], 1,
|
||||
highLevelReward[Misc.random(52)], 1,
|
||||
highLevelStacks[Misc.random(5)], 1 + Misc.random(350));
|
||||
break;
|
||||
case 1:
|
||||
displayReward(c, highLevelReward[Misc.random(52)], 1,
|
||||
highLevelStacks[Misc.random(5)], 1 + Misc.random(350),
|
||||
-1, 1);
|
||||
break;
|
||||
case 2:
|
||||
displayReward(c, highLevelReward[Misc.random(52)], 1, -1, 1,
|
||||
-1, 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void displayReward(Client c, int item, int amount, int item2,
|
||||
int amount2, int item3, int amount3) {
|
||||
int[] items = { item, item2, item3 };
|
||||
int[] amounts = { amount, amount2, amount3 };
|
||||
c.outStream.createFrameVarSizeWord(53);
|
||||
c.outStream.writeWord(6963);
|
||||
c.outStream.writeWord(items.length);
|
||||
for (int i = 0; i < items.length; i++) {
|
||||
if (c.playerItemsN[i] > 254) {
|
||||
c.outStream.writeByte(255);
|
||||
c.outStream.writeDWord_v2(amounts[i]);
|
||||
} else {
|
||||
c.outStream.writeByte(amounts[i]);
|
||||
}
|
||||
if (items[i] > 0) {
|
||||
c.outStream.writeWordBigEndianA(items[i] + 1);
|
||||
} else {
|
||||
c.outStream.writeWordBigEndianA(0);
|
||||
}
|
||||
}
|
||||
c.outStream.endFrameVarSizeWord();
|
||||
c.flushOutStream();
|
||||
c.getItemAssistant().addItem(item, amount);
|
||||
c.getItemAssistant().addItem(item2, amount2);
|
||||
c.getItemAssistant().addItem(item3, amount3);
|
||||
c.getPlayerAssistant().showInterface(6960);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,280 @@
|
||||
package redone.game.content.minigames.castlewars;
|
||||
|
||||
import redone.game.players.Client;
|
||||
|
||||
public class CastleWarObjects {
|
||||
|
||||
public static void handleObject(Client c, int id, int x, int y) {
|
||||
switch (id) {
|
||||
case 4469:
|
||||
if (CastleWars.getTeamNumber(c) == 2) {
|
||||
c.getActionSender().sendMessage(
|
||||
"You are not allowed in the other teams spawn point.");
|
||||
break;
|
||||
}
|
||||
if (x == 2426) {
|
||||
if (c.getY() == 3080) {
|
||||
c.getPlayerAssistant()
|
||||
.movePlayer(2426, 3081, c.heightLevel);
|
||||
} else if (c.getY() == 3081) {
|
||||
c.getPlayerAssistant()
|
||||
.movePlayer(2426, 3080, c.heightLevel);
|
||||
}
|
||||
} else if (x == 2422) {
|
||||
if (c.getX() == 2422) {
|
||||
c.getPlayerAssistant()
|
||||
.movePlayer(2423, 3076, c.heightLevel);
|
||||
} else if (c.getX() == 2423) {
|
||||
c.getPlayerAssistant()
|
||||
.movePlayer(2422, 3076, c.heightLevel);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 4470:
|
||||
if (CastleWars.getTeamNumber(c) == 1) {
|
||||
c.getActionSender().sendMessage(
|
||||
"You are not allowed in the other teams spawn point.");
|
||||
break;
|
||||
}
|
||||
if (x == 2373 && y == 3126) {
|
||||
if (c.getY() == 3126) {
|
||||
c.getPlayerAssistant().movePlayer(2373, 3127, 1);
|
||||
} else if (c.getY() == 3127) {
|
||||
c.getPlayerAssistant().movePlayer(2373, 3126, 1);
|
||||
}
|
||||
} else if (x == 2377 && y == 3131) {
|
||||
if (c.getX() == 2376) {
|
||||
c.getPlayerAssistant().movePlayer(2377, 3131, 1);
|
||||
} else if (c.getX() == 2377) {
|
||||
c.getPlayerAssistant().movePlayer(2376, 3131, 1);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 4417:
|
||||
if (x == 2428 && y == 3081 && c.heightLevel == 1) {
|
||||
c.getPlayerAssistant().movePlayer(2430, 3080, 2);
|
||||
}
|
||||
if (x == 2425 && y == 3074 && c.heightLevel == 2) {
|
||||
c.getPlayerAssistant().movePlayer(2426, 3074, 3);
|
||||
}
|
||||
if (x == 2419 && y == 3078 && c.heightLevel == 0) {
|
||||
c.getPlayerAssistant().movePlayer(2420, 3080, 1);
|
||||
}
|
||||
break;
|
||||
case 4415:
|
||||
if (x == 2419 && y == 3080 && c.heightLevel == 1) {
|
||||
c.getPlayerAssistant().movePlayer(2419, 3077, 0);
|
||||
}
|
||||
if (x == 2430 && y == 3081 && c.heightLevel == 2) {
|
||||
c.getPlayerAssistant().movePlayer(2427, 3081, 1);
|
||||
}
|
||||
if (x == 2425 && y == 3074 && c.heightLevel == 3) {
|
||||
c.getPlayerAssistant().movePlayer(2425, 3077, 2);
|
||||
}
|
||||
if (x == 2374 && y == 3133 && c.heightLevel == 3) {
|
||||
c.getPlayerAssistant().movePlayer(2374, 3130, 2);
|
||||
}
|
||||
if (x == 2369 && y == 3126 && c.heightLevel == 2) {
|
||||
c.getPlayerAssistant().movePlayer(2372, 3126, 1);
|
||||
}
|
||||
if (x == 2380 && y == 3127 && c.heightLevel == 1) {
|
||||
c.getPlayerAssistant().movePlayer(2380, 3130, 0);
|
||||
}
|
||||
break;
|
||||
case 4411: // castle wars jumping stones
|
||||
if (x == c.getX() && y == c.getY()) {
|
||||
c.getActionSender().sendMessage("You are standing on the rock you clicked.");
|
||||
} else if (x > c.getX() && y == c.getY()) {
|
||||
c.getPlayerAssistant().walkTo(1, 0);
|
||||
} else if (x < c.getX() && y == c.getY()) {
|
||||
c.getPlayerAssistant().walkTo(-1, 0);
|
||||
} else if (y > c.getY() && x == c.getX()) {
|
||||
c.getPlayerAssistant().walkTo(0, 1);
|
||||
} else if (y < c.getY() && x == c.getX()) {
|
||||
c.getPlayerAssistant().walkTo(0, -1);
|
||||
} else {
|
||||
c.getActionSender().sendMessage("Can't reach that.");
|
||||
}
|
||||
break;
|
||||
case 4419:
|
||||
if (x == 2417 && y == 3074 && c.heightLevel == 0) {
|
||||
if (c.getX() == 2416) {
|
||||
c.getPlayerAssistant().movePlayer(2417, 3077, 0);
|
||||
} else {
|
||||
c.getPlayerAssistant().movePlayer(2416, 3074, 0);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 4911:
|
||||
if (x == 2421 && y == 3073 && c.heightLevel == 1) {
|
||||
c.getPlayerAssistant().movePlayer(2421, 3074, 0);
|
||||
}
|
||||
if (x == 2378 && y == 3134 && c.heightLevel == 1) {
|
||||
c.getPlayerAssistant().movePlayer(2378, 3133, 0);
|
||||
}
|
||||
break;
|
||||
case 1747:
|
||||
if (x == 2421 && y == 3073 && c.heightLevel == 0) {
|
||||
c.getPlayerAssistant().movePlayer(2421, 3074, 1);
|
||||
}
|
||||
if (x == 2378 && y == 3134 && c.heightLevel == 0) {
|
||||
c.getPlayerAssistant().movePlayer(2378, 3133, 1);
|
||||
}
|
||||
break;
|
||||
case 4912:
|
||||
if (x == 2430 && y == 3082 && c.heightLevel == 0) {
|
||||
c.getPlayerAssistant().movePlayer(c.getX(), c.getY() + 6400, 0);
|
||||
}
|
||||
if (x == 2369 && y == 3125 && c.heightLevel == 0) {
|
||||
c.getPlayerAssistant().movePlayer(c.getX(), c.getY() + 6400, 0);
|
||||
}
|
||||
break;
|
||||
case 1757:
|
||||
if (x == 2430 && y == 9482) {
|
||||
c.getPlayerAssistant().movePlayer(2430, 3081, 0);
|
||||
} else if (c.absX == 2533) {
|
||||
c.getPlayerAssistant().movePlayer(2532, 3155, 0);
|
||||
} else {
|
||||
c.getPlayerAssistant().movePlayer(2369, 3126, 0);
|
||||
}
|
||||
break;
|
||||
|
||||
case 4418:
|
||||
if (x == 2380 && y == 3127 && c.heightLevel == 0) {
|
||||
c.getPlayerAssistant().movePlayer(2379, 3127, 1);
|
||||
}
|
||||
if (x == 2369 && y == 3126 && c.heightLevel == 1) {
|
||||
c.getPlayerAssistant().movePlayer(2369, 3127, 2);
|
||||
}
|
||||
if (x == 2374 && y == 3131 && c.heightLevel == 2) {
|
||||
c.getPlayerAssistant().movePlayer(2373, 3133, 3);
|
||||
}
|
||||
break;
|
||||
case 4420:
|
||||
if (x == 2382 && y == 3131 && c.heightLevel == 0) {
|
||||
if (c.getX() >= 2383 && c.getX() <= 2385) {
|
||||
c.getPlayerAssistant().movePlayer(2382, 3130, 0);
|
||||
} else {
|
||||
c.getPlayerAssistant().movePlayer(2383, 3133, 0);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 4437:
|
||||
if (x == 2400 && y == 9512) {
|
||||
c.getPlayerAssistant().movePlayer(2400, 9514, 0);
|
||||
} else if (x == 2391 && y == 9501) {
|
||||
c.getPlayerAssistant().movePlayer(2393, 9502, 0);
|
||||
} else if (x == 2409 && y == 9503) {
|
||||
c.getPlayerAssistant().movePlayer(2411, 9503, 0);
|
||||
} else if (x == 2401 && y == 9494) {
|
||||
c.getPlayerAssistant().movePlayer(2401, 9493, 0);
|
||||
}
|
||||
break;
|
||||
case 1568:
|
||||
if (x == 2399 && y == 3099) {
|
||||
c.getPlayerAssistant().movePlayer(2399, 9500, 0);
|
||||
} else {
|
||||
c.getPlayerAssistant().movePlayer(2400, 9507, 0);
|
||||
}
|
||||
case 6281:
|
||||
c.getPlayerAssistant().movePlayer(2370, 3132, 2);
|
||||
break;
|
||||
case 4472:
|
||||
c.getPlayerAssistant().movePlayer(2370, 3132, 1);
|
||||
break;
|
||||
case 6280:
|
||||
c.getPlayerAssistant().movePlayer(2429, 3075, 2);
|
||||
break;
|
||||
case 4471:
|
||||
c.getPlayerAssistant().movePlayer(2429, 3075, 1);
|
||||
break;
|
||||
case 4406:
|
||||
CastleWars.removePlayerFromCw(c);
|
||||
break;
|
||||
case 4407:
|
||||
CastleWars.removePlayerFromCw(c);
|
||||
break;
|
||||
case 4458:
|
||||
if (System.currentTimeMillis() - c.miscTimer > 1200) {
|
||||
c.startAnimation(881);
|
||||
c.getItemAssistant().addItem(4049, 1);
|
||||
c.getActionSender().sendMessage("You get some bandages");
|
||||
c.miscTimer = System.currentTimeMillis();
|
||||
}
|
||||
break;
|
||||
case 4902: // sara flag
|
||||
case 4377:
|
||||
switch (CastleWars.getTeamNumber(c)) {
|
||||
case 1:
|
||||
CastleWars.returnFlag(c, c.playerEquipment[c.playerWeapon]);
|
||||
break;
|
||||
case 2:
|
||||
CastleWars.captureFlag(c);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 4903: // zammy flag
|
||||
case 4378:
|
||||
switch (CastleWars.getTeamNumber(c)) {
|
||||
case 1:
|
||||
CastleWars.captureFlag(c);
|
||||
break;
|
||||
case 2:
|
||||
CastleWars.returnFlag(c, c.playerEquipment[c.playerWeapon]);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 4461: // barricades
|
||||
if (System.currentTimeMillis() - c.miscTimer > 1200) {
|
||||
c.getActionSender().sendMessage("You get a barricade!");
|
||||
c.getItemAssistant().addItem(4053, 1);
|
||||
c.miscTimer = System.currentTimeMillis();
|
||||
}
|
||||
break;
|
||||
case 4463: // explosive potion!
|
||||
if (System.currentTimeMillis() - c.miscTimer > 1200) {
|
||||
c.getActionSender().sendMessage(
|
||||
"You get an explosive potion!");
|
||||
c.getItemAssistant().addItem(4045, 1);
|
||||
c.miscTimer = System.currentTimeMillis();
|
||||
}
|
||||
break;
|
||||
case 4464: // pickaxe table
|
||||
if (System.currentTimeMillis() - c.miscTimer > 1200) {
|
||||
c.getActionSender().sendMessage(
|
||||
"You get a bronzen pickaxe for mining.");
|
||||
c.getItemAssistant().addItem(1265, 1);
|
||||
c.miscTimer = System.currentTimeMillis();
|
||||
}
|
||||
break;
|
||||
case 4459: // tinderbox table
|
||||
if (System.currentTimeMillis() - c.miscTimer > 1200) {
|
||||
c.getActionSender().sendMessage("You take a tinderbox!");
|
||||
c.getItemAssistant().addItem(590, 1);
|
||||
c.miscTimer = System.currentTimeMillis();
|
||||
}
|
||||
break;
|
||||
case 4462:
|
||||
if (System.currentTimeMillis() - c.miscTimer > 1200) {
|
||||
c.getActionSender().sendMessage("You take some rope!");
|
||||
c.getItemAssistant().addItem(954, 1);
|
||||
c.miscTimer = System.currentTimeMillis();
|
||||
}
|
||||
break;
|
||||
case 4460:
|
||||
if (System.currentTimeMillis() - c.miscTimer > 1200) {
|
||||
c.getActionSender().sendMessage("You take a rock!");
|
||||
c.getItemAssistant().addItem(4043, 1);
|
||||
c.miscTimer = System.currentTimeMillis();
|
||||
}
|
||||
break;
|
||||
case 4900:
|
||||
case 4901:
|
||||
CastleWars.pickupFlag(c);
|
||||
default:
|
||||
break;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,857 @@
|
||||
package redone.game.content.minigames.castlewars;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
|
||||
import redone.game.items.ItemAssistant;
|
||||
import redone.game.players.Client;
|
||||
import redone.game.players.Player;
|
||||
import redone.util.Misc;
|
||||
|
||||
/**
|
||||
* @Author Sanity for base
|
||||
* @Author Satan666
|
||||
* @Author Andrew fixing it up
|
||||
*/
|
||||
|
||||
public class CastleWars {
|
||||
|
||||
/*
|
||||
* Game timers.
|
||||
*/
|
||||
private static final int GAME_TIMER = 200; // 1500 * 600 = 900000ms = 15
|
||||
// minutes
|
||||
private static final int GAME_START_TIMER = 30;
|
||||
/*
|
||||
* Hashmap for the waitingroom players
|
||||
*/
|
||||
private static HashMap<Client, Integer> waitingRoom = new HashMap<Client, Integer>();
|
||||
/*
|
||||
* hashmap for the gameRoom players
|
||||
*/
|
||||
private static HashMap<Client, Integer> gameRoom = new HashMap<Client, Integer>();
|
||||
/*
|
||||
* The coordinates for the waitingRoom both sara/zammy
|
||||
*/
|
||||
private static final int[][] WAIT_ROOM = { { 2377, 9485 }, // sara
|
||||
{ 2421, 9524 } // zammy
|
||||
};
|
||||
/*
|
||||
* The coordinates for the gameRoom both sara/zammy
|
||||
*/
|
||||
private static final int[][] GAME_ROOM = { { 2426, 3076 }, // sara
|
||||
{ 2372, 3131 } // zammy
|
||||
};
|
||||
private static final int[][] FLAG_STANDS = { { 2429, 3074 }, // sara
|
||||
// {X-Coord,
|
||||
// Y-Coord)
|
||||
{ 2370, 3133 } // zammy
|
||||
};
|
||||
/*
|
||||
* Scores for saradomin and zamorak!
|
||||
*/
|
||||
private static int[] scores = { 0, 0 };
|
||||
/*
|
||||
* Booleans to check if a team's flag is safe
|
||||
*/
|
||||
private static int zammyFlag = 0;
|
||||
private static int saraFlag = 0;
|
||||
/*
|
||||
* Zamorak and saradomin banner/capes item ID's
|
||||
*/
|
||||
public static final int SARA_BANNER = 4037;
|
||||
public static final int ZAMMY_BANNER = 4039;
|
||||
public static final int SARA_CAPE = 4041;
|
||||
public static final int ZAMMY_CAPE = 4042;
|
||||
public static final int SARA_HOOD = 4513;
|
||||
public static final int ZAMMY_HOOD = 4515;
|
||||
|
||||
public static boolean deleteCastleWarsItems(Client c, int itemId) {
|
||||
int[] items = { 4049, 4045, 4053, 4042, 4041, 4037, 4039, 4043 };
|
||||
for (int item : items) {
|
||||
int amount = c.getItemAssistant().getItemCount(item);
|
||||
if (itemId == item && !isInCw(c)) {
|
||||
c.getItemAssistant().deleteItem(item, amount);
|
||||
c.getActionSender().sendMessage("You shouldn't have " + ItemAssistant.getItemName(itemId) + " outside of castlewars!");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
private static final int[][] COLLAPSE_ROCKS = { // collapsing rocks coords
|
||||
{ 2399, 2402, 9511, 9514 }, // north X Y coords sara 0
|
||||
{ 2390, 2393, 9500, 9503 }, // east X Y coords sara 1
|
||||
{ 2400, 2403, 9493, 9496 }, // south X Y coords zammy 2
|
||||
{ 2408, 2411, 9502, 9505 } // west X Y coords zammy 3
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
private static int properTimer = 0;
|
||||
private static int timeRemaining = -1;
|
||||
private static int gameStartTimer = GAME_START_TIMER;
|
||||
private static boolean gameStarted = false;
|
||||
|
||||
public static void resetPlayer(Client c) {
|
||||
c.getPlayerAssistant().movePlayer(2440 + Misc.random(3), 3089 - Misc.random(3), 0);
|
||||
deleteGameItems(c);
|
||||
c.getActionSender().sendMessage("Cheating will not be tolerated.");
|
||||
}
|
||||
|
||||
public static void collapseCave(int cave) {
|
||||
Iterator<Client> iterator = gameRoom.keySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Client teamPlayer = iterator.next();
|
||||
if (teamPlayer.absX > COLLAPSE_ROCKS[cave][0]
|
||||
&& teamPlayer.absX < COLLAPSE_ROCKS[cave][1]
|
||||
&& teamPlayer.absY > COLLAPSE_ROCKS[cave][2]
|
||||
&& teamPlayer.absY < COLLAPSE_ROCKS[cave][3]) {
|
||||
int dmg = teamPlayer.playerLevel[3];
|
||||
teamPlayer.handleHitMask(dmg);
|
||||
teamPlayer.dealDamage(99);// 99 damage?
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use to add someone to the waitinroom in a different method,
|
||||
* this will filter out some error messages
|
||||
*
|
||||
* @param player
|
||||
* the player that wants to join
|
||||
* @param team
|
||||
* the team!
|
||||
*/
|
||||
public static void addToWaitRoom(Client player, int team) {
|
||||
if (player == null) {
|
||||
return;
|
||||
} else if (gameStarted == true) {
|
||||
player.getActionSender()
|
||||
.sendMessage(
|
||||
"There's already a Castle Wars going. Please wait a few minutes before trying again.");
|
||||
return;
|
||||
} else if (player.playerEquipment[player.playerHat] > 0 || player.playerEquipment[player.playerCape] > 0 || player.getItemAssistant().playerHasItem(player.playerCape) || player.getItemAssistant().playerHasItem(player.playerHat)) {
|
||||
player.getActionSender().sendMessage("You may not bring capes or helmets in castle wars.");
|
||||
return;
|
||||
}
|
||||
toWaitingRoom(player, team);
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use to transfer to player from the outside to the waitingroom
|
||||
* (:
|
||||
*
|
||||
* @param player
|
||||
* the player that wants to join
|
||||
* @param team
|
||||
* team he wants to be in - team = 1 (saradomin), team = 2
|
||||
* (zamorak), team = 3 (random)
|
||||
*/
|
||||
public static void toWaitingRoom(Client player, int team) {
|
||||
int[] food = { 391, 385, 379, 333, 329, 373, 361, 7946, 397, 1891, 365,
|
||||
339, 1942, 6701, 6705, 7056, 7054, 7058, 7060, 315, 347, 325,
|
||||
1897, 2289, 2293, 2297, 2301, 2309, 2323, 2325, 2327, 351,
|
||||
6703, 1963, 6883, 2108, 2118, 2116, 15272, 1961, 1959, 1989,
|
||||
1935, 1915, 1978, 712, 1907, 2120, 2114, 1973, 1993, 355,
|
||||
3144, 1917, 1909, 2955, 1969, 6701, 1893, 1895, 1965, 1899,
|
||||
1901, 2291, 2295, 2297, 2299, 2301, 2303, 1883, 6883, 2108, 2118,
|
||||
2116, 7928, 7929, 7930, 7931, 7932, 7933, 10476, 2130, 2003, 2011,
|
||||
4049};
|
||||
for (int element : food) {
|
||||
if (player.getItemAssistant().playerHasItem(element)) {
|
||||
player.getActionSender().sendMessage("You may not bring your own consumables inside of Castle Wars.");
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (team == 1) {
|
||||
if (getSaraPlayers() > getZammyPlayers() && getSaraPlayers() > 0) {
|
||||
player.getActionSender().sendMessage(
|
||||
"The saradomin team is full, try again later!");
|
||||
return;
|
||||
}
|
||||
if (getZammyPlayers() >= getSaraPlayers() || getSaraPlayers() == 0) {
|
||||
player.getActionSender().sendMessage(
|
||||
"You have been added to the Saradomin team.");
|
||||
player.getActionSender().sendMessage(
|
||||
"Next Game Begins In: "
|
||||
+ (gameStartTimer * 3 + timeRemaining * 3)
|
||||
+ " seconds.");
|
||||
addCapes(player, SARA_CAPE);
|
||||
waitingRoom.put(player, team);
|
||||
player.getPlayerAssistant().movePlayer(
|
||||
WAIT_ROOM[team - 1][0] + Misc.random(5),
|
||||
WAIT_ROOM[team - 1][1] + Misc.random(5), 0);
|
||||
}
|
||||
} else if (team == 2) {
|
||||
if (getZammyPlayers() > getSaraPlayers() && getZammyPlayers() > 0) {
|
||||
player.getActionSender().sendMessage(
|
||||
"The zamorak team is full, try again later!");
|
||||
return;
|
||||
}
|
||||
if (getZammyPlayers() <= getSaraPlayers() || getZammyPlayers() == 0) {
|
||||
player.getActionSender()
|
||||
.sendMessage(
|
||||
"Random team: You have been added to the Zamorak team.");
|
||||
player.getActionSender().sendMessage(
|
||||
"Next Game Begins In: "
|
||||
+ (gameStartTimer * 3 + timeRemaining * 3)
|
||||
+ " seconds.");
|
||||
addCapes(player, ZAMMY_CAPE);
|
||||
waitingRoom.put(player, team);
|
||||
player.getPlayerAssistant().movePlayer(
|
||||
WAIT_ROOM[team - 1][0] + Misc.random(5),
|
||||
WAIT_ROOM[team - 1][1] + Misc.random(5), 0);
|
||||
}
|
||||
} else if (team == 3) {
|
||||
toWaitingRoom(player, getZammyPlayers() > getSaraPlayers() ? 1 : 2);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to add score to scoring team
|
||||
*
|
||||
* @param player
|
||||
* the player who scored
|
||||
* @param banner
|
||||
* banner id!
|
||||
*/
|
||||
public static void returnFlag(Client player, int wearItem) {
|
||||
if (player == null) {
|
||||
return;
|
||||
}
|
||||
if (wearItem != SARA_BANNER && wearItem != ZAMMY_BANNER) {
|
||||
return;
|
||||
}
|
||||
int team = gameRoom.get(player);
|
||||
int objectId = -1;
|
||||
int objectTeam = -1;
|
||||
switch (team) {
|
||||
case 1:
|
||||
if (wearItem == SARA_BANNER) {
|
||||
setSaraFlag(0);
|
||||
objectId = 4902;
|
||||
objectTeam = 0;
|
||||
player.getActionSender().sendMessage(
|
||||
"Returned the sara flag!");
|
||||
} else {
|
||||
objectId = 4903;
|
||||
objectTeam = 1;
|
||||
setZammyFlag(0);
|
||||
scores[0]++; // upping the score of a team; team 0 = sara,
|
||||
// team 1 = zammy
|
||||
player.getActionSender().sendMessage(
|
||||
"The team of Saradomin scores 1 point!");
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
if (wearItem == ZAMMY_BANNER) {
|
||||
setZammyFlag(0);
|
||||
objectId = 4903;
|
||||
objectTeam = 1;
|
||||
player.getActionSender().sendMessage(
|
||||
"Returned the zammy flag!");
|
||||
} else {
|
||||
objectId = 4902;
|
||||
objectTeam = 0;
|
||||
setSaraFlag(0);
|
||||
scores[1]++; // upping the score of a team; team 0 = sara,
|
||||
// team 1 = zammy
|
||||
player.getActionSender().sendMessage(
|
||||
"The team of Zamorak scores 1 point!");
|
||||
zammyFlag = 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
changeFlagObject(objectId, objectTeam);
|
||||
player.getActionSender().createPlayerHints(10, -1);
|
||||
player.playerEquipment[player.playerWeapon] = -1;
|
||||
player.playerEquipmentN[player.playerWeapon] = 0;
|
||||
player.getItemAssistant().updateSlot(3);
|
||||
player.appearanceUpdateRequired = true;
|
||||
player.updateRequired = true;
|
||||
player.getItemAssistant().resetItems(3214);
|
||||
}
|
||||
|
||||
/**
|
||||
* Method that will capture a flag when being taken by the enemy team!
|
||||
*
|
||||
* @param player
|
||||
* the player who returned the flag
|
||||
* @param team
|
||||
*/
|
||||
public static void captureFlag(Client player) {
|
||||
if (player.playerEquipment[player.playerWeapon] > 0) {
|
||||
player.getActionSender()
|
||||
.sendMessage(
|
||||
"Please remove your weapon before attempting to get the flag again!");
|
||||
return;
|
||||
}
|
||||
int team = gameRoom.get(player);
|
||||
if (team == 2 && saraFlag == 0) { // sara flag
|
||||
setSaraFlag(1);
|
||||
addFlag(player, SARA_BANNER);
|
||||
createHintIcon(player, 1);
|
||||
changeFlagObject(4377, 0);
|
||||
}
|
||||
if (team == 1 && zammyFlag == 0) {
|
||||
setZammyFlag(1);
|
||||
addFlag(player, ZAMMY_BANNER);
|
||||
createHintIcon(player, 2);
|
||||
changeFlagObject(4378, 1);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Method that will add the flag to a player's weapon slot
|
||||
*
|
||||
* @param player
|
||||
* the player who's getting the flag
|
||||
* @param flagId
|
||||
* the banner id.
|
||||
*/
|
||||
public static void addFlag(Client player, int flagId) {
|
||||
player.playerEquipment[player.playerWeapon] = flagId;
|
||||
player.playerEquipmentN[player.playerWeapon] = 1;
|
||||
player.getItemAssistant().updateSlot(player.playerWeapon);
|
||||
player.appearanceUpdateRequired = true;
|
||||
player.updateRequired = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use to handle the flag dropping
|
||||
*
|
||||
* @param player
|
||||
* the player who dropped the flag/died
|
||||
* @param flagId
|
||||
* the flag item ID
|
||||
*/
|
||||
public static void dropFlag(Client player, int flagId) {
|
||||
int object = -1;
|
||||
switch (flagId) {
|
||||
case SARA_BANNER: // sara
|
||||
setSaraFlag(2);
|
||||
object = 4900;
|
||||
createFlagHintIcon(player.getX(), player.getY());
|
||||
break;
|
||||
case ZAMMY_BANNER: // zammy
|
||||
setZammyFlag(2);
|
||||
object = 4901;
|
||||
createFlagHintIcon(player.getX(), player.getY());
|
||||
break;
|
||||
}
|
||||
|
||||
player.playerEquipment[player.playerWeapon] = -1;
|
||||
player.playerEquipmentN[player.playerWeapon] = 0;
|
||||
player.getItemAssistant().updateSlot(player.playerWeapon);
|
||||
player.appearanceUpdateRequired = true;
|
||||
player.updateRequired = true;
|
||||
for (Client teamPlayer : gameRoom.keySet()) {
|
||||
teamPlayer.getActionSender().object(object, player.getX(),
|
||||
player.getY(), 0, 10);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use to pickup the flag when it was dropped/lost
|
||||
*
|
||||
* @param Player
|
||||
* the player who's picking it up
|
||||
* @param objectId
|
||||
* the flag object id.
|
||||
*/
|
||||
public static void pickupFlag(Client player) {
|
||||
switch (player.objectId) {
|
||||
case 4900: // sara
|
||||
if (player.playerEquipment[player.playerWeapon] > 0) {
|
||||
player.getActionSender()
|
||||
.sendMessage(
|
||||
"Please remove your weapon before attempting to get the flag again!");
|
||||
return;
|
||||
}
|
||||
if (saraFlag != 2) {
|
||||
return;
|
||||
}
|
||||
setSaraFlag(1);
|
||||
addFlag(player, 4037);
|
||||
break;
|
||||
case 4901: // zammy
|
||||
if (player.playerEquipment[player.playerWeapon] > 0) {
|
||||
player.getActionSender()
|
||||
.sendMessage(
|
||||
"Please remove your weapon before attempting to get the flag again!");
|
||||
return;
|
||||
}
|
||||
if (zammyFlag != 2) {
|
||||
return;
|
||||
}
|
||||
setZammyFlag(1);
|
||||
addFlag(player, 4039);
|
||||
break;
|
||||
}
|
||||
createHintIcon(player, gameRoom.get(player) == 1 ? 2 : 1);
|
||||
Iterator<Client> iterator = gameRoom.keySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Client teamPlayer = iterator.next();
|
||||
teamPlayer.getActionSender().createObjectHints(player.objectX,
|
||||
player.objectY, 170, -1);
|
||||
teamPlayer.getActionSender().object(-1, player.objectX,
|
||||
player.objectY, 0, 10);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* Hint icons appear to your team when a enemy steals flag
|
||||
*
|
||||
* @param player
|
||||
* the player who took the flag
|
||||
* @param t
|
||||
* team of the opponent team. (:
|
||||
*/
|
||||
public static void createHintIcon(Client player, int t) {
|
||||
Iterator<Client> iterator = gameRoom.keySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Client teamPlayer = iterator.next();
|
||||
// System.out.println(teamPlayer.playerName + " => Team => " +
|
||||
// gameRoom.get(teamPlayer));
|
||||
// System.out.println("Desired team = " + t);
|
||||
teamPlayer.getActionSender().createPlayerHints(10, -1);
|
||||
if (gameRoom.get(teamPlayer) == t) {
|
||||
// System.out.println("Created hint icons for playername " +
|
||||
// teamPlayer.playerName + " and team number: " + t);
|
||||
teamPlayer.getActionSender().createPlayerHints(10,
|
||||
player.playerId);
|
||||
teamPlayer.getPlayerAssistant().requestUpdates();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Hint icons appear to your team when a enemy steals flag
|
||||
*
|
||||
* @param player
|
||||
* the player who took the flag
|
||||
* @param t
|
||||
* team of the opponent team. (:
|
||||
*/
|
||||
public static void createFlagHintIcon(int x, int y) {
|
||||
Iterator<Client> iterator = gameRoom.keySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Client teamPlayer = iterator.next();
|
||||
teamPlayer.getActionSender().createObjectHints(x, y, 170, 2);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This method is used to get the teamNumber of a certain player
|
||||
*
|
||||
* @param player
|
||||
* @return
|
||||
*/
|
||||
public static int getTeamNumber(Client player) {
|
||||
if (player == null) {
|
||||
return -1;
|
||||
}
|
||||
if (gameRoom.containsKey(player)) {
|
||||
return gameRoom.get(player);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* The leaving method will be used on click object or log out
|
||||
*
|
||||
* @param player
|
||||
* player who wants to leave
|
||||
*/
|
||||
public static void leaveWaitingRoom(Client player) {
|
||||
if (player == null) {
|
||||
System.out.println("player is null");
|
||||
return;
|
||||
}
|
||||
if (waitingRoom.containsKey(player)) {
|
||||
waitingRoom.remove(player);
|
||||
player.getActionSender().createPlayerHints(10, -1);
|
||||
player.getActionSender().sendMessage("You left your team!");
|
||||
deleteGameItems(player);
|
||||
player.getPlayerAssistant().movePlayer(2439 + Misc.random(4),
|
||||
3085 + Misc.random(5), 0);
|
||||
return;
|
||||
}
|
||||
player.getPlayerAssistant().movePlayer(2439 + Misc.random(4),
|
||||
3085 + Misc.random(5), 0);
|
||||
// System.out.println("Waiting room map does not contain " +
|
||||
// player.playerName);
|
||||
}
|
||||
|
||||
public static void process() {
|
||||
if (properTimer > 0) {
|
||||
properTimer--;
|
||||
return;
|
||||
} else {
|
||||
properTimer = 4;
|
||||
}
|
||||
if (gameStartTimer > 0) {
|
||||
gameStartTimer--;
|
||||
updatePlayers();
|
||||
} else if (gameStartTimer == 0) {
|
||||
startGame();
|
||||
}
|
||||
if (timeRemaining > 0) {
|
||||
timeRemaining--;
|
||||
updateInGamePlayers();
|
||||
} else if (timeRemaining == 0) {
|
||||
endGame();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use to update the player's interface in the waiting room
|
||||
*/
|
||||
public static void updatePlayers() {
|
||||
Iterator<Client> iterator = waitingRoom.keySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Client player = iterator.next();
|
||||
if (player != null) {
|
||||
player.getPlayerAssistant().sendFrame126(
|
||||
"Next Game Begins In: "
|
||||
+ (gameStartTimer * 3 + timeRemaining * 3)
|
||||
+ " seconds.", 6570);
|
||||
player.getPlayerAssistant().sendFrame126(
|
||||
"Zamorak Players: " + getZammyPlayers() + ".", 6572);
|
||||
player.getPlayerAssistant().sendFrame126(
|
||||
"Saradomin Players: " + getSaraPlayers() + ".", 6664);
|
||||
player.getPlayerAssistant().walkableInterface(6673);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use the update the player's interface in the game room
|
||||
*/
|
||||
public static void updateInGamePlayers() {
|
||||
if (getSaraPlayers() > 0 && getZammyPlayers() > 0) {
|
||||
Iterator<Client> iterator = gameRoom.keySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Client player = iterator.next();
|
||||
int config;
|
||||
if (player == null) {
|
||||
continue;
|
||||
}
|
||||
player.getPlayerAssistant().walkableInterface(11146);
|
||||
player.getPlayerAssistant().sendFrame126(
|
||||
"Zamorak = " + scores[1], 11147);
|
||||
player.getPlayerAssistant().sendFrame126(
|
||||
scores[0] + " = Saradomin", 11148);
|
||||
player.getPlayerAssistant().sendFrame126(
|
||||
timeRemaining * 3 + " secs", 11155);
|
||||
config = 2097152 * saraFlag;
|
||||
player.getPlayerAssistant().sendFrame87(378, config);
|
||||
config = 2097152 * zammyFlag; // flags 0 = safe 1 = taken 2
|
||||
// = dropped
|
||||
player.getPlayerAssistant().sendFrame87(377, config);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Method that will start the game when there's enough players.
|
||||
*/
|
||||
public static void startGame() {
|
||||
if (getSaraPlayers() < 1 || getZammyPlayers() < 1) {
|
||||
gameStartTimer = GAME_START_TIMER;
|
||||
return;
|
||||
}
|
||||
gameStartTimer = -1;
|
||||
System.out.println("Starting Castle Wars game.");
|
||||
gameStarted = true;
|
||||
timeRemaining = GAME_TIMER / 2;
|
||||
Iterator<Client> iterator = waitingRoom.keySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Client player = iterator.next();
|
||||
int team = waitingRoom.get(player);
|
||||
if (player == null) {
|
||||
continue;
|
||||
}
|
||||
player.getPlayerAssistant().walkableInterface(-1);
|
||||
player.getPlayerAssistant().movePlayer(
|
||||
GAME_ROOM[team - 1][0] + Misc.random(3),
|
||||
GAME_ROOM[team - 1][1] - Misc.random(3), 1);
|
||||
player.getPlayerAssistant().movePlayer(
|
||||
GAME_ROOM[team - 1][0] + Misc.random(3),
|
||||
GAME_ROOM[team - 1][1] - Misc.random(3), 1);
|
||||
gameRoom.put(player, team);
|
||||
}
|
||||
waitingRoom.clear();
|
||||
}
|
||||
|
||||
/*
|
||||
* Method we use to end an ongoing cw game.
|
||||
*/
|
||||
public static void endGame() {
|
||||
Iterator<Client> iterator = gameRoom.keySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Client player = iterator.next();
|
||||
int team = gameRoom.get(player);
|
||||
if (player == null) {
|
||||
continue;
|
||||
}
|
||||
player.cwGames++;
|
||||
player.getPlayerAssistant().movePlayer(2440 + Misc.random(3),
|
||||
3089 - Misc.random(3), 0);
|
||||
player.getActionSender().sendMessage(
|
||||
"Castle Wars: The Castle Wars game has ended!");
|
||||
player.getActionSender().sendMessage(
|
||||
"Castle Wars: Kills: " + player.cwKills + " Deaths: "
|
||||
+ player.cwDeaths + " Games Played: "
|
||||
+ player.cwGames + ".");
|
||||
player.getActionSender().createPlayerHints(10, -1);
|
||||
deleteGameItems(player);
|
||||
player.isDead = false;
|
||||
for (int i = 0; i < 25; i++) {
|
||||
player.playerLevel[i] = player
|
||||
.getLevelForXP(player.playerXP[i]);
|
||||
player.getPlayerAssistant().refreshSkill(i);
|
||||
}
|
||||
if (scores[0] == scores[1]) {
|
||||
player.getItemAssistant().addItem(4067, 1);
|
||||
player.getActionSender().sendMessage(
|
||||
"Tie game! You earn 1 ticket!");
|
||||
} else if (team == 1) {
|
||||
if (scores[0] > scores[1]) {
|
||||
player.getItemAssistant().addItem(4067, 2);
|
||||
player.getActionSender()
|
||||
.sendMessage(
|
||||
"You won the game. You received 2 Castle Wars Tickets!");
|
||||
} else if (scores[0] < scores[1]) {
|
||||
player.getItemAssistant().addItem(4067, 0);
|
||||
player.getActionSender().sendMessage(
|
||||
"You lost the game. You received no tickets!");
|
||||
}
|
||||
} else if (team == 2) {
|
||||
if (scores[1] > scores[0]) {
|
||||
player.getItemAssistant().addItem(4067, 2);
|
||||
player.getActionSender()
|
||||
.sendMessage(
|
||||
"You won the game. You received 2 Castle Wars Tickets!");
|
||||
} else if (scores[1] < scores[0]) {
|
||||
player.getItemAssistant().addItem(4067, 0);
|
||||
player.getActionSender().sendMessage(
|
||||
"You lost the game. You received no tickets!");
|
||||
;
|
||||
}
|
||||
}
|
||||
}
|
||||
resetGame();
|
||||
}
|
||||
|
||||
/**
|
||||
* reset the game variables
|
||||
*/
|
||||
public static void resetGame() {
|
||||
changeFlagObject(4902, 0);
|
||||
changeFlagObject(4903, 1);
|
||||
setSaraFlag(0);
|
||||
setZammyFlag(0);
|
||||
timeRemaining = -1;
|
||||
System.out.println("Ending Castle Wars game.");
|
||||
gameStartTimer = GAME_START_TIMER;
|
||||
gameStarted = false;
|
||||
gameRoom.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use to remove a player from the game
|
||||
*
|
||||
* @param player
|
||||
* the player we want to be removed
|
||||
*/
|
||||
public static void removePlayerFromCw(Client player) {
|
||||
if (player == null) {
|
||||
System.out.println("Error removing player from castle wars [REASON = null].");
|
||||
return;
|
||||
}
|
||||
if (gameRoom.containsKey(player)) {
|
||||
/*
|
||||
* Logging/leaving with flag
|
||||
*/
|
||||
if (player.getItemAssistant().playerHasEquipped(SARA_BANNER)) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[3],
|
||||
3);
|
||||
setSaraFlag(0); // safe flag
|
||||
} else if (player.getItemAssistant()
|
||||
.playerHasEquipped(ZAMMY_BANNER)) {
|
||||
player.getItemAssistant().removeItem(player.playerEquipment[3],
|
||||
3);
|
||||
setZammyFlag(0); // safe flag
|
||||
}
|
||||
deleteGameItems(player);
|
||||
player.getPlayerAssistant().movePlayer(2440, 3089, 0);
|
||||
player.getActionSender().sendMessage(
|
||||
"The Casle Wars game has ended for you!");
|
||||
player.getActionSender().sendMessage(
|
||||
"Kills: " + player.cwKills + " Deaths: " + player.cwDeaths
|
||||
+ ".");
|
||||
player.getActionSender().createPlayerHints(10, -1);
|
||||
gameRoom.remove(player);
|
||||
}
|
||||
if (getZammyPlayers() <= 0 || getSaraPlayers() <= 0) {
|
||||
endGame();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Will add a cape to a player's equip
|
||||
*
|
||||
* @param player
|
||||
* the player
|
||||
* @param capeId
|
||||
* the capeId
|
||||
*/
|
||||
public static void addCapes(Client player, int capeId) {
|
||||
player.playerEquipment[player.playerCape] = capeId;
|
||||
player.playerEquipmentN[player.playerCape] = 1;
|
||||
player.getItemAssistant().updateSlot(player.playerCape);
|
||||
player.appearanceUpdateRequired = true;
|
||||
player.updateRequired = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method will delete all items received in game. Easy to add items to
|
||||
* the array. (:
|
||||
*
|
||||
* @param player
|
||||
* the player who want the game items deleted from.
|
||||
*/
|
||||
|
||||
public static void deleteGameItems(Client player) {
|
||||
switch (player.playerEquipment[3]) {
|
||||
case 4037:
|
||||
case 4039:
|
||||
player.playerEquipment[3] = -1;
|
||||
player.playerEquipmentN[3] = 0;
|
||||
player.getItemAssistant().updateSlot(player.playerWeapon);
|
||||
player.appearanceUpdateRequired = true;
|
||||
player.updateRequired = true;
|
||||
System.out.println(player.playerName + " removed weapon:"
|
||||
+ player.playerEquipment[3]);
|
||||
break;
|
||||
}
|
||||
switch (player.playerEquipment[1]) {
|
||||
case 4042:
|
||||
case 4041:
|
||||
player.playerEquipment[1] = -1;
|
||||
player.playerEquipmentN[1] = 0;
|
||||
player.getItemAssistant().updateSlot(player.playerCape);
|
||||
player.appearanceUpdateRequired = true;
|
||||
player.updateRequired = true;
|
||||
System.out.println(player.playerName + " removed cape: "
|
||||
+ player.playerEquipment[1]);
|
||||
break;
|
||||
}
|
||||
int[] items = { 4049, 1265, 4045, 4053, 4042, 4041, 4037, 4039, 4043 };
|
||||
//4049, 4045, 4053, 4042, 4041, 4037, 4039
|
||||
for (int item : items) {
|
||||
if (player.getItemAssistant().playerHasItem(item)) {
|
||||
player.getItemAssistant().deleteItem2(item,
|
||||
player.getItemAssistant().getItemAmount(item));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Methode we use to get the zamorak players
|
||||
*
|
||||
* @return the amount of players in the zamorakian team!
|
||||
*/
|
||||
public static int getZammyPlayers() {
|
||||
int players = 0;
|
||||
Iterator<Integer> iterator = !waitingRoom.isEmpty() ? waitingRoom
|
||||
.values().iterator() : gameRoom.values().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
if (iterator.next() == 2) {
|
||||
players++;
|
||||
}
|
||||
}
|
||||
return players;
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use to get the saradomin players!
|
||||
*
|
||||
* @return the amount of players in the saradomin team!
|
||||
*/
|
||||
public static int getSaraPlayers() {
|
||||
int players = 0;
|
||||
Iterator<Integer> iterator = !waitingRoom.isEmpty() ? waitingRoom
|
||||
.values().iterator() : gameRoom.values().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
if (iterator.next() == 1) {
|
||||
players++;
|
||||
}
|
||||
}
|
||||
return players;
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use for checking if the player is in the gameRoom
|
||||
*
|
||||
* @param player
|
||||
* player who will be checking
|
||||
* @return
|
||||
*/
|
||||
public static boolean isInCw(Player player) {
|
||||
return gameRoom.containsKey(player);
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use for checking if the player is in the waitingRoom
|
||||
*
|
||||
* @param player
|
||||
* player who will be checking
|
||||
* @return
|
||||
*/
|
||||
public static boolean isInCwWait(Player player) {
|
||||
return waitingRoom.containsKey(player);
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to make sara flag change status 0 = safe, 1 = taken, 2 = dropped
|
||||
*
|
||||
* @param status
|
||||
*/
|
||||
public static void setSaraFlag(int status) {
|
||||
saraFlag = status;
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to make zammy flag change status 0 = safe, 1 = taken, 2 = dropped
|
||||
*
|
||||
* @param status
|
||||
*/
|
||||
public static void setZammyFlag(int status) {
|
||||
zammyFlag = status;
|
||||
}
|
||||
|
||||
/**
|
||||
* Method we use for the changing the object of the flag stands when
|
||||
* capturing/returning flag
|
||||
*
|
||||
* @param objectId
|
||||
* the object
|
||||
* @param team
|
||||
* the team of the player
|
||||
*/
|
||||
public static void changeFlagObject(int objectId, int team) {
|
||||
Iterator<Client> iterator = gameRoom.keySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Client teamPlayer = iterator.next();
|
||||
teamPlayer.getActionSender().object(objectId,
|
||||
FLAG_STANDS[team][0], FLAG_STANDS[team][1], 0, 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
package redone.game.content.minigames.trawler;
|
||||
|
||||
public abstract class GroupMinigame {
|
||||
|
||||
public abstract WaitingRoom getWaitingRoom();
|
||||
|
||||
public abstract String getWaitingRoomMessage();
|
||||
|
||||
}
|
||||
@@ -0,0 +1,879 @@
|
||||
package redone.game.content.minigames.trawler;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Random;
|
||||
|
||||
import redone.Server;
|
||||
import redone.event.CycleEvent;
|
||||
import redone.event.CycleEventContainer;
|
||||
import redone.event.CycleEventHandler;
|
||||
import redone.game.content.skills.SkillHandler;
|
||||
import redone.game.items.GameItem;
|
||||
import redone.game.players.Client;
|
||||
import redone.game.players.Player;
|
||||
|
||||
public class Trawler extends GroupMinigame {
|
||||
|
||||
/*
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* The waiting room for the minigame
|
||||
*/
|
||||
|
||||
public WaitingRoom waiting_room = new TrawlerWaitingRoom(this);
|
||||
|
||||
/*
|
||||
* The arraylist containing all of the players
|
||||
*/
|
||||
|
||||
public ArrayList<Client> players = new ArrayList<Client>();
|
||||
|
||||
/*
|
||||
* The arraylist containing all of the players that need to removed Created
|
||||
* so that an instance wouldn't have to be created every time the updating
|
||||
* is called simply just call the clear method
|
||||
*/
|
||||
|
||||
public ArrayList<Client> players_to_remove = new ArrayList<Client>();
|
||||
|
||||
/*
|
||||
* A unique id, which the cycle event handler may use to stop the trawlers
|
||||
* event
|
||||
*/
|
||||
|
||||
public static final int CYCLE_ID = 222;
|
||||
|
||||
/*
|
||||
* Random object
|
||||
*/
|
||||
|
||||
private final Random random_gen = new Random();
|
||||
|
||||
/*
|
||||
* All of the animations needed for the minigame
|
||||
*/
|
||||
|
||||
final int climb_up = 828;
|
||||
final int climb_down = 827;
|
||||
final int swimming_walk = 772;
|
||||
final int swimming_stand = 773;
|
||||
final int net_interaction = 832;
|
||||
final int SWIM_MOVEMENT_ANIMATION = 772;
|
||||
final int SWIM_STILL_ANIMATION = 773;
|
||||
|
||||
/*
|
||||
* All of the items needed for the minigame
|
||||
*/
|
||||
|
||||
final int bailing_bucket_full = 585;
|
||||
final int bailing_bucket_empty = 583;
|
||||
final int rope = 954;
|
||||
final int swamp_paste = 1941;
|
||||
|
||||
/*
|
||||
* All of the objects needed for the minigame
|
||||
*/
|
||||
|
||||
final int perfect_wall = 2177;
|
||||
final int patched_wall = 2168;
|
||||
final int leaking_wall = 2167;
|
||||
|
||||
/*
|
||||
* Variables that will be changing as the minigame progresses
|
||||
*/
|
||||
|
||||
private int water_level = 0;
|
||||
private boolean net_ripped = false;
|
||||
public int fish_caught = 0;
|
||||
private boolean[] wall_status = new boolean[16];
|
||||
private boolean isSunk = false;
|
||||
private int game_time = 10;
|
||||
private boolean started = false;
|
||||
boolean in_progress = false;
|
||||
|
||||
/*
|
||||
* Contains the coordinates for each wall, since all of the objects of the
|
||||
* same id's and the methods needed to get them
|
||||
*/
|
||||
|
||||
public enum Wall {
|
||||
|
||||
North_One_Normal(0, 1885, 4826), North_Two_Normal(1, 1886, 4826), North_Three_Normal(
|
||||
2, 1887, 4826), North_Four_Normal(3, 1888, 4826), North_Five_Normal(
|
||||
4, 1889, 4826), North_Six_Normal(5, 1890, 4826), North_Seven_Normal(
|
||||
6, 1891, 4826), North_Eight_Normal(7, 1892, 4826), South_One_Normal(
|
||||
8, 1885, 4823), South_Two_Normal(9, 1886, 4823), South_Three_Normal(
|
||||
10, 1887, 4823), South_Four_Normal(11, 1888, 4823), South_Five_Normal(
|
||||
12, 1889, 4823), South_Six_Normal(13, 1890, 4823), South_Seven_Normal(
|
||||
14, 1891, 4823), South_Eight_Normal(15, 1892, 4823), North_One_Sinking(
|
||||
0, 2013, 4826), North_Two_Sinking(1, 2014, 4826), North_Three_Sinking(
|
||||
2, 2015, 4826), North_Four_Sinking(3, 2016, 4826), North_Five_Sinking(
|
||||
4, 2017, 4826), North_Six_Sinking(5, 2018, 4826), North_Seven_Sinking(
|
||||
6, 2019, 4826), North_Eight_Sinking(7, 2020, 4826), South_One_Sinking(
|
||||
8, 2013, 4823), South_Two_Sinking(9, 2014, 4823), South_Three_Sinking(
|
||||
10, 2015, 4823), South_Four_Sinking(11, 2016, 4823), South_Five_Sinking(
|
||||
12, 2017, 4823), South_Six_Sinking(13, 2018, 4823), South_Seven_Sinking(
|
||||
14, 2019, 4823), South_Eight_Sinking(15, 2020, 4823);
|
||||
|
||||
int index, x, y;
|
||||
|
||||
Wall(int index, int x, int y) {
|
||||
this.index = index;
|
||||
this.y = y;
|
||||
this.x = x;
|
||||
}
|
||||
|
||||
public static int getIndex(int x, int y) {
|
||||
for (Wall s : Wall.values()) {
|
||||
if (s != null) {
|
||||
if (s.x == x && s.y == y) {
|
||||
return s.index;
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
public static Wall getWallByIndex(int index, boolean sinking) {
|
||||
for (Wall w : Wall.values()) {
|
||||
if (w.index == index) {
|
||||
if (sinking && w.x < 2000) {
|
||||
continue;
|
||||
} else {
|
||||
return w;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* Gets the amount of walls that are not broken
|
||||
*/
|
||||
|
||||
public int getAvaliableWallSize() {
|
||||
int toReturn = 0;
|
||||
for (int j = 0; j < wall_status.length; j++) {
|
||||
if (wall_status[j] == false) {
|
||||
toReturn++;
|
||||
}
|
||||
}
|
||||
return toReturn;
|
||||
}
|
||||
|
||||
/*
|
||||
* Generates the indexes of the walls that are not broken
|
||||
*/
|
||||
|
||||
public int[] getAvaliableWalls() {
|
||||
int[] toReturn = new int[getAvaliableWallSize()];
|
||||
int index = 0;
|
||||
for (int j = 0; j < wall_status.length; j++) {
|
||||
if (wall_status[j] == false) {
|
||||
toReturn[index] = j;
|
||||
index++;
|
||||
}
|
||||
}
|
||||
return toReturn;
|
||||
}
|
||||
|
||||
/*
|
||||
* Sets a random wall as broken & updates it
|
||||
*/
|
||||
|
||||
public void breakRandomWall() {
|
||||
try {
|
||||
final int[] walls = getAvaliableWalls();
|
||||
int random = walls[random_gen.nextInt(walls.length)];
|
||||
wall_status[random] = true;
|
||||
updateWall(random);
|
||||
} catch (Exception e) {// Exception should never occur
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Removes every wall and resets them back to default
|
||||
*/
|
||||
|
||||
public void resetWalls() {
|
||||
for(Wall w : Wall.values()) {
|
||||
if(w != null) {
|
||||
Server.objectHandler.removeObject(Server.objectHandler.getObjectByPosition(w.x, w.y));
|
||||
Server.objectHandler.createAnObject(perfect_wall, w.x,w.y, w.y == 4826 ? 1 : 3);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Updates a wall based on index
|
||||
*/
|
||||
|
||||
public void updateWall(int index) {
|
||||
Wall w = Wall.getWallByIndex(index, isSunk);
|
||||
if (w == null) {
|
||||
System.out.println("null");
|
||||
return;
|
||||
}
|
||||
Server.objectHandler.removeObject(Server.objectHandler.getObjectByPosition(w.x, w.y));
|
||||
Server.objectHandler.removeObject(Server.objectHandler.getObjectByPosition(w.x + (isSunk ? -128 : 128), w.y));
|
||||
if (wall_status[index] == true) {
|
||||
Server.objectHandler.createAnObject(leaking_wall, w.x, w.y,
|
||||
w.y == 4826 ? 1 : 3);
|
||||
if (isSunk)
|
||||
Server.objectHandler.createAnObject(leaking_wall, w.x - 128,
|
||||
w.y, w.y == 4826 ? 1 : 3);
|
||||
else
|
||||
Server.objectHandler.createAnObject(leaking_wall, w.x + 128,
|
||||
w.y, w.y == 4826 ? 1 : 3);
|
||||
} else {
|
||||
Server.objectHandler.createAnObject(patched_wall, w.x, w.y,
|
||||
w.y == 4826 ? 1 : 3);
|
||||
if (isSunk)
|
||||
Server.objectHandler.createAnObject(patched_wall, w.x - 128,
|
||||
w.y, w.y == 4826 ? 1 : 3);
|
||||
else
|
||||
Server.objectHandler.createAnObject(patched_wall, w.x + 128,
|
||||
w.y, w.y == 4826 ? 1 : 3);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Updates every play in the game's interface, if the player is null they
|
||||
* are removed from the game
|
||||
*/
|
||||
|
||||
public void playerUpdates() {
|
||||
for (Client p : players) {
|
||||
if (p != null) {
|
||||
p.asClient()
|
||||
.getPlayerAssistant()
|
||||
.sendFrame126(net_ripped ? "@red@Ripped" : "@gre@Okay",
|
||||
11935);
|
||||
p.getPlayerAssistant().sendFrame126("" + fish_caught, 11937);
|
||||
p.getPlayerAssistant().sendFrame126(game_time + " mins", 11938);
|
||||
p.getPlayerAssistant().sendFrame20(391, water_level);
|
||||
} else {
|
||||
players_to_remove.add(p);
|
||||
}
|
||||
}
|
||||
if (players_to_remove.size() > 0) {
|
||||
for (Player p : players_to_remove) {
|
||||
players.remove(p);
|
||||
}
|
||||
players_to_remove.clear();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Does everything needed when the game starts
|
||||
*/
|
||||
|
||||
public void onStart() {
|
||||
resetWalls();
|
||||
waiting_room.setActive(false);
|
||||
water_level = 0;
|
||||
fish_caught = 0;
|
||||
net_ripped = false;
|
||||
isSunk = false;
|
||||
started = false;
|
||||
game_time = 10;
|
||||
in_progress = true;
|
||||
for (int j = 0; j < wall_status.length; j++) {
|
||||
wall_status[j] = false;
|
||||
}
|
||||
playerUpdates();
|
||||
for (Client p : players) {
|
||||
if (p != null) {
|
||||
p.getPlayerAssistant().removeAllSidebars();
|
||||
p.getPlayerAssistant().sendMapState(2);
|
||||
p.getPlayerAssistant().showInterface(3281);
|
||||
p.getPlayerAssistant().sendFrame20(75, 11);
|
||||
p.getPlayerAssistant().movePlayer(1885, 4825, 1);
|
||||
p.getPlayerAssistant().sendFrame126("", 11936);
|
||||
}
|
||||
}
|
||||
CycleEventHandler.getSingleton().addEvent(this, new CycleEvent() {
|
||||
@Override
|
||||
public void execute(CycleEventContainer container) {
|
||||
container.stop();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void stop() {
|
||||
for (Client p : players) {
|
||||
if (p != null) {
|
||||
p.getPlayerAssistant().sendSidebars();
|
||||
p.getPlayerAssistant().showInterface(5596);
|
||||
p.getPlayerAssistant().sendMapState(0);
|
||||
}
|
||||
}
|
||||
started = true;
|
||||
startGameTimer();
|
||||
}
|
||||
}, 25);
|
||||
}
|
||||
|
||||
/*
|
||||
* Does everything needed when the game ends
|
||||
*/
|
||||
|
||||
public void onEndLose() {
|
||||
for (Client p : players) {
|
||||
if (p != null) {
|
||||
p.getPlayerAssistant().movePlayer(1885, 4825, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Essentially starts the game
|
||||
*/
|
||||
|
||||
public void start() {
|
||||
|
||||
CycleEventHandler.getSingleton().stopEvents(CYCLE_ID);// Stops any other
|
||||
// events using
|
||||
// the trawler's
|
||||
// id
|
||||
onStart();
|
||||
CycleEventHandler.getSingleton().addEvent(this, new CycleEvent() {
|
||||
@Override
|
||||
public void execute(CycleEventContainer container) {
|
||||
if (started) {
|
||||
tick();
|
||||
if (end() > 0) {
|
||||
if (end() == 1) {
|
||||
setSwimmingAnimations();// Loss
|
||||
movePlayersLoss();
|
||||
players.clear();
|
||||
container.stop();
|
||||
} else if (end() == 2) {
|
||||
for (Client p : players) {
|
||||
if (p != null) {
|
||||
p.fishingTrawlerReward = playerReward(p);
|
||||
}
|
||||
}
|
||||
movePlayerWin(players);
|
||||
container.stop();
|
||||
}
|
||||
container.stop();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void stop() {
|
||||
waiting_room.reset();
|
||||
waiting_room.setActive(true);
|
||||
in_progress = false;
|
||||
game_time = 0;
|
||||
players.clear();
|
||||
//System.out.println("should start again now");
|
||||
waiting_room.startWaiting();
|
||||
}
|
||||
}, 10);
|
||||
}
|
||||
|
||||
/*
|
||||
* Everything that should be done on one tick of the minigame
|
||||
*/
|
||||
|
||||
public void tick() {
|
||||
int random;
|
||||
random = random_gen.nextInt(2) + 1;
|
||||
for (int j = 0; j < random; j++) {
|
||||
breakRandomWall();
|
||||
}
|
||||
ripNet();
|
||||
increaseWaterLevel();
|
||||
switchBoats();
|
||||
if (!net_ripped)
|
||||
increaseFish();
|
||||
playerUpdates();
|
||||
}
|
||||
|
||||
/*
|
||||
* Randomly breaks the net
|
||||
*/
|
||||
|
||||
public void ripNet() {
|
||||
if (!net_ripped) {
|
||||
if (random_gen.nextInt(10) > 7) {
|
||||
net_ripped = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Adds water depending on the amount of leaks in the ship
|
||||
*/
|
||||
|
||||
public void increaseWaterLevel() {
|
||||
int leaks = 16 - getAvaliableWalls().length;
|
||||
water_level += (leaks / 2) + random_gen.nextInt(leaks * random_gen.nextInt(2) + 1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Fixes the holes in the ship
|
||||
*/
|
||||
|
||||
public void fixHole(Client p, int x, int y) {
|
||||
if (doAction(p)) {
|
||||
if (p.getItemAssistant().playerHasItem(swamp_paste)) {
|
||||
int index = Wall.getIndex(x, y);
|
||||
if (index >= 0) {
|
||||
p.getItemAssistant().deleteItem2(swamp_paste, 1);
|
||||
p.startAnimation(832);
|
||||
wall_status[index] = false;
|
||||
updateWall(index);
|
||||
p.turnPlayerTo(x, y + (y == 4826 ? 1 : -1));
|
||||
}
|
||||
} else {
|
||||
p.getActionSender().sendMessage("You don't have any swamp paste.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Moves the player to the top of the boat
|
||||
*/
|
||||
|
||||
public void upLadder(Client p, int obX, int obY) {
|
||||
if (doAction(p)) {
|
||||
if (!isSunk) {
|
||||
p.startAnimation(climb_up);
|
||||
p.getPlayerAssistant()
|
||||
.movePlayer(obX == 1884 ? 1885 : 1892, obY, 1);
|
||||
} else {
|
||||
p.startAnimation(climb_up);
|
||||
p.getPlayerAssistant().movePlayer(obX == 2021 ? 2020 : 2013, obY, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Moves the player to the top of the boat
|
||||
*/
|
||||
|
||||
public void downLadder(Client p, int obX, int obY) {
|
||||
if (doAction(p)) {
|
||||
if (!isSunk) {
|
||||
p.startAnimation(climb_down);
|
||||
p.getPlayerAssistant()
|
||||
.movePlayer(obX == 1884 ? 1885 : 1892, obY, 0);
|
||||
} else {
|
||||
p.startAnimation(climb_down);
|
||||
p.getPlayerAssistant().movePlayer(obX == 2021 ? 2020 : 2013, obY, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Fixes the net on the ship
|
||||
*/
|
||||
|
||||
public void fixNet(Client p) {
|
||||
if (doAction(p)) {
|
||||
if (!net_ripped) {
|
||||
p.getActionSender().sendMessage("The net is not ripped.");
|
||||
return;
|
||||
}
|
||||
if (!p.getItemAssistant().playerHasItem(rope)) {
|
||||
p.getActionSender().sendMessage(
|
||||
"You need a rope before attempting to fix the net!");
|
||||
return;
|
||||
}
|
||||
p.startAnimation(net_interaction);
|
||||
if (skillCheck(p.playerLevel[p.playerCrafting], 1, 0)) {
|
||||
p.getItemAssistant().deleteItem(rope, 1);
|
||||
net_ripped = false;
|
||||
playerUpdates();
|
||||
p.getActionSender().sendMessage("You successfully fix the net!");
|
||||
} else {
|
||||
p.getItemAssistant().deleteItem(rope, 1);
|
||||
p.getActionSender().sendMessage("You failed to repair the net!");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns true if the player can complete the interaction
|
||||
*/
|
||||
|
||||
public boolean doAction(Player p) {
|
||||
if (!players.contains(p)) {
|
||||
return false;
|
||||
}
|
||||
if (System.currentTimeMillis() - p.lastFishingTrawlerInteraction >= 1600) {
|
||||
p.lastFishingTrawlerInteraction = System.currentTimeMillis();
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Bails water out of the boat
|
||||
*/
|
||||
|
||||
public void bail(Client p) {
|
||||
if (doAction(p)) {
|
||||
if (p.getItemAssistant().playerHasItem(bailing_bucket_empty)) {
|
||||
p.startAnimation(827);
|
||||
p.getItemAssistant()
|
||||
.replaceItem(bailing_bucket_empty, bailing_bucket_full);
|
||||
water_level -= random_gen.nextInt(3) + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Bails water out of the boat
|
||||
*/
|
||||
|
||||
public void emptyBucket(Client p) {
|
||||
if (doAction(p)) {
|
||||
if (p.getItemAssistant().playerHasItem(bailing_bucket_full)) {
|
||||
p.startAnimation(832);
|
||||
p.getItemAssistant()
|
||||
.replaceItem(bailing_bucket_full, bailing_bucket_empty);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Adds a random amount of fish to the total fish reaward, based off of the
|
||||
* amount of players in the game
|
||||
*/
|
||||
|
||||
public void increaseFish() {
|
||||
fish_caught += random_gen.nextInt(players.size() + 2);
|
||||
}
|
||||
|
||||
/*
|
||||
* If it returns true, the minigame will end
|
||||
*/
|
||||
|
||||
public int end() {
|
||||
if (players.size() == 0) {
|
||||
return 1;
|
||||
}
|
||||
if (water_level >= 100) {
|
||||
return 1;
|
||||
}
|
||||
if (game_time == 0) {
|
||||
return 2;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Sets the swimming animations
|
||||
*/
|
||||
|
||||
public void setSwimmingAnimations() {
|
||||
for(Client p : players) {
|
||||
if (p != null) {
|
||||
p.prevplayerWalkIndex = p.playerWalkIndex;
|
||||
p.prevPlayerStandIndex = p.playerStandIndex;
|
||||
p.prevPrevPlayerRunIndex = p.playerRunIndex;
|
||||
p.prevPlayerTurnIndex = p.playerTurnIndex;
|
||||
p.prevPlayerTurn180Index = p.playerTurn180Index;
|
||||
p.prevPlayerTurn90CCWIndex = p.playerTurn90CCWIndex;
|
||||
p.prevPlayerTurn90CWIndex = p.playerTurn90CWIndex;
|
||||
p.prevRunning2 = p.isRunning2;
|
||||
p.isRunning2 = false;
|
||||
p.playerRunIndex = SWIM_MOVEMENT_ANIMATION;
|
||||
p.playerStandIndex = SWIM_STILL_ANIMATION;
|
||||
p.playerWalkIndex = SWIM_MOVEMENT_ANIMATION;
|
||||
p.playerTurnIndex = SWIM_STILL_ANIMATION;
|
||||
p.playerTurn90CWIndex = SWIM_STILL_ANIMATION;
|
||||
p.playerTurn90CCWIndex = SWIM_STILL_ANIMATION;
|
||||
p.playerTurn180Index = SWIM_STILL_ANIMATION;
|
||||
p.getPlayerAssistant().requestUpdates();
|
||||
p.getPlayerAssistant().closeAllWindows();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Switches boats based on the water level
|
||||
*/
|
||||
|
||||
public void switchBoats() {
|
||||
if (water_level > 25 && !isSunk) {
|
||||
isSunk = true;
|
||||
for (int j = 0; j < players.size(); j++) {
|
||||
if (players.get(j) != null) {
|
||||
players.get(j).stopMovement();
|
||||
players.get(j).getPlayerAssistant()
|
||||
.movePlayer(players.get(j).absX + 128,
|
||||
players.get(j).absY,
|
||||
players.get(j).heightLevel);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (water_level <= 25 && isSunk) {
|
||||
isSunk = false;
|
||||
for (int j = 0; j < players.size(); j++) {
|
||||
if (players.get(j) != null) {
|
||||
players.get(j).stopMovement();
|
||||
players.get(j).getPlayerAssistant().
|
||||
movePlayer(players.get(j).absX - 128,
|
||||
players.get(j).absY,
|
||||
players.get(j).heightLevel);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Starts the timer for the game
|
||||
*/
|
||||
|
||||
public void startGameTimer() {
|
||||
CycleEventHandler.getSingleton().addEvent(this, new CycleEvent() {
|
||||
@Override
|
||||
public void execute(CycleEventContainer container) {
|
||||
if (game_time == 0) {
|
||||
container.stop();
|
||||
} else {
|
||||
game_time--;
|
||||
waiting_room.messageWaiting("The trawler will return in "+game_time+ (game_time == 1 ? " minute" : " minutes")+"!");
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void stop() {
|
||||
waiting_room.reset();
|
||||
waiting_room.setActive(true);
|
||||
in_progress = false;
|
||||
players.clear();
|
||||
waiting_room.startWaiting();
|
||||
}
|
||||
}, 80);
|
||||
}
|
||||
|
||||
/*
|
||||
* Slightly increases chance of higher level fish with levels
|
||||
*/
|
||||
|
||||
public int chanceByLevel(Player p, int fish) {
|
||||
switch (fish) {
|
||||
case 381:
|
||||
if (p.playerLevel[p.playerFishing] >= 81
|
||||
&& p.playerLevel[p.playerFishing] < 90) {
|
||||
return 5;
|
||||
} else if (p.playerLevel[p.playerFishing] >= 90
|
||||
&& p.playerLevel[p.playerFishing] < 99) {
|
||||
return 9;
|
||||
} else if (p.playerLevel[p.playerFishing] == 99) {
|
||||
return 13;
|
||||
}
|
||||
return 0;
|
||||
case 395:
|
||||
if (p.playerLevel[p.playerFishing] >= 79
|
||||
&& p.playerLevel[p.playerFishing] < 85) {
|
||||
return 8;
|
||||
} else if (p.playerLevel[p.playerFishing] >= 85
|
||||
&& p.playerLevel[p.playerFishing] < 95) {
|
||||
return 13;
|
||||
} else if (p.playerLevel[p.playerFishing] >= 95) {
|
||||
return 17;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Loss teleporting
|
||||
*/
|
||||
public void movePlayersLoss() {
|
||||
for (Client p : players) {
|
||||
if (p != null) {
|
||||
p.getPlayerAssistant().movePlayer(1952, 4826, 0);
|
||||
}
|
||||
}
|
||||
in_progress = false;
|
||||
game_time = 0;
|
||||
players.clear();
|
||||
waiting_room.startWaiting();
|
||||
}
|
||||
|
||||
/*
|
||||
* Win teleporting
|
||||
*/
|
||||
|
||||
public void movePlayerWin(final ArrayList<Client> pl) {
|
||||
for (Client p : pl) {
|
||||
if (p != null) {
|
||||
p.getPlayerAssistant().removeAllSidebars();
|
||||
p.getPlayerAssistant().sendMapState(2);
|
||||
p.getPlayerAssistant().showInterface(3281);
|
||||
p.getPlayerAssistant().sendFrame20(75, 12);
|
||||
p.getPlayerAssistant().movePlayer(2666, 3161, 0);
|
||||
//p.getPlayerAssistant().movePlayer(2804, 3421, 0);
|
||||
}
|
||||
}
|
||||
CycleEventHandler.getSingleton().addEvent(this, new CycleEvent() {
|
||||
@Override
|
||||
public void execute(CycleEventContainer container) {
|
||||
container.stop();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void stop() {
|
||||
for (Client p : pl) {
|
||||
if (p != null) {
|
||||
p.getPlayerAssistant().sendSidebars();
|
||||
p.getPlayerAssistant().sendMapState(0);
|
||||
p.getPlayerAssistant().closeAllWindows();
|
||||
}
|
||||
}
|
||||
in_progress = false;
|
||||
game_time = 0;
|
||||
players.clear();
|
||||
waiting_room.startWaiting();
|
||||
}
|
||||
}, 25);
|
||||
}
|
||||
|
||||
/*
|
||||
* Adds the rewards to each player
|
||||
*/
|
||||
|
||||
public ArrayList<GameItem> playerReward(Client p) {
|
||||
ArrayList<GameItem> toReturn = new ArrayList<GameItem>();
|
||||
boolean turtles = true;
|
||||
boolean mantas = true;
|
||||
boolean lobsters = true;
|
||||
boolean swordfish = true;
|
||||
int turt = 0;
|
||||
int manta = 0;
|
||||
int lobs = 0;
|
||||
int swordFish = 0;
|
||||
int junk = 0;
|
||||
int done = 0;
|
||||
while (done != fish_caught) {
|
||||
done++;
|
||||
int random = random_gen.nextInt(100);
|
||||
if (random >= 85 - chanceByLevel(p, 381)) {
|
||||
if (mantas) {
|
||||
manta++;
|
||||
}
|
||||
} else if (random >= 70 - chanceByLevel(p, 381)) {
|
||||
if (turtles) {
|
||||
turt++;
|
||||
}
|
||||
} else if (random >= 40) {
|
||||
if (swordfish) {
|
||||
swordFish++;
|
||||
}
|
||||
} else if (random >= 5) {
|
||||
if (lobsters) {
|
||||
lobs++;
|
||||
}
|
||||
} else {
|
||||
junk++;
|
||||
}
|
||||
}
|
||||
int xpToAdd = 0;
|
||||
if (manta > 0) {
|
||||
toReturn.add(new GameItem(389, manta));
|
||||
if (p.playerLevel[p.playerFishing] >= 81) {
|
||||
xpToAdd += (manta * 46 * SkillHandler.FISHING_EXPERIENCE);
|
||||
}
|
||||
}
|
||||
if (turt > 0) {
|
||||
toReturn.add(new GameItem(395, turt));
|
||||
if (p.playerLevel[p.playerFishing] >= 79) {
|
||||
xpToAdd += (manta * 38 * SkillHandler.FISHING_EXPERIENCE);
|
||||
}
|
||||
}
|
||||
if (lobs > 0) {
|
||||
toReturn.add(new GameItem(377, lobs));
|
||||
if (p.playerLevel[p.playerFishing] >= 40) {
|
||||
xpToAdd += (manta * 90 * SkillHandler.FISHING_EXPERIENCE);
|
||||
}
|
||||
}
|
||||
if (swordFish > 0) {
|
||||
toReturn.add(new GameItem(371, swordFish));
|
||||
if (p.playerLevel[p.playerFishing] >= 50) {
|
||||
xpToAdd += (manta * 100 * SkillHandler.FISHING_EXPERIENCE);
|
||||
}
|
||||
}
|
||||
if (junk > 0)
|
||||
toReturn.add(new GameItem(685, junk));
|
||||
p.getPlayerAssistant().addSkillXP(xpToAdd, p.playerFishing);
|
||||
return toReturn;
|
||||
}
|
||||
|
||||
/*
|
||||
* Randomly returns true, players craft level increases chance of returning
|
||||
* true
|
||||
*/
|
||||
|
||||
public boolean skillCheck(int level, int levelRequired, int itemBonus) {
|
||||
double chance = 0.0;
|
||||
double baseChance = Math.pow(10d - levelRequired / 10d, 2d) / 2d;
|
||||
chance = baseChance + ((level - levelRequired) / 2d)
|
||||
+ (itemBonus / 10d);
|
||||
return chance >= (new Random().nextDouble() * 100.0);
|
||||
}
|
||||
|
||||
@Override
|
||||
public WaitingRoom getWaitingRoom() {
|
||||
return waiting_room;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getWaitingRoomMessage() {
|
||||
return null;
|
||||
}
|
||||
|
||||
public boolean inProgress() {
|
||||
return in_progress;
|
||||
}
|
||||
|
||||
public int getGameTime() {
|
||||
return game_time;
|
||||
}
|
||||
|
||||
public void resetRewardsInterface(Client c) {
|
||||
for(int j = 0; j < 45; j++) {
|
||||
c.getPlayerAssistant().sendFrame34(-1, j, 4640, -1);
|
||||
}
|
||||
}
|
||||
public void showReward(Client c) {
|
||||
resetRewardsInterface(c);
|
||||
c.inFishingTrawlerRewardsInterface = true;
|
||||
c.getPlayerAssistant().showInterface(4564);
|
||||
for(int j = 0; j < c.fishingTrawlerReward.size(); j++) {
|
||||
c.getPlayerAssistant().sendFrame34(c.fishingTrawlerReward.get(j).id, j, 4640, c.fishingTrawlerReward.get(j).amount);
|
||||
}
|
||||
}
|
||||
|
||||
public void updateRewardSlot(Client c, int slot) {
|
||||
c.inFishingTrawlerRewardsInterface = true;
|
||||
c.getPlayerAssistant().sendFrame34(c.fishingTrawlerReward.get(slot).id, slot, 4640, c.fishingTrawlerReward.get(slot).amount);
|
||||
if(slot != 4 && c.fishingTrawlerReward.size() == 5) {
|
||||
c.getPlayerAssistant().sendFrame34(c.fishingTrawlerReward.get(4).id, 4, 4640, c.fishingTrawlerReward.get(4).amount);
|
||||
}
|
||||
}
|
||||
|
||||
public int getRewardSlot(int j) {
|
||||
if(j < 4) {
|
||||
return j;
|
||||
} else {
|
||||
return j+1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
package redone.game.content.minigames.trawler;
|
||||
|
||||
import redone.game.players.Client;
|
||||
import redone.game.players.Location;
|
||||
|
||||
public class TrawlerWaitingRoom extends WaitingRoom {
|
||||
|
||||
private Trawler trawler;
|
||||
private Location boat = new Location(2668,2674,3165,3185);
|
||||
//private Location boat = new Location(2808, 2811,3415,3425);
|
||||
|
||||
|
||||
public TrawlerWaitingRoom(Trawler trawler) {
|
||||
super(2, 1);
|
||||
this.trawler = trawler;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean startGame() {
|
||||
if(trawler.inProgress()) {
|
||||
return false;
|
||||
}
|
||||
if(waiting.size() < minimumPlayers) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onStart() {
|
||||
trawler.players.clear();
|
||||
/*for(Iterator<Player> i = waiting.iterator(); i.hasNext();) {
|
||||
Player p = i.next();
|
||||
if(!boat.playerInArea(p)) {
|
||||
i.remove(); // Allowed with an iterator
|
||||
}
|
||||
}*/
|
||||
|
||||
for(Client p : waiting) {
|
||||
trawler.players.add(p);
|
||||
}
|
||||
|
||||
trawler.start();
|
||||
waiting.clear();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onLeave(Client p) {
|
||||
//p.asClient().getPA().movePlayer(2804, 3421, 0);
|
||||
p.asClient().getPlayerAssistant().movePlayer(2676, 3170, 0);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onJoin(Client p) {
|
||||
//p.asClient().getPA().movePlayer(2808, 3421, 1);
|
||||
p.getPlayerAssistant().movePlayer(2672, 3170, 1);
|
||||
if(!isActive()) {
|
||||
p.getActionSender().sendMessage(trawler.getGameTime() == 0 ? "The trawler will be returning in less than a minute!" : "The trawler will return in "+trawler.getGameTime() + (trawler.getGameTime() == 1 ? " minute" : " minutes")+"!");
|
||||
} else {
|
||||
p.getActionSender().sendMessage(getTimeRemaining() == 0 ? "The trawler will be leaving in less than a minute!" : "The trawler will leave in "+ getTimeRemaining() + (getTimeRemaining() == 1 ? " minute" : " minutes")+"!");
|
||||
}
|
||||
}
|
||||
|
||||
public Location getLocation() {
|
||||
return boat;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onTimeChange() {
|
||||
for(Client p : waiting) {
|
||||
if(!isActive()) {
|
||||
p.getActionSender().sendMessage(trawler.getGameTime() == 0 ? "The trawler will be returning in less than a minute!" : "The trawler will return in "+trawler.getGameTime() + (trawler.getGameTime() == 1 ? " minute" : " minutes")+"!");
|
||||
} else {
|
||||
p.getActionSender().sendMessage(getTimeRemaining() == 0 ? "The trawler will be leaving in less than a minute!" : "The trawler will leave in "+ getTimeRemaining() + (getTimeRemaining() == 1 ? " minute" : " minutes")+"!");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canStart() {
|
||||
if(trawler.inProgress()) {
|
||||
return false;
|
||||
}
|
||||
if(waiting.size() < minimumPlayers) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
package redone.game.content.minigames.trawler;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
import redone.event.CycleEvent;
|
||||
import redone.event.CycleEventContainer;
|
||||
import redone.event.CycleEventHandler;
|
||||
import redone.game.players.Client;
|
||||
import redone.game.players.Location;
|
||||
|
||||
public abstract class WaitingRoom {
|
||||
|
||||
public int minimumPlayers;
|
||||
public ArrayList<Client> waiting = new ArrayList<Client>();
|
||||
private int wait_time;
|
||||
private int minutes_remaining;
|
||||
private boolean active;
|
||||
|
||||
public abstract Location getLocation();
|
||||
public abstract boolean startGame();
|
||||
public abstract void onStart();
|
||||
public abstract void onLeave(Client p);
|
||||
public abstract void onJoin(Client p);
|
||||
public abstract void onTimeChange();
|
||||
public abstract boolean canStart();
|
||||
|
||||
public WaitingRoom(int minutes, int minimum) {
|
||||
this.wait_time = minutes;
|
||||
this.minimumPlayers = minimum;
|
||||
this.minutes_remaining = wait_time;
|
||||
if(!firstStarted){
|
||||
startWaiting();
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
public void join(Client p) {
|
||||
if(!waiting.contains(p)) {
|
||||
onJoin(p);
|
||||
waiting.add(p);
|
||||
}
|
||||
}
|
||||
|
||||
public void leave(Client p) {
|
||||
if(waiting.contains(p)) {
|
||||
onLeave(p);
|
||||
waiting.remove(p);
|
||||
}
|
||||
}
|
||||
|
||||
public void reset() {
|
||||
minutes_remaining = wait_time;
|
||||
//startWaiting();
|
||||
}
|
||||
public static boolean firstStarted = false;
|
||||
|
||||
public void startWaiting() {
|
||||
if(isActive()) {
|
||||
return;
|
||||
}
|
||||
setActive(true);
|
||||
CycleEventHandler.getSingleton().addEvent(100, this, new CycleEvent() {
|
||||
@Override
|
||||
public void execute(CycleEventContainer container) {
|
||||
firstStarted = true;
|
||||
if(minutes_remaining != 0) {
|
||||
minutes_remaining--;
|
||||
onTimeChange();
|
||||
} else {
|
||||
if(startGame()) {
|
||||
onStart();
|
||||
reset();
|
||||
setActive(false);
|
||||
container.stop();
|
||||
} else {
|
||||
messageWaiting("A minimum of "+minimumPlayers+" players are needed to start this minigame!");
|
||||
reset();
|
||||
startWaiting();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void stop() {
|
||||
|
||||
}
|
||||
}, 80);
|
||||
}
|
||||
|
||||
|
||||
public void messageWaiting(String message) {
|
||||
for(Client p : waiting) {
|
||||
if(p != null) {
|
||||
p.getActionSender().sendMessage(message);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isActive() {
|
||||
return active;
|
||||
}
|
||||
|
||||
public void setActive(boolean active) {
|
||||
this.active = active;
|
||||
}
|
||||
|
||||
public int getTimeRemaining() {
|
||||
return minutes_remaining;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user