doom3 aas部分

随随便便123

已于 2024-05-12 11:55:14 修改

阅读量1.5k

点赞数

分类专栏： doom3 文章标签：人工智能大数据

于 2014-07-09 23:50:51 首次发布

本文链接：https://blog.csdn.net/tailiangliang/article/details/16341713

版权

doom3 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

botlib运行时刻

机器人里有限状态机的处理，在进行这个徘徊，移动，飞行等等的一个选择了

对于这个武器的ai，没子弹了装弹，彻底没子弹了换枪，

最后没有子弹了换电锯来处理

、

怪物的各种动画状态和这个ai相对应

机器人目标终结对手

控制机器人的命令者也

----------------------------------

机器人的各项状态，在游戏的时候

----------------------------------

/*
-----------------------------------------

ai的bot 加载这个角色的处理等等者也

------------------------------------------

加载脚本部分了

---------------------------------------

ai的目标的处理等等

----------------------------------------

BOTLIB_AI_RESET_GOAL_STATE, 重启目标状态

BOTLIB_AI_RESET_AVOID_GOALS, 重启避免目标了

BOTLIB_AI_PUSH_GOAL, 压入目标

BOTLIB_AI_POP_GOAL, 弹出目标

BOTLIB_AI_EMPTY_GOAL_STACK,

BOTLIB_AI_DUMP_AVOID_GOALS,

BOTLIB_AI_DUMP_GOAL_STACK,

BOTLIB_AI_GOAL_NAME, 目标的名字了者也

BOTLIB_AI_GET_TOP_GOAL, 得到了首要的目标了者也

BOTLIB_AI_GET_SECOND_GOAL,

BOTLIB_AI_CHOOSE_LTG_ITEM,

BOTLIB_AI_CHOOSE_NBG_ITEM,

BOTLIB_AI_TOUCHING_GOAL,

BOTLIB_AI_ITEM_GOAL_IN_VIS_BUT_NOT_VISIBLE,

BOTLIB_AI_GET_LEVEL_ITEM_GOAL,

BOTLIB_AI_AVOID_GOAL_TIME,

BOTLIB_AI_INIT_LEVEL_ITEMS,

BOTLIB_AI_UPDATE_ENTITY_ITEMS, 更新关卡的item图标了

BOTLIB_AI_LOAD_ITEM_WEIGHTS, 加载图标的权重了

BOTLIB_AI_FREE_ITEM_WEIGHTS,

BOTLIB_AI_SAVE_GOAL_FUZZY_LOGIC,

BOTLIB_AI_ALLOC_GOAL_STATE,

BOTLIB_AI_FREE_GOAL_STATE,

-----------------------------------

ai的移动的状态的处理等等

---------------------------------

BOTLIB_AI_RESET_MOVE_STATE,重启ai的移动状态了者也

BOTLIB_AI_MOVE_TO_GOAL,

BOTLIB_AI_MOVE_IN_DIRECTION,

BOTLIB_AI_RESET_AVOID_REACH,

BOTLIB_AI_RESET_LAST_AVOID_REACH,

BOTLIB_AI_REACHABILITY_AREA,

BOTLIB_AI_MOVEMENT_VIEW_TARGET,

BOTLIB_AI_ALLOC_MOVE_STATE,

BOTLIB_AI_FREE_MOVE_STATE,

BOTLIB_AI_INIT_MOVE_STATE,

----------------

weapon ai 武器的ai处理

----------------

BOTLIB_AI_CHOOSE_BEST_FIGHT_WEAPON,

BOTLIB_AI_GET_WEAPON_INFO,

BOTLIB_AI_LOAD_WEAPON_WEIGHTS,

BOTLIB_AI_ALLOC_WEAPON_STATE,

BOTLIB_AI_FREE_WEAPON_STATE,

BOTLIB_AI_RESET_WEAPON_STATE,

-----------------------------

ai的chat的这个处理等等

------------------------------

BOTLIB_AI_GENETIC_PARENTS_AND_CHILD_SELECTION,

BOTLIB_AI_INTERBREED_GOAL_FUZZY_LOGIC,

BOTLIB_AI_MUTATE_GOAL_FUZZY_LOGIC,

BOTLIB_AI_GET_NEXT_CAMP_SPOT_GOAL,

BOTLIB_AI_GET_MAP_LOCATION_GOAL,

BOTLIB_AI_NUM_INITIAL_CHATS,

BOTLIB_AI_GET_CHAT_MESSAGE,

BOTLIB_AI_REMOVE_FROM_AVOID_GOALS,

BOTLIB_AI_PREDICT_VISIBLE_POSITION,

---------------------------------------

bot机器人用来进行path寻径的函数处理者也

----------------------------------------

BOTLIB_AI_SET_AVOID_GOAL_TIME,

BOTLIB_AI_ADD_AVOID_SPOT,

BOTLIB_AAS_ALTERNATIVE_ROUTE_GOAL,

BOTLIB_AAS_PREDICT_ROUTE,

BOTLIB_AAS_POINT_REACHABILITY_AREA_INDEX,

bot脚本的加载与这个编译脚本的处理等等

BOTLIB_PC_LOAD_SOURCE,

BOTLIB_PC_FREE_SOURCE,

BOTLIB_PC_READ_TOKEN,

BOTLIB_PC_SOURCE_FILE_AND_LINE

}

void trap_EA_Say(int client, char *str);

void trap_EA_SayTeam(int client, char *str);

void trap_EA_Command(int client, char *command);

void trap_EA_Action(int client, int action);

void trap_EA_Gesture(int client);

void trap_EA_Talk(int client);

void trap_EA_Attack(int client);

void trap_EA_Use(int client);

void trap_EA_Respawn(int client);

void trap_EA_Crouch(int client);

void trap_EA_MoveUp(int client);

void trap_EA_MoveDown(int client);

void trap_EA_MoveForward(int client);

void trap_EA_MoveBack(int client);

void trap_EA_MoveLeft(int client);

void trap_EA_MoveRight(int client);

void trap_EA_SelectWeapon(int client, int weapon);

void trap_EA_Jump(int client);

void trap_EA_DelayedJump(int client);

void trap_EA_Move(int client, vec3_t dir, float speed);

void trap_EA_View(int client, vec3_t viewangles);

void trap_EA_EndRegular(int client, float thinktime);

void trap_EA_GetInput(int client, float thinktime, void /* struct bot_input_s */ *input);

