Phrancol's blog
To be surprised,to wonder,is to begin to understand.
BlogJava
首页
联系
聚合
管理
随笔 - 1 文章 - 37 trackbacks - 0
<
2024年11月
>
日
一
二
三
四
五
六
27
28
29
30
31
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
1
2
3
4
5
6
7
留言簿
(16)
给我留言
查看公开留言
查看私人留言
随笔分类
反汇编(1)
随笔档案
2008年5月 (1)
文章分类
Eclipse(2)
iOS(1)
Mir3gAnyWhere(1)
OSGI(16)
反汇编(5)
文章档案
2011年11月 (1)
2009年11月 (2)
2009年8月 (1)
2009年7月 (2)
2009年5月 (2)
2009年4月 (3)
2009年3月 (1)
2008年11月 (1)
2008年10月 (1)
2008年7月 (1)
2008年6月 (6)
2008年5月 (1)
2008年4月 (5)
2007年11月 (1)
2007年10月 (1)
2007年9月 (4)
2007年8月 (2)
test
搜索
最新评论
1. re: 精武馆——在线棋牌游戏平台[未登录]
好
--五味子
2. re: 精武馆——在线棋牌游戏平台[未登录]
很好玩
--五味子
3. re: [原]一个例子理解AccessController.doPrivileged()
谢谢分享,我第一遍没看懂,后来去其他地方看了有关权限检查的的文章以后才看懂,建议解释一下调用栈,和权限检查(取调用栈中权限的交集)。
--Flexin
4. re: [原]MIR3G二次加解密反汇编分析(四)——还原
@Mir3
好久没有研究这个...
--phrancol
5. re: [原]MIR3G二次加解密反汇编分析(四)——还原
ll4bb903 这其实是srand 函数
--Mir3
[原]角色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
阅读(474)
评论(0)
编辑
收藏
所属分类:
Mir3gAnyWhere
新用户注册
刷新评论列表
只有注册用户
登录
后才能发表评论。
网站导航:
博客园
IT新闻
知识库
C++博客
博问
管理