Ceikry
a100affda2
Unified kotlin and java into just src/main Unified the rs09 and core packages Took all content out of the core package, and placed it into the new content package Reorganised all source code relating to content to be easier to find and explore
407 lines
12 KiB
Java
407 lines
12 KiB
Java
package content.global.skill.slayer;
|
|
|
|
import core.cache.def.impl.ItemDefinition;
|
|
import core.cache.def.impl.NPCDefinition;
|
|
import core.game.component.Component;
|
|
import core.game.component.ComponentDefinition;
|
|
import core.game.component.ComponentPlugin;
|
|
import core.game.node.entity.skill.Skills;
|
|
import core.game.interaction.NodeUsageEvent;
|
|
import core.game.interaction.OptionHandler;
|
|
import core.game.interaction.UseWithHandler;
|
|
import core.game.node.Node;
|
|
import core.game.node.entity.player.Player;
|
|
import core.game.node.item.Item;
|
|
import core.plugin.Initializable;
|
|
import core.plugin.Plugin;
|
|
import core.plugin.ClassScanner;
|
|
|
|
/**
|
|
* Handles the slayer reward interface plugin.
|
|
* @author Vexia
|
|
*
|
|
*/
|
|
@Initializable
|
|
public class SlayerRewardPlugin extends ComponentPlugin {
|
|
|
|
/**
|
|
* The assignment component tab.
|
|
*/
|
|
private static final Component ASSIGNMENT = new Component(161);
|
|
|
|
/**
|
|
* The learn component tab.
|
|
*/
|
|
private static final Component LEARN = new Component(163);
|
|
|
|
/**
|
|
* The buy component tab.
|
|
*/
|
|
private static final Component BUY = new Component(164);
|
|
|
|
@Override
|
|
public Plugin<Object> newInstance(Object arg) throws Throwable {
|
|
ComponentDefinition.forId(161).setPlugin(this);//assignment
|
|
ComponentDefinition.forId(163).setPlugin(this);//learn
|
|
ComponentDefinition.forId(164).setPlugin(this);//buy
|
|
ClassScanner.definePlugins(new SlayerMasterPlugin(), new SlayerHelmCraftPlugin());
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public void open(Player player, Component open) {
|
|
updateInterface(player, open);
|
|
}
|
|
|
|
@Override
|
|
public boolean handle(Player player, Component component, int opcode, int button, int slot, int itemId) {
|
|
switch (component.getId()) {
|
|
case 161://asignment
|
|
switch (button) {
|
|
case 23://reassign
|
|
case 26:
|
|
if (!SlayerManager.getInstance(player).hasTask()) {
|
|
player.sendMessage("You don't have an active task right now.");
|
|
break;
|
|
}
|
|
if (purchase(player, 30)) {
|
|
SlayerManager.getInstance(player).clear();
|
|
player.sendMessage("You have canceled your current task.");
|
|
}
|
|
break;
|
|
case 24:
|
|
case 27:
|
|
if (SlayerManager.getInstance(player).getTask() == null) {
|
|
player.sendMessage("You don't have a slayer task.");
|
|
break;
|
|
}
|
|
if (SlayerManager.getInstance(player).getRemoved().size() >= 4) {
|
|
player.sendMessage("You can't remove anymore tasks.");
|
|
break;
|
|
}
|
|
if (SlayerManager.getInstance(player).getSlayerPoints() >= 30 && !player.isAdmin()) {
|
|
int size = SlayerManager.getInstance(player).getRemoved().size();
|
|
int qp = player.getQuestRepository().getAvailablePoints();
|
|
if (size == 0 && qp < 50) {
|
|
player.sendMessage("You need 50 quest points as a requirement in order to block one task.");
|
|
break;
|
|
} else if (size == 1 && qp < 100) {
|
|
player.sendMessage("You need 100 quest points as a requirement in order to block two tasks.");
|
|
break;
|
|
} else if (size == 2 && qp < 150) {
|
|
player.sendMessage("You need 150 quest points as a requirement in order to block three tasks.");
|
|
break;
|
|
} else if (size == 3 && qp < 200) {
|
|
player.sendMessage("You need 200 quest points as a requirement in order to block four tasks.");
|
|
break;
|
|
}
|
|
}
|
|
if (purchase(player, 100)) {
|
|
SlayerManager.getInstance(player).getRemoved().add(SlayerManager.getInstance(player).getTask());
|
|
SlayerManager.getInstance(player).clear();
|
|
updateInterface(player, player.getInterfaceManager().getOpened());
|
|
}
|
|
break;
|
|
case 36:
|
|
case 37:
|
|
case 38:
|
|
case 39:
|
|
int index = 3 - (39 - button);
|
|
if (SlayerManager.getInstance(player).getRemoved().isEmpty() || index > SlayerManager.getInstance(player).getRemoved().size() - 1 || SlayerManager.getInstance(player).getRemoved().get(index) == null) {
|
|
break;
|
|
}
|
|
SlayerManager.getInstance(player).getRemoved().remove(index);
|
|
updateInterface(player, player.getInterfaceManager().getOpened());
|
|
break;
|
|
case 15:
|
|
openTab(player, BUY);
|
|
break;
|
|
case 14:
|
|
openTab(player, LEARN);
|
|
break;
|
|
}
|
|
break;
|
|
case 163://learn
|
|
switch (button) {
|
|
case 14:
|
|
openTab(player, ASSIGNMENT);
|
|
break;
|
|
case 15:
|
|
openTab(player, BUY);
|
|
break;
|
|
case 22://Broad arrows
|
|
case 29:
|
|
if (SlayerManager.getInstance(player).flags.isBroadsUnlocked()) {
|
|
player.sendMessage("You don't need to learn this ability again.");
|
|
break;
|
|
}
|
|
if (purchase(player, 300)) {
|
|
SlayerManager.getInstance(player).flags.unlockBroads();
|
|
updateInterface(player, component);
|
|
}
|
|
break;
|
|
case 23://Slayer ring
|
|
case 30:
|
|
if (SlayerManager.getInstance(player).flags.isRingUnlocked()) {
|
|
player.sendMessage("You don't need to learn this ability again.");
|
|
break;
|
|
}
|
|
if (purchase(player, 300)) {
|
|
SlayerManager.getInstance(player).flags.unlockRing();
|
|
updateInterface(player, component);
|
|
}
|
|
break;
|
|
case 24://Slayer helm
|
|
case 31:
|
|
if (SlayerManager.getInstance(player).flags.isHelmUnlocked()) {
|
|
player.sendMessage("You don't need to learn this ability again.");
|
|
break;
|
|
}
|
|
if (purchase(player, 400)) {
|
|
SlayerManager.getInstance(player).flags.unlockHelm();
|
|
updateInterface(player, component);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case 164://buy
|
|
switch (button) {
|
|
case 16:
|
|
openTab(player, LEARN);
|
|
break;
|
|
case 17:
|
|
openTab(player, ASSIGNMENT);
|
|
break;
|
|
case 24://slayer exp
|
|
case 32:
|
|
if (purchase(player, 400)) {
|
|
player.getSkills().addExperience(Skills.SLAYER, 10000, false);
|
|
}
|
|
break;
|
|
case 26://ring of slaying
|
|
case 33:
|
|
if (player.getInventory().freeSlots() < 1 && SlayerManager.getInstance(player).getSlayerPoints() >= 75) {
|
|
player.sendMessage("You don't have enough inventory space.");
|
|
break;
|
|
}
|
|
if (purchase(player, 75)) {
|
|
player.getInventory().add(new Item(13281), player);
|
|
}
|
|
break;
|
|
case 28:
|
|
case 36:
|
|
if (purchase(player, 35)) {
|
|
player.getInventory().add(new Item(558, 1000), player);
|
|
player.getInventory().add(new Item(560, 250), player);
|
|
}
|
|
break;
|
|
case 34:
|
|
case 37:
|
|
if (purchase(player, 35)) {
|
|
player.getInventory().add(new Item(13280, 250), player);
|
|
}
|
|
break;
|
|
case 35:
|
|
case 39:
|
|
if (purchase(player, 35)) {
|
|
player.getInventory().add(new Item(4172, 250), player);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Purchases a slayer point reward.
|
|
* @param player The player.
|
|
* @param amount The amount of points.
|
|
* @return {@code True} if purchased.
|
|
*/
|
|
private boolean purchase(Player player, int amount) {
|
|
if (SlayerManager.getInstance(player).getSlayerPoints() < amount) {
|
|
player.sendMessage("You need " + amount + " slayer points in order to purchase this reward.");
|
|
return false;
|
|
}
|
|
SlayerManager.getInstance(player).setSlayerPoints(SlayerManager.getInstance(player).getSlayerPoints() - amount);
|
|
updateInterface(player, player.getInterfaceManager().getOpened());
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Switches the tab on the reward interface.
|
|
* @param player The player instance
|
|
* @param open The component to open.
|
|
*/
|
|
private void openTab(Player player, Component open) {
|
|
player.getInterfaceManager().open(open);
|
|
updateInterface(player, open);
|
|
}
|
|
|
|
/**
|
|
* Update the current points text.
|
|
* @param player the player.
|
|
* @param open the component.
|
|
*/
|
|
private void updateInterface(Player player, Component open) {
|
|
if (open == null) {
|
|
return;
|
|
}
|
|
String space = "";
|
|
String num = String.valueOf(SlayerManager.getInstance(player).getSlayerPoints());
|
|
if (num != "0") {
|
|
for (int i = 0; i < num.length(); i++) {
|
|
space += " ";
|
|
}
|
|
}
|
|
switch (open.getId()) {
|
|
case 161://assignment
|
|
int childs[] = new int[] {35, 30, 31, 32};
|
|
String[] letters = new String[] {"A", "B", "C", "D"};
|
|
Tasks task = null;
|
|
for (int i = 0; i < 4; i++) {
|
|
task = i > SlayerManager.getInstance(player).getRemoved().size() - 1 ? null : SlayerManager.getInstance(player).getRemoved().get(i);
|
|
player.getPacketDispatch().sendString(task == null ? letters[i] : task.getName(), open.getId(), childs[i]);
|
|
}
|
|
player.getPacketDispatch().sendString(space + SlayerManager.getInstance(player).getSlayerPoints(), open.getId(), 19);
|
|
break;
|
|
case 163://learn
|
|
for (int i = 0; i < 3; i++) {
|
|
switch(i){
|
|
case 0:
|
|
player.getPacketDispatch().sendInterfaceConfig(open.getId(), 25 + i, !SlayerManager.getInstance(player).flags.isBroadsUnlocked());
|
|
break;
|
|
case 1:
|
|
player.getPacketDispatch().sendInterfaceConfig(open.getId(), 25 + i, !SlayerManager.getInstance(player).flags.isRingUnlocked());
|
|
break;
|
|
case 2:
|
|
player.getPacketDispatch().sendInterfaceConfig(open.getId(), 25 + i, !SlayerManager.getInstance(player).flags.isHelmUnlocked());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
player.getPacketDispatch().sendString(space + SlayerManager.getInstance(player).getSlayerPoints(), open.getId(), 18);
|
|
break;
|
|
case 164://buy
|
|
player.getPacketDispatch().sendString(space + SlayerManager.getInstance(player).getSlayerPoints(), open.getId(), 20);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handles the slayer master option plugin.
|
|
* @author Vexia
|
|
*
|
|
*/
|
|
public class SlayerMasterPlugin extends OptionHandler {
|
|
|
|
@Override
|
|
public Plugin<Object> newInstance(Object arg) throws Throwable {
|
|
for (Master m : Master.values()) {
|
|
NPCDefinition.forId(m.getNpc()).getHandlers().put("option:rewards", this);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public boolean handle(Player player, Node node, String option) {
|
|
openTab(player, BUY);
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Handles the crafting of a slayer helmet.
|
|
* @author Vexia
|
|
*
|
|
*/
|
|
public static class SlayerHelmCraftPlugin extends UseWithHandler {
|
|
|
|
/**
|
|
* The slayer helm item.
|
|
*/
|
|
private static final Item SLAYER_HELM = new Item(13263);
|
|
|
|
/**
|
|
* The spiny helmet.
|
|
*/
|
|
private static final Item SPINY_HELMET = new Item(4551);
|
|
|
|
/**
|
|
* The ingredients needed.
|
|
*/
|
|
private static final int[] INGREDIENTS = new int[] {4168, 4166, 4164, 8921};
|
|
|
|
/**
|
|
* Constructs a new {@Code SlayerHelmCraftPlugin} {@Code Object}
|
|
*/
|
|
public SlayerHelmCraftPlugin() {
|
|
super(INGREDIENTS);
|
|
}
|
|
|
|
@Override
|
|
public Plugin<Object> newInstance(Object arg) throws Throwable {
|
|
addHandler(SPINY_HELMET.getId(), ITEM_TYPE, this);
|
|
ClassScanner.definePlugin(new OptionHandler() {
|
|
|
|
@Override
|
|
public Plugin<Object> newInstance(Object arg) throws Throwable {
|
|
ItemDefinition.forId(SLAYER_HELM.getId()).getHandlers().put("option:disassemble", this);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public boolean handle(Player player, Node node, String option) {
|
|
if (player.getInventory().freeSlots() < 4) {
|
|
player.sendMessage("You don't have enough inventory space.");
|
|
return true;
|
|
}
|
|
player.lock(1);
|
|
if (player.getInventory().remove(node.asItem())) {
|
|
for (int id : INGREDIENTS) {
|
|
player.getInventory().add(new Item(id));
|
|
}
|
|
player.getInventory().add(SPINY_HELMET);
|
|
}
|
|
player.sendMessage("You dissasemble your Slayer helm.");
|
|
return true;
|
|
}
|
|
|
|
});
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public boolean handle(NodeUsageEvent event) {
|
|
final Player player = event.getPlayer();
|
|
if (player.getSkills().getStaticLevel(Skills.CRAFTING) < 55) {
|
|
player.sendMessage("You need a Crafting level of at least 55 in order to do this.");
|
|
return true;
|
|
}
|
|
if (!SlayerManager.getInstance(player).flags.isHelmUnlocked()) {
|
|
player.sendMessage("You need to unlock the ability to do that first.");
|
|
return true;
|
|
}
|
|
if (!player.getInventory().containItems(INGREDIENTS)) {
|
|
player.sendMessages("You need a nosepeg, facemask, earmuffs, spiny helmet, and a black mask in", "your inventory in order to construct a Slayer helm.");
|
|
return true;
|
|
}
|
|
player.lock(1);
|
|
if (player.getInventory().remove(SPINY_HELMET)) {
|
|
for (int id : INGREDIENTS) {
|
|
if (!player.getInventory().remove(new Item(id))) {
|
|
return true;
|
|
}
|
|
}
|
|
player.getInventory().add(SLAYER_HELM);
|
|
player.sendMessage("You combine the items into a Slayer helm.");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
}
|
|
}
|