太诡异了。。战棋的攻击问题（附上工程了） - Project1

class Scene_SLG
#==========================================================================
# ■ 敌人AI计算
#==========================================================================
def start_phaseAI
# 转移到回合 0
@phase = 0
# 生成敌人行动
if @active_battler.is_a?(Game_Enemy)
@active_battler.make_action
if enemy_decide_target(@active_battler) == false
# 寻找目标失败的话，不行动
@active_battler.current_action.kind = 0
@active_battler.current_action.basic = 3
end
end
end
# ◎刷新
def update_phaseAI
# 事件移动
$game_map.events[@active_battler.event_id].move_type_custom
# 镜头跟随
if $game_map.events[@active_battler.event_id].moving?
max_x = ($game_map.width - 20) * 128
max_y = ($game_map.height - 15) * 128
$game_map.display_x = [0, [
$game_map.events[@active_battler.event_id].real_x - CENTER_X, max_x].min].max
$game_map.display_y = [0, [
$game_map.events[@active_battler.event_id].real_y - CENTER_Y, max_y].min].max
return
end
# 开始行动回合
start_phase5
end
#==========================================================================
# ■ 算法
#==========================================================================
#--------------------------------------------------------------------------
# ◎确定目标
#--------------------------------------------------------------------------
def enemy_decide_target(battler)
# 检测视野
check_view_range(battler)
# 无仇恨就放弃行动
if battler.hate_list.compact == []
return false
end
case battler.current_action.kind
# 基本
when 0
# 攻击
if battler.current_action.basic == 0
battler.current_action.kind = 1
skill = $data_skills[battler.skill_of_attack]
battler.current_action.skill_id = skill.id
make_range_and_aoe(skill)
decide_damage_target
end
# 特技
when 1
# 记录
skill = $data_skills[battler.current_action.skill_id]
make_range_and_aoe(skill)
decide_damage_target
# 物品
when 2
# 敌人无物品
return false
end
end
#--------------------------------------------------------------------------
# ◎检测视野，force为true的话强行添加仇恨列表
#--------------------------------------------------------------------------
def check_view_range(battler, force=false)
# 已存在仇恨列表的话，不检测
if battler.hate_list != [] and !force
return
end
# 取得初始位置
ori_grid = Grid.new $game_map.events[battler.event_id].x, $game_map.events[battler.event_id].y
view_grids = get_target_range(ori_grid, battler.view_range)
for grid in view_grids
for actor in @actors
# actor为nil就跳过
next if actor == nil
# 角色在其视野内，不隐身或死亡，对其无仇恨的话
if $game_map.events[actor.event_id].x == grid.x and
$game_map.events[actor.event_id].y == grid.y and
!actor.hp0? and battler.hate_list[actor.event_id] == nil
# 添加到仇恨列表
battler.hate_list[actor.event_id] = 0
end
end
end
end
#--------------------------------------------------------------------------
# ◎仇恨列表排序（仇恨列表理论上支持同时对1000个单位有仇恨）
#--------------------------------------------------------------------------
def sort_hate_list(battler)
# 获得列表
list = battler.hate_list.dup
# 在个位、十位和百位标记位置
for number in 0...list.size
# 不为nil的话，标记
if list[number] != nil
list[number] = list[number] * 1000 + number
end
end
# 排序（由小到大）
list.compact!
list.sort!
list.reverse!
#返回列表
return list
end
#--------------------------------------------------------------------------
# ◎确认敌人目标
#--------------------------------------------------------------------------
def decide_damage_target
battler = @active_battler
# 取得初始位置
ori_grid = Grid.new $game_map.events[battler.event_id].x, $game_map.events[battler.event_id].y
# 取得排好序的仇恨列表
# 第一张是一次行动就能攻击用，第二张是长距离移动用
list1 = sort_hate_list(battler)
list2 = list1.dup
# 计算移动范围
@move_range_grids = get_move_range(ori_grid, battler.move_range)
# 一次行动可及距离
@available_range = battler.current_action.range +
battler.current_action.aoe - 1 + battler.move_range
# 攻击可及距离
@attack_range = battler.current_action.range +
battler.current_action.aoe - 1
# 不用AOE可及距离
@no_aoe_range = battler.current_action.range
# AOE可及距离
@aoe_range = battler.current_action.aoe
# 循环
loop do
# 取得列表排首位的角色
actor_id = list1.shift
# 找不到角色就进行移动处理
if actor_id != nil
# 还原角色ID
actor_id %= 1000
# 不打死人
next if @battlers[actor_id].death
# 取得角色坐标
actor_x = $game_map.events[actor_id].x
actor_y = $game_map.events[actor_id].y
actor_grid = Grid.new(actor_x, actor_y)
# 获得双方距离
@battler_range = (actor_x - ori_grid.x).abs + (actor_y - ori_grid.y).abs
# 一次行动就可以攻击到的话
if @battler_range <= @available_range
# 不用移动就可以攻击到的话
if @battler_range <= @attack_range
# 调用获得行动目标格子
decide_target_grid(ori_grid, actor_grid)
return
end
# 需要移动才攻击到
# 匹配格子
for grid in @move_range_grids
if (actor_x - grid.x).abs + (
actor_y - grid.y).abs <= @attack_range and
@battler_coordinate[grid.x, grid.y] == 0
# 设置移动路线（采用短距离算法）
index = battler.event_id
setup_path(index, grid)
start_event(index)
# 确定目标
decide_target_grid(grid, actor_grid)
return
end
end
end
# 找不到一次行动就可以攻击到的目标的话，移动
else
# 初始化对比路径
available_paths = []
# 移动到最近的战斗者
for actor_id in list2
next if actor_id == nil
# 还原角色ID
actor_id %= 1000
# 取得角色坐标
actor_x = $game_map.events[actor_id].x
actor_y = $game_map.events[actor_id].y
actor_grid = Grid.new(actor_x, actor_y)
# 采用长距离移动算法
index = battler.event_id
$path_finding.setup_event(index)
if $path_finding.add_paths_event(index, actor_grid.x, actor_grid.y,
[$game_map.events[actor_id]]) != false
available_paths.push $game_map.events[index].path.list
end
end
# 寻路失败就返回false
return false if available_paths == []
# 按照移动路径远近排序
available_paths.sort! do |a, b|
a.size <=> b.size
end
# 清空路径
$game_map.events[index].path.list = []
# 代入最短的路径（限制步数）
for step in 0...battler.move_range
$game_map.events[index].path.list.push(available_paths[0][step])
end
# 防止战斗者重叠
loop do
# 路径上所有格子都被阻挡的话就放弃移动
break if $game_map.events[index].path.list == []
end_grid = get_path_end_grid(ori_grid, $game_map.events[index].path.list)
if @battler_coordinate[end_grid.x, end_grid.y] == 0
# 开始行动
$path_finding.start_event(index)
# 休息
battler.current_action.kind = 0
battler.current_action.basic = 3
return
end
# 删除最后一步，继续检查
$game_map.events[index].path.list.pop
end
# 休息
battler.current_action.kind = 0
battler.current_action.basic = 3
return
end
end
end
#--------------------------------------------------------------------------
# ◎获得行动目标格子
#--------------------------------------------------------------------------
def decide_target_grid(start_grid, target_grid)
# 在射程内（不用AOE）的话，直接以角色的格子为目标
if @battler_range <= @no_aoe_range
@active_battler.current_action.target_grid = target_grid
return
# 需要AOE范围的话
else
# 从目标开始铺AOE范围
aoe_grids = get_target_aoe(target_grid, @aoe_range)
# 从自己开始铺射程范围
range_grids = get_target_range(start_grid, @no_aoe_range)
# 匹配格子
for grid in range_grids
if grid.compare_grids(aoe_grids) == true
@active_battler.current_action.target_grid = grid
return
end
end
end
end
end

复制代码