随笔 - 1  文章 - 37  trackbacks - 0
<2024年11月>
日一二三四五六
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

留言簿(16)

随笔分类

随笔档案

文章分类

文章档案

test

搜索

  •  

最新评论

[原]角色AI动作调度器

人物角色有多种动作：上马，下马，走，跑，物理攻击，魔法攻击，施放魔法，交易 .....等等
每个动作间隔为600毫秒，任务有可能会执行失败。

/**
 * 角色动作调度器
 * @author Donf Yang
 */
public final class ActionDispatcher {

    /**
     * 上一次动作的执行时间
     */
    private static long previousActionTime = 0;

    /**
     * 每次动作执行时间间隔
     */
    public static final int ACTION_INTERVAL = 600;

    /**
     * 上一个ActionMission，不受调度器控制，当currentActionMission不可执行时，调度该Mission [未实现]
     */
    private static ActionMission previousActionMission = null;
    /**
     * 下一个ActionMission，不受调度器控制，当continueDispatch时，优先调度
     */
    private static ActionMission nextActionMission = null;

    private static ActionMission currentActionMission = null;

    private static final String ISDISPATCHLOCKME = "IL";
    private static final String ACTIONLOCKME = "AL";

    private static Logger log = LoggerFactory.getLogger(ActionDispatcher.class);

    private static boolean isActionExecuting = false;

    /**
     * dispatch之前，先判断是否可以被调度isDispatchable(); 如果不能被调度，调用setNextActionMission();
     * 
     * @param action
     * @throws Exception
     */
    public static void dispatch(ActionMission action) throws Exception {

        if (!isDispatchable()) {
            return;
        }
        try {
            setDispatching(true);
            currentActionMission = action;
            /*
             * 如果Action时间为0，说明该动作没有执行
             */
            long _l = action.doMission();
            if (_l == 0) {
                setDispatching(false);
            } 
        } catch (Exception e) {
            setDispatching(false);
            throw e;
        }
    }

    /**
     * GameProcess接受到服务器返回的动作执行成功指令
     */
    public static void actionGood() {
        currentActionMission.returnActionGood();
        try {
            continueDispatch();
        } catch (Exception e) {
            setDispatching(false);
            e.printStackTrace();
        }

    }

    /**
     * GameProcess接受到服务器返回的动作执行失败指令
     */
    public static void actionFail() {
        currentActionMission.returnActionFail();
        try {
            continueDispatch();
        } catch (Exception e) {
            setDispatching(false);
            e.printStackTrace();
        }
    }

    private static void continueDispatch() throws Exception {
        synchronized (ACTIONLOCKME) {
            if (nextActionMission != null) {
                currentActionMission = nextActionMission;
                nextActionMission = null;
            }
        }
        try {
            if (currentActionMission.isContinueExecutable()) {
                setDispatching(true);
                /*
                 * 如果Action时间为0，说明该动作没有执行
                 */
                long _l = currentActionMission.continueDoMission();
                if (_l == 0) {
                    setDispatching(false);
                }
            } else {
                setDispatching(false);
            }
        } catch (Exception e) {
            setDispatching(false);
            throw e;
        }

    }

    /**
     * 设置当前是否有Mission正在被执行的状态
     * @param dispatching
     */
    private static void setDispatching(boolean dispatching) {
        synchronized (ISDISPATCHLOCKME) {
            isActionExecuting = dispatching;
        }
    }

    /**
     * Mission是否可以被马上执行，由当前是否有Mission正在被执行决定
     * @return
     */
    public static boolean isDispatchable() {
        synchronized (ISDISPATCHLOCKME) {
            return !isActionExecuting;
        }
    }

    public static void setNextActionMission(ActionMission actionMission) {
        synchronized (ACTIONLOCKME) {
            nextActionMission = actionMission;
        }
    }

    public static void setPreviousActionMission(ActionMission actionMission) {
        synchronized (ACTIONLOCKME) {
            previousActionMission = actionMission;
        }
    }
    
    /**
     * 设置调度时间，600毫秒
     * @return
     */
    public static long dispatchActionTime(){
        long _l = ActionDispatcher.generateCurrentActionTime();
        if (_l - previousActionTime < ActionDispatcher.ACTION_INTERVAL) {
            try {
                Thread.sleep((ActionDispatcher.ACTION_INTERVAL - (_l - previousActionTime)));
            } catch (Exception e) {
                e.printStackTrace();
            }
            previousActionTime = ActionDispatcher.generateCurrentActionTime();
        } else {
            previousActionTime = _l;
        }
        return previousActionTime;
    }

    /**
     * 为Action生成当前时间
     * @return
     */
    public static long generateCurrentActionTime() {
        Calendar now = Calendar.getInstance();
        return now.get(Calendar.HOUR_OF_DAY) * 3600000 + now.get(Calendar.MINUTE) * 60000
                + now.get(Calendar.SECOND) * 1000 + now.get(Calendar.MILLISECOND);
    }

}


 

/**
 * ActionMission，可调度的动作任务，该任务可以是一个简单的移动，也可以包含N层任务的AI流程
 * @author Donf Yang
 */
public interface ActionMission {

    /**
     * 首次执行Mission
     * @return 返回Action执行时的当前时间，如果为0，说明没有被执行
     * @throws Exception
     */
    public long doMission() throws Exception;

    /**
     * 继续执行Mission
     * @return 返回Action执行时的当前时间，如果为0，说明没有被执行
     * @throws Exception
     */
    public long continueDoMission() throws Exception;
    
    /**
     * 服务器返回动作执行成功，该方法不能有过多的动作逻辑
     */
    public void returnActionGood();
    
    /**
     * 服务器返回动作执行失败，该方法不能有过多的动作逻辑
     */
    public void returnActionFail();

    /**
     * 是否需要（可以）继续执行
     * @return
     */
    public boolean isContinueExecutable();

}


动作的回调接口

/**
 * 
 * ControllableAction回调接口 <br />
 * 1. 停止当前动作<br />
 * 2. 当动作完成时，得到通知
 * 
 * @author Donf Yang
 * @2008-7-8 下午09:31:44
 */
public interface ActionObserver {

    public void onControllableActionFinished(ControllableAction action);
    
}

/**
 * 
 * 所有可控制的动作接口需要继承该接口，用于回调 <br />
 * 
 * @author Donf Yang
 * @2008-7-8 下午09:32:31
 */
public interface ControllableAction {
    
    public void stopAction();

}
posted on 2008-07-06 18:05 Phrancol Yang 阅读(473) 评论(0)  编辑  收藏 所属分类: Mir3gAnyWhere

只有注册用户登录后才能发表评论。
网站导航:
 
Copyright ©2024 Phrancol Yang Powered by: 博客园 模板提供：沪江博客