TabCompleter

Hier könnt ihr anderen Leuten helfen, indem ihr Anleitungen oder praktische Codesegmente zur Verfügung stellt.

TabCompleter

Beitragvon Ch4t4r » Mo 14. Sep 2015, 14:45

Hi,

ich wollte letztens TabCompleter zu meinen Befehlen hinzufügen, hatte aber nicht die Lust, für jeden Befehl von Hand einen erstellen und habe das ganze deswegen automatisiert.
Ohne lange Umschweife will ich erklären, wie man ihn benutzt, dazu fange ich mit dem Konstruktor an.
Code: Alles auswählen
  1. DynamicRegister listRegister = new DynamicReferenceHandler();
  2. boolean permissionMustBeSet; //Wenn auf true muss selbst ein OP die Permission explizit gesetzt haben (oder die Console sein)
  3. TabCompleterBuilder completer = new TabCompleterBuilder(listRegister,new Permission("beispiels.permission",permissionMustBeSet))

Der Completer kann nur benutzt werden, wenn der Spieler die Permission hat (In den nachfolgenden Methoden kann diese für teilargumente überschrieben werden). Ein Dynamisches Register gibt anhand eines Schlüssels eine List<String> zurück, und ist für Argumente da, die sich ändern, z.B Spieler die online sind, was dann so aussieht
Code: Alles auswählen
  1. public class DynamicReferenceHandler implements DynamicRegister{
  2.    public List<String> get(String ref){
  3.       List<String> res = new ArrayList<String>();
  4.                 if(ref.equalsIgnoreCase("players")){
  5.          for(Player p:Bukkit.getOnlinePlayers())res.add(p.getName());
  6.       }
  7.       return res;
  8.    }
  9. }


Generell gibt es zwei Typen von Argumenten: Argumente, die auf ein anderes Argument folgen und Argumente, die positionsgebunden sind (beide Typen gibt es in dynamischer und statischer Form).
Über
Code: Alles auswählen
  1. .addCompletion("vorherigesArgument",new Permission("permission2.beispiel",true),"möglichkeit1","möglichkeit2",[...},"möglichkeit99"); //new Permission ist optional, kann also wegelassen werden (ist über den Konstruktor keine Permission gesetzt, kann jeder tab benutzen)

bzw.
Code: Alles auswählen
  1. addCompletion("vorherigesArgument",new Permission("permission2.beispiel",true),"dynamischerSchlüssel");//Auch hier kann new Permission weggelassen werden

werden Argumente vervollständigt, die einem anderem folgen. Positionsgebundene Listen ersetzen das erste Argument durch die Nummer der Position (0 für das erste Argument)
über .build() wird der TabCompleter erstellt und bei beiden typen kann vor der Permission oder anstatt der Permission ein StringArray angegeben werden, hinter welchem die Vervollständigung nicht eintreten soll.

Nehmen wir an, wir haben einen Befehl whitelist und wollen über Tab die Einträge auswählen können. Der Code mit meiner Libary würde

Code: Alles auswählen
  1. getCommand("whitelist").setExecutor(new CommandWhitelist());
  2.        getCommand("whitelist").setTabCompleter(new TabCompleterBuilder( "example.command.whitelist").addCompletion(0,
  3.              "gungame.command.whitelist", "on","off","message","add","remove").
  4.              addDynamicCompletion(1,new String[]{"on","off","message","add"}, "players").build());

lauten. Das erste Argument bietet zur Vervollständigung on,off,message,add und remove an. Das zweite Argument ist dynamisch (aktuelle Spieler), folgt aber nur auf remove.

Ich hoffe, dass das ganze nicht zu kompliziert ist und einigen hilft.