void trap_EA_ResetInput(int client);

int trap_BotLoadCharacter(char *charfile, float skill);

void trap_BotFreeCharacter(int character);

float trap_Characteristic_Float(int character, int index);

float trap_Characteristic_BFloat(int character, int index, float min, float max);

int trap_Characteristic_Integer(int character, int index);

int trap_Characteristic_BInteger(int character, int index, int min, int max);

void trap_Characteristic_String(int character, int index, char *buf, int size);

int trap_BotAllocChatState(void);

void trap_BotFreeChatState(int handle);

void trap_BotQueueConsoleMessage(int chatstate, int type, char *message);

void trap_BotRemoveConsoleMessage(int chatstate, int handle);

int trap_BotNextConsoleMessage(int chatstate, void /* struct bot_consolemessage_s */ *cm);

int trap_BotNumConsoleMessages(int chatstate);

void trap_BotInitialChat(int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 );

int trap_BotNumInitialChats(int chatstate, char *type);

int trap_BotReplyChat(int chatstate, char *message, int mcontext, int vcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 );

int trap_BotChatLength(int chatstate);

void trap_BotEnterChat(int chatstate, int client, int sendto);

void trap_BotGetChatMessage(int chatstate, char *buf, int size);

int trap_StringContains(char *str1, char *str2, int casesensitive);

int trap_BotFindMatch(char *str, void /* struct bot_match_s */ *match, unsigned long int context);

void trap_BotMatchVariable(void /* struct bot_match_s */ *match, int variable, char *buf, int size);

void trap_UnifyWhiteSpaces(char *string);

void trap_BotReplaceSynonyms(char *string, unsigned long int context);

int trap_BotLoadChatFile(int chatstate, char *chatfile, char *chatname);

void trap_BotSetChatGender(int chatstate, int gender);

void trap_BotSetChatName(int chatstate, char *name, int client);

void trap_BotResetGoalState(int goalstate);

void trap_BotRemoveFromAvoidGoals(int goalstate, int number);

void trap_BotResetAvoidGoals(int goalstate);

void trap_BotPushGoal(int goalstate, void /* struct bot_goal_s */ *goal);

void trap_BotPopGoal(int goalstate);

void trap_BotEmptyGoalStack(int goalstate);

