KasterborousConfigurable

Représente une donnée configurable de la partie. Les configurables sont représenté dans l'onglet Configurables.

Onglet en jeu

KasterborousConfigurable

public interface KasterBorousConfigurable {
    Binding getBind();

    Bound getBound();

    AddingRule getRule();

    ConfigurableType getType();

    int getBaseData();

    String getDescription();

    String getName();

    Material getMat();
}

Accès

ConfigurableProvider configurableProvider = api.getConfigurableProvider();

Ressources nécessaires

Type de configurable

public enum ConfigurableType {
	Bool,
	Timer,
	Percentage,
	Integer	
}

• Integer: Le Configurable est un entier.

• Bool: Le Configurable représente un booléen. Vrai/Faux

• Percentage: Le Configurable est un pourcentage.

• Timer: Le Configurable représente un temps, ou un intervalle de temps.

Pour les type Bool il est important que le Bound soit comme précisé ici.

Binding

Un Binding est un moyen d'expliquer a quoi le Configurable est rattaché. C'est a dire dans quel onglet il apparaitra. Il peut apparaitre soit dans un onglet générique, comme l'onglet objets, joueurs ou blocs, mais il peut aussi apparaitre dans un onglet spécifique à un mode de jeu, car il ne concerne que ce mode de jeu.

Il existe donc deux type de Binding. Ceux qui sont dit TYPE et ceux dit MODE.

Les TYPE renseigne un attachement a un onglet.

Les MODE renseigne un attachement a un mode de jeu.

TypeBinding

Pour créer un TypeBinding, il faut renseigner la catégorie dans laquelle le Configurable apparaitra. Voici les onglets disponible:

Cette liste n'est peut être pas mise à jour. Il existe peut être d'autres catégories.

• World

• Chat

• Player

• Block

• Object

• Effect

Ils se trouvent tous dans l'énumération BindingType

Exemple

Créons ici un TypeBinding dans l'onglet World

TypeBinding worldbind = new TypeBinding(BindingType.World);

ModeBinding

Avancée

Autres

BoundAddingRule

Créer un nouveau configurable

Création avec une énumération:

public enum TestConfig implements KasterBorousConfigurable{
    TEST_CONFIG(
            new TypeBinding(BindingType.Object),
            new Bound(0,100),
            new AddingRule(1,10),
            ConfigurableType.Timer,
            10,
            "description",
            "nom",
            Material.PAPER)
    ;
    private final Binding binding;
    private final Bound bound;
    private final AddingRule rule;
    private final ConfigurableType type;
    private final int data;
    private final String description;
    private final String name;
    private final Material material;
    TestConfig(Binding binding,Bound bound,AddingRule rule,ConfigurableType type,int basedata,String description,String name,Material material){
        this.binding=binding;
        this.bound=bound;
        this.rule=rule;
        this.type=type;
        this.data=basedata;
        this.description=description;
        this.name=name;
        this.material=material;
    }
    @Override
    public Binding getBind() {
        return binding;
    }

    @Override
    public Bound getBound() {
        return bound;
    }

    @Override
    public AddingRule getRule() {
        return rule;
    }

    @Override
    public ConfigurableType getType() {
        return type;
    }

    @Override
    public int getBaseData() {
        return data;
    }

    @Override
    public String getDescription() {
        return description;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Material getMat() {
        return material;
    }
}

Ici le Configurable TEST_CONFIG:

• a un lien TYPE, il est donc lier a une catégorie. Le liens peut être soit TYPE ou MODE, c'est à dire qu'il peut être lié a une catégorie ou a un mode de jeu.

• est minoré par 0 et majoré par 100. C'est a dire qu'il ne peut pas aller en dessous de 0 et au dessus de 100.

• est modifiable par tranche de 1, et rapidement par tranche de 10.

• a pour valeur par défaut 10

• a pour nom: "nom"

• a pour description: "description"

• a pour représentation un papier.