2019-12-11 17:13:54 +01:00
|
|
|
package net.citizensnpcs.trait.versioned;
|
2019-04-24 15:01:22 +02:00
|
|
|
|
2022-07-09 19:53:34 +02:00
|
|
|
import org.bukkit.command.CommandSender;
|
|
|
|
import org.bukkit.entity.EntityType;
|
2019-04-24 15:01:22 +02:00
|
|
|
import org.bukkit.entity.Panda;
|
|
|
|
|
2022-07-09 19:53:34 +02:00
|
|
|
import net.citizensnpcs.api.command.Command;
|
|
|
|
import net.citizensnpcs.api.command.CommandContext;
|
2022-09-06 20:11:07 +02:00
|
|
|
import net.citizensnpcs.api.command.Flag;
|
2022-07-09 19:53:34 +02:00
|
|
|
import net.citizensnpcs.api.command.Requirements;
|
|
|
|
import net.citizensnpcs.api.command.exception.CommandException;
|
|
|
|
import net.citizensnpcs.api.command.exception.CommandUsageException;
|
|
|
|
import net.citizensnpcs.api.npc.NPC;
|
2019-04-24 15:01:22 +02:00
|
|
|
import net.citizensnpcs.api.persistence.Persist;
|
|
|
|
import net.citizensnpcs.api.trait.Trait;
|
|
|
|
import net.citizensnpcs.api.trait.TraitName;
|
2022-07-09 19:53:34 +02:00
|
|
|
import net.citizensnpcs.api.util.Messaging;
|
|
|
|
import net.citizensnpcs.util.Messages;
|
2020-02-21 13:28:57 +01:00
|
|
|
import net.citizensnpcs.util.NMS;
|
2022-07-09 19:53:34 +02:00
|
|
|
import net.citizensnpcs.util.Util;
|
2019-04-24 15:01:22 +02:00
|
|
|
|
|
|
|
@TraitName("pandatrait")
|
|
|
|
public class PandaTrait extends Trait {
|
2023-04-19 19:35:44 +02:00
|
|
|
@Persist
|
|
|
|
private boolean eating;
|
2019-04-24 15:01:22 +02:00
|
|
|
@Persist
|
|
|
|
private Panda.Gene hiddenGene;
|
|
|
|
@Persist
|
|
|
|
private Panda.Gene mainGene = Panda.Gene.NORMAL;
|
2020-02-21 13:28:57 +01:00
|
|
|
@Persist
|
2023-02-14 16:26:21 +01:00
|
|
|
private boolean rolling;
|
|
|
|
@Persist
|
2020-02-21 13:28:57 +01:00
|
|
|
private boolean sitting;
|
2023-02-14 16:26:21 +01:00
|
|
|
@Persist
|
|
|
|
private boolean sneezing;
|
2019-04-24 15:01:22 +02:00
|
|
|
|
|
|
|
public PandaTrait() {
|
|
|
|
super("pandatrait");
|
|
|
|
}
|
|
|
|
|
2020-10-07 13:16:41 +02:00
|
|
|
public Panda.Gene getHiddenGene() {
|
|
|
|
return hiddenGene;
|
|
|
|
}
|
|
|
|
|
|
|
|
public Panda.Gene getMainGene() {
|
|
|
|
return mainGene;
|
|
|
|
}
|
|
|
|
|
2023-04-19 19:35:44 +02:00
|
|
|
public boolean isEating() {
|
|
|
|
return eating;
|
|
|
|
}
|
|
|
|
|
2023-02-14 16:26:21 +01:00
|
|
|
public boolean isRolling() {
|
|
|
|
return rolling;
|
|
|
|
}
|
|
|
|
|
2020-10-07 13:16:41 +02:00
|
|
|
public boolean isSitting() {
|
|
|
|
return sitting;
|
|
|
|
}
|
|
|
|
|
2023-02-14 16:26:21 +01:00
|
|
|
public boolean isSneezing() {
|
|
|
|
return sneezing;
|
|
|
|
}
|
|
|
|
|
2019-04-24 15:01:22 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (npc.isSpawned() && npc.getEntity() instanceof Panda) {
|
|
|
|
Panda panda = (Panda) npc.getEntity();
|
|
|
|
panda.setMainGene(mainGene);
|
2020-02-21 13:28:57 +01:00
|
|
|
NMS.setPandaSitting(npc.getEntity(), sitting);
|
2023-02-14 16:26:21 +01:00
|
|
|
if (SUPPORT_ROLLING_SNEEZING) {
|
|
|
|
try {
|
|
|
|
panda.setRolling(rolling);
|
|
|
|
panda.setSneezing(sneezing);
|
2023-04-19 19:35:44 +02:00
|
|
|
panda.setEating(eating);
|
2023-02-14 16:26:21 +01:00
|
|
|
} catch (Throwable t) {
|
|
|
|
SUPPORT_ROLLING_SNEEZING = false;
|
|
|
|
}
|
|
|
|
}
|
2019-04-24 15:01:22 +02:00
|
|
|
if (hiddenGene != null) {
|
|
|
|
panda.setHiddenGene(hiddenGene);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-04-19 19:35:44 +02:00
|
|
|
public void setEating(boolean eating) {
|
|
|
|
this.eating = eating;
|
|
|
|
}
|
|
|
|
|
2019-04-24 15:01:22 +02:00
|
|
|
public void setHiddenGene(Panda.Gene gene) {
|
2023-11-05 13:58:37 +01:00
|
|
|
hiddenGene = gene;
|
2019-04-24 15:01:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public void setMainGene(Panda.Gene gene) {
|
2023-11-05 13:58:37 +01:00
|
|
|
mainGene = gene;
|
2019-04-24 15:01:22 +02:00
|
|
|
}
|
|
|
|
|
2023-02-14 16:26:21 +01:00
|
|
|
public void setRolling(boolean rolling) {
|
|
|
|
this.rolling = rolling;
|
|
|
|
}
|
|
|
|
|
2020-10-07 13:16:41 +02:00
|
|
|
public void setSitting(boolean sitting) {
|
|
|
|
this.sitting = sitting;
|
|
|
|
}
|
|
|
|
|
2023-02-14 16:26:21 +01:00
|
|
|
public void setSneezing(boolean sneezing) {
|
|
|
|
this.sneezing = sneezing;
|
|
|
|
}
|
|
|
|
|
2023-04-19 19:35:44 +02:00
|
|
|
public boolean toggleEating() {
|
|
|
|
return eating = !eating;
|
|
|
|
}
|
|
|
|
|
2023-02-14 16:26:21 +01:00
|
|
|
public boolean toggleRolling() {
|
|
|
|
return rolling = !rolling;
|
|
|
|
}
|
|
|
|
|
2020-02-21 13:28:57 +01:00
|
|
|
public boolean toggleSitting() {
|
|
|
|
return sitting = !sitting;
|
|
|
|
}
|
|
|
|
|
2023-02-14 16:26:21 +01:00
|
|
|
public boolean toggleSneezing() {
|
|
|
|
return sneezing = !sneezing;
|
|
|
|
}
|
|
|
|
|
2022-07-09 19:53:34 +02:00
|
|
|
@Command(
|
|
|
|
aliases = { "npc" },
|
2023-04-19 19:35:44 +02:00
|
|
|
usage = "panda --gene (main gene) --hiddengene (hidden gene) -e(ating) -s(itting) -n (sneezing) -r(olling)",
|
2024-02-29 18:03:30 +01:00
|
|
|
desc = "",
|
2022-07-09 19:53:34 +02:00
|
|
|
modifiers = { "panda" },
|
2023-04-19 19:35:44 +02:00
|
|
|
flags = "srne",
|
2022-07-09 19:53:34 +02:00
|
|
|
min = 1,
|
|
|
|
max = 1,
|
|
|
|
permission = "citizens.npc.panda")
|
|
|
|
@Requirements(selected = true, ownership = true, types = EntityType.PANDA)
|
2022-09-06 20:11:07 +02:00
|
|
|
public static void panda(CommandContext args, CommandSender sender, NPC npc, @Flag("gene") Panda.Gene gene,
|
|
|
|
@Flag("hiddengene") Panda.Gene hiddengene) throws CommandException {
|
2022-07-09 19:53:34 +02:00
|
|
|
PandaTrait trait = npc.getOrAddTrait(PandaTrait.class);
|
|
|
|
String output = "";
|
|
|
|
if (args.hasValueFlag("gene")) {
|
2023-11-05 13:58:37 +01:00
|
|
|
if (gene == null)
|
2022-07-09 19:53:34 +02:00
|
|
|
throw new CommandUsageException(Messages.INVALID_PANDA_GENE,
|
|
|
|
Util.listValuesPretty(Panda.Gene.values()));
|
|
|
|
trait.setMainGene(gene);
|
|
|
|
output += ' ' + Messaging.tr(Messages.PANDA_MAIN_GENE_SET, args.getFlag("gene"));
|
|
|
|
}
|
2022-09-06 20:11:07 +02:00
|
|
|
if (args.hasValueFlag("hiddengene")) {
|
2023-11-05 13:58:37 +01:00
|
|
|
if (hiddengene == null)
|
2022-07-09 19:53:34 +02:00
|
|
|
throw new CommandUsageException(Messages.INVALID_PANDA_GENE,
|
|
|
|
Util.listValuesPretty(Panda.Gene.values()));
|
2022-09-06 20:11:07 +02:00
|
|
|
trait.setHiddenGene(hiddengene);
|
|
|
|
output += ' ' + Messaging.tr(Messages.PANDA_HIDDEN_GENE_SET, hiddengene);
|
2022-07-09 19:53:34 +02:00
|
|
|
}
|
2023-04-19 19:35:44 +02:00
|
|
|
if (args.hasFlag('e')) {
|
|
|
|
boolean isEating = trait.toggleEating();
|
|
|
|
output += ' '
|
|
|
|
+ Messaging.tr(isEating ? Messages.PANDA_EATING : Messages.PANDA_STOPPED_EATING, npc.getName());
|
|
|
|
}
|
2022-07-09 19:53:34 +02:00
|
|
|
if (args.hasFlag('s')) {
|
|
|
|
boolean isSitting = trait.toggleSitting();
|
2023-04-19 19:35:44 +02:00
|
|
|
output += ' '
|
|
|
|
+ Messaging.tr(isSitting ? Messages.PANDA_SITTING : Messages.PANDA_STOPPED_SITTING, npc.getName());
|
2022-07-09 19:53:34 +02:00
|
|
|
}
|
2023-02-14 16:26:21 +01:00
|
|
|
if (args.hasFlag('r')) {
|
|
|
|
boolean isRolling = trait.toggleRolling();
|
2023-04-19 19:35:44 +02:00
|
|
|
output += ' '
|
|
|
|
+ Messaging.tr(isRolling ? Messages.PANDA_ROLLING : Messages.PANDA_STOPPED_ROLLING, npc.getName());
|
2023-02-14 16:26:21 +01:00
|
|
|
}
|
|
|
|
if (args.hasFlag('n')) {
|
|
|
|
boolean isSneezing = trait.toggleSneezing();
|
2023-04-19 19:35:44 +02:00
|
|
|
output += ' ' + Messaging.tr(isSneezing ? Messages.PANDA_SNEEZING : Messages.PANDA_STOPPED_SNEEZING,
|
|
|
|
npc.getName());
|
2023-02-14 16:26:21 +01:00
|
|
|
}
|
2022-07-09 19:53:34 +02:00
|
|
|
if (!output.isEmpty()) {
|
|
|
|
Messaging.send(sender, output.trim());
|
2023-11-05 13:58:37 +01:00
|
|
|
} else
|
2022-07-09 19:53:34 +02:00
|
|
|
throw new CommandUsageException();
|
|
|
|
}
|
|
|
|
|
2023-02-14 16:26:21 +01:00
|
|
|
private static boolean SUPPORT_ROLLING_SNEEZING = true;
|
|
|
|
|
2019-04-24 15:01:22 +02:00
|
|
|
}
|