void trap_BotDumpAvoidGoals(int goalstate);

void trap_BotDumpGoalStack(int goalstate);

void trap_BotGoalName(int number, char *name, int size);

int trap_BotGetTopGoal(int goalstate, void /* struct bot_goal_s */ *goal);

int trap_BotGetSecondGoal(int goalstate, void /* struct bot_goal_s */ *goal);

int trap_BotChooseLTGItem(int goalstate, vec3_t origin, int *inventory, int travelflags);

int trap_BotChooseNBGItem(int goalstate, vec3_t origin, int *inventory, int travelflags, void /* struct bot_goal_s */ *ltg, float maxtime);

int trap_BotTouchingGoal(vec3_t origin, void /* struct bot_goal_s */ *goal);

int trap_BotItemGoalInVisButNotVisible(int viewer, vec3_t eye, vec3_t viewangles, void /* struct bot_goal_s */ *goal);

int trap_BotGetNextCampSpotGoal(int num, void /* struct bot_goal_s */ *goal);

int trap_BotGetMapLocationGoal(char *name, void /* struct bot_goal_s */ *goal);

int trap_BotGetLevelItemGoal(int index, char *classname, void /* struct bot_goal_s */ *goal);

float trap_BotAvoidGoalTime(int goalstate, int number);

void trap_BotSetAvoidGoalTime(int goalstate, int number, float avoidtime);

void trap_BotInitLevelItems(void);

void trap_BotUpdateEntityItems(void);

int trap_BotLoadItemWeights(int goalstate, char *filename);

void trap_BotFreeItemWeights(int goalstate);

void trap_BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child);

void trap_BotSaveGoalFuzzyLogic(int goalstate, char *filename);

void trap_BotMutateGoalFuzzyLogic(int goalstate, float range);

int trap_BotAllocGoalState(int state);

void trap_BotFreeGoalState(int handle);

void trap_BotResetMoveState(int movestate);

void trap_BotMoveToGoal(void /* struct bot_moveresult_s */ *result, int movestate, void /* struct bot_goal_s */ *goal, int travelflags);

int trap_BotMoveInDirection(int movestate, vec3_t dir, float speed, int type);

void trap_BotResetAvoidReach(int movestate);

void trap_BotResetLastAvoidReach(int movestate);

int trap_BotReachabilityArea(vec3_t origin, int testground);

int trap_BotMovementViewTarget(int movestate, void /* struct bot_goal_s */ *goal, int
travelflags, float lookahead, vec3_t target);

int trap_BotPredictVisiblePosition(vec3_t origin, int areanum, void /* struct bot_goal_s */ *goal, int travelflags, vec3_t target);

int trap_BotAllocMoveState(void);

void trap_BotFreeMoveState(int handle);

void trap_BotInitMoveState(int handle, void /* struct bot_initmove_s */ *initmove);

void trap_BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type);

int trap_BotChooseBestFightWeapon(int weaponstate, int *inventory);

void trap_BotGetWeaponInfo(int weaponstate, int weapon, void /* struct weaponinfo_s */ *weaponinfo);

int trap_BotLoadWeaponWeights(int weaponstate, char *filename);

int trap_BotAllocWeaponState(void);

void trap_BotFreeWeaponState(int weaponstate);

void trap_BotResetWeaponState(int weaponstate);

int trap_GeneticParentsAndChildSelection(int numranks, float *ranks, int *parent1, int *parent2, int *child);

void trap_SnapVector( float *v );

这样子比较的彻底的把整个引擎的函数全部的处理的干干净净的了！

enum {

BC_NULL,

BC_FOLLOW , 跟随

BC_HELP, 帮助

BC_GET, 得到

BC_PATROL,入口

BC_CAMP,

BC_HUNT,

BC_DISMISS,

BC_REPORT, 报告

BC_POINT,

BC_GETFLAG, 得到标志

BC_DEFENDBASE 防御基地

} botCommandId;

这个目标的处理了这个的判断，这个乃是对于机器人目标的处理了

压入到了目标的堆栈，来处理这个的了

机器人的第二目标，机器人的第一目标的处理

加载武器的权重

机器人的跑跳，向左移动，向右移动，跑跳，等等的处理了者也

对于

这个机器人的逻辑大致上是有限状态机的模式了

见到人就打，没人的时候，遍历，寻找area的这个

我认为area就是brush的逻辑上的一个名称了者也

