随笔 - 1  文章 - 37  trackbacks - 0
<2024年11月>
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

留言簿(16)

随笔分类

随笔档案

文章分类

文章档案

test

搜索

  •  

最新评论

人物角色有多种动作:上马,下马,走,跑,物理攻击,魔法攻击,施放魔法,交易 .....等等
每个动作间隔为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 阅读(474) 评论(0)  编辑  收藏 所属分类: Mir3gAnyWhere

只有注册用户登录后才能发表评论。


网站导航: