C++博客-点点滴滴-随笔分类-19 源码收集

(搬运工)Mangos代码阅读

点点滴滴 — Fri, 16 Dec 2016 03:28:00 GMT

逻辑层：类World实现了wow的World，所有的逻辑处理
　　MaNGOS 下载，编译，配置和运行的基本步骤下载和安装msysgit，用于代码管理我使用的是Git-1.6.5.1-preview20091022.exe
　　下载和安装tortoisegit，用于代码管理我使用的是TortoiseGit-1.3.2.0-32bit.msi
　　使用git://github.com/mangos/mangos.git，从github提取mangos代码
　　采用Git GUI工具的Clone Existing Repository，得到 mangos代码（我的是9560，安装UDB参考这）
　　使用git://github.com/scriptdev2/scriptdev2.git，从github提取scriptdev2代码
　　采用Git GUI工具的Clone Existing Repository，得到 scriptdev2代码.
　　编译mangos我用的是VC9,打开mangoswinmangosdVC90.sln进行构造，构造完成后，会得到mangosbinWin32_Debug文件夹
　　编译scriptdev2我用的是VC9,打开mangoswinscriptdev2VC90.sln进行构造，构造完成后，会得到scriptdev2binWin32_Debug文件夹也可参考
　　pandore
　　拷贝mangossrcmangosd目录下的mangosd.conf.dist.in为mangosbinWin32_Debugmangosd.conf
　　拷贝mangossrcrealmd目录下的realmd.conf.dist.in为mangosbinWin32_Debugrealmd.conf
　　从http://www.wowtaiwan.com.tw/下载和安装台服WOW，并升级到最新版本我使用的是台服WOW 3.3.2 build 11403
　　，采用MaNGOS的工具ad从wow的MPQ中抽取map，得到的所有的map数据文件，文件命名规范为map_id（3位） tileY（2位） tileX（2位）.map，如文件名为0002035.map，代表的是Azeroth(地图id为000，tile坐标为(35,20). 注：WOW客户端的Tile对应mangos中的grid，WOW客户端的Chunk对应mangos中的cell(1cell = 4 chunk)
　　按照常规流程（包括建立数据库和配置服务器）把服务器跑起来，使用account create zzh1234567 zzh1234567 创建一个账号，使用account set gmlevel zzh1234567 3设置为超级用户
　　配置好客户端后，运行WOW，顺利登陆，呵呵
　　通过安装UDB来丰富场景FULL DB 9560 : HERE，参考这，在我安装DB9560的时候，发现Mangos在LoadCreatureAddons的时候，加载creature template addons出错，Mangos只要求creature template addons有7个字段，而creature template addons有9个字段我现在只是简单地跳过LoadCreatureAddons的调用
　　
运行Mangos （运行Mangos一节过期，是以前我针对国服3.1.3版本进行的安装配置），采用MaNGOS的工具ad从wow的MPQ中抽取map，得到的所有的map数据文件，文件命名规范为map_id（3位） tileY（2位） tileX（2位）.map，如文件名为0002035.map，代表的是Azeroth(地图id为000，tile坐标为(35,20). 注：WOW客户端的Tile对应mangos中的grid，WOW客户端的Chunk对应mangos中的cell(1cell = 4 chunk)
　　配置好客户端后，运行WOW，顺利登陆，呵呵
　　
Mangos代码阅读
　　Mangos有13个工程
　　使用了4个外部工具库，分别是：跨平台的网络通讯框架The ADAPTIVE Communication Environment (ACE)
　　压缩库zlib
　　Socket通信库 C++ Sockets Library (使用在realmd工程中，和使用在Mangosd工程中的RASocket，负责处理Remote Administration其他地方没有使用到这个C++ Sockets Library ）发现在C++ Sockets Library的TcpSocket::Open中存在一个问题，在n = connect(s, ad, ad);语句执行后，如果n=-1，C++ Sockets Library会检测是否ERR为WSAEWOULDBLOCK，否则表示成功，但在动态库中使用TcpSocket的时候，我发现n = connect(s, ad, ad);语句执行后，n=-1，ERR会为0，这个时候连接也是成功了，但TcpSocket::Open会当做不成功处理我发现这个问题，但没有时间去探究原因，也许并不是一个问题
　　C++的并行编程模板库Threading Building Blocks （tbb 和 tbbmalloc）
　　Mangos的实现分为：登录服务器（realmd）和世界服务器（mangosd+game）realmd和mangos共用了Mangos公共库（shared）
　　工程shared
　　提供了通用功能，包括了数据库的封装类，实现了对MySql的访问，同样，我们可以编写派生类来支持其他的数据库
　　工程script
　　提供了脚本接口，并实现了简单的几个脚本，封装为DLL，提供给game使用，具体可参考：MaNGOS脚本接口
　　通过使用不同的脚本DLL来替换share的这个DLL,可以让game具有更强的AIScriptDev2 就是一个这样的库ScriptDev2 is a replacement for the Script Library that comes with MaNGOS( http://www.getmangos.com ) written in C++ and is compatible with Windows and Linux. It provides scripts for NPCs, Boss events, and Items currently. Once ScriptDev2 is compiled it is automatically run by MaNGOS on server startup.
　　
工程mangosd
　　mangos是世界服务器的管理器，负责初始化工作和启动世界服务器各层的线程，这些工作主要是由类Master来实现具体是：使用三个数据库对象WorldDatabase和CharacterDatabase和loginDatabase，初始化三大数据库：World Database和Character Database和login Database，并为每个数据库的访问都启动一个DB delay threads具体的数据库操作功能都是由Mangos公共库shared来提供
　　调用sWorld.SetInitialWorldSettings，对World进行初始化，包括加载所有的游戏数据和初始化各种更新定时器和邮件定时器，还有些其他的初始化工作类World的成员函数SetInitialWorldSettings调用成员函数LoadConfigSettings解析mangosd.conf，解析后内容放入uint32 m_configs[CONFIG_VALUE_COUNT]中
　　加载的游戏数据有：
　　DBC数据
　　Objects数据
　　Spells数据
　　Pooling数据
　　Game Event数据
　　loot数据
　　技能数据
　　所有其他的游戏数据，包括Waypoints和Trainers等等等
　　脚本数据
　　其他的初始化工作有:
　　初始化MapManager，启动Map System
　　初始化Battlegrounds，启动BattleGround System
　　初始化DailyQuestResetTime
　　初始化sGameEventMgr，Starting Game Event system
　　类Master启动WorldRunnable，开始游戏逻辑Heartbeat for the World，由Master创建，并设置线程为最高优先级
　　类Master启动CliRunnable：Command Line Interface handling thread，由Master创建CliRunnable运行时候会生成一个WorldDatabase线程，在接收到输入后会调用sWorld.QueueCliCommand把Cmd放入到World::cliCmdQueue中
　　mangosd的线程总共有（1+3+1+1+1+2 +1 =10）10个线程主线程Master
　　2个网络线程ReactorRunnable（可配置数目）（网络层）
　　一个World线程（逻辑层）
　　三个DB线程（数据层）
　　一个CLI线程（输入层），运行时候会生成一个WorldDatabase线程
　　一个RA线程（管理层）
　　一个freeze catcher 线程（可选）
　　工程g3dlite：游戏逻辑层的底层库
　　工程framework：系统框架
　　工程realm
　　负责登陆和选择游戏服务器，进行负载均衡用到了C++ Sockets Library进行登录处理，采用select I/O模型实现了Wow, Mangos登录时的SRP6认证客户端作为它的client连接到realm server认证和选择了mangos server就断开而mangos server和realm server则不进行连接，只是通过数据库交互数据：mangos server把自己的状态和拥有的角色数放入库中realm server会读取数据库中的这些信息来获知mangos server的状态数据库realm的realmlist表保存了realm的列表
　　realm通过如下事件处理函数来负责登陆和选择游戏服务器
　　const AuthHandler table[] =
　　{
　　{ AUTH_LOGON_CHALLENGE, STATUS_CONNECTED, &AuthSocket::_HandleLogonChallenge },
　　{ AUTH_LOGON_PROOF, STATUS_CONNECTED, &AuthSocket::_HandleLogonProof },
　　{ AUTH_RECONNECT_CHALLENGE, STATUS_CONNECTED, &AuthSocket::_HandleReconnectChallenge},
　　{ AUTH_RECONNECT_PROOF, STATUS_CONNECTED, &AuthSocket::_HandleReconnectProof },
　　{ REALM_LIST, STATUS_AUTHED, &AuthSocket::_HandleRealmList },
　　{ XFER_ACCEPT, STATUS_CONNECTED, &AuthSocket::_HandleXferAccept },
　　{ XFER_RESUME, STATUS_CONNECTED, &AuthSocket::_HandleXferResume },
　　{ XFER_CANCEL, STATUS_CONNECTED, &AuthSocket::_HandleXferCancel }
　　}; 登录处理：
　　user登录到realm server进行身份认证，并选择登录上哪个mangos serveruser登录到mangos server后，将不再和realm server交互
　　参考： Wow 服务器解析
　　工程game
　　game：是Mangos的核心代码，网络层和逻辑层代码(采用了ACE反应器(Reactor)模式）
　　网络层： WorldSocket ：负责网络IO,而类WorldSession负责逻辑处理WorldSocket和WorldSession分别在独立的线程ReactorRunnable和WorldRunnable中运行，使用WorldSession中的消息队列_recvQueue来进行数据缓冲在WorldSocket接收到网咯输入后，会调用m_Session->QueuePacket (new_pct);把网络包放入WorldSession的_recvQueue所以，可以看到WorldSocket 是Mangos game的网络层，而WorldSession是逻辑处理层WorldSocketMgr是网络层的一个管理器，它负责指派WorldSocket归哪个ReactorRunnable管理（Mangos可创建多个ReactorRunnable，缺省是2个）
　　WorldSocketMgr（Manages all sockets connected to peers and network threads）管理所有的连接WorldSocketWorldSocketMgr的WorldSocketMgr::StartNetwork对8085（缺省）端口进行侦听逻辑处理的循环是在World::Update中循环处理包括：
　　刷新更新定时器
　　刷新游戏定时器和处理游戏关闭
　　处理日常任务
　　处理拍卖
　　刷新SessionsWorld::UpdateSessions会调用所有WorldSession的WorldSession::Update在WorldSession::Update中进行逻辑处理
　　处理天气
　　刷新uptime table
　　刷新Objects，包括maps，transport，creatures，，，，
　　刷新所有running battlegrounds
　　刷新SqlResultQueue, 逻辑层和数据层是通过Queue来进行异步操作的（用了AsyncPQuery和SqlResultQueue）
　　处理尸体移除
　　处理游戏事件
　　处理 Move all creatures with "delayed move" and remove and delete all objects with "delayed remove"
　　处理InstanceSaveManager的刷新
　　调用World::ProcessCliCommands，处理CLI从cliCmdQueue取得cmd进行解析执行所有有效的Cmd，都可以在ChatHandler::getCommandTable中找到
　　类WorldSession：类WorldSession负责逻辑处理
　　void WorldSession::SendPacket(WorldPacket const* packet) 负责发包给客户端，直接发包，没有输出缓冲队列
　　在WorldSession::Update中进行逻辑处理World::UpdateSessions会调用所有WorldSession的WorldSession::Update
　　执行语句OpcodeHandler& opHandle = opcodeTable[packet->GetOpcode()];得到opHandle
　　根据得到的opHandle，执行(this->opHandle.handler)(packet);
　　WorldSession::HandlePlayerLogin处理玩家登陆游戏
　　构建Player
　　Player::LoadFromDB从数据库中加载玩家数据在Player::LoadFromDB中会调用SetMap(MapManager::Instance().CreateMap(GetMapId() , this));加载当前player所在的map
　　Player::SetPosition在Player运动的时候，改变位置，保存处理夸区
　　类Map实现了一个state machine，采用state pattern组织了Gid的4个state object：InvalidState；ActiveState；IdleState；RemovalState
　　game中的管理器有： ObjectMgr
　　mMangosStringLocaleMap 关联到mangos_string table
　　m_scriptNames 关联到tables: creature_template;gameobject_template;item_templat e;areatrigger_scripts;instance_template
　　mCreatureLocaleMap 关联到locales_creature table
　　mGameObjectLocaleMap关联到locales_gameobject table
　　mItemLocaleMap关联到locales_item table
　　mQuestLocaleMap –> locales_quest
　　mNpcTextLocaleMap –> locales_npc_text
　　mPageTextLocaleMap –> locales_page_text
　　mGossipMenuItemsLocaleMap –> locales_gossip_menu_option
　　mPointOfInterestLocaleMap –> locales_points_of_interest
　　…
　　对象类层次
　　对象的类层次如下，所有的Object都由ObjectMgr进行管理ObjectMgr以GUID方式，管理了characters，creature，item_instance，gameobject，auctionhouse，mail，item_text，corpse，arena_team，character_equipmentsets
　　
　　
　　
　　
　　
Player状态
　　/// Player state
　　enum SessionStatus
　　{
　　STATUS_AUTHED = 0, ///< Player authenticated (_player==NULL, m_playerRecentlyLogout = false or will be reset before handler call, m_GUID have garbage)
　　STATUS_LOGGEDIN, ///< Player in game (_player!=NULL, m_GUID == _player->GetGUID(), inWorld())
　　STATUS_TRANSFER, ///< Player transferring to another map (_player!=NULL, m_GUID == _player->GetGUID(), !inWorld())
　　STATUS_LOGGEDIN_OR_RECENTLY_LOGGOUT, ///< _player!= NULL or _player==NULL && m_playerRecentlyLogout, m_GUID store last _player guid)
　　STATUS_NEVER ///< Opcode not accepted from client (deprecated or server side only)
　　};
　　生物状态
　　enum DeathState
　　{
　　ALIVE = 0,
　　JUST_DIED = 1,
　　CORPSE = 2,
　　DEAD = 3,
　　JUST_ALIVED = 4,
　　DEAD_FALLING= 5
　　};
　　玩家登陆
　　服务器端在连接打开后，会发SMSG_AUTH_CHALLENGE到客户端客户端从服务器端发送回来的种子和 SRP6 数据中产生随机种子，生成 SHA1 字符串，用这些数据生成 CMSG_AUITH_SESSION 数据包，发送给服务端这个过程是没有经过加密的
　　
　　客户端发送SMSG_AUTH_SESSION到服务器
　　服务器处理SMSG_AUTH_SESSION
　　服务器发送SMSG_AUTH_RESPONSE给客户端
　　服务器发送SMSG_ADDON_INFO给客户端
　　服务器发送SMSG_CLIENTCACHE_VERSION给客户端
　　服务器发送SMSG_TUTORIAL_FLAGS给客户端
　　packet结构 SMSG_AUTH_SESSION 是client packet有一个头部（ClientPktHeader），后面是数据块
　　SMSG_AUTH_RESPONSE 是server packet有一个头部（ServicePktHeader），后面是数据块
　　SMSG_AUTH_RESPONSE 的包组织
　　SMSG_AUTH_RESPONSE 的opcode是01EE，ByteBuffer大小为1 + 4 + 1 + 4 + 1=11一个SMSG_AUTH_RESPONSE 的数据如下：在构造了SMSG_AUTH_RESPONSE packet后，WorldSocket::SendPacket会根据SMSG_AUTH_RESPONSE packet构造出一个ServerPktHeader，并对ServerPktHeader中的数据header进行加密发送加密采用m_Crypt.EncryptSend ((uint8)header.header, header.getHeaderLength()); WorldSocket::handle_input_header会对从客户端接收来的数据进行解密，解密采用m_Crypt.DecryptRecv ((uint8) m_Header.rd_ptr (), sizeof (ClientPktHeader));
　　角色枚举玩家登上服务器后，从客户端发送SMSG_CHAR_ENUM到服务器
　　在服务器端
　　根据{ "CMSG_CHAR_ENUM", STATUS_AUTHED, &WorldSession::HandleCharEnumOpcode }，服务器会调用WorldSession::HandleCharEnumOpcode
　　WorldSession::HandleCharEnumOpcode会调用CharacterDatabase.AsyncPQuery，进行异步查询后，调用CharacterHandler::HandleCharEnumCallback
　　CharacterHandler::HandleCharEnumCallback会回头调用session->HandleCharEnum(result);
　　WorldSession::HandleCharEnum根据characters数据库的查询结果，调用Player::BuildEnumData，加载角色数据，构造SMSG_CHAR_ENUM返回包，然后发送回客户端
　　
　　角色创建
　　
　　角色的初始化装备在CharStartOutfit.dbc
　　角色的创建和选择的设置都在 ChrRaces.dbc
　　角色的创建属性都在Playercreateinfo，包括出生地和出生属性
　　playercreateinfo_item表是创建一个新人物时，人物默认带的所有Item的表
　　playercreateinfo_spell表是创建一个新人物时，人物默认带的所有Spell的表
角色删除
　　

点点滴滴 2016-12-16 11:28 发表评论

(搬用工)mangos新手教程 - 服务器配置文件中文说明

点点滴滴 — Fri, 16 Dec 2016 03:16:00 GMT

# MaNGOS Configuration file 服务器配置文件中文说明
ConfVersion=2007071001
# RealmID must match the realmlist (国度ID 必牒凸攘斜砝锩娴南喾?
RealmID = 1

# 0 NORMAL 1 PVP 4 NORMAL 6 RP 8 RPPVP(服务器类型)
GameType = 1

# 扩展柚每 ?# 0 不检查扩展地图,不允许创建新种族,忽略账号的扩展设置.
# 默认: 1 (如果客户端支持扩展且账号拥有扩展权限,即允许使用新种族及访问新地图.)
Expansion = 1

#==================================服务端添加的参数===========================================================================
#世界聊天消费(默认是1G/次)
sjxf=10000

#初始人物金币，以分为单位.
# 默认: 8
mymoney = 1000000

# 自动公告时间间隔 1=1秒
AutoBroadcastInterval=10

#初始怪物尸体停留时间
#单位/秒
# 默认: 60
MyCropseDelay = 60

#人物复活虚弱时间
#默认: 1000
Playerdietime = 1000

#初始出生人物等级
# 默认: 1
LevelFirst = 1

#加血技能治疗倍数
aurahealing = 5

#法术技能伤害倍数
tmpDamage = 5

#物理技能伤害倍数(数字别改的太大了)
pdaDamage = 2

#猎人闪避率设置(数字越大闪避率越低)

Rate.Hunter_Max.Dodge=31.4

#盗贼闪避率设置(数字越大闪避率越低)

Rate.Roguer_Max.Dodge=19.5

#其他职业闪避率设置(数字越大闪避率越低)

Rate.Else_Max.Dodge=27

#==================================服务端添加的参数===========================================================================
# 数据目录设置。
# 重要说明：数据目录需要放在引号里面，因为字符串可能包含空格
# DataDir = "@MANGOSD_DATA@" //这个是默认目录
DataDir = "./"

# Logs directory setting.
# Important: Logs dir must exists, or all logs be disable
# Default: "" - no log directory prefix, if used log names isn't absolute path then logs will be stored in current directory for run program.

LogsDir = ""

# 世界服务器的数据库连接设置。
# 格式：主机地址(域名或IP）;端口;用户名;密码;数据库名称
#           .;somenumber;username;password;database - use named pipes at Windows
#                 Named pipes: mySQL required adding "enable-named-pipe" to [mysqld] section my.ini
#           .;/path/to/unix_socket;username;password;database - use Unix sockets at Unix/Linux
#                 Unix sockets: experimental, not tested
LoginDatabaseInfo = "127.0.0.1;3306;root;netspace;realmd"
WorldDatabaseInfo = "127.0.0.1;3306;root;netspace;mangos"

# 设置最高ping数据库的时间间隔(分钟)
MaxPingTime = 30

# DBC 语言设置
#8 英语
#4 韩语
#3 法语
#3 德语
#4 中文
#5 台湾繁体
#6 西班牙语
#7 俄语
#8 未知
# 8 = Unknown
# 9 = Unknown
# 10 = Unknown
# 11 = Unknown
# 12 = Unknown
# 13 = Unknown
# 14 = Unknown
# 15 = Unknown
# 255 = 自动检测 (默认)
DBC.Locale = 255

# 启用GM命令记录-所有的SQL代码都将被记录在日记文件中
# All commands are written to a file: YYYY-MM-DD_logSQL.sql
# If a new day starts (00:00:00) then a new file is created - the old
# file will not be deleted.
# 0 - 不记录
# 1 - 记录
LogSQL = 1

# 服务器控制台记录显示的级别
# 0 = 最小; 1 = 基础和错误; 2 = 详细; 3 = 完全或侦错
# 默认: 0
# 推荐: 1
LogLevel = 0

# 记录文件的名字
# 文件名为空则不创建记录文件,如: LogFile =
# 默认: ""
LogFile = "Server.log"

# Logfile with timestamp of server start in name
# Default: 0 - no timestamp in name
#           1 - add timestamp in name in form Logname_YYYY-MM-DD_HH-MM-SS.Ext for Logname.Ext

LogTimestamp = 0

# 记录文件的记录级别
# 0 = 最小; 1 = 基础和错误; 2 = 详细; 3 = 完全或侦错
# 默认: 0
LogFileLevel = 0

# Log filters
# 0 (default) - include in log if log level permit, 1 - not include with any log level
LogFilter_TransportMoves = 0
LogFilter_CreatureMoves = 0
LogFilter_VisibilityChanges = 0

# 控制台信息的颜色 (格式: "正常颜色详情颜色 debug颜色错误颜色)
# 颜色: 0-黑色, 1-红, 2-绿, 3-棕, 4-蓝, 5-品红, 6-青绿, 7-灰色,
# 8-黄, 9-淡红, 10-淡绿, 11-淡蓝, 12-淡品红, 13-淡青绿, 14-白色
# 默认: "" 无颜色(白色)
# 例如: "13 7 11 9"
LogColors = "13 7 11 9"

# Packet logging file for the worldserver.
# Default: ""
WorldLogFile = "world.log"

# 记录数据库错误的文件名
# 默认: ""
DBErrorLogFile = "DBErrors.log"

# 记录GM命令使用情况的记录文件名
# 默认: "" (禁止) 允许时:例如: "GMcommand.log"
GmLogFile = ""

# Log file of RA commands, "" for disable
# Default: "Ra.log"
RaLogFile = ""

# 在多线程系统使用线程MASK(只在Windows系统下使用)
# 默认: 0 (操作系统来选择)
# 举例: 数字
UseProcessors = 80

# 进程优先权设置(只在Windows系统下使用)
# 0 (正常优先权)
# 默认: 1 (高优先)
ProcessPriority = 1

#发送到客户端的更新数据包的压缩级别(1到9)
# 默认: 1 (速度快,不压缩)
# 9 (最好的压缩)
Compression = 1

# 除GM之外游戏最大在线玩家数限制
# 默认: 100
PlayerLimit = 100

# 玩家获得经验能升到的最高等级(必须在 1 到 255).
# 不建议修改建议用默认的 60 超过60 可能影响游戏平衡
# 默认: 60
MaxPlayerLevel = 70

# 天气系统开关
# 默认: 1 (开)
#           0 (关)
ActivateWeather = 1

# 是否忽略进入副本的等级需要
#       1 (true)
# 默认: 0 (否)
IgnoreATLevelRequirement = 0

# 玩家最多可以学的商业技能
# 默认: 2
# 最大: 9
MaxPrimaryTradeSkill = 2

# 建立公会所需的最少玩家签名个数 (0..9).
# 默认: 9
MinPetitionSigns = 9

# 小队成员在生物死亡获得经验的最大距离(同怪物的距离)
# 默认: 74
MaxGroupXPDistance = 74

# 小队成员在生物死亡获得经验的最大等级差(同怪物的等级)
# 默认: 10
MaxGroupXPLevelDiff = 10

# 是否运行同1个帐号建立不2个不同阵营的角色 GM号为始终为允许
# 默认: 0 (不允许)
# 1 (允许)
AllowTwoSide.Accounts = 0

# 是否允许不同阵营间的聊天频道聊天组队交易
# 默认: 0 (不允许)
#     1 (允许)
AllowTwoSide.Interaction.Chat = 0
AllowTwoSide.Interaction.Channel = 0
AllowTwoSide.Interaction.Group = 0
AllowTwoSide.Interaction.Guild = 0
AllowTwoSide.Interaction.Trade = 0

# 是否在在线玩家列表里显示敌对阵营玩家
# 默认: 0 (不允许)
# 1 (允许)
AllowTwoSide.WhoList = 0

# 防刷屏开关,多少条违规信息激活保护
#           0 (为关闭防刷屏)
# 默认: 10
ChatFlood.MessageCount = 10

# 防刷屏开关,多少秒间隔开始计算为违规信息
# 默认: 1 (秒)
ChatFlood.MessageDelay = 1

# 防刷屏开关,禁言时间.
# 默认: 10 (秒)
ChatFlood.MuteTime = 10

# GM默认是否接受玩家的悄悄话.
# 默认: 0 (false)
#     1 (true)
GM.WhisperingTo = 0

# 当GM设置为可见时是否在玩家列表显示GM.
# 默认: 0 (false)
#     1 (true)
GM.InGMList = 0

# 是否显示GM名单 (if visible).
# 默认: 0 (false)
#           1 (true)
GM.InWhoList = 0

# GM模式在登陆时状态
#           0 (总是关)
#           1 (总是开)
# 默认: 2 (上次离开时状态)
GM.LoginState = 2

# 如果打开则在GM LOG里记录GM的交易和交易信息
#           0 (不记录)
# 默认: 1 (记录)
GM.LogTrade = 1

# 团队可见模式
# 默认: 0-标准设置：只有同一个团队的队友才可以100%侦测隐形玩家
#    1-只有同一个小队的队友才可以100%侦测隐形玩家
#    2-同一阵营的队友可以100%侦测隐形玩家
Visibility.GroupMode = 0

# 不同的游戏物体之间的可见度
# 最大设置: ~ 166
# 最小设置以物体为准
# 默认: 66 (单元)
#
# Min limit is max aggro radius (45) * Rate.Creature.Aggro
Visibility.Distance.Creature    = 66
Visibility.Distance.Player       = 66

# gameobject, dynobject, bodies, corpses, bones
# Min limit is iteraction distance (5)
Visibility.Distance.Object       = 66

# visible distance for player in flight
# Min limit is 0 (not show any objects)
Visibility.Distance.InFlight    = 66

# Visibility grey distance for creatures/players (fast changing obects)
#     addition to appropriate object type Visibility.Distance.* use in case visibility removing to object (except corpse around distences)
#     If ?is distance and G is grey distance then object make visible if distance to it <= D but make non visible if distance > D+G
# Default: 1 yard
Visibility.Distance.Grey.Unit = 1

# Visibility grey distance for dynobjects/gameobjects/corpses/creature bodies
#
# Default: 10 yards
Visibility.Distance.Grey.Object = 10

# 如果邮寄物品延时多久收到？？
# 默认: 3600 秒 (1 hour)
MailDeliveryDelay = 3600

# 每日消息。当玩家进入游戏的时候显示在聊天窗口的信息。
Motd = "Welcome to the Massive Network Game Object Server."

# Health and power regeneration and rage income from damage.
Rate.Health = 1;
Rate.Mana = 1;
Rate.Rage.Income = 1;
Rate.Rage.Loss = 1;
Rate.Focus = 1;

# 物品的掉率倍数
#poor,白色；
#common,普通；
#uncommon,罕见的;
#rare,贵重的；
#Epic,史诗;
#Legendary,传说;
#uest,任务>
# 默认: 1
# Rate.Drop.Items = 1

Rate.Drop.Items.Quality.Poor = 1
Rate.Drop.Items.Quality.Common = 1
Rate.Drop.Items.Quality.Uncommon = 1
Rate.Drop.Items.Quality.Rare = 1
Rate.Drop.Items.Quality.Epic = 1
Rate.Drop.Items.Quality.Legendary = 1
Rate.Drop.Items.Quest = 1
Rate.Drop.Money = 1

# 杀怪,任务,探索地图获得经验乘以的倍数
# 默认: 1
Rate.XP.Kill     = 20
Rate.XP.Quest = 30
Rate.XP.Explore = 10

# 普通,精英,稀有精英,BOSS,稀有普通怪的伤害乘以的倍数
# 例如: 1.4 就是增加0.4倍攻击伤害
Rate.Creature.Normal.Damage = 1
Rate.Creature.Elite.Elite.Damage = 1
Rate.Creature.Elite.RAREELITE.Damage = 1
Rate.Creature.Elite.WORLDBOSS.Damage = 1
Rate.Creature.Elite.RARE.Damage = 1

# 普通,精英,稀有精英,BOSS,稀有普通怪的血量乘以的倍数
# 例如: 1.4 就是增加0.4倍攻击血量
Rate.Creature.Normal.HP = 1
Rate.Creature.Elite.Elite.HP = 1
Rate.Creature.Elite.RAREELITE.HP = 1
Rate.Creature.Elite.WORLDBOSS.HP = 1
Rate.Creature.Elite.RARE.HP = 1

#仇恨系数，默认1.1f，即有超过第一仇恨者造成伤害110%者就转变攻击对象。
#注意！必须精确到小数点后1位
# 默认: 1.1f
AggroThreat = 1.1f

# 精力条增长倍数 (1 - normal, 2 - double rate, 0.5 - half rate, etc) from standard values
# 游戏中
Rate.Rest.InGame = 1
# 在旅馆下线时
Rate.Rest.Offline.InTavernOrCity = 1
# 在野外下线时
Rate.Rest.Offline.InWilderness = 1

# 空中跌落伤害倍数
Rate.Damage.Fall = 1

# 拍卖倍数
# Rate.Auction.Time (拍卖时间倍率),Rate.Auction.Deposit(拍卖押金),Rate.Auction.Cut(拍卖上限)
Rate.Auction.Time = 1
Rate.Auction.Deposit = 1
Rate.Auction.Cut = 1

# 矿物倍数
#Rate.Mining.Next (采矿的几率倍数),Rate.Mining.Amount (产生矿最大最小的倍数)
Rate.Mining.Amount = 1
Rate.Mining.Next = 1

# 天赋点的升级倍率
# 默认: 1
Rate.Talent = 1

# 保存刷新时间当生物死当物体被打开或使用
#           0 (保存人/物体的刷新时间在网格卸载的时候)
# 默认: 1 (不在网格卸载的时候保存人/物体的刷新时间)
SaveRespawnTimeImmediately = 1

# 技能熟练度提升几率(0..100)
# 默认: 100-75-25-0
SkillChance.Orange = 100
SkillChance.Yellow = 75
SkillChance.Green = 25
SkillChance.Grey = 0

# 怪物自动攻击的范围乘以的倍数或者关闭自动攻击
# 0 - 关闭(0%)
# 默认: 1 - 乘以100%
# 1.5 - 乘以150%
Rate.Creature.Aggro = 1

# 控制台开关
#           0 - 关
# 默认: 1 - 开
Console.Enable = 1

# 远程控制台开关
# 默认: 0 - 关
#           1 - 开
Ra.Enable = 0

# 默认远程控制IP地址,0.0.0.0为所有IP皆可.
Ra.IP = 0.0.0.0

# 默认远程控制台端口
Ra.Port = 3443

# 远程控制台连接到服务器所需要的GM等级，默认为3（管理员）
Ra.MinLevel = 3

# 踢出用户，如果他输入了错误的密码（仅限远程控制台）
Ra.Secure = 1

# 最大速度限制倍率
# 默认: 2 如果为0则关闭检查加速
MaxOverspeedPings = 2

# 卸载Grids (如果里的内存够大,可以禁用,提高玩家第二次经过新Grids时候的速度)
# P.S: Grids就是地图上刷出来的东西,玩家经过一个地方就会加载该地方的环境,离开的时候就卸载该地方的环境
# 默认: 1 ( 卸载 grids) 0 ( 不卸载 grids)
GridUnload = 1;

# 以下所有的时间设置都以毫秒为单位。
# 默认端口选择时间
SocketSelectTime = 10000

# 默认地图网格清理延迟
GridCleanUpDelay = 300000

# 默认地图更新间隔
MapUpdateInterval = 100
# 默认天气更新间隔
ChangeWeatherInterval = 600000

# 默认玩家数据保存间隔
PlayerSaveInterval = 900000
# 默认世界服务器端口 mangosd.exe 的端口）
WorldServerPort = 8085

# 在mangos启动完毕后蜂鸣一声(通常只在Unix nux系统下工作)
# 默认: 1
BeepAtStart = 1

# 打开/关闭 VMmap 对视线和高度的推算支持
# Default: 1 (true)
#       : 0 (false)
vmap.enableLOS = 1
vmap.enableHeight = 1

# 不使用 VMap功能的地图ID
# 地图ID之间用 ','分割
# 如果有多个地图ID使用 "号包含
#vmap.ignoreMapIds = "369,0,1,530"
#DeeprunTram 没有包含在地图中
vmap.ignoreMapIds = "369"

# 不进行视线推算的技能
# 技能之间使用 ','分割
vmap.ignoreSpellIds = "7720"

点点滴滴 2016-12-16 11:16 发表评论

(搬运工)CritterAI官方文档翻译【An Introduction to NMGen】

点点滴滴 — Tue, 08 Nov 2016 13:18:00 GMT

The purpose of NMGen is to generate navigation meshes from arbitrary source geometry. Features fall into two categories: Core and 'standard build'.
NMGen用于将任意网格转化为一个或多个NavMesh。其所有功能都包含于两个目录： Core(核心) 和 'standard build'(普通);

The core features are located in the org.critterai.nmgen namespace and involve creating simplified polygon mesh data from detailed triangle-based source geometry. You can code your own build process from scratch using these features, but it will require a significant amount of work and detailed knowlege of all aspects of the process.
核心功能位于nmgen命名空间下，与将复杂的三角形mesh转化为简化的多边形mesh有关。你可以通过代码彻底重新规划生成过程(1)，不过这里有很多事情要做，而且你需要了解生成过程中各个方面的实现细节(2)。

The standard build process implements a flexible, extendable build process suitable for use at design time. It takes care of many of the mundane details for you. Its features are implemented in the following namespaces:
Common extentions: org.critterai.nmbuild
Unity extensions: org.critterai.nmbuild.u3d.editor
普通生成流程为了满足编辑期的需要，被设计成可变的、可扩展的结构。它已经为你处理好了很多细枝末节的事情(3)。普通功能位于以下的命名空间中：
通用扩展(3): nmbuild
Unity扩展: nmbuild.u3d.editor

The standard build process has three main steps which will be covered in detail throughout the rest of this section.
Compile the input.
The NMGen Build. (Produces the polygon meshes.)
Create the navigation mesh.
普通生成流程有如下三个主要步骤，稍后的章节会对这三个步骤进行详细的介绍。
编译数据源.
调用NMGen的生成功能(生成多边形网格).
生成 Navigation Mesh.(导航网格)

Note Note:
CAINav uses the OpenGL coordinate system.

注意：
CAINav使用OpenGL坐标系统.(XYZ,左右手什么的);

(1)生成过程有哪些？
(2)哪些方面的细节需要了解？
(3)相对于recast的扩展,cai是基于recast的功能基础而实现的;

快速扫盲
1、A* Path Finding是一个图最短路径搜索算法，只要数据源支持"遍历邻居"的操作，就可以应用A*;
2、Ploygen Mesh 是凸多边形网格，因为凸多边形内任意两点可以直达--在满足指定的倾斜角(slope limit)和高度差(step height)的情况下。
3、如果有地形的Triangle Mesh,其实已经可以基于它进行A*了，因为三角形也是凸多边形。大费周章的使用Nav Mesh是为了1、大幅简化图的复杂度，将不必要的信息进行合并。2、记录一些额外的信息，比如 xxx xxx。

点点滴滴 2016-11-08 21:18 发表评论

(搬运工) CritterAI官方文档翻译【The Crowd Manager】

点点滴滴 — Tue, 08 Nov 2016 13:17:00 GMT

The crowd manager is the big beast of the navigation components. It not only handles a lot of the path management for you, but also local steering and dynamic avoidance between navigation clients. I.e. It can keep your agents from running into each other.
【CrowdManager】类是十分庞杂的一个类。它不仅为你处理了非常多的路径管理相关的事情，同时也处理一些局部转向和避开其它寻路代理对象。也就是说，他可以让所有的代理对象不会相互穿插。

Core Class: CrowdManager
核心类：CrowdManager

The NavmeshQuery and PathCorridor classes provide perfectly good, easy to use path planning features. But in the end they only give you points that your navigation client should be moving toward. When it comes to deciding things like client velocity and steering to avoid other clients, that is up to you to implement. Unless, of course, you decide to use the crowd manager.
NavmeshQuery和PathCorridor这两个类已经很不错了，用来做路径规划也足够简单。但是说到底它们只是给了你一堆指导角色运动的路点。当你决定实现一些角色之间不发生碰撞的特性时，只能你自己实现了。除非，当然，你决定使用CrowdManager。

Basically, you add an navigation client (agent) to the crowd manager, providing various configuration settings such as maximum speed and acceleration. You also provide a local target to more toward. The crowd manager then provides, with every update, the new agent position and velocity for the frame. The movement will be constrained to the navigation mesh, and steering will be applied to ensure agents managed by the crowd manager do not collide with each other.
基本上来讲，你可以往CrowdManager添加一个角色，同时提供一些配置数据，例如最大速度和加速度。你也可以提供一个局部的目标(让角色自主的移动过去(1))。然后CrowdManager会在每帧更新的时候设置角色的最新位置和速度。运动会被约束在Navmesh内，CrowdManager会让角色在需要的时候进行转向，以确保不会相互碰。

This is very powerful feature set. But it comes with limitations.
The biggest limitation is that you must give control of the agent's position and velocity completely over to the crowd manager. You can update things like maximum speed and acceleration. But in order for the crowd manager to do its thing, it can't allow you to constantly be giving it overrides to position and velocity. So you give up direct control of the agent's movement. It belongs to the crowd manager.
The second biggest limitation revolves around the fact that the crowd manager deals with local planning. The agent's target should never be more than 256 polygons aways from its current position. If it is, you risk your agent failing to reach its target. So you may still need to do long distance planning and provide the crowd manager with intermediate targets.

这是一个非常强大的特性集。但是它伴随着一些限制。
最大的限制在于你必须将角色的位置和速度完全交给CrowdManager来控制。你可以更新类似最大速度和加速度之类的参数。但是为了让CrowdManager能正常工作，你不能经常的改变角色的位置和速度。因此你需要放弃管理角色运动。这个工作现在属于CrowdManager。

Other significant limitations:
All agents using the crowd manager use the same NavmeshQueryFilter.
Crowd management is relatively expensive. The maximum agents under crowd management at any one time is around 20.

其他明显的限制
所有托管的角色都使用同样的查询过滤器
人群管理的开销相对较大。可以管理的人群的个体数量最大约为20个(1)。

The Sample Pack includes a Crowd Manager Demo that lets you see the manager in action.

(1)需要实验?
(1)这个数量是一个人为的限制，可以通过修改代码突破此限制。

点点滴滴 2016-11-08 21:17 发表评论

(搬运工) CritterAI官方文档翻译【The Path Corridor】

点点滴滴 — Tue, 08 Nov 2016 13:16:00 GMT

The Path Corridor
翻译：kun 2014.12.4

The path corridor provides a way of moving along a navigation path without worrying about the minutiae of managing the path.
廊道提供了一种沿指定导航路径进行移动，而不必担心管理使用路径数据时的细节问题。

Core Class: PathCorridor
核心类：PathCorridor

In the simplest scenario, a path is a list of waypoints from a starting point to an end point. The waypoints form a connected set of line segments along which a navigation client moves. But

navigation is much more complex in the real world. There are locomotion limitations, local steering restrictions, dynamic obstacle avoidance, and good old floating point errors. All of these

issues can make management of a path difficult.
在最简单的情景里，一个路径是一组从开始点到结束点的路点列表。如果能精确的按照使用此导航数据运动，角色的轨迹会是一组相互连接的线段。但是在真实环境下进行导航比这个要复杂的多。你需要考虑角色的运

动能力的局限性(1)、局部转向限制、避开动态障碍物、以及一些常见的浮点数错误。所有这些情况都会让管理一个路径的使用变得困难。

Navigation based on a polygon mesh provides a different abstraction than just a list of waypoints. The path returned by the NavmeshQuery class is a list of polygons. Technically, a client can

move freely anywhere within this corridor of polygons. If a client strays outside the corridor, then the corridor can be patched up using local searches rather than full path replanning.
在一个多边形网格上进行导航比在一堆路点上进行导航要更加抽象一些。NavmeshQuery返回的Path是一组多边形。技术上讲，一个角色可以在这个廊道上的任意多边形内自由的移动。如果一个角色跑出了这个廊道的范

围，廊道的范围可以使用局部搜索进行扩大，而不是重新规划整条路径。

The path corridor is loaded with a path, a start point, and a target point. It is then used to move the navigation client through the corridor. It handles path straightening, constraining the

client to the navigation mesh, and adjusting the corridor due to inaccurate client locomotion.
廊道需要加载一个Path、一个起始点、一个目标点。然后用于角色在这个廊道内移动。它处理路径的矫正、确保角色不会跑出Navmesh、以及当角色移动超出预期时修正廊道信息。

The PathCorridor API is well documented. The only thing worth repeating here is a warning: You can't just initialize a corridor with a path and forget long distance path planning. Since the

path corridor class uses local searches to maintain the corridor, attempting to apply large delta movement to the corridor's position or target can result in a malformed corridor. Details are

in the API documentation.
PathCorridor API已经有详细的文档说明了。在这里只有一点值得提一下：你不能只创建一个廊道然后一切都交给它去做，而不进行长路径规划。虽然廊道使用了局部搜索来维持廊道完整性，不过如果在廊道里产生一

个大的运动距离，或者目标点离得很远，会产生一个畸形的廊道(1)。更多的细节可以参考相关API文档。

(1)加速、减速、惯性之类的运动参数.
(2)啥意思?

点点滴滴 2016-11-08 21:16 发表评论

(搬运工)CritterAI官方文档翻译【The Navigation Query】

点点滴滴 — Tue, 08 Nov 2016 13:15:00 GMT

翻译：kun 2014.12.4

The navigation mesh query is the most important class to understand since most navigation clients will interact with the query rather than the navigation mesh itself. The mesh contains the data, but the query provides almost all of the features necessary for pathfinding.
用户和navigation mesh query(Navmesh查询器)打交道的次数比Navmes本身多的多。网格包含数据，但是查询器提供了几乎全部的寻路特性。

Core Class: NavmeshQuery
核心类：NavmeshQuery

Query features fall into two general categories: Pathfinding and local search.
查询器的特性包括两个大的方面：寻路和局部搜索。

Pathfinding involves standard A* and Dijkstra searches that find the best path(s) between two points. Paths are made up of a list polygon references that represent a polygon corridor from the start to the end position. Path straightening is used to convert the path into a list of waypoints. (I.e. String pulling.)
寻路使用标准的A*和Dijkstra算法，用于找出两点之间最好的路径(可能不止一条)。Path(路径)是由一组Polygon的引用(1)组成数据，从开始点到结束点。路径矫正是将一个Path数据转为一组路点数据(即String pulling(绳子拉直))(2)。

The local search features offer various methods for locating polygons and points on polygons, and for querying the local environment. I.e. Raycasting, finding the distance to the nearest wall, etc.
局部搜索功能提供多种方式进行多边形和多边形上的点的定位，以及查询局部的一些环境信息。比如射线查询、计算离最近的墙的距离之类的。

Many of the query methods require a NavmeshQueryFilter. Filters define area traversal costs as well as flags used for including/excluding polygons and off-mesh connections from results.
许多查询方法要求一个NavmeshQueryFilter(查询过滤器)。过滤器定义了Polygon和off-mesh connections的穿越代价，代价值可以参与启发式的计算，用来决定是否在最终路径里包含/排除某个Polygon或off-mesh connections。

The best way to understand the query class is to play around with it. The Sample Pack includes the Query Explorer demo that permits experimentation with all of the main query features.
理解查询器的最好办法就是用一用。【Sample Pack(示例包)】里的【Query Explorer(查询演示)】demo展示了查询器一些主要的特性。

Common Operations
通用操作

This section contains some simple examples of common query operations.
Finding a Point in the Navigation Mesh
You can't do much without first getting a valid point on the navigation mesh. So the first step is to find one.
GetNearestPoint(Vector3, Vector3, NavmeshQueryFilter, NavmeshPoint)
本节是例子
查询一个在Navmesh上的点
如果你没有一个Navmesh上的起始点的话，你能做的不多。所以第一部就是找一个点。
GetNearestPoint(Vector3, Vector3, NavmeshQueryFilter, NavmeshPoint)函数提供此功能。

CopyC#
// Where 'query' is a NavmeshQuery object and 'filter' is a NavmeshQueryFilter object.
// 'position' is a Vector3 indicating the world position of the client.
// 'query'是一个 NavmeshQuery对象，'filter'是一个NavmeshQueryFilter对象。
// 'position' 是一个Vector3对象，值为角色的世界坐标。

NavmeshPoint result;
Vector3 extents = new Vector3(1, 1, 1); // Keep this to the minimum extents practical. // 范围越小越好。

NavStatus status = query.GetNearestPoly(position, extents, filter
, out result);

if (result.polyRef == Navmesh.NullPoly)
{
// Handle error. Could not find a result.
// The status can be checked to see if there was an error. If not, then
// the cause is that the search extents did not overlap any polygons.
// 错误处理。找不到结果。
// 可以检查状态看看是什么问题。如果没有问题，说明指定范围里不包含多边形。
}

// Use the result point, which includes a vector point and the reference of
// the polygon that contains the point.
//使用结果点。包括一个Vector3的点和包含这个点的Polygon的引用。

Basic Pathfinding
Even if you are planning to use PathCorridor or CrowdManager, you'll always need to do long distance planning using the basic NavmeshQuery features. First, get a path, then optionally straighten it.
基础的寻径
即使你打算使用pathcorridor或crowdmanager,你也会需要NavmeshQuery的功能来完成一些长距离路径规划。第一，获取一条路径，然后选择性的弄直它(3)。

CopyC#
// Where 'query' is a NavmeshQuery object and 'filter' is a NavmeshQueryFilter object.
// 'start' and 'end' are NavmeshPoints known to be on the navigation mesh.
// 'query'是一个 NavmeshQuery对象，'filter'是一个NavmeshQueryFilter对象;
// 'start' 和 'end' 是已知的在Navmesh上的点;

int pathCount;
// The path will be a list of polygon references.
// path是一组polygon的引用;
uint[] path = new uint[100]; // Size for maximum allowed path length. // 路径的最大长度;
NavStatus status;

if (start.polyRef == end.polyRef)
{
// No need to do any planning.
// 开始点和结束点在同一个多边形内，不需要进行路径规划;
pathCount = 1;
path[0] = start.polyRef;
}
else
{
status = query.FindPath(start, end, filter, path
, out pathCount);

if (NavUtil.Failed(status) || path.pathCount == 0)
{
// Handle pathfinding failure.
// 处理寻路失败;
}
else if (end.polyRef != path[pathCount - 1])
{
// Handle a partial path.
// The query either could not reach the end point,
// or the path buffer was too small to hold the
// entire path. (A check of 'status' will reveal if
// the buffer was too small.)
// 处理只有一部分路径的情况;
// 可能是结束点不可达;
// 或者路径的buffer长度太小，装不下整条路径;
// 如果是buffer太小，可以检查state;
}

}

// If you need to straighten the path...
// 如果你需要拉直路径;

const int MaxStraightPath = 4; // Just getting the first 4 waypoints. // 只处理前4个路点;
int wpCount;

// The waypoints.
// 路点列表;
Vector3[] wpPoints = new Vecotr3[MaxStraightPath];

// A list of polygon references. (The polygon being entered at each waypoint.)
// 一个多边形引用列表;(路点是多边形的入口点)
uint[] wpPath = new uint[MaxStraightPath];

// The type of each waypoint. (Start, end, off-mesh connection.)
// 每一个路点的类型信息.(开始点，结束点, 连接);
WaypointFlag[] wpFlags = new WaypointFlag[MaxStraightPath];

status = query.GetStraightPath(start.point
, goal.point
, path
, 0 // The index of the start of the path. // 路径的开始点;
, pathCount // The length of the path. // 路径的长度;
, wpPoints
, wpFlags
, wpPath
, out wpCount);

if (NavUtil.Failed(status) || wpCount == 0)
{
// Handle the failure. There should always be at least one waypoint
// (the goal) for a valid point/path combination,
// 处理失败。应该总是存在一个点(目标点)用于路径合并.
}

// Use the path and waypoints.
// 使用路径和路点;

(1)可以理解为句柄，或索引。
(2)Path上每个多边形中心之间的连线一般不会是直线，路径如果有拐角也会造成一些美观上的问题，这个时候需要使用特定的方法将路径变得尽量笔直，就好像将一根绳子拉直。

点点滴滴 2016-11-08 21:15 发表评论

(搬运工)CritterAI官方文档翻译【The Navigation Mesh】

点点滴滴 — Tue, 08 Nov 2016 13:14:00 GMT

The Navigation Mesh
翻译：kun 2014.12.4

The navigation mesh is the primary data model for the navigation system. The only user component that deals directly with the mesh on a regular basis is the component that is responsible for creating the mesh and managing its state. Normal navigation clients, the one's needing to perform pathfinding and such, rarely if ever interact directly with the navigation mesh.
NavigationMesh是导航系统的主要数据模型。用户只需要创建导航网格数据和维护数据状态。需要使用导航的地方一般是进行寻路操作，偶尔也可以使用navmesh进行一些交互。

Core Class: Navmesh
核心类：Navmesh

The Data Model
数据模型

Tiles
At the core of the navigation mesh is the tile. Tiles hold the vast majority of structural and state information. In fact, the Navmesh class is little more than a tile manager. It may consist of a single tile, or many tiles laid out in a grid that can be swapped in and out at runtime.
The tile based structure of the navigation mesh adds a lot of flexibility. As mentioned, tiles can be swapped in and out at runtime. This means that the mesh can represent a large area, but not all tiles have to be loaded and active, reducing the mesh's memory footprint. This also allows for a situation where individual tiles can be rebuilt without the need to rebuild the entire mesh.

Tiles(片区)
Navmesh的核心概念之一就是Tile。Tiles存放了大多数的结构信息和状态信息。事实上，Navmesh类有点像一个TileManager。Navmesh可以由单个Tile构成，也可以向网格一样的平铺开来，以便在运行期动态的替换其中的某个Tile。

Structural Elements
The tile's structural data is what defines the navigation graph used for pathfinding. It consists of two types of elements: Polygons and off-mesh connections.
The core of the structure is a mesh of convex polygons with between three and MaxAllowedVertsPerPoly vertices. This mesh is in the same format as NMGen's PolyMesh structure, and usually represents an abstraction of a scene's static geometry.
Off-mesh connections are optional. They consist of two connected endpoints, at least one of which resides within a polygon in the polygon mesh. Off-mesh connections are added to the navigation graph as a single edge and represent special travel routes not defined by scene geometry. Think: The route an agent travels if it jumps over a railing that normally blocks movement.

节点元素
Tile的数据结构是一个用于寻路的graph(图)。它由两种数据结构组成：Polygons(多边形集合)和off-mesh connections(分离的网格之间的连接关系集合)。
Off-mesh connections(分离的网格之间的连接关系集合)可以没有。它由两个相互连接的端点构成，至少一边在某个多边形里。Off-mesh connections作为单独的边添加到图的数据结构里。它代表着一种特殊的行走路线，并且不是由原始场景的几何体生成的。想象一下，一个角色跳过一个栏杆-栏杆可以阻碍普通的前进。

State Data
Tiles also contain state data. This data is associated with individual polygons and off-mesh connections. State data includes area and flags.
Areas are used to associate traversal cost to structural elements. This effects pathfinding. For example, the area representing swampland can have a higher cost than the area representing smooth surfaces such as meadowland.
Flags can be used to control when a structural element is traversable. For example, a flag can be set on the polygon below a door to indicate that it is closed and locked. Or a flag can indicate that only agents of a particular type are allowed to traverse the element.
It is important to note that areas and flags have no meaning within the navigation mesh itself. The interpretation of the values is dependant on the NavmeshQueryFilter used by each navigation client. For example: One filter may define a cost of 10 for area id 5, while another may define a cost of 2 for the same area. One flag may be set when a door is closed with one filter checking for the flag during pathfinding, while another filter, used by a ghost, ignores the flag completely.

状态
Tile包括了一些状态信息。状态用来区分不同的Polygons和off-mesh connections。状态数据包括areas(区域信息)和flags(标志位)。
Areas(区域)一般用来定义移动代价的。代价影响寻路。举个例子，穿越被标记为沼泽的区域时的代价花费可能比穿越标记为草地的区域的代价要高。
Flags(标志位)可以用来控制一个节点的可行走属性。举个例子，一个作为'门'的多边形，在门关闭的时候，可以给这个多边形设置一个特殊的标志位，以表示它是不可通过的。或者设置一个特殊的标志位，只允许特定类型的角色通过。
Areas和Flags的意义不是由Navmesh定义的，这非常重要。这些特别指定的数字都是由导航系认的用户系统自定义的NavmeshQueryFilter来解释的。举个例子：一个过滤器认为ID为5的区域具有10点路径代价，而另一个过滤器则认为只有2的路径代价。当一个关闭的门的标志位被设置后(1)，一种过滤器在寻路的时候就会考虑这种情况而将这个门视为不可通过，另外一种过滤器-可能是用于鬼魂的寻路-就会完全忽略这个标志位而将此节点认为是可通过的。

Structure Versus State
Why is it important to know the difference between structural elements and state data?
The first reason is that it is possible to save and load state separately from structure. One common use case is to have a serialized version of the full navigation mesh that represents its default state. Then serialized versions of various states, such as the last runtime state, are used to overwrite the default state as needed.
The main limitation is that a state is only valid for a particular structure. So you can't, for example, save the state, change the tile structure, then load the original state into the new structure.
The second reason for understanding the difference between structure and state has to to with tile and polygon references...

结构VS状态
节点元素和状态之间进行了分离，理解这点非常重要。
首先，这样它们可以独立的进行保存和加载。一个通常的情况是，加载一个预制的Navmesh数据后，其中的状态可能都是默认值，而利用一个上一次运行时保存的串行化的状态缓存，可以覆盖原始的状态信息。
不过这里有一个限制，状态信息和节点自身是精确匹配的。你不能在更改完一个节点的信息后，又将一个老的状态赋给它。
第二点则是对Tile和Polygon的引用方式。

Tile and Polygon References
The last bit of information needed to understand the navigation mesh is the concept of tile and polygon references. These values are one of the few data types that are defined by the navigation mesh rather than the tiles within the mesh. It is important to understand what references are because they are used by various classes to automatically invalidate pathfinding data if the structure of a navigation mesh changes.
Essentially, tile and polygon references are unsigned integer 'handles' to structural elements within a navigation mesh. Tile references are rarely used by navigation clients, while polygon references are all over the place. Polygon references are unique for the navigation mesh, so they are useful for easily identifying a polygon without needing to know which tile it belongs to.
Despite the name, polygon references can refer to a either a polygon or an off-mesh connection.
References can become invalid. If they are used after they are invalidated, then methods will return a failure status. Polygon references are based on the tile reference. So they will be invalidated whenever their associated tile reference is invalidated.
Structural changes govern the life of a reference. Changing the configuration of a navigation mesh or the internal structure of a tile will invalidate all associated references.
References are preserved during tile state changes such as changes flags and areas. They are also preserved during normal runtime loading and unloading of tiles, and during normal serialization/de-serialization of a navigation mesh.

Tile和Polygon的引用方式
要完全理解Navmesh，最后一点信息是关于Tile和Polygon的引用这个概念。这些引用是Navmesh为数不多的数据结构之一，而不是由Tile定义的。理解引用是什么很重要，因为通过它可以实现当导航网格发生变化的时候，一些类似寻路功能的模块能自动的将引用的多边形置为无效。
本质上来说，Tile和Polygon的引用是一个uint32(无符号整型)。Tile的引用很少被客户代码直接使用，因为使用场合基本上都可以被Polygon代替。Navmesh里的每个Polygon的引用都是唯一的，因此它们能够非常方便的定位到指定的Polygon，而不需要知道这个Polygon属于哪个Tile。
虽然名字差别比较大，Polygon的引用概念同时也涵盖了off-mesh connections对象。
引用可以变成无效的。如果在无效之后还使用引用，函数会返回一个失败信息。Polygon的引用有效性是基于Tile的引用的。因此当Tile的引用无效了，所有属于Tile的Polygon的引用也会无效。
构造的变化会影响引用的生命周期。改变Navmesh的配置或者Tile的内部结构会引起相关的引用全部失效。
引用会在Tile的状态发生变化的时候进行保存，比如指定Area或Flag值的时候。在运行期动态的加载或卸载Tile也会使引用自动保存，还有当正常串行化/反串行化一个Navmesh的时候。

Creating a Navigation Mesh

There are various pipelines for creating a navigation mesh. If you are using Unity, the Unity extensions make it easier. Otherwise, the basic steps are as follows:
Generate packed tile data:
Generate PolyMesh and PolyMeshDetail data using NMGen.
Optionally create a ConnectionSet. (Off-mesh connections.)
Load the data into a NavmeshTileBuildData object.
Create a NavmeshTileData object from the build data.

The tile's structure and default state is now locked into a packed data format that is ready to be loaded into a navigation mesh.

创建一个Navigation Mesh
创建一个Navmesh有一些流程。如果你在使用Unity，那么CAI提供的Unity扩展会让这件事情稍微简单点。否则，基本流程如下：
生成打包好的Tile数据.
使用NMGen生成PolyMesh和PolyMeshDetail。
创建个ConnectionSet(Off-mesh connections的容器)，这是可选的。
将这些数据(tile,PolyMesh,PolyMeshDetail,ConnectionSet)加载到NavmeshTileBuildData对象里。
创建一个NavmeshTileDatad数据。

现在Tile的构成关系和默认状态已经都封装到NavmeshTileData里了，并且为生成Navmesh而做了数据结构的改变。

Note Note:
Using the NavmeshTileBuildData class directly can be a bit daunting. The GetBuildData(BuildContext, Int32, Int32, PolyMeshData, PolyMeshDetailData, ConnectionSet, Boolean) utility method provides a standard way of
creating the build data.

注意：
直接使用NavmeshTileBuildData类可能有点难搞。GetBuildData这个工具函数提供了一种标准流程。

Create a navigation mesh:
Single tile navigation meshes are created using the the single step Create(NavmeshTileBuildData, Navmesh) method.
Multi-tile navigation meshes are created then loaded using multiple methods. Use the Create(NavmeshParams, Navmesh) method to initialize an empty mesh. then add tile data using the AddTile(NavmeshTileData, UInt32, UInt32) method.

创建一个Navmesh
如果创建只有个Tile的Navmesh,只需要调用一次Create(【NavmeshTileBuildData】, Navmesh)函数。
创建多Tile的Navmesh需要多次调用函数。使用Create(【NavmeshParams】, Navmesh)函数创建一个空的navmesh,然后使用AddTile函数将Tile添加进去(1)。

Navigation Mesh Serialization

The Navmesh class supports byte serialization using the GetSerializedMesh() method. This saves the entire mesh.
It is possible to serialize state separately from structure on a tile-by-tile basis. Get the tile from the mesh using the GetTile(Int32) method, then use the GetState(Byte[]) and SetState(Byte[]) methods.

Navmesh的串行化
Namvesh类支持二进制串行化，使用GetSerializedMesh来完成。这会将整个mesh转成二进制数据。
它可以每Tile的、状态和拓扑结构分离的进行串行化。从mesh里取Tile使用GetTile(Int32)函数，然后使用GetState(Byte[])函数和SetState(Byte[])函数进行状态的赋值。

(1)Tile数据有自己的生成流程，可以参考An Introduction to NMGen

点点滴滴 2016-11-08 21:14 发表评论

(搬运工)CritterAI官方文档翻译【An Introduction to Navigation】

点点滴滴 — Tue, 08 Nov 2016 13:13:00 GMT

An Introduction to Navigation
翻译：kun 2014.12.4

The navigation side of CAINav consists of features used to create and use navigation meshes for pathfinding and local steering.
CAINav提供创建Navmesh、基于Navmesh的寻路和局部转向避障。

Core: org.critterai.nav
Unity extensions: org.critterai.nav.u3d
核心命名空间：org.critterai.nav
Unity扩展：org.critterai.nav.u3d

There are five main classes you'll be dealing with:
经常和你打交道的类有五个：

Note Note:
CAINav uses the OpenGL coordinate system.
注意：
CAINav使用OpenGL坐标系。

The Navmesh class defines the structure and state of the navigation mesh. The only user component that deals directly with this class on a regular basis is the component responsible for creating the mesh and managing its state. Normal navigation clients, the one's needing to perform pathfinding and such, rarely if ever interact directly with the navigation mesh.
【Navmesh】类定义了导航网格的数据结构和状态。这个类用于保存用户创建的导航网格数据和数据状态。需要使用导航的地方一般是进行寻路操作，偶尔也可以使用navmesh进行一些交互。

The most important class to understand and become comfortable with is the NavmeshQuery class. It provides almost all of the client navigation features, including A* and Dijkstra path searches, string pulling, point and polygon searches, raycasting, etc.
【NavmeshQuery】类是需要理解透彻的最重要的类。它提供了所有用户级的导航功能，包括使用A*算法和Dijkstra算法进行寻路、绳索牵引、搜索点和多边形、射线查询等等。

The NavmeshQueryFilter is a seemingly minor class, but it has a large impact on navigation. Filters are used to define the costs of traversing the mesh and flags that control which parts of the navigation mesh are included in operations. Multiple filters can be used to customize the navigation behavior on a per client basis.
【NavmeshQueryFilter】是一个看起来很小的类，但是它对导航的影响很大。过滤器用来定义穿过某个区域时的代价。可以使用多个过滤器来实现自定义的导航行为。

The PathCorridor class provides a way of moving along a navigation path without worrying about the minutiae of managing the path.
【PathCorridor】类提供了一种沿导航路径，而不必担心管理路径的细节(1)。

The CrowdManager is the big beast of the navigation classes. It not only handles a lot of the path management for you, but also local steering and dynamic avoidance between navigation clients. I.e. It can keep your agents from running into each other.
【CrowdManager】类是十分庞杂的一个类。它不仅为你处理了非常多的路径管理相关的事情，同时也处理一些局部避障和避开其它寻路代理对象。也就是说，他可以让所有的代理对象不会相互穿插。

(1)需要实验。

点点滴滴 2016-11-08 21:13 发表评论

(搬运工)五种开源协议的比较(BSD,Apache,GPL,LGPL,MIT)

点点滴滴 — Tue, 28 Dec 2010 09:07:00 GMT

当Adobe、Microsoft、Sun等一系列巨头开始表现出对”开源”的青睐时，”开源”的时代即将到来！

最初来自：sinoprise.com/read.php?tid-662-page-e-fpage-1.html（遗憾的是这个链接已经打不开了），我基本未改动，只是进行了一些排版和整理。
参考文献：http://www.fsf.org/licensing/licenses/

现今存在的开源协议很多，而经过Open Source Initiative组织通过批准的开源协议目前有58种（http://www.opensource.org/licenses/alphabetical）。我们在常见的开源协议如BSD, GPL, LGPL,MIT等都是OSI批准的协议。如果要开源自己的代码，最好也是选择这些被批准的开源协议。

这里我们来看四种最常用的开源协议及它们的适用范围，供那些准备开源或者使用开源产品的开发人员/厂家参考。

BSD开源协议（original BSD license、FreeBSD license、Original BSD license）

BSD开源协议是一个给于使用者很大自由的协议。基本上使用者可以”为所欲为”,可以自由的使用，修改源代码，也可以将修改后的代码作为开源或者专有软件再发布。

但”为所欲为”的前提当你发布使用了BSD协议的代码，或则以BSD协议代码为基础做二次开发自己的产品时，需要满足三个条件：

如果再发布的产品中包含源代码，则在源代码中必须带有原来代码中的BSD协议。
如果再发布的只是二进制类库/软件，则需要在类库/软件的文档和版权声明中包含原来代码中的BSD协议。
不可以用开源代码的作者/机构名字和原来产品的名字做市场推广。

BSD 代码鼓励代码共享，但需要尊重代码作者的著作权。BSD由于允许使用者修改和重新发布代码，也允许使用或在BSD代码上开发商业软件发布和销售，因此是对商业集成很友好的协议。而很多的公司企业在选用开源产品的时候都首选BSD协议，因为可以完全控制这些第三方的代码，在必要的时候可以修改或者二次开发。

Apache Licence 2.0（Apache License, Version 2.0、Apache License, Version 1.1、Apache License, Version 1.0）

Apache Licence是著名的非盈利开源组织Apache采用的协议。该协议和BSD类似，同样鼓励代码共享和尊重原作者的著作权，同样允许代码修改，再发布（作为开源或商业软件）。需要满足的条件也和BSD类似：

需要给代码的用户一份Apache Licence
如果你修改了代码，需要再被修改的文件中说明。
在延伸的代码中（修改和有源代码衍生的代码中）需要带有原来代码中的协议，商标，专利声明和其他原来作者规定需要包含的说明。
如果再发布的产品中包含一个Notice文件，则在Notice文件中需要带有Apache Licence。你可以在Notice中增加自己的许可，但不可以表现为对Apache Licence构成更改。

Apache Licence也是对商业应用友好的许可。使用者也可以在需要的时候修改代码来满足需要并作为开源或商业产品发布/销售。

GPL（GNU General Public License）

我们很熟悉的Linux就是采用了GPL。GPL协议和BSD, Apache Licence等鼓励代码重用的许可很不一样。GPL的出发点是代码的开源/免费使用和引用/修改/衍生代码的开源/免费使用，但不允许修改后和衍生的代码做为闭源的商业软件发布和销售。这也就是为什么我们能用免费的各种linux，包括商业公司的linux和linux上各种各样的由个人，组织，以及商业软件公司开发的免费软件了。

GPL协议的主要内容是只要在一个软件中使用(“使用”指类库引用，修改后的代码或者衍生代码)GPL 协议的产品，则该软件产品必须也采用GPL协议，既必须也是开源和免费。这就是所谓的”传染性”。GPL协议的产品作为一个单独的产品使用没有任何问题，还可以享受免费的优势。

由于GPL严格要求使用了GPL类库的软件产品必须使用GPL协议，对于使用GPL协议的开源代码，商业软件或者对代码有保密要求的部门就不适合集成/采用作为类库和二次开发的基础。

其它细节如再发布的时候需要伴随GPL协议等和BSD/Apache等类似。

LGPL（GNU Lesser General Public License）

LGPL是GPL的一个为主要为类库使用设计的开源协议。和GPL要求任何使用/修改/衍生之GPL类库的的软件必须采用GPL协议不同。LGPL允许商业软件通过类库引用(link)方式使用LGPL类库而不需要开源商业软件的代码。这使得采用LGPL协议的开源代码可以被商业软件作为类库引用并发布和销售。

但是如果修改LGPL协议的代码或者衍生，则所有修改的代码，涉及修改部分的额外代码和衍生的代码都必须采用LGPL协议。因此LGPL协议的开源代码很适合作为第三方类库被商业软件引用，但不适合希望以LGPL协议代码为基础，通过修改和衍生的方式做二次开发的商业软件采用。

GPL/LGPL都保障原作者的知识产权，避免有人利用开源代码复制并开发类似的产品

MIT（MIT）

MIT是和BSD一样宽范的许可协议,作者只想保留版权,而无任何其他了限制.也就是说,你必须在你的发行版里包含原许可协议的声明,无论你是以二进制发布的还是以源代码发布的.

点点滴滴 2010-12-28 17:07 发表评论