从这个area里面寻找到了这个边edge路径了者也

以下是机器人移动时的这个结构体

typedef struct bsp_trace_s

{

qboolean allsolid; // if true, plane is not valid

//判断机器人是否碰撞到了实体了呢？

qboolean startsolid; // if true, the initial point was in a solid area 如果为真，则初始点位于固体区域

float fraction; // time completed, 1.0 = didn't hit anything 时间完成，1.0 =没有击中任何东西

vec3_t endpos; // final position 终点位置 / 结束姿势 / 最终位置 / 起面地位

cplane_t plane; // surface normal at impact

float exp_dist; // expanded plane distance

int sidenum; // number of the brush side hit

bsp_surface_t surface; // hit surface

int contents; // contents on other side of surface hit

int ent; // number of entity hit

} bsp_trace_t;

bspc

对于脚本的这个分配内存

脚本的多边形

从脚本中得到了这个数学的处理者也

bsp的处理者也！

生成这个aas文件的部分

这个aas中的这个entity的处理

这个机器人包括了目标等等的处理，寻径等等的处理者也

动态菜单里面包含了这些bot的命令者也

这个其实是机器人一类的东西了者也！

用于机器的行走，quake3的机器人是不停地行走，如果

遇到敌人就开枪，

这些是在脚本文件中实现的者也

机器人有各种的状态，

判断在一个节点中是否有敌人要运用平面与点之间的关系，打不过逃，遇到武器就拣，

这是机器人的逻辑，

生成路径的方法

寻路的算法，从aas文件中查找到了边，然后，再来寻找了这个边，路径

机器人选择最好的枪，选择枪的处理了

在重生时，选择附近的点来重生点来重生等等，随机点来重生，或者特定点

从脚本中加载变量，和其他的值者也！

有关机器人的有限状态机在有策划等人在脚本中来设计者也，

对于怪物的导航，预先生成的路径存储在了aas地图上了，预先避免碰撞，

waypoint，我很怀疑这个quake3使用的这个命令排队技术者也

分配机器人到达各部分的这个运动方式等等

要给与这个bot以权重，

对于机器人分配这个运动状态

机器人也分为男女，在网络战争中处理这个细腻者也

值得一提的是加上了debug阶段，判断内存消耗多少者也。

对于这个脚本的处理者也

area

如果这个掉下了地板上了，那么起点的z值减去了100，然后，从起点到达到了这个终点上了

预测运功

预测运动?预测这个能到达了那里者也

还有这个点的运动？

火箭跳，这个要除以质量，伤害距离

要计算这个火箭跳的方向，从而来判断这个伤害的距离者也

火箭的伤害距离-，这个的距离等于

加快速度的处理

摩擦力的处理

判断这个摩擦力的影响能不能使得物体停下来，如果不能

现在的速度=速度- 摩擦系数*每一帧的时间*控制

