mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-11 21:57:40 +00:00
Luis C.M
c8a8e866cb
-Added crossProduct(IPos), divide(scalar), and to/FromLong functions. NpcAPI: -Added getAllInBox(from,to) IBlock: -Added setPosition functions IBlock, IPos, IEntity, IWorld: -Added a readable toString() function
780 lines
23 KiB
Java
780 lines
23 KiB
Java
package noppes.npcs.scripted.entity;
|
|
|
|
import java.util.*;
|
|
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.player.EntityPlayerMP;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.stats.Achievement;
|
|
import net.minecraft.stats.StatBase;
|
|
import net.minecraft.stats.StatList;
|
|
import net.minecraft.util.ChatComponentTranslation;
|
|
import net.minecraft.util.ChatStyle;
|
|
import net.minecraft.util.ChunkCoordinates;
|
|
import net.minecraft.util.EnumChatFormatting;
|
|
import net.minecraft.world.WorldSettings;
|
|
import noppes.npcs.*;
|
|
import noppes.npcs.constants.EnumPacketClient;
|
|
import noppes.npcs.constants.EnumQuestType;
|
|
import noppes.npcs.containers.ContainerCustomGui;
|
|
import noppes.npcs.controllers.CustomGuiController;
|
|
import noppes.npcs.controllers.data.Dialog;
|
|
import noppes.npcs.controllers.DialogController;
|
|
import noppes.npcs.controllers.PixelmonHelper;
|
|
import noppes.npcs.controllers.data.PlayerData;
|
|
import noppes.npcs.controllers.PlayerDataController;
|
|
import noppes.npcs.controllers.data.PlayerDialogData;
|
|
import noppes.npcs.controllers.data.PlayerQuestData;
|
|
import noppes.npcs.controllers.data.Quest;
|
|
import noppes.npcs.controllers.QuestController;
|
|
import noppes.npcs.controllers.data.QuestData;
|
|
import noppes.npcs.entity.EntityDialogNpc;
|
|
import noppes.npcs.scripted.NpcAPI;
|
|
import noppes.npcs.scripted.ScriptPixelmonPlayerData;
|
|
import noppes.npcs.scripted.ScriptSound;
|
|
import noppes.npcs.scripted.constants.EntityType;
|
|
import noppes.npcs.scripted.gui.ScriptGui;
|
|
import noppes.npcs.scripted.interfaces.*;
|
|
import noppes.npcs.scripted.interfaces.handler.data.IDialog;
|
|
import noppes.npcs.scripted.interfaces.handler.data.IQuest;
|
|
import noppes.npcs.scripted.interfaces.gui.ICustomGui;
|
|
import noppes.npcs.scripted.interfaces.handler.data.ISound;
|
|
import noppes.npcs.scripted.interfaces.overlay.ICustomOverlay;
|
|
import noppes.npcs.scripted.interfaces.entity.IPlayer;
|
|
import noppes.npcs.scripted.interfaces.entity.IEntity;
|
|
import noppes.npcs.scripted.interfaces.handler.IOverlayHandler;
|
|
import noppes.npcs.scripted.interfaces.item.IItemStack;
|
|
import noppes.npcs.scripted.overlay.ScriptOverlay;
|
|
import noppes.npcs.util.ValueUtil;
|
|
|
|
public class ScriptPlayer<T extends EntityPlayerMP> extends ScriptLivingBase<T> implements IPlayer {
|
|
public T player;
|
|
private PlayerData data;
|
|
|
|
public ScriptPlayer(T player){
|
|
super(player);
|
|
this.player = player;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the displayed name of the player
|
|
*/
|
|
public String getDisplayName(){
|
|
return player.getDisplayName();
|
|
}
|
|
|
|
/**
|
|
* @return Returns the players name
|
|
*/
|
|
public String getName(){
|
|
return player.getCommandSenderName();
|
|
}
|
|
|
|
public void kick(String reason) {
|
|
player.playerNetServerHandler.kickPlayerFromServer(reason);
|
|
}
|
|
|
|
@Override
|
|
public void spawnParticle(IParticle entityParticle) {
|
|
entityParticle.spawnOnEntity(this);
|
|
}
|
|
|
|
@Override
|
|
public void setPosition(double x, double y, double z){
|
|
NoppesUtilPlayer.teleportPlayer(player, x, y, z, player.dimension);
|
|
}
|
|
public void setPos(double x, double y, double z) {
|
|
this.setPosition(x,y,z);
|
|
}
|
|
|
|
public void setPosition(IPos pos) {
|
|
this.setPosition(pos.getX(),pos.getY(),pos.getZ());
|
|
}
|
|
public void setPos(IPos pos) {
|
|
this.setPosition(pos);
|
|
}
|
|
|
|
public void setPosition(double x, double y, double z, int dimensionId) {
|
|
if (NpcAPI.Instance().getIWorld(dimensionId) == null)
|
|
return;
|
|
|
|
NoppesUtilPlayer.teleportPlayer(player, x, y, z, dimensionId);
|
|
}
|
|
public void setPos(double x, double y, double z, int dimensionId) {
|
|
this.setPosition(x,y,z,dimensionId);
|
|
}
|
|
public void setPosition(double x, double y, double z, IWorld world) {
|
|
this.setPosition(x,y,z,world.getDimensionID());
|
|
}
|
|
public void setPos(double x, double y, double z, IWorld world) {
|
|
this.setPos(x,y,z,world.getDimensionID());
|
|
}
|
|
|
|
public void setPosition(IPos pos, int dimensionId) {
|
|
this.setPosition(pos.getX(),pos.getY(),pos.getZ(), dimensionId);
|
|
}
|
|
public void setPos(IPos pos, int dimensionId) {
|
|
this.setPosition(pos,dimensionId);
|
|
}
|
|
public void setPosition(IPos pos, IWorld world) {
|
|
this.setPosition(pos.getX(),pos.getY(),pos.getZ(),world.getDimensionID());
|
|
}
|
|
public void setPos(IPos pos, IWorld world) {
|
|
this.setPosition(pos,world.getDimensionID());
|
|
}
|
|
|
|
public void setDimension(int dimension) {
|
|
this.setPosition(this.getPos(),dimension);
|
|
}
|
|
public void setDimension(IWorld world) {
|
|
this.setDimension(world.getDimensionID());
|
|
}
|
|
|
|
public int getHunger(){
|
|
return player.getFoodStats().getFoodLevel();
|
|
}
|
|
|
|
public void setHunger(int hunger){
|
|
int prevHunger = this.getHunger();
|
|
if(hunger < 0)
|
|
hunger = 0;
|
|
|
|
player.getFoodStats().addStats(hunger-prevHunger,0);
|
|
}
|
|
|
|
public float getSaturation(){
|
|
return player.getFoodStats().getSaturationLevel();
|
|
}
|
|
|
|
public void setSaturation(float saturation){
|
|
float prevSaturation = this.getHunger();
|
|
if(saturation < 0)
|
|
saturation = 0;
|
|
|
|
player.getFoodStats().addStats(0,saturation-prevSaturation);
|
|
}
|
|
|
|
public void showDialog(IDialog dialog) {
|
|
if (dialog != null) {
|
|
showDialog(dialog.getId());
|
|
}
|
|
}
|
|
|
|
public boolean hasReadDialog(IDialog dialog) {
|
|
if (dialog != null) {
|
|
return hasReadDialog(dialog.getId());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void readDialog(IDialog dialog) {
|
|
if (dialog != null) {
|
|
this.readDialog(dialog.getId());
|
|
}
|
|
}
|
|
|
|
public void unreadDialog(IDialog dialog) {
|
|
if (dialog != null) {
|
|
this.unreadDialog(dialog.getId());
|
|
}
|
|
}
|
|
|
|
public void showDialog(int id){
|
|
Dialog dialog = (Dialog) DialogController.instance.get(id);
|
|
if(dialog == null)
|
|
return;
|
|
|
|
NoppesUtilServer.openDialog(player, new EntityDialogNpc(this.player.worldObj), dialog, 0);
|
|
}
|
|
|
|
public boolean hasReadDialog(int id){
|
|
PlayerDialogData data = PlayerDataController.instance.getPlayerData(player).dialogData;
|
|
return data.dialogsRead.contains(id);
|
|
}
|
|
|
|
public void readDialog(int id) {
|
|
PlayerDataController.instance.getPlayerData(player).dialogData.dialogsRead.add(id);
|
|
}
|
|
|
|
public void unreadDialog(int id) {
|
|
PlayerDataController.instance.getPlayerData(player).dialogData.dialogsRead.remove(id);
|
|
}
|
|
|
|
public boolean hasFinishedQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return false;
|
|
return hasFinishedQuest(quest.getId());
|
|
}
|
|
|
|
public boolean hasActiveQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return false;
|
|
return hasActiveQuest(quest.getId());
|
|
}
|
|
|
|
public void startQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return;
|
|
startQuest(quest.getId());
|
|
}
|
|
|
|
public void finishQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return;
|
|
finishQuest(quest.getId());
|
|
}
|
|
|
|
public void stopQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return;
|
|
stopQuest(quest.getId());
|
|
}
|
|
|
|
public void removeQuest(IQuest quest) {
|
|
if (quest == null)
|
|
return;
|
|
removeQuest(quest.getId());
|
|
}
|
|
|
|
public boolean hasFinishedQuest(int id){
|
|
PlayerQuestData data = PlayerDataController.instance.getPlayerData(player).questData;
|
|
return data.finishedQuests.containsKey(id);
|
|
}
|
|
|
|
public boolean hasActiveQuest(int id){
|
|
PlayerQuestData data = PlayerDataController.instance.getPlayerData(player).questData;
|
|
return data.activeQuests.containsKey(id);
|
|
}
|
|
|
|
/**
|
|
* Add the quest from active quest list
|
|
* @param id The Quest ID
|
|
*/
|
|
public void startQuest(int id){
|
|
Quest quest = QuestController.instance.quests.get(id);
|
|
if (quest == null)
|
|
return;
|
|
PlayerData data = PlayerDataController.instance.getPlayerData(player);
|
|
if(data.questData.activeQuests.containsKey(id))
|
|
return;
|
|
QuestData questdata = new QuestData(quest);
|
|
data.questData.activeQuests.put(id, questdata);
|
|
Server.sendData((EntityPlayerMP)player, EnumPacketClient.MESSAGE, "quest.newquest", quest.title);
|
|
Server.sendData((EntityPlayerMP)player, EnumPacketClient.CHAT, "quest.newquest", ": ", quest.title);
|
|
}
|
|
|
|
/**
|
|
* Add the quest from finished quest list
|
|
* @param id The Quest ID
|
|
*/
|
|
public void finishQuest(int id){
|
|
Quest quest = QuestController.instance.quests.get(id);
|
|
if (quest == null)
|
|
return;
|
|
PlayerData data = PlayerDataController.instance.getPlayerData(player);
|
|
data.questData.finishedQuests.put(id, System.currentTimeMillis());
|
|
}
|
|
|
|
/**
|
|
* Removes the quest from active quest list
|
|
* @param id The Quest ID
|
|
*/
|
|
public void stopQuest(int id){
|
|
Quest quest = QuestController.instance.quests.get(id);
|
|
if (quest == null)
|
|
return;
|
|
PlayerData data = PlayerDataController.instance.getPlayerData(player);
|
|
data.questData.activeQuests.remove(id);
|
|
}
|
|
|
|
/**
|
|
* Removes the quest from active and finished quest list
|
|
* @param id The Quest ID
|
|
*/
|
|
public void removeQuest(int id){
|
|
Quest quest = QuestController.instance.quests.get(id);
|
|
if (quest == null)
|
|
return;
|
|
PlayerData data = PlayerDataController.instance.getPlayerData(player);
|
|
data.questData.activeQuests.remove(id);
|
|
data.questData.finishedQuests.remove(id);
|
|
}
|
|
|
|
@Override
|
|
public int getType(){
|
|
return EntityType.PLAYER;
|
|
}
|
|
|
|
@Override
|
|
public boolean typeOf(int type){
|
|
return type == EntityType.PLAYER?true:super.typeOf(type);
|
|
}
|
|
/**
|
|
* @param faction The faction id
|
|
* @param points The points to increase. Use negative values to decrease
|
|
*/
|
|
public void addFactionPoints(int faction, int points){
|
|
PlayerData data = PlayerDataController.instance.getPlayerData(player);
|
|
data.factionData.increasePoints(faction, points, player);
|
|
}
|
|
/**
|
|
* @param faction The faction id
|
|
* @param points The new point value for this faction
|
|
*/
|
|
public void setFactionPoints(int faction, int points) {
|
|
PlayerData data = PlayerDataController.instance.getPlayerData(player);
|
|
data.factionData.increasePoints(faction, points-getFactionPoints(faction), player);
|
|
}
|
|
|
|
/**
|
|
* @param faction The faction id
|
|
* @return points
|
|
*/
|
|
public int getFactionPoints(int faction) {
|
|
PlayerData data = PlayerDataController.instance.getPlayerData(player);
|
|
return data.factionData.getFactionPoints(faction);
|
|
}
|
|
|
|
public void sendMessage(String message){
|
|
player.addChatMessage(new ChatComponentTranslation(NoppesStringUtils.formatText(message,player)));
|
|
}
|
|
|
|
public void sendMessage(String message, String color, boolean bold, boolean italic, boolean underlined) {
|
|
sendMessage(message, color, bold, italic, underlined, false, false);
|
|
}
|
|
|
|
public void sendMessage(String message, String color, boolean bold, boolean italic, boolean obfuscated, boolean strikethrough, boolean underlined) {
|
|
EnumChatFormatting c = getColor(color);
|
|
|
|
if (c == null)
|
|
return;
|
|
|
|
ChatComponentTranslation chat = new ChatComponentTranslation(NoppesStringUtils.formatText(message,player));
|
|
ChatStyle style = new ChatStyle();
|
|
style.setColor(c);
|
|
style.setBold(bold);
|
|
style.setItalic(italic);
|
|
style.setObfuscated(obfuscated);
|
|
style.setStrikethrough(strikethrough);
|
|
style.setUnderlined(underlined);
|
|
chat.setChatStyle(style);
|
|
|
|
player.addChatMessage(chat);
|
|
}
|
|
|
|
private EnumChatFormatting getColor(String color) {
|
|
switch (color) {
|
|
case "black": return EnumChatFormatting.BLACK;
|
|
case "dark_blue": return EnumChatFormatting.DARK_BLUE;
|
|
case "dark_green": return EnumChatFormatting.DARK_GREEN;
|
|
case "dark_aqua": return EnumChatFormatting.DARK_AQUA;
|
|
case "dark_red": return EnumChatFormatting.DARK_RED;
|
|
case "dark_purple": return EnumChatFormatting.DARK_PURPLE;
|
|
case "gold": return EnumChatFormatting.GOLD;
|
|
case "gray": return EnumChatFormatting.GRAY;
|
|
case "dark_gray": return EnumChatFormatting.DARK_GRAY;
|
|
case "blue": return EnumChatFormatting.BLUE;
|
|
case "green": return EnumChatFormatting.GREEN;
|
|
case "aqua": return EnumChatFormatting.AQUA;
|
|
case "red": return EnumChatFormatting.RED;
|
|
case "light_purple": return EnumChatFormatting.LIGHT_PURPLE;
|
|
case "yellow": return EnumChatFormatting.YELLOW;
|
|
case "white": return EnumChatFormatting.WHITE;
|
|
default: return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return Return gamemode. 0: Survival, 1: Creative, 2: Adventure
|
|
*/
|
|
public int getMode(){
|
|
return player.theItemInWorldManager.getGameType().getID();
|
|
}
|
|
|
|
/**
|
|
* @param type The gamemode type. 0:SURVIVAL, 1:CREATIVE, 2:ADVENTURE
|
|
*/
|
|
public void setMode(int type){
|
|
player.setGameType(WorldSettings.getGameTypeById(type));
|
|
}
|
|
|
|
/**
|
|
* @since 1.7.10d
|
|
* @return Returns a IItemStack array size 36
|
|
*/
|
|
public IItemStack[] getInventory(){
|
|
IItemStack[] items = new IItemStack[36];
|
|
for(int i = 0; i < player.inventory.mainInventory.length; i++){
|
|
ItemStack item = player.inventory.mainInventory[i];
|
|
if(item != null)
|
|
items[i] = NpcAPI.Instance().getIItemStack(item);
|
|
}
|
|
return items;
|
|
}
|
|
|
|
public int inventoryItemCount(IItemStack item){
|
|
return inventoryItemCount(item, true, true);
|
|
}
|
|
|
|
/**
|
|
* @param item The item to be checked
|
|
* @return How many of this item the player has
|
|
*/
|
|
public int inventoryItemCount(IItemStack item, boolean ignoreNBT, boolean ignoreDamage) {
|
|
int i = 0;
|
|
for(ItemStack is : player.inventory.mainInventory){
|
|
if (is != null && NoppesUtilPlayer.compareItems(is, item.getMCItemStack(), ignoreDamage, ignoreNBT)) {
|
|
i += is.stackSize;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
/**
|
|
* @since 1.7.10c
|
|
* @param id The items name
|
|
* @param damage The damage value
|
|
* @param amount How many will be removed
|
|
* @return Returns true if the items were removed succesfully. Returns false incase a bigger amount than what the player has was given or item doesnt exist
|
|
*/
|
|
public boolean removeItem(String id, int damage, int amount){
|
|
Item item = (Item)Item.itemRegistry.getObject(id);
|
|
if(item == null)
|
|
return false;
|
|
return removeItem(NpcAPI.Instance().getIItemStack(new ItemStack(item, 1, damage)), amount);
|
|
}
|
|
|
|
public boolean removeItem(IItemStack item, int amount){
|
|
return removeItem(item, amount, true, true);
|
|
}
|
|
|
|
/**
|
|
* @param item The Item type to be removed
|
|
* @param amount How many will be removed
|
|
* @return Returns true if the items were removed succesfully. Returns false incase a bigger amount than what the player has was given
|
|
*/
|
|
public boolean removeItem(IItemStack item, int amount, boolean ignoreNBT, boolean ignoreDamage) {
|
|
int count = inventoryItemCount(item);
|
|
if(amount > count)
|
|
return false;
|
|
else if(count == amount)
|
|
removeAllItems(item);
|
|
else{
|
|
for(int i = 0; i < player.inventory.mainInventory.length; i++){
|
|
ItemStack is = player.inventory.mainInventory[i];
|
|
if (is != null && NoppesUtilPlayer.compareItems(is, item.getMCItemStack(), ignoreDamage, ignoreNBT)) {
|
|
if(amount > is.stackSize){
|
|
player.inventory.mainInventory[i] = null;
|
|
amount -= is.stackSize;
|
|
}
|
|
else{
|
|
is.splitStack(amount);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.updatePlayerInventory();
|
|
return true;
|
|
}
|
|
|
|
public void removeAllItems(IItemStack item){
|
|
removeAllItems(item, true, true);
|
|
}
|
|
|
|
/**
|
|
* @param item The item to be removed from the players inventory
|
|
*/
|
|
public int removeAllItems(IItemStack item, boolean ignoreNBT, boolean ignoreDamage){
|
|
int removed = 0;
|
|
|
|
for(int i = 0; i < player.inventory.mainInventory.length; i++) {
|
|
ItemStack is = player.inventory.mainInventory[i];
|
|
if (is != null && NoppesUtilPlayer.compareItems(is, item.getMCItemStack(), ignoreDamage, ignoreNBT)) {
|
|
player.inventory.mainInventory[i] = null;
|
|
removed++;
|
|
}
|
|
}
|
|
|
|
return removed;
|
|
}
|
|
|
|
/**
|
|
* @since 1.7.10c
|
|
* @param item Item to be added
|
|
* @param amount The amount of the item to be added
|
|
* @return Returns whether or not it gave the item succesfully
|
|
*/
|
|
public boolean giveItem(IItemStack item, int amount){
|
|
if(item != null && item.getMCItemStack() != null) {
|
|
item.setStackSize(amount);
|
|
boolean bool = this.player.inventory.addItemStackToInventory(item.getMCItemStack());
|
|
this.updatePlayerInventory();
|
|
return bool;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @since 1.7.10c
|
|
* @param id The items name
|
|
* @param damage The damage value
|
|
* @param amount The amount of the item to be added
|
|
* @return Returns whether or not it gave the item succesfully
|
|
*/
|
|
public boolean giveItem(String id, int damage, int amount){
|
|
Item item = (Item)Item.itemRegistry.getObject(id);
|
|
if(item == null)
|
|
return false;
|
|
return player.inventory.addItemStackToInventory(new ItemStack(item, amount, damage));
|
|
}
|
|
|
|
/**
|
|
* Same as the /spawnpoint command
|
|
* @param x The x position
|
|
* @param y The y position
|
|
* @param z The z position
|
|
*/
|
|
public void setSpawnpoint(int x, int y, int z){
|
|
x = ValueUtil.CorrectInt(x, -30000000, 30000000);
|
|
z = ValueUtil.CorrectInt(z, -30000000, 30000000);
|
|
y = ValueUtil.CorrectInt(y, 0, 256);
|
|
player.setSpawnChunk(new ChunkCoordinates(x, y, z), true);
|
|
}
|
|
|
|
public void setSpawnpoint(IPos pos){
|
|
this.setSpawnpoint(pos.getX(),pos.getY(),pos.getZ());
|
|
}
|
|
|
|
public void resetSpawnpoint(){
|
|
player.setSpawnChunk(null, false);
|
|
}
|
|
|
|
public void clearInventory() {
|
|
for(int i = 0; i < player.inventory.mainInventory.length; i++) player.inventory.mainInventory[i] = null;
|
|
for(int i = 0; i < player.inventory.armorInventory.length; i++) player.inventory.armorInventory[i] = null;
|
|
}
|
|
|
|
public void setRotation(float rotationYaw){
|
|
NoppesUtilPlayer.teleportPlayer(player, player.posX, player.posY, player.posZ, rotationYaw, player.rotationPitch, player.dimension);
|
|
}
|
|
|
|
public void setRotation(float rotationYaw, float rotationPitch){
|
|
NoppesUtilPlayer.teleportPlayer(player, player.posX, player.posY, player.posZ, rotationYaw, rotationPitch, player.dimension);
|
|
}
|
|
|
|
public void swingHand(){
|
|
NoppesUtilPlayer.swingPlayerArm(player);
|
|
}
|
|
|
|
public void disableMouseInput(long time, int... buttonIds) {
|
|
NoppesUtilPlayer.disableMouseInput(player ,time, buttonIds);
|
|
}
|
|
|
|
public void stopUsingItem(){
|
|
player.stopUsingItem();
|
|
}
|
|
|
|
public void clearItemInUse(){
|
|
player.clearItemInUse();
|
|
}
|
|
|
|
public void playSound(String name, float volume, float pitch){
|
|
player.playSound(name, volume, pitch);
|
|
}
|
|
|
|
public void playSound(int id, ISound sound) {
|
|
NoppesUtilPlayer.playSoundTo(player, id, (ScriptSound) sound);
|
|
}
|
|
|
|
public void stopSound(int id) {
|
|
NoppesUtilPlayer.stopSoundFor(player, id);
|
|
}
|
|
|
|
public void pauseSounds() {
|
|
NoppesUtilPlayer.pauseSoundsFor(player);
|
|
}
|
|
|
|
public void continueSounds() {
|
|
NoppesUtilPlayer.continueSoundsFor(player);
|
|
}
|
|
|
|
public void stopSounds() {
|
|
NoppesUtilPlayer.stopSoundsFor(player);
|
|
}
|
|
|
|
public void mountEntity(Entity ridingEntity){
|
|
player.mountEntity(ridingEntity);
|
|
}
|
|
|
|
public IEntity dropOneItem(boolean dropStack){
|
|
return NpcAPI.Instance().getIEntity(player.dropOneItem(dropStack));
|
|
}
|
|
|
|
public boolean canHarvestBlock(IBlock block){
|
|
return player.canHarvestBlock(block.getMCBlock());
|
|
}
|
|
|
|
public boolean interactWith(IEntity entity){
|
|
return player.interactWith(entity.getMCEntity());
|
|
}
|
|
|
|
/**
|
|
* @param achievement The achievement id. For a complete list see http://minecraft.gamepedia.com/Achievements
|
|
* @return Returns whether or not the player has this achievement
|
|
*/
|
|
public boolean hasAchievement(String achievement){
|
|
StatBase statbase = StatList.func_151177_a(achievement);
|
|
if(statbase == null || !(statbase instanceof Achievement)){
|
|
return false;
|
|
}
|
|
return player.func_147099_x().hasAchievementUnlocked((Achievement) statbase);
|
|
}
|
|
|
|
/**
|
|
* @param permission Bukkit/Cauldron permission
|
|
* @return Returns whether or not the player has the permission
|
|
*/
|
|
public boolean hasBukkitPermission(String permission){
|
|
return CustomNpcsPermissions.hasPermissionString(player, permission);
|
|
}
|
|
|
|
/**
|
|
* @since 1.7.10c
|
|
* @return Returns the exp level
|
|
*/
|
|
public int getExpLevel(){
|
|
return player.experienceLevel;
|
|
}
|
|
|
|
/**
|
|
* @since 1.7.10c
|
|
* @param level The new exp level you want to set
|
|
*/
|
|
public void setExpLevel(int level){
|
|
player.experienceLevel = level;
|
|
player.addExperienceLevel(0);
|
|
}
|
|
|
|
/**
|
|
* Requires pixelmon to be installed
|
|
* @since 1.7.10d
|
|
*/
|
|
public ScriptPixelmonPlayerData getPixelmonData(){
|
|
if(!PixelmonHelper.Enabled)
|
|
return null;
|
|
return new ScriptPixelmonPlayerData(player);
|
|
}
|
|
|
|
public ITimers getTimers() {
|
|
return PlayerDataController.instance.getPlayerData(player).timers;
|
|
}
|
|
|
|
public void updatePlayerInventory() {
|
|
((EntityPlayerMP)this.entity).inventoryContainer.detectAndSendChanges();
|
|
PlayerData playerData = PlayerDataController.instance.getPlayerData(player);
|
|
PlayerQuestData questData = playerData.questData;
|
|
questData.checkQuestCompletion(playerData, EnumQuestType.Item);
|
|
}
|
|
|
|
@Deprecated
|
|
public boolean checkGUIOpen() {
|
|
NoppesUtilPlayer.isGUIOpen(player);
|
|
PlayerData data = PlayerDataController.instance.getPlayerData(player);
|
|
return data.getGUIOpen();
|
|
}
|
|
|
|
public ScriptDBCPlayer<T> getDBCPlayer() {
|
|
Set keySet = player.getEntityData().getCompoundTag("PlayerPersisted").func_150296_c();
|
|
Iterator iterator = keySet.iterator();
|
|
|
|
while (iterator.hasNext())
|
|
{
|
|
String s = (String)iterator.next();
|
|
if(s.contains("jrmc"))
|
|
return new ScriptDBCPlayer<T>(this.player);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public boolean blocking() {
|
|
return player.isBlocking();
|
|
}
|
|
|
|
public PlayerData getData() {
|
|
if (this.data == null) {
|
|
this.data = PlayerDataController.instance.getPlayerData(player);
|
|
}
|
|
|
|
return this.data;
|
|
}
|
|
|
|
public boolean isScriptingDev() {
|
|
return CustomNpcs.isScriptDev(player);
|
|
}
|
|
|
|
public IQuest[] getActiveQuests() {
|
|
PlayerQuestData data = (PlayerQuestData) this.getData().getQuestData();
|
|
List<IQuest> quests = new ArrayList();
|
|
Iterator var3 = data.activeQuests.keySet().iterator();
|
|
|
|
while(var3.hasNext()) {
|
|
int id = (Integer)var3.next();
|
|
IQuest quest = (IQuest)QuestController.instance.quests.get(id);
|
|
if (quest != null) {
|
|
quests.add(quest);
|
|
}
|
|
}
|
|
|
|
return (IQuest[])quests.toArray(new IQuest[quests.size()]);
|
|
}
|
|
|
|
public IContainer getOpenContainer() {
|
|
return NpcAPI.Instance().getIContainer(((EntityPlayerMP)this.entity).openContainer);
|
|
}
|
|
|
|
public void showCustomGui(ICustomGui gui) {
|
|
CustomGuiController.openGui(this, (ScriptGui) gui);
|
|
}
|
|
|
|
public ICustomGui getCustomGui() {
|
|
return ((EntityPlayerMP)this.entity).openContainer instanceof ContainerCustomGui ? ((ContainerCustomGui)((EntityPlayerMP)this.entity).openContainer).customGui : null;
|
|
}
|
|
|
|
public void closeGui() {
|
|
((EntityPlayerMP)this.entity).closeContainer();
|
|
Server.sendData((EntityPlayerMP)this.entity, EnumPacketClient.GUI_CLOSE, -1, new NBTTagCompound());
|
|
}
|
|
|
|
public void showCustomOverlay(ICustomOverlay overlay) {
|
|
CustomGuiController.openOverlay(this, (ScriptOverlay) overlay);
|
|
}
|
|
|
|
public void closeOverlay(int id) {
|
|
Server.sendData((EntityPlayerMP)this.entity, EnumPacketClient.SCRIPT_OVERLAY_CLOSE, id, new NBTTagCompound());
|
|
}
|
|
|
|
public IOverlayHandler getOverlays() {
|
|
return this.getData().skinOverlays;
|
|
}
|
|
|
|
public IQuest[] getFinishedQuests() {
|
|
PlayerQuestData data = this.getData().questData;
|
|
List<IQuest> quests = new ArrayList();
|
|
Iterator var3 = data.finishedQuests.keySet().iterator();
|
|
|
|
while(var3.hasNext()) {
|
|
int id = (Integer)var3.next();
|
|
IQuest quest = (IQuest)QuestController.instance.quests.get(id);
|
|
if (quest != null) {
|
|
quests.add(quest);
|
|
}
|
|
}
|
|
|
|
return (IQuest[])quests.toArray(new IQuest[quests.size()]);
|
|
}
|
|
}
|