Java SpellResult.NO_ACTION属性代码示例

@Override
   public SpellResult step(CastContext context)
{
       while (currentEntity < entities.size())
       {
           Entity entity = entities.get(currentEntity).get();
           if (entity == null)
           {
               currentEntity++;
               skippedActions(context);
               continue;
           }
           actionContext.setTargetEntity(entity);
           if (entity instanceof LivingEntity) {
               actionContext.setTargetLocation(((LivingEntity)entity).getEyeLocation());
           } else {
               actionContext.setTargetLocation(entity.getLocation());
           }
           return startActions();
       }

       return SpellResult.NO_ACTION;
   }
 

protected SpellResult startActions(String handlerKey) {
    currentHandler = handlerKey;
    ActionHandler handler = handlers.get(currentHandler);
    if (handler != null) {
        handler.reset(actionContext);
    } else {
        currentHandler = null;
    }

    return SpellResult.NO_ACTION;
}
 

@Override
public SpellResult perform(CastContext context) {
    SpellResult result = SpellResult.NO_ACTION;
    while (!result.isStop()) {
        if (state == State.NOT_STARTED) {
            result = result.min(start(context));

            // Don't continue if the action failed to start
            if (result.isStop() || result.isFailure()) break;
            state = State.STARTED;
        }

        if (state == State.STARTED) {
            result = result.min(step(context));
            if (result.isStop()) break;
            state = State.STEPPING;
        }

        ActionHandler handler = currentHandler == null ? null : handlers.get(currentHandler);
        if (handler != null) {
            result = result.min(handler.perform(actionContext));
            if (result.isStop()) break;
            if (stopOnSuccess && result.isSuccess()) {
                result = SpellResult.STOP;
                break;
            }
        }

        if (!next(context)) {
            if (handler != null) {
                handler.finish(actionContext);
            }
            break;
        }

        result = result.min(step(context));
    }
    return result;
}
 

public CastContext() {
    this.location = null;
    this.entity = null;
    this.base = this;
    this.result = SpellResult.NO_ACTION;
    targetMessagesSent = new HashSet<UUID>();
    currentEffects = new ArrayList<EffectPlay>();
}
 

@Override
public SpellResult processHandlers() {
    SpellResult result = SpellResult.NO_ACTION;
    if (handlers == null) return result;

    if (finishedHandlers == null) {
        finishedHandlers = new ArrayList<ActionHandlerContext>();
    }
    int startingWork = getWorkAllowed();
    int splitWork = Math.max(1, startingWork / handlers.size());
    for (Iterator<ActionHandlerContext> iterator = handlers.iterator(); iterator.hasNext();) {
        ActionHandlerContext handler = iterator.next();
        handler.setWorkAllowed(splitWork);
        SpellResult actionResult = handler.perform();
        if (actionResult != SpellResult.PENDING) {
            result = result.min(actionResult);
            finishedHandlers.add(handler);
            iterator.remove();
        }
    }
    
    if (handlers.isEmpty()) {
        handlers = null;
        return result;
    }

    return SpellResult.PENDING;
}
 

public SpellResult perform(CastContext context)
{
    boolean hasTarget = context.getTargetLocation() != null;
    boolean hasEntityTarget = context.getTargetEntity() != null;
    if (action.requiresTarget() && !hasTarget) return SpellResult.NO_TARGET;
    if (action.requiresTargetEntity() && !hasEntityTarget) return SpellResult.NO_TARGET;

    SpellResult result = action.perform(context);
    return action.ignoreResult() && !result.isStop() ? SpellResult.NO_ACTION : result;
}
 

protected boolean finalizeCast(ConfigurationSection parameters) {
    SpellResult result = null;

    // Global parameters
    controller.disablePhysics(parameters.getInt("disable_physics", 0));

    if (!mage.isSuperPowered()) {
        if (backfireChance > 0 && random.nextDouble() < backfireChance) {
            backfire();
        } else if (fizzleChance > 0 && random.nextDouble() < fizzleChance) {
            result = SpellResult.FIZZLE;
        }
    }

    if (result == null) {
        result = onCast(parameters);
    }
    if (backfired) {
        result = SpellResult.BACKFIRE;
    }
    if (result == SpellResult.CAST) {
        LivingEntity sourceEntity = mage.getLivingEntity();
        Entity targetEntity = getTargetEntity();
        if (sourceEntity == targetEntity) {
            result = SpellResult.CAST_SELF;
        }
    }
    processResult(result, parameters);

    boolean success = result.isSuccess();
    boolean requiresCost = success || (castOnNoTarget && (result == SpellResult.NO_TARGET || result == SpellResult.NO_ACTION));
    boolean free = !requiresCost && result.isFree();
    if (!free) {
        if (costs != null && !mage.isCostFree()) {
            for (CastingCost cost : costs)
            {
                if (cost.isItem() && currentCast != null) {
                    currentCast.getUndoList().setConsumed(true);
                }
                cost.use(this);
            }
        }
        updateCooldown();
    }

    sendCastMessage(result, " (" + success + ")");
    return success;
}
 

public SpellResult step(CastContext context) {
    return SpellResult.NO_ACTION;
}
 

public SpellResult start(CastContext context) {
    return SpellResult.NO_ACTION;
}