碰撞力的计算(???此处有问题者也）

如果与这个碰撞包围盒相交的话，检查这个碰撞检测，

那么计算这个碰撞点和这个速度=开始点+因素*end;

客户端移动预测

垂直这个移动跳跃

机器人的这个goal这个目标的ai处理者也、

加载这个item的权重

aas人工智能部分

我觉得这一部分应该和这个游戏逻辑部分合并一下子比较的好了者也！

在这里，使用了这个命令行的命令来进行这个讲述了者也

bsp-》aas文件

在运用bspc.exe生成了这个aas文件的

加载bsp文件生成aas文件，aas不仅仅是供机器人使用的者也，

还表明了不同的区域之间的属性等等

这个aas文件，变化成了quake1,hl1,quake2的bsp文件，

很可能是这个加载quake3的bsp文件了者也

aas文件的内容

对于aas文件

area

对于这个area的这个bound的处理了者也

一个区域area中这个点的数目了者也

到达点的数目了者也

所以两个区域之间判断这个边，通常在线判断两个区域是不是相连接着，如果相连的话，就可以生成一条路径了，

有没有共同的边，共同的点，那么就证明这两个区域相连接着

对于area区域的组合，边的组合者也

对于区域类型不同的情况，不能进行组合，例如水面和这个地面者也

area这个数目，乃是指的这个怪物要跑的这个区域的数目者也啊！

碰撞检测部分

检查这个aas文件那里能够到达，哪里不能够的到达，这个来检查，

机器人到达了不同的区域后要进行转换这个运动方式者也

如果两个区域有相同的类型，才能够组合成一个类型的者也，这个及其正确者也，

如果构成这两个区域的图元相同，那么可以组合成了一块了者也

这个对于这个电梯，门等等加上了一座桥和没有加上了桥的区域不一样了者也

把所有的这个区域内部进行组合了者也

如果是梯子则不组合者也

把在各个区域的速度，等等加上了者也

确保所有的这个区域都能够到达了这个

aas的格式为

跟bsp文件的格式极其相似了

------------------------------------

以下为这个aas文件格式的一些东西

基本上将用户在关卡编辑器中，制定的区域类型，等等最后保存到了aas文件之中了

------------------------------------

#define AASID (('S'<<24)+('A'<<16)+('A'<<8)+'E')

#define AASVERSION_OLD 4

#define AASVERSION 5

//presence types

#define PRESENCE_NONE 1

#define PRESENCE_NORMAL 2

#define PRESENCE_CROUCH 4

//travel types

#define MAX_TRAVELTYPES 32

#define TRAVEL_INVALID 1 //temporary not possible

#define TRAVEL_WALK 2 //walking

#define TRAVEL_CROUCH 3 //crouching

#define TRAVEL_BARRIERJUMP 4 //jumping onto a barrier

#define TRAVEL_JUMP 5 //jumping

#define TRAVEL_LADDER 6 //climbing a ladder

#define TRAVEL_WALKOFFLEDGE 7 //walking of a ledge

#define TRAVEL_SWIM 8 //swimming

#define TRAVEL_WATERJUMP 9 //jump out of the water

#define TRAVEL_TELEPORT 10 //teleportation

#define TRAVEL_ELEVATOR 11 //travel by elevator

#define TRAVEL_ROCKETJUMP 12 //rocket jumping required for travel

#define TRAVEL_BFGJUMP 13 //bfg jumping required for travel

#define TRAVEL_GRAPPLEHOOK 14 //grappling hook required for travel

#define TRAVEL_DOUBLEJUMP 15 //double jump

#define TRAVEL_RAMPJUMP 16 //ramp jump

#define TRAVEL_STRAFEJUMP 17 //strafe jump

#define TRAVEL_JUMPPAD 18 //jump pad

#define TRAVEL_FUNCBOB 19 //func bob

//face flags

#define FACE_SOLID 1 //just solid at the other side

#define FACE_LADDER 2 //ladder

#define FACE_GROUND 4 //standing on ground when in this face

#define FACE_GAP 8 //gap in the ground

#define FACE_LIQUID 16

#define FACE_LIQUIDSURFACE 32

/ *

--------------------------------------

area contents区域的类型，用于机器人或者你自己，到达了这个区域之后，根据区域类型生成相对应的旅行方式

-----------------------------------

#define AREACONTENTS_WATER 1

#define AREACONTENTS_LAVA 2

#define AREACONTENTS_SLIME 4

#define AREACONTENTS_CLUSTERPORTAL 8

#define AREACONTENTS_TELEPORTAL 16

#define AREACONTENTS_ROUTEPORTAL 32

#define AREACONTENTS_TELEPORTER 64

#define AREACONTENTS_JUMPPAD 128

#define AREACONTENTS_DONOTENTER 256

#define AREACONTENTS_VIEWPORTAL 512

//area flags

#define AREA_GROUNDED 1 //bot can stand on the ground

#define AREA_LADDER 2 //area contains one or more ladder faces

#define AREA_LIQUID 4 //area contains a liquid

#define AAS_LUMPS 14

#define AASLUMP_BBOXES 0

#define AASLUMP_VERTEXES 1

#define AASLUMP_PLANES 2

#define AASLUMP_EDGES 3

#define AASLUMP_EDGEINDEX 4

#define AASLUMP_FACES 5

#define AASLUMP_FACEINDEX 6

#define AASLUMP_AREAS 7

#define AASLUMP_AREASETTINGS 8

#define AASLUMP_REACHABILITY 9

#define AASLUMP_NODES 10

#define AASLUMP_PORTALS 11

#define AASLUMP_PORTALINDEX 12

#define AASLUMP_CLUSTERS 13

加载这个botlb这个静态库者也，然后调用这个bot中的这个方法者也

在关卡编辑器中完全制定这个surface的类型，属于哪一种，然后在运行时候可以被解析了

aas这分割这个face面，分割这个区域，为什么呢？为什么要分割这个区域呢？

寻找这个最好的分割平面，

ladder梯子的分割，为什么要分割这个呢？

梯子分割区域了者也，这个也能够的分割啊

box距离这个平面的距离者也

计算这个起点位于平面的距离啊

创建一个brush者也，

如果这个brush->content这个味playerclip,

如果为其他的内容的话，

真的不一样啊

真的是要研究这个quake3代码花费的时间太久了啊

创建一个brush这个怎么一回事情啊

如果在aas部分，我们从中得到了这个物体的类型等等的处理者也！

我想明白了，在这个aas文件里面，来进行这个bot的处理者也！

这个我真的没有想到这个一部分也会出现变化了者也！

aas文件这个包括了这个边的处理，索引缓存，

还有这个的处理，第一条边，最后一条边的处理

area包括了这个face面的数目了者也

这样子的对于每一个area这个乃是包括的这个face数目了者也

这样子优化aas的处理了者也

if ( !( face->flags & ( FACE_FLOOR|FACE_LADDER ) ) ) {

如果这个面的类型乃是是一个地板

face面可以是梯子，湖泊等等的东西了者也

如果这个边数小于0那么表示这个区域达不到，把这个区域删除掉了者也

// remap vertices if not yet remapped

如果这个边=-1，那么把这条边删除掉了者也

newFaces[ newFaces.Num()-1 ].firstEdge = faceFirstEdge;

newFaces[ newFaces.Num()-1 ].numEdges = newEdgeIndex.Num() - faceFirstEdge;

新的边数将会减去了这个边数了者也

::EdgeCenter

这条边的中心的处理了者也，这个寻找这个边的中心来干什么的？

寻找这个face面的中心，

中心=face/面的数目了者也

区域的中心的处理了者也

中心=区域、区域的数目了者也

AreaReachableGoal

区域到达的这个目标了者也

area->flags & (AREA_REACHABLE_WALK|AREA_REACHABLE_FLY)) || (area->flags & AREA_LIQUID) ) {

return AreaCenter( areaNum );

这个到达的方式是这个步行和这个飞跃，

还有到达的方式是这个液体水中游泳的话，

返回了这个区域的中心的数目了者也

到达的这个区域的中心地带了者也

face面的这个bound的处理了者也

aas文件中包含了表示各个房间的node节点，

1 生成了旅行方式

运用brush.content中的lava（岩浆）,land（陆地）,movers，等生成aas_areas节点，

使得机器人在经过这些区

域时运用不同的行走方式，例如在经过这个陆地时，旅行方式为行走，

在经过这个水池时，旅行方式为这个游泳，经过梯子时，这个旅行方式为这个攀爬，

对于不同的区域，生成不同的行走方式，使得玩家以及机器人到了特定的区域，

自动切换这个行走的方式者也。

对于不同的区域area，区域通常是brush的一个面，面里面包含了多边形，由这个多边形组成的

，多边形又是由边edge组成的，要生成，两个区域的最短路径，就要判断两个区域之间最短的边了

face面这个乃是由brush的bspface转化而来的

edge，机器人寻路的时候，所用到的边

2 aas文件的参数的一些设置

例如，玩家的走路速度，跑步速度，跳跃的高度，

玩家的下蹲时候移动的速度，

对于设置速度，比如这个在水中的速度，火箭跳的速度

aas_set

初始化这个aas的设置，

例如最大的步行速度，水面的游泳最大速度，

最大的蹲着行走的速度，水面的最大流速，

水面跳跃的高度，电梯的速度

火箭跳的速度

武器跳的速度

者也

这个点和面的移动，这个在水中和地面上都可以看成是这个点和面的移动方式者也

设置移动方向

这个跳跃这个开始点与这个结束点之间的这个法线等等的处理者也

原来这个cfg加载这个各种aas的参数者也！

3判断这个aas的机器人能够到达的区域

Log_Print("numvertexes = %d\r\n", aasworld.numvertexes);

Log_Print("numplanes = %d\r\n", aasworld.numplanes);

Log_Print("numedges = %d\r\n", aasworld.numedges);

Log_Print("edgeindexsize = %d\r\n", aasworld.edgeindexsize);

Log_Print("numfaces = %d\r\n", aasworld.numfaces);

Log_Print("faceindexsize = %d\r\n", aasworld.faceindexsize);

Log_Print("numareas = %d\r\n", aasworld.numareas);

Log_Print("numareasettings = %d\r\n", aasworld.numareasettings);

Log_Print("reachabilitysize = %d\r\n", aasworld.reachabilitysize);

Log_Print("numnodes = %d\r\n", aasworld.numnodes);

Log_Print("numportals = %d\r\n", aasworld.numportals);

Log_Print("portalindexsize = %d\r\n", aasworld.portalindexsize);

Log_Print("numclusters = %d\r\n", aasworld.numclusters);

AAS_ShowNumReachabilities(TRAVEL_WALK, "walk");

AAS_ShowNumReachabilities(TRAVEL_CROUCH, "crouch");

AAS_ShowNumReachabilities(TRAVEL_BARRIERJUMP, "barrier jump");

AAS_ShowNumReachabilities(TRAVEL_JUMP, "jump");

AAS_ShowNumReachabilities(TRAVEL_LADDER, "ladder");

AAS_ShowNumReachabilities(TRAVEL_WALKOFFLEDGE, "walk off ledge");

AAS_ShowNumReachabilities(TRAVEL_SWIM, "swim");

AAS_ShowNumReachabilities(TRAVEL_WATERJUMP, "water jump");

AAS_ShowNumReachabilities(TRAVEL_TELEPORT, "teleport");

AAS_ShowNumReachabilities(TRAVEL_ELEVATOR, "elevator");

AAS_ShowNumReachabilities(TRAVEL_ROCKETJUMP, "rocket jump");

AAS_ShowNumReachabilities(TRAVEL_BFGJUMP, "bfg jump");

AAS_ShowNumReachabilities(TRAVEL_GRAPPLEHOOK, "grapple hook");

AAS_ShowNumReachabilities(TRAVEL_DOUBLEJUMP, "double jump");

AAS_ShowNumReachabilities(TRAVEL_RAMPJUMP, "ramp jump");

AAS_ShowNumReachabilities(TRAVEL_STRAFEJUMP, "strafe jump");

AAS_ShowNumReachabilities(TRAVEL_JUMPPAD, "jump pad");

AAS_ShowNumReachabilities(TRAVEL_FUNCBOB, "func b

这家伙，要输出来这个aas这个能够抵达的区域，并且这个输出来了这个日志，以及这个函数来了者也

4，对于这个entity物体这个的处理了等等

例如漂浮着的弹药，生命值，武器等，传送门等的处理

//entity info

typedef struct aas_entityinfo_s

{

int valid; // true if updated this frame

int type; // entity type

int flags; // entity flags

float ltime; // local time

float update_time; // time between last and current update

int number; // number of the entity

vec3_t origin; // origin of the entity

vec3_t angles; // angles of the model

vec3_t old_origin; // for lerping

vec3_t lastvisorigin; // last visible origin

vec3_t mins; // bounding box minimums

vec3_t maxs; // bounding box maximums

int groundent; // ground entity

int solid; // solid type

int modelindex; // model used

int modelindex2; // weapons, CTF flags, etc

int frame; // model frame number

int event; // impulse events -- muzzle flashes, footsteps, etc

int eventParm; // even parameter

int powerups; // bit flags

int weapon; // determines weapon and flash model, etc

int legsAnim; // mask off ANIM_TOGGLEBIT

int torsoAnim; // mask off ANIM_TOGGLEBIT

} aas_entityinfo_t;

5 预测

在游戏运行时候，也要进行预测这个区域类型了者也

aas_predictroute_t;

aas这个乃是可以预测路由，路径的处理的者也

开始点，结束点，这个开始的时间，最后的时间，时间的差距

旅行的方式的处理，这个行走的速度的处理

最后的这个area的这个区域的类型

//a trace is returned when a box is swept through the BSP world

这个来判断这个二叉树是不是有这个碰撞的呢？

对于这个二叉树的这个所有的实体，还有这个所有的这个叶子等等的处理者也

组合这个brush这个东西了者也，优化brush这个者也

移动距离的处理

路径的信息的处理，有多少个入口，有多少个这个

到达一个区域的时间

一个入口的区域的数目者也

计算这个穿过区域的时间

这家伙居然要计算这个入口的时间

初始化这个入口的最大的穿越时间

随机目标区域的处理

doom3 aas部分

“相关推荐”对你有帮助么？