求一个SLG,大十字，米字,直线 等范围的算法,有知道么

sjzzjl

详细点哦

叶子

1. #==============================================================================
   
2. # ■ Grids
   
3. #------------------------------------------------------------------------------
   
4. # 　获得各种范围的模块。
   
5. #==============================================================================
   
6. 
   
7. module Grids
   
8.   #==========================================================================
   
9.   # ■ 目标范围算法
   
10.   #==========================================================================
    
11.   # 图例解析
    
12.   # ■ 范围格子
    
13.   # ● 范围格子&确定格子
    
14.   # ○ 确定格子
    
15.   # ◎ 战斗者位置
    
16.   #--------------------------------------------------------------------------
    
17.   # ● 获得菱形范围
    
18.   # range为2的范围
    
19.   # □□□□□
    
20.   # □□■□□
    
21.   # □■●■□
    
22.   # □□■□□
    
23.   # □□□□□
    
24.   #--------------------------------------------------------------------------
    
25.   def self.get_diamond_grids(grid, range)
    
26.     # 射程小于等于0的话，返回空数组
    
27.     if range <= 0
    
28.       return []
    
29.     end
    
30.     # 初始化范围格集合
    
31.     available_grids = get_squar_grids(grid, range)
    
32.     for each_grid in available_grids.clone
    
33.       if each_grid.distance(grid) >= range
    
34.         available_grids.delete(each_grid)
    
35.       end
    
36.     end
    
37.     # 添加菱形上半部分及平行部分
    
38.     #for line in 1..(range)
    
39.     #  width = line * 2 - 1
    
40.     #  grid_y = grid.y + range - line + 1
    
41.     #  for grid_x in (grid.x - line + 1)..(grid.x + line - 1)
    
42.     #    # 防止生成地图外格子
    
43.     #    next if !$game_map.valid?(grid_x, grid_y)
    
44.     #    distance = (grid.x - grid_x).abs + (grid.y - grid_y).abs
    
45.     #    available_grids.push Grid.new(grid_x, grid_y, distance)
    
46.     #  end
    
47.     #end
    
48.     # 添加菱形下半部分
    
49.     #for line in 1..(range - 1)
    
50.     #  width = line * 2 - 1
    
51.     #  grid_y = grid.y - (range - line + 1)
    
52.     #  for grid_x in (grid.x - line + 1)..(grid.x + line - 1)
    
53.     #    # 防止生成地图外格子
    
54.     #    next if !$game_map.valid?(grid_x, grid_y)
    
55.     #    distance = (grid.x - grid_x).abs + (grid.y - grid_y).abs
    
56.     #    available_grids.push Grid.new(grid_x, grid_y, distance)
    
57.     #  end
    
58.     #end
    
59.     return available_grids
    
60.   end
    
61.   #--------------------------------------------------------------------------
    
62.   # ● 获得正方形范围
    
63.   # range为2的范围
    
64.   # □□□□□
    
65.   # □■■■□
    
66.   # □■●■□
    
67.   # □■■■□
    
68.   # □□□□□
    
69.   #--------------------------------------------------------------------------
    
70.   def self.get_squar_grids(grid, range, valid = true)
    
71.     # 射程小于等于0的话，返回空数组
    
72.     if range <= 0
    
73.       return []
    
74.     end
    
75.     available_grids = []
    
76.     for x in (grid.x - range)..(grid.x + range)
    
77.       for y in (grid.y - range)..(grid.y + range)
    
78.         # 防止生成地图外格子
    
79.         if !$game_map.valid?(grid.x, grid.y) and valid
    
80.           next
    
81.         end
    
82.         distance = (grid.x - x).abs + (grid.y - y).abs
    
83.         available_grids.push Grid.new(x, y, distance)
    
84.       end
    
85.     end
    
86.     return available_grids
    
87.   end
    
88.   #--------------------------------------------------------------------------
    
89.   # ● 获得直线范围
    
90.   # range为2的范围
    
91.   # □□□□
    
92.   # ■●◎□
    
93.   # □□□□
    
94.   #--------------------------------------------------------------------------
    
95.   def self.get_linear_grids(battler_grid, target_grid, range)
    
96.     # 射程小于等于0的话，返回空数组
    
97.     if range <= 0 or target_grid.distance(battler_grid) == 0
    