Code hier:
Code: Alles auswählen
  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  3. import java.util.HashMap;
  4. import java.util.List;
  5. import org.bukkit.Bukkit;
  6. import org.bukkit.command.Command;
  7. import org.bukkit.command.CommandSender;
  8. import org.bukkit.command.ConsoleCommandSender;
  9. import org.bukkit.command.TabCompleter;
  10. import org.bukkit.entity.Player;
  11. public class TabCompleterBuilder {
  12.    private HashMap<String,List<Completion>> completion = new HashMap<>();
  13.    private HashMap<String,List<DynamicCompletion>> dynamicCompletion = new HashMap<>();
  14.    private DynamicRegister register;
  15.    private static DynamicRegister staticRegister;
  16.    private Permission permission = null;
  17.    
  18.    public TabCompleterBuilder(DynamicRegister register,Permission permission){
  19.       this.register = register;
  20.       this.permission = permission;
  21.    }
  22.    
  23.    public TabCompleterBuilder(DynamicRegister register,String permission){
  24.       this.register = register;
  25.       this.permission = new Permission(permission, true);
  26.    }
  27.    
  28.    public TabCompleterBuilder(DynamicRegister register){
  29.       this.register = register;
  30.    }
  31.    
  32.    public TabCompleterBuilder(Permission permission){
  33.       this.permission = permission;
  34.    }
  35.    
  36.    public TabCompleterBuilder(String permission){
  37.       this.permission = new Permission(permission, true);
  38.    }
  39.    
  40.    public TabCompleterBuilder(){}
  41.    public TabCompleterBuilder addCompletion(String prevArg,Permission permission,String... dependedArgs){
  42.       if(dependedArgs.length == 0)return this;
  43.       List<Completion> comp = completion.containsKey(prevArg.toLowerCase()) ? completion.get(prevArg) : new ArrayList<Completion>();
  44.       comp.add(new Completion(permission,Arrays.asList(dependedArgs)));
  45.       completion.put(prevArg.toLowerCase(), comp);
  46.       return this;
  47.    }
  48.    
  49.    public TabCompleterBuilder addCompletion(int position,Permission permission,String... dependedArgs){
  50.       if(dependedArgs.length == 0)return this;
  51.       List<Completion> comp = completion.containsKey("<!>" + position) ? completion.get("<!>" + position) : new ArrayList<Completion>();
  52.       comp.add(new Completion(permission,Arrays.asList(dependedArgs)));
  53.       completion.put("<!>" + position, comp);
  54.       return this;
  55.    }
  56.    
  57.    public TabCompleterBuilder addCompletion(int position,String[] excludedPreviousArgs,Permission permission,String... dependedArgs){
  58.       if(dependedArgs.length == 0)return this;
  59.       List<Completion> comp = completion.containsKey("<!>" + position) ? completion.get("<!>" + position) : new ArrayList<Completion>();
  60.       comp.add(new Completion(permission,Arrays.asList(dependedArgs),Arrays.asList(excludedPreviousArgs)));
  61.       completion.put("<!>" + position, comp);
  62.       return this;
  63.    }
  64.    
  65.    public TabCompleterBuilder addDynamicCompletion(String prevArg,Permission permission,String dynamicKey){
  66.       List<DynamicCompletion> comp = dynamicCompletion.containsKey(prevArg.toLowerCase()) ? dynamicCompletion.get(prevArg.toLowerCase()) : new ArrayList<DynamicCompletion>();
  67.       comp.add(new DynamicCompletion(permission,dynamicKey));
  68.       dynamicCompletion.put(prevArg.toLowerCase(), comp);
  69.       return this;
  70.    }
  71.    
  72.    public TabCompleterBuilder addDynamicCompletion(int position,Permission permission,String dynamicKey){
  73.       List<DynamicCompletion> comp = dynamicCompletion.containsKey("<!>" + position) ? dynamicCompletion.get("<!>" + position) : new ArrayList<DynamicCompletion>();
  74.       comp.add(new DynamicCompletion(permission,dynamicKey));
  75.       dynamicCompletion.put("<!>" + position, comp);
  76.       return this;
  77.    }
  78.    
  79.    public TabCompleterBuilder addDynamicCompletion(int position,String[] excludedPreviousArgs,Permission permission,String dynamicKey){
  80.       List<DynamicCompletion> comp = dynamicCompletion.containsKey("<!>" + position) ? dynamicCompletion.get("<!>" + position) : new ArrayList<DynamicCompletion>();
  81.       comp.add(new DynamicCompletion(permission,dynamicKey,Arrays.asList(excludedPreviousArgs)));
  82.       dynamicCompletion.put("<!>" + position, comp);
  83.       return this;
  84.    }
  85.    
  86.    public TabCompleterBuilder addCompletion(String prevArg,String... dependedArgs){
  87.       if(dependedArgs.length == 0)return this;
  88.       List<Completion> comp = completion.containsKey(prevArg.toLowerCase()) ? completion.get(prevArg.toLowerCase()) : new ArrayList<Completion>();
  89.       comp.add(new Completion(Arrays.asList(dependedArgs)));
  90.       completion.put(prevArg.toLowerCase(),comp);
  91.       return this;
  92.    }
  93.    
  94.    public TabCompleterBuilder addCompletion(int position,String... dependedArgs){
  95.       if(dependedArgs.length == 0)return this;
  96.       List<Completion> comp = completion.containsKey("<!>" + position) ? completion.get("<!>" + position) : new ArrayList<Completion>();
  97.       comp.add(new Completion(Arrays.asList(dependedArgs)));
  98.       completion.put("<!>" + position, comp);
  99.       return this;
  100.    }
  101.    
  102.    public TabCompleterBuilder addCompletion(int position,String[] excludedPreviousArgs,String... dependedArgs){
  103.       if(dependedArgs.length == 0)return this;
  104.       List<Completion> comp = completion.containsKey("<!>" + position) ? completion.get("<!>" + position) : new ArrayList<Completion>();
  105.       comp.add(new Completion(Arrays.asList(dependedArgs),Arrays.asList(excludedPreviousArgs)));
  106.       completion.put("<!>" + position, comp);
  107.       return this;
  108.    }
  109.    
  110.    public TabCompleterBuilder addDynamicCompletion(String prevArg,String dynamicKey){
  111.       List<DynamicCompletion> comp = dynamicCompletion.containsKey(prevArg.toLowerCase()) ? dynamicCompletion.get(prevArg.toLowerCase()) : new ArrayList<DynamicCompletion>();
  112.       comp.add(new DynamicCompletion(dynamicKey));
  113.       dynamicCompletion.put(prevArg.toLowerCase(), comp);
  114.       return this;
  115.    }
  116.    
  117.    public TabCompleterBuilder addDynamicCompletion(int position,String dynamicKey){
  118.       List<DynamicCompletion> comp = dynamicCompletion.containsKey("<!>" + position) ? dynamicCompletion.get("<!>" + position) : new ArrayList<DynamicCompletion>();
  119.       comp.add(new DynamicCompletion(dynamicKey));
  120.       dynamicCompletion.put("<!>" + position, comp);
  121.       return this;
  122.    }
  123.    
  124.    public TabCompleterBuilder addDynamicCompletion(int position,String[] excludedPreviousArgs,String dynamicKey){
  125.       List<DynamicCompletion> comp = dynamicCompletion.containsKey("<!>" + position) ? dynamicCompletion.get("<!>" + position) : new ArrayList<DynamicCompletion>();
  126.       comp.add(new DynamicCompletion(dynamicKey,Arrays.asList(excludedPreviousArgs)));
  127.       dynamicCompletion.put("<!>" + position, comp);
  128.       return this;
  129.    }
  130.    
  131.    public TabCompleter build(){
  132.       return new TabCompleter() {
  133.          public List<String> onTabComplete(CommandSender sender, Command cmd,String alias, String[] args) {
  134.             if(!hasCompletion(args))return new ArrayList<String>();
  135.             return getCompletionWithPermission(sender,args);
  136.          }
  137.          
  138.          
  139.          private List<String> getCompletionWithPermission(CommandSender sender,String[] args){
  140.             String lastArg = args[args.length-1].toLowerCase().equals("") && args.length >= 2 ? args[args.length - 2].toLowerCase() : args[args.length-1].toLowerCase(),currentArg = args[args.length-1],
  141.                   posKey = "<!>" + (args.length-(1));
  142.             List<String> comp = new ArrayList<String>();
  143.             if(completion.containsKey(lastArg)){
  144.                for(Completion c: completion.get(lastArg)){
  145.                   if(checkPermission(c.permission,sender))comp.addAll(c.dependArgs);
  146.                   else break;
  147.                }
  148.             }else if(completion.containsKey(posKey)){
  149.                for(Completion c: completion.get(posKey)){
  150.                   if(c.excludedPrevArgs.contains(lastArg))break;
  151.                   if(checkPermission(c.permission,sender))comp.addAll(!currentArg.equals("") ? sort(c.dependArgs,currentArg) : c.dependArgs);
  152.                   else break;
  153.                }
  154.             }else if(dynamicCompletion.containsKey(posKey)){
  155.                for(DynamicCompletion c: dynamicCompletion.get(posKey)){
  156.                   if(c.excludedPrevArgs.contains(lastArg))break;
  157.                   if(checkPermission(c.permission, sender))comp.addAll(!currentArg.equals("") ? sort(getRegister().get(c.dynamicKey),currentArg) : getRegister().get(c.dynamicKey));
  158.                   else break;
  159.                }
  160.             }else if(dynamicCompletion.containsKey(lastArg)){
  161.                for(DynamicCompletion c: dynamicCompletion.get(lastArg)){
  162.                   if(checkPermission(c.permission,sender))comp.addAll(getRegister().get(c.dynamicKey));
  163.                   else break;
  164.                }
  165.             }else if(lastArg.equalsIgnoreCase("")){
  166.                comp.addAll(playerList());
  167.             }
  168.             return comp;
  169.          }
  170.          
  171.          private List<String> playerList(){
  172.             List<String> names = new ArrayList<>();
  173.             for(Player p: Bukkit.getOnlinePlayers())names.add(p.getName());
  174.             return names;
  175.          }
  176.          
  177.          private List<String> sort(List<String> completion,String lastArg){
  178.             List<String> tmp = new ArrayList<String>();
  179.             for(String s: completion)if(s.toLowerCase().startsWith(lastArg))tmp.add(s);
  180.             return tmp;
  181.          }
  182.          
  183.          private List<String> findMatches(String[] args){
  184.             String lastArg = args[args.length-1].toLowerCase();
  185.             List<String> matches = new ArrayList<>();
  186.             for(String s: completion.keySet()){
  187.                for(Completion c: completion.get(s)){
  188.                   if(args.length >= 2 && c.excludedPrevArgs.contains(args[args.length-2]))continue;
  189.                   for(String s2: c.dependArgs){
  190.                      if(s2.toLowerCase().startsWith(lastArg)){
  191.                         matches.add(s2);
  192.                      }
  193.                   }
  194.                }
  195.             }
  196.             for(String s: dynamicCompletion.keySet()){
  197.                for(DynamicCompletion c2: dynamicCompletion.get(s)){
  198.                   if(args.length >= 2 && c2.excludedPrevArgs.contains(args[args.length-2]))continue;
  199.                   for(String s2: getRegister().get(c2.dynamicKey)){
  200.                      if(s2.toLowerCase().startsWith(lastArg)){
  201.                         matches.add(s2);
  202.                      }
  203.                   }
  204.                }
  205.             }
  206.             return matches;
  207.          }
  208.          
  209.          private boolean hasCompletion(String[] args){
  210.             return completion.containsKey(args[args.length-1].toLowerCase()) || dynamicCompletion.containsKey(args[args.length-1].toLowerCase()) || completion.containsKey("<!>" + (args.length-1)) || dynamicCompletion.containsKey("<!>" + (args.length-1));
  211.          }
  212.          
  213. //         private boolean checkPermission(CommandSender sender,String[] args){
  214. //            Permission perm = getPermission(args);
  215. //            if(perm.getPermission().equalsIgnoreCase(""))return true;
  216. //            return perm.isExplicit() ? sender.isPermissionSet(perm.getPermission()) && (sender.hasPermission(perm.getPermission()) || sender instanceof ConsoleCommandSender) : sender.hasPermission(perm.getPermission());
  217. //         }
  218.          
  219.          private boolean checkPermission(Permission perm,CommandSender sender){
  220.             if(perm.getPermission().equalsIgnoreCase(""))return true;
  221.             return perm.isExplicit() ? sender.isPermissionSet(perm.getPermission()) && (sender.hasPermission(perm.getPermission()) || sender instanceof ConsoleCommandSender) : sender.hasPermission(perm.getPermission());
  222.          }
  223.          
  224. //         private Permission getPermission(String[] args){
  225. //            String lastArg = args[args.length-1].toLowerCase(), posKey = "<!>" + (args.length-1);
  226. //            Permission perm = completion.containsKey(lastArg) ? completion.get(lastArg).permission : (completion.containsKey(posKey) ? completion.get(posKey).permission : (dynamicCompletion.containsKey(posKey) ? dynamicCompletion.get(posKey).permission : (dynamicCompletion.containsKey(lastArg) ? dynamicCompletion.get(lastArg).permission : null)));;
  227. //            return perm == null ? (TabCompleterBuilder.this.permission == null ? new Permission("", true) : TabCompleterBuilder.this.permission) : perm;
  228. //         }
  229.          
  230.          private DynamicRegister getRegister(){
  231.             if(register != null)return register;
  232.             else if(staticRegister != null)return staticRegister;
  233.             else throw new IllegalStateException("[TabCompleterBuilder] No DynamicRegister given, but a value was requested");
  234.          }
  235.       };
  236.    }
  237.    
  238.    private class Completion{
  239.       Permission permission;
  240.       List<String> dependArgs;
  241.       List<String> excludedPrevArgs;
  242.       
  243.       private Completion(List<String> dependArgs){
  244.          this.permission = new Permission("", true);
  245.          this.dependArgs = dependArgs;
  246.          excludedPrevArgs = new ArrayList<>();
  247.       }
  248.       
  249.       private Completion(Permission permission,List<String> dependArgs){
  250.          this.permission = permission;
  251.          this.dependArgs = dependArgs;
  252.          excludedPrevArgs = new ArrayList<>();
  253.       }
  254.       
  255.       private Completion(Permission permission,List<String> dependArgs,List<String> excludedPrevArgs){
  256.          this.permission = permission;
  257.          this.dependArgs = dependArgs;
  258.          this.excludedPrevArgs = excludedPrevArgs;
  259.       }
  260.       
  261.       private Completion(List<String> dependArgs,List<String> excludedPrevArgs){
  262.          this.permission = new Permission("", true);
  263.          this.dependArgs = dependArgs;
  264.          this.excludedPrevArgs = excludedPrevArgs;
  265.       }
  266.    }
  267.    
  268.    private class DynamicCompletion{
  269.       Permission permission;
  270.       String dynamicKey;
  271.       List<String> excludedPrevArgs;
  272.       
  273.       private DynamicCompletion(String dynamicKey){
  274.          this.permission = new Permission("", true);
  275.          this.dynamicKey = dynamicKey;
  276.          excludedPrevArgs = new ArrayList<>();
  277.       }
  278.       
  279.       private DynamicCompletion(Permission permission,String dynamicKey){
  280.          this.permission = permission;
  281.          this.dynamicKey = dynamicKey;
  282.          excludedPrevArgs = new ArrayList<>();
  283.       }
  284.       
  285.       private DynamicCompletion(Permission permission,String dynamicKey,List<String> excludedPrevArgs){
  286.          this.permission = permission;
  287.          this.dynamicKey = dynamicKey;
  288.          this.excludedPrevArgs = excludedPrevArgs;
  289.       }
  290.       
  291.       private DynamicCompletion(String dynamicKey,List<String> excludedPrevArgs){
  292.          this.permission = new Permission("", true);
  293.          this.dynamicKey = dynamicKey;
  294.          this.excludedPrevArgs = excludedPrevArgs;
  295.       }
  296.    }
  297.    
  298.    public static interface DynamicRegister{
  299.       public List<String> get(String key);
  300.    }
  301.    
  302.    public static class Permission{
  303.       private String perm;
  304.       private boolean explicit;
  305.       
  306.       public Permission(String permission,boolean allowOps){
  307.          perm = permission;
  308.          explicit = !allowOps;
  309.       }
  310.       
  311.       public String getPermission(){
  312.          return perm;
  313.       }
  314.       
  315.       public boolean isExplicit(){
  316.          return explicit;
  317.       }
  318.    }
  319.    public static void setStaticRegister(DynamicRegister register){
  320.       staticRegister = register;
  321.    }
  322. }
Benutzeravatar
Ch4t4r
 
Beiträge: 455
Registriert: So 7. Jul 2013, 12:44

Zurück zu Anleitungen

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 3 Gäste

cron