com.aionemu.gameserver.restrictions.RestrictionsManager.java Source code

Java tutorial

Introduction

Here is the source code for com.aionemu.gameserver.restrictions.RestrictionsManager.java

Source

/**
 * This file is part of Aion-Lightning <aion-lightning.org>.
 *
 *  Aion-Lightning is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Aion-Lightning is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details. *
 *  You should have received a copy of the GNU General Public License
 *  along with Aion-Lightning.
 *  If not, see <http://www.gnu.org/licenses/>.
 */
package com.aionemu.gameserver.restrictions;

import com.aionemu.gameserver.model.gameobjects.Item;
import com.aionemu.gameserver.model.gameobjects.VisibleObject;
import com.aionemu.gameserver.model.gameobjects.player.Player;
import com.aionemu.gameserver.skillengine.model.Skill;
import org.apache.commons.lang.ArrayUtils;

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Comparator;

/**
 * @author lord_rex This class is a Manager for restrictions. This is a very
 *         useful system, you can use that for: game restrictions, events restrictions,
 *         quests restrictions, instances restrictions, customs restrictions.
 * @Example: Open a new class like this: public class AppleRestrictions extends
 * AbstractRestrictions {
 * @Override public boolean canEatApple(Player player) {
 * if(player.getController().isInEvent()) { // only example, don't forget!
 * return true; // player can eat apple in event. } return false; // player
 * cannot eat apple in normal game. } }
 */
public final class RestrictionsManager {

    private RestrictionsManager() {
    }

    private static enum RestrictionMode implements Comparator<Restrictions> {

        isRestricted, canAttack, canAffectBySkill, canUseSkill, canChat, canInviteToGroup, canInviteToAlliance, canChangeEquip, canTrade, canUseWarehouse, canUseItem, // TODO
        ;
        private final Method METHOD;

        private RestrictionMode() {
            for (Method method : Restrictions.class.getMethods()) {
                if (name().equals(method.getName())) {
                    METHOD = method;
                    return;
                }
            }

            throw new InternalError();
        }

        private boolean equalsMethod(Method method) {
            if (!METHOD.getName().equals(method.getName())) {
                return false;
            }

            if (!METHOD.getReturnType().equals(method.getReturnType())) {
                return false;
            }

            return Arrays.equals(METHOD.getParameterTypes(), method.getParameterTypes());
        }

        private static final RestrictionMode[] VALUES = RestrictionMode.values();

        private static RestrictionMode parse(Method method) {
            for (RestrictionMode mode : VALUES) {
                if (mode.equalsMethod(method)) {
                    return mode;
                }
            }

            return null;
        }

        @Override
        public int compare(Restrictions o1, Restrictions o2) {
            return Double.compare(getPriority(o2), getPriority(o1));
        }

        private double getPriority(Restrictions restriction) {
            RestrictionPriority a1 = getMatchingMethod(restriction.getClass())
                    .getAnnotation(RestrictionPriority.class);
            if (a1 != null) {
                return a1.value();
            }

            RestrictionPriority a2 = restriction.getClass().getAnnotation(RestrictionPriority.class);
            if (a2 != null) {
                return a2.value();
            }

            return RestrictionPriority.DEFAULT_PRIORITY;
        }

        private Method getMatchingMethod(Class<? extends Restrictions> clazz) {
            for (Method method : clazz.getMethods()) {
                if (equalsMethod(method)) {
                    return method;
                }
            }

            throw new InternalError();
        }
    }

    private static final Restrictions[][] RESTRICTIONS = new Restrictions[RestrictionMode.VALUES.length][0];

    public synchronized static void activate(Restrictions restriction) {
        for (Method method : restriction.getClass().getMethods()) {
            RestrictionMode mode = RestrictionMode.parse(method);

            if (mode == null) {
                continue;
            }

            if (method.getAnnotation(DisabledRestriction.class) != null) {
                continue;
            }

            Restrictions[] restrictions = RESTRICTIONS[mode.ordinal()];

            if (!ArrayUtils.contains(restrictions, restriction)) {
                restrictions = (Restrictions[]) ArrayUtils.add(restrictions, restriction);
            }

            Arrays.sort(restrictions, mode);

            RESTRICTIONS[mode.ordinal()] = restrictions;
        }
    }

    public synchronized static void deactivate(Restrictions restriction) {
        for (RestrictionMode mode : RestrictionMode.VALUES) {
            Restrictions[] restrictions = RESTRICTIONS[mode.ordinal()];

            for (int index; (index = ArrayUtils.indexOf(restrictions, restriction)) != -1;) {
                restrictions = (Restrictions[]) ArrayUtils.remove(restrictions, index);
            }

            RESTRICTIONS[mode.ordinal()] = restrictions;
        }
    }

