257 lines
8.3 KiB
Lua
257 lines
8.3 KiB
Lua
|
|
local BattleManager = class("BattleManager", BaseModule)
|
|
local BattleConst = GConst.BattleConst
|
|
|
|
BattleManager.SKILL_HERO_CFG = ConfigManager:getConfig("skill_hero")
|
|
|
|
local BATTLE_CONTROLLER_BASE = "app/module/battle/controller/battle_controller"
|
|
|
|
local BATTLE_CONTROLLER = {
|
|
[BattleConst.BATTLE_TYPE.STAGE] = "app/module/battle/controller/battle_controller_stage"
|
|
}
|
|
|
|
function BattleManager:showSelectSkillUI(skillList)
|
|
UIManager:showUI("app/ui/battle/battle_skill_select_ui", {skillList = skillList})
|
|
end
|
|
|
|
function BattleManager:playBattle(battleType, params, returnFunc)
|
|
if self.battleController then -- 同一时间只能有一场战斗
|
|
self:clear()
|
|
end
|
|
self.returnFunc = returnFunc
|
|
UIManager:stopCurrentBGM()
|
|
self:_play(battleType, params)
|
|
end
|
|
|
|
function BattleManager:_play(battleType, params)
|
|
local controllerPath = BATTLE_CONTROLLER[battleType] or BATTLE_CONTROLLER_BASE
|
|
self.battleController = require(controllerPath):create()
|
|
self.battleController:init(params)
|
|
end
|
|
|
|
function BattleManager:onSelectSkill(skillId)
|
|
if not self.battleController then
|
|
return
|
|
end
|
|
|
|
self.battleController:onSelectSkill(skillId)
|
|
end
|
|
|
|
function BattleManager:endBattleAndExit()
|
|
if self.battleController then
|
|
self.battleController:endBattleAndExit()
|
|
else
|
|
self:exitBattle()
|
|
end
|
|
end
|
|
|
|
function BattleManager:exitBattle()
|
|
self:clear()
|
|
if self.returnFunc then
|
|
local returnFunc = self.returnFunc
|
|
self.returnFunc = nil
|
|
returnFunc()
|
|
else -- 没有指定返回则直接去主城
|
|
UIManager:closeAllUI()
|
|
ModuleManager.MaincityManager:showMainCityUI()
|
|
end
|
|
self:performWithDelayGlobal(function()
|
|
Game:garbageCollect()
|
|
end, 0.02)
|
|
end
|
|
|
|
function BattleManager:clear()
|
|
if self.battleController == nil then
|
|
return
|
|
end
|
|
self.battleController:clear()
|
|
self.battleController = nil
|
|
DataManager.BattleData:clear()
|
|
end
|
|
|
|
|
|
----------------------- start 一些公共相关的方法 -----------------------------
|
|
function BattleManager:getPosInfo(posId)
|
|
local posInfo = GConst.BattleConst.GRID_POS[posId]
|
|
if not posInfo then
|
|
local r = self:getPosRC(posId).r
|
|
local c = self:getPosRC(posId).c
|
|
|
|
local offsetC = c - BattleConst.HALF_COLUMN_COUNT
|
|
local offsetR = BattleConst.HALF_ROW_COUNT - r
|
|
local info = {x = offsetC * BattleConst.GRID_STEP_H, y = offsetR * BattleConst.GRID_STEP_H}
|
|
|
|
GConst.BattleConst.GRID_POS[posId] = info
|
|
posInfo = GConst.BattleConst.GRID_POS[posId]
|
|
end
|
|
return posInfo
|
|
end
|
|
|
|
function BattleManager:getElementIcon(elementType)
|
|
local icon = GConst.BattleConst.ELEMENT_ICON[elementType]
|
|
if not icon then
|
|
return GConst.ATLAS_PATH.COMMON, "common_alpha"
|
|
end
|
|
return GConst.ATLAS_PATH.BATTLE, icon
|
|
end
|
|
|
|
function BattleManager:getGridTypeIcon(gridType)
|
|
local icon = GConst.BattleConst.GRID_TYPE_ICON[gridType]
|
|
if not icon then
|
|
return GConst.ATLAS_PATH.COMMON, "common_alpha"
|
|
end
|
|
return GConst.ATLAS_PATH.BATTLE, icon
|
|
end
|
|
|
|
function BattleManager:getPosId(row, column)
|
|
if not BattleConst.RC_2_POS_ID[row] then
|
|
BattleConst.RC_2_POS_ID[row] = {}
|
|
end
|
|
if not BattleConst.RC_2_POS_ID[row][column] then
|
|
local posId
|
|
local rowValue = row * BattleConst.ROW_STEP
|
|
if rowValue >= 0 then
|
|
posId = rowValue + column
|
|
else
|
|
rowValue = rowValue + BattleConst.ROW_STEP
|
|
posId = rowValue - column
|
|
end
|
|
BattleConst.RC_2_POS_ID[row][column] = posId
|
|
end
|
|
return BattleConst.RC_2_POS_ID[row][column]
|
|
end
|
|
|
|
function BattleManager:getFirstLineLastRowPosId(row, column)
|
|
return self:getPosId(1 - row, column)
|
|
end
|
|
|
|
function BattleManager:getAroundPosIdsByList(posId, boardrange, cludePosIdsMap, randomExclusion)
|
|
local posIdInfos = {}
|
|
for _, info in ipairs(boardrange) do
|
|
local list = self:getAroundPosIds(posId, info.type, info.range, cludePosIdsMap, randomExclusion)
|
|
for _, info in ipairs(list) do
|
|
table.insert(posIdInfos, info)
|
|
cludePosIdsMap[info.posId] = nil
|
|
end
|
|
end
|
|
|
|
return posIdInfos
|
|
end
|
|
|
|
function BattleManager:getAroundPosIds(posId, direction, range, cludePosIdsMap, randomExclusion)
|
|
local rc = self:getPosRC(posId)
|
|
local r = rc.r
|
|
local c = rc.c
|
|
local posIdList = {}
|
|
|
|
if direction == BattleConst.BOARD_RANGE_TYPE.RANDOM then
|
|
if cludePosIdsMap then
|
|
local cludePosIds = {}
|
|
for posId, _ in pairs(cludePosIdsMap) do
|
|
if not randomExclusion or not randomExclusion[posId] then
|
|
table.insert(cludePosIds, posId)
|
|
end
|
|
end
|
|
|
|
local count = math.min(#cludePosIds, range)
|
|
for i = 1, count do
|
|
table.insert(posIdList, {posId = cludePosIds[math.random(1, #cludePosIds)], direction = direction})
|
|
end
|
|
end
|
|
elseif direction == BattleConst.BOARD_RANGE_TYPE.UP then
|
|
for i = r - 1, r - range, -1 do
|
|
if i >= 1 then
|
|
table.insert(posIdList, {posId = self:getPosId(i, c), direction = direction})
|
|
end
|
|
end
|
|
elseif direction == BattleConst.BOARD_RANGE_TYPE.DOWN then
|
|
for i = r + 1, r + range do
|
|
if i <= BattleConst.ROW_COUNT then
|
|
table.insert(posIdList, {posId = self:getPosId(i, c), direction = direction})
|
|
end
|
|
end
|
|
elseif direction == BattleConst.BOARD_RANGE_TYPE.LEFT then
|
|
for i = c - 1, c - range, -1 do
|
|
if i >= 1 then
|
|
table.insert(posIdList, {posId = self:getPosId(r, i), direction = direction})
|
|
end
|
|
end
|
|
elseif direction == BattleConst.BOARD_RANGE_TYPE.RIGHT then
|
|
for i = c + 1, c + range do
|
|
if i <= BattleConst.COLUMN_COUNT then
|
|
table.insert(posIdList, {posId = self:getPosId(r, i), direction = direction})
|
|
end
|
|
end
|
|
elseif direction == BattleConst.BOARD_RANGE_TYPE.LEFT_UP then
|
|
for i = c - 1, c - range, -1 do
|
|
if i >= 1 then
|
|
for j = r - 1, r - range, -1 do
|
|
if j >= 1 then
|
|
table.insert(posIdList, {posId = self:getPosId(j, i), direction = direction})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
elseif direction == BattleConst.BOARD_RANGE_TYPE.LEFT_DOWN then
|
|
for i = c - 1, c - range, -1 do
|
|
if i >= 1 then
|
|
for j = r + 1, r + range do
|
|
if j <= BattleConst.ROW_COUNT then
|
|
table.insert(posIdList, {posId = self:getPosId(j, i), direction = direction})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
elseif direction == BattleConst.BOARD_RANGE_TYPE.RIGHT_UP then
|
|
for i = c + 1, c + range do
|
|
if i <= BattleConst.COLUMN_COUNT then
|
|
for j = r - 1, r - range, -1 do
|
|
if j >= 1 then
|
|
table.insert(posIdList, {posId = self:getPosId(j, i), direction = direction})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
elseif direction == BattleConst.BOARD_RANGE_TYPE.RIGHT_DOWN then
|
|
for i = c + 1, c + range do
|
|
if i <= BattleConst.COLUMN_COUNT then
|
|
for j = r + 1, r + range do
|
|
if j <= BattleConst.ROW_COUNT then
|
|
table.insert(posIdList, {posId = self:getPosId(j, i), direction = direction})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if cludePosIdsMap then
|
|
local newList = {}
|
|
for _, info in ipairs(posIdList) do
|
|
if cludePosIdsMap[info.posId] then
|
|
table.insert(newList, info)
|
|
end
|
|
end
|
|
return newList
|
|
else
|
|
return posIdList
|
|
end
|
|
end
|
|
|
|
function BattleManager:getPosRC(posId)
|
|
if not BattleConst.POS_ID_2_RC[posId] then
|
|
local r = posId // BattleConst.ROW_STEP
|
|
local c
|
|
if r <= 0 then
|
|
local adsPosId = math.abs(posId)
|
|
c = adsPosId % BattleConst.ROW_STEP
|
|
else
|
|
c = posId % BattleConst.ROW_STEP
|
|
end
|
|
BattleConst.POS_ID_2_RC[posId] = {r = r , c = c}
|
|
end
|
|
return BattleConst.POS_ID_2_RC[posId]
|
|
end
|
|
|
|
----------------------- end 一些公共相关的方法 -----------------------------
|
|
|
|
return BattleManager |