98.       return []
    
99.     end
    
100.     # 初始化范围格集合
     
101.     available_grids = []
     
102.     # 获得战斗者格子与目标格子的直线函数
     
103.     funtion = Math.get_2_grids_function(battler_grid, target_grid)
     
104.     a = funtion[0]
     
105.     b = funtion[1]
     
106.     c = funtion[2]
     
107.     # 取得正方形范围
     
108.     squar_grids = self.get_squar_grids(target_grid, range, false)
     
109.     # 排序
     
110.     squar_grids = self.sort_grids(squar_grids)
     
111.     # 循环正方形范围，如果直线过格子，并且格子不和战斗者格子在同一方向的话，添加
     
112.     number = 0
     
113.     for grid in squar_grids
     
114.       # 只添加range个格子
     
115.       if number >= range
     
116.         break
     
117.       end
     
118.       if Math.overlap?(a, b, c, grid) and !Math.grids_same_side?(target_grid, battler_grid, grid)
     
119.         number += 1
     
120.         if $game_map.valid?(grid.x, grid.y)
     
121.           available_grids.push(grid)
     
122.         end
     
123.       end
     
124.     end
     
125.     return available_grids
     
126.   end
     
127.   #--------------------------------------------------------------------------
     
128.   # ● 获得横线范围
     
129.   # range为2的范围
     
130.   # □□□□□
     
131.   # □■●■□
     
132.   # □□◎□□
     
133.   # □□□□□
     
134.   #--------------------------------------------------------------------------
     
135.   def self.get_transverse_grids(battler_grid, target_grid, range)
     
136.     # 射程小于等于0的话，返回空数组
     
137.     if range <= 0 or target_grid.distance(battler_grid) == 0
     
138.       return []
     
139.     end
     
140.     # 初始化范围格集合
     
141.     available_grids = []
     
142.     # 获得战斗者格子与目标格子的直线函数
     
143.     funtion = Math.get_2_grids_function(battler_grid, target_grid)
     
144.     a = funtion[0]
     
145.     b = funtion[1]
     
146.     c = funtion[2]
     
147.     # 取得直线过目标格子的垂线
     
148.     funtion_90 = Math.get_90_linear(a, b, c, target_grid.center_x, target_grid.center_y)
     
149.     a = funtion_90[0]
     
150.     b = funtion_90[1]
     
151.     c = funtion_90[2]
     
152.     # 取得正方形范围
     
153.     squar_grids = self.get_squar_grids(target_grid, range, false)
     
154.     # 排序
     
155.     squar_grids = self.sort_grids(squar_grids)
     
156.     # 循环正方形范围，如果直线过格子的话，添加
     
157.     number = 0
     
158.     true_range = range * 2 - 1
     
159.     for grid in squar_grids
     
160.       # 只添加range个格子
     
161.       if number >= true_range
     
162.         break
     
163.       end
     
164.       if Math.overlap?(a, b, c, grid)
     
165.         number += 1
     
166.         if $game_map.valid?(grid.x, grid.y)
     
167.           available_grids.push(grid)
     
168.         end
     
169.       end
     
170.     end
     
171.     return available_grids
     
172.   end
     
173.   #--------------------------------------------------------------------------
     
174.   # ● 获得十字范围
     
175.   # range为3的范围
     
176.   # □□□□□□□
     
177.   # □□□■□□□
     
178.   # □□□■□□□
     
179.   # □■■●■■□
     
180.   # □□□■□□□
     
181.   # □□□■□□□
     
182.   # □□□□□□□
     
183.   #--------------------------------------------------------------------------
     
184.   def self.get_cross_grids(target_grid, range)
     
185.     # 射程小于等于0的话，返回空数组
     
186.     if range <= 0
     
187.       return []
     
188.     end
     
189.     # 初始化范围格集合
     
190.     available_grids = []
     
191.     # 添加平行部分
     
192.     for x in (target_grid.x - range + 1)..(target_grid.x + range - 1)
     
193.       # 防止生成地图外格子
     
194.       next if !$game_map.valid?(x, target_grid.y)
     
195.       distance = (x - target_grid.x).abs
     
196.       available_grids.push Grid.new(x, target_grid.y, distance)
     
197.     end
     
