I'll probably find out that this was released under someone else's name, but not using this anymore. Have at it.
Second Click Object
Code:
/** Thieving **/
case 6162:
case 6163:
case 6164:
Thieving.startThieving(player, objectType, obX, obY);
break;
Second Click NPC
Code:
case 1:
case 2:
case 3:
Thieving.startPickpocketAction(player, i);
break;
Stalls.java
Code:
package org.delrith.world.entity.player.skill.thieving;
/**
* @author Vili
*/
public enum Stalls {
/** Represents the values for Gem Stalls **/
GEM(6162, 1609, 1, 50.0),
/** Represents the values for Bakery Stalls **/
BAKERY(6163, 1891, 50, 125.0),
/** Represents the values for Silver Stalls **/
SILVER(6164, 2355, 75, 200.0);
/** Field Variables **/
private final int objectIdentifier, itemIdentifier, levelRequired;
private final double experience;
private Stalls(final int objectIdentifier, final int itemIdentifier,
final int levelRequired, final double experience) {
this.objectIdentifier = objectIdentifier;
this.itemIdentifier = itemIdentifier;
this.levelRequired = levelRequired;
this.experience = experience;
}
/**
* Public constructs objectIdentifier.
*
* @return
*/
public int getObject() {
return objectIdentifier;
}
/**
* Publicly constructs itemIdentifier.
*
* @return
*/
public int getItem() {
return itemIdentifier;
}
/**
* Publicly constructs levelRequired.
*
* @return
*/
public int getLevel() {
return levelRequired;
}
/**
* Publicly constructs experience.
*
* @return
*/
public double getExperience() {
return experience;
}
}
Thieving.java
Code:
package org.delrith.world.entity.player.skill.thieving;
import org.delrith.core.util.Misc;
import org.delrith.world.entity.Hit;
import org.delrith.world.entity.Hit.HitType;
import org.delrith.world.entity.player.Player;
import org.delrith.world.entity.player.skill.SkillHandler;
import org.delrith.world.event.WorldEvent;
import org.delrith.world.event.WorldEventContainer;
import org.delrith.world.event.WorldEventHandler;
/*
* @author Vili
*/
public class Thieving extends SkillHandler {
/**
* Calculates the rate of failure to pickpocket.
* @param player
* The player trying to pickpocket.
* @param npcId
* The npc taking action.
* @return
* The failure rate.
*/
private static int failureRate(final Player player, final int npcId) {
final Pickpocket pickpocket = Pickpocket.forId(npcId);
double npcFactor = pickpocket.getLevel() / 10;
double levelFactor = 100 / ((player.playerLevel[player.playerThieving] + 1) - pickpocket.getLevel());
return (int) Math.floor((levelFactor + npcFactor) / 2);
}
/**
* Checks if the player meets all requirements.
* @param player
* The player being checked.
* @param npcId
* The npc being checked by the player level.
* @return
* The outcome of the check.
*/
private static boolean meetsRequirements(final Player player, final int npcId) {
final Pickpocket pickpocket = Pickpocket.forId(npcId);
if (player.playerLevel[player.playerThieving] < pickpocket.getLevel()) {
player.sendMessage("You need a thieving level of " + pickpocket.getLevel() + " to pickpocket this npc.");
return false;
}
return true;
}
/**
* Handles the outcome of a successful pickpocket.
* @param player
* The player taking action.
* @param npcId
* The npc taking action.
*/
private static void handleSuccess(final Player player, final int npcId) {
final Pickpocket pickpocket = Pickpocket.forId(npcId);
int random = Misc.random(pickpocket.getProduct().length - 1);
player.getItems().addItem(pickpocket.getProduct()[random][0], pickpocket.getProduct()[random][1]);
player.getPA().addSkillXP((int) pickpocket.getExperience() , player.playerThieving);
}
/**
* Handles the outcome of a failed pickpocket.
* @param player
* The player failing.
* @param stunTime
* The time between being able to pickpocket again.
* @param damage
* The damage resulted in failing.
* @param npcId
* The npc stunning and damaging the player.
*/
private static void handleFailure(final Player player, final int stunTime, final int damage, int npcId) {
player.startAnimation(player.getCombat().getBlockEmote());
player.dealHit(new Hit(damage, HitType.NORMAL));
player.setHitUpdateRequired(true);
player.playerLevel[player.playerHitpoints] -= damage;
player.getPA().refreshSkill(player.playerHitpoints);
player.setIsStunned(true);
player.gfx100(80);
WorldEventHandler.getSingleton().addEvent(player, new WorldEvent() {
@Override
public void execute(WorldEventContainer container) {
if (System.currentTimeMillis() - player.lastStunned > stunTime) {
container.stop();
}
}
@Override
public void stop() {
player.setIsStunned(false);
resetSkill(player);
}
}, 2);
}
/**
* Handles the action of pickpocketing npc.
* @param player
* The player taking action.
* @param npcId
* The npc being taken action upon.
*/
public static void startPickpocketAction(final Player player, final int npcId) {
final Pickpocket pickpocket = Pickpocket.forId(npcId);
if (pickpocket == null)
return;
if (isBusy(player))
return;
if (player.getIsStunned())
return;
if (meetsRequirements(player, npcId)) {
player.startAnimation(881);
player.sendMessage("You attempt to pickpocket the npc.");
WorldEventHandler.getSingleton().addEvent(player, new WorldEvent() {
@Override
public void execute(WorldEventContainer container) {
setBusy(player, true);
player.startAnimation(881);
if (Misc.random(100) < failureRate(player, npcId)) {
player.sendMessage("You failed to pickpocket the npc.");
player.setSuccessfulThief(false);
container.stop();
} else {
player.setSuccessfulThief(true);
container.stop();
}
}
@Override
public void stop() {
resetSkill(player);
if (player.getSuccessfulThief()) {
handleSuccess(player, npcId);
player.sendMessage("You successfully pickpocket the npc.");
return;
} else if (!player.getSuccessfulThief()) {
handleFailure(player, pickpocket.getTimer() * 1000, pickpocket.getDamage(), npcId);
player.lastStunned = System.currentTimeMillis();
return;
}
}
}, 1);
}
}
/**
* Handles the action of Theiving Stalls.
*
* @param player
* The player thieving.
* @param objectIdentifier
* The object being thieved from.
* @param objectX
* The object X.
* @param objectY
* The object Y.
*/
public static void startThieving(final Player player,
final int objectIdentifier, final int objectX, final int objectY) {
if (isBusy(player)) {
return;
}
for (final Stalls stall : Stalls.values()) {
if (objectIdentifier == stall.getObject()) {
if (player.playerLevel[player.playerThieving] < stall
.getLevel()) {
player.sendMessage("You don't have the required level to do this.");
return;
} else if (player.getItems().freeSlots() == 0) {
player.sendMessage("You don't have enough space to do this.");
return;
}
if (System.currentTimeMillis() - player.lastThieve > 2500) {
player.startAnimation(832);
setBusy(player, true);
WorldEventHandler.getSingleton().addEvent(player,
new WorldEvent() {
int random = Misc.random(10);
@Override
public void execute(
WorldEventContainer container) {
player.startAnimation(832);
player.getPA()
.addSkillXP(
(player.playerRights >= 3
&& random == 1
&& player
.getItems()
.freeSlots() > 2 ? (stall
.getExperience() * 2)
: (stall.getExperience())),
player.playerThieving);
player.getItems()
.addItem(
stall.getItem(),
player.playerRights >= 3
&& random == 1
&& player
.getItems()
.freeSlots() > 2 ? 2
: 1);
player.sendMessage(player.playerRights >= 3
&& random == 1
&& player.getItems().freeSlots() > 2 ? "You managed to steal an extra gem because you're a donator."
: "You managed to steal a gem.");
player.lastThieve = System
.currentTimeMillis();
container.stop();
}
@Override
public void stop() {
resetSkill(player);
}
}, 1);
}
}
}
}
}
Code:
package org.delrith.world.entity.player.skill.thieving;
import java.util.HashMap;
import org.delrith.core.util.Misc;
public enum Pickpocket {
/** Represents the values for Men **/
MAN(new int[] { 1, 2, 3 }, new int[][] { {995, Misc.random(3) + 3} }, 1, 5, 1, 8.0);
/** Field Variables **/
private final int[] entityIdentifier;
private final int[][] entityYield;
private final int levelRequired, stunTimer, entityDamage;
private double experience;
/**
* Constructs the enumeration.
* @param entityIdentifier
* The entity being taken into action.
* @param entityYield
* The yield from taking action.
* @param levelRequired
* The level required to take action.
* @param stunTimer
* The timer for failing to take action.
* @param entityDamage
* The damage for failing the action.
* @param experience
* The experience received for taking action.
*/
private Pickpocket(final int[] entityIdentifier, final int[][] entityYield, final int levelRequired, final int stunTimer,
final int entityDamage, final double experience) {
this.entityIdentifier = entityIdentifier;
this.entityYield = entityYield;
this.levelRequired = levelRequired;
this.stunTimer = stunTimer;
this.entityDamage = entityDamage;
this.experience = experience;
}
/** Constructs a HashMap to populate **/
public static HashMap <Integer, Pickpocket> pickpocket = new HashMap <Integer, Pickpocket>();
/**
* Populates the HashMap.
*/
static {
for (Pickpocket p : Pickpocket.values()) {
for (int id : p.getNpc()) {
pickpocket.put(id, p);
}
}
}
/**
* Creates the instance.
* @param id
* The thing being instanced.
* @return
* The instance.
*/
public static Pickpocket forId(int id) {
return pickpocket.get(id);
}
/**
* Publicly constructs entityIdentiifer.
* @return
*/
public int[] getNpc() {
return entityIdentifier;
}
/**
* Publicly constructs entityYield.
* @return
*/
public int[][] getProduct() {
return entityYield;
}
/**
* Publicly constructs levelRequired.
* @return
*/
public int getLevel() {
return levelRequired;
}
/**
* Publicly constructs stunTimer.
* @return
*/
public int getTimer() {
return stunTimer;
}
/**
* Publicly constructs entityDamage.
* @return
*/
public int getDamage() {
return entityDamage;
}
/**
* Publicly constructs experience.
* @return
*/
public double getExperience() {
return experience;
}
}