637 lines
19 KiB
Ruby
637 lines
19 KiB
Ruby
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
# - Pathfinding script by Karanum -
|
|
#----------------------------------------------------------------------------
|
|
# This pathfinding script is based off a simplified version of Dijkstra's
|
|
# algorithm. It's mainly made for calculating paths over small distances,
|
|
# but also provides some methods for longer calculations.
|
|
#
|
|
# It adds 4 different methods for calculating the path and 1 method to check
|
|
# whether an event is pathfinding or not.
|
|
# For all of these methods, the x and y are the end coordinates and the id is
|
|
# the id of the event that has to run the pathfinding method. When left out, the
|
|
# id will always default to 0. **
|
|
# Setting through? allows you to change the pathfinding event's passability.
|
|
# This setting defaults to true if you don't set it.
|
|
#
|
|
#
|
|
# - walk_to_straight( x, y, id, through? )
|
|
# This performs simple pathfinding, using only a part of the map.
|
|
# It can't find long detours, but it's the least expensive method.
|
|
# This should be used for basic events that don't require advanced
|
|
# pathfinding.
|
|
#
|
|
# - walk_to( x, y, id, through? )
|
|
# This is the most basic form of the pathfinding algorithm, although it
|
|
# can lag when using large maps or when there is no path to the endpoint.
|
|
# This is the most balanced pathfinding method, able to find paths of up
|
|
# to a 1000 tiles.
|
|
#
|
|
# - walk_to_short( x, y, id, through? )
|
|
# Basically a lesser version of the walk_to method.
|
|
# It can find paths of up to a 100 tiles and is best for larger maps.
|
|
#
|
|
# - walk_to_long( x, y, max_steps, id, through? )
|
|
# This method lets you specify the maximum amount of tiles the path can
|
|
# be, but will take a while to calculate the path. This method is best
|
|
# for pathfinding over long distances, although it takes the longest.
|
|
# This method will only lag the calling event, not your entire game.
|
|
#
|
|
# - pathfinding?( id )
|
|
# This method returns true when the specified event is currently going
|
|
# through one of the above methods. Otherwise it returns false.
|
|
#
|
|
#
|
|
# ** NOTE: As event id, you can use 0 for 'This Event' and -1 for 'Player'
|
|
#
|
|
# Don't change anything past this point if you don't know what you're doing.
|
|
# It can make your game crash when you try to call one of the methods.
|
|
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
=begin
|
|
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
# - Game_Character -
|
|
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
class Game_Character
|
|
attr_accessor :target_PF_x
|
|
attr_accessor :target_PF_y
|
|
attr_reader :path_through
|
|
attr_accessor :pathfinding
|
|
attr_reader :distance_map
|
|
|
|
#--------------------------------------------------------------------------
|
|
# Game_CharacterBase's update override
|
|
# May cause incompatibility with other scripts that also override this
|
|
#--------------------------------------------------------------------------
|
|
|
|
#--------------------------------------------------------------------------
|
|
# Update pathfinding movement
|
|
#--------------------------------------------------------------------------
|
|
def movePathfinding(character)
|
|
if !@distance_map
|
|
return move_toward_character(character)
|
|
end
|
|
|
|
if (@x == @target_PF_x) and (@y == @target_PF_y)
|
|
#puts "[Pathfinding] Pathfinding completed"
|
|
#@through = false if @path_through
|
|
@pathfinding = false
|
|
return move_toward_character(character)
|
|
|
|
end
|
|
|
|
next_dir = find_next_tag(@distance_map, @x, @y)
|
|
if next_dir == 0
|
|
#puts "[Pathfinding] Could not find path to endpoint"
|
|
#puts "[Pathfinding] If a path exists, try increasing the amount of iterations"
|
|
@pathfinding = false
|
|
return move_toward_characterRNG(character)
|
|
end
|
|
move_straight(next_dir)
|
|
end
|
|
|
|
def movePathfindingXY
|
|
if !@distance_map
|
|
return @pathfinding = false
|
|
end
|
|
|
|
if (@x == @target_PF_x) and (@y == @target_PF_y)
|
|
#puts "[Pathfinding] Pathfinding completed"
|
|
#@through = false if @path_through
|
|
@pathfinding = false
|
|
return @pathfinding = false
|
|
|
|
end
|
|
|
|
next_dir = find_next_tag(@distance_map, @x, @y)
|
|
if next_dir == 0
|
|
#puts "[Pathfinding] Could not find path to endpoint"
|
|
#puts "[Pathfinding] If a path exists, try increasing the amount of iterations"
|
|
@pathfinding = false
|
|
return @pathfinding = false
|
|
end
|
|
move_straight(next_dir)
|
|
end
|
|
|
|
#--------------------------------------------------------------------------
|
|
# Check if currently pathfinding
|
|
#--------------------------------------------------------------------------
|
|
def pathfinding?
|
|
if @pathfinding
|
|
return @pathfinding
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
#--------------------------------------------------------------------------
|
|
# Obtain array with distance map from $game_map
|
|
#--------------------------------------------------------------------------
|
|
def createPath(x, y, iterations=25, long_mode=false, short_mode=false, passthrough=@through)
|
|
#puts "[Pathfinding] Starting pathfinding"
|
|
@pathfinding = true
|
|
@path_through = passthrough
|
|
|
|
@target_PF_x = x
|
|
@target_PF_y = y
|
|
|
|
@distance_map = $game_map.find_path(self, x, y, iterations, long_mode, short_mode)
|
|
#puts "[Pathfinding] Distance map generated"
|
|
end
|
|
|
|
#--------------------------------------------------------------------------
|
|
# Find next tile to walk to
|
|
#--------------------------------------------------------------------------
|
|
def find_next_tag(map, x, y)
|
|
current_tag = map[y][x]
|
|
if(current_tag == -1)
|
|
return 0
|
|
end
|
|
|
|
if y != (map.length - 1)
|
|
if map[y+1][x] == current_tag - 1
|
|
return 2
|
|
end
|
|
end
|
|
|
|
if x != 0
|
|
if map[y][x-1] == current_tag - 1
|
|
return 4
|
|
end
|
|
end
|
|
|
|
if y != 0
|
|
if map[y-1][x] == current_tag - 1
|
|
return 8
|
|
end
|
|
end
|
|
|
|
if x != (map[y].length - 1)
|
|
if map[y][x+1] == current_tag - 1
|
|
return 6
|
|
end
|
|
end
|
|
|
|
return 0
|
|
|
|
end
|
|
end
|
|
|
|
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
# - Game_Map -
|
|
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
class Game_Map
|
|
|
|
def get_event_passable(x,y) #test
|
|
evs=events_xy(x,y)
|
|
return true if evs.size==0
|
|
return false if !evs[0].through && evs[0].priority_type == 1
|
|
true
|
|
end
|
|
def passable_pathfinding?(x, y, d)
|
|
return false if !get_event_passable(x,y)
|
|
check_passage(x, y, (1 << (d / 2 - 1)) & 0x0f)
|
|
end
|
|
#--------------------------------------------------------------------------
|
|
# Check adjacent tiles for passability
|
|
#--------------------------------------------------------------------------
|
|
def check_adjacent_panels(x, y)
|
|
adjacent_panels = Array.new(4, false)
|
|
if y != (height - 1)
|
|
if passable_pathfinding?(x, y, 2) and passable_pathfinding?(x, y+1, 8) #Down
|
|
adjacent_panels[0] = true
|
|
end
|
|
end
|
|
|
|
if y != 0
|
|
if passable_pathfinding?(x, y, 8) and passable_pathfinding?(x, y-1, 2) #Up
|
|
adjacent_panels[2] = true
|
|
end
|
|
end
|
|
|
|
if x != (width - 1)
|
|
if passable_pathfinding?(x, y, 6) and passable_pathfinding?(x+1, y, 4) #Right
|
|
adjacent_panels[3] = true
|
|
end
|
|
end
|
|
|
|
if x != 0
|
|
if passable_pathfinding?(x, y, 4) and passable_pathfinding?(x-1, y, 6) #Left
|
|
adjacent_panels[1] = true
|
|
end
|
|
end
|
|
return adjacent_panels
|
|
end
|
|
|
|
#--------------------------------------------------------------------------
|
|
# Create an array with a distance map to the endpoint
|
|
#--------------------------------------------------------------------------
|
|
def find_path(event, x, y, iterations=1000, long_mode=false, short_mode=false)
|
|
map_array = Array.new(height) { Array.new(width, -1) }
|
|
map_array[y][x] = 0
|
|
current_tag = 0
|
|
current_iteration = 0
|
|
low_x = 0
|
|
low_y = 0
|
|
high_x = width - 1
|
|
high_y = height - 1
|
|
if short_mode
|
|
low_x = [event.x, x].min - 2
|
|
low_y = [event.y, y].min - 2
|
|
high_x = [event.x, x].max + 2
|
|
high_y = [event.y, y].max + 2
|
|
end
|
|
iterations.times do
|
|
current_iteration = current_iteration + 1
|
|
for map_y in (low_y..high_y)
|
|
for map_x in (low_x..high_x)
|
|
if map_array[map_y][map_x] == current_tag
|
|
adjacent_panels = check_adjacent_panels(map_x, map_y)
|
|
if adjacent_panels[0]
|
|
if map_array[map_y+1][map_x] == -1
|
|
map_array[map_y+1][map_x] = current_tag + 1
|
|
end
|
|
end
|
|
if adjacent_panels[1]
|
|
if map_array[map_y][map_x-1] == -1
|
|
map_array[map_y][map_x-1] = current_tag + 1
|
|
end
|
|
end
|
|
if adjacent_panels[2]
|
|
if map_array[map_y-1][map_x] == -1
|
|
map_array[map_y-1][map_x] = current_tag + 1
|
|
end
|
|
end
|
|
if adjacent_panels[3]
|
|
if map_array[map_y][map_x+1] == -1
|
|
map_array[map_y][map_x+1] = current_tag + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
current_tag = current_tag + 1
|
|
if map_array[event.y][event.x] != -1
|
|
return map_array
|
|
end
|
|
if (current_iteration % 20 == 0) and long_mode
|
|
Fiber.yield
|
|
end
|
|
end
|
|
return map_array
|
|
end
|
|
end
|
|
|
|
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
# - Game_Interpreter -
|
|
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
# Changes:
|
|
# - Added walk_to(x, y, id)
|
|
# - Added walk_to_short(x, y, id)
|
|
# - Added walk_to_long(x, y, iterations, id)
|
|
# - Added walk_to_straight(x, y, id)
|
|
# - Added pathfinding?(id)
|
|
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
class Game_Interpreter
|
|
def walk_to(x, y, id=0, passthrough=true)
|
|
character = get_character(id)
|
|
character.walk_to(x, y, 1000, false, false, passthrough)
|
|
end
|
|
|
|
def walk_to_short(x, y, id=0, passthrough=true)
|
|
character = get_character(id)
|
|
character.walk_to(x, y, 100, false, false, passthrough)
|
|
end
|
|
|
|
def walk_to_long(x, y, iterations, id=0, passthrough=true)
|
|
character = get_character(id)
|
|
character.walk_to(x, y, iterations, true, false, passthrough)
|
|
end
|
|
|
|
def walk_to_straight(x, y, id=0, passthrough=true)
|
|
character = get_character(id)
|
|
character.walk_to(x, y, 1000, false, true, passthrough)
|
|
end
|
|
|
|
def pathfinding?(id=0)
|
|
character = get_character(id)
|
|
return character.pathfinding?
|
|
end
|
|
end
|
|
=end
|
|
|
|
|
|
|
|
class Game_Character
|
|
attr_accessor :target_PF_x, :target_PF_y, :pathfinding
|
|
attr_reader :path_through, :distance_map
|
|
|
|
#--------------------------------------------------------------------------
|
|
# Main pathfinding movement update
|
|
#--------------------------------------------------------------------------
|
|
def movePathfinding(character = nil)
|
|
return finish_pathfinding(character) unless @distance_map
|
|
return finish_pathfinding(character) if at_target?
|
|
|
|
next_dir = find_next_tag(@distance_map, @x, @y)
|
|
return fail_pathfinding(character) if next_dir == 0
|
|
|
|
move_straight(next_dir)
|
|
end
|
|
|
|
def movePathfindingXY
|
|
movePathfinding(nil)
|
|
end
|
|
|
|
def pathfinding?
|
|
!!@pathfinding
|
|
end
|
|
|
|
def createPath(x, y, iterations = 25, long_mode = false, short_mode = false, passthrough = @through)
|
|
@pathfinding = true
|
|
@path_through = passthrough
|
|
@target_PF_x, @target_PF_y = x, y
|
|
@distance_map = $game_map.find_path(self, x, y, iterations, long_mode, short_mode)
|
|
end
|
|
|
|
#--------------------------------------------------------------------------
|
|
# Check if at destination
|
|
#--------------------------------------------------------------------------
|
|
def at_target?
|
|
@x == @target_PF_x && @y == @target_PF_y
|
|
end
|
|
|
|
#--------------------------------------------------------------------------
|
|
# Handle pathfinding completion
|
|
#--------------------------------------------------------------------------
|
|
def finish_pathfinding(character)
|
|
@pathfinding = false
|
|
character ? move_toward_character(character) : false
|
|
end
|
|
|
|
#--------------------------------------------------------------------------
|
|
# Handle pathfinding failure
|
|
#--------------------------------------------------------------------------
|
|
def fail_pathfinding(character)
|
|
@pathfinding = false
|
|
character ? move_toward_characterRNG(character) : false
|
|
end
|
|
|
|
#--------------------------------------------------------------------------
|
|
# Determine next direction from distance map
|
|
#--------------------------------------------------------------------------
|
|
def find_next_tag(map, x, y)
|
|
return 0 if map[y][x] == -1
|
|
|
|
{
|
|
2 => [x, y + 1],
|
|
4 => [x - 1, y],
|
|
8 => [x, y - 1],
|
|
6 => [x + 1, y]
|
|
}.each do |dir, (nx, ny)|
|
|
next unless ny.between?(0, map.size - 1) && nx.between?(0, map[0].size - 1)
|
|
return dir if map[ny][nx] == map[y][x] - 1
|
|
end
|
|
|
|
0
|
|
end
|
|
end
|
|
|
|
|
|
|
|
class Game_Map
|
|
def get_event_passable(x, y)
|
|
evs = events_xy(x, y)
|
|
return true if evs.empty?
|
|
return false unless evs[0].through || evs[0].priority_type != 1
|
|
true
|
|
end
|
|
|
|
def passable_pathfinding?(x, y, d)
|
|
return false unless get_event_passable(x, y)
|
|
check_passage(x, y, (1 << (d / 2 - 1)) & 0x0f)
|
|
end
|
|
|
|
def check_adjacent_panels(x, y)
|
|
[
|
|
y < height - 1 && passable_pathfinding?(x, y, 2) && passable_pathfinding?(x, y + 1, 8), # Down
|
|
x > 0 && passable_pathfinding?(x, y, 4) && passable_pathfinding?(x - 1, y, 6), # Left
|
|
y > 0 && passable_pathfinding?(x, y, 8) && passable_pathfinding?(x, y - 1, 2), # Up
|
|
x < width - 1 && passable_pathfinding?(x, y, 6) && passable_pathfinding?(x + 1, y, 4) # Right
|
|
]
|
|
end
|
|
|
|
def find_path(event, x, y, iterations = 1000, long_mode = false, short_mode = false)
|
|
map_array = Array.new(height) { Array.new(width, -1) }
|
|
map_array[y][x] = 0
|
|
current_tag = 0
|
|
low_x, low_y = 0, 0
|
|
high_x, high_y = width - 1, height - 1
|
|
if short_mode
|
|
low_x = [event.x, x].min - 2
|
|
low_y = [event.y, y].min - 2
|
|
high_x = [event.x, x].max + 2
|
|
high_y = [event.y, y].max + 2
|
|
end
|
|
iterations.times do |i|
|
|
for map_y in low_y..high_y
|
|
for map_x in low_x..high_x
|
|
next unless map_array[map_y][map_x] == current_tag
|
|
check_adjacent_panels(map_x, map_y).each_with_index do |pass, index|
|
|
next unless pass
|
|
dx, dy = [[0,1],[ -1,0],[0,-1],[1,0]][index]
|
|
nx, ny = map_x + dx, map_y + dy
|
|
map_array[ny][nx] = current_tag + 1 if map_array[ny][nx] == -1
|
|
end
|
|
end
|
|
end
|
|
return map_array if map_array[event.y][event.x] != -1
|
|
Fiber.yield if long_mode && (i % 20 == 0)
|
|
current_tag += 1
|
|
end
|
|
map_array
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
##########################################################################
|
|
|
|
|
|
|
|
|
|
|
|
def passable_pathfinding?(x, y, d)
|
|
return false unless get_event_passable(x, y)
|
|
bitflag = (1 << (d / 2 - 1)) & 0x0f
|
|
check_passage(x, y, bitflag)
|
|
end
|
|
def get_event_passable(x, y)
|
|
evs = events_xy(x, y)
|
|
return true if evs.empty?
|
|
return false unless evs[0].through || evs[0].priority_type != 1
|
|
true
|
|
end
|
|
def check_adjacent_panels(x, y)
|
|
[
|
|
y < height - 1 && passable_pathfinding?(x, y, 2) && passable_pathfinding?(x, y + 1, 8), # Down
|
|
x > 0 && passable_pathfinding?(x, y, 4) && passable_pathfinding?(x - 1, y, 6), # Left
|
|
y > 0 && passable_pathfinding?(x, y, 8) && passable_pathfinding?(x, y - 1, 2), # Up
|
|
x < width - 1 && passable_pathfinding?(x, y, 6) && passable_pathfinding?(x + 1, y, 4) # Right
|
|
]
|
|
end
|
|
def find_path(event, x, y, iterations = 1000, long_mode = false, short_mode = false)
|
|
map_array = Array.new(height) { Array.new(width, -1) }
|
|
map_array[y][x] = 0
|
|
frontier = [[x, y]]
|
|
|
|
low_x, low_y = 0, 0
|
|
high_x, high_y = width - 1, height - 1
|
|
if short_mode
|
|
low_x = [[event.x, x].min - 2, 0].max
|
|
low_y = [[event.y, y].min - 2, 0].max
|
|
high_x = [[event.x, x].max + 2, width - 1].min
|
|
high_y = [[event.y, y].max + 2, height - 1].min
|
|
end
|
|
|
|
iterations.times do |i|
|
|
break if frontier.empty?
|
|
new_frontier = []
|
|
for map_x, map_y in frontier
|
|
check_adjacent_panels(map_x, map_y).each_with_index do |pass, index|
|
|
next unless pass
|
|
dx, dy = [[0,1],[-1,0],[0,-1],[1,0]][index]
|
|
nx, ny = map_x + dx, map_y + dy
|
|
next unless nx.between?(low_x, high_x) && ny.between?(low_y, high_y)
|
|
if map_array[ny][nx] == -1
|
|
map_array[ny][nx] = map_array[map_y][map_x] + 1
|
|
new_frontier << [nx, ny]
|
|
end
|
|
end
|
|
end
|
|
return map_array if map_array[event.y][event.x] != -1
|
|
frontier = new_frontier
|
|
Fiber.yield if long_mode && (i % 20 == 0)
|
|
end
|
|
|
|
map_array
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
=begin
|
|
def find_path(event, x, y, iterations = 1000, long_mode = false, short_mode = false)
|
|
map_array = Array.new(height) { Array.new(width, -1) }
|
|
map_array[y][x] = 0
|
|
current_tag = 0
|
|
low_x, low_y = 0, 0
|
|
high_x, high_y = width - 1, height - 1
|
|
|
|
if short_mode
|
|
low_x = [event.x, x].min - 2
|
|
low_y = [event.y, y].min - 2
|
|
high_x = [event.x, x].max + 2
|
|
high_y = [event.y, y].max + 2
|
|
# Clamp bounds
|
|
low_x = [low_x, 0].max
|
|
low_y = [low_y, 0].max
|
|
high_x = [high_x, width - 1].min
|
|
high_y = [high_y, height - 1].min
|
|
end
|
|
|
|
rows = (low_y..high_y).to_a
|
|
thread_count = 1 # Adjust number of threads to your environment
|
|
rows_per_thread = (rows.size / thread_count.to_f).ceil
|
|
|
|
iterations.times do |i|
|
|
# Collect updates from all threads
|
|
updates = []
|
|
|
|
threads = (0...thread_count).map do |t|
|
|
Thread.new do
|
|
local_updates = []
|
|
thread_rows = rows[(t * rows_per_thread)...((t + 1) * rows_per_thread)] || []
|
|
|
|
thread_rows.each do |map_y|
|
|
(low_x..high_x).each do |map_x|
|
|
next unless map_array[map_y][map_x] == current_tag
|
|
check_adjacent_panels(map_x, map_y).each_with_index do |pass, index|
|
|
next unless pass
|
|
dx, dy = [[0,1],[-1,0],[0,-1],[1,0]][index]
|
|
nx, ny = map_x + dx, map_y + dy
|
|
# Only add update if within bounds and currently -1
|
|
if nx.between?(0, width - 1) && ny.between?(0, height - 1) && map_array[ny][nx] == -1
|
|
local_updates << [nx, ny]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
local_updates
|
|
end
|
|
end
|
|
|
|
# Gather all updates from threads
|
|
threads.each do |thr|
|
|
updates.concat(thr.value)
|
|
end
|
|
|
|
# Apply updates to map_array
|
|
updates.each do |nx, ny|
|
|
map_array[ny][nx] = current_tag + 1
|
|
end
|
|
|
|
return map_array if map_array[event.y][event.x] != -1
|
|
|
|
Fiber.yield if long_mode && (i % 20 == 0)
|
|
current_tag += 1
|
|
end
|
|
|
|
map_array
|
|
end
|
|
=end
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
class Game_Interpreter
|
|
def walk_to(x, y, id = 0, passthrough = true)
|
|
get_character(id).walk_to(x, y, 1000, false, false, passthrough)
|
|
end
|
|
|
|
def walk_to_short(x, y, id = 0, passthrough = true)
|
|
get_character(id).walk_to(x, y, 100, false, false, passthrough)
|
|
end
|
|
|
|
def walk_to_long(x, y, iterations, id = 0, passthrough = true)
|
|
get_character(id).walk_to(x, y, iterations, true, false, passthrough)
|
|
end
|
|
|
|
def walk_to_straight(x, y, id = 0, passthrough = true)
|
|
get_character(id).walk_to(x, y, 1000, false, true, passthrough)
|
|
end
|
|
|
|
def pathfinding?(id = 0)
|
|
get_character(id).pathfinding?
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|