198.     # 添加垂直部分
     
199.     for y in (target_grid.y - range + 1)..(target_grid.y + range - 1)
     
200.       # 防止生成地图外格子
     
201.       next if !$game_map.valid?(target_grid.x, y)
     
202.       distance = (y - target_grid.y).abs
     
203.       # 防止重复生成
     
204.       next if distance == 0
     
205.       available_grids.push Grid.new(target_grid.x, y, distance)
     
206.     end
     
207.     return available_grids
     
208.   end
     
209.   #--------------------------------------------------------------------------
     
210.   # ● 获得扇形范围（范围需要比较大才看得出是扇形..）
     
211.   # range为2，正切为1的范围
     
212.   # □□□□□
     
213.   # □■■■□
     
214.   # □□●□□
     
215.   # □□◎□□
     
216.   # □□□□□
     
217.   #--------------------------------------------------------------------------
     
218.   def self.get_fan_grids(battler_grid, target_grid, tan, range)
     
219.     # 射程小于等于0的话，返回空数组
     
220.     if range <= 0 or target_grid.distance(battler_grid) == 0
     
221.       return []
     
222.     end
     
223.     # 取得半径
     
224.     radius = range * Math.cos(Math.atan(tan))
     
225.     # 初始化范围格集合
     
226.     available_grids = []
     
227.     # 获得战斗者格子与目标格子的直线函数
     
228.     funtion = Math.get_2_grids_function(battler_grid, target_grid)
     
229.     a = funtion[0]
     
230.     b = funtion[1]
     
231.     c = funtion[2]
     
232.     # 获得直线与X轴夹角
     
233.     if b == 0
     
234.       slope_radian = Math::PI / 2
     
235.     else
     
236.       slope_radian = Math.atan(-a / b.to_f)
     
237.     end
     
238.     # 获得扇形夹角的二分之一
     
239.     deflective_radian = Math.atan(tan)
     
240.     # 获得扇形靠近Y轴的边
     
241.     radian = slope_radian + deflective_radian
     
242.     slope = Math.tan(radian)
     
243.     side1 = Math.get_linear_function(target_grid.center_x, target_grid.center_y, target_grid.center_x + 1, slope + target_grid.center_y)
     
244.     side1_grids = []
     
245.     # 获得扇形靠近X轴的边
     
246.     radian = slope_radian - deflective_radian
     
247.     slope = Math.tan(radian)
     
248.     side2 = Math.get_linear_function(target_grid.center_x, target_grid.center_y, target_grid.center_x + 1, slope + target_grid.center_y)
     
249.     side2_grids = []
     
250.     # 取得正方形范围
     
251.     squar_grids = self.get_squar_grids(target_grid, radius.ceil)
     
252.     # 排序
     
253.     squar_grids = self.sort_grids(squar_grids)
     
254.     a1 = side1[0]
     
255.     b1 = side1[1]
     
256.     c1 = side1[2]
     
257.     a2 = side2[0]
     
258.     b2 = side2[1]
     
259.     c2 = side2[2]
     
260.     # 循环正方形范围
     
261.     for grid in squar_grids
     
262.       # 超出范围的不添加
     
263.       distance = (grid.center_x - target_grid.center_x) ** 2 + (grid.center_y - target_grid.center_y) ** 2
     
264.       if distance > radius ** 2
     
265.         next
     
266.       end
     
267.       # 只添加同方向格子
     
268.       if Math.grids_same_side?(target_grid, battler_grid, grid)
     
269.         next
     
270.       end
     
271.       # 添加边上的格子
     
272.       if Math.overlap?(a1, b1, c1, grid)
     
273.         side1_grids.push(grid)
     
274.         available_grids.push(grid)
     
275.       elsif Math.overlap?(a2, b2, c2, grid)
     
276.         side2_grids.push(grid)
     
277.         available_grids.push(grid)
     
278.       end
     
279.     end
     
280.     if side1_grids == [] or side2_grids == []
     
281.       return available_grids
     
282.     end
     
283.     # 循环正方形范围
     
284.     for grid in squar_grids
     
285.       # 超出范围的不添加
     
286.       distance = (grid.center_x - target_grid.center_x) ** 2 + (grid.center_y - target_grid.center_y) ** 2
     
287.       if distance > radius ** 2
     
