· 6 years ago · Oct 18, 2019, 06:36 AM
1package space.essentials;
2
3import java.io.File;
4import java.io.IOException;
5import java.text.SimpleDateFormat;
6import java.util.Date;
7import java.util.ArrayList;
8import java.util.Calendar;
9import java.util.Collection;
10import java.util.GregorianCalendar;
11import java.util.LinkedHashMap;
12import java.util.List;
13import java.util.TimeZone;
14
15import org.bukkit.Bukkit;
16import org.bukkit.GameMode;
17import org.bukkit.Location;
18import org.bukkit.configuration.file.FileConfiguration;
19import org.bukkit.configuration.file.YamlConfiguration;
20import org.bukkit.enchantments.Enchantment;
21import org.bukkit.entity.Player;
22import org.bukkit.event.EventHandler;
23import org.bukkit.event.Listener;
24import org.bukkit.event.block.Action;
25import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
26import org.bukkit.event.player.PlayerInteractEvent;
27import org.bukkit.event.player.PlayerJoinEvent;
28import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
29import org.bukkit.inventory.ItemStack;
30import org.bukkit.inventory.meta.ItemMeta;
31import org.bukkit.plugin.java.JavaPlugin;
32
33import de.tr7zw.nbtapi.NBTItem;
34import io.github.jorelali.commandapi.api.CommandAPI;
35import io.github.jorelali.commandapi.api.CommandPermission;
36import io.github.jorelali.commandapi.api.arguments.Argument;
37import io.github.jorelali.commandapi.api.arguments.BooleanArgument;
38import io.github.jorelali.commandapi.api.arguments.DynamicSuggestedStringArgument;
39import io.github.jorelali.commandapi.api.arguments.EnchantmentArgument;
40import io.github.jorelali.commandapi.api.arguments.EntitySelectorArgument;
41import io.github.jorelali.commandapi.api.arguments.EntitySelectorArgument.EntitySelector;
42import io.github.jorelali.commandapi.api.arguments.GreedyStringArgument;
43import io.github.jorelali.commandapi.api.arguments.IntegerArgument;
44import io.github.jorelali.commandapi.api.arguments.StringArgument;
45import net.md_5.bungee.api.ChatColor;
46
47public class SpaceEssentialsPlugin extends JavaPlugin implements Listener
48{
49 @Override
50 public void onEnable()
51 {
52 //register all commands
53 registerFly();
54 registerPowertool();
55 registerSetwarp();
56 registerDelwarp();
57 registerWarp();
58 registerTpall();
59 registerFeed();
60 registerHeal();
61 registerEnchantUnsafe();
62 registerSudo();
63 registerTop();
64 registerGma();
65 registerGms();
66 registerGmc();
67 registerGmsp();
68 registerTempban();
69 registerRename();
70 //register this as the event listener
71 Bukkit.getPluginManager().registerEvents(this, this);
72 }
73
74 private void registerFly()
75 {
76 //create the arguments hashmap (same as for every other register method)
77 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
78 //register the command using command api (in this case, this is for toggling your own fly status)
79 CommandAPI.getInstance().register("fly", CommandPermission.fromString("spaceessentials.fly.self"), arguments, (sender, args) -> {
80 if(sender instanceof Player)
81 {
82 Player senderP = (Player)sender; //make it so I don't have to do ((Player)sender). for each method I call
83 senderP.setAllowFlight(!senderP.getAllowFlight()); //sets whether they are allowed to fly to the opposite of whatever it currently is
84 senderP.setFlying(senderP.getAllowFlight()); //makes it so they stop flying if they aren't allowed to fly, and stop falling if they are
85 senderP.sendMessage(ChatColor.GOLD + "Fly set to " + senderP.getAllowFlight()); //tells them what it was set to
86 }
87 else
88 {
89 CommandAPI.fail(ChatColor.RED + " when run with no arguments, /fly must be run by a player");
90 }
91 });
92 //adds an entity selector argument, accepting players only
93 arguments.put("players", new EntitySelectorArgument(EntitySelector.MANY_PLAYERS));
94 //registers the command for toggling a group of players fly states
95 CommandAPI.getInstance().register("fly", CommandPermission.fromString("spaceessentials.fly.others"), arguments, (sender, args) -> {
96 Collection<Player> players = (Collection<Player>)args[0];
97 players.forEach((player) -> {
98 player.setAllowFlight(!player.getAllowFlight());
99 player.setFlying(player.getAllowFlight());
100 player.sendMessage(ChatColor.GOLD + "Fly set to " + player.getAllowFlight());
101 sender.sendMessage(ChatColor.GOLD + "Fly for " + player.getName() + " set to " + player.getAllowFlight());
102 });
103 });
104 //adds a boolean argument for what to set the fly states of selected players to
105 arguments.put("value", new BooleanArgument());
106 //registers the command for setting a group of players fly status to a specified state
107 CommandAPI.getInstance().register("fly", CommandPermission.fromString("spaceessentials.fly.others"), arguments, (sender, args) -> {
108 Collection<Player> players = (Collection<Player>)args[0];
109 players.forEach((player) -> {
110 player.setAllowFlight((boolean)args[1]);
111 player.setFlying((boolean)args[1]);
112 player.sendMessage(ChatColor.GOLD + "Fly set to " + (boolean)args[1]);
113 sender.sendMessage(ChatColor.GOLD + "Fly for " + player.getName() + " set to " + player.getAllowFlight());
114 });
115 });
116 }
117
118 @EventHandler
119 public void playerInteractEvent(PlayerInteractEvent event)
120 {
121 //if it is a right click
122 if(event.getAction() == Action.RIGHT_CLICK_AIR || event.getAction() == Action.RIGHT_CLICK_BLOCK)
123 {
124 ItemStack item = event.getItem();
125 //if the item the player is holding isn't null
126 if(!(item == null))
127 {
128 //gets the nbt from the held item
129 NBTItem itemNbt = new NBTItem(item);
130 //if it has the key "powertool"
131 if(itemNbt.hasKey("powertool"))
132 {
133 //runs the command contained and cancels the event
134 event.getPlayer().chat(itemNbt.getString("powertool"));
135 event.setCancelled(true);
136 }
137 }
138 }
139 }
140
141 private void registerPowertool()
142 {
143 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
144 //registers command for removing a command from an item
145 CommandAPI.getInstance().register("powertool", CommandPermission.fromString("spaceessentials.powertool"), new String[] {"pt"}, arguments, (sender,args) -> {
146 if(sender instanceof Player)
147 {
148 Player senderP = (Player)sender;
149 ItemStack disabling = senderP.getInventory().getItemInMainHand();
150 //if they are holding air or something
151 if(disabling.getItemMeta() == null)
152 {
153 CommandAPI.fail("/powertool can only be run when holding an item!");
154 }
155 else
156 {
157 NBTItem disablingNbt = new NBTItem(disabling);
158 if(disablingNbt.hasKey("powertool"))
159 {
160 disablingNbt.removeKey("powertool");
161 senderP.getInventory().setItemInMainHand(disablingNbt.getItem());
162 senderP.updateInventory();
163 sender.sendMessage(ChatColor.GOLD + "Command removed from item");
164 }
165 else
166 {
167 CommandAPI.fail("Item already wasn't a powertool!");
168 }
169 }
170 }
171 else
172 {
173 CommandAPI.fail("/powertool can only be run by a player!");
174 }
175 });
176 //adds a greedy string argument (an argument that essentially turns the rest of the arguments entered into being processed as one string)
177 arguments.put("command",new GreedyStringArgument());
178 //registers the command for setting the command attached to an item
179 CommandAPI.getInstance().register("powertool", CommandPermission.fromString("spaceessentials.powertool"), new String[] {"pt"}, arguments, (sender,args) -> {
180 if(sender instanceof Player)
181 {
182 Player senderP = (Player)sender;
183 ItemStack powertool = senderP.getInventory().getItemInMainHand();
184 if(powertool == null)
185 {
186 CommandAPI.fail("/powertool can only be run when holding an item!");
187 }
188 else
189 {
190 NBTItem powertoolNbt = new NBTItem(powertool);
191 powertoolNbt.setString("powertool", (String)args[0]);
192 senderP.getInventory().setItemInMainHand(powertoolNbt.getItem());
193 senderP.updateInventory();
194 senderP.sendMessage(ChatColor.GOLD + "Item command set to " + (String)args[0]);
195 }
196 }
197 else
198 {
199 CommandAPI.fail("/powertool can only be run by a player!");
200 }
201 });
202 }
203
204 private void registerSetwarp()
205 {
206 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
207 arguments.put("name", new StringArgument());
208 CommandAPI.getInstance().register("setwarp", CommandPermission.fromString("spaceessentials.warp.setwarp"), arguments, (sender, args) -> {
209 if(sender instanceof Player)
210 {
211 FileConfiguration warps = YamlConfiguration.loadConfiguration(new File(getDataFolder(),"warps.yml"));
212 List<String> warpNames = (List<String>)warps.getList("names", new ArrayList<String>());
213 List<Location> warpLocations = (List<Location>)warps.getList("locations",new ArrayList<Location>());
214 warpNames.add((String)args[0]);
215 warpLocations.add(((Player) sender).getLocation());
216 warps.set("names", warpNames);
217 warps.set("locations", warpLocations);
218 try
219 {
220 warps.save(new File(getDataFolder(),"warps.yml"));
221 sender.sendMessage(ChatColor.GOLD + "Created warp " + (String)args[0]);
222 }
223 catch (IOException e)
224 {
225 e.printStackTrace();
226 }
227 }
228 else
229 {
230 CommandAPI.fail("/setwarp can only be run by a player!");
231 }
232 });
233 }
234
235 private void registerDelwarp()
236 {
237 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
238 arguments.put("warp", new DynamicSuggestedStringArgument(() -> {
239 FileConfiguration warps = YamlConfiguration.loadConfiguration(new File(getDataFolder(),"warps.yml"));
240 List<String> warpNames = (List<String>)warps.getList("names", new ArrayList<String>());
241 String[] warpNamesArray = new String[warpNames.size()];
242 for(int i = 0; i < warpNames.size(); i ++)
243 {
244 warpNamesArray[i] = warpNames.get(i);
245 }
246 return warpNamesArray;}));
247 CommandAPI.getInstance().register("delwarp", CommandPermission.fromString("spaceessentials.warp.delwarp"), arguments, (sender, args) -> {
248 FileConfiguration warps = YamlConfiguration.loadConfiguration(new File(getDataFolder(),"warps.yml"));
249 List<String> warpNames = (List<String>)warps.getList("names", new ArrayList<String>());
250 if(warpNames.contains(args[0]))
251 {
252 int index = warpNames.indexOf(args[0]);
253 warpNames.remove(index);
254 List<Location> warpLocations = (List<Location>)warps.getList("locations",new ArrayList<Location>());
255 warpLocations.remove(index);
256 warps.set("names", warpNames);
257 warps.set("locations", warpLocations);
258 try
259 {
260 warps.save(new File(getDataFolder(),"warps.yml"));
261 sender.sendMessage(ChatColor.GOLD + "Deleted warp " + (String)args[0]);
262 }
263 catch (IOException e)
264 {
265 e.printStackTrace();
266 }
267 }
268 else
269 {
270 CommandAPI.fail(ChatColor.RED + "Warp " + (String)args[0] + " does not exist!");
271 }
272 });
273 }
274
275 private void registerWarp()
276 {
277 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
278 arguments.put("warp", new DynamicSuggestedStringArgument(() -> {
279 FileConfiguration warps = YamlConfiguration.loadConfiguration(new File(getDataFolder(),"warps.yml"));
280 List<String> warpNames = (List<String>)warps.getList("names", new ArrayList<String>());
281 String[] warpNamesArray = new String[warpNames.size()];
282 for(int i = 0; i < warpNames.size(); i ++)
283 {
284 warpNamesArray[i] = warpNames.get(i);
285 }
286 return warpNamesArray;}));
287 CommandAPI.getInstance().register("warp", CommandPermission.fromString("spaceessentials.warp.warp"), arguments, (sender, args) -> {
288 if(!(sender instanceof Player))
289 {
290 CommandAPI.fail(ChatColor.RED + "/warp can only be run by a player!");
291 return;
292 }
293 FileConfiguration warps = YamlConfiguration.loadConfiguration(new File(getDataFolder(),"warps.yml"));
294 List<String> warpNames = (List<String>)warps.getList("names", new ArrayList<String>());
295 if(warpNames.contains(args[0]))
296 {
297 Player senderP = (Player)sender;
298 List<Location> warpLocations = (List<Location>)warps.getList("locations",new ArrayList<Location>());
299 senderP.teleport(warpLocations.get(warpNames.indexOf(args[0])), TeleportCause.PLUGIN);
300 sender.sendMessage(ChatColor.GOLD + "Warped to " + (String)args[0]);
301 }
302 else
303 {
304 CommandAPI.fail(ChatColor.RED + "Warp " + (String)args[0] + " does not exist!");
305 }
306 });
307 }
308
309 private void registerTpall()
310 {
311 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
312 CommandAPI.getInstance().register("tpall", CommandPermission.fromString("spaceessentials.tpall"), arguments, (sender, args) -> {
313 if(sender instanceof Player)
314 {
315 Bukkit.getOnlinePlayers().forEach((player) -> {
316 if(player != sender)
317 {
318 player.teleport((Player)sender,TeleportCause.COMMAND);
319 }
320 });
321 sender.sendMessage(ChatColor.GOLD + "Teleported all players to your location");
322 }
323 else
324 {
325 CommandAPI.fail("/tpall can only be run by a player!");
326 }
327 });
328 }
329
330 private void registerFeed()
331 {
332 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
333 CommandAPI.getInstance().register("feed", CommandPermission.fromString("spaceessentials.feed.self"), arguments, (sender, args) -> {
334 if(sender instanceof Player)
335 {
336 ((Player) sender).setFoodLevel(20);
337 ((Player) sender).setSaturation(5f);
338 sender.sendMessage(ChatColor.GOLD + "You have been fed!");
339 }
340 else
341 {
342 CommandAPI.fail("/feed with no players specified can only be run by a player!");
343 }
344 });
345 arguments.put("players", new EntitySelectorArgument(EntitySelector.MANY_PLAYERS));
346 CommandAPI.getInstance().register("feed", CommandPermission.fromString("spaceessentials.feed.others"), arguments, (sender, args) -> {
347 Collection<Player> players = (Collection<Player>)args[0];
348 players.forEach((player) -> {
349 player.setFoodLevel(20);
350 player.setSaturation(5f);
351 player.sendMessage(ChatColor.GOLD + "You have been fed!");
352 sender.sendMessage(ChatColor.GOLD + "Fed " + player.getName() + "!");
353 });
354 });
355 }
356
357 private void registerHeal()
358 {
359 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
360 CommandAPI.getInstance().register("heal", CommandPermission.fromString("spaceessentials.heal.self"), arguments, (sender, args) -> {
361 if(sender instanceof Player)
362 {
363 ((Player) sender).setHealth(20);
364 sender.sendMessage(ChatColor.GOLD + "You have been healed!");
365 }
366 else
367 {
368 CommandAPI.fail("/heal with no players specified can only be run by a player!");
369 }
370 });
371 arguments.put("players", new EntitySelectorArgument(EntitySelector.MANY_PLAYERS));
372 CommandAPI.getInstance().register("heal", CommandPermission.fromString("spaceessentials.heal.others"), arguments, (sender, args) -> {
373 Collection<Player> players = (Collection<Player>)args[0];
374 players.forEach((player) -> {
375 player.setHealth(20);
376 player.sendMessage(ChatColor.GOLD + "You have been healed!");
377 sender.sendMessage(ChatColor.GOLD + "Healed " + player.getName() + "!");
378 });
379 });
380 }
381
382 private void registerEnchantUnsafe()
383 {
384 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
385 arguments.put("enchantment", new EnchantmentArgument());
386 arguments.put("level", new IntegerArgument());
387 CommandAPI.getInstance().register("enchantunsafe", CommandPermission.fromString("spaceessentials.enchantunsafe"), arguments, (sender,args) -> {
388 if(sender instanceof Player)
389 {
390 ItemStack enchanting = ((Player) sender).getInventory().getItemInMainHand();
391 if(enchanting == null)
392 {
393 CommandAPI.fail("/enchantunsafe must be used with an item in hand");
394 }
395 else
396 {
397 int level = (int)args[1];
398 if(level < 0)
399 {
400 CommandAPI.fail("level must be at least 0");
401 }
402 else
403 {
404 enchanting.addUnsafeEnchantment((Enchantment)args[0], level);
405 }
406 }
407 }
408 else
409 {
410 CommandAPI.fail("/enchantunsafe can only be run by a player");
411 }
412 });
413 }
414
415 private void registerSudo()
416 {
417 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
418 arguments.put("player", new EntitySelectorArgument(EntitySelector.ONE_PLAYER));
419 arguments.put("command", new GreedyStringArgument());
420 CommandAPI.getInstance().register("sudo", CommandPermission.fromString("spaceessentials.sudo"), arguments, (sender,args) -> {
421 Player player = (Player)args[0];
422 if(player.hasPermission("spaceessentials.exempt.sudo"))
423 {
424 CommandAPI.fail("Player " + player.getName() + " is exempt from sudo");
425 }
426 else
427 {
428 player.chat((String)args[1]);
429 }
430 });
431 }
432
433 private void registerTop()
434 {
435 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
436 CommandAPI.getInstance().register("top", CommandPermission.fromString("spaceessentials.top"), arguments, (sender, args) -> {
437 if(sender instanceof Player)
438 {
439 Player senderP = (Player) sender;
440 Location senderL = senderP.getLocation().clone();
441 senderL.setY(senderP.getWorld().getHighestBlockYAt(senderL));
442 senderP.teleport(senderL, TeleportCause.COMMAND);
443 }
444 else
445 {
446 CommandAPI.fail(ChatColor.RED + "/top can only be run by a player!");
447 }
448 });
449 }
450
451 private void registerGma()
452 {
453 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
454 CommandAPI.getInstance().register("gma", CommandPermission.fromString("spaceessentials.gma.self"), arguments, (sender,args) -> {
455 if(sender instanceof Player)
456 {
457 ((Player) sender).setGameMode(GameMode.ADVENTURE);
458 }
459 else
460 {
461 CommandAPI.fail("/gma with no players specified can only be run by a player!");
462 }
463 });
464 arguments.put("players", new EntitySelectorArgument(EntitySelector.MANY_PLAYERS));
465 CommandAPI.getInstance().register("gma", CommandPermission.fromString("spaceessentials.gma.others"), arguments, (sender, args) -> {
466 Collection<Player> players = (Collection<Player>)args[0];
467 players.forEach((player) -> {
468 player.setGameMode(GameMode.ADVENTURE);
469 sender.sendMessage(ChatColor.GOLD + "Gamemode for player " + player.getName() + " set to adventure!");
470 });
471 });
472 }
473
474 private void registerGms()
475 {
476 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
477 CommandAPI.getInstance().register("gms", CommandPermission.fromString("spaceessentials.gms.self"), arguments, (sender,args) -> {
478 if(sender instanceof Player)
479 {
480 ((Player) sender).setGameMode(GameMode.SURVIVAL);
481 }
482 else
483 {
484 CommandAPI.fail("/gms with no players specified can only be run by a player!");
485 }
486 });
487 arguments.put("players", new EntitySelectorArgument(EntitySelector.MANY_PLAYERS));
488 CommandAPI.getInstance().register("gms", CommandPermission.fromString("spaceessentials.gms.others"), arguments, (sender, args) -> {
489 Collection<Player> players = (Collection<Player>)args[0];
490 players.forEach((player) -> {
491 player.setGameMode(GameMode.SURVIVAL);
492 sender.sendMessage(ChatColor.GOLD + "Gamemode for player " + player.getName() + " set to survival!");
493 });
494 });
495 }
496
497 private void registerGmc()
498 {
499 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
500 CommandAPI.getInstance().register("gmc", CommandPermission.fromString("spaceessentials.gmc.self"), arguments, (sender,args) -> {
501 if(sender instanceof Player)
502 {
503 ((Player) sender).setGameMode(GameMode.CREATIVE);
504 }
505 else
506 {
507 CommandAPI.fail("/gmc with no players specified can only be run by a player!");
508 }
509 });
510 arguments.put("players", new EntitySelectorArgument(EntitySelector.MANY_PLAYERS));
511 CommandAPI.getInstance().register("gmc", CommandPermission.fromString("spaceessentials.gmc.others"), arguments, (sender, args) -> {
512 Collection<Player> players = (Collection<Player>)args[0];
513 players.forEach((player) -> {
514 player.setGameMode(GameMode.CREATIVE);
515 sender.sendMessage(ChatColor.GOLD + "Gamemode for player " + player.getName() + " set to creative!");
516 });
517 });
518 }
519
520 private void registerGmsp()
521 {
522 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
523 CommandAPI.getInstance().register("gmsp", CommandPermission.fromString("spaceessentials.gmsp.self"), arguments, (sender,args) -> {
524 if(sender instanceof Player)
525 {
526 ((Player) sender).setGameMode(GameMode.SPECTATOR);
527 }
528 else
529 {
530 CommandAPI.fail("/gmsp with no players specified can only be run by a player!");
531 }
532 });
533 arguments.put("players", new EntitySelectorArgument(EntitySelector.MANY_PLAYERS));
534 CommandAPI.getInstance().register("gmsp", CommandPermission.fromString("spaceessentials.gmsp.others"), arguments, (sender, args) -> {
535 Collection<Player> players = (Collection<Player>)args[0];
536 players.forEach((player) -> {
537 player.setGameMode(GameMode.SPECTATOR);
538 sender.sendMessage(ChatColor.GOLD + "Gamemode for player " + player.getName() + " set to spectator!");
539 });
540 });
541 }
542
543 private void registerTempban()
544 {
545 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
546 arguments.put("player", new StringArgument());
547 arguments.put("seconds", new IntegerArgument());
548 registerTempban(arguments);
549 arguments.put("minutes", new IntegerArgument());
550 registerTempban(arguments);
551 arguments.put("hours", new IntegerArgument());
552 registerTempban(arguments);
553 arguments.put("days", new IntegerArgument());
554 registerTempban(arguments);
555 arguments.put("months", new IntegerArgument());
556 registerTempban(arguments);
557 arguments.put("years", new IntegerArgument());
558 registerTempban(arguments);
559 }
560
561 private void registerTempbanHelp(LinkedHashMap<String, Argument> arguments)
562 {
563 CommandAPI.getInstance().register("tempban", CommandPermission.fromString("spaceessentials.tempban"), arguments, (sender,args) -> {
564 CommandAPI.fail("Usage: /tempban <player> <seconds> [minutes] [hours] [days] [months] [years]");
565 });
566 }
567
568 private void registerTempban(LinkedHashMap<String, Argument> arguments)
569 {
570 CommandAPI.getInstance().register("tempban", CommandPermission.fromString("spaceessentials.tempban"), arguments, (sender,args) -> {
571 String uuid = Bukkit.getOfflinePlayer((String)args[0]).getUniqueId().toString();
572 Calendar time = new GregorianCalendar(TimeZone.getTimeZone("GMT"));
573 time.add(Calendar.SECOND, (int)args[1]);
574 if(args.length > 2) time.add(Calendar.MINUTE, (int)args[2]);
575 if(args.length > 3) time.add(Calendar.HOUR, (int)args[3]);
576 if(args.length > 4) time.add(Calendar.DATE, (int)args[4]);
577 if(args.length > 5) time.add(Calendar.MONTH, (int)args[5]);
578 if(args.length == 7) time.add(Calendar.YEAR, (int)args[6]);
579 long dateLong = time.getTime().getTime();
580 File tempbannedFile = new File(getDataFolder(), "tempbanned_players.yml");
581 FileConfiguration reader = YamlConfiguration.loadConfiguration(tempbannedFile);
582 reader.set(uuid,dateLong);
583 try
584 {
585 reader.save(tempbannedFile);
586 }
587 catch (Exception e)
588 {
589 e.printStackTrace();
590 }
591 SimpleDateFormat df = new SimpleDateFormat("yyyy-MMM-dd hh:mm:ss aa");
592 df.setTimeZone(TimeZone.getTimeZone("GMT"));
593 sender.sendMessage(ChatColor.GOLD + "Banned player " + (String)args[0] + " until " + df.format(time.getTime()) + " GMT");
594 });
595 }
596
597 @EventHandler
598 public void playerJoinEvent(PlayerJoinEvent event)
599 {
600 if(event.getPlayer().hasPermission("spaceessentials.exempt.tempban")) return;
601 File tempbannedFile = new File(getDataFolder(), "tempbanned_players.yml");
602 FileConfiguration reader = YamlConfiguration.loadConfiguration(tempbannedFile);
603 if(reader.contains(event.getPlayer().getUniqueId().toString()))
604 {
605 Date currentTime = new Date();
606 Date endTime = new Date(reader.getLong(event.getPlayer().getUniqueId().toString()));
607 if(currentTime.after(endTime))
608 {
609 reader.set(event.getPlayer().getUniqueId().toString(), null);
610 try
611 {
612 reader.save(tempbannedFile);
613 }
614 catch(Exception e)
615 {
616 e.printStackTrace();
617 }
618 }
619 else
620 {
621 SimpleDateFormat df = new SimpleDateFormat("yyyy-MMM-dd hh:mm:ss aa");
622 df.setTimeZone(TimeZone.getTimeZone("GMT"));
623 event.getPlayer().kickPlayer("You are tempoarily banned from this server.\nBanned until " + df.format(endTime) + " GMT");
624 }
625 }
626 }
627
628 private void registerRename()
629 {
630 LinkedHashMap<String, Argument> arguments = new LinkedHashMap();
631 arguments.put("name", new GreedyStringArgument());
632 CommandAPI.getInstance().register("rename", CommandPermission.fromString("spaceessentials.rename"), arguments, (sender,args) -> {
633 if(sender instanceof Player)
634 {
635 Player senderP = (Player)sender;
636 ItemStack renaming = senderP.getInventory().getItemInMainHand();
637 if(renaming.getItemMeta() == null)
638 {
639 CommandAPI.fail("must have an item in hand when using /rename!");
640 }
641 else
642 {
643 ItemMeta renamingMeta = renaming.getItemMeta();
644 renamingMeta.setDisplayName(ChatColor.translateAlternateColorCodes('&', (String)args[0]));
645 renaming.setItemMeta(renamingMeta);
646 senderP.getInventory().setItemInMainHand(renaming);
647 senderP.updateInventory();
648 }
649 }
650 else
651 {
652 CommandAPI.fail("/rename can only be run by a player!");
653 }
654 });
655 }
656}