    static {
        // This is the Restrictions when player is in normal game.
        activate(new PlayerRestrictions());
        // This is the Restrictions when player is in shutdown.
        activate(new ShutdownRestrictions());
        // This is the Restrictions when player is in prison.
        activate(new PrisonRestrictions());
    }

    /**
     * This function can be used for activate one restriction. Example: public
     * static boolean startAppleEatingEvent(Player player) {
     * if(RestrictionsManager.isRestricted(player,
     * AppleEatingEventRestriction.class)) return false; return true; }
     */
    public static boolean isRestricted(Player player, Class<? extends Restrictions> callingRestriction) {
        if (player == null) {
            return true;
        }

        for (Restrictions restrictions : RESTRICTIONS[RestrictionMode.isRestricted.ordinal()]) {
            if (!restrictions.isRestricted(player, callingRestriction)) {
                return false;
            }
        }

        return false;
    }

    /**
     * This function created for enable/disable attack.
     *
     * @param player
     * @param target
     */
    public static boolean canAttack(Player player, VisibleObject target) {
        for (Restrictions restrictions : RESTRICTIONS[RestrictionMode.canAttack.ordinal()]) {
            if (!restrictions.canAttack(player, target)) {
                return false;
            }
        }

        return true;
    }

    /**
     * This function is created for enable/disable on specific target.
     *
     * @param player
     * @param target
     */
    public static boolean canAffectBySkill(Player player, VisibleObject target, Skill skill) {
        for (Restrictions restrictions : RESTRICTIONS[RestrictionMode.canAffectBySkill.ordinal()]) {
            if (!restrictions.canAffectBySkill(player, target, skill)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Check whether player can use such skill
     *
     * @param player
     * @param skill
     * @return
     */
    public static boolean canUseSkill(Player player, Skill skill) {
        for (Restrictions restrictions : RESTRICTIONS[RestrictionMode.canUseSkill.ordinal()]) {
            if (!restrictions.canUseSkill(player, skill)) {
                return false;
            }
        }

        return true;
    }

    /**
     * This function is created for enable/disable chat.
     *
     * @param player
     */
    public static boolean canChat(Player player) {
        for (Restrictions restrictions : RESTRICTIONS[RestrictionMode.canChat.ordinal()]) {
            if (!restrictions.canChat(player)) {
                return false;
            }
        }

        return true;
    }

    /**
     * This function is created for enable/disable invite to group.
     *
     * @param player
     * @param target
     */
    public static boolean canInviteToGroup(Player player, Player target) {
        for (Restrictions restrictions : RESTRICTIONS[RestrictionMode.canInviteToGroup.ordinal()]) {
            if (!restrictions.canInviteToGroup(player, target)) {
                return false;
            }
        }

        return true;
    }

    /**
     * This function is created for enable/disable invite to alliance.
     *
     * @param player
     * @param target
     */
    public static boolean canInviteToAlliance(Player player, Player target) {
        for (Restrictions restrictions : RESTRICTIONS[RestrictionMode.canInviteToAlliance.ordinal()]) {
            if (!restrictions.canInviteToAlliance(player, target)) {
                return false;
            }
        }

        return true;
    }

    /**
     * This function is created for enable/disable equip change.
     *
     * @param player
     */
    public static boolean canChangeEquip(Player player) {
        for (Restrictions restrictions : RESTRICTIONS[RestrictionMode.canChangeEquip.ordinal()]) {
            if (!restrictions.canChangeEquip(player)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Check whether player can perform trade
     *
     * @param player
     * @return true or false
     */
    public static boolean canTrade(Player player) {
        for (Restrictions restrictions : RESTRICTIONS[RestrictionMode.canTrade.ordinal()]) {
            if (!restrictions.canTrade(player)) {
                return false;
            }
        }

        if (player.getLifeStats().isAlreadyDead()) {
            return false;
        }

        return true;
    }

    /**
     * Check whether player can use warehouse
     *
     * @param player
     * @return true or false
     */
    public static boolean canUseWarehouse(Player player) {
        for (Restrictions restrictions : RESTRICTIONS[RestrictionMode.canUseWarehouse.ordinal()]) {
            if (!restrictions.canUseWarehouse(player)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Check whether player can use an item
     *
     * @param player
     * @return
     */
    public static boolean canUseItem(Player player, Item item) {
        for (Restrictions restrictions : RESTRICTIONS[RestrictionMode.canUseItem.ordinal()]) {
            if (!restrictions.canUseItem(player, item)) {
                return false;
            }
        }
        return true;
    }
}