288.         next
     
289.       end
     
290.       # 只添加同方向格子
     
291.       if Math.grids_same_side?(target_grid, battler_grid, grid)
     
292.         next
     
293.       end
     
294.       # 添加中间的格子
     
295.       if Math.same_side?(a1, b1, c1, grid, side2_grids[side2_grids.size-1]) and
     
296.         Math.same_side?(a2, b2, c2, grid, side1_grids[side1_grids.size-1])
     
297.         available_grids.push(grid)
     
298.       end
     
299.     end
     
300.     return available_grids
     
301.   end
     
302.   #--------------------------------------------------------------------------
     
303.   # ● 以grid的point由小到大进行排序
     
304.   #--------------------------------------------------------------------------
     
305.   def self.sort_grids(grids)
     
306.     grids.sort! do |a, b|
     
307.       a.point <=> b.point
     
308.     end
     
309.     return grids
     
310.   end
     
311.   #--------------------------------------------------------------------------
     
312.   # ● 通过通行列表对格子进行遮挡处理
     
313.   #--------------------------------------------------------------------------
     
314.   def self.block_grids(target_grid, grids, map_cost_list)
     
315.     fixed_grids = grids.clone
     
316.     # 循环所有格子
     
317.     for grid in grids
     
318.       # 获得战斗者格子与格子的直线函数
     
319.       funtion = Math.get_2_grids_function(target_grid, grid)
     
320.       a = funtion[0]
     
321.       b = funtion[1]
     
322.       c = funtion[2]
     
323.       delete_flag = false
     
324.       for x in 0...map_cost_list.xsize
     
325.         break if delete_flag == true
     
326.         for y in 0...map_cost_list.ysize
     
327.           break if delete_flag == true
     
328.           if (x - target_grid.x).abs + (y - target_grid.y).abs >
     
329.             (grid.x - target_grid.x).abs + (grid.y - target_grid.y).abs
     
330.             next
     
331.           end
     
332.           if map_cost_list[x, y] == 30000
     
333.             block = Grid.new(x, y)
     
334.             if Math.overlap?(a, b, c, block)
     
335.               if Math.grids_same_side?(target_grid, block, grid)
     
336.                 fixed_grids.delete(grid)
     
337.                 delete_flag = true
     
338.               end
     
339.             end
     
340.           end
     
341.         end
     
342.       end
     
343.     end
     
344.     return fixed_grids
     
345.   end
     
346. end
     

复制代码

1. #==============================================================================
   
2. # ■ Grid
   
3. #------------------------------------------------------------------------------
   
4. # 　SLG地图格子的类。
   
5. #==============================================================================
   
6. 
   
7. class Grid
   
8.   attr_accessor :x                       # x坐标
   
9.   attr_accessor :y                       # y坐标
   
10.   attr_accessor :point                   # 移动用
    
11.   def initialize(x, y, point = 0)
    
12.     @x = x
    
13.     @y = y
    
14.     @point = point
    
15.   end
    
16.   #--------------------------------------------------------------------------
    
17.   # ◎中心坐标，应用到解析计算中
    
18.   #--------------------------------------------------------------------------
    
19.   def center_x
    
20.     return @x + 0.5
    
21.   end
    
22.   def center_y
    
23.     return @y + 0.5
    
24.   end
    
25.   #--------------------------------------------------------------------------
    
26.   # ◎比较坐标集
    
27.   #--------------------------------------------------------------------------
    
28.   def compare_grids(grids)
    
29.     for grid in grids
    
30.       if @x == grid.x and @y == grid.y
    
31.         return grid
    
32.       end
    
33.     end
    
34.     return false
    
35.   end
    
36.   #--------------------------------------------------------------------------
    
37.   # ◎取得距离
    
38.   #--------------------------------------------------------------------------
    
39.   def distance(other_grid_or_x, or_y = 0)
    
40.     if other_grid_or_x.is_a?(Grid)
    
41.       return ((@x - other_grid_or_x.x).abs + (@y - other_grid_or_x.y).abs)
    
42.     else
    
43.       return ((@x - other_grid_or_x).abs + (@y - or_y).abs)
    
44.     end
    
45.   end
    
46. end

复制代码

1. #==============================================================================
   
2. # ■ Math
   
