Merge pull request 'Use BungeeTabListPlus inspired Condition system' (#209) from feature/use-btlp-condition-system into master

Reviewed-on: https://codeberg.org/Andre601/AdvancedServerList/pulls/209

core/pom.xml

@@ -72,6 +72,8 @@
             <version>4.1.2</version>
             <scope>provided</scope>
         </dependency>
+        
+        <!-- MiniMessage -->
         <dependency>
             <groupId>net.kyori</groupId>
             <artifactId>adventure-api</artifactId>
@@ -114,6 +116,8 @@
             <version>33.0.0-jre</version>
             <scope>provided</scope>
         </dependency>
+        
+        <!-- Plugins -->
         <dependency>
             <groupId>net.william278</groupId>
             <artifactId>papiproxybridge</artifactId>
@@ -129,9 +133,9 @@
         
         <!-- Test dependencies -->
         <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.13.2</version>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>5.8.1</version>
             <scope>test</scope>
         </dependency>
     </dependencies>

core/src/main/java/ch/andre601/advancedserverlist/core/AdvancedServerList.java

@@ -31,6 +31,7 @@ import ch.andre601.advancedserverlist.core.check.UpdateChecker;
 import ch.andre601.advancedserverlist.core.commands.CommandHandler;
 import ch.andre601.advancedserverlist.core.file.FileHandler;
 import ch.andre601.advancedserverlist.core.interfaces.core.PluginCore;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ExpressionEngine;
 import ch.andre601.advancedserverlist.core.profiles.players.PlayerHandler;
 
 import java.io.IOException;
@@ -47,6 +48,7 @@ public class AdvancedServerList<F>{
     private final CommandHandler commandHandler;
     private final PlayerHandler playerHandler;
     private final AdvancedServerListAPI api = AdvancedServerListAPI.get();
+    private final ExpressionEngine expressionEngine = new ExpressionEngine();
     
     private UpdateChecker updateChecker;
     
@@ -91,6 +93,10 @@ public class AdvancedServerList<F>{
         return api;
     }
     
+    public ExpressionEngine getExpressionEngine(){
+        return expressionEngine;
+    }
+    
     public void disable(){
         getPlugin().getPluginLogger().info("Saving playercache.json file...");
         getPlayerHandler().save();

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/ServerListProfile.java

@@ -30,16 +30,22 @@ import ch.andre601.advancedserverlist.api.objects.GenericServer;
 import ch.andre601.advancedserverlist.api.profiles.ProfileEntry;
 import ch.andre601.advancedserverlist.core.interfaces.PluginLogger;
 import ch.andre601.advancedserverlist.core.profiles.conditions.Expression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ExpressionEngine;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionErrorTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.replacer.StringReplacer;
 import org.spongepowered.configurate.ConfigurationNode;
 import org.spongepowered.configurate.serialize.SerializationException;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
+import java.util.StringJoiner;
 
 public class ServerListProfile{
     
     private final int priority;
+    private final String condition;
     private final List<Expression> expressions;
     private final ProfileEntry defaultProfile;
     
@@ -47,8 +53,9 @@ public class ServerListProfile{
     
     private final Random random = new Random();
     
-    public ServerListProfile(int priority, List<Expression> expressions, ProfileEntry defaultProfile, List<ProfileEntry> profiles){
+    public ServerListProfile(int priority, String condition, List<Expression> expressions, ProfileEntry defaultProfile, List<ProfileEntry> profiles){
         this.priority = priority;
+        this.condition = condition;
         this.expressions = expressions;
         this.defaultProfile = defaultProfile;
         
@@ -59,7 +66,17 @@ public class ServerListProfile{
         return priority;
     }
     
-    public boolean evalConditions(GenericPlayer player, GenericServer server){
+    public boolean evalConditions(ExpressionEngine expressionEngine, PluginLogger logger, GenericPlayer player, GenericServer server){
+        if(condition != null && !condition.isEmpty()){
+            ExpressionTemplate template = expressionEngine.compile(condition, logger, player, server);
+            if(template instanceof ExpressionErrorTemplate errorTemplate){
+                logger.warn(errorTemplate.instantiateWithStringResult().evaluate());
+                return true;
+            }
+            
+            return template.instantiateWithBooleanResult().evaluate();
+        }
+        
         if(expressions.isEmpty())
             return true;
         
@@ -121,6 +138,7 @@ public class ServerListProfile{
         
         private final PluginLogger logger;
         
+        private String condition = null;
         private List<ProfileEntry> profiles = new ArrayList<>();
         private ProfileEntry defaultProfile = ProfileEntry.empty();
         
@@ -133,11 +151,21 @@ public class ServerListProfile{
         
         public static Builder resolve(String fileName, ConfigurationNode node, PluginLogger logger){
             return new Builder(fileName, node, logger)
+                .resolveCondition()
                 .resolveExpressions()
                 .resolveProfiles()
                 .resolveDefaultProfile();
         }
         
+        private Builder resolveCondition(){
+            String condition = node.node("condition").getString();
+            if(condition == null || condition.isEmpty())
+                return this;
+            
+            this.condition = condition;
+            return this;
+        }
+        
         private Builder resolveExpressions(){
             List<String> temp;
             try{
@@ -150,6 +178,8 @@ public class ServerListProfile{
             if(temp == null || temp.isEmpty())
                 return this;
             
+            StringJoiner joiner = new StringJoiner(" and ");
+            
             for(String str : temp){
                 Expression expr = Expression.resolve(str);
                 
@@ -158,9 +188,18 @@ public class ServerListProfile{
                     continue;
                 }
                 
+                joiner.add(str);
                 this.expressions.add(expr);
             }
             
+            if(!this.expressions.isEmpty()){
+                logger.warn("'%s' uses 'conditions' which is deprecated in favour of the newer 'condition' option.", fileName);
+                logger.warn("The 'conditions' option will be removed in a future version.");
+                logger.warn("");
+                logger.warn("Please migrate your condition(s) over from the old option to the new option like this:");
+                logger.warn("consition: '%s'", joiner.toString());
+            }
+            
             return this;
         }
         
@@ -184,7 +223,7 @@ public class ServerListProfile{
         }
         
         public ServerListProfile build(){
-            return new ServerListProfile(this.priority, this.expressions, this.defaultProfile, this.profiles);
+            return new ServerListProfile(this.priority, this.condition, this.expressions, this.defaultProfile, this.profiles);
         }
     }
 }

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/Conversions.java

@@ -0,0 +1,107 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToBooleanExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToDoubleExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToStringExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.AbstractUnaryToBooleanExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.AbstractUnaryToDoubleExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.AbstractUnaryToStringExpression;
+
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.util.Locale;
+
+public class Conversions{
+    
+    private final static NumberFormat NUMBER_FORMAT;
+    
+    static {
+        NUMBER_FORMAT = NumberFormat.getNumberInstance(Locale.ROOT);
+        NUMBER_FORMAT.setGroupingUsed(false);
+    }
+    
+    public static ToBooleanExpression toBoolean(ToDoubleExpression expression){
+        return new AbstractUnaryToBooleanExpression<>(expression) {
+            @Override
+            public boolean evaluate(){
+                return delegate.evaluate() != 0;
+            }
+        };
+    }
+    
+    public static ToBooleanExpression toBoolean(ToStringExpression expression){
+        return new AbstractUnaryToBooleanExpression<>(expression) {
+            @Override
+            public boolean evaluate(){
+                return Boolean.parseBoolean(delegate.evaluate());
+            }
+        };
+    }
+    
+    public static ToDoubleExpression toDouble(ToBooleanExpression expression){
+        return new AbstractUnaryToDoubleExpression<>(expression) {
+            @Override
+            public double evaluate(){
+                return delegate.evaluate() ? 1 : 0;
+            }
+        };
+    }
+    
+    public static ToDoubleExpression toDouble(ToStringExpression expression){
+        return new AbstractUnaryToDoubleExpression<>(expression) {
+            @Override
+            public double evaluate(){
+                String result = delegate.evaluate();
+                try{
+                    return NUMBER_FORMAT.parse(result).doubleValue();
+                }catch(ParseException | NumberFormatException ex){
+                    return 0;
+                }
+            }
+        };
+    }
+    
+    public static ToStringExpression toString(ToBooleanExpression expression){
+        return new AbstractUnaryToStringExpression<>(expression) {
+            @Override
+            public String evaluate(){
+                return Boolean.toString(delegate.evaluate());
+            }
+        };
+    }
+    
+    public static ToStringExpression toString(ToDoubleExpression expression){
+        return new AbstractUnaryToStringExpression<>(expression) {
+            @Override
+            public String evaluate(){
+                double result = delegate.evaluate();
+                return result == (int)result ? Integer.toString((int)result) : Double.toString(result);
+            }
+        };
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/ExpressionTokenizer.java

@@ -0,0 +1,78 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions;
+
+import ch.andre601.advancedserverlist.api.objects.GenericPlayer;
+import ch.andre601.advancedserverlist.api.objects.GenericServer;
+import ch.andre601.advancedserverlist.core.interfaces.PluginLogger;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.readers.TokenReader;
+import com.google.common.collect.Ordering;
+
+import java.text.ParsePosition;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class ExpressionTokenizer{
+    
+    private static final Ordering<TokenReader> TOKEN_READER_ORDERING = Ordering.from(Comparator.comparingInt(TokenReader::getPriority)).reverse();
+    
+    private final List<TokenReader> tokenReaders;
+    
+    public ExpressionTokenizer(Iterable<TokenReader> tokenReaders){
+        this.tokenReaders = TOKEN_READER_ORDERING.immutableSortedCopy(tokenReaders);
+    }
+    
+    public List<Token> parse(String text, PluginLogger logger, GenericPlayer player, GenericServer server){
+        ParsePosition position = new ParsePosition(0);
+        
+        List<Token> tokens = new LinkedList<>();
+        
+        next_token:
+        while(true){
+            while(position.getIndex() < text.length() && Character.isWhitespace(text.charAt(position.getIndex()))){
+                position.setIndex(position.getIndex() + 1);
+            }
+            
+            if(position.getIndex() >= text.length())
+                break;
+            
+            for(TokenReader tokenReader : tokenReaders){
+                Token token;
+                if(null != (token = tokenReader.read(text, position, player, server))){
+                    tokens.add(token);
+                    continue next_token;
+                }
+            }
+            
+            logger.warn("Illegal token '%c' at index %d.", text.charAt(position.getIndex()), position.getIndex());
+            break;
+        }
+        
+        return tokens;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/expressions/Expression.java

@@ -0,0 +1,28 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.expressions;
+
+public interface Expression{}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/expressions/ExpressionEngine.java

@@ -0,0 +1,170 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.expressions;
+
+import ch.andre601.advancedserverlist.api.objects.GenericPlayer;
+import ch.andre601.advancedserverlist.api.objects.GenericServer;
+import ch.andre601.advancedserverlist.core.interfaces.PluginLogger;
+import ch.andre601.advancedserverlist.core.profiles.conditions.ExpressionTokenizer;
+import ch.andre601.advancedserverlist.core.profiles.conditions.operators.ListOperator;
+import ch.andre601.advancedserverlist.core.profiles.conditions.operators.Operator;
+import ch.andre601.advancedserverlist.core.profiles.conditions.parsers.*;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplates;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.BooleanToken;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.DefaultTokens;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.readers.*;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ExpressionEngine{
+    
+    private final ExpressionTokenizer tokenizer;
+    private final ExpressionTemplateParser templateParser;
+    
+    public ExpressionEngine(){
+        Options options = new Options.Builder()
+            .withDefaultTokenReaders()
+            .withDefaultOperators()
+            .withDefaultValueReaders()
+            .build();
+        
+        this.tokenizer = new ExpressionTokenizer(options.tokenReaders);
+        this.templateParser = new ExpressionTemplateParser(options.operators, options.valueReaders);
+    }
+    
+    public ExpressionTemplate compile(String expression, PluginLogger logger, GenericPlayer player, GenericServer server){
+        return templateParser.parse(tokenizer.parse(expression, logger, player, server));
+    }
+    
+    public static class Options{
+        
+        private final List<TokenReader> tokenReaders;
+        private final ImmutableMap<Token, Operator> operators;
+        private final ImmutableList<ValueReader> valueReaders;
+        
+        private Options(List<TokenReader> tokenReaders, ImmutableMap<Token, Operator> operators, ImmutableList<ValueReader> valueReaders){
+            this.tokenReaders = tokenReaders;
+            this.operators = operators;
+            this.valueReaders = valueReaders;
+        }
+        
+        public static class Builder{
+            private final List<TokenReader> tokenReaders = new ArrayList<>();
+            private final Map<Token, Operator> operators = new HashMap<>();
+            private final List<ValueReader> valueReaders = new ArrayList<>();
+            
+            public Builder(){}
+            
+            public Builder withDefaultTokenReaders(){
+                return this
+                    .tokenReader(new PatternTokenReader(BooleanToken.FALSE, "false"))
+                    .tokenReader(new PatternTokenReader(BooleanToken.TRUE, "true"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.AND, "and"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.AND, "&&"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.OR, "or"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.OR, "||"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.EQUAL, "=="))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.EQUAL, "="))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.NOT_EQUAL, "!="))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.EQUAL_IGNORE_CASE, "~="))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.NOT_EQUAL_IGNORE_CASE, "!~"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.GREATER_OR_EQUAL_THAN, ">="))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.LESSER_OR_EQUAL_THAN, "<="))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.OPENING_PARENTHESIS, "("))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.CLOSING_PARENTHESIS, ")"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.NEGATION, "!"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.GREATER_THAN, ">"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.LESSER_THAN, "<"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.CONCAT_STRING, "."))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.ADD, "+"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.SUB, "-"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.MULT, "*"))
+                    .tokenReader(new PatternTokenReader(DefaultTokens.DIV, "/"))
+                    .tokenReader(new QuotedLiteralTokenReader(-10, '\"'))
+                    .tokenReader(new QuotedLiteralTokenReader(-10, '\''))
+                    .tokenReader(new PlaceholderTokenReader(-20))
+                    .tokenReader(new NumberTokenReader(-50))
+                    .tokenReader(new NonQuotedLiteralTokenReader(-100));
+            }
+            
+            public Builder withDefaultOperators(){
+                return this
+                    .operator(DefaultTokens.AND, ListOperator.of(100, ExpressionTemplates::and))
+                    .operator(DefaultTokens.OR, ListOperator.of(50, ExpressionTemplates::or))
+                    .operator(DefaultTokens.EQUAL, Operator.of(25, ExpressionTemplates::equal))
+                    .operator(DefaultTokens.NOT_EQUAL, Operator.of(25, ExpressionTemplates::notEqual))
+                    .operator(DefaultTokens.EQUAL_IGNORE_CASE, Operator.of(25, ExpressionTemplates::equalIgnoreCase))
+                    .operator(DefaultTokens.NOT_EQUAL_IGNORE_CASE, Operator.of(25, ExpressionTemplates::notEqualIgnoreCase))
+                    .operator(DefaultTokens.GREATER_THAN, Operator.of(25, ExpressionTemplates::greater))
+                    .operator(DefaultTokens.GREATER_OR_EQUAL_THAN, Operator.of(25, ExpressionTemplates::greaterOrEqual))
+                    .operator(DefaultTokens.LESSER_THAN, Operator.of(25, ExpressionTemplates::less))
+                    .operator(DefaultTokens.LESSER_OR_EQUAL_THAN, Operator.of(25, ExpressionTemplates::lessOrEqual))
+                    .operator(DefaultTokens.CONCAT_STRING, ListOperator.of(10, ExpressionTemplates::concat))
+                    .operator(DefaultTokens.ADD, ListOperator.of(4, ExpressionTemplates::sum))
+                    .operator(DefaultTokens.SUB, Operator.of(3, ExpressionTemplates::sub))
+                    .operator(DefaultTokens.MULT, ListOperator.of(2, ExpressionTemplates::product))
+                    .operator(DefaultTokens.DIV, Operator.of(1, ExpressionTemplates::div));
+            }
+            
+            public Builder withDefaultValueReaders(){
+                return this
+                    .valueReader(new BooleanConstantReader())
+                    .valueReader(new NumberConstantReader())
+                    .valueReader(new StringConstantReader())
+                    .valueReader(new NegatedExpressionReader(DefaultTokens.NEGATION))
+                    .valueReader(new ParenthesisedExpressionReader(DefaultTokens.OPENING_PARENTHESIS, DefaultTokens.CLOSING_PARENTHESIS))
+                    .valueReader(new PlaceholderReader())
+                    .valueReader(new NegatedNumberReader(DefaultTokens.SUB));
+            }
+            
+            public Builder tokenReader(TokenReader tokenReader){
+                this.tokenReaders.add(tokenReader);
+                return this;
+            }
+            
+            public Builder operator(Token token, Operator operator){
+                this.operators.put(token, operator);
+                return this;
+            }
+            
+            public Builder valueReader(ValueReader valueReader){
+                this.valueReaders.add(valueReader);
+                return this;
+            }
+            
+            public Options build(){
+                return new Options(this.tokenReaders, ImmutableMap.copyOf(operators), ImmutableList.copyOf(valueReaders));
+            }
+        }
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/expressions/Expressions.java

@@ -0,0 +1,211 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.expressions;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.*;
+
+import java.util.Collection;
+
+public class Expressions{
+    
+    public static ToBooleanExpression negate(ToBooleanExpression expression){
+        return new AbstractUnaryToBooleanExpression<>(expression) {
+            @Override
+            public boolean evaluate(){
+                return !delegate.evaluate();
+            }
+        };
+    }
+    
+    public static ToBooleanExpression and(Collection<ToBooleanExpression> operands){
+        return new AbstractToBooleanExpression<>(operands) {
+            @Override
+            public boolean evaluate(){
+                for(ToBooleanExpression operand : operands){
+                    if(!operand.evaluate())
+                        return false;
+                }
+                
+                return true;
+            }
+        };
+    }
+    
+    public static ToBooleanExpression or(Collection<ToBooleanExpression> operands){
+        return new AbstractToBooleanExpression<>(operands) {
+            @Override
+            public boolean evaluate(){
+                for(ToBooleanExpression operand : operands){
+                    if(operand.evaluate())
+                        return true;
+                }
+                
+                return false;
+            }
+        };
+    }
+    
+    public static ToStringExpression concat(Collection<ToStringExpression> operands){
+        return new AbstractToStringExpression<>(operands) {
+            @Override
+            public String evaluate(){
+                StringBuilder result = new StringBuilder();
+                for(ToStringExpression operand : operands){
+                    result.append(operand.evaluate());
+                }
+                
+                return result.toString();
+            }
+        };
+    }
+    
+    public static ToBooleanExpression equal(ToStringExpression a, ToStringExpression b){
+        return new AbstractBinaryToBooleanExpression<>(a, b) {
+            @Override
+            public boolean evaluate(){
+                return a.evaluate().equals(b.evaluate());
+            }
+        };
+    }
+    
+    public static ToBooleanExpression notEqual(ToStringExpression a, ToStringExpression b){
+        return new AbstractBinaryToBooleanExpression<>(a, b) {
+            @Override
+            public boolean evaluate(){
+                return !a.evaluate().equals(b.evaluate());
+            }
+        };
+    }
+    
+    public static ToBooleanExpression equalIgnoreCase(ToStringExpression a, ToStringExpression b){
+        return new AbstractBinaryToBooleanExpression<>(a, b) {
+            @Override
+            public boolean evaluate(){
+                return a.evaluate().equalsIgnoreCase(b.evaluate());
+            }
+        };
+    }
+    
+    public static ToBooleanExpression notEqualIgnoreCase(ToStringExpression a, ToStringExpression b){
+        return new AbstractBinaryToBooleanExpression<>(a, b) {
+            @Override
+            public boolean evaluate(){
+                return !a.evaluate().equalsIgnoreCase(b.evaluate());
+            }
+        };
+    }
+    
+    public static ToBooleanExpression greaterThan(ToDoubleExpression a, ToDoubleExpression b){
+        return new AbstractBinaryToBooleanExpression<>(a, b) {
+            @Override
+            public boolean evaluate(){
+                return a.evaluate() > b.evaluate();
+            }
+        };
+    }
+    
+    public static ToBooleanExpression greaterOrEqualThan(ToDoubleExpression a, ToDoubleExpression b){
+        return new AbstractBinaryToBooleanExpression<>(a, b) {
+            @Override
+            public boolean evaluate(){
+                return a.evaluate() >= b.evaluate();
+            }
+        };
+    }
+    
+    public static ToBooleanExpression lessThan(ToDoubleExpression a, ToDoubleExpression b){
+        return new AbstractBinaryToBooleanExpression<>(a, b) {
+            @Override
+            public boolean evaluate(){
+                return a.evaluate() < b.evaluate();
+            }
+        };
+    }
+    
+    public static ToBooleanExpression lessOrEqualThan(ToDoubleExpression a, ToDoubleExpression b){
+        return new AbstractBinaryToBooleanExpression<>(a, b) {
+            @Override
+            public boolean evaluate(){
+                return a.evaluate() <= b.evaluate();
+            }
+        };
+    }
+    
+    public static ToDoubleExpression sum(Collection<ToDoubleExpression> operands){
+        return new AbstractToDoubleExpression<>(operands) {
+            @Override
+            public double evaluate(){
+                double result = 0;
+                for(ToDoubleExpression operand : operands){
+                    result += operand.evaluate();
+                }
+                
+                return result;
+            }
+        };
+    }
+    
+    public static ToDoubleExpression product(Collection<ToDoubleExpression> operands){
+        return new AbstractToDoubleExpression<>(operands) {
+            @Override
+            public double evaluate(){
+                double result = 1;
+                for(ToDoubleExpression operand : operands){
+                    result *= operand.evaluate();
+                }
+                
+                return result;
+            }
+        };
+    }
+    
+    public static ToDoubleExpression sub(ToDoubleExpression a, ToDoubleExpression b){
+        return new AbstractBinaryToDoubleExpression<>(a, b) {
+            @Override
+            public double evaluate(){
+                return a.evaluate() - b.evaluate();
+            }
+        };
+    }
+    
+    public static ToDoubleExpression div(ToDoubleExpression a, ToDoubleExpression b){
+        return new AbstractBinaryToDoubleExpression<>(a, b) {
+            @Override
+            public double evaluate(){
+                return a.evaluate() / b.evaluate();
+            }
+        };
+    }
+    
+    public static ToDoubleExpression negateNumber(ToDoubleExpression a){
+        return new AbstractUnaryToDoubleExpression<>(a) {
+            @Override
+            public double evaluate(){
+                return -delegate.evaluate();
+            }
+        };
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/expressions/ToBooleanExpression.java

@@ -0,0 +1,49 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.expressions;
+
+public interface ToBooleanExpression extends Expression{
+    
+    boolean evaluate();
+    
+    static ToBooleanExpression literal(boolean value){
+        return new ConstantToBooleanExpression(value);
+    }
+    
+    class ConstantToBooleanExpression implements ToBooleanExpression{
+        
+        private final boolean value;
+        
+        public ConstantToBooleanExpression(boolean value){
+            this.value = value;
+        }
+        
+        @Override
+        public boolean evaluate(){
+            return value;
+        }
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/expressions/ToDoubleExpression.java

@@ -0,0 +1,49 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.expressions;
+
+public interface ToDoubleExpression extends Expression{
+    
+    double evaluate();
+    
+    static ToDoubleExpression literal(double value){
+        return new ConstantToDoubleExpression(value);
+    }
+    
+    class ConstantToDoubleExpression implements ToDoubleExpression{
+        
+        private final double value;
+        
+        public ConstantToDoubleExpression(double value){
+            this.value = value;
+        }
+        
+        @Override
+        public double evaluate(){
+            return value;
+        }
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/expressions/ToStringExpression.java

@@ -0,0 +1,49 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.expressions;
+
+public interface ToStringExpression extends Expression{
+    
+    String evaluate();
+    
+    static ToStringExpression literal(String value){
+        return new ConstantToStringExpression(value);
+    }
+    
+    class ConstantToStringExpression implements ToStringExpression{
+        
+        private final String value;
+        
+        private ConstantToStringExpression(String value){
+            this.value = value;
+        }
+        
+        @Override
+        public String evaluate(){
+            return value;
+        }
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/operators/ListOperator.java

@@ -0,0 +1,56 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.operators;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+
+public abstract class ListOperator extends Operator{
+    
+    public ListOperator(int priority){
+        super(priority);
+    }
+    
+    public static ListOperator of(int priority, Function<Collection<ExpressionTemplate>, ExpressionTemplate> function){
+        return new ListOperator(priority){
+            @Override
+            public ExpressionTemplate createTemplate(List<ExpressionTemplate> operands){
+                return function.apply(operands);
+            }
+        };
+    }
+    
+    @Override
+    public ExpressionTemplate createTemplate(ExpressionTemplate a, ExpressionTemplate b){
+        return createTemplate(Arrays.asList(a, b));
+    }
+    
+    public abstract ExpressionTemplate createTemplate(List<ExpressionTemplate> operands);
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/operators/Operator.java

@@ -0,0 +1,54 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.operators;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+
+import java.util.function.BiFunction;
+
+public abstract class Operator{
+    
+    private final int priority;
+    
+    public Operator(int priority){
+        this.priority = priority;
+    }
+    
+    public static Operator of(int priority, BiFunction<ExpressionTemplate, ExpressionTemplate, ExpressionTemplate> function){
+        return new Operator(priority){
+            @Override
+            public ExpressionTemplate createTemplate(ExpressionTemplate a, ExpressionTemplate b){
+                return function.apply(a, b);
+            }
+        };
+    }
+    
+    public int getPriority(){
+        return priority;
+    }
+    
+    public abstract ExpressionTemplate createTemplate(ExpressionTemplate a, ExpressionTemplate b);
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/parsers/BooleanConstantReader.java

@@ -0,0 +1,44 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.parsers;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ConstantExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.BooleanToken;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.util.List;
+
+public class BooleanConstantReader extends ValueReader{
+    
+    @Override
+    public ExpressionTemplate read(ExpressionTemplateParser parser, List<Token> tokenList){
+        if(tokenList.get(0) instanceof BooleanToken){
+            return ConstantExpressionTemplate.of(((BooleanToken)tokenList.remove(0)).getValue());
+        }
+        return null;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/parsers/ExpressionTemplateParser.java

@@ -0,0 +1,133 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.parsers;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.operators.ListOperator;
+import ch.andre601.advancedserverlist.core.profiles.conditions.operators.Operator;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionErrorTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplates;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ExpressionTemplateParser{
+    
+    private final ImmutableMap<Token, Operator> operators;
+    private final ImmutableList<ValueReader> valueReaders;
+    
+    public ExpressionTemplateParser(ImmutableMap<Token, Operator> operators, ImmutableList<ValueReader> valueReaders){
+        this.operators = operators;
+        this.valueReaders = valueReaders;
+    }
+    
+    public ExpressionTemplate parse(List<Token> tokenList){
+        List<ExpressionTemplate> parts = new ArrayList<>();
+        List<Operator> operators = new ArrayList<>();
+        
+        try{
+            parts.add(read(tokenList));
+        }catch(IllegalArgumentException ex){
+            return ExpressionErrorTemplate.of(ex.getMessage());
+        }
+        
+        while(!tokenList.isEmpty()){
+            Token token = tokenList.remove(0);
+            Operator operator = this.operators.get(token);
+            if(operator == null){
+                return ExpressionErrorTemplate.of("Error while parsing Expression. Got \"" + token + "\" but expected OPERATOR.");
+            }
+            
+            operators.add(operator);
+            if(tokenList.isEmpty()){
+                return ExpressionErrorTemplate.of("Received unexpected end of input.");
+            }
+            
+            try{
+                parts.add(read(tokenList));
+            }catch(IllegalArgumentException ex){
+                return ExpressionErrorTemplate.of(ex.getMessage());
+            }
+        }
+        
+        while(!operators.isEmpty()){
+            Operator operator = operators.get(0);
+            int lowest = operator.getPriority();
+            int start = 0;
+            int end = 1;
+            for(int i = 1; i < operators.size(); i++){
+                operator = operators.get(i);
+                if(operator.getPriority() < lowest){
+                    lowest = operator.getPriority();
+                    start = i;
+                    end = i + 1;
+                }else
+                if(operator.getPriority() > lowest){
+                    break;
+                }else{
+                    end++;
+                }
+            }
+            
+            operator = operators.get(start);
+            
+            ExpressionTemplate replacement;
+            if(start + 1 == end){
+                replacement = operator.createTemplate(parts.get(start), parts.get(end));
+            }else
+            if(operator instanceof ListOperator listOperator){
+                replacement = listOperator.createTemplate(new ArrayList<>(parts.subList(start, end + 1)));
+            }else{
+                List<ExpressionTemplate> conditions = new ArrayList<>(end - start);
+                for(int i = start; i < end; i++)
+                    conditions.add(operators.get(i).createTemplate(parts.get(i), parts.get(i + 1)));
+                
+                replacement = ExpressionTemplates.and(conditions);
+            }
+            
+            for(int i = start; i < end; i++){
+                parts.remove(start);
+                operators.remove(start);
+            }
+            parts.set(start, replacement);
+        }
+        
+        return parts.get(0);
+    }
+    
+    ExpressionTemplate read(List<Token> tokenList){
+        for(ValueReader valueReader : valueReaders){
+            ExpressionTemplate template = valueReader.read(this, tokenList);
+            if(template != null)
+                return template;
+        }
+        
+        throw new IllegalArgumentException("Invalid Expression. Expected literal but got token \"" + tokenList.get(0).toString() + "\"");
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/parsers/NegatedExpressionReader.java

@@ -0,0 +1,51 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.parsers;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplates;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.util.List;
+
+public class NegatedExpressionReader extends ValueReader{
+    
+    private final Token tokenNegation;
+    
+    public NegatedExpressionReader(Token tokenNegation){
+        this.tokenNegation = tokenNegation;
+    }
+    
+    @Override
+    public ExpressionTemplate read(ExpressionTemplateParser parser, List<Token> tokenList){
+        if(tokenList.get(0) == tokenNegation){
+            tokenList.remove(0);
+            return ExpressionTemplates.negate(parser.read(tokenList));
+        }
+        
+        return null;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/parsers/NegatedNumberReader.java

@@ -0,0 +1,51 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.parsers;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplates;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.util.List;
+
+public class NegatedNumberReader extends ValueReader{
+    
+    private final Token tokenNegation;
+    
+    public NegatedNumberReader(Token tokenNegation){
+        this.tokenNegation = tokenNegation;
+    }
+    
+    @Override
+    public ExpressionTemplate read(ExpressionTemplateParser parser, List<Token> tokenList){
+        if(tokenList.get(0) == tokenNegation){
+            tokenList.remove(0);
+            return ExpressionTemplates.negateNumber(parser.read(tokenList));
+        }
+        
+        return null;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/parsers/NumberConstantReader.java

@@ -0,0 +1,43 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.parsers;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ConstantExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.NumberToken;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.util.List;
+
+public class NumberConstantReader extends ValueReader{
+    @Override
+    public ExpressionTemplate read(ExpressionTemplateParser parser, List<Token> tokenList){
+        if(tokenList.get(0) instanceof NumberToken){
+            return ConstantExpressionTemplate.of(((NumberToken)tokenList.remove(0)).getValue());
+        }
+        return null;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/parsers/ParenthesisedExpressionReader.java

@@ -0,0 +1,71 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.parsers;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ParenthesisedExpressionReader extends ValueReader{
+    
+    private final Token openingParenthesis;
+    private final Token closingParenthesis;
+    
+    public ParenthesisedExpressionReader(Token openingParenthesis, Token closingParenthesis){
+        this.openingParenthesis = openingParenthesis;
+        this.closingParenthesis = closingParenthesis;
+    }
+    
+    @Override
+    public ExpressionTemplate read(ExpressionTemplateParser parser, List<Token> tokenList){
+        if(tokenList.get(0) == openingParenthesis){
+            int index = 0;
+            int cnt = 1;
+            do {
+                index += 1;
+                if(tokenList.size() <= index)
+                    return null;
+                
+                Token token = tokenList.get(index);
+                if(token == openingParenthesis){
+                    cnt++;
+                }else
+                if(token == closingParenthesis){
+                    cnt--;
+                }
+            }while(cnt != 0);
+            
+            ExpressionTemplate result = parser.parse(new ArrayList<>(tokenList.subList(1, index)));
+            tokenList.subList(0, index + 1).clear();
+            
+            return result;
+        }
+        
+        return null;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/parsers/PlaceholderReader.java

@@ -0,0 +1,43 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.parsers;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.PlaceholderToken;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.util.List;
+
+public class PlaceholderReader extends ValueReader{
+    @Override
+    public ExpressionTemplate read(ExpressionTemplateParser parser, List<Token> tokenList){
+        if(tokenList.get(0) instanceof PlaceholderToken){
+            PlaceholderToken token = (PlaceholderToken)tokenList.remove(0);
+            return token.getValue();
+        }
+        return null;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/parsers/StringConstantReader.java

@@ -0,0 +1,44 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.parsers;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ConstantExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.StringToken;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.util.List;
+
+public class StringConstantReader extends ValueReader{
+    @Override
+    public ExpressionTemplate read(ExpressionTemplateParser parser, List<Token> tokenList){
+        if(tokenList.get(0) instanceof StringToken){
+            return ConstantExpressionTemplate.of(((StringToken)tokenList.remove(0)).getValue());
+        }
+        
+        return null;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/parsers/ValueReader.java

@@ -0,0 +1,36 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.parsers;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.util.List;
+
+public abstract class ValueReader{
+    
+    public abstract ExpressionTemplate read(ExpressionTemplateParser parser, List<Token> tokenList);
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/placeholders/Placeholder.java

@@ -0,0 +1,62 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.placeholders;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToBooleanExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToDoubleExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToStringExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.templates.ExpressionTemplate;
+
+public interface Placeholder extends ExpressionTemplate{
+    
+    static LiteralPlaceholderValue of(String value){
+        return new LiteralPlaceholderValue(value);
+    }
+    
+    class LiteralPlaceholderValue implements Placeholder{
+        
+        private final String value;
+        
+        public LiteralPlaceholderValue(String value){
+            this.value = value;
+        }
+        
+        @Override
+        public ToStringExpression instantiateWithStringResult(){
+            return ToStringExpression.literal(value);
+        }
+        
+        @Override
+        public ToDoubleExpression instantiateWithDoubleResult(){
+            return ToDoubleExpression.literal(value.length());
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return ToBooleanExpression.literal(Boolean.parseBoolean(value));
+        }
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/placeholders/PlaceholderParser.java

@@ -0,0 +1,111 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.placeholders;
+
+import ch.andre601.advancedserverlist.api.AdvancedServerListAPI;
+import ch.andre601.advancedserverlist.api.PlaceholderProvider;
+import ch.andre601.advancedserverlist.api.objects.GenericPlayer;
+import ch.andre601.advancedserverlist.api.objects.GenericServer;
+
+import java.text.ParsePosition;
+
+public class PlaceholderParser{
+    
+    public static Placeholder parse(String text, ParsePosition position, GenericPlayer player, GenericServer server){
+        AdvancedServerListAPI api = AdvancedServerListAPI.get();
+        int index = position.getIndex();
+        
+        StringBuilder identifier = new StringBuilder();
+        StringBuilder values = new StringBuilder();
+        
+        boolean identified = false;
+        boolean invalid = true;
+        
+        char[] chars = text.substring(index).toCharArray();
+        for(final char c : chars){
+            index++;
+            if(c == '}'){
+                invalid = false;
+                break;
+            }
+            
+            if(c == ' ' && !identified){
+                identified = true;
+                continue;
+            }
+            
+            if(identified){
+                values.append(c);
+            }else{
+                identifier.append(c);
+            }
+        }
+        
+        String identifierStr = identifier.toString();
+        String valuesStr = values.toString();
+        
+        StringBuilder raw = new StringBuilder();
+        
+        position.setIndex(index + 1);
+        
+        if(invalid){
+            raw.append("${").append(identifierStr);
+            
+            if(identified)
+                raw.append(' ').append(valuesStr);
+            
+            
+            return Placeholder.of(raw.toString());
+        }
+        
+        PlaceholderProvider provider = api.retrievePlaceholderProvider(identifierStr);
+        if(provider == null){
+            raw.append("${").append(identifierStr);
+            
+            if(identified)
+                raw.append(' ').append(valuesStr);
+            
+            
+            raw.append('}');
+            
+            return Placeholder.of(raw.toString());
+        }
+        
+        String replacement = provider.parsePlaceholder(valuesStr, player, server);
+        if(replacement == null){
+            raw.append("${").append(identifierStr);
+            
+            if(identified)
+                raw.append(' ').append(valuesStr);
+            
+            raw.append('}');
+            
+            return Placeholder.of(raw.toString());
+        }
+        
+        return Placeholder.of(replacement);
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/AbstractBinaryToBooleanExpression.java

@@ -0,0 +1,40 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.Expression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToBooleanExpression;
+
+public abstract class AbstractBinaryToBooleanExpression<T extends Expression> implements ToBooleanExpression{
+    
+    protected final T a;
+    protected final T b;
+    
+    public AbstractBinaryToBooleanExpression(T a, T b){
+        this.a = a;
+        this.b = b;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/AbstractBinaryToDoubleExpression.java

@@ -0,0 +1,40 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.Expression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToDoubleExpression;
+
+public abstract class AbstractBinaryToDoubleExpression<T extends Expression> implements ToDoubleExpression{
+    
+    protected final T a;
+    protected final T b;
+    
+    public AbstractBinaryToDoubleExpression(T a, T b){
+        this.a = a;
+        this.b = b;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/AbstractBooleanExpressionTemplate.java

@@ -0,0 +1,43 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.Conversions;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToDoubleExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToStringExpression;
+
+public abstract class AbstractBooleanExpressionTemplate implements ExpressionTemplate{
+    
+    @Override
+    public ToStringExpression instantiateWithStringResult(){
+        return Conversions.toString(instantiateWithBooleanResult());
+    }
+    
+    @Override
+    public ToDoubleExpression instantiateWithDoubleResult(){
+        return Conversions.toDouble(instantiateWithBooleanResult());
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/AbstractDoubleExpressionTemplate.java

@@ -0,0 +1,43 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.Conversions;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToBooleanExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToStringExpression;
+
+public abstract class AbstractDoubleExpressionTemplate implements ExpressionTemplate{
+    
+    @Override
+    public ToStringExpression instantiateWithStringResult(){
+        return Conversions.toString(instantiateWithDoubleResult());
+    }
+    
+    @Override
+    public ToBooleanExpression instantiateWithBooleanResult(){
+        return Conversions.toBoolean(instantiateWithDoubleResult());
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/AbstractStringExpressionTemplate.java

@@ -0,0 +1,43 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.Conversions;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToBooleanExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToDoubleExpression;
+
+public abstract class AbstractStringExpressionTemplate implements ExpressionTemplate{
+    
+    @Override
+    public ToDoubleExpression instantiateWithDoubleResult(){
+        return Conversions.toDouble(instantiateWithStringResult());
+    }
+    
+    @Override
+    public ToBooleanExpression instantiateWithBooleanResult(){
+        return Conversions.toBoolean(instantiateWithStringResult());
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/AbstractToBooleanExpression.java

@@ -0,0 +1,40 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.Expression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToBooleanExpression;
+
+import java.util.Collection;
+
+public abstract class AbstractToBooleanExpression<T extends Expression> implements ToBooleanExpression{
+    
+    protected final Collection<T> operands;
+    
+    public AbstractToBooleanExpression(Collection<T> operands){
+        this.operands = operands;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/AbstractToDoubleExpression.java

@@ -0,0 +1,40 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.Expression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToDoubleExpression;
+
+import java.util.Collection;
+
+public abstract class AbstractToDoubleExpression<T extends Expression> implements ToDoubleExpression{
+    
+    protected final Collection<T> operands;
+    
+    public AbstractToDoubleExpression(Collection<T> operands){
+        this.operands = operands;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/AbstractToStringExpression.java

@@ -0,0 +1,40 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.Expression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToStringExpression;
+
+import java.util.Collection;
+
+public abstract class AbstractToStringExpression<T extends Expression> implements ToStringExpression{
+    
+    protected Collection<T> operands;
+    
+    public AbstractToStringExpression(Collection<T> operands){
+        this.operands = operands;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/AbstractUnaryToBooleanExpression.java

@@ -0,0 +1,38 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.Expression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToBooleanExpression;
+
+public abstract class AbstractUnaryToBooleanExpression<T extends Expression> implements ToBooleanExpression{
+    
+    protected final T delegate;
+    
+    public AbstractUnaryToBooleanExpression(T delegate){
+        this.delegate = delegate;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/AbstractUnaryToDoubleExpression.java

@@ -0,0 +1,38 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.Expression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToDoubleExpression;
+
+public abstract class AbstractUnaryToDoubleExpression<T extends Expression> implements ToDoubleExpression{
+    
+    protected final T delegate;
+    
+    public AbstractUnaryToDoubleExpression(T delegate){
+        this.delegate = delegate;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/AbstractUnaryToStringExpression.java

@@ -0,0 +1,38 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.Expression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToStringExpression;
+
+public abstract class AbstractUnaryToStringExpression<T extends Expression> implements ToStringExpression{
+    
+    protected final T delegate;
+    
+    public AbstractUnaryToStringExpression(T delegate){
+        this.delegate = delegate;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/ConstantExpressionTemplate.java

@@ -0,0 +1,77 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToBooleanExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToDoubleExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToStringExpression;
+
+public class ConstantExpressionTemplate implements ExpressionTemplate{
+    
+    private final ToStringExpression stringExpression;
+    private final ToDoubleExpression doubleExpression;
+    private final ToBooleanExpression booleanExpression;
+    
+    private ConstantExpressionTemplate(String stringValue, double doubleValue, boolean booleanValue){
+        this.stringExpression = ToStringExpression.literal(stringValue);
+        this.doubleExpression = ToDoubleExpression.literal(doubleValue);
+        this.booleanExpression = ToBooleanExpression.literal(booleanValue);
+    }
+    
+    public static ConstantExpressionTemplate of(String stringValue){
+        double doubleValue;
+        try{
+            doubleValue = Double.parseDouble(stringValue);
+        }catch(NumberFormatException ex){
+            doubleValue = stringValue.length();
+        }
+        return new ConstantExpressionTemplate(stringValue, doubleValue, Boolean.parseBoolean(stringValue));
+    }
+    
+    public static ConstantExpressionTemplate of(double doubleValue){
+        return new ConstantExpressionTemplate(((int)doubleValue) == doubleValue ? Integer.toString((int)doubleValue) : Double.toString(doubleValue), doubleValue, doubleValue != 0);
+    }
+    
+    public static ConstantExpressionTemplate of(boolean booleanValue){
+        return new ConstantExpressionTemplate(Boolean.toString(booleanValue), booleanValue ? 1 : 0, booleanValue);
+    }
+    
+    
+    @Override
+    public ToStringExpression instantiateWithStringResult(){
+        return stringExpression;
+    }
+    
+    @Override
+    public ToDoubleExpression instantiateWithDoubleResult(){
+        return doubleExpression;
+    }
+    
+    @Override
+    public ToBooleanExpression instantiateWithBooleanResult(){
+        return booleanExpression;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/ExpressionErrorTemplate.java

@@ -0,0 +1,58 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToBooleanExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToDoubleExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToStringExpression;
+
+public class ExpressionErrorTemplate implements ExpressionTemplate{
+    
+    private final String msg;
+    
+    private ExpressionErrorTemplate(String msg){
+        this.msg = msg;
+    }
+    
+    public static ExpressionErrorTemplate of(String msg){
+        return new ExpressionErrorTemplate(msg);
+    }
+    
+    @Override
+    public ToStringExpression instantiateWithStringResult(){
+        return ToStringExpression.literal(msg);
+    }
+    
+    @Override
+    public ToDoubleExpression instantiateWithDoubleResult(){
+        return ToDoubleExpression.literal(0);
+    }
+    
+    @Override
+    public ToBooleanExpression instantiateWithBooleanResult(){
+        return ToBooleanExpression.literal(false);
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/ExpressionTemplate.java

@@ -0,0 +1,39 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToBooleanExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToDoubleExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToStringExpression;
+
+public interface ExpressionTemplate{
+    
+    ToStringExpression instantiateWithStringResult();
+    
+    ToDoubleExpression instantiateWithDoubleResult();
+    
+    ToBooleanExpression instantiateWithBooleanResult();
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/templates/ExpressionTemplates.java

@@ -0,0 +1,362 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.templates;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.Expressions;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToBooleanExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToDoubleExpression;
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ToStringExpression;
+
+import java.util.Collection;
+
+public class ExpressionTemplates{
+    
+    public static ExpressionTemplate negate(ExpressionTemplate template){
+        return new Negation(template);
+    }
+    
+    public static ExpressionTemplate and(Collection<ExpressionTemplate> operands){
+        return new And(operands);
+    }
+    
+    public static ExpressionTemplate or(Collection<ExpressionTemplate> operands){
+        return new Or(operands);
+    }
+    
+    public static ExpressionTemplate concat(Collection<ExpressionTemplate> operands){
+        return new Concatenate(operands);
+    }
+    
+    public static ExpressionTemplate equal(ExpressionTemplate a, ExpressionTemplate b){
+        return new Equal(a, b);
+    }
+    
+    public static ExpressionTemplate notEqual(ExpressionTemplate a, ExpressionTemplate b){
+        return new NotEqual(a, b);
+    }
+    
+    public static ExpressionTemplate equalIgnoreCase(ExpressionTemplate a, ExpressionTemplate b){
+        return new EqualIgnoreCase(a, b);
+    }
+    
+    public static ExpressionTemplate notEqualIgnoreCase(ExpressionTemplate a, ExpressionTemplate b){
+        return new NotEqualIgnoreCase(a, b);
+    }
+    
+    public static ExpressionTemplate greater(ExpressionTemplate a, ExpressionTemplate b){
+        return new Greater(a, b);
+    }
+    
+    public static ExpressionTemplate greaterOrEqual(ExpressionTemplate a, ExpressionTemplate b){
+        return new GreaterOrEqual(a, b);
+    }
+    
+    public static ExpressionTemplate less(ExpressionTemplate a, ExpressionTemplate b){
+        return new Less(a, b);
+    }
+    
+    public static ExpressionTemplate lessOrEqual(ExpressionTemplate a, ExpressionTemplate b){
+        return new LessOrEqual(a, b);
+    }
+    
+    public static ExpressionTemplate sum(Collection<ExpressionTemplate> operands){
+        return new Sum(operands);
+    }
+    
+    public static ExpressionTemplate product(Collection<ExpressionTemplate> operands){
+        return new Product(operands);
+    }
+    
+    public static ExpressionTemplate sub(ExpressionTemplate a, ExpressionTemplate b){
+        return new Sub(a, b);
+    }
+    
+    public static ExpressionTemplate div(ExpressionTemplate a, ExpressionTemplate b){
+        return new Div(a, b);
+    }
+    
+    public static ExpressionTemplate negateNumber(ExpressionTemplate template){
+        return new NegationNumber(template);
+    }
+    
+    private static class Negation extends AbstractBooleanExpressionTemplate{
+        
+        private final ExpressionTemplate template;
+        
+        Negation(ExpressionTemplate template){
+            this.template = template;
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return Expressions.negate(template.instantiateWithBooleanResult());
+        }
+    }
+    
+    private static class And extends AbstractBooleanExpressionTemplate{
+        
+        private final Collection<ExpressionTemplate> operands;
+        
+        And(Collection<ExpressionTemplate> operands){
+            this.operands = operands;
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return Expressions.and(operands.stream().map(ExpressionTemplate::instantiateWithBooleanResult).toList());
+        }
+    }
+    
+    private static class Or extends AbstractBooleanExpressionTemplate{
+        
+        private final Collection<ExpressionTemplate> operands;
+        
+        Or(Collection<ExpressionTemplate> operands){
+            this.operands = operands;
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return Expressions.or(operands.stream().map(ExpressionTemplate::instantiateWithBooleanResult).toList());
+        }
+    }
+    
+    private static class Concatenate extends AbstractStringExpressionTemplate{
+        
+        private final Collection<ExpressionTemplate> operands;
+        
+        Concatenate(Collection<ExpressionTemplate> operands){
+            this.operands = operands;
+        }
+        
+        @Override
+        public ToStringExpression instantiateWithStringResult(){
+            return Expressions.concat(operands.stream().map(ExpressionTemplate::instantiateWithStringResult).toList());
+        }
+    }
+    
+    private static class Equal extends AbstractBooleanExpressionTemplate{
+        
+        private final ExpressionTemplate a;
+        private final ExpressionTemplate b;
+        
+        Equal(ExpressionTemplate a, ExpressionTemplate b){
+            this.a = a;
+            this.b = b;
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return Expressions.equal(a.instantiateWithStringResult(), b.instantiateWithStringResult());
+        }
+    }
+    
+    private static class NotEqual extends AbstractBooleanExpressionTemplate{
+        
+        private final ExpressionTemplate a;
+        private final ExpressionTemplate b;
+        
+        NotEqual(ExpressionTemplate a, ExpressionTemplate b){
+            this.a = a;
+            this.b = b;
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return Expressions.notEqual(a.instantiateWithStringResult(), b.instantiateWithStringResult());
+        }
+    }
+    
+    private static class EqualIgnoreCase extends AbstractBooleanExpressionTemplate{
+        
+        private final ExpressionTemplate a;
+        private final ExpressionTemplate b;
+        
+        EqualIgnoreCase(ExpressionTemplate a, ExpressionTemplate b){
+            this.a = a;
+            this.b = b;
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return Expressions.equalIgnoreCase(a.instantiateWithStringResult(), b.instantiateWithStringResult());
+        }
+    }
+    
+    private static class NotEqualIgnoreCase extends AbstractBooleanExpressionTemplate{
+        
+        private final ExpressionTemplate a;
+        private final ExpressionTemplate b;
+        
+        NotEqualIgnoreCase(ExpressionTemplate a, ExpressionTemplate b){
+            this.a = a;
+            this.b = b;
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return Expressions.notEqualIgnoreCase(a.instantiateWithStringResult(), b.instantiateWithStringResult());
+        }
+    }
+    
+    private static class Greater extends AbstractBooleanExpressionTemplate{
+        
+        private final ExpressionTemplate a;
+        private final ExpressionTemplate b;
+        
+        Greater(ExpressionTemplate a, ExpressionTemplate b){
+            this.a = a;
+            this.b = b;
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return Expressions.greaterThan(a.instantiateWithDoubleResult(), b.instantiateWithDoubleResult());
+        }
+    }
+    
+    private static class GreaterOrEqual extends AbstractBooleanExpressionTemplate{
+        
+        private final ExpressionTemplate a;
+        private final ExpressionTemplate b;
+        
+        GreaterOrEqual(ExpressionTemplate a, ExpressionTemplate b){
+            this.a = a;
+            this.b = b;
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return Expressions.greaterOrEqualThan(a.instantiateWithDoubleResult(), b.instantiateWithDoubleResult());
+        }
+    }
+    
+    private static class Less extends AbstractBooleanExpressionTemplate{
+        
+        private final ExpressionTemplate a;
+        private final ExpressionTemplate b;
+        
+        Less(ExpressionTemplate a, ExpressionTemplate b){
+            this.a = a;
+            this.b = b;
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return Expressions.lessThan(a.instantiateWithDoubleResult(), b.instantiateWithDoubleResult());
+        }
+    }
+    
+    private static class LessOrEqual extends AbstractBooleanExpressionTemplate{
+        
+        private final ExpressionTemplate a;
+        private final ExpressionTemplate b;
+        
+        LessOrEqual(ExpressionTemplate a, ExpressionTemplate b){
+            this.a = a;
+            this.b = b;
+        }
+        
+        @Override
+        public ToBooleanExpression instantiateWithBooleanResult(){
+            return Expressions.lessOrEqualThan(a.instantiateWithDoubleResult(), b.instantiateWithDoubleResult());
+        }
+    }
+    
+    private static class Sum extends AbstractDoubleExpressionTemplate{
+        
+        private final Collection<ExpressionTemplate> operands;
+        
+        Sum(Collection<ExpressionTemplate> operands){
+            this.operands = operands;
+        }
+        
+        @Override
+        public ToDoubleExpression instantiateWithDoubleResult(){
+            return Expressions.sum(operands.stream().map(ExpressionTemplate::instantiateWithDoubleResult).toList());
+        }
+    }
+    
+    private static class Product extends AbstractDoubleExpressionTemplate{
+        
+        private final Collection<ExpressionTemplate> operands;
+        
+        Product(Collection<ExpressionTemplate> operands){
+            this.operands = operands;
+        }
+        
+        @Override
+        public ToDoubleExpression instantiateWithDoubleResult(){
+            return Expressions.product(operands.stream().map(ExpressionTemplate::instantiateWithDoubleResult).toList());
+        }
+    }
+    
+    private static class Sub extends AbstractDoubleExpressionTemplate{
+        
+        private final ExpressionTemplate a;
+        private final ExpressionTemplate b;
+        
+        Sub(ExpressionTemplate a, ExpressionTemplate b){
+            this.a = a;
+            this.b = b;
+        }
+        
+        @Override
+        public ToDoubleExpression instantiateWithDoubleResult(){
+            return Expressions.sub(a.instantiateWithDoubleResult(), b.instantiateWithDoubleResult());
+        }
+    }
+    
+    private static class Div extends AbstractDoubleExpressionTemplate{
+        
+        private final ExpressionTemplate a;
+        private final ExpressionTemplate b;
+        
+        Div(ExpressionTemplate a, ExpressionTemplate b){
+            this.a = a;
+            this.b = b;
+        }
+        
+        @Override
+        public ToDoubleExpression instantiateWithDoubleResult(){
+            return Expressions.div(a.instantiateWithDoubleResult(), b.instantiateWithDoubleResult());
+        }
+    }
+    
+    private static class NegationNumber extends AbstractDoubleExpressionTemplate{
+        
+        private final ExpressionTemplate template;
+        
+        NegationNumber(ExpressionTemplate template){
+            this.template = template;
+        }
+        
+        @Override
+        public ToDoubleExpression instantiateWithDoubleResult(){
+            return Expressions.negateNumber(template.instantiateWithDoubleResult());
+        }
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/BooleanToken.java

@@ -0,0 +1,42 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens;
+
+public class BooleanToken extends Token{
+    
+    public static final BooleanToken TRUE = new BooleanToken(true);
+    public static final BooleanToken FALSE = new BooleanToken(false);
+    private final boolean value;
+    
+    public BooleanToken(boolean value){
+        super("BOOLEAN(" + value + ")");
+        this.value = value;
+    }
+    
+    public boolean getValue(){
+        return value;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/DefaultTokens.java

@@ -0,0 +1,47 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens;
+
+public class DefaultTokens{
+    public static final Token AND = new Token("AND");
+    public static final Token OR = new Token("OR");
+    public static final Token OPENING_PARENTHESIS = new Token("OPENING_PARENTHESIS");
+    public static final Token CLOSING_PARENTHESIS = new Token("CLOSING_PARENTHESIS");
+    public static final Token EQUAL = new Token("EQUAL");
+    public static final Token NOT_EQUAL = new Token("NOT_EQUAL");
+    public static final Token EQUAL_IGNORE_CASE = new Token("EQUAL_IGNORE_CASE");
+    public static final Token NOT_EQUAL_IGNORE_CASE = new Token("NOT_EQUAL_IGNORE_CASE");
+    public static final Token NEGATION = new Token("NEGATION");
+    public static final Token GREATER_THAN = new Token("GREATER_THAN");
+    public static final Token GREATER_OR_EQUAL_THAN = new Token("GREATER_OR_EQUAL_THAN");
+    public static final Token LESSER_THAN = new Token("LESSER_THAN");
+    public static final Token LESSER_OR_EQUAL_THAN = new Token("LESSER_OR_EQUAL_THAN");
+    public static final Token CONCAT_STRING = new Token("CONCAT_STRING");
+    public static final Token ADD = new Token("ADD");
+    public static final Token SUB = new Token("SUB");
+    public static final Token MULT = new Token("MULT");
+    public static final Token DIV = new Token("DIV");
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/NumberToken.java

@@ -0,0 +1,40 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens;
+
+public class NumberToken extends Token{
+    
+    private final double value;
+    
+    public NumberToken(double value){
+        super("NUMBER(" + value + ")");
+        this.value = value;
+    }
+    
+    public double getValue(){
+        return value;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/PlaceholderToken.java

@@ -0,0 +1,42 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.placeholders.Placeholder;
+
+public class PlaceholderToken extends Token{
+    
+    private final Placeholder value;
+    
+    public PlaceholderToken(Placeholder value){
+        super("PLACEHOLDER");
+        this.value = value;
+    }
+    
+    public Placeholder getValue(){
+        return value;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/StringToken.java

@@ -0,0 +1,40 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens;
+
+public class StringToken extends Token{
+    
+    private final String value;
+    
+    public StringToken(String value){
+        super("STRING(" + value + ")");
+        this.value = value;
+    }
+    
+    public String getValue(){
+        return value;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/Token.java

@@ -0,0 +1,40 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens;
+
+public class Token{
+    
+    private final String id;
+    
+    public Token(String id){
+        this.id = id;
+    }
+    
+    @Override
+    public String toString(){
+        return id;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/readers/NonQuotedLiteralTokenReader.java

@@ -0,0 +1,53 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens.readers;
+
+import ch.andre601.advancedserverlist.api.objects.GenericPlayer;
+import ch.andre601.advancedserverlist.api.objects.GenericServer;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.StringToken;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.text.ParsePosition;
+
+public class NonQuotedLiteralTokenReader extends TokenReader{
+    
+    public NonQuotedLiteralTokenReader(int priority){
+        super(priority);
+    }
+    
+    @Override
+    public Token read(String text, ParsePosition position, GenericPlayer player, GenericServer server){
+        int startIndex = position.getIndex();
+        int index = position.getIndex();
+        
+        while(++index < text.length() && !Character.isWhitespace(text.charAt(index)))
+            ;
+        
+        position.setIndex(index);
+        
+        return new StringToken(text.substring(startIndex, position.getIndex()));
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/readers/NumberTokenReader.java

@@ -0,0 +1,55 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens.readers;
+
+import ch.andre601.advancedserverlist.api.objects.GenericPlayer;
+import ch.andre601.advancedserverlist.api.objects.GenericServer;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.NumberToken;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.text.NumberFormat;
+import java.text.ParsePosition;
+import java.util.Locale;
+
+public class NumberTokenReader extends TokenReader{
+    
+    private final NumberFormat format = NumberFormat.getInstance(Locale.ROOT);
+    
+    public NumberTokenReader(int priority){
+        super(priority);
+    }
+    
+    @Override
+    public Token read(String text, ParsePosition position, GenericPlayer player, GenericServer server){
+        int previous = position.getIndex();
+        Number number = format.parse(text, position);
+        
+        if(position.getIndex() != previous)
+            return new NumberToken(number.doubleValue());
+        
+        return null;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/readers/PatternTokenReader.java

@@ -0,0 +1,61 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens.readers;
+
+import ch.andre601.advancedserverlist.api.objects.GenericPlayer;
+import ch.andre601.advancedserverlist.api.objects.GenericServer;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.text.ParsePosition;
+
+public class PatternTokenReader extends TokenReader{
+    
+    private final Token token;
+    private final String pattern;
+    private final boolean ignoreCase;
+    
+    public PatternTokenReader(Token token, String pattern){
+        this(token, pattern, true);
+    }
+    
+    public PatternTokenReader(Token token, String pattern, boolean ignoreCase){
+        super(pattern.length());
+        
+        this.token = token;
+        this.pattern = pattern;
+        this.ignoreCase = ignoreCase;
+    }
+    
+    @Override
+    public Token read(String text, ParsePosition position, GenericPlayer player, GenericServer server){
+        if(text.regionMatches(ignoreCase, position.getIndex(), pattern, 0, pattern.length())){
+            position.setIndex(position.getIndex() + pattern.length());
+            return token;
+        }
+        
+        return null;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/readers/PlaceholderTokenReader.java

@@ -0,0 +1,50 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens.readers;
+
+import ch.andre601.advancedserverlist.api.objects.GenericPlayer;
+import ch.andre601.advancedserverlist.api.objects.GenericServer;
+import ch.andre601.advancedserverlist.core.profiles.conditions.placeholders.PlaceholderParser;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.PlaceholderToken;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.text.ParsePosition;
+
+public class PlaceholderTokenReader extends TokenReader{
+    
+    public PlaceholderTokenReader(int priority){
+        super(priority);
+    }
+    
+    @Override
+    public Token read(String text, ParsePosition position, GenericPlayer player, GenericServer server){
+        if(position.getIndex() + 1 < text.length() && text.charAt(position.getIndex()) == '$' && text.charAt(position.getIndex() + 1) == '{'){
+            position.setIndex(position.getIndex() + 2);
+            return new PlaceholderToken(PlaceholderParser.parse(text, position, player, server));
+        }
+        return null;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/readers/QuotedLiteralTokenReader.java

@@ -0,0 +1,62 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens.readers;
+
+import ch.andre601.advancedserverlist.api.objects.GenericPlayer;
+import ch.andre601.advancedserverlist.api.objects.GenericServer;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.StringToken;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.text.ParsePosition;
+
+public class QuotedLiteralTokenReader extends TokenReader{
+    
+    private final char quote;
+    
+    public QuotedLiteralTokenReader(int priority, char quote){
+        super(priority);
+        
+        this.quote = quote;
+    }
+    
+    @Override
+    public Token read(String text, ParsePosition position, GenericPlayer player, GenericServer server){
+        if(position.getIndex() < text.length() && text.charAt(position.getIndex()) == quote){
+            int startIndex = position.getIndex();
+            
+            position.setIndex(position.getIndex() + 1);
+            
+            while(position.getIndex() < text.length() && quote != text.charAt(position.getIndex()))
+                position.setIndex(position.getIndex() + 1);
+            
+            position.setIndex(position.getIndex() + 1);
+            
+            return new StringToken(text.substring(startIndex + 1, position.getIndex() - 1));
+        }
+        
+        return null;
+    }
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/conditions/tokens/readers/TokenReader.java

@@ -0,0 +1,47 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.core.profiles.conditions.tokens.readers;
+
+import ch.andre601.advancedserverlist.api.objects.GenericPlayer;
+import ch.andre601.advancedserverlist.api.objects.GenericServer;
+import ch.andre601.advancedserverlist.core.profiles.conditions.tokens.Token;
+
+import java.text.ParsePosition;
+
+public abstract class TokenReader{
+    
+    private final int priority;
+    
+    public TokenReader(int priority){
+        this.priority = priority;
+    }
+    
+    public int getPriority(){
+        return priority;
+    }
+    
+    public abstract Token read(String text, ParsePosition position, GenericPlayer player, GenericServer server);
+}

core/src/main/java/ch/andre601/advancedserverlist/core/profiles/profile/ProfileManager.java

@@ -67,7 +67,7 @@ public class ProfileManager{
             if(profile.isInvalidProfile())
                 continue;
             
-            if(profile.evalConditions(player, server))
+            if(profile.evalConditions(core.getExpressionEngine(), core.getPlugin().getPluginLogger(), player, server))
                 return profile;
         }
         

core/src/main/resources/profiles/default.yml

@@ -6,6 +6,15 @@
 #
 priority: 0
 
+#
+# Set conditions that need to me met to show this profile.
+# You can use keywords 'and' or 'or' (Or alternatively '&&' or `||`) to make more complex condition sets.
+#
+# Read more: https://asl.andre601.ch/profiles/#condition
+#
+# condition: '${player protocol} < 759'
+#
+
 #
 # Set conditions that needs to be met.
 # Only when all conditions return true will the profile be shown (Given no profile with higher priority is used).

core/src/test/java/ch/andre601/advancedserverlist/test/DummyPluginLogger.java

@@ -0,0 +1,60 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.test;
+
+import ch.andre601.advancedserverlist.core.interfaces.PluginLogger;
+
+public class DummyPluginLogger implements PluginLogger{
+    @Override
+    public void debug(Class<?> clazz, String msg, Object... args){
+        info("[DEBUG] [" + clazz.getSimpleName() + "] " + msg, args);
+    }
+    
+    @Override
+    public void debugWarn(Class<?> clazz, String msg, Object... args){
+        warn("[DEBUG] [" + clazz.getSimpleName() + "] " + msg, args);
+    }
+    
+    @Override
+    public void info(String msg, Object... args){
+        System.out.printf((msg) + "%n", args);
+    }
+    
+    @Override
+    public void warn(String msg, Object... args){
+        System.out.printf((msg) + "%n", args);
+    }
+    
+    @Override
+    public void warn(String msg, Throwable throwable){
+        System.out.printf((msg) + "%n", throwable);
+    }
+    
+    @Override
+    public void warn(String msg, Throwable throwable, Object... args){
+        System.out.printf((msg) + "%n", args);
+    }
+}

core/src/test/java/ch/andre601/advancedserverlist/test/ExpressionParserTests.java

@@ -0,0 +1,63 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022-2024 Andre_601
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package ch.andre601.advancedserverlist.test;
+
+import ch.andre601.advancedserverlist.core.profiles.conditions.expressions.ExpressionEngine;
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+
+public class ExpressionParserTests{
+    
+    private final ExpressionEngine expressionEngine = new ExpressionEngine();
+    private final DummyPluginLogger logger = new DummyPluginLogger();
+    private final Map<String, Boolean> testValuesMap = getTestMap();
+    
+    @Test
+    public void testBasicExpressionResults(){
+        for(Map.Entry<String, Boolean> values : testValuesMap.entrySet()){
+            logger.info("TEST[expression=\"%s\", expected=%b]", values.getKey(), values.getValue());
+            
+            boolean result = expressionEngine.compile(values.getKey(), logger, null, null).instantiateWithBooleanResult().evaluate();
+            logger.info("Result (output, isExpected): " + result + ", " + (result == values.getValue()));
+        }
+    }
+    
+    private Map<String, Boolean> getTestMap(){
+        return Map.of(
+            "20 > 10", true,
+            "10 > 20", false,
+            "10 = 10", true,
+            "10 = 20", false,
+            "(10 - 5) > (1 + 1)", true,
+            "(10 - 10) > (1 + 1)", false,
+            "100 > 50 and 50 < 100", true,
+            "100 < 50 and 50 > 100", false,
+            "true or 100 > 10", true,
+            "false or 100 < 10", false
+        );
+    }
+}

core/src/test/java/ch/andre601/advancedserverlist/test/FlexVerTests.java

@@ -26,7 +26,9 @@
 package ch.andre601.advancedserverlist.test;
 
 import com.unascribed.flexver.FlexVerComparator;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class FlexVerTests{
     
@@ -286,7 +288,9 @@ public class FlexVerTests{
     
     private void compare(String version1, String comparator, String version2, int expected){
         String expression = version1 + " " + comparator + " " + version2 + "?";
+        int result = FlexVerComparator.compare(version1, version2);
         
         System.out.printf("│ %-24s %5b │\n", expression, FlexVerComparator.compare(version1, version2) == expected);
+        assertEquals(result, expected);
     }
 }

docs/.hooks/badges.py

@@ -25,18 +25,19 @@ def on_page_markdown(
     def replace(match: Match):
         type, args = match.groups()
         args = args.strip()
-        if type == "abstract":   return _admo(text = args, type = "abstract")
-        elif type == "info":     return _admo(text = args, type = "info")
-        elif type == "tip":      return _admo(text = args, type = "tip")
-        elif type == "success":  return _admo(text = args, type = "success")
-        elif type == "question": return _admo(text = args, type = "question")
-        elif type == "warning":  return _admo(text = args, type = "warning")
-        elif type == "failure":  return _admo(text = args, type = "failure")
-        elif type == "danger":   return _admo(text = args, type = "danger")
-        elif type == "bug":      return _admo(text = args, type = "bug")
-        elif type == "example":  return _admo(text = args, type = "example")
-        elif type == "quote":    return _admo(text = args, type = "quote")
-        else:                    return _admo(text = args)
+        if type == "abstract":     return _admo(text = args, type = "abstract")
+        elif type == "info":       return _admo(text = args, type = "info")
+        elif type == "tip":        return _admo(text = args, type = "tip")
+        elif type == "success":    return _admo(text = args, type = "success")
+        elif type == "question":   return _admo(text = args, type = "question")
+        elif type == "warning":    return _admo(text = args, type = "warning")
+        elif type == "failure":    return _admo(text = args, type = "failure")
+        elif type == "danger":     return _admo(text = args, type = "danger")
+        elif type == "bug":        return _admo(text = args, type = "bug")
+        elif type == "example":    return _admo(text = args, type = "example")
+        elif type == "quote":      return _admo(text = args, type = "quote")
+        elif type == "deprecated": return _admo(text = args, type = "deprecated")
+        else:                      return _admo(text = args)
 
         # Otherwise, raise an error
         raise RuntimeError(f"Unknown shortcode: {type}")

docs/assets/stylesheets/admo.css

@@ -23,6 +23,8 @@
     --md-badge-bg--example: #7c4dff1a;
     --md-badge-fg--quote: #9e9e9e;
     --md-badge-bg--quote: #9e9e9e1a;
+    --md-badge-fg--deprecated: #ff5252;
+    --md-badge-bg--deprecated: #ff52521a;
     
     --badge-icon--note: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M17.263 2.177a1.75 1.75 0 0 1 2.474 0l2.586 2.586a1.75 1.75 0 0 1 0 2.474L19.53 10.03l-.012.013L8.69 20.378a1.753 1.753 0 0 1-.699.409l-5.523 1.68a.748.748 0 0 1-.747-.188.748.748 0 0 1-.188-.747l1.673-5.5a1.75 1.75 0 0 1 .466-.756L14.476 4.963ZM4.708 16.361a.26.26 0 0 0-.067.108l-1.264 4.154 4.177-1.271a.253.253 0 0 0 .1-.059l10.273-9.806-2.94-2.939-10.279 9.813ZM19 8.44l2.263-2.262a.25.25 0 0 0 0-.354l-2.586-2.586a.25.25 0 0 0-.354 0L16.061 5.5Z"></path></svg>');
     --badge-icon--abstract: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M5.962 2.513a.75.75 0 0 1-.475.949l-.816.272a.25.25 0 0 0-.171.237V21.25c0 .138.112.25.25.25h14.5a.25.25 0 0 0 .25-.25V3.97a.25.25 0 0 0-.17-.236l-.817-.272a.75.75 0 0 1 .474-1.424l.816.273A1.751 1.751 0 0 1 21 3.97v17.28A1.75 1.75 0 0 1 19.25 23H4.75A1.75 1.75 0 0 1 3 21.25V3.97a1.75 1.75 0 0 1 1.197-1.66l.816-.272a.75.75 0 0 1 .949.475Z"></path><path d="M7 1.75C7 .784 7.784 0 8.75 0h6.5C16.216 0 17 .784 17 1.75v1.5A1.75 1.75 0 0 1 15.25 5h-6.5A1.75 1.75 0 0 1 7 3.25Zm1.75-.25a.25.25 0 0 0-.25.25v1.5c0 .138.112.25.25.25h6.5a.25.25 0 0 0 .25-.25v-1.5a.25.25 0 0 0-.25-.25Z"></path></svg>');
@@ -36,6 +38,7 @@
     --badge-icon--bug: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M7.72.22a.75.75 0 0 1 1.06 0l1.204 1.203A4.98 4.98 0 0 1 12 1c.717 0 1.4.151 2.016.423L15.22.22a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042l-.971.972A4.991 4.991 0 0 1 17 6v1.104a2.755 2.755 0 0 1 1.917 1.974l1.998-.999a.75.75 0 0 1 .67 1.342L19 10.714V13.5l3.25.003a.75.75 0 0 1 0 1.5L19 15.001V16c0 .568-.068 1.134-.204 1.686l.04.018 2.75 1.375a.75.75 0 1 1-.671 1.342l-2.638-1.319A6.998 6.998 0 0 1 12 23a6.998 6.998 0 0 1-6.197-3.742l-2.758 1.181a.752.752 0 0 1-1.064-.776.752.752 0 0 1 .474-.602l2.795-1.199A6.976 6.976 0 0 1 5 16v-.996H1.75a.75.75 0 0 1 0-1.5H5v-2.79L2.415 9.42a.75.75 0 0 1 .67-1.342l1.998.999A2.756 2.756 0 0 1 7 7.104V6a4.99 4.99 0 0 1 1.69-3.748l-.97-.972a.75.75 0 0 1 0-1.06ZM6.5 9.75V16a5.5 5.5 0 1 0 11 0V9.75c0-.69-.56-1.25-1.25-1.25h-8.5c-.69 0-1.25.56-1.25 1.25ZM8.5 7h7V6a3.5 3.5 0 1 0-7 0Z"></path></svg>');
     --badge-icon--example: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M8 8.807V3.5h-.563a.75.75 0 0 1 0-1.5h9.125a.75.75 0 0 1 0 1.5H16v5.307l5.125 9.301c.964 1.75-.302 3.892-2.299 3.892H5.174c-1.998 0-3.263-2.142-2.3-3.892ZM4.189 18.832a1.123 1.123 0 0 0 .985 1.668h13.652a1.123 1.123 0 0 0 .985-1.668L17.7 15H6.3ZM14.5 3.5h-5V9a.75.75 0 0 1-.093.362L7.127 13.5h9.746l-2.28-4.138A.75.75 0 0 1 14.5 9Z"></path></svg>');
     --badge-icon--quote: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M3 6.25a.75.75 0 0 1 .75-.75h13.5a.75.75 0 0 1 0 1.5H3.75A.75.75 0 0 1 3 6.25Zm5 6.063a.75.75 0 0 1 .75-.75h11.5a.75.75 0 0 1 0 1.5H8.75a.75.75 0 0 1-.75-.75Zm0 5.937a.75.75 0 0 1 .75-.75h11.5a.75.75 0 0 1 0 1.5H8.75a.75.75 0 0 1-.75-.75ZM3.75 11a.75.75 0 0 1 .75.75v7a.75.75 0 0 1-1.5 0v-7a.75.75 0 0 1 .75-.75Z"></path></svg>');
+    --badge-icon--deprecated: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24"><path d="M16 1.75V3h5.25a.75.75 0 0 1 0 1.5H2.75a.75.75 0 0 1 0-1.5H8V1.75C8 .784 8.784 0 9.75 0h4.5C15.216 0 16 .784 16 1.75Zm-6.5 0V3h5V1.75a.25.25 0 0 0-.25-.25h-4.5a.25.25 0 0 0-.25.25ZM4.997 6.178a.75.75 0 1 0-1.493.144L4.916 20.92a1.75 1.75 0 0 0 1.742 1.58h10.684a1.75 1.75 0 0 0 1.742-1.581l1.413-14.597a.75.75 0 0 0-1.494-.144l-1.412 14.596a.25.25 0 0 1-.249.226H6.658a.25.25 0 0 1-.249-.226L4.997 6.178Z"></path><path d="M9.206 7.501a.75.75 0 0 1 .793.705l.5 8.5A.75.75 0 1 1 9 16.794l-.5-8.5a.75.75 0 0 1 .705-.793Zm6.293.793A.75.75 0 1 0 14 8.206l-.5 8.5a.75.75 0 0 0 1.498.088l.5-8.5Z"></path></svg>');
 }
 
 /*
@@ -257,4 +260,20 @@
     
     -webkit-mask-image: var(--badge-icon--quote);
             mask-image: var(--badge-icon--quote);
+}
+
+/* Deprecated */
+.mdx-admo--deprecated {
+    border-color: var(--md-badge-fg--deprecated);
+}
+
+.mdx-admo--deprecated .mdx-grid-child--icon {
+    background-color: var(--md-badge-bg--deprecated);
+}
+
+.mdx-admo--deprecated .mdx-grid-child--icon::before {
+    background-color: var(--md-badge-fg--deprecated);
+
+    -webkit-mask-image: var(--badge-icon--deprecated);
+    mask-image: var(--badge-icon--deprecated);
 }

docs/examples/index.md

@@ -6,7 +6,7 @@ icon: octicons/list-unordered-24
 
 ## About
 
-<!-- admo:info The below examples may only work in v1.10.0 or newer! -->
+<!-- admo:info The below examples may only work in v3.7.0 or newer! -->
 
 This page lists some examples you may want to use for your proxy or server.
 
@@ -38,8 +38,7 @@ This example here shows a separate MOTD and player count message for when the pl
 priority: 1
 
 # Display this profile, if the version of the player is below 760 (1.19.1)
-conditions:
-  - '${player protocol} < 760'
+condition: '${player protocol} < 760'
 
 motd:
   - '<red>You are using an outdated client!'
@@ -57,8 +56,7 @@ This profile would display a MOTD without HEX colours if the player's version is
 priority: 1
 
 # Display this profile, if the version of the player is below 735 (1.16)
-conditions:
-  - '${player protocol} < 735'
+condition: '${player protocol} < 735'
 
 motd:
   - '<grey>Welcome to <aqua>YourServer.com</aqua>!'
@@ -79,8 +77,7 @@ Displays a separate profile for when the player has been banned from the server.
 ```yaml title="banned.yml"
 priority: 1
 
-conditions:
-  - '${player isBanned} = true'
+condition: '${player isBanned}'
 
 motd:
   - '<red>You have been <bold>BANNED</bold>!'
@@ -103,8 +100,7 @@ Display a different profile when the playing pings a specific domain/IP.
 ```yaml title="specific-host.yml"
 priority: 1
 
-conditions:
-  - '${server host} = other.example.com'
+condition: '${server host} = "host.example.com"'
 
 motd:
   - '<grey>Please use <aqua>mc.example.com'
@@ -118,12 +114,11 @@ Display a different profile, if the player pinging the server is "known" by Adva
 ```yaml title="personalized.yml"
 priority: 1
 
-conditions:
-  - `${player name} != Anonymous` # "Anonymous" should be replaced with whatever you use in 'unknown_player'
+condition: '${player name} != Anonymous' # "Anonymous" would be the value from the "unknownPlayer > name" option.
 
 motd:
   - '<grey>Hello there <aqua>${player name}</aqua>!'
-  - '<grey>It's nice to see you again.'
+  - '<grey>It''s nice to see you again.'
 
 playerCount:
   hover:

docs/profiles/index.md

@@ -27,7 +27,37 @@ The priority option determines the order in which the profiles are checked by Ad
 It will go through each file until it finds one with [`conditions`](#conditions) returning true (Default if no conditions are set).  
 This means that a profile with no conditions and a priority of `1` will be used before a profile with a condition and priority `0` even if the player is meeting the condition.
 
-## Conditions
+## Condition
+
+A string containing one or multiple conditions chained together using the keywords `and` or `or` (Or alternatively `&&` or `||`).  
+The system used is similar to the one used in BungeeTabListPlus.
+
+### Operands { #condition-operands }
+
+The following operands can be used for expressions in the condition option.
+
+| Operand      | Description                                                                                                      |
+|--------------|------------------------------------------------------------------------------------------------------------------|
+| `and` / `&&` | Returns true if the expression on the left and right side return true.                                           |
+| `or` / `||`  | Returns true if an expression from either side returns true.                                                     |
+| `()`         | Expressions in-between those are prioritized in evaluation, starting with the most inner first.                  |
+| `<`          | Returns true if the left side is less than the right. In case of text will the text length be used.              |
+| `<=`         | Returns true if the left side is less or equal to the right. In case of text will the text length be used.       |
+| `>`          | Returns true if the left side is larger than the right. In case of text will the text length be used.            |
+| `>=`         | Returns true if the left side is larger or equal to the right. In case of text will the text length be used.     |
+| `==` / `=`   | Returns true if both sides are equal to each other. This also checks capitalization.                             |
+| `!=`         | Returns true if both sides are NOT equal to each other. This also checks capitalization.                         |
+| `~=`         | Returns true if both sides are equal to each other while also ignoring capitalization.                           |
+| `!~`         | Returns true if both sides are NOT equal to each other while also ignoring capitalization.                       |
+| `.`          | Merges two strings into one.                                                                                     |
+| `+`          | Adds two numbers together. In case of text will its text length be used as number.                               |
+| `-`          | Subtracts the value from the right from the left number. In case of text will its text length be used as number. |
+| `*`          | Multiplies two numbers together. In case of text will its text length be used as number.                         |
+| `/`          | Divides the left number through the right number. In case of text will its text length be used as number.        |
+
+## Conditions :octicons-trash-24:{ title="Deprecated" style="color: #ff5252;" }
+
+<!-- admo:deprecated This option was deprecated in favour of the new condition option! -->
 
 A list of conditions can be set that need to be met in order to have this profile shown to the player.  
 [Placeholders](formatting.md#placeholders) can be used to further customize the conditions (PlaceholderAPI placeholders are **not** supported).
@@ -36,22 +66,22 @@ Only when **all** conditions defined return true will the profile be displayed.
 
 You can remove this option, or set it to an empty list (`conditions: []`) to always return true.
 
-### Operands
+### Operands { #conditions-operands }
 
 The following operants are available and can be used in the conditions.
 
-<!-- admo:warning Only one operant can be used per condition! -->
+<!-- admo:warning For conditions option can you only use one operand per condition. -->
 
-| Operand | Description                                                            |
-|---------|------------------------------------------------------------------------|
-| `<`     | Checks if the left value is less than the right one.[^1]               |
-| `<=`    | Checks if the left value is less than or equal to the right one.[^1]   |
-| `>`     | Checks if the left value is more than the right one.[^1]               |
-| `>=`    | Checks if the left value is more than or equal to the right one.[^1]   |
-| `=`     | Checks if the left value is equal to the right one.                    |
-| `!=`    | Checks if the left value is not equal to the right one.                |
-| `~=`    | Checks if the left value is equal to the right one, ignoring case.     |
-| `!~`    | Checks if the left value is not equal to the right one, ignoring case. |
+| Operand       | Description                                                             |
+|---------------|-------------------------------------------------------------------------|
+| `<`           | Checks if the left value is less than the right one.[^1]                |
+| `<=`          | Checks if the left value is less than or equal to the right one.[^1]    |
+| `>`           | Checks if the left value is more than the right one.[^1]                |
+| `>=`          | Checks if the left value is more than or equal to the right one.[^1]    |
+| `=`           | Checks if the left value is equal to the right one.                     |
+| `!=`          | Checks if the left value is not equal to the right one.                 |
+| `~=`          | Checks if the left value is equal to the right one, ignoring case.      |
+| `!~`          | Checks if the left value is not equal to the right one, ignoring case.  |
 
 [^1]:
     Should the provided value not be a number, will AdvancedServerList use the text length to compare.  

mkdocs.yml

@@ -29,6 +29,7 @@ theme:
   - navigation.tabs
   - navigation.tabs.sticky
   - content.code.copy
+  - content.tooltips
 
   icon:
     repo: 'simple/codeberg'

pom.xml

@@ -38,7 +38,7 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.build.commit/>
         
-        <plugin.version>3.6.1</plugin.version>
+        <plugin.version>3.7.0</plugin.version>
         <plugin.description>Create multiple Server lists based on conditions.</plugin.description>
         
         <api.version>v3.1.0</api.version>

velocity/pom.xml

@@ -79,7 +79,7 @@
             <groupId>org.spongepowered</groupId>
             <artifactId>configurate-yaml</artifactId>
             <version>4.1.2</version>
-            <scope>compile</scope>
+            <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>com.squareup.okhttp3</groupId>