NormalPlayMessi_11vs11_new.lua
约 8615 字
前言
NormalPlayMessi_11vs11_new.lua 是NormalPlay中的对抗脚本,在我方球员为大于8辆、小于等于11辆(即9-11辆车)时使用,仅在国赛 Div A 场地使用,用于比赛的正常进攻/防守场景
NormalPlay用于在特殊指令后,Ref 脚本发出 exit 信号后,使用的脚本,也是默认运行的脚本
注意
这个脚本是我们的 Lua 脚本中第一重要的脚本,我们的正常进攻与防守均于此有关
提示
你可以在这一位置找到文件: ZBin/lua_scripts/play/Nor/NormalPlayMessi_11vs11_new.lua
local isUsePass = false
local f = flag.dribbling
local DSS_FLAG = flag.dodge_ball + flag.allow_dss
local pl = param.pitchLength
local pw = param.pitchWidth
local pew = param.penaltyWidth
local ped = param.penaltyDepth
local goal= param.goalWidth
local matchStr = ""
local lastMatchStr = ""
local needchangestate = false
local defendTaskTable = {}
local attackTaskTable = {}
local lastCycle = 0
local laststate = "GetBall"
local attackerAmount = defenceSquence:attackerAmount()
local leaderNum = function()
return messi:leaderNum()
end
local receiverNum = function()
return messi:receiverNum()
end
function goaliePassPos()
local gPos = function ()
return messi:goaliePassPos()
end
return gPos
end
local function getAttackerNum(i)
return function()
return defenceSquence:getFreeDefNum(i)
end
end
function getPassPos()
local rPos = function ()
return messi:passPos()
end
return rPos
end
function getPassVel()
local vel = function ()
if messi:needChip() then
return messi:passVel() * 1
end
return messi:passVel() * 1
end
return vel
end
local KICK_TASK = function()
return function()
-- return task.goandTurnKick(getPassPos(),_,getPassVel())
-- return task.zAttackv2(getPassPos(),_,getPassVel())
return task.Crosserover(getPassPos(),_,getPassVel(),_,false)
end
end
local function receiverTask()
return function()
-- if getOurNum() <= 3 and messi:nextState() == "GetBall" then
-- return task.wmarking("Zero",_,getAttackerNum(0))
-- else
return task.goCmuRush(pos.getReceivePos(),player.toBallDir,_,DSS_FLAG)
--end
end
end
local generateAttackTask = function()
attackTaskTable = {}
local leader = leaderNum()
local receiver = receiverNum()
local markingindex = 0
local otherindex = 0
local curindex = 1
local backNum = 3
local posNum = 11
local subStr = {"A","S","M","D","B","R","C","F","K"}
attackerAmount = defenceSquence:attackerAmount()
table.insert(attackTaskTable,KICK_TASK()())
if leader ~= receiver and player.valid(receiver) and leader ~= gRoleNum["Goalie"] and receiver ~= gRoleNum["Goalie"] then
if gRoleNum["Leader"] ~= leader or gRoleNum["Assister"] ~= receiver then
needchangestate = true
end
gRoleNum["Leader"] = leader
gRoleNum["Assister"] = receiver
matchStr = "{LA}"
else
if gRoleNum["Leader"] ~= leader and leader ~= gRoleNum["Goalie"] then
needchangestate = true
end
gRoleNum["Leader"] = leader
matchStr = "{L}[A]"
end
--receiver
table.insert(attackTaskTable,receiverTask()())
curindex = curindex+1
matchStr = matchStr.."("
--danger marking
table.insert(attackTaskTable,task.wmarking("Zero",_,getAttackerNum(0)))
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
matchStr = matchStr..")"
--back
matchStr = matchStr.."("
if ball.posX() > -1000 and (cond.validNum() < 4) then
backNum = 1
end
for i=1,backNum do
table.insert(attackTaskTable,task.wback(backNum,i))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
end
matchStr = matchStr..")("
--marking
for i=1,attackerAmount-2 do
table.insert(attackTaskTable,task.wmarking("Zero",_,getAttackerNum(i)))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
markingindex = markingindex+1
end
matchStr = matchStr..")("
--otherpos
for i=0,posNum do
table.insert(attackTaskTable,task.wdrag(pos.getOtherPos(otherindex)))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
otherindex = otherindex+1
end
matchStr = matchStr..")"
end
local generateDefendTask = function()
defendTaskTable = {}
local leader = leaderNum()
local receiver = receiverNum()
local markingindex = 0
local otherindex = 0
local curindex = 1
local backNum = 3
local posNum = 11
local subStr = {"A","S","M","D","B","R","C","F","K"}
attackerAmount = defenceSquence:attackerAmount()
-- matchStr = "{L}{A}"
-- curindex = curindex+1
table.insert(defendTaskTable,KICK_TASK()())
--receiver
-- if cond.validNum() - backNum - 1 - attackerAmount -1 > 0 then
-- table.insert(defendTaskTable,receiverTask()())
-- else
-- table.insert(defendTaskTable,task.wmarking("Zero",_,getAttackerNum(markingindex)))
-- matchStr = matchStr..subStr[curindex]
-- markingindex = markingindex+1
-- attackerAmount = attackerAmount-1
-- end
if gRoleNum["Leader"] ~= leader and leader ~= gRoleNum["Goalie"] then
needchangestate = true
end
gRoleNum["Leader"] = leader
matchStr = "{L}("
--danger marking
table.insert(defendTaskTable,task.wmarking("Zero",_,getAttackerNum(0)))
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
matchStr = matchStr..")("
--back
if ball.posX() > 0 and (cond.validNum() < 4) then-- or cond.validNum()-4 < attackerAmount-1
backNum = 1
end
for i=1,backNum do
table.insert(defendTaskTable,task.wback(backNum,i))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
end
matchStr = matchStr..")("
--marking
for i=1,attackerAmount-1 do
table.insert(defendTaskTable,task.wmarking("Zero",_,getAttackerNum(i)))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
markingindex = markingindex+1
end
matchStr = matchStr..")("
--receiver
table.insert(defendTaskTable,receiverTask()())
-- matchStr = matchStr..subStr[curindex]
-- curindex = curindex+1
matchStr = matchStr..")("
--otherpos
for i=0,posNum do
table.insert(defendTaskTable,task.wdrag(pos.getOtherPos(otherindex)))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
otherindex = otherindex+1
end
matchStr = matchStr..")"
end
local ourBallJumpCond = function()
local state = messi:nextState()
local leader = leaderNum()
local receiver = receiverNum()
needchangestate = false
if state == "Pass" then
generateAttackTask()
if matchStr ~= lastMatchStr then
lastMatchStr = matchStr
needchangestate = true
end
if defenceSquence:enemyOrderChangedNew() then
needchangestate = true
end
-- return "Pass"
elseif state == "GetBall" then
generateDefendTask()
if gRoleNum["Leader"] ~= leader and RoleNum["Goalie"] ~= leader then
gRoleNum["Leader"] = leader
needchangestate = true
end
if matchStr ~= lastMatchStr then
lastMatchStr = matchStr
needchangestate = true
end
if defenceSquence:enemyOrderChangedNew() then
needchangestate = true
end
-- return "GetBall"
end
debugEngine:gui_debug_msg(CGeoPoint:new_local(-600,3000), state)
-- debugEngine:gui_debug_msg(CGeoPoint:new_local(-600,3200), laststate)
if laststate ~= state or needchangestate then
laststate = state
return state
end
end
local getMatch = function()
debugEngine:gui_debug_msg(CGeoPoint(-600,-param.pitchWidth/2-200),matchStr)
return matchStr
end
local attackTask = function(index)
return function()
return attackTaskTable[index]
end
end
local defendTask = function(index)
return function()
return defendTaskTable[index]
end
end
gPlayTable.CreatePlay{
firstState = "GetBall",
["GetBall"]={
switch = function ()
return ourBallJumpCond()
end,
Leader = defendTask(1),
Assister = defendTask(2),
Special = defendTask(3),
Middle = defendTask(4),
Defender = defendTask(5),
Breaker = defendTask(6),
Receiver = defendTask(7),
Center = defendTask(8),
Fronter = defendTask(9),
Kicker = defendTask(10),
Goalie = task.goalie(goaliePassPos()),
match = getMatch
},
["Pass"]={
switch = function ()
return ourBallJumpCond()
end,
Leader = attackTask(1),
Assister = attackTask(2),
Special = attackTask(3),
Middle = attackTask(4),
Defender = attackTask(5),
Breaker = attackTask(6),
Receiver = attackTask(7),
Center = attackTask(8),
Fronter = attackTask(9),
Kicker = attackTask(10),
Goalie = task.goalie(goaliePassPos()),
match = getMatch
},
name = "NormalPlayMessi_11vs11_new",
applicable ={
exp = "a",
a = true
},
attribute = "attack",
timeout = 99999
}1. 状态
一如既往,我们的 Lua 脚本使用状态机思想编写,我们把会遇到的情况抽象成各种状态,去做具体的对应,这里亦是如此。
在这个脚本,定义了两个状态
GetBall (防守/抢球状态)
Pass (进攻/传球状态)
我们比赛中大多数时间,都会花费在这个上面,简单的状态也便于维护
两个状态与其叫做 GetBall 和 Pass ,不如叫做 Attack 与 Defend ,不过你也因此可以看出,我们在进攻还是防守状态,可以说是由我们有没有拿到球决定的。
2. 角色分配
这个脚本支持 9-11 辆车的配置(8-10辆场上车 + 1辆守门员),使用以下角色:
- Leader
- Assister
- Special
- Middle
- Defender
- Breaker
- Receiver
- Center
- Fronter
- Kicker
- Goalie - 守门员
注
在这里,我们需要在 Config.lua 中给定守门员的车号,守门员几乎独立于整个体系,而且它不参与匹配,以固定车号方式进行
3. 匹配(Match)机制
对于匹配机制的讲解,请参考官方WIKI:
核心原理:双轨制设计
matchStr 和 任务表 是两个独立但同步的系统:
- matchStr:告诉框架哪些车号应该被分配到哪些角色名(如Leader、Assister等)
- attackTaskTable/defendTaskTable:定义每个角色名应该执行什么任务
匹配字符串示例
-- 进攻模式可能生成:
matchStr = "{LA}(S)(MDB)(DDDD)(CCCC)"
-- 防守模式可能生成:
matchStr = "{L}[A](S)(MDB)(DDDDD)(CCC)"匹配规则(三种括号的含义):
| 括号 | 名称 | 重新匹配时机 | 使用场景 |
|---|---|---|---|
{} | 保持匹配 | 仅在脚本跳转时 | 核心角色,整场比赛保持车号不变 |
() | 单次匹配 | 状态跳转时(switch有返回值) | 战术角色,状态切换时重新分配 |
[] | 实时匹配 | 每帧都重新匹配 | 灵活角色,实时选择最优车辆 |
具体含义:
{LA}- Leader和Assister使用保持匹配,除非切换脚本,否则1号车始终是Leader,2号车始终是Assister{L}[A]- Leader保持匹配,Assister实时匹配(当Leader==Receiver时,A用方括号表示可以每帧重新选择接球者)(S)(MDB)- Special、Middle、Defender、Breaker使用单次匹配,在GetBall↔Pass状态切换时重新分配车号
字符含义与角色映射
关键理解:matchStr中的每个字符都直接对应角色名的首字母
根据RoleMatch.lua中的gRoleLookUpTable定义:
gRoleLookUpTable = {
["L"] = "Leader", -- L代表Leader
["A"] = "Assister", -- A代表Assister
["S"] = "Special", -- S代表Special
["M"] = "Middle", -- M代表Middle
["D"] = "Defender", -- D代表Defender
["B"] = "Breaker", -- B代表Breaker
["R"] = "Receiver", -- R代表Receiver
["C"] = "Center", -- C代表Center
["F"] = "Fronter", -- F代表Fronter
["K"] = "Kicker", -- K代表Kicker
["G"] = "Goalie", -- G代表Goalie
...
}代码中的matchStr生成逻辑
local subStr = {"A","S","M","D","B","R","C","F","K"}
-- 这个数组用于动态构建matchStr的后续部分
-- 每个字符对应一个角色:A=Assister, S=Special, M=Middle, 等等-- 进攻模式:Leader和Assister都存在且不同
if leader ~= receiver and player.valid(receiver) and
leader ~= gRoleNum["Goalie"] and receiver ~= gRoleNum["Goalie"] then
matchStr = "{LA}" -- L=Leader, A=Assister,两者都保持匹配
else
matchStr = "{L}[A]" -- L=Leader保持,A=Assister实时匹配
end为什么进攻时Assister可能用[A]实时匹配?
- 当Leader==Receiver时,说明控球者自己就是最佳接球点
- 此时Assister角色不需要固定车号,可以实时选择最佳支援位置的车辆
- 使用
[A]实时匹配可以提高灵活性
进攻模式(generateAttackTask)matchStr示例:
11辆车(10场上 + 守门员):
matchStr = "{LA}(S)(MDB)(RCFK)"
-- {LA} = Leader和Assister(保持匹配)- 2辆车
-- (S) = Special(单次匹配)- 1辆车
-- (MDB) = Middle、Defender、Breaker三个后卫(单次匹配)- 3辆车
-- (RCFK) = Receiver、Center、Fronter、Kicker用于盯人/补位(单次匹配)- 4辆车
-- 共10辆场上球员 + Goalie = 11辆车10辆车(9场上 + 守门员):
matchStr = "{LA}(S)(MDB)(RCF)"
-- {LA} = Leader和Assister(保持匹配)- 2辆车
-- (S) = Special(单次匹配)- 1辆车
-- (MDB) = Middle、Defender、Breaker三个后卫(单次匹配)- 3辆车
-- (RCF) = Receiver、Center、Fronter用于盯人/补位(单次匹配)- 3辆车
-- 共9辆场上球员 + Goalie = 10辆车
-- Kicker不会被使用9辆车(8场上 + 守门员):
matchStr = "{LA}(S)(MDB)(RC)"
-- {LA} = Leader和Assister(保持匹配)- 2辆车
-- (S) = Special(单次匹配)- 1辆车
-- (MDB) = Middle、Defender、Breaker三个后卫(单次匹配)- 3辆车
-- (RC) = Receiver、Center用于盯人/补位(单次匹配)- 2辆车
-- 共8辆场上球员 + Goalie = 9辆车
-- Fronter和Kicker不会被使用脚本使用范围
此脚本在车辆数为 9-11辆(即大于8辆,小于等于11辆)时启用。车辆数≤8时会使用其他脚本。
重要
matchStr中不会出现重复的角色字符!每个角色(L、A、S、M等)只能对应一辆车。
- ✅ 正确:
{LA}(S)(MDB)(RCF)- 每个字符出现一次 - ❌ 错误:
{LA}(S)(MDB)(RRR)- R出现3次,不可能!
字符与角色、任务的对应关系:
以matchStr = "{LA}(S)(MDB)(RCFK)"(11辆车满配示例,本脚本最大配置)为例:
| matchStr字符 | 角色名 | Play中定义位置 | 任务表索引 | 实际任务 |
|---|---|---|---|---|
L | Leader | Leader | attackTaskTable[1] | 传球/射门 |
A | Assister | Assister | attackTaskTable[2] | 跑位接球 |
S | Special | Special | attackTaskTable[3] | 盯最危险对手 |
M | Middle | Middle | attackTaskTable[4] | 后卫1 |
D | Defender | Defender | attackTaskTable[5] | 后卫2 |
B | Breaker | Breaker | attackTaskTable[6] | 后卫3 |
R | Receiver | Receiver | attackTaskTable[7] | 盯次危险对手 |
C | Center | Center | attackTaskTable[8] | 补位 |
F | Fronter | Fronter | attackTaskTable[9] | 补位 |
K | Kicker | Kicker | attackTaskTable[10] | 补位 |
subStr数组的完整定义
local subStr = {"A","S","M","D","B","R","C","F","K"}这9个字符对应9个可以动态分配的角色(不含Leader和Goalie)。
脚本车辆范围(9-11辆):
- 9辆车:Leader + subStr前7个角色(A,S,M,D,B,R,C)= 8场上 + Goalie
- 10辆车:Leader + subStr前8个角色(A,S,M,D,B,R,C,F)= 9场上 + Goalie
- 11辆车:Leader + subStr全部9个角色 = 10场上 + Goalie
代码中使用subStr数组和curindex来动态构建matchStr:
local subStr = {"A","S","M","D","B","R","C","F","K"}
local curindex = 1
-- 1. 首先处理Leader和Assister(特殊处理)
matchStr = "{LA}" -- 或 "{L}[A]"
table.insert(attackTaskTable, KICK_TASK()()) -- 索引1: Leader任务
table.insert(attackTaskTable, receiverTask()()) -- 索引2: Assister任务
-- 2. Assister后curindex递增,但不添加到matchStr(因为A已在{LA}中)
curindex = curindex+1 -- curindex变成2
-- 3. 添加Special
matchStr = matchStr.."("
table.insert(attackTaskTable, task.wmarking(...)) -- 索引3: Special任务
matchStr = matchStr..subStr[curindex] -- 添加subStr[2]="S"
curindex = curindex+1 -- curindex变成3
matchStr = matchStr..")"
-- 4. 添加3个后卫
matchStr = matchStr.."("
for i=1,backNum do -- backNum=3
table.insert(attackTaskTable, task.wback(backNum,i))
matchStr = matchStr..subStr[curindex]
-- curindex=3时添加"M", =4时添加"D", =5时添加"B"
curindex = curindex+1
end
matchStr = matchStr..")"
-- 5. 继续添加其他角色(盯人、补位等)
-- 每添加一个任务,就从subStr中取下一个字符
-- 结果:matchStr = "{LA}(S)(MDB)(RCF)..."关键点:curindex的作用
curindex用于从subStr数组中顺序取字符- 初始值为1,但首次使用时已经是2(因为Assister已包含在
{LA}中) - 每个角色字符只添加一次,确保matchStr中无重复角色
完整生成示例(8辆车):
-- 任务表生成顺序:
attackTaskTable[1] = KICK_TASK() -- Leader
attackTaskTable[2] = receiverTask() -- Assister (A已在{LA})
attackTaskTable[3] = wmarking(0) -- Special → 添加"S"
attackTaskTable[4] = wback(3,1) -- Middle → 添加"M"
attackTaskTable[5] = wback(3,2) -- Defender → 添加"D"
attackTaskTable[6] = wback(3,3) -- Breaker → 添加"B"
attackTaskTable[7] = wmarking(1) -- Receiver → 添加"R"
attackTaskTable[8] = wdrag(otherPos) -- Center → 添加"C"
-- 最终matchStr取决于场上车辆数(本脚本支持9-11辆):
-- 9辆车(8场上+守门员): matchStr = "{LA}(S)(MDB)(RC)"
-- 10辆车(9场上+守门员): matchStr = "{LA}(S)(MDB)(RCF)"
-- 11辆车(10场上+守门员): matchStr = "{LA}(S)(MDB)(RCFK)"
-- 11辆车满配:
attackTaskTable[1] = KICK_TASK() -- Leader
attackTaskTable[2] = receiverTask() -- Assister (A已在{LA})
attackTaskTable[3] = wmarking(0) -- Special → 添加"S"
attackTaskTable[4] = wback(3,1) -- Middle → 添加"M"
attackTaskTable[5] = wback(3,2) -- Defender → 添加"D"
attackTaskTable[6] = wback(3,3) -- Breaker → 添加"B"
attackTaskTable[7] = wmarking(1) -- Receiver → 添加"R"
attackTaskTable[8] = wdrag(otherPos) -- Center → 添加"C"
attackTaskTable[9] = wdrag(otherPos) -- Fronter → 添加"F"
attackTaskTable[10] = wdrag(otherPos) -- Kicker → 添加"K"
-- matchStr = "{LA}(S)(MDB)(RCFK)"
-- 10个场上角色 + 1个守门员 = 11辆车(标准11v11配置)角色到任务的绑定
gPlayTable.CreatePlay{
["Pass"] = {
Leader = attackTask(1), -- 执行 attackTaskTable[1]
Assister = attackTask(2), -- 执行 attackTaskTable[2]
Special = attackTask(3), -- 执行 attackTaskTable[3]
Middle = attackTask(4), -- 执行 attackTaskTable[4]
...
}
}工作流程:
- 框架根据
matchStr="{LA}(S)(MDB)..."将车号分配给角色名 - 每个角色名通过
attackTask(i)获取对应的任务 attackTask(i)返回attackTaskTable[i],即具体的执行任务
matchStr的三重作用
车号分配:Rocos框架根据matchStr和括号类型,在合适的时机将车号分配到角色名
{LA}→ 脚本加载时分配一次,之后保持不变(MDB)→ 每次状态切换时重新分配[R]→ 每帧都重新分配
阵型检测:
matchStr != lastMatchStr时触发任务表重新生成if matchStr ~= lastMatchStr then lastMatchStr = matchStr needchangestate = true -- 触发状态机重新分配角色 end
实际匹配示例
进攻模式示例
-- 场景:进攻模式,6辆车(1-6号)+ 守门员
matchStr = "{LA}(S)(MDB)"
-- 第一帧(脚本刚加载):
-- {LA}组匹配:1号车→Leader, 2号车→Assister(之后保持)
-- (S)组匹配:3号车→Special(最近的车)
-- (MDB)组匹配:4,5,6号车→Middle/Defender/Breaker(总代价最小)
-- GetBall→Pass状态切换时:
-- {LA}保持不变:仍然是1号Leader, 2号Assister
-- (S)重新匹配:可能变成5号车→Special(因为5号车现在离Special任务点最近)
-- (MDB)重新匹配:4,6,3号车→Middle/Defender/Breaker(重新优化分配)
-- 普通帧(无状态切换):
-- 所有角色保持上次匹配结果,不重新计算防守模式示例
-- 场景:防守模式,6辆车(1-6号)+ 守门员
matchStr = "{L}(A)(MDB)(R)"
-- 注意:这里的A实际上对应Special角色!(因为代码bug或设计问题)
-- 任务表映射:
-- defendTaskTable[1] = KICK_TASK() → Leader(对应matchStr中的L)
-- defendTaskTable[2] = wmarking(0) → Special(对应matchStr中的A)
-- defendTaskTable[3-5] = wback(3,i) → Middle/Defender/Breaker(对应M/D/B)
-- defendTaskTable[6] = wmarking(1) → Receiver(对应R)
-- defendTaskTable[7] = receiverTask() → Assister(但matchStr中没有!)
-- 车号分配结果:
-- 1号车 → Leader
-- 2号车 → Special(执行的是wmarking任务,虽然Play定义中是Assister位置)
-- 3-5号车 → Middle/Defender/Breaker
-- 6号车 → Receiver
-- Assister角色在防守模式下不会被分配车号!4. 状态的切换
匹配的内容讲完了,就该细讲两个状态了,先讲切换的内容吧。
你们直接看这个状态,也可以看出,代码的核心并不在状态内,而是 switch 函数里面的东西,即 ourBallJumpCond()
gPlayTable.CreatePlay{
firstState = "GetBall",
["GetBall"]={
switch = function ()
return ourBallJumpCond() -- 这个
end,
Leader = defendTask(1),
Assister = defendTask(2),
Special = defendTask(3),
Middle = defendTask(4),
Defender = defendTask(5),
Breaker = defendTask(6),
Receiver = defendTask(7),
Center = defendTask(8),
Fronter = defendTask(9),
Kicker = defendTask(10),
Goalie = task.goalie(goaliePassPos()),
match = getMatch
},
···不论是哪个状态, switch 函数均使用 ourBallJumpCond ,所以整套代码,每一帧都会运行这个函数
我们来看这个函数
local ourBallJumpCond = function()
local state = messi:nextState()
local leader = leaderNum()
local receiver = receiverNum()
needchangestate = false
if state == "Pass" then
generateAttackTask()
if matchStr ~= lastMatchStr then
lastMatchStr = matchStr
needchangestate = true
end
if defenceSquence:enemyOrderChangedNew() then
needchangestate = true
end
-- return "Pass"
elseif state == "GetBall" then
generateDefendTask()
if gRoleNum["Leader"] ~= leader and RoleNum["Goalie"] ~= leader then
gRoleNum["Leader"] = leader
needchangestate = true
end
if matchStr ~= lastMatchStr then
lastMatchStr = matchStr
needchangestate = true
end
if defenceSquence:enemyOrderChangedNew() then
needchangestate = true
end
-- return "GetBall"
end
debugEngine:gui_debug_msg(CGeoPoint:new_local(-600,3000), state)
-- debugEngine:gui_debug_msg(CGeoPoint:new_local(-600,3200), laststate)
if laststate ~= state or needchangestate then
laststate = state
return state
end
end初始化
local ourBallJumpCond = function()
local state = messi:nextState()
local leader = leaderNum()
local receiver = receiverNum()
needchangestate = false我们从头开始看,Receiver 字段未使用,不必在意
函数向 Messi 系统要了两个参数,一个是 state ,一个是 Leader 的车号
Messi 的代码在 Medusa/src/Algorithm/messidecition.cpp ,你可以在 Lumina 中找到
从这里你也可以看出,状态的切换其实并非由 ourBallJumpCond 决定,真正决定状态切换的是 MessiDecision 系统, ourBallJumpCond 其实只负责获取信息
Pass 状态 与 Getball 状态
if state == "Pass" then
generateAttackTask()
if matchStr ~= lastMatchStr then
lastMatchStr = matchStr
needchangestate = true
end
if defenceSquence:enemyOrderChangedNew() then
needchangestate = true
end
-- return "Pass"
elseif state == "GetBall" then
generateDefendTask()
if gRoleNum["Leader"] ~= leader and RoleNum["Goalie"] ~= leader then
gRoleNum["Leader"] = leader
needchangestate = true
end
if matchStr ~= lastMatchStr then
lastMatchStr = matchStr
needchangestate = true
end
if defenceSquence:enemyOrderChangedNew() then
needchangestate = true
end
-- return "GetBall"
end从这里的代码,你可以看出以下几点:
函数会根据 Messi 决定的状态来选择是生成 AttackTask 还是 DefendTask
当进攻情况下,如果 Leader 车号发生变化,并不会进行车号的更新,这是因为这时候在进攻关键阶段,车号的变更会导致我们的 Leader 突然发生变化,局势也会因此变化,这会扰乱我们的进攻节奏
当防守情况下,这时候我们要做的不是去射门,而是先把球抢到手。我们又不拿球,这时候 Leader 的更新,对我们有利无害,可以随时更新车号,让我们的战术更加灵活
当 match 字符串发生变化时,状态可能没有变化,我们可能依然在进攻或者防守,但是我方车的角色产生了变化,可能是后卫被调走,也可能是盯防车数增加,各种情况。这时候我方的策略发生了变化,需要重新分配角色与车号。needchangestate 会变为 true ,它会强制 return 一个状态回去,即使状态没有发生变化,也会导致角色分配,[] 与 () 的角色会重新决定角色与车号。
当敌方角色的威胁等级顺序发生了变化时,也需要进行重新角色分配。意思就是,敌方最有威胁的车,或者第几威胁的车改变了,这时候对于我们来说需要进行重新处理了,因此需要更新。
defenceSquence:enemyOrderChangedNew()
defenceSquence:enemyOrderChangedNew() 是调用防守序列对象的方法,用来检查对方球员的威胁顺序是否发生了变化
这个函数监测对方防守阵容的威胁等级排序是否发生变化。当防守队伍中哪些对手变成了更大的威胁时(比如某个对手更接近球或更有进攻机会了),就会触发状态改变,让我们的队伍重新调整防守策略。
5. AttackTask
我们先讲AttackTask ,即 Pass 状态任务的分配
因此我们需要讲的是 generateAttackTask() 函数
5.1 初始化
local generateAttackTask = function()
attackTaskTable = {}
local leader = leaderNum()
local receiver = receiverNum()
local markingindex = 0
local otherindex = 0
local curindex = 1
local backNum = 3
local posNum = 11
local subStr = {"A","S","M","D","B","R","C","F","K"}
attackerAmount = defenceSquence:attackerAmount()这里先定义了一系列参数:
- Leader 车号,从 Messi 获取
- Receiver 车号,即接球车,也从 Messi 获取
- backNum 后卫数量,这里定义默认的后卫数量
- posNum 最大车数
- attackerAmount 敌方在我方半场中,有威胁的车数
5.2 Leader 与 Asisister
table.insert(attackTaskTable,KICK_TASK()())
if leader ~= receiver and player.valid(receiver) and leader ~= gRoleNum["Goalie"] and receiver ~= gRoleNum["Goalie"] then
if gRoleNum["Leader"] ~= leader or gRoleNum["Assister"] ~= receiver then
needchangestate = true
end
gRoleNum["Leader"] = leader
gRoleNum["Assister"] = receiver
matchStr = "{LA}"
else
if gRoleNum["Leader"] ~= leader and leader ~= gRoleNum["Goalie"] then
needchangestate = true
end
gRoleNum["Leader"] = leader
matchStr = "{L}[A]"
end
--receiver
table.insert(attackTaskTable,receiverTask()())
curindex = curindex+1
matchStr = matchStr.."("从这里可以看出这些内容
Leader 任务
Leader 的任务就是 KICK_TASK() ,实现如下
local KICK_TASK = function()
return function()
-- return task.goandTurnKick(getPassPos(),_,getPassVel())
-- return task.zAttackv2(getPassPos(),_,getPassVel())
return task.Crosserover(getPassPos(),_,getPassVel(),_,false)
end
endLeader 就跑一个 Crosserover,这个 skill 是给拿球的车用的,可以拿球,避人,传球
这个第一个传入参数是 要传球传给的目标点,也是接球车所在的位置
第二个参数不使用,是自己的角色,可以不给
第三个参数是 传球的力度,由 Messi提供,Messi会根据距离等信息计算出传球的力度
第四个参数是 flag ,可以不给
第五个参数是 是否进行自动传球,这里由 Messi 决定,因此为 false
Assister 任务
Assister 的任务就是 receiverTask() ,实现如下
local function receiverTask()
return function()
-- if getOurNum() <= 3 and messi:nextState() == "GetBall" then
-- return task.wmarking("Zero",_,getAttackerNum(0))
-- else
return task.goCmuRush(pos.getReceivePos(),player.toBallDir,_,DSS_FLAG)
--end
end
endAssister 的任务现在很简单,跑点就行,因此跑 goCmuRush
跑的目标点由 Messi 提供,他会朝向球,等待接球
match 匹配
if leader ~= receiver and player.valid(receiver) and leader ~= gRoleNum["Goalie"] and receiver ~= gRoleNum["Goalie"] then
if gRoleNum["Leader"] ~= leader or gRoleNum["Assister"] ~= receiver then
needchangestate = true
end
gRoleNum["Leader"] = leader
gRoleNum["Assister"] = receiver
matchStr = "{LA}"
else
if gRoleNum["Leader"] ~= leader and leader ~= gRoleNum["Goalie"] then
needchangestate = true
end
gRoleNum["Leader"] = leader
matchStr = "{L}[A]"
end这里能看出,存在两种情况:
- 已经有明确的分工,均给定车号且车号不重合,这时候 Leader 和 Assister 可以给车号了,并使用 {} ,代表车号定死了,在脚本切换前或 match 中的括号改变前,不会自动匹配车号了
- 仅有 Leader ,没有或无法确定 Assister ,标记为 {L}[A] , Leader 已经给死了,但是 Assister 去用匹配来分配车。
总结
从这里你大概可以明白,Leader 与 Assister 两辆车是一组,Leader 是拿球车,Assister 是接球车,Messi 会根据场上的角色随时变更 Leader 与 Assister 的车号,我方所有进攻车均可以成为 Leader 与 Assister 。
5.3 盯防车 Special
提示
Special 和在后场的多人防守任务不太一样,他是在进攻阶段盯死敌方最危险车辆用的,不让他干扰到我们的传球与射门,不让他拿球。
--danger marking
table.insert(attackTaskTable,task.wmarking("Zero",_,getAttackerNum(0)))
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
matchStr = matchStr..")"我们的场上,肯定是需要存在一辆车,去盯防敌方最危险的车辆,它有可能会去争夺我们的球权,或许是对方的 Leader 。
这辆车就是去盯防敌方 Leader 用的,它会阻碍这辆车拿球的机会,在这辆车前面站着,干扰他的进攻,不让他有可趁之机。
这辆车跑的 skill 是 task.wmarking
"Zero"代表盯防优先级,一般都填 ZerogetAttackerNum(0)代表从 DefenceSquence 获取敌方最危险的车,相当于对方的 Leader 。
5.4 后卫
matchStr = matchStr.."("
if ball.posX() > -1000 and (cond.validNum() < 4) then
backNum = 1
end
for i=1,backNum do
table.insert(attackTaskTable,task.wback(backNum,i))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
end
matchStr = matchStr..")("后卫的默认数量由 backNum 决定的,当没有意外情况时,按这里的情况,会有 3 辆后卫在禁区前防守。
当球的 X 坐标大于 -1000 ,即球并不在我方半场深入,我方没有进攻威胁,如果这时候我们的车被罚下很多,除了 Goalie 剩的车都不到 4 辆了,因此,后卫只会留下一辆,其余的后卫全部去盯防
后卫的车匹配使用 () 进行,即状态改变之前不自动匹配车辆。
后卫使用 task.wback 这个 skill ,第一个参数代表这一组后卫总共的数量,第二个参数代表这是第几个后卫。这组后卫会并排站在一起,形成一道车墙,阻拦敌方的射门意图
5.5 后场多人盯防
--marking
for i=1,attackerAmount-2 do
table.insert(attackTaskTable,task.wmarking("Zero",_,getAttackerNum(i)))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
markingindex = markingindex+1
end
matchStr = matchStr..")("这部分的车辆负责在后场盯防,在我方半场中,可能会对我方造成威胁的车辆。这些敌方车辆可能会接受前场敌方车的传球,然后向我方球门射门,因此我们需要盯住这些车辆
敌方车辆的车号由 defenceSquence:getFreeDefNum(i) 提供
defenceSquence:getFreeDefNum(i)
defenceSquence:getFreeDefNum(i) 的实现在 C++ 层,他维护了一个存储了敌方车号的数组,你可以发送 index 来获取车号。数组内的车号按照威胁程度,依次排列。例如,getFreeDefNum(0) 是威胁最大的。
重要
请务必注意,Lua 的语法中,数组的索引是从 1 开始的,因此在访问 Lua 内声明的数组时,你需要注意索引。
但是在 defenceSquence:getFreeDefNum(i) 这种地方。它的实现在 C++ 层,他是通过 tolua++ 把 C++ 的类打包成 Lua API 进行访问。它并非直接返回数组,而是让你发送索引。这时数组是在 C++ 层的,你要传入的索引号从 0 开始。
请务必小心!!!!!!!!!
多人盯防任务中,执行盯防任务的车数,由 attackerAmount 决定,此参数由 defenceSquence 传递,在初始化阶段完成,代表敌方车辆在我方半场,能对我方造成威胁的车数。
当我方车数充足时,这些车都会被盯防,但是当我方车数不充足时,无法顾及敌方所有威胁车辆。我们会优先盯防最具威胁的几辆车,这是因为数组内的车号是按照威胁程度排序的。
5.6 剩余车辆
--otherpos
for i=0,posNum do
table.insert(attackTaskTable,task.wdrag(pos.getOtherPos(otherindex)))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
otherindex = otherindex+1
end
matchStr = matchStr..")"如果在前面的任务执行完后,依然有剩余车辆,这些车会被安排到指定的位置等待时机。
这些车执行 wdrag 任务,执行任务的位置由 PosModule 决定。
task.wdrag
task.wdrag 这个 Skill ,他接受一个坐标作为传入参数,它会将这个坐标作为自己基本的站位。
跑 task.wdrag 任务的车辆,会在给定的站位等待时机,当没有什么事的时候,它就会在这个位置站着
如果他发现自己被敌方车盯防了,他会开始跑位,试图甩开敌方盯防车,和对方拉扯。
如果他发现球正在被传,他会计算敌方想要接球的车辆,去干扰他们的接球
6. DefendTask
6.1 初始化
local generateDefendTask = function()
defendTaskTable = {}
local leader = leaderNum()
local receiver = receiverNum()
local markingindex = 0
local otherindex = 0
local curindex = 1
local backNum = 3
local posNum = 11
local subStr = {"A","S","M","D","B","R","C","F","K"}
attackerAmount = defenceSquence:attackerAmount()这里先定义了一系列参数:
Leader 车号,从 Messi 获取 Receiver 车号,即接球车,也从 Messi 获取 backNum 后卫数量,这里定义默认的后卫数量 posNum 最大车数 attackerAmount 敌方在我方半场中,有威胁的车数
这部分与 AttackTask 相同。
6.2 Leader
table.insert(defendTaskTable,KICK_TASK()())
--receiver
-- if cond.validNum() - backNum - 1 - attackerAmount -1 > 0 then
-- table.insert(defendTaskTable,receiverTask()())
-- else
-- table.insert(defendTaskTable,task.wmarking("Zero",_,getAttackerNum(markingindex)))
-- matchStr = matchStr..subStr[curindex]
-- markingindex = markingindex+1
-- attackerAmount = attackerAmount-1
-- end
if gRoleNum["Leader"] ~= leader and leader ~= gRoleNum["Goalie"] then
needchangestate = true
end
gRoleNum["Leader"] = leader
matchStr = "{L}("Leader 的任务就是 KICK_TASK() ,实现如下,与 AttackTask 相同。
local KICK_TASK = function()
return function()
-- return task.goandTurnKick(getPassPos(),_,getPassVel())
-- return task.zAttackv2(getPassPos(),_,getPassVel())
return task.Crosserover(getPassPos(),_,getPassVel(),_,false)
end
endLeader 就跑一个 Crosserover,这个 skill 是给拿球的车用的,可以拿球,避人,传球
相关信息
这个第一个传入参数是 要传球传给的目标点,也是接球车所在的位置
第二个参数不使用,是自己的角色,可以不给
第三个参数是 传球的力度,由 Messi 提供,Messi 会根据距离等信息计算出传球的力度
第四个参数是 flag ,可以不给
第五个参数是 是否进行自动传球,这里由 Messi 决定,因此为 false
在这里, Assister 的优先级下降,这时候我们球都没拿到,在有空的时候再安排接球车。
6.3 盯防车
--danger marking
table.insert(defendTaskTable,task.wmarking("Zero",_,getAttackerNum(0)))
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
matchStr = matchStr..")("这部分和进攻阶段的盯防车并无区别,虽然我们现在是防守阶段,但是我们还是需要有人去盯死对方最危险的车的,这部分防守阶段和进攻阶段一致,无论什么时候,对方最危险的车是需要盯死的。
6.4 后卫
--back
if ball.posX() > 0 and (cond.validNum() < 4) then-- or cond.validNum()-4 < attackerAmount-1
backNum = 1
end
for i=1,backNum do
table.insert(defendTaskTable,task.wback(backNum,i))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
end
matchStr = matchStr..")("后卫的部分和进攻状态大差不差,没啥区别。
6.5 多人盯防
--marking
for i=1,attackerAmount-1 do
table.insert(defendTaskTable,task.wmarking("Zero",_,getAttackerNum(i)))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
markingindex = markingindex+1
end
matchStr = matchStr..")("多人盯防任务也和进攻阶段相同,能防住几辆是几辆。
6.6 Receiver
--receiver
table.insert(defendTaskTable,receiverTask()())
-- matchStr = matchStr..subStr[curindex]
-- curindex = curindex+1
matchStr = matchStr..")("这部分就是进攻阶段的 Assister 任务,在防守阶段,我们球都没拿到,没有那么大的必要去安排接球车,只在我方防守任务完成,没有太大的防守压力下,才会去安排接球车。
不过这里 match 字符串的添加被注释掉了,因为这里的分配不会检查是否越过数组边界,可能会导致数组越界的段错误,反正后面的任务也会分配 match 。
6.7 剩余车辆
--otherpos
for i=0,posNum do
table.insert(defendTaskTable,task.wdrag(pos.getOtherPos(otherindex)))
if curindex > 9 then
break
end
matchStr = matchStr..subStr[curindex]
curindex = curindex+1
otherindex = otherindex+1
end
matchStr = matchStr..")"和进攻阶段一样,如果任务分配完了,还能剩下车,那么我们就让他们跑 wdrag 任务待命
2. AttackTask vs DefendTask
生成流程对比
| 步骤 | AttackTask (进攻) | DefendTask (防守) |
|---|---|---|
| 1. Leader任务 | KICK_TASK() - 传球/射门 | KICK_TASK() - 抢球后传球 |
| 2. Assister任务 | receiverTask() - 跑位接球 | 不插入Assister任务 |
| 3. 盯防敌方Leader | wmarking(0) - 盯最危险对手 | wmarking(0) - 盯敌方 Leader |
| 4. 后卫 | wback(3,i) - 3个后卫 | wback(3,i) - 3个后卫 |
| 5. 多人盯防 | attackerAmount-2 人盯防 | attackerAmount-1 人盯防 |
| 6. 接应 | receiverTask() - 接球车 | |
| 7. 其他位置 | wdrag(otherPos) - 补位 | wdrag(otherPos) - 补位 |
4. 车号分配与优先级机制
两层优先级系统
第一层:matchStr决定车号→角色名的分配
-- 假设场上车号为:0, 1, 2, 3, 4, 5, 6, 7, 8, 9 + 守门员
matchStr = "{L}[A](S)(MDB)()(RCFK)"
-- 框架使用匈牙利算法进行二分图匹配:
-- {L} - 保持匹配:Leader在整个脚本运行期间,都不会进行车号的自动匹配,除非 match字符串中 L 的括号变更,或者 Leader 的车号被手动变更。
-- [A] - 实时匹配: 每一帧都进行匹配,系统会在每一帧检查,是否有更优的车辆可以作为 Assister
-- (S) - 单次匹配:状态切换时(switch函数触发 return 时,不必是新状态)重新选择最优车辆执行 Special
-- (MDB)- 单次匹配:状态切换时重新分配 Middle/Defender/Breaker
-- (RCFK) - 单次匹配:状态切换时重新分配 Receiver/Center/Fronter/Kicker
-- 11个角色对应11辆场上车,每个字母对应唯一一辆车匹配算法原理(匈牙利算法):
- 在每个匹配组内,计算每辆车执行每个任务的代价(如距离、角度等)
- 使用二分图匹配找到总代价最小的分配方案
{}组只在脚本切换时计算一次()组在状态跳转(switch返回状态)时重新计算[]组每帧都重新计算
分组的含义:
- 同一对括号内的角色作为一组,整体进行最优匹配
- 例如
(MDB)表示3个后卫角色一起匹配,确保这3辆车执行这3个任务的总代价最小
第二层:角色名→任务的绑定
-- 每个角色名执行对应索引的任务
Leader = attackTask(1) -- 执行 attackTaskTable[1]
Assister = attackTask(2) -- 执行 attackTaskTable[2]
Special = attackTask(3) -- 执行 attackTaskTable[3]
Middle = attackTask(4) -- 执行 attackTaskTable[4]
...完整工作流程示例
满配情况(11辆车:10场上 + 守门员)
-- 步骤1: 生成任务表(10个场上角色)
attackTaskTable = {
[1] = KICK_TASK(), -- Leader: 传球任务
[2] = receiverTask(), -- Assister: 接球任务
[3] = wmarking(0), -- Special: 盯最危险对手
[4] = wback(3,1), -- Middle: 后卫1
[5] = wback(3,2), -- Defender: 后卫2
[6] = wback(3,3), -- Breaker: 后卫3
[7] = wmarking(1), -- Receiver: 盯次危险对手
[8] = wdrag(otherPos), -- Center: 补位
[9] = wdrag(otherPos), -- Fronter: 补位
[10] = wdrag(otherPos), -- Kicker: 补位
}
-- 步骤2: 生成匹配字符串
matchStr = "{LA}(S)(MDB)(RCFK)"
-- 步骤3: 框架根据matchStr分配车号(使用匈牙利算法)
-- {LA}组: 1号车→Leader, 2号车→Assister
-- (S)组: 3号车→Special
-- (MDB)组: 4,5,6号车→Middle/Defender/Breaker
-- (RCFK)组: 7,8,9,10号车→Receiver/Center/Fronter/Kicker
-- 第11辆车固定为Goalie
-- 步骤4: 执行任务
-- 1号车 (Leader) → attackTaskTable[1] = 传球
-- 2号车 (Assister) → attackTaskTable[2] = 接球
-- 3号车 (Special) → attackTaskTable[3] = 盯最危险对手
-- 4号车 (Middle) → attackTaskTable[4] = 后卫1
-- 5号车 (Defender) → attackTaskTable[5] = 后卫2
-- 6号车 (Breaker) → attackTaskTable[6] = 后卫3
-- 7号车 (Receiver) → attackTaskTable[7] = 盯次危险对手
-- 8号车 (Center) → attackTaskTable[8] = 补位
-- 9号车 (Fronter) → attackTaskTable[9] = 补位
-- 10号车 (Kicker) → attackTaskTable[10] = 补位
-- 11号车 (Goalie) → 守门员任务(不在matchStr中)5. 任务类型与传参机制
任务函数对比
| 任务函数 | 参数 | 功能 | 使用场景 |
|---|---|---|---|
task.Crosserover | (目标位置, _, 速度, _, false) | 交叉传球 | Leader传球 |
task.goCmuRush | (接球位置, 朝向, _, 标志) | CMU冲刺接球 | Assister接球 |
task.wmarking | ("Zero", _, 对手函数) | 盯人防守 | 盯防对手 |
task.wback | (后卫总数, 位置索引) | 后卫站位 | 防守后场 |
task.wdrag | (目标位置) | 拖延/占位 | 补位/控场 |
task.goalie | (位置函数) | 守门员 | Goalie专用 |
传参机制详解
1. 闭包传递动态参数
local KICK_TASK = function()
return function() -- 返回闭包
return task.Crosserover(
getPassPos(), -- 函数调用,每次执行时动态获取传球位置
_, -- 占位符(可能是默认角度)
getPassVel(), -- 动态获取传球速度
_,
false
)
end
end为什么要双层函数?
- 外层函数:在脚本加载时定义任务生成器
- 内层闭包:每个周期执行时,实时获取最新的球位置、速度等参数
- 如果直接调用
getPassPos(),会在脚本加载时就固定位置,无法适应球的移动
2. 函数引用传递
function getAttackerNum(i)
return function()
return defenceSquence:getFreeDefNum(i) -- 闭包捕获索引i
end
end
-- 使用时
task.wmarking("Zero", _, getAttackerNum(0))
-- 传入的是函数引用,不是函数结果
-- 每次执行盯人任务时,才调用函数获取当前最危险的对手编号3. 任务表的延迟绑定
local attackTask = function(index)
return function()
return attackTaskTable[index] -- 返回预先生成的任务
end
end
-- 在Play定义中使用
Leader = attackTask(1) -- 第一次调用:返回一个函数
-- 每个周期执行时:再次调用该函数,获取 attackTaskTable[1] 的任务为什么不直接写 Leader = attackTaskTable[1]?
attackTaskTable在每次状态切换或阵型变化时会重新生成- 使用函数引用确保每次都获取最新的任务表内容
- 如果直接赋值,会在脚本加载时就固定任务,无法响应阵型变化
-- 使用 Leader = attackTask(1) -- 第一次调用返回函数 -- 执行时再次调用该函数,获取 attackTaskTable[1]