3. #------------------------------------------------------------------------------
   
4. # 　支持浮点运算的模块。
   
5. #==============================================================================
   
6. module Math
   
7.   #--------------------------------------------------------------------------
   
8.   # ● 获得积点（0～1）
   
9.   # number : 目标数字
   
10.   # array : 对比的数组
    
11.   #--------------------------------------------------------------------------
    
12.   def self.rate_number(number, array)
    
13.     return 0.5 if array == [] or number.nil?
    
14.     max = array.max
    
15.     min = array.min
    
16.     return 0.5 if max - min == 0
    
17.     return (number - min)/(max - min)
    
18.   end
    
19.   #--------------------------------------------------------------------------
    
20.   # ● 返回弧度对应的角度
    
21.   #--------------------------------------------------------------------------
    
22.   def self.radian_to_angle(radian)
    
23.     return radian * 180 / PI
    
24.   end
    
25.   #--------------------------------------------------------------------------
    
26.   # ● 返回角度对应的弧度
    
27.   #--------------------------------------------------------------------------
    
28.   def self.angle_to_radian(angle)
    
29.     return angle * PI / 180
    
30.   end
    
31.   #--------------------------------------------------------------------------
    
32.   # ● 返回一次函数（ax+by+c=0）的[a,b,c]
    
33.   # x1, y1, x2, y2 : 直线上两点的坐标
    
34.   #--------------------------------------------------------------------------
    
35.   def self.get_linear_function(x1, y1, x2, y2)
    
36.     a = y2 - y1
    
37.     b = -(x2 - x1)
    
38.     c = y1 * (x2 - x1) - x1 * (y2 - y1)
    
39.     return [a, b, c]
    
40.   end
    
41.   #--------------------------------------------------------------------------
    
42.   # ● 返回过两个格子中心的一次函数（ax+by+c=0）的[a,b,c]
    
43.   # grid1，grid2 : 两个格子
    
44.   #--------------------------------------------------------------------------
    
45.   def self.get_2_grids_function(grid1, grid2)
    
46.     return self.get_linear_function(grid1.center_x, grid1.center_y,
    
47.     grid2.center_x, grid2.center_y)
    
48.   end
    
49.   #--------------------------------------------------------------------------
    
50.   # ● 已知x与一次函数（ax+by+c=0），返回y
    
51.   #--------------------------------------------------------------------------
    
52.   def self.get_y(a, b, c, x)
    
53.     return -(c + a * x) / b.to_f
    
54.   end
    
55.   #--------------------------------------------------------------------------
    
56.   # ● 返回与一次函数（ax+by+c=0）成直角，并且交于x，y的一次函数的[a,b,c]
    
57.   # y不可等于0
    
58.   #--------------------------------------------------------------------------
    
59.   def self.get_90_linear(a, b, c, x, y)
    
60.     if b == 0
    
61.       return self.get_linear_function(x, y, 0, y)
    
62.     elsif a == 0
    
63.       return self.get_linear_function(x, y, x, 0)
    
64.     else
    
65.       a2 = 1
    
66.       b2 = -a / b.to_f
    
67.       c2 = -(a2 * x + b2 * y)
    
68.       return [a2, b2, c2]
    
69.     end
    
70.   end
    
71.   #--------------------------------------------------------------------------
    
72.   # ● 判断一次函数（ax+by+c=0）是否通过grid
    
73.   #--------------------------------------------------------------------------
    
74.   def self.overlap?(a, b, c, grid)
    
75.     if b == 0
    
76.       if -c / a > grid.x and -c / a < grid.x + 1
    
77.         return true
    
78.       end
    
79.     elsif -a / b >= 0
    
80.       y1 = self.get_y(a, b, c, grid.x)
    
81.       y2 = self.get_y(a, b, c, grid.x + 1)
    
82.       if y1 < (grid.y + 1) and y2 > grid.y
    
83.         return true
    
84.       end
    
85.     elsif -a / b < 0
    
86.       y1 = self.get_y(a, b, c, grid.x)
    
87.       y2 = self.get_y(a, b, c, grid.x + 1)
    
88.       if y1 > grid.y and y2 < (grid.y + 1)
    
89.         return true
    
90.       end
    
91.     end
    
92.     return false
    
93.   end
    
