TotalFreedomMC/PlayerParticles
1
0
Fork 0
mirror of https://github.com/TotalFreedomMC/PlayerParticles.git synced 2025-07-07 22:38:01 +00:00
Code Issues Projects Releases Wiki Activity

Probably compiles, nowhere near functional

Browse source
This commit is contained in:
Esophose 2018-09-26 23:31:00 -06:00
parent febe2963d1
commit 8354f40a04
17 changed files with 783 additions and 791 deletions
Download patch file Download diff file Expand all files Collapse all files

31
src/com/esophose/playerparticles/command/DataCommandModule.java
View file

@ -2,13 +2,42 @@ package com.esophose.playerparticles.command;
import java.util.List;
import com.esophose.playerparticles.manager.LangManager;
import com.esophose.playerparticles.manager.LangManager.Lang;
import com.esophose.playerparticles.particles.PPlayer;
import com.esophose.playerparticles.particles.ParticleEffect;
import com.esophose.playerparticles.particles.ParticleEffect.ParticleProperty;
public class DataCommandModule implements CommandModule {
public void onCommandExecute(PPlayer pplayer, String[] args) {
if (args.length > 0) {
ParticleEffect effect = ParticleEffect.fromName(args[0]);
if ((!effect.hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA) && !effect.hasProperty(ParticleProperty.COLORABLE)) || args.length == 0) {
if (effect.hasProperty(ParticleProperty.COLORABLE)) {
if (effect == ParticleEffect.NOTE) {
LangManager.sendMessage(pplayer, Lang.DATA_USAGE, "note");
LangManager.sendCustomMessage(pplayer, Lang.USAGE.get() + " " + Lang.NOTE_DATA_USAGE.get());
} else {
LangManager.sendMessage(pplayer, Lang.DATA_USAGE, "color");
LangManager.sendCustomMessage(pplayer, Lang.USAGE.get() + " " + Lang.COLOR_DATA_USAGE.get());
}
} else if (effect.hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA)) {
if (effect == ParticleEffect.ITEM) {
LangManager.sendMessage(pplayer, Lang.DATA_USAGE, "item");
LangManager.sendCustomMessage(pplayer, Lang.USAGE.get() + " " + Lang.ITEM_DATA_USAGE.get());
} else {
LangManager.sendMessage(pplayer, Lang.DATA_USAGE, "block");
LangManager.sendCustomMessage(pplayer, Lang.USAGE.get() + " " + Lang.BLOCK_DATA_USAGE.get());
}
} else {
LangManager.sendMessage(pplayer, Lang.NO_DATA_USAGE);
}
}
} else {
LangManager.sendMessage(pplayer, Lang.INVALID_TYPE);
}
}
public List<String> onTabComplete(PPlayer pplayer, String[] args) {
@ -24,7 +53,7 @@ public class DataCommandModule implements CommandModule {
}
public String getArguments() {
return "<args>";
return "<effect>";
}
public boolean requiresEffects() {

3
src/com/esophose/playerparticles/command/EffectCommandModule.java
View file

@ -2,13 +2,14 @@ package com.esophose.playerparticles.command;
import java.util.List;
import com.esophose.playerparticles.manager.LangManager;
import com.esophose.playerparticles.manager.LangManager.Lang;
import com.esophose.playerparticles.particles.PPlayer;
public class EffectCommandModule implements CommandModule {
public void onCommandExecute(PPlayer pplayer, String[] args) {
LangManager.sendMessage(pplayer, Lang.COMMAND_REMOVED);
}
public List<String> onTabComplete(PPlayer pplayer, String[] args) {

24
src/com/esophose/playerparticles/command/EffectsCommandModule.java
View file

@ -2,13 +2,37 @@ package com.esophose.playerparticles.command;
import java.util.List;
import org.bukkit.entity.Player;
import com.esophose.playerparticles.manager.LangManager;
import com.esophose.playerparticles.manager.PermissionManager;
import com.esophose.playerparticles.manager.LangManager.Lang;
import com.esophose.playerparticles.particles.PPlayer;
import com.esophose.playerparticles.particles.ParticleEffect;
public class EffectsCommandModule implements CommandModule {
public void onCommandExecute(PPlayer pplayer, String[] args) {
Player p = pplayer.getPlayer();
if (PermissionManager.getEffectsUserHasPermissionFor(p).size() == 1) {
LangManager.sendMessage(p, Lang.NO_PARTICLES);
return;
}
String toSend = Lang.USE.get() + " ";
for (ParticleEffect effect : ParticleEffect.getSupportedEffects()) {
if (PermissionManager.hasEffectPermission(p, effect)) {
toSend += effect.getName() + ", ";
continue;
}
}
if (toSend.endsWith(", ")) {
toSend = toSend.substring(0, toSend.length() - 2);
}
LangManager.sendCustomMessage(p, toSend);
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.PARTICLE_USAGE.get());
}
public List<String> onTabComplete(PPlayer pplayer, String[] args) {

327
src/com/esophose/playerparticles/command/FixedCommandModule.java
View file

@ -1,14 +1,341 @@
package com.esophose.playerparticles.command;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import com.esophose.playerparticles.manager.DataManager;
import com.esophose.playerparticles.manager.LangManager;
import com.esophose.playerparticles.manager.ParticleManager;
import com.esophose.playerparticles.manager.PermissionManager;
import com.esophose.playerparticles.manager.LangManager.Lang;
import com.esophose.playerparticles.particles.FixedParticleEffect;
import com.esophose.playerparticles.particles.PPlayer;
import com.esophose.playerparticles.particles.ParticleEffect;
import com.esophose.playerparticles.particles.ParticleEffect.NoteColor;
import com.esophose.playerparticles.particles.ParticleEffect.OrdinaryColor;
import com.esophose.playerparticles.particles.ParticleEffect.ParticleProperty;
import com.esophose.playerparticles.particles.ParticlePair;
import com.esophose.playerparticles.styles.api.ParticleStyle;
import com.esophose.playerparticles.styles.api.ParticleStyleManager;
import com.esophose.playerparticles.util.ParticleUtils;
public class FixedCommandModule implements CommandModule {
public void onCommandExecute(PPlayer pplayer, String[] args) {
Player p = pplayer.getPlayer();
if (!PermissionManager.canUseFixedEffects(p)) {
LangManager.sendMessage(p, Lang.NO_PERMISSION_FIXED);
return;
}
if (args.length == 0) { // General information on command
LangManager.sendMessage(p, Lang.INVALID_FIXED_COMMAND);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_CREATE);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_REMOVE);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_LIST);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_INFO);
if (p.hasPermission("playerparticles.fixed.clear"))
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_CLEAR);
return;
}
String cmd = args[0];
String[] cmdArgs = new String[args.length - 1];
for (int i = 1; i < args.length; i++) {
cmdArgs[i - 1] = args[i];
}
args = cmdArgs;
if (cmd.equalsIgnoreCase("create")) {
boolean reachedMax = DataManager.hasPlayerReachedMaxFixedEffects(pplayer);
if (reachedMax) {
LangManager.sendMessage(p, Lang.MAX_FIXED_EFFECTS_REACHED);
return;
}
if (args.length < 5) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_MISSING_ARGS, (5 - args.length) + "");
return;
}
double xPos = -1, yPos = -1, zPos = -1;
try {
if (args[0].startsWith("~")) {
if (args[0].equals("~"))
xPos = p.getLocation().getX();
else
xPos = p.getLocation().getX() + Double.parseDouble(args[0].substring(1));
} else {
xPos = Double.parseDouble(args[0]);
}
if (args[1].startsWith("~")) {
if (args[1].equals("~"))
yPos = p.getLocation().getY() + 1;
else
yPos = p.getLocation().getY() + 1 + Double.parseDouble(args[1].substring(1));
} else {
yPos = Double.parseDouble(args[1]);
}
if (args[2].startsWith("~")) {
if (args[2].equals("~"))
zPos = p.getLocation().getZ();
else
zPos = p.getLocation().getZ() + Double.parseDouble(args[2].substring(1));
} else {
zPos = Double.parseDouble(args[2]);
}
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_INVALID_COORDS);
return;
}
double distanceFromEffect = p.getLocation().distance(new Location(p.getWorld(), xPos, yPos, zPos));
int maxCreationDistance = DataManager.getMaxFixedEffectCreationDistance();
if (maxCreationDistance != 0 && distanceFromEffect > maxCreationDistance) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_OUT_OF_RANGE, maxCreationDistance + "");
return;
}
ParticleEffect effect = ParticleManager.effectFromString(args[3]);
if (effect == null) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_INVALID_EFFECT, args[3]);
return;
} else if (!PermissionManager.hasEffectPermission(p, effect)) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_NO_PERMISSION_EFFECT, effect.getName());
return;
}
ParticleStyle style = ParticleStyleManager.styleFromString(args[4]);
if (style == null) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_INVALID_STYLE, args[4]);
return;
} else if (!PermissionManager.hasStylePermission(p, style)) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_NO_PERMISSION_STYLE, args[4]);
return;
}
if (!style.canBeFixed()) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_NON_FIXABLE_STYLE, style.getName());
return;
}
Material itemData = null;
Material blockData = null;
OrdinaryColor colorData = null;
NoteColor noteColorData = null;
if (args.length > 5) {
if (effect.hasProperty(ParticleProperty.COLORABLE)) {
if (effect == ParticleEffect.NOTE) {
if (args[5].equalsIgnoreCase("rainbow")) {
noteColorData = new NoteColor(99);
} else {
int note = -1;
try {
note = Integer.parseInt(args[5]);
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "note");
return;
}
if (note < 0 || note > 23) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "note");
return;
}
noteColorData = new NoteColor(note);
}
} else {
if (args[5].equalsIgnoreCase("rainbow")) {
colorData = new OrdinaryColor(999, 999, 999);
} else {
int r = -1;
int g = -1;
int b = -1;
try {
r = Integer.parseInt(args[5]);
g = Integer.parseInt(args[6]);
b = Integer.parseInt(args[7]);
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "color");
return;
}
if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "color");
return;
}
colorData = new OrdinaryColor(r, g, b);
}
}
} else if (effect.hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA)) {
if (effect == ParticleEffect.BLOCK || effect == ParticleEffect.FALLING_DUST) {
Material material = null;
try {
material = ParticleUtils.closestMatch(args[5]);
if (material == null)
material = Material.matchMaterial(args[5]);
if (material == null)
throw new Exception();
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "block");
return;
}
blockData = material;
} else if (effect == ParticleEffect.ITEM) {
Material material = null;
try {
material = ParticleUtils.closestMatch(args[5]);
if (material == null)
material = Material.matchMaterial(args[5]);
if (material == null)
throw new Exception();
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "item");
return;
}
itemData = material;
}
}
}
int nextFixedEffectId = pplayer.getNextFixedEffectId();
ParticlePair particle = new ParticlePair(pplayer.getUniqueId(), nextFixedEffectId, effect, style, itemData, blockData, colorData, noteColorData);
FixedParticleEffect fixedEffect = new FixedParticleEffect(p.getUniqueId(), nextFixedEffectId, p.getLocation().getWorld().getName(), xPos, yPos, zPos, particle);
LangManager.sendMessage(p, Lang.CREATE_FIXED_SUCCESS);
DataManager.saveFixedEffect(fixedEffect);
} else if (cmd.equalsIgnoreCase("remove")) {
if (args.length < 1) {
LangManager.sendMessage(p, Lang.REMOVE_FIXED_NO_ARGS);
return;
}
int id = -1;
try {
id = Integer.parseInt(args[0]);
} catch (Exception e) {
LangManager.sendMessage(p, Lang.REMOVE_FIXED_INVALID_ARGS);
return;
}
if (pplayer.getFixedEffectById(id) != null) {
DataManager.removeFixedEffect(pplayer.getUniqueId(), id);
LangManager.sendMessage(p, Lang.REMOVE_FIXED_SUCCESS, id + "");
} else {
LangManager.sendMessage(p, Lang.REMOVE_FIXED_NONEXISTANT, id + "");
}
} else if (cmd.equalsIgnoreCase("list")) {
List<Integer> ids = pplayer.getFixedEffectIds();
Collections.sort(ids);
if (ids.isEmpty()) {
LangManager.sendMessage(p, Lang.LIST_FIXED_NONE);
return;
}
String msg = Lang.LIST_FIXED_SUCCESS.get();
boolean first = true;
for (int id : ids) {
if (!first)
msg += ", ";
else
first = false;
msg += id;
}
LangManager.sendCustomMessage(p, msg);
} else if (cmd.equalsIgnoreCase("info")) {
if (args.length < 1) {
LangManager.sendMessage(p, Lang.INFO_FIXED_NO_ARGS);
return;
}
int id = -1;
try {
id = Integer.parseInt(args[0]);
} catch (Exception e) {
LangManager.sendMessage(p, Lang.INFO_FIXED_INVALID_ARGS);
return;
}
FixedParticleEffect fixedEffect = pplayer.getFixedEffectById(id);
if (fixedEffect == null) {
LangManager.sendMessage(p, Lang.INFO_FIXED_NONEXISTANT, id + "");
return;
}
ParticlePair particle = fixedEffect.getParticlePair();
DecimalFormat df = new DecimalFormat("0.##"); // Decimal formatter so the coords aren't super long
String listMessage = Lang.INFO_FIXED_INFO.get() // @formatter:off
.replaceAll("\\{0\\}", fixedEffect.getId() + "")
.replaceAll("\\{1\\}", fixedEffect.getLocation().getWorld().getName())
.replaceAll("\\{2\\}", df.format(fixedEffect.getLocation().getX()) + "")
.replaceAll("\\{3\\}", df.format(fixedEffect.getLocation().getY()) + "")
.replaceAll("\\{4\\}", df.format(fixedEffect.getLocation().getZ()) + "")
.replaceAll("\\{5\\}", particle.getEffect().getName())
.replaceAll("\\{6\\}", particle.getStyle().getName())
.replaceAll("\\{7\\}", particle.getDataString()); // @formatter:on
LangManager.sendCustomMessage(p, listMessage);
} else if (cmd.equalsIgnoreCase("clear")) {
if (!p.hasPermission("playerparticles.fixed.clear")) {
LangManager.sendMessage(p, Lang.CLEAR_FIXED_NO_PERMISSION);
return;
}
if (args.length < 1) {
LangManager.sendMessage(p, Lang.CLEAR_FIXED_NO_ARGS);
return;
}
int radius = -1;
try {
radius = Math.abs(Integer.parseInt(args[0]));
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CLEAR_FIXED_INVALID_ARGS);
return;
}
ArrayList<FixedParticleEffect> fixedEffectsToRemove = new ArrayList<FixedParticleEffect>();
for (PPlayer ppl : ParticleManager.getPPlayers())
for (FixedParticleEffect fixedEffect : ppl.getFixedParticles())
if (fixedEffect.getLocation().getWorld().equals(p.getLocation().getWorld())
&& fixedEffect.getLocation().distance(p.getLocation()) <= radius)
fixedEffectsToRemove.add(fixedEffect);
for (FixedParticleEffect fixedEffect : fixedEffectsToRemove)
DataManager.removeFixedEffect(fixedEffect.getOwnerUniqueId(), fixedEffect.getId());
String clearMessage = Lang.CLEAR_FIXED_SUCCESS.get() // @formatter:off
.replaceAll("\\{0\\}", fixedEffectsToRemove.size() + "").replaceAll("\\{1\\}", radius + ""); // @formatter:on
LangManager.sendCustomMessage(pplayer, clearMessage);
return;
} else {
LangManager.sendMessage(pplayer, Lang.INVALID_FIXED_COMMAND);
LangManager.sendMessage(pplayer, Lang.FIXED_COMMAND_DESC_CREATE);
LangManager.sendMessage(pplayer, Lang.FIXED_COMMAND_DESC_REMOVE);
LangManager.sendMessage(pplayer, Lang.FIXED_COMMAND_DESC_LIST);
LangManager.sendMessage(pplayer, Lang.FIXED_COMMAND_DESC_INFO);
if (p.hasPermission("playerparticles.fixed.clear"))
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_CLEAR);
}
}
public List<String> onTabComplete(PPlayer pplayer, String[] args) {

4
src/com/esophose/playerparticles/command/HelpCommandModule.java
View file

@ -2,13 +2,15 @@ package com.esophose.playerparticles.command;
import java.util.List;
import com.esophose.playerparticles.manager.LangManager;
import com.esophose.playerparticles.manager.LangManager.Lang;
import com.esophose.playerparticles.particles.PPlayer;
public class HelpCommandModule implements CommandModule {
public void onCommandExecute(PPlayer pplayer, String[] args) {
LangManager.sendMessage(pplayer, Lang.AVAILABLE_COMMANDS); // TODO: Rewrite to be dynamically generated from the ParticleCommandHandler's registered CommandModules
LangManager.sendMessage(pplayer, Lang.COMMAND_USAGE);
}
public List<String> onTabComplete(PPlayer pplayer, String[] args) {

737
src/com/esophose/playerparticles/command/ParticleCommandHandler.java
View file

@ -8,41 +8,20 @@
package com.esophose.playerparticles.command;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import org.bukkit.entity.Player;
import org.bukkit.util.StringUtil;
import com.esophose.playerparticles.PlayerParticles;
import com.esophose.playerparticles.gui.PlayerParticlesGui;
import com.esophose.playerparticles.gui.PlayerParticlesGui.GuiState;
import com.esophose.playerparticles.manager.DataManager;
import com.esophose.playerparticles.manager.LangManager;
import com.esophose.playerparticles.manager.LangManager.Lang;
import com.esophose.playerparticles.manager.ParticleManager;
import com.esophose.playerparticles.manager.PermissionManager;
import com.esophose.playerparticles.particles.FixedParticleEffect;
import com.esophose.playerparticles.particles.PPlayer;
import com.esophose.playerparticles.particles.ParticleEffect;
import com.esophose.playerparticles.particles.ParticleEffect.NoteColor;
import com.esophose.playerparticles.particles.ParticleEffect.OrdinaryColor;
import com.esophose.playerparticles.particles.ParticleEffect.ParticleProperty;
import com.esophose.playerparticles.styles.DefaultStyles;
import com.esophose.playerparticles.styles.api.ParticleStyle;
import com.esophose.playerparticles.styles.api.ParticleStyleManager;
import com.esophose.playerparticles.util.ParticleUtils;
public class ParticleCommandHandler implements CommandExecutor, TabCompleter {
@ -72,6 +51,12 @@ public class ParticleCommandHandler implements CommandExecutor, TabCompleter {
commands.add(new WorldsCommandModule());
}
/**
* Finds a matching CommandModule by its name
*
* @param commandName The command name
* @return The found CommandModule, otherwise null
*/
public static CommandModule findMatchingCommand(String commandName) {
for (CommandModule commandModule : commands)
if (commandModule.getName().equalsIgnoreCase(commandName))
@ -113,622 +98,10 @@ public class ParticleCommandHandler implements CommandExecutor, TabCompleter {
return true;
}
/**
* Gets an online player by their username if they exist
*
* @param playerName The player's username to lookup
* @return The player, if they exist
*/
private Player getOnlinePlayerByName(String playerName) {
for (Player p : Bukkit.getOnlinePlayers())
if (p.getName().toLowerCase().contains(playerName.toLowerCase())) return p;
return null;
}
/**
* Called when a player uses /pp help
*
* @param p The player who used the command
*/
private void onHelp(Player p) {
LangManager.sendMessage(p, Lang.AVAILABLE_COMMANDS);
LangManager.sendMessage(p, Lang.COMMAND_USAGE);
}
/**
* Called when a player uses /pp data
*
* @param p The player who used the command
* @param args The arguments for the command
*/
private void onData(Player p, String[] args) {
ParticleEffect effect = DataManager.getInstance().getPPlayer(p.getUniqueId()).getParticleEffect();
if ((!effect.hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA) && !effect.hasProperty(ParticleProperty.COLORABLE)) || args.length == 0) {
if (effect.hasProperty(ParticleProperty.COLORABLE)) {
if (effect == ParticleEffect.NOTE) {
LangManager.sendMessage(p, Lang.DATA_USAGE, "note");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.NOTE_DATA_USAGE.get());
} else {
LangManager.sendMessage(p, Lang.DATA_USAGE, "color");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.COLOR_DATA_USAGE.get());
}
} else if (effect.hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA)) {
if (effect == ParticleEffect.ITEM) {
LangManager.sendMessage(p, Lang.DATA_USAGE, "item");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.ITEM_DATA_USAGE.get());
} else {
LangManager.sendMessage(p, Lang.DATA_USAGE, "block");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.BLOCK_DATA_USAGE.get());
}
} else {
LangManager.sendMessage(p, Lang.NO_DATA_USAGE);
}
return;
}
if (effect.hasProperty(ParticleProperty.COLORABLE)) {
if (effect == ParticleEffect.NOTE) {
if (args[0].equalsIgnoreCase("rainbow")) {
DataManager.getInstance().savePPlayer(p.getUniqueId(), new NoteColor(99));
LangManager.sendMessage(p, Lang.DATA_APPLIED, "note");
return;
}
int note = -1;
try {
note = Integer.parseInt(args[0]);
} catch (Exception e) {
LangManager.sendMessage(p, Lang.DATA_INVALID_ARGUMENTS, "note");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.NOTE_DATA_USAGE.get());
return;
}
if (note < 0 || note > 23) {
LangManager.sendMessage(p, Lang.DATA_INVALID_ARGUMENTS, "note");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.NOTE_DATA_USAGE.get());
return;
}
DataManager.getInstance().savePPlayer(p.getUniqueId(), new NoteColor(note));
LangManager.sendMessage(p, Lang.DATA_APPLIED, "note");
} else {
if (args[0].equalsIgnoreCase("rainbow")) {
DataManager.getInstance().savePPlayer(p.getUniqueId(), new OrdinaryColor(999, 999, 999));
LangManager.sendMessage(p, Lang.DATA_APPLIED, "color");
} else if (args.length >= 3) {
int r = -1;
int g = -1;
int b = -1;
try {
r = Integer.parseInt(args[0]);
g = Integer.parseInt(args[1]);
b = Integer.parseInt(args[2]);
} catch (Exception e) {
LangManager.sendMessage(p, Lang.DATA_INVALID_ARGUMENTS, "color");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.COLOR_DATA_USAGE.get());
return;
}
if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
LangManager.sendMessage(p, Lang.DATA_INVALID_ARGUMENTS, "color");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.COLOR_DATA_USAGE.get());
return;
}
DataManager.getInstance().savePPlayer(p.getUniqueId(), new OrdinaryColor(r, g, b));
LangManager.sendMessage(p, Lang.DATA_APPLIED, "color");
} else {
LangManager.sendMessage(p, Lang.DATA_INVALID_ARGUMENTS, "color");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.COLOR_DATA_USAGE.get());
}
}
} else if (effect.hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA)) {
if (effect == ParticleEffect.ITEM) {
Material material = null;
try {
material = ParticleUtils.closestMatch(args[0]);
if (material == null) material = Material.matchMaterial(args[0]);
if (material == null) throw new Exception();
} catch (Exception e) {
LangManager.sendMessage(p, Lang.DATA_MATERIAL_UNKNOWN, "item");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.ITEM_DATA_USAGE.get());
return;
}
if (material.isBlock()) {
LangManager.sendMessage(p, Lang.DATA_MATERIAL_MISMATCH, "item");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.ITEM_DATA_USAGE.get());
return;
}
DataManager.getInstance().savePPlayer(p.getUniqueId(), new ItemData(material));
LangManager.sendMessage(p, Lang.DATA_APPLIED, "item");
} else {
Material material = null;
try {
material = ParticleUtils.closestMatch(args[0]);
if (material == null) material = Material.matchMaterial(args[0]);
if (material == null) throw new Exception();
} catch (Exception e) {
LangManager.sendMessage(p, Lang.DATA_MATERIAL_UNKNOWN, "block");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.BLOCK_DATA_USAGE.get());
return;
}
if (!material.isBlock()) {
LangManager.sendMessage(p, Lang.DATA_MATERIAL_MISMATCH, "block");
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.BLOCK_DATA_USAGE.get());
return;
}
DataManager.getInstance().savePPlayer(p.getUniqueId(), new BlockData(material));
LangManager.sendMessage(p, Lang.DATA_APPLIED, "block");
}
}
}
/**
* Called when a player uses /pp reset
* Can be executed for another player by having their name as the final command argument
*
* @param p The player who used the command
* @param args Additional arguments
*/
private void onReset(Player p, String[] args) {
if (args.length >= 1) {
String altPlayerName = args[0];
if (!PermissionManager.canUseForceReset(p)) {
LangManager.sendMessage(p, Lang.FAILED_EXECUTE_NO_PERMISSION, altPlayerName);
} else {
Player altPlayer = getOnlinePlayerByName(altPlayerName);
if (altPlayer == null) {
LangManager.sendMessage(p, Lang.FAILED_EXECUTE_NOT_FOUND, altPlayerName);
} else {
DataManager.getInstance().resetPPlayer(altPlayer.getUniqueId());
LangManager.sendMessage(altPlayer, Lang.RESET);
LangManager.sendMessage(p, Lang.EXECUTED_FOR_PLAYER, altPlayer.getName());
}
}
} else {
DataManager.getInstance().resetPPlayer(p.getUniqueId());
LangManager.sendMessage(p, Lang.RESET);
}
}
/**
* Called when a player uses /pp effect
*
* @param p The player who used the command
* @param args The arguments for the command
*/
private void onEffect(Player p, String[] args) {
if (args.length == 0) {
LangManager.sendMessage(p, Lang.INVALID_TYPE);
return;
}
String argument = args[0];
if (ParticleManager.effectFromString(argument) != null) {
ParticleEffect effect = ParticleManager.effectFromString(argument);
if (!PermissionManager.hasEffectPermission(p, effect)) {
LangManager.sendMessage(p, Lang.NO_PERMISSION, effect.getName());
return;
}
DataManager.getInstance().savePPlayer(p.getUniqueId(), effect);
if (effect != ParticleEffect.NONE) {
LangManager.sendMessage(p, Lang.NOW_USING, effect.getName());
} else {
LangManager.sendMessage(p, Lang.CLEARED_PARTICLES);
}
return;
}
LangManager.sendMessage(p, Lang.INVALID_TYPE);
}
/**
* Called when a player uses /pp effects
*
* @param p The player who used the command
*/
private void onEffects(Player p) {
if (PermissionManager.getEffectsUserHasPermissionFor(p).size() == 1) {
LangManager.sendMessage(p, Lang.NO_PARTICLES);
return;
}
String toSend = Lang.USE.get() + " ";
for (ParticleEffect effect : ParticleEffect.getSupportedEffects()) {
if (PermissionManager.hasEffectPermission(p, effect)) {
toSend += effect.getName() + ", ";
continue;
}
}
if (toSend.endsWith(", ")) {
toSend = toSend.substring(0, toSend.length() - 2);
}
LangManager.sendCustomMessage(p, toSend);
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.PARTICLE_USAGE.get());
}
/**
* Called when a player uses /pp style
*
* @param p The player who used the command
* @param args The arguments for the command
*/
private void onStyle(Player p, String[] args) {
if (PermissionManager.getStylesUserHasPermissionFor(p).size() == 1) {
LangManager.sendMessage(p, Lang.NO_STYLES);
return;
}
if (args.length == 0) {
LangManager.sendMessage(p, Lang.INVALID_TYPE_STYLE);
return;
}
String argument = args[0];
if (ParticleStyleManager.styleFromString(argument) != null) {
ParticleStyle style = ParticleStyleManager.styleFromString(argument);
if (!PermissionManager.hasStylePermission(p, style)) {
LangManager.sendMessage(p, Lang.NO_PERMISSION_STYLE, style.getName());
return;
}
DataManager.getInstance().savePPlayer(p.getUniqueId(), style);
if (style != DefaultStyles.NONE) {
LangManager.sendMessage(p, Lang.NOW_USING_STYLE, style.getName());
} else {
LangManager.sendMessage(p, Lang.CLEARED_STYLE);
}
return;
}
LangManager.sendMessage(p, Lang.INVALID_TYPE_STYLE);
}
/**
* Called when a player uses /pp styles
*
* @param p The player who used the command
*/
private void onStyles(Player p) {
if (PermissionManager.getStylesUserHasPermissionFor(p).size() == 1) {
LangManager.sendMessage(p, Lang.NO_STYLES);
return;
}
String toSend = Lang.USE.get() + " ";
for (ParticleStyle style : ParticleStyleManager.getStyles()) {
if (PermissionManager.hasStylePermission(p, style)) {
toSend += style.getName();
toSend += ", ";
}
}
if (toSend.endsWith(", ")) {
toSend = toSend.substring(0, toSend.length() - 2);
}
LangManager.sendCustomMessage(p, toSend);
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.STYLE_USAGE.get());
}
/**
* Called when a player uses /pp fixed
*
* @param p The player who used the command
* @param args The arguments for the command
*/
private void onFixed(Player p, String[] args) {
if (!PermissionManager.canUseFixedEffects(p)) {
LangManager.sendMessage(p, Lang.NO_PERMISSION_FIXED);
return;
}
if (args.length == 0) { // General information on command
LangManager.sendMessage(p, Lang.INVALID_FIXED_COMMAND);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_CREATE);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_REMOVE);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_LIST);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_INFO);
if (p.hasPermission("playerparticles.fixed.clear")) LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_CLEAR);
return;
}
String cmd = args[0];
String[] cmdArgs = new String[args.length - 1];
for (int i = 1; i < args.length; i++) {
cmdArgs[i - 1] = args[i];
}
args = cmdArgs;
if (cmd.equalsIgnoreCase("create")) {
final String[] f_args = args;
DataManager.getInstance().hasPlayerReachedMaxFixedEffects(p.getUniqueId(), (reachedMax) -> {
if (reachedMax) {
LangManager.sendMessage(p, Lang.MAX_FIXED_EFFECTS_REACHED);
return;
}
if (f_args.length < 5) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_MISSING_ARGS, (5 - f_args.length) + "");
return;
}
double xPos = -1, yPos = -1, zPos = -1;
try {
if (f_args[0].startsWith("~")) {
if (f_args[0].equals("~")) xPos = p.getLocation().getX();
else xPos = p.getLocation().getX() + Double.parseDouble(f_args[0].substring(1));
} else {
xPos = Double.parseDouble(f_args[0]);
}
if (f_args[1].startsWith("~")) {
if (f_args[1].equals("~")) yPos = p.getLocation().getY() + 1;
else yPos = p.getLocation().getY() + 1 + Double.parseDouble(f_args[1].substring(1));
} else {
yPos = Double.parseDouble(f_args[1]);
}
if (f_args[2].startsWith("~")) {
if (f_args[2].equals("~")) zPos = p.getLocation().getZ();
else zPos = p.getLocation().getZ() + Double.parseDouble(f_args[2].substring(1));
} else {
zPos = Double.parseDouble(f_args[2]);
}
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_INVALID_COORDS);
return;
}
double distanceFromEffect = p.getLocation().distance(new Location(p.getWorld(), xPos, yPos, zPos));
int maxCreationDistance = DataManager.getInstance().getMaxFixedEffectCreationDistance();
if (maxCreationDistance != 0 && distanceFromEffect > maxCreationDistance) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_OUT_OF_RANGE, maxCreationDistance + "");
return;
}
ParticleEffect effect = ParticleManager.effectFromString(f_args[3]);
if (effect == null) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_INVALID_EFFECT, f_args[3]);
return;
} else if (!PermissionManager.hasEffectPermission(p, effect)) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_NO_PERMISSION_EFFECT, effect.getName());
return;
}
ParticleStyle style = ParticleStyleManager.styleFromString(f_args[4]);
if (style == null) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_INVALID_STYLE, f_args[4]);
return;
} else if (!PermissionManager.hasStylePermission(p, style)) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_NO_PERMISSION_STYLE, f_args[4]);
return;
}
if (!style.canBeFixed()) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_NON_FIXABLE_STYLE, style.getName());
return;
}
ItemData itemData = null;
BlockData blockData = null;
OrdinaryColor colorData = null;
NoteColor noteColorData = null;
if (f_args.length > 5) {
if (effect.hasProperty(ParticleProperty.COLORABLE)) {
if (effect == ParticleEffect.NOTE) {
if (f_args[5].equalsIgnoreCase("rainbow")) {
noteColorData = new NoteColor(99);
} else {
int note = -1;
try {
note = Integer.parseInt(f_args[5]);
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "note");
return;
}
if (note < 0 || note > 23) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "note");
return;
}
noteColorData = new NoteColor(note);
}
} else {
if (f_args[5].equalsIgnoreCase("rainbow")) {
colorData = new OrdinaryColor(999, 999, 999);
} else {
int r = -1;
int g = -1;
int b = -1;
try {
r = Integer.parseInt(f_args[5]);
g = Integer.parseInt(f_args[6]);
b = Integer.parseInt(f_args[7]);
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "color");
return;
}
if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "color");
return;
}
colorData = new OrdinaryColor(r, g, b);
}
}
} else if (effect.hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA)) {
if (effect == ParticleEffect.BLOCK || effect == ParticleEffect.FALLING_DUST) {
Material material = null;
try {
material = ParticleUtils.closestMatch(f_args[5]);
if (material == null) material = Material.matchMaterial(f_args[5]);
if (material == null) throw new Exception();
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "block");
return;
}
blockData = new BlockData(material);
} else if (effect == ParticleEffect.ITEM) {
Material material = null;
try {
material = ParticleUtils.closestMatch(f_args[5]);
if (material == null) material = Material.matchMaterial(f_args[5]);
if (material == null) throw new Exception();
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CREATE_FIXED_DATA_ERROR, "item");
return;
}
itemData = new ItemData(material);
}
}
}
// If somebody knows how to avoid this, please create a pull request
final double f_xPos = xPos, f_yPos = yPos, f_zPos = zPos;
final ItemData f_itemData = itemData;
final BlockData f_blockData = blockData;
final OrdinaryColor f_colorData = colorData;
final NoteColor f_noteData = noteColorData;
DataManager.getInstance().getNextFixedEffectId(p.getUniqueId(), (nextFixedEffectId) -> {
FixedParticleEffect fixedEffect = new FixedParticleEffect(p.getUniqueId(), // @formatter:off
nextFixedEffectId,
p.getLocation().getWorld().getName(), f_xPos, f_yPos, f_zPos,
effect, style, f_itemData, f_blockData, f_colorData, f_noteData); // @formatter:on
LangManager.sendMessage(p, Lang.CREATE_FIXED_SUCCESS);
DataManager.getInstance().saveFixedEffect(fixedEffect);
});
});
} else if (cmd.equalsIgnoreCase("remove")) {
if (args.length < 1) {
LangManager.sendMessage(p, Lang.REMOVE_FIXED_NO_ARGS);
return;
}
int id = -1;
try {
id = Integer.parseInt(args[0]);
} catch (Exception e) {
LangManager.sendMessage(p, Lang.REMOVE_FIXED_INVALID_ARGS);
return;
}
final int f_id = id;
DataManager.getInstance().removeFixedEffect(p.getUniqueId(), id, (successful) -> {
if (successful) {
LangManager.sendMessage(p, Lang.REMOVE_FIXED_SUCCESS, f_id + "");
} else {
LangManager.sendMessage(p, Lang.REMOVE_FIXED_NONEXISTANT, f_id + "");
}
});
} else if (cmd.equalsIgnoreCase("list")) {
DataManager.getInstance().getFixedEffectIdsForPlayer(p.getUniqueId(), (ids) -> {
Collections.sort(ids);
if (ids.isEmpty()) {
LangManager.sendMessage(p, Lang.LIST_FIXED_NONE);
return;
}
String msg = Lang.LIST_FIXED_SUCCESS.get();
boolean first = true;
for (int id : ids) {
if (!first) msg += ", ";
else first = false;
msg += id;
}
LangManager.sendCustomMessage(p, msg);
});
} else if (cmd.equalsIgnoreCase("info")) {
if (args.length < 1) {
LangManager.sendMessage(p, Lang.INFO_FIXED_NO_ARGS);
return;
}
int id = -1;
try {
id = Integer.parseInt(args[0]);
} catch (Exception e) {
LangManager.sendMessage(p, Lang.INFO_FIXED_INVALID_ARGS);
return;
}
final int f_id = id;
DataManager.getInstance().getFixedEffectForPlayerById(p.getUniqueId(), id, (fixedEffect) -> {
if (fixedEffect == null) {
LangManager.sendMessage(p, Lang.INFO_FIXED_NONEXISTANT, f_id + "");
return;
}
DecimalFormat df = new DecimalFormat("0.##"); // Decimal formatter so the coords aren't super long
String listMessage = Lang.INFO_FIXED_INFO.get() // @formatter:off
.replaceAll("\\{0\\}", fixedEffect.getId() + "")
.replaceAll("\\{1\\}", fixedEffect.getLocation().getWorld().getName())
.replaceAll("\\{2\\}", df.format(fixedEffect.getLocation().getX()) + "")
.replaceAll("\\{3\\}", df.format(fixedEffect.getLocation().getY()) + "")
.replaceAll("\\{4\\}", df.format(fixedEffect.getLocation().getZ()) + "")
.replaceAll("\\{5\\}", fixedEffect.getParticleEffect().getName())
.replaceAll("\\{6\\}", fixedEffect.getParticleStyle().getName())
.replaceAll("\\{7\\}", fixedEffect.getDataString()); // @formatter:on
LangManager.sendCustomMessage(p, listMessage);
});
} else if (cmd.equalsIgnoreCase("clear")) {
if (!p.hasPermission("playerparticles.fixed.clear")) {
LangManager.sendMessage(p, Lang.CLEAR_FIXED_NO_PERMISSION);
return;
}
if (args.length < 1) {
LangManager.sendMessage(p, Lang.CLEAR_FIXED_NO_ARGS);
return;
}
int radius = -1;
try {
radius = Math.abs(Integer.parseInt(args[0]));
} catch (Exception e) {
LangManager.sendMessage(p, Lang.CLEAR_FIXED_INVALID_ARGS);
return;
}
ArrayList<FixedParticleEffect> fixedEffectsToRemove = new ArrayList<FixedParticleEffect>();
for (FixedParticleEffect fixedEffect : ParticleManager.fixedParticleEffects)
if (fixedEffect.getLocation().getWorld() == p.getLocation().getWorld() && fixedEffect.getLocation().distance(p.getLocation()) <= radius)
fixedEffectsToRemove.add(fixedEffect);
for (FixedParticleEffect fixedEffect : fixedEffectsToRemove)
DataManager.getInstance().removeFixedEffect(fixedEffect.getOwnerUniqueId(), fixedEffect.getId(), (successful) -> { });
String clearMessage = Lang.CLEAR_FIXED_SUCCESS.get() // @formatter:off
.replaceAll("\\{0\\}", fixedEffectsToRemove.size() + "")
.replaceAll("\\{1\\}", radius + ""); // @formatter:on
LangManager.sendCustomMessage(p, clearMessage);
return;
} else {
LangManager.sendMessage(p, Lang.INVALID_FIXED_COMMAND);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_CREATE);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_REMOVE);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_LIST);
LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_INFO);
if (p.hasPermission("playerparticles.fixed.clear")) LangManager.sendMessage(p, Lang.FIXED_COMMAND_DESC_CLEAR);
}
}
private static final String[] COMMANDS = { "help", "gui", "effect", "effects", "style", "styles", "data", "fixed", "reset", "worlds", "version" };
private static final String[] FIXED_COMMANDS = { "create", "remove", "list", "info" };
private static final List<String> BLOCK_MATERIALS = ParticleUtils.getAllBlockMaterials();
private static final List<String> ITEM_MATERIALS = ParticleUtils.getAllItemMaterials();
// private static final String[] COMMANDS = { "help", "gui", "effect", "effects", "style", "styles", "data", "fixed", "reset", "worlds", "version" };
// private static final String[] FIXED_COMMANDS = { "create", "remove", "list", "info" };
// private static final List<String> BLOCK_MATERIALS = ParticleUtils.getAllBlockMaterials();
// private static final List<String> ITEM_MATERIALS = ParticleUtils.getAllItemMaterials();
/**
* Activated when a user pushes tab in chat prefixed with /pp
@ -751,55 +124,55 @@ public class ParticleCommandHandler implements CommandExecutor, TabCompleter {
}
// TODO: Move to correct CommandModules
if (args[0].equalsIgnoreCase("effect") && args.length == 2) {
List<String> commands = PermissionManager.getEffectsUserHasPermissionFor((Player) sender);
StringUtil.copyPartialMatches(args[1], commands, completions);
} else if (args[0].equalsIgnoreCase("style") && args.length == 2) {
List<String> commands = PermissionManager.getStylesUserHasPermissionFor((Player) sender);
StringUtil.copyPartialMatches(args[1], commands, completions);
} else if (args[0].equalsIgnoreCase("fixed") && args.length > 1) {
if (args.length == 2) {
List<String> commands = Arrays.asList(FIXED_COMMANDS);
StringUtil.copyPartialMatches(args[1], commands, completions);
} else if (args[1].equalsIgnoreCase("create")) {
completions.add("<x> <y> <z> <effect> <style> [data]");
} else if ((args[1].equalsIgnoreCase("remove") || args[1].equalsIgnoreCase("info")) && args.length == 3) {
completions.add("<id>");
}
} else if (args[0].equalsIgnoreCase("data")) {
PPlayer pplayer = DataManager.getPPlayer(((Player) sender).getUniqueId());
if (pplayer == null) {
completions.add(ChatColor.stripColor(Lang.NO_DATA_USAGE.get()));
} else if (pplayer.getParticleEffect().hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA) && args.length == 2) {
if (pplayer.getParticleEffect() == ParticleEffect.ITEM) {
StringUtil.copyPartialMatches(args[1], ITEM_MATERIALS, completions);
} else {
StringUtil.copyPartialMatches(args[1], BLOCK_MATERIALS, completions);
}
} else if (pplayer.getParticleEffect().hasProperty(ParticleProperty.COLORABLE)) {
if (pplayer.getParticleEffect() == ParticleEffect.NOTE && args.length == 2) {
completions.add("<0-23>");
StringUtil.copyPartialMatches(args[args.length - 1], Arrays.asList(new String[] { "rainbow" }), completions);
} else if (pplayer.getParticleEffect() != ParticleEffect.NOTE && args.length > 1 && args.length < 5) {
completions.add("<0-255>");
if (args.length == 2) {
StringUtil.copyPartialMatches(args[args.length - 1], Arrays.asList(new String[] { "rainbow" }), completions);
}
}
} else if (args.length == 2) {
completions.add(ChatColor.stripColor(Lang.NO_DATA_USAGE.get()));
}
}
} else {
List<String> commands = new ArrayList<String>(Arrays.asList(COMMANDS));
StringUtil.copyPartialMatches(args[0], commands, completions);
// if (args[0].equalsIgnoreCase("effect") && args.length == 2) {
// List<String> commands = PermissionManager.getEffectsUserHasPermissionFor((Player) sender);
// StringUtil.copyPartialMatches(args[1], commands, completions);
// } else if (args[0].equalsIgnoreCase("style") && args.length == 2) {
// List<String> commands = PermissionManager.getStylesUserHasPermissionFor((Player) sender);
// StringUtil.copyPartialMatches(args[1], commands, completions);
// } else if (args[0].equalsIgnoreCase("fixed") && args.length > 1) {
// if (args.length == 2) {
// List<String> commands = Arrays.asList(FIXED_COMMANDS);
// StringUtil.copyPartialMatches(args[1], commands, completions);
// } else if (args[1].equalsIgnoreCase("create")) {
// completions.add("<x> <y> <z> <effect> <style> [data]");
// } else if ((args[1].equalsIgnoreCase("remove") || args[1].equalsIgnoreCase("info")) && args.length == 3) {
// completions.add("<id>");
// }
// } else if (args[0].equalsIgnoreCase("data")) {
// PPlayer pplayer = DataManager.getPPlayer(((Player) sender).getUniqueId());
// if (pplayer == null) {
// completions.add(ChatColor.stripColor(Lang.NO_DATA_USAGE.get()));
// } else if (pplayer.getParticleEffect().hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA) && args.length == 2) {
// if (pplayer.getParticleEffect() == ParticleEffect.ITEM) {
// StringUtil.copyPartialMatches(args[1], ITEM_MATERIALS, completions);
// } else {
// StringUtil.copyPartialMatches(args[1], BLOCK_MATERIALS, completions);
// }
// } else if (pplayer.getParticleEffect().hasProperty(ParticleProperty.COLORABLE)) {
// if (pplayer.getParticleEffect() == ParticleEffect.NOTE && args.length == 2) {
// completions.add("<0-23>");
// StringUtil.copyPartialMatches(args[args.length - 1], Arrays.asList(new String[] { "rainbow" }), completions);
// } else if (pplayer.getParticleEffect() != ParticleEffect.NOTE && args.length > 1 && args.length < 5) {
// completions.add("<0-255>");
// if (args.length == 2) {
// StringUtil.copyPartialMatches(args[args.length - 1], Arrays.asList(new String[] { "rainbow" }), completions);
// }
// }
// } else if (args.length == 2) {
// completions.add(ChatColor.stripColor(Lang.NO_DATA_USAGE.get()));
// }
// }
// } else {
// List<String> commands = new ArrayList<String>(Arrays.asList(COMMANDS));
// StringUtil.copyPartialMatches(args[0], commands, completions);
}
}
return null;
}
public static String[] getCommandsList() {
return COMMANDS;
}
// public static String[] getCommandsList() {
// return COMMANDS;
// }
}

32
src/com/esophose/playerparticles/command/ResetCommandModule.java
View file

@ -2,13 +2,45 @@ package com.esophose.playerparticles.command;
import java.util.List;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import com.esophose.playerparticles.manager.DataManager;
import com.esophose.playerparticles.manager.LangManager;
import com.esophose.playerparticles.manager.PermissionManager;
import com.esophose.playerparticles.manager.LangManager.Lang;
import com.esophose.playerparticles.particles.PPlayer;
import com.esophose.playerparticles.particles.ParticleGroup;
public class ResetCommandModule implements CommandModule {
public void onCommandExecute(PPlayer pplayer, String[] args) {
if (args.length >= 1) {
String altPlayerName = args[0];
if (!PermissionManager.canUseForceReset(pplayer.getPlayer())) {
LangManager.sendMessage(pplayer, Lang.FAILED_EXECUTE_NO_PERMISSION, altPlayerName);
} else {
Player targetPlayer = null;
for (Player p : Bukkit.getOnlinePlayers()) {
if (p.getName().toLowerCase().contains(altPlayerName.toLowerCase())) {
targetPlayer = p;
break;
}
}
if (targetPlayer == null) {
LangManager.sendMessage(pplayer, Lang.FAILED_EXECUTE_NOT_FOUND, altPlayerName);
} else {
DataManager.saveParticleGroup(targetPlayer.getUniqueId(), ParticleGroup.getDefaultGroup());
LangManager.sendMessage(targetPlayer, Lang.RESET);
LangManager.sendMessage(pplayer, Lang.EXECUTED_FOR_PLAYER, targetPlayer.getName());
}
}
} else {
DataManager.saveParticleGroup(pplayer.getUniqueId(), ParticleGroup.getDefaultGroup());
LangManager.sendMessage(pplayer, Lang.RESET);
}
}
public List<String> onTabComplete(PPlayer pplayer, String[] args) {

3
src/com/esophose/playerparticles/command/StyleCommandModule.java
View file

@ -2,13 +2,14 @@ package com.esophose.playerparticles.command;
import java.util.List;
import com.esophose.playerparticles.manager.LangManager;
import com.esophose.playerparticles.manager.LangManager.Lang;
import com.esophose.playerparticles.particles.PPlayer;
public class StyleCommandModule implements CommandModule {
public void onCommandExecute(PPlayer pplayer, String[] args) {
LangManager.sendMessage(pplayer, Lang.COMMAND_REMOVED);
}
public List<String> onTabComplete(PPlayer pplayer, String[] args) {

25
src/com/esophose/playerparticles/command/StylesCommandModule.java
View file

@ -2,13 +2,38 @@ package com.esophose.playerparticles.command;
import java.util.List;
import org.bukkit.entity.Player;
import com.esophose.playerparticles.manager.LangManager;
import com.esophose.playerparticles.manager.PermissionManager;
import com.esophose.playerparticles.manager.LangManager.Lang;
import com.esophose.playerparticles.particles.PPlayer;
import com.esophose.playerparticles.styles.api.ParticleStyle;
import com.esophose.playerparticles.styles.api.ParticleStyleManager;
public class StylesCommandModule implements CommandModule {
public void onCommandExecute(PPlayer pplayer, String[] args) {
Player p = pplayer.getPlayer();
if (PermissionManager.getStylesUserHasPermissionFor(p).size() == 1) {
LangManager.sendMessage(pplayer, Lang.NO_STYLES);
return;
}
String toSend = Lang.USE.get() + " ";
for (ParticleStyle style : ParticleStyleManager.getStyles()) {
if (PermissionManager.hasStylePermission(p, style)) {
toSend += style.getName();
toSend += ", ";
}
}
if (toSend.endsWith(", ")) {
toSend = toSend.substring(0, toSend.length() - 2);
}
LangManager.sendCustomMessage(p, toSend);
LangManager.sendCustomMessage(p, Lang.USAGE.get() + " " + Lang.STYLE_USAGE.get());
}
public List<String> onTabComplete(PPlayer pplayer, String[] args) {

265
src/com/esophose/playerparticles/gui/PlayerParticlesGui.java
View file

@ -18,7 +18,6 @@ import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Color;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.Particle;
@ -41,13 +40,17 @@ import org.bukkit.scheduler.BukkitRunnable;
import com.esophose.playerparticles.PlayerParticles;
import com.esophose.playerparticles.manager.DataManager;
import com.esophose.playerparticles.manager.LangManager.Lang;
import com.esophose.playerparticles.manager.ParticleManager;
import com.esophose.playerparticles.manager.PermissionManager;
import com.esophose.playerparticles.particles.PPlayer;
import com.esophose.playerparticles.particles.ParticleEffect;
import com.esophose.playerparticles.particles.ParticleEffect.NoteColor;
import com.esophose.playerparticles.particles.ParticleEffect.OrdinaryColor;
import com.esophose.playerparticles.particles.ParticleEffect.ParticleColor;
import com.esophose.playerparticles.particles.ParticleEffect.ParticleProperty;
import com.esophose.playerparticles.manager.ParticleManager;
import com.esophose.playerparticles.manager.PermissionManager;
import com.esophose.playerparticles.particles.ParticleGroup;
import com.esophose.playerparticles.particles.ParticlePair;
import com.esophose.playerparticles.styles.DefaultStyles;
import com.esophose.playerparticles.styles.api.ParticleStyle;
import com.esophose.playerparticles.styles.api.ParticleStyleManager;
import com.esophose.playerparticles.util.ParticleUtils;
@ -56,6 +59,7 @@ import com.esophose.playerparticles.util.ParticleUtils;
* This class provides a collection of static methods for modifying your
* particle/style/data through the use of a GUI
*/
// TODO: This entire GUI is currently hardwired to only work with the first particle in the player's list, make it with with everything
public class PlayerParticlesGui extends BukkitRunnable implements Listener {
/**
@ -188,6 +192,157 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
new PlayerParticlesGui().runTaskTimer(PlayerParticles.getPlugin(), 0, 10);
}
// TODO: Delete these specialized getter methods once the new GUI is finished
private static ParticleEffect getPPlayerEffect(PPlayer pplayer) {
List<ParticlePair> particles = pplayer.getActiveParticles();
if (particles.isEmpty()) return ParticleEffect.NONE;
return particles.get(0).getEffect();
}
private static ParticleStyle getPPlayerStyle(PPlayer pplayer) {
List<ParticlePair> particles = pplayer.getActiveParticles();
if (particles.isEmpty()) return DefaultStyles.NONE;
return particles.get(0).getStyle();
}
private static Material getPPlayerItemMaterial(PPlayer pplayer) {
List<ParticlePair> particles = pplayer.getActiveParticles();
if (particles.isEmpty()) return ParticlePair.getDefault().getItemMaterial();
return particles.get(0).getItemMaterial();
}
private static Material getPPlayerBlockMaterial(PPlayer pplayer) {
List<ParticlePair> particles = pplayer.getActiveParticles();
if (particles.isEmpty()) return ParticlePair.getDefault().getBlockMaterial();
return particles.get(0).getBlockMaterial();
}
private static OrdinaryColor getPPlayerColor(PPlayer pplayer) {
List<ParticlePair> particles = pplayer.getActiveParticles();
if (particles.isEmpty()) return ParticlePair.getDefault().getColor();
return particles.get(0).getColor();
}
private static NoteColor getPPlayerNoteColor(PPlayer pplayer) {
List<ParticlePair> particles = pplayer.getActiveParticles();
if (particles.isEmpty()) return ParticlePair.getDefault().getNoteColor();
return particles.get(0).getNoteColor();
}
private static Material getPPlayerSpawnMaterial(PPlayer pplayer) {
List<ParticlePair> particles = pplayer.getActiveParticles();
if (particles.isEmpty()) return ParticlePair.getDefault().getSpawnMaterial();
return particles.get(0).getSpawnMaterial();
}
private static ParticleColor getPPlayerSpawnColor(PPlayer pplayer) {
List<ParticlePair> particles = pplayer.getActiveParticles();
if (particles.isEmpty()) return ParticlePair.getDefault().getSpawnColor();
return particles.get(0).getSpawnColor();
}
private static String getPPlayerDataString(PPlayer pplayer) {
List<ParticlePair> particles = pplayer.getActiveParticles();
if (particles.isEmpty()) return ParticlePair.getDefault().getDataString();
return particles.get(0).getDataString();
}
private static void setPPlayerEffect(PPlayer pplayer, ParticleEffect effect) {
List<ParticlePair> particles = pplayer.getActiveParticles();
ParticlePair particle;
if (particles.isEmpty())
particle = ParticlePair.getDefault(pplayer.getUniqueId());
else
particle = particles.get(0);
particle.setEffect(effect);
particles.clear();
particles.add(particle);
ParticleGroup group = new ParticleGroup(null, particles);
DataManager.saveParticleGroup(pplayer.getUniqueId(), group);
}
private static void setPPlayerStyle(PPlayer pplayer, ParticleStyle style) {
List<ParticlePair> particles = pplayer.getActiveParticles();
ParticlePair particle;
if (particles.isEmpty())
particle = ParticlePair.getDefault(pplayer.getUniqueId());
else
particle = particles.get(0);
particle.setStyle(style);
particles.clear();
particles.add(particle);
ParticleGroup group = new ParticleGroup(null, particles);
DataManager.saveParticleGroup(pplayer.getUniqueId(), group);
}
private static void setPPlayerItemMaterial(PPlayer pplayer, Material material) {
List<ParticlePair> particles = pplayer.getActiveParticles();
ParticlePair particle;
if (particles.isEmpty())
particle = ParticlePair.getDefault(pplayer.getUniqueId());
else
particle = particles.get(0);
particle.setItemMaterial(material);
particles.clear();
particles.add(particle);
ParticleGroup group = new ParticleGroup(null, particles);
DataManager.saveParticleGroup(pplayer.getUniqueId(), group);
}
private static void setPPlayerBlockMaterial(PPlayer pplayer, Material material) {
List<ParticlePair> particles = pplayer.getActiveParticles();
ParticlePair particle;
if (particles.isEmpty())
particle = ParticlePair.getDefault(pplayer.getUniqueId());
else
particle = particles.get(0);
particle.setBlockMaterial(material);
particles.clear();
particles.add(particle);
ParticleGroup group = new ParticleGroup(null, particles);
DataManager.saveParticleGroup(pplayer.getUniqueId(), group);
}
private static void setPPlayerColor(PPlayer pplayer, OrdinaryColor color) {
List<ParticlePair> particles = pplayer.getActiveParticles();
ParticlePair particle;
if (particles.isEmpty())
particle = ParticlePair.getDefault(pplayer.getUniqueId());
else
particle = particles.get(0);
particle.setColor(color);
particles.clear();
particles.add(particle);
ParticleGroup group = new ParticleGroup(null, particles);
DataManager.saveParticleGroup(pplayer.getUniqueId(), group);
}
private static void setPPlayerNoteColor(PPlayer pplayer, NoteColor noteColor) {
List<ParticlePair> particles = pplayer.getActiveParticles();
ParticlePair particle;
if (particles.isEmpty())
particle = ParticlePair.getDefault(pplayer.getUniqueId());
else
particle = particles.get(0);
particle.setNoteColor(noteColor);
particles.clear();
particles.add(particle);
ParticleGroup group = new ParticleGroup(null, particles);
DataManager.saveParticleGroup(pplayer.getUniqueId(), group);
}
/**
* Updates all color/note data inventories to display the rainbow icon
* Removes any players who are no longer online from playerGuiInventoriesd
@ -197,7 +352,7 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
for (Map.Entry<UUID, GuiInventory> entry : playerGuiInventories.entrySet()) {
UUID playerUUID = entry.getKey();
PPlayer pplayer = DataManager.getInstance().getPPlayer(playerUUID);
PPlayer pplayer = DataManager.getPPlayer(playerUUID);
if (pplayer == null) {
toRemoveList.add(playerUUID);
continue;
@ -212,12 +367,12 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
GuiInventory guiInventory = entry.getValue();
Inventory inventory = guiInventory.getInventory();
if (player.getOpenInventory().getTopInventory().equals(inventory) && guiInventory.getGuiState() == GuiState.DATA && pplayer.getParticleEffect().hasProperty(ParticleProperty.COLORABLE)) {
if (player.getOpenInventory().getTopInventory().equals(inventory) && guiInventory.getGuiState() == GuiState.DATA && getPPlayerEffect(pplayer).hasProperty(ParticleProperty.COLORABLE)) {
ItemStack rainbowIcon;
if (pplayer.getParticleEffect() != ParticleEffect.NOTE) {
rainbowIcon = getItemForRainbowColorData(pplayer.getColorData(), rainbowColors[rainbowColorsIndex]);
if (getPPlayerEffect(pplayer) != ParticleEffect.NOTE) {
rainbowIcon = getItemForRainbowColorData(getPPlayerColor(pplayer), rainbowColors[rainbowColorsIndex]);
} else {
rainbowIcon = getItemForRainbowNoteData(pplayer.getNoteColorData(), rainbowColors[rainbowColorsIndex]);
rainbowIcon = getItemForRainbowNoteData(getPPlayerNoteColor(pplayer), rainbowColors[rainbowColorsIndex]);
}
inventory.setItem(40, rainbowIcon);
}
@ -264,20 +419,20 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
* Changes the GUI to the indicated state
* If the GUI isn't open yet, it gets opened
*
* @param p The pplayer
* @param pplayer The pplayer
* @param state The new state
*/
public static void changeState(PPlayer p, GuiState state) {
Player player = p.getPlayer();
public static void changeState(PPlayer pplayer, GuiState state) {
Player player = pplayer.getPlayer();
if ((state == GuiState.EFFECT && PermissionManager.getEffectsUserHasPermissionFor(player).size() == 1) ||
(state == GuiState.STYLE && PermissionManager.getStylesUserHasPermissionFor(player).size() == 1) ||
(state == GuiState.DATA && p.getSpawnMaterial() == null && p.getSpawnColor() == null)) return;
(state == GuiState.DATA && getPPlayerSpawnMaterial(pplayer) == null && getPPlayerSpawnColor(pplayer) == null)) return;
// Update the state and create an inventory for the player if one isn't already open for them
// If they have the wrong inventory open for some reason, create a new one and open it for them
if (playerGuiInventories.containsKey(p.getUniqueId())) {
GuiInventory guiInventory = playerGuiInventories.get(p.getUniqueId());
if (playerGuiInventories.containsKey(pplayer.getUniqueId())) {
GuiInventory guiInventory = playerGuiInventories.get(pplayer.getUniqueId());
guiInventory.setGuiState(state);
if (!player.getOpenInventory().getTopInventory().equals(guiInventory.getInventory())) {
player.openInventory(guiInventory.getInventory());
@ -285,21 +440,21 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
} else {
Inventory ppInventory = Bukkit.createInventory(null, INVENTORY_SIZE, "PlayerParticles");
player.openInventory(ppInventory);
playerGuiInventories.put(p.getUniqueId(), new GuiInventory(ppInventory, state));
playerGuiInventories.put(pplayer.getUniqueId(), new GuiInventory(ppInventory, state));
}
switch (state) {
case DEFAULT:
populateDefault(p);
populateDefault(pplayer);
break;
case EFFECT:
populateEffect(p);
populateEffect(pplayer);
break;
case STYLE:
populateStyle(p);
populateStyle(pplayer);
break;
case DATA:
populateData(p);
populateData(pplayer);
break;
}
}
@ -307,10 +462,10 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
/**
* Opens the menu to go to other menus: effect, style, data
*
* @param p The PPlayer
* @param pplayer The PPlayer
*/
private static void populateDefault(PPlayer p) {
Player player = p.getPlayer();
private static void populateDefault(PPlayer pplayer) {
Player player = pplayer.getPlayer();
Inventory inventory = player.getOpenInventory().getTopInventory();
inventory.clear(); // Make sure the inventory is always empty before we start adding items
@ -326,9 +481,9 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
SkullMeta currentIconMeta = (SkullMeta) currentIcon.getItemMeta();
currentIconMeta.setDisplayName(ChatColor.GREEN + player.getName());
String[] currentIconLore = new String[3];
currentIconLore[0] = ChatColor.YELLOW + "Effect: " + ChatColor.AQUA + p.getParticleEffect().getName();
currentIconLore[1] = ChatColor.YELLOW + "Style: " + ChatColor.AQUA + p.getParticleStyle().getName();
currentIconLore[2] = ChatColor.YELLOW + "Active Data: " + ChatColor.AQUA + p.getDataString();
currentIconLore[0] = ChatColor.YELLOW + "Effect: " + ChatColor.AQUA + getPPlayerEffect(pplayer).getName();
currentIconLore[1] = ChatColor.YELLOW + "Style: " + ChatColor.AQUA + getPPlayerStyle(pplayer).getName();
currentIconLore[2] = ChatColor.YELLOW + "Active Data: " + ChatColor.AQUA + getPPlayerDataString(pplayer);
currentIconMeta.setLore(Arrays.asList(currentIconLore));
currentIconMeta.setOwner(player.getName());
//currentIconMeta.setOwningPlayer(Bukkit.getOfflinePlayer(player.getUniqueId())); // This doesn't exist in 1.9
@ -355,7 +510,7 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
ItemStack dataIcon = new ItemStack(defaultMenuIcons[2], 1);
ItemMeta dataIconMeta = dataIcon.getItemMeta();
dataIconMeta.setDisplayName(ChatColor.GREEN + "Data");
ParticleEffect pe = p.getParticleEffect();
ParticleEffect pe = getPPlayerEffect(pplayer);
String dataType = "data";
if (pe.hasProperty(ParticleProperty.COLORABLE)) // @formatter:off
if (pe == ParticleEffect.NOTE) dataType = "note " + dataType;
@ -363,7 +518,7 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
else if (pe.hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA)) if (pe == ParticleEffect.ITEM) dataType = "item " + dataType;
else dataType = "block " + dataType; // @formatter:on
dataIconMeta.setLore(Arrays.asList(Lang.GUI_ICON_SET_YOUR.getMessageReplaced(dataType)));
if (p.getSpawnMaterial() == null && p.getSpawnColor() == null) {
if (getPPlayerSpawnMaterial(pplayer) == null && getPPlayerSpawnColor(pplayer) == null) {
dataIconMeta.setLore(Arrays.asList(Lang.GUI_NO_DATA.get()));
}
dataIcon.setItemMeta(dataIconMeta);
@ -377,10 +532,10 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
/**
* Opens the menu that allows you to select an effect you have permission for
*
* @param p The PPlayer
* @param pplayer The PPlayer
*/
private static void populateEffect(PPlayer p) {
Player player = p.getPlayer();
private static void populateEffect(PPlayer pplayer) {
Player player = pplayer.getPlayer();
Inventory inventory = player.getOpenInventory().getTopInventory();
inventory.clear(); // Make sure the inventory is always empty before we start adding items
@ -388,7 +543,7 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
for (int i = 0; i < effectsUserHasPermissionFor.size(); i++) {
String s = effectsUserHasPermissionFor.get(i);
ParticleEffect effect = ParticleManager.effectFromString(s);
inventory.setItem(i, getItemForEffect(effect, effect == p.getParticleEffect()));
inventory.setItem(i, getItemForEffect(effect, effect == getPPlayerEffect(pplayer)));
}
inventory.setItem(INVENTORY_SIZE - 1, getItemForBack());
@ -397,10 +552,10 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
/**
* Opens the menu that allows you to select a style you have permission for
*
* @param p The PPlayer
* @param pplayer The PPlayer
*/
private static void populateStyle(PPlayer p) {
Player player = p.getPlayer();
private static void populateStyle(PPlayer pplayer) {
Player player = pplayer.getPlayer();
Inventory inventory = player.getOpenInventory().getTopInventory();
inventory.clear(); // Make sure the inventory is always empty before we start adding items
@ -409,7 +564,7 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
for (int i = 0; i < stylesUserHasPermissionFor.size(); i++) {
String s = stylesUserHasPermissionFor.get(i);
ParticleStyle style = ParticleStyleManager.styleFromString(s);
inventory.setItem(i, getItemForStyle(style, style == p.getParticleStyle()));
inventory.setItem(i, getItemForStyle(style, style == getPPlayerStyle(pplayer)));
}
inventory.setItem(INVENTORY_SIZE - 1, getItemForBack());
@ -418,19 +573,19 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
/**
* Opens the menu that allows you to select some preset data
*
* @param p The PPlayer
* @param pplayer The PPlayer
*/
private static void populateData(PPlayer p) {
Player player = p.getPlayer();
private static void populateData(PPlayer pplayer) {
Player player = pplayer.getPlayer();
Inventory inventory = player.getOpenInventory().getTopInventory();
inventory.clear(); // Make sure the inventory is always empty before we start adding items
// There are a lot of for loops here, somebody submit a pull request if you have a better way of doing this
ParticleEffect pe = p.getParticleEffect();
ParticleEffect pe = getPPlayerEffect(pplayer);
if (pe.hasProperty(ParticleProperty.COLORABLE)) {
if (pe == ParticleEffect.NOTE) { // Note data
NoteColor currentNote = p.getNoteColorData();
NoteColor currentNote = getPPlayerNoteColor(pplayer);
int noteIndex = 0;
for (int i = 1; i <= 7; i++) { // Top row
inventory.setItem(i, getItemForNoteData(currentNote, noteIndex));
@ -449,9 +604,9 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
noteIndex++;
}
inventory.setItem(40, getItemForRainbowNoteData(p.getNoteColorData(), rainbowColors[rainbowColorsIndex]));
inventory.setItem(40, getItemForRainbowNoteData(getPPlayerNoteColor(pplayer), rainbowColors[rainbowColorsIndex]));
} else { // Color data
OrdinaryColor currentColor = p.getColorData();
OrdinaryColor currentColor = getPPlayerColor(pplayer);
int colorIndex = 0;
for (int i = 10; i <= 16; i++) { // Top row
inventory.setItem(i, getItemForColorData(currentColor, colorIndex));
@ -466,14 +621,14 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
colorIndex++;
}
inventory.setItem(40, getItemForRainbowColorData(p.getColorData(), rainbowColors[rainbowColorsIndex]));
inventory.setItem(40, getItemForRainbowColorData(getPPlayerColor(pplayer), rainbowColors[rainbowColorsIndex]));
}
} else if (pe.hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA)) {
List<Material> materialBag = new ArrayList<Material>();
int materialIndex = 0;
if (pe == ParticleEffect.ITEM) { // Item data
Material currentItemMaterial = p.getMaterialData().getMaterial();
Material currentItemMaterial = getPPlayerItemMaterial(pplayer);
while (materialBag.size() < 28) { // Grab 28 random materials that are an item
Material randomMaterial = ITEM_MATERIALS.get(RANDOM.nextInt(ITEM_MATERIALS.size()));
@ -498,7 +653,7 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
materialIndex++;
}
} else { // Block data
Material currentBlockMaterial = p.getBlockData().getMaterial();
Material currentBlockMaterial = getPPlayerBlockMaterial(pplayer);
while (materialBag.size() < 28) { // Grab 28 random materials that are an item
Material randomMaterial = BLOCK_MATERIALS.get(RANDOM.nextInt(BLOCK_MATERIALS.size()));
@ -549,7 +704,7 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
if (!guiInventory.getInventory().equals(e.getClickedInventory())) return; // Clicked bottom inventory
PPlayer pplayer = DataManager.getInstance().getPPlayer(player.getUniqueId());
PPlayer pplayer = DataManager.getPPlayer(player.getUniqueId());
if (pplayer == null) {
player.closeInventory();
return;
@ -576,30 +731,30 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
}
break;
case EFFECT:
DataManager.getInstance().savePPlayer(pplayer.getUniqueId(), ParticleManager.effectFromString(name));
setPPlayerEffect(pplayer, ParticleManager.effectFromString(name));
changeState(pplayer, GuiState.DEFAULT);
break;
case STYLE:
DataManager.getInstance().savePPlayer(pplayer.getUniqueId(), ParticleStyleManager.styleFromString(name));
setPPlayerStyle(pplayer, ParticleStyleManager.styleFromString(name));
changeState(pplayer, GuiState.DEFAULT);
break;
case DATA:
ParticleEffect pe = pplayer.getParticleEffect();
ParticleEffect pe = getPPlayerEffect(pplayer);
if (pe.hasProperty(ParticleProperty.COLORABLE)) {
if (pe == ParticleEffect.NOTE) {
if (clicked.getItemMeta().getDisplayName().equals(rainbowName)) {
DataManager.getInstance().savePPlayer(pplayer.getUniqueId(), new NoteColor(99));
setPPlayerNoteColor(pplayer, new NoteColor(99));
} else {
int note = Integer.parseInt(ChatColor.stripColor(clicked.getItemMeta().getDisplayName()).substring(6));
DataManager.getInstance().savePPlayer(pplayer.getUniqueId(), new NoteColor(note));
setPPlayerNoteColor(pplayer, new NoteColor(note));
}
} else {
if (clicked.getItemMeta().getDisplayName().equals(rainbowName)) {
DataManager.getInstance().savePPlayer(pplayer.getUniqueId(), new OrdinaryColor(999, 999, 999));
setPPlayerColor(pplayer, new OrdinaryColor(999, 999, 999));
} else {
for (int i = 0; i < colorMapping.length; i++) {
if (clicked.getItemMeta().getDisplayName().equals(colorMapping[i].getName())) {
DataManager.getInstance().savePPlayer(pplayer.getUniqueId(), colorMapping[i].getOrdinaryColor());
setPPlayerColor(pplayer, colorMapping[i].getOrdinaryColor());
}
}
}
@ -607,9 +762,9 @@ public class PlayerParticlesGui extends BukkitRunnable implements Listener {
} else if (pe.hasProperty(ParticleProperty.REQUIRES_MATERIAL_DATA)) {
Material clickedMaterial = clicked.getType(); // All preset materials have a data value of 0
if (pe == ParticleEffect.ITEM) {
DataManager.getInstance().savePPlayer(pplayer.getUniqueId(), new ItemData(clickedMaterial));
setPPlayerItemMaterial(pplayer, clickedMaterial);
} else {
DataManager.getInstance().savePPlayer(pplayer.getUniqueId(), new BlockData(clickedMaterial));
setPPlayerBlockMaterial(pplayer, clickedMaterial);
}
}

46
src/com/esophose/playerparticles/manager/DataManager.java
View file

@ -14,7 +14,6 @@ import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.scheduler.BukkitRunnable;
@ -342,7 +341,7 @@ public class DataManager { // @formatter:off
* @param id The id of the effect to remove
* @param callback The callback to execute with if the fixed effect was removed or not
*/
public static void removeFixedEffect(UUID playerUUID, int id, ConfigurationCallback<Boolean> callback) {
public static void removeFixedEffect(UUID playerUUID, int id) {
async(() -> {
PlayerParticles.databaseConnector.connect((connection) -> {
String particleUUID = null;
@ -378,53 +377,20 @@ public class DataManager { // @formatter:off
});
}
/**
* Gets a list of all fixed effect ids for a player
*
* @param pplayerUUID The player
* @param callback The callback to execute with a list of all fixed effect ids for the given player
*/
public static void getFixedEffectIdsForPlayer(UUID pplayerUUID, ConfigurationCallback<List<Integer>> callback) {
getPPlayer(pplayerUUID, (pplayer) -> {
callback.execute(pplayer.getFixedEffectIds());
});
}
/**
* Checks if the given player has reached the max number of fixed effects
*
* @param pplayerUUID The player to check
* @param callback The callback to execute with if the player can create any more fixed effects
* @return If the player has reached the max number of fixed effects
*/
public static void hasPlayerReachedMaxFixedEffects(UUID pplayerUUID, ConfigurationCallback<Boolean> callback) {
public static boolean hasPlayerReachedMaxFixedEffects(PPlayer pplayer) {
if (maxFixedEffects == -1) { // Initialize on the fly
maxFixedEffects = PlayerParticles.getPlugin().getConfig().getInt("max-fixed-effects");
}
if (Bukkit.getPlayer(pplayerUUID).hasPermission("playerparticles.fixed.unlimited")) {
callback.execute(false);
return;
}
getPPlayer(pplayerUUID, (pplayer) -> {
callback.execute(pplayer.getFixedEffectIds().size() >= maxFixedEffects);
});
}
/**
* Gets the next Id for a player's fixed effects
*
* @param pplayerUUID The player to get the Id for
* @param callback The callback to execute with the smallest available Id the player can use
*/
public static void getNextFixedEffectId(UUID pplayerUUID, ConfigurationCallback<Integer> callback) {
getPPlayer(pplayerUUID, (pplayer) -> {
List<Integer> fixedEffectIds = pplayer.getFixedEffectIds();
int[] ids = new int[fixedEffectIds.size()];
for (int i = 0; i < fixedEffectIds.size(); i++)
ids[i] = fixedEffectIds.get(i);
callback.execute(ParticleUtils.getSmallestPositiveInt(ids));
});
if (pplayer.getPlayer().hasPermission("playerparticles.fixed.unlimited"))
return false;
return pplayer.getFixedEffectIds().size() >= maxFixedEffects;
}
/**

6
src/com/esophose/playerparticles/manager/LangManager.java
View file

@ -49,6 +49,8 @@ public class LangManager {
VERSION_COMMAND_DESCRIPTION("version-command-description"),
WORLDS_COMMAND_DESCRIPTION("worlds-command-description"),
COMMAND_REMOVED("command-removed"),
// Particles
NO_PERMISSION("message-no-permission"),
NO_PARTICLES("message-no-particles"),
@ -163,8 +165,8 @@ public class LangManager {
*
* @return The message
*/
public String get() {
return this.message;
public String get(String... replacements) {
return String.format(this.message, (Object[])replacements);
}
/**

11
src/com/esophose/playerparticles/manager/ParticleManager.java
View file

@ -38,7 +38,7 @@ public class ParticleManager extends BukkitRunnable implements Listener {
/**
* The list containing all the loaded PPlayer info
*/
public static ArrayList<PPlayer> particlePlayers = new ArrayList<PPlayer>();
public static List<PPlayer> particlePlayers = new ArrayList<PPlayer>();
/**
* Rainbow particle effect hue and note color used for rainbow colorable effects
@ -69,6 +69,15 @@ public class ParticleManager extends BukkitRunnable implements Listener {
particlePlayers.remove(pplayer);
}
/**
* Gets the PPlayers that are loaded
*
* @return The loaded PPlayers
*/
public static List<PPlayer> getPPlayers() {
return particlePlayers;
}
/**
* Load a PPlayer for all players on the server who have active particles or fixed effects
*/

20
src/com/esophose/playerparticles/particles/PPlayer.java
View file

@ -16,6 +16,7 @@ import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import com.esophose.playerparticles.styles.api.ParticleStyle;
import com.esophose.playerparticles.util.ParticleUtils;
public class PPlayer {
@ -148,6 +149,11 @@ public class PPlayer {
return null;
}
/**
* Gets a list of ids of all fixed effect this player has
*
* @return A List<Integer> of ids this player's fixed effects have
*/
public List<Integer> getFixedEffectIds() {
List<Integer> ids = new ArrayList<Integer>();
for (FixedParticleEffect fixedEffect : this.fixedParticles)
@ -175,4 +181,18 @@ public class PPlayer {
this.fixedParticles.remove(i);
}
/**
* Gets the next Id for a player's fixed effects
*
* @param pplayerUUID The player to get the Id for
* @return The next available fixed effect id
*/
public int getNextFixedEffectId() {
List<Integer> fixedEffectIds = this.getFixedEffectIds();
int[] ids = new int[fixedEffectIds.size()];
for (int i = 0; i < fixedEffectIds.size(); i++)
ids[i] = fixedEffectIds.get(i);
return ParticleUtils.getSmallestPositiveInt(ids);
}
}

10
src/com/esophose/playerparticles/particles/ParticleGroup.java
View file

@ -1,5 +1,6 @@
package com.esophose.playerparticles.particles;
import java.util.ArrayList;
import java.util.List;
public class ParticleGroup {
@ -31,4 +32,13 @@ public class ParticleGroup {
return this.particles;
}
/**
* Gets an empty ParticleGroup
*
* @return The default empty active ParticleGroup
*/
public static ParticleGroup getDefaultGroup() {
return new ParticleGroup(null, new ArrayList<ParticlePair>());
}
}

16
src/com/esophose/playerparticles/particles/ParticlePair.java
View file

@ -257,4 +257,20 @@ public class ParticlePair {
new NoteColor(0)); // @formatter:on
}
/**
* Gets a ParticlePair with the default values applied
*
* @return A ParticlePair with default values
*/
public static ParticlePair getDefault(UUID ownerUUID) {
return new ParticlePair(ownerUUID, // @formatter:off
1,
ParticleEffect.NONE,
DefaultStyles.NONE,
ParticleUtils.closestMatchWithFallback("IRON_SHOVEL", "IRON_SPADE"),
Material.STONE,
new OrdinaryColor(0, 0, 0),
new NoteColor(0)); // @formatter:on
}
}