94.   #--------------------------------------------------------------------------
    
95.   # ● 判断grid是否与target_grid在一次函数（ax+by+c=0）的同一方向
    
96.   #--------------------------------------------------------------------------
    
97.   def self.same_side?(a, b, c, target_grid, grid)
    
98.     if b < 0.1 and b > -0.1
    
99.       x_intercept = -c / a
    
100.       if target_grid.center_x > x_intercept and grid.center_x > x_intercept
     
101.         return true
     
102.       elsif target_grid.center_x < x_intercept and grid.center_x < x_intercept
     
103.         return true
     
104.       end
     
105.     else
     
106.       if target_grid.center_y > self.get_y(a, b, c, target_grid.center_x) and
     
107.         grid.center_y > self.get_y(a, b, c, grid.center_x)
     
108.         return true
     
109.       elsif target_grid.center_y < self.get_y(a, b, c, target_grid.center_x) and
     
110.         grid.center_y < self.get_y(a, b, c, grid.center_x)
     
111.         return true
     
112.       end
     
113.     end
     
114.     return false
     
115.   end
     
116.   #--------------------------------------------------------------------------
     
117.   # ● 判断grid是否与target_grid在同一方向
     
118.   # 分割线为target_grid与ori_grid的连线的垂线，垂线过ori_grid中心
     
119.   #--------------------------------------------------------------------------
     
120.   def self.grids_same_side?(ori_grid, target_grid, grid)
     
121.     connecting_line = self.get_2_grids_function(ori_grid, target_grid)
     
122.     a = connecting_line[0]
     
123.     b = connecting_line[1]
     
124.     c = connecting_line[2]
     
125.     parting_line = self.get_90_linear(a, b, c, ori_grid.center_x, ori_grid.center_y)
     
126.     a = parting_line[0]
     
127.     b = parting_line[1]
     
128.     c = parting_line[2]
     
129.     return self.same_side?(a, b, c, target_grid, grid)
     
130.   end
     
131.   #--------------------------------------------------------------------------
     
132.   # ● SLG用的数字增加
     
133.   #--------------------------------------------------------------------------
     
134.   def self.plus_number(number1, number2)
     
135.     if number2.is_a?(Float)
     
136.       number1 *= number2
     
137.     else
     
138.       number1 += number2
     
139.     end
     
140.     return number1.round
     
141.   end
     
142.   #--------------------------------------------------------------------------
     
143.   # ● 以(0,0)为中心，逆时针方向旋转angle度，返回旋转后的[x, y]
     
144.   #--------------------------------------------------------------------------
     
145.   def self.rotate(x, y, angle)
     
146.     r1 = angle * PI / 180
     
147.     r2 = r1 - self.atan((x/y.to_f).abs)
     
148.     radius = self.sqrt(x**2 + y**2)
     
149.     x = (radius * self.sin(r2)).round
     
150.     y = (radius * self.cos(r2)).round
     
151.     return [x, y]
     
152.   end
     
153.   #--------------------------------------------------------------------------
     
154.   # ● 获得直线(ax+by+c=0)与半径为r，中心为(0,0)的圆的交点
     
155.   # 返回两个交点的坐标的数组，无解时返回nil
     
156.   #--------------------------------------------------------------------------
     
157.   def self.solve_linear_circle(a, b, c, r)
     
158.     boo = 4*(b*c)**2 + 4*(c**2-a**2*r**2)*(a**2+b**2)
     
159.     if boo < 0
     
160.       return
     
161.     end
     
162.     y1 = (-2*b*c + self.sqrt(boo)) / (2.0 * (a**2 + b**2))
     
163.     if a == 0
     
164.       x1 = 0
     
165.     else
     
166.       x1 = - (b * y1 + c) / a
     
167.     end
     
168.     y2 = (-2*b*c - self.sqrt(boo)) / (2.0 * (a**2 + b**2))
     
169.     if a == 0
     
170.       x2 = 0
     
171.     else
     
172.       x2 = - (b * y2 + c) / a
     
173.     end
     
174.     return [x1, y1, x2, y2]
     
175.   end
     
176. end
     

复制代码

---

系统信息：本贴由楼主认可为正确答案，66RPG感谢您的热情解答～

叶子

http://rpg.blue/viewthread.php?tid=12035