存放腳本

熊喵酱 · 发表于 2013-8-29 09:01:09

加入我们，或者，欢迎回来。

您需要登录才可以下载或查看，没有帐号？注册会员

x

純屬給LBQ腳本:

=begin #=======================================================================- A6 S- @0 s& W& r$ J
' p1 U% C0 T. g P% m
Sion Mouse System v1.3e
- K0 F E8 Y+ S. F% `% _7 u
8 {8 I3 b" K& J4 m% _6 v2 r
Changlog
! @" L: o4 c. w4 D/ d/ [
1 V& k( `& r2 ]/ q* X
2013.4.21 v1.3f( B* Z: m' t: |9 E% E
0 k& F/ ?8 l7 Q/ ^. }
1.3f 卷动地图 bug 修正
( r9 N( M, g/ d9 Z# k
2 P1 N; O- z0 S
1.3e 逻辑优化；提供解除鼠标固定的接口
4 D& }' J r8 Q0 T: C! c4 w
在事件中执行脚本 Mouse.lock_mouse_in_screen 将鼠标锁定在屏幕内
9 d8 C3 C: ]4 |, P V) O u' Z
Mouse.unlock_mouse_in_screen 解除锁定* f- C9 ~* L) g1 O
& ?* W+ `* ] t1 V& A; I) m
1.3f bug修正1 n6 \) u5 i( u0 c# ^; m
8 Z& B. t8 ]. N9 O
1.3d 常数设置增加：Menu_Set_Pos，用来设置打开菜单时鼠标是否移动到光标处以及$ c: N) Y- q: k1 _ W. Y
关闭菜单时，鼠标是否移动到原来的位置。4 l5 C( W6 k y; G
5 j3 _8 y7 z6 }: k3 A
1.3c 打开菜单、光标移动时鼠标会移动到光标位置处. _& Q1 {# h5 J
- n: K* g6 F: s4 M# A
1.3b 修正一些罕见的bug；
! Y! p. \0 H. T% l+ N1 k
6 _3 x& N6 w" x! x5 c
1.3a 代码小修改；% N0 p9 V( i. B& x
加入了鼠标点击启动事件的功能，
8 n- j( ~0 V$ U/ J( Y3 d7 x
在事件中加入“注释”：鼠标启动，
; L. ~% }: q: `0 s7 l9 T0 }
该事件将无法用其它方式启动，只能用鼠标左键点击启动。
, U2 I" d. G8 p2 P
# r/ h: I0 D: o2 p1 S
2013.2.12 v1.2
5 T0 G3 s& t- Z
9 p/ E, I; ~* E% _! y; r; H' D% A$ V
寻路逻辑优化；
7 b: M w' l; W3 `5 p5 s) ` p
优化了事件判断，现在点击事件附近的格子，移动到指定点后不会触发该事件了；
6 T7 P8 q" ~/ _) W/ h' o0 ~
现在支持用鼠标来操作载具了。. ^" b; ~! P" ]- |; O7 [
% W0 j4 ^3 D: T0 u! b
2013.2.8 v1.19 [4 q" N. R! z7 s" b( F: l$ u- L) O
5 C" x/ @/ G$ y7 r3 o
优化了事件判断，现在可以方便地启动柜台后面的事件；! C0 ]8 ?. f3 K7 {
修复了某些菜单（例如更换装备的菜单）掉帧的问题；
4 p! D1 `8 l4 B- q6 a) x* t
移动时，路径指示点的绘制更加稳定；
$ j. G2 J& V. X0 r5 P
现在支持默认存档画面的鼠标操作了。
$ Z8 C& d% H( ?, l9 b- t: v& G$ W
) L) i) r9 m/ ^3 S: q1 G1 m
0 }6 a3 \3 a. p
OrigenVersion
! p+ ^; T/ I9 d
: y3 T! Q$ k) i) P
2013.2.7 v1.0 ) b6 d0 w4 X L; c' Q
$ z/ _; m( i3 c: J; x% i. {' x
主要功能( W; a8 b! ~2 P. r3 m/ n
! Y+ N/ _2 e% X, P
使用鼠标进行各种操作...
! ]" X& i2 u5 ]% ?
将鼠标锁定在游戏窗口内
+ t' P4 U0 V, `7 L/ n7 u
自动寻路，按住 D 键可以扩大寻路的范围/ g9 q( r: v# h* M9 n
双击鼠标进行冲刺
5 J1 e( t {) M) R% i b" Q) ]
更改地图卷动方式以适应鼠标移动$ g3 @0 l9 E7 _- f' @' R; x/ ?
变量输入框改良
# b4 P2 b: M) X
2 p- ?" @! Y: u0 `$ \1 [8 c
★ 鼠标指针图片 Cursor.png 放入 GraphicsSystem 文件夹* a9 a8 E2 m% V) [- X2 ~: U v
& {, n7 \+ \8 }6 Q
★ 路径点指示图片 $Arrow.png 放入 GraphicsCharacters 文件夹
7 ?' ]6 m) |% m! d. V3 Z, C, T
+ m. t2 A5 O- v6 n" q
★ 如果未放入会弹出提示，并使用RM自带图片代替缺失文件；该提示可以在下面关闭9 I( b# B, h* b6 A; n- v
1 r; a9 `* k$ P
2 a9 C1 |( D! i% D
=end #★★★★★★★★ 可能需要设置的参数都在下面用“★”标出了 ★★★★★★★★★★) d) ~* X$ V9 u/ ^' ?/ i
9 [! C' j9 n8 ^! k- n1 e2 X
5 Y) j7 A) b+ H4 o6 E+ H
$no_arrowpic_warn = true # ★ 设置为false不弹出图片缺失提示
& c' ~% [& p2 n
) c6 X9 O: | I9 L1 S9 A4 }% T
#==============================================================================, o0 e; o# A( L) M( C& [) B' f
# ■ 常数设置
/ M, ], [) M# B$ Y& X3 W+ y
#==============================================================================, D* {9 @2 L4 e1 w( A# s
module KsOfSion
! f' ~# f9 y0 b# \% a
Clip_Cursor = false # ★ 鼠标锁定在游戏窗口内，需要关闭设置为false
5 x* O$ _7 F: D. F9 @
Dbclick_Frame = 20 # ★ 双击的最大间隔帧数。在地图画面双击进行奔跑# E& n% ~/ @7 {! M8 J6 A
New_Scroll = false # ★ 更改地图卷动方式，需要关闭设置为false
, w; z7 |. [% |# m, V
Map_Scroll_Spd = 1.0 # ★ 更改地图卷动速率，请确保此值为大于0的float变量
& n6 I: C! C6 ~3 v! T0 a
Menu_Set_Pos = true # ★ 打开菜单时将鼠标移动到光标处
' i2 h9 E) n; n4 \
Break_Steps = 30 # ★ 鼠标寻路最大步数，防止路径太长导致卡帧: e9 M* g+ w+ l) E' q! D; j
# “30” 是默认显示格子数长（17） + 宽（13）
0 d) w, H, f; Q$ Y' v
Find_Path_Key = Z # ★ 扩大寻路范围至全地图按键 Z 对应 D键( n6 {+ {! k# w3 u5 V g; a
# RM几个内置的空键位 (X = A)(Y = S)(Z = D)0 b: E" D: ]$ e0 @6 A
end0 c6 s% l1 f m- R* g5 i- F
. d) f* c7 q+ U0 U: W
#==============================================================================
, v" \) m+ i& K% _; i7 S7 o) F) s
# ■ 用来显示路径点的类
- o8 z* W! V! J
#==============================================================================2 \2 K3 L; ]1 B3 @' e
class Move_Sign Game_Character: A7 F0 Q/ I/ p7 v
#--------------------------------------------------------------------------
0 c2 O8 V4 D6 Y, @
# ● 设置目标点指示图的各种参数，请注意要使用的图片是行走图# `8 m$ i% N" L3 T# t- J( l# }+ `) Z
#--------------------------------------------------------------------------& a4 k! e' J% U, L2 f1 Y3 {6 \2 u8 N# r
def init_public_members0 u$ T0 `$ u; ^' Q5 J9 F2 S: a5 h
@character_name = '!$Arrow'# ★ 路径点箭头，置于.GraphicsCharacters文件夹
1 q) c# F/ S0 R. j8 \+ j# a6 O
@character_index = 0 # ★ 图片索引。$开头的行走图设为0
' u! n4 e, u a, q. G" w C. g
@move_speed = 5 # ★ 踏步速度
6 s9 r! |# b& N5 l1 W
@step_anime = true # ★ 踏步动画（如果想使用静态图标就关闭这个）
7 F" U8 ]; i1 M4 }0 i
[url=home.php?mod=space&uid=316553]@opacity[/url] = 255 # ★ 不透明度* g8 W9 \2 ]% N+ r7 A
@blend_type = 0 # ★ 图片合成方式，默认为0（正常）+ E9 M4 Q) o6 [! Z: g
@direction = 2 # ★ 朝向，2 4 6 8 分别对应行走图第1 2 3 4 列
) g4 \; {' Y! l) G4 J7 U1 x
@priority_type = 1 # ★ 优先级（默认与人物同级：1）
7 y& B% W9 s/ _$ D- D& k2 H
4 Y0 a) Y3 ?3 Q' D; Q% A4 O; }
7 ?& K9 P8 L. \& O5 N6 c ]
# ★★★★★★★★★★★★★★★ 参数设置完毕 ★★★★★★★★★★★★★★★★★★★
1 p0 i# O; Q+ m- k' k
. d. t2 `! l: G
( ^, f& P0 [; k+ W0 e9 ]: s
# 如果 $Arrow.png 不在对应的文件夹内，弹出提示，并使用游戏一张内置的行走图
. J( p J$ z9 }9 [3 J- Q ]
unless File.exist('GraphicsCharacters' + @character_name + '.png')
- s( @+ a( D$ W0 n
$ i) k! }5 J' Q5 a c% ?: T# I
if $no_arrowpic_warn" ?. H0 B' H/ _* o- b! j$ F' T
MouseShow_Cursor.call(1): A7 i: j/ L! D7 v, ~
msgbox('未找到文件：GraphicsCharacters' + @character_name + '.png5 B# g" ]4 G9 q. z( I
3 K& ~# [: d+ U
“路径指示点”将使用游戏自带图片' _" X6 T! ]3 R; r, m( O/ o7 D
- w7 l/ I/ m( P! b- f+ D1 C* H
该提示可以在脚本内关闭')
1 m4 i/ r0 a* I9 }' ^+ g
MouseShow_Cursor.call(0) i2 n2 [. ]8 s5 p3 m2 t. ]
$no_arrowpic_warn = false
/ O: C- l" o! M* [6 Q: p
end. Z/ O* N% O6 @/ S2 {
@character_name = '!Flame'
) q5 }# ?# p0 m+ \9 h( ?* T
@character_index = 6
4 M& u1 {8 Z. b" T7 ~. T( q
( ^4 E% H7 j3 z. F# L1 X5 O& \9 x
end& f; l0 L& U- c, d( V5 I+ ?2 r
@direction_fix = false # 固定朝向
3 Z1 ~* f7 E5 }% \
@move_frequency = 6 # 移动频率
0 Y6 X/ d* K8 T; x3 L
@walk_anime = true # 步行动画9 _6 v& \4 e) g X) a2 X) L
@pattern = 1 # 图案
9 A8 K; s1 A1 F
@through = true # 穿透
$ f) x, s9 a2 L1 H0 b
@bush_depth = 0 # 草木深度
+ e8 ~" }0 d9 i
@animation_id = 0 # 动画 ID1 F! f* N1 f+ r- S0 H
@balloon_id = 0 # 心情 ID
) ~: X' S% g* y
@transparent = true # 透明5 U0 I! V- [8 g& C) {
@id = 0
5 I# i. m/ u# v
@x = 05 Y9 i( J% i7 L
@y = 0
" d% G" f. N; W6 Y# W6 w
@real_x = 05 I; H. v! v" |
@real_y = 01 b c% J( }) o8 X
@tile_id = 0. L5 Q$ _1 Y2 U
end; S; ]+ x% d, G& E; I
#--------------------------------------------------------------------------% Q" p1 f9 A) }, _' N
# ● 定义实例变量4 ~' T9 Y3 N$ \
#--------------------------------------------------------------------------% [3 d- L9 w% d# J- M& a' a
attr_accessor direction
( f, `" N' r6 U& ]% Z! V; a+ B! ?
end" o7 m$ R$ F1 k+ {5 k C' j
_2 {6 }# ^7 H n
#============================================================================== r0 `+ T @9 ?8 J/ z
# ■ Module Mouse
0 l) N+ X( Q# c) ]0 N
#==============================================================================" g. v- z: S5 f9 R- _" g$ Z
module Mouse
( j h" G, ~2 a2 E1 l$ D1 Z
#--------------------------------------------------------------------------+ _3 z! s; k6 f8 b8 G* w
# ● API) t& A. Z- Q7 l( x
#--------------------------------------------------------------------------" p, C1 M( E* z* Y0 F6 R/ O9 E8 |
Show_Cursor = Win32API.new('user32', 'ShowCursor', 'i', 'l')
8 ~# x5 F: I$ p' H' V2 ^
Get_Cursor_Pos = Win32API.new('user32', 'GetCursorPos', 'p', 'i')/ }7 C$ [# f3 L# Z; w2 l
Set_Cursor_Pos = Win32API.new('user32', 'SetCursorPos', 'ii', 'l')$ I5 n! b* V, A: \9 R
Screen_To_Client = Win32API.new('user32', 'ScreenToClient', 'ip', 'i')
+ t: F7 F3 N1 @
Get_Active_Window = Win32API.new('user32', 'GetActiveWindow', nil, 'l')+ Z/ }% D" ^ R" h: S2 U# A6 ~9 T
Clip_Cursor = Win32API.new('user32', 'ClipCursor', 'p', 'l')( y! F& @, z D% i0 L2 G) @
Get_Key_State = Win32API.new('user32', 'GetKeyState', 'i', 'i')( E0 K; B! O6 s O
Window_Hwnd = Get_Active_Window.call
& I) R. T! ^# ^% K
! s0 b+ u! C ?2 U7 O
class self
4 J! o( \ w( M) Y# X5 e8 `
#--------------------------------------------------------------------------0 E4 o3 |7 W. ~$ d7 a8 ~: K
# ● 初始化# _8 i/ [3 p8 K, g
#--------------------------------------------------------------------------# ^) c$ q" ^; P- h% }) x
def init
! a+ U' ? W0 [) T5 ^
lock_mouse_in_screen if KsOfSionClip_Cursor
# u2 p# s9 ~9 O0 ~. ~. d
@left_state = 0
5 }9 G& S x# l. G' I" N+ K
@right_state = 0
2 A7 @+ y: u! T* ^" J( T
@ck_count = 0 # 帧数计，单击以后从0开始) P4 e, S/ o: Y" p! I$ R3 m4 [
@dk_count = 0 # 用于双击的判定7 \# ^) r+ k7 b- X$ i$ l5 P, T
@clicked = false) u+ u2 I( H2 J; h' F; I
creat_mouse_sprite0 |7 ~ k) G2 U( J; L1 {8 S2 ?# }
update' @7 H$ o! z2 c
end
+ z/ X3 S9 n) ~$ k: x! F; e
#--------------------------------------------------------------------------
! ]* \; k' a3 F7 ~; Y ^# c" K& J5 ^
# ● 鼠标指针精灵! j2 m( j% U3 {1 e% @$ |
#--------------------------------------------------------------------------
; r- U, b* F9 O8 R, }
#~ def creat_mouse_sprite+ l' G$ V0 H9 @' @
#~ 8 ~: ^2 F' W: z4 [4 t: r; a
#~ @mouse_sprite = Sprite.new
! Q) }- |! V9 S9 \: v2 z
#~ panda = 2#rand(2)+1 j! O9 ^6 T) ~5 z) {5 ~
: D! i; ]( x( ?# O' N5 i9 V
#~ if panda = 17 Q) ]) J* ]0 h, Y$ M; D' ]
#~ if File.exist('GraphicsSystemCursor2.png')
% D' J0 y9 y x6 Y; X) D: L
#~ @mouse_sprite.bitmap = Bitmap.new('GraphicsSystemCursor2')- v; G) i' G, q- g' `
#~ end#with if File.exist
4 u& q1 O; S% T% j$ G$ t' B$ W
#~ ' x$ O U' X* V5 B+ ]0 Z
#~ else if panda = 2 #with if panda=1; y6 V9 o/ |& r y2 K- ?8 g( O% W
#~
* d) c2 y* Z+ F6 y' k
#~ if File.exist('GraphicsSystemCursor2.png')1 a% Z( w/ d2 Q3 S" V/ {7 ?1 a9 G
#~ @mouse_sprite.bitmap = Bitmap.new('GraphicsSystemCursor2')
; y) z& [- ^( [
#~ end#with if File.exist
, z( r$ S/ Z* N! N, `
#~ ' H/ [9 z- Z! t' f- B
#~ else #with if panda=1$ v& S Y8 u A$ Q
#~ @mouse_sprite.bitmap = Bitmap.new(24, 24)1 i( w# i& w! a" p) @$ D1 |- _9 q
#~ @mouse_sprite.bitmap.blt(0, 0, Cache.system('Iconset'),0 p& u1 N& [# R6 P; Z7 o
#~ Rect.new(5 24, 24 24, 24, 24))
& Z: N# ~) ~6 Z$ K) @
#~ end#with if panda=1
5 w! i. u/ H7 x: b, g V% M
#~
) h6 t* P+ X4 ?# C
#~ #with def: A- U J5 u* D, O) b/ @: B4 m
#~ end# T: |- Q/ I4 P3 b
def creat_mouse_sprite
% {7 N# B: ~! |- C. Y: \2 p9 e
@mouse_sprite = Sprite.new
( M' ?- [: L! D8 ^" U5 }
@mouse_sprite.bitmap = Bitmap.new(GraphicsSystemCursor#{rand(2)+1})& }5 R) ~) J6 w; e- g& H
@mouse_sprite.z = 9999
' w7 V3 q# Z" u$ p+ r6 U! l
Show_Cursor.call(0)
* d* t0 B0 S5 }- U6 A. q
end% v, O# A* H" A& x: Z
" B& E. X( |2 Z5 P4 W" T" @3 z# m
#--------------------------------------------------------------------------) J# z0 H1 c: Q/ K( j% O
# ● 更新; e9 q, W: o9 B! \) ?; h
#--------------------------------------------------------------------------: ~. B, m, ?- |6 i% N
def update
7 z* d$ w% v F# Y1 Z/ w! S& r4 B
@mouse_sprite.x, @mouse_sprite.y = get_mouse_pos
" g; L- `( B$ A1 p2 k' @. d) I
left_state = Get_Key_State.call(0x01) z5 \1 K) E$ Z* M
left_state[7] == 1 @left_state +=1 @left_state = 0
% @% {* J6 I& N# o' p& W3 A
right_state = Get_Key_State.call(0x02)
: ^- I. ^5 F3 r1 ]$ R* X
right_state[7] == 1 @right_state +=1 @right_state = 0: h% g; t. v& V; M! R5 W: Q% \
update_double_click7 O& Q( t& w- f5 G
@left_state == 1 @ck_count = 0 @ck_count += 1- \5 n. r _& k
end
( r4 n( y' V' }. J% @* H6 w- P: \
#--------------------------------------------------------------------------
; [2 }) l) R6 O
# ● 获取鼠标坐标6 K& D' Y8 h( b; \
#--------------------------------------------------------------------------- F% J, G/ R. Z0 Q: I! d% K
def get_mouse_pos
3 x9 ?$ J3 Z9 ~# n/ W% Q# X2 `( |
arg = [0, 0].pack('ll')5 c% f+ ]+ x4 B2 W. X- X( r$ T
Get_Cursor_Pos.call(arg)
5 r0 }* ]) r- j' x; K
Screen_To_Client.call(Window_Hwnd, arg)( V! I3 d! ] |; x
x, y = arg.unpack('ll')
7 t$ d6 c+ ]0 L5 [+ Y6 D2 ^; j
return x, y
/ _9 H o, U" c
end
8 g, X/ }" y3 ?6 O# J- ]3 U5 e9 ]
#--------------------------------------------------------------------------
$ U! k9 I/ U3 {! V: k% k
# ● 将鼠标固定在屏幕内
7 L$ P/ w% \6 D2 N3 G3 y% S+ ]
#--------------------------------------------------------------------------
+ I8 D: c) D& P; k* V
def lock_mouse_in_screen
2 }* B$ ^* c0 D; K- J
arg = [0, 0].pack('ll')
. ^; Q. A( w# G
Screen_To_Client.call(Window_Hwnd, arg)
+ E' b9 t; J2 \% w' i3 {
x, y = arg.unpack('ll')+ Q; B5 s8 J+ a% r) y- G
Clip_Cursor.call([-x, -y, Graphics.width-x, Graphics.height-y].pack('llll'))+ S/ p* O [( B( D1 O: h- K
end
* K* V5 n N# l1 A5 u8 q1 _. m
#--------------------------------------------------------------------------
! Z% F2 q. F; ~; `. G* h: X
# ● 解除鼠标固定
" w, W) D. U5 G4 O* A: Y
#--------------------------------------------------------------------------) s1 J$ b+ p4 n: h
def unlock_mouse_in_screen
r. h* N; n( Y5 P( {4 |
Clip_Cursor.call(0)
! ?1 t/ [2 t) T k% s- ?) w1 F" i
end. x0 H' z( N8 s! K
#--------------------------------------------------------------------------
, s. k3 ~, Y7 g/ C9 \& c, T8 }
# ● 鼠标双击判定
9 @; h6 d/ b" J, C6 \* z- \. c5 q( _
#--------------------------------------------------------------------------; [' o9 X3 P: y# P# n
def update_double_click; c v2 j: s5 D! ]7 l& Q2 U$ a1 U
@clicked = true if @left_state == 1
) d+ U: P7 H% H" V/ F
if @dk_count 0 && @left_state == 1
. h2 g4 N/ N, x
@dk_count = 0; @clicked = false
+ p# `- D' ^- ]( C
return @double_click = true
& \! G+ Z7 u& e2 N8 z0 ]
elsif @clicked
1 D0 O. y3 A* l/ a/ L
if @dk_count KsOfSionDbclick_Frame
4 R& O: B) h* U! @+ U) K% b
@dk_count += 1/ P" R1 t0 p. I" I0 q: h
else
/ l7 W& P4 C# s. F3 R" D" r4 W" }8 O
@dk_count = 0; @clicked = false6 V9 q6 }2 J9 ?& I& |
end/ |- Y( V4 r- s `
end
; U% V1 y. C2 @
@double_click = false
5 k1 c# A0 a) n; F
end
( C% h; w$ n" p4 {( P. G8 g7 i
#--------------------------------------------------------------------------
7 n2 h, B& Y6 @
# ● 按键被按下就返回true) o! ~4 n/ R9 a4 B1 _& J
#--------------------------------------------------------------------------
, c& Y' M# k! t9 Y
def press(button)) i# J \) {$ K7 @/ z) S& U0 P [
case button7 M; W2 X/ w) Q$ H6 N. ]% k8 a
when 0x01; return !@left_state.zero! m" n5 z2 ^" g5 X
when 0x02; return !@right_state.zero
# _, ]1 \; z( Q$ d
end/ _1 M/ d# ?& J( f4 w" J# f1 L5 n5 _
return false
6 `0 K+ V) Z: ]* w1 Q8 m
end+ u! ]5 o% ~! s `( f* F9 p
#--------------------------------------------------------------------------
' [; T. C6 Q9 ^( J, G$ M
# ● 按键刚被按下则返回true
* |) {# R' T% j0 `- z7 R
#--------------------------------------------------------------------------
2 g) m+ o2 S# X8 Z6 Z
def trigger(button)
5 `5 h( m% ?% I% Q
case button$ @& c5 B! \+ z* u7 V
when 0x01; return @left_state == 1
- n" D5 z: c: K/ H- O$ R( r$ P) z5 d" A
when 0x02; return @right_state == 10 `5 [* i& c$ X
end
; o" g& y4 ?/ t! j
return false
4 ~" G' b! _/ T' o$ |
end
9 |1 q* |+ z" C
#--------------------------------------------------------------------------, O0 ?# m P/ s2 i r+ A4 S5 D
# ● 持续按住键一段时间的话，每隔5帧返回一次true8 z9 L/ s6 @+ o) H1 V: j' Y
#--------------------------------------------------------------------------( u( s. h. t( V' k
def repeat(button)
( G* C: i* @/ }. _- p2 B# K) y# j! Z
case button
. E/ Z$ I) K0 j5 z4 [; s( `- h
when 0x01; return @left_state == 1
5 r' r: ^/ k- X0 c
(@left_state 22 && (@left_state % 6).zero)6 I8 q7 q" y. D
when 0x02; return @right_state == 1
/ J) K$ z% _* X9 V) e, l ^
(@right_state 22 && (@right_state % 6).zero)
3 a. o. `5 _7 p6 s
end. F3 v) y- e& ^# E7 G
return false
+ ?/ F3 h* d9 G' _" g9 f
end1 Y& b) ]# d T
#--------------------------------------------------------------------------
: K+ M$ ^( X" ?) l) ?
# ● 判断是否双击鼠标
$ |, R( T' B! y! f- k
#--------------------------------------------------------------------------
| a6 X U' B3 ]6 L
def double_click7 k& z! a% h; e0 ~& k3 F3 r* o
@double_click
" h# l1 {" Y) x0 W
end
0 w+ p/ R4 r9 E- c2 v, r
#--------------------------------------------------------------------------
6 d! |, U2 q2 I3 f
# ● 获取@ck_count（每一帧+=1，单击后重置为0）, ^8 v( Y! D" t
#--------------------------------------------------------------------------
& L3 Z0 t* \6 ~, T: I# p o8 |
def click_count/ n2 `. i7 X, n+ F C& y8 q6 a& ^- U+ H
@ck_count
+ ]& r! e) g, F( O2 f
end
/ r4 z3 \9 R, t+ q
#--------------------------------------------------------------------------2 F9 s' O# E/ I# V
# ● 获取@left_state（按住左键每一帧+=1）) M: Z! j, b G1 @8 ^$ c
#--------------------------------------------------------------------------5 s* u; v5 @& J8 F3 T! Y
def left_state4 X9 C$ |0 C* U: I$ R4 P
@left_state" X, l! ~% @( w# N' X. R% O
end$ A4 z1 P5 m( B1 v9 o) r7 B* c
#--------------------------------------------------------------------------
! p, Z6 X: b/ i& c5 g
# ● 获取鼠标的x坐标
4 w7 m" ^: { H3 ]: J; s
#--------------------------------------------------------------------------
6 D& D: w+ Q: p* Y! O
def mouse_x5 ~( T( X6 @! H5 \
@mouse_sprite.x
! q; N; D" J Y$ Z
end
. C+ u& M( g+ T5 z, O* J" d8 }
#--------------------------------------------------------------------------
' o9 \) Q5 N- _! Q6 C
# ● 获取鼠标的y坐标
2 V% ?' O% |; i" e* t9 m
#--------------------------------------------------------------------------
8 q0 O$ r' L* Z/ v4 C
def mouse_y
3 L9 x" S+ |1 p
@mouse_sprite.y
3 V" M; B5 U3 `, O) O
end
A; b! \9 W% H. K
#--------------------------------------------------------------------------1 c9 q2 p! n2 Z% M
# ● 设置鼠标坐标
3 k0 C4 s9 y1 S0 {
#--------------------------------------------------------------------------% W3 |# ^' @! n( d3 X9 n" f
def set_mouse_pos(new_x, new_y)8 K( D6 c! C: }; e- g6 K- C
arg = [0, 0].pack('ll')5 M+ i3 w1 L3 S: J
Screen_To_Client.call(Window_Hwnd, arg)
2 ~" D5 a) {2 z9 R( n" \7 D
x, y = arg.unpack('ll')
& Y1 l3 S# V# x: x' O7 Q' i
Set_Cursor_Pos.call(new_x - x, new_y - y)
4 F" r0 e6 U/ ~
end
' ?& @$ U9 Z) F
end #end of class self # e. U1 f& ]( K- }& S* X2 V& Z: N
2 V9 N) j6 u/ v9 g, |1 J7 [& X
end
4 L0 L% L1 U& _4 o8 s6 \
7 J2 e) w' j2 X
#==============================================================================
& w; B9 Y: K- g+ M) j+ o T
# ■ SceneManager
u/ d, {* `% ?$ w" g
#==============================================================================
# [' u1 W. D7 Z6 D: b- m7 ?% X
class SceneManager9 h% q9 K8 E& I; N) v
#--------------------------------------------------------------------------
! H. R/ X$ _ n/ V+ f ^" l* w$ I
# ● alias0 Z. a! N" I W+ {$ U( ^; b! r
#--------------------------------------------------------------------------
) \# f- G* O' ~% |! @
unless self.method_defined(sion_mouse_run) [" e/ F3 D/ N: k/ {1 l: A+ S5 j
alias_method sion_mouse_run, run% h% B0 M( b% W
alias_method sion_mouse_call, call4 _7 e, z3 `; T7 k1 u
alias_method sion_mouse_return, return7 ~' D; G* S. K; b
end7 s" d- y4 @4 n9 Q$ M3 h6 o. `$ n z
#--------------------------------------------------------------------------
+ e0 m6 T; m7 [( _, |
# ● 运行
% f8 s5 X4 x* F; g& o! z
#--------------------------------------------------------------------------
% j8 L+ U0 @$ T4 ?) S7 U) }& i
def run8 i1 P3 @: O% X$ L8 |, ? j3 ~
Mouse.init
Z& i4 c: l% Y* \4 `2 K
sion_mouse_run1 e' X6 ^- H6 R, o
end
6 ?8 v2 j; u9 B3 `' S2 g" a$ a
#--------------------------------------------------------------------------
3 y) o5 z' p' L! R+ D
# ● 切换
8 z8 S& }9 l/ O3 n
#--------------------------------------------------------------------------
3 U/ R) S1 h$ { n3 R7 g
def call(scene_class)
- W; w. c# M3 ~) f2 X
$game_map.prepare_reset_mouse_pos if @scene.instance_of(Scene_Map)# a& d5 X t' W# Z! V
sion_mouse_call(scene_class)2 n5 n* n, P* R v$ P. E$ u' W) s
end+ k/ v! }- Z x: m, ~
#--------------------------------------------------------------------------7 e/ a" Z8 Y6 W- |
# ● 返回到上一个场景
2 S' W" t6 S1 t5 Z4 `/ ?$ L
#--------------------------------------------------------------------------
4 C2 T" c& b6 U- [, _
def return& b) v0 z/ s4 H6 q! \+ q/ n1 T/ w
sion_mouse_return# z$ ~1 h7 m/ ?/ ]3 [* W
$game_map.reset_mouse_pos if KsOfSionMenu_Set_Pos &&
4 @. `0 W5 C; z- f
@scene.instance_of(Scene_Map)
1 m s, B6 o+ Y- D! k+ d! U
end7 V0 a+ H; c' [! s3 k% w
end
2 y [6 g7 i$ g& B2 l) }' n
! M4 L8 i1 m5 l2 S0 u0 V1 R) o
#==============================================================================! j1 a8 B7 y( v
# ■ Module Input
* i# p( O& X9 X- ~
#==============================================================================
1 ~3 N: y1 d! e) A$ |
class Input( a( {# E6 |- U) H# U) J' j9 a
#--------------------------------------------------------------------------+ Q" k1 X+ d9 R, @) _* o, L2 }
# ● alias2 |3 V5 G1 g( Q9 g) Q
#--------------------------------------------------------------------------
0 Z4 d4 Z% U! v) ^( v: C
unless self.method_defined(sion_mouse_update)- ~0 X6 T/ t9 a* d m
alias_method sion_mouse_update, update
6 `/ b4 E3 c9 [" Q6 t W. Z0 H& @
alias_method sion_mouse_press, press; p! C0 R" k7 R/ R, Q9 I! P
alias_method sion_mouse_trigger, trigger
s9 O/ J% {# g+ r& w, O! D5 I
alias_method sion_mouse_repeat, repeat
9 h/ w7 W; E& C6 Z' B
end
) T8 o5 G# K' V% u" D3 E( [# T9 R
#--------------------------------------------------------------------------
$ [: }2 a& [; W( x% x
# ● 更新鼠标/ n& t0 ~7 B O$ g
#--------------------------------------------------------------------------$ `) [& G7 }3 F& d+ X) G& ]2 u
def update
) D4 ^, U' P" _/ \
Mouse.update1 ^ ]2 I) l. T2 o! ]
sion_mouse_update
end
( @ y$ U- I- U( D
#--------------------------------------------------------------------------
6 z* B/ j2 W. Y. h) J0 Q
# ● 按键被按下就返回true
5 l" k) L$ b/ Q, Z
#--------------------------------------------------------------------------
$ ~& V' h: I8 L0 F2 \
def press(key)
* M9 O- G1 A) _) P
return true if sion_mouse_press(key)7 k; o& N8 V2 a# n
return Mouse.press(0x01) if key == C
0 W7 z7 i3 F/ D" ~6 ]" W2 o" r" f Q
return Mouse.press(0x02) if key == B
2 p8 J( N) S+ H. f. s( B/ B( B
return false
) s0 G: m' I; g8 ^
end% K- v. ~8 _- Q% w4 y
#--------------------------------------------------------------------------3 h7 n% n/ j' b6 N' h- Z
# ● 按键刚被按下则返回true
9 M: ?/ W( Q0 Y8 W8 i
#--------------------------------------------------------------------------1 Q2 N9 a. h, ^8 Q5 L6 I
def trigger(key)* \# C. J' `$ h9 ~- I$ }
return true if sion_mouse_trigger(key)
; D. c$ j" H4 ]/ O
return Mouse.trigger(0x01) if key == C
+ h1 M/ O( x9 v. I
return Mouse.trigger(0x02) if key == B6 [% N/ F" H- f2 W& t
return false6 w ]+ F+ n `" n' u
end
+ z h6 l8 t1 H+ C$ Q
#--------------------------------------------------------------------------
) b. A0 c w; u% f; G: j
# ● 持续按住键一段时间的话，每隔5帧返回一次true0 G6 Y/ D; V f/ R% h7 V# x& a
#--------------------------------------------------------------------------
! L E& `% k: C7 R( B
def repeat(key)
- L T$ Z: h- f5 Y/ s
return true if sion_mouse_repeat(key)
* K9 _& o3 g. N# {# r8 s
return Mouse.repeat(0x01) if key == C* U- c# T' x% P! `6 x' j
return Mouse.repeat(0x02) if key == B
M; e7 P% Z5 H7 C$ T8 T
return false% t' N0 b+ B: u/ G( q2 E, k8 l
end
; R% x2 P' F0 y6 t% B |4 b
end; [& a& e7 ~0 N( k* r& l
, p- z. o9 e: h% e
# Q) W$ |7 x! |( e% R/ |. A- N' A
#==============================================================================3 k& G# A9 k8 C4 [, n1 z
# ■ Window_Selectable
8 P! G# r% T2 B( c- L
#------------------------------------------------------------------------------8 `2 I( A0 w5 R s& y# b# b5 W
# 　拥有光标移动、滚动功能的窗口
9 ?. U6 X0 R: E1 h9 f: j) H
#==============================================================================7 Z ]* u# B0 s& e$ [* _* }8 R
class Window_Selectable( w# S7 g$ R$ h0 d* r6 M3 v
#--------------------------------------------------------------------------0 `. p: `2 ?9 }; p1 n1 \
# ● 初始化2 A; l1 h6 o# C/ z5 j
#--------------------------------------------------------------------------
$ q5 E. Z& N8 ~
alias sion_mouse_initialize initialize
% n+ M7 a% t3 [4 t5 I7 ^8 c
def initialize(x, y, width, height)
4 V1 u" p+ f7 B; X
sion_mouse_initialize(x, y, width, height)
8 ?2 U$ v9 U2 i' C( |
@move_state = 0& V$ ^: b; O+ P$ y _* `9 g, C" D
end
: r( L" g; M# u& L U- \2 ^
#--------------------------------------------------------------------------
- {3 W( Q6 g* R( p6 Z" b! X1 I
# ● 更新
$ |, B4 W+ a- U z8 A
#--------------------------------------------------------------------------
; x) B# m* z$ _8 V
alias sion_mouse_update update) K* N6 K8 I; H6 C
def update
- r0 O( c9 A7 V6 Y
sion_mouse_update
; h) U( k6 N! ~4 v0 B6 N5 q' b! ~# y
update_mouse_cursor
0 `- J' ~. N( m: Z0 }. C( n
end
) m& h L- U/ V' c2 F9 U
#--------------------------------------------------------------------------
2 B4 D8 I ]+ S. c3 v f0 E
# ● 启动后设置鼠标到index位置
7 @; ]# o. ]) y3 U0 j3 Z7 D
#--------------------------------------------------------------------------! n" D. M1 a0 i7 m& Z
def activate
" S7 W5 ]5 C) |. g# b/ @, u- O9 C
@need_set_pos = true if KsOfSionMenu_Set_Pos
9 h& a% B7 @' V/ w8 S
super' t7 ~. v X0 e
end* k( s) r- u! R
#--------------------------------------------------------------------------% g0 x) k& _7 T9 y: E+ _$ Y- c& \9 W
# ● 更新鼠标和光标的位置% D* q Z9 F* L
#--------------------------------------------------------------------------, K, t/ F# z9 n
def update_mouse_cursor: M' I- x; [$ c+ f
if active
; c$ q' [ @5 H7 m9 o! _
if @need_set_pos7 {& C! ~6 l( M
@need_set_pos = nil8 ^3 _% u0 z% q' q" A
set_mouse_pos
5 B! e* L& p% T# n
elsif cursor_movable$ X0 B3 O4 U, P- V( k( R
Input.dir4.zero set_cursor set_mouse_pos7 i( ?! t% U! t+ u% f
end8 Z* q. U' u8 {% D; Z
end
% V3 i P7 y }- A+ c9 T' G2 a
end2 @2 t" p, F& d; \
#--------------------------------------------------------------------------
( @+ L; b; O% d7 T! i$ f0 g! T
# ● 将光标设置到鼠标所在的位置，附带卷动菜单的功能' a& y* G; R' U4 |. ]
#--------------------------------------------------------------------------
5 @" r) ~2 @5 G, L1 Z( @9 O
def set_cursor6 w+ z0 ]3 E2 U4 b% i& j
mouse_row, mouse_col = mouse_window_area/ ~0 K. Z( A# d+ S
if mouse_row == -1
9 s1 Y( [5 }4 d) m. t: b. f N
@move_state += 1 if need_scroll5 c7 Z$ [1 Q& ]
cursor_up if (@move_state - 1) % 4 == 0 && !is_horzcommand; u9 Y% e; O O8 z( w/ s9 `" S# N
elsif mouse_row == -2
, Z- o, ?0 }& Z! K0 L
@move_state += 1 if need_scroll
5 w; h$ O& l/ t$ @6 C8 Z
cursor_down if (@move_state - 1) % 4 == 0 && !is_horzcommand% j! G4 g- k" i
elsif mouse_col == -1
6 `% d' H$ i! W
@move_state += 1 if need_scroll
/ v% Q$ _* }6 w3 b5 T
cursor_left if (@move_state - 1) % 16 == 0 && is_horzcommand4 N7 C& x& Z+ ^' Z2 j: ?
elsif mouse_col == -2
/ m7 v, K5 W/ A7 z
@move_state += 1 if need_scroll( I8 ~+ R0 j5 U* R$ t+ [
cursor_right if (@move_state - 1) % 16 == 0 && is_horzcommand& G- w: z# d+ ^( e' b) Q& G
else2 ~ q" b1 w; a) `
@move_state = 0
8 J4 J# R9 Y4 e K/ G* o# ^
new_index = (top_row + mouse_row) col_max + mouse_col5 k, I+ A/ Z0 [/ X/ _
select(new_index) if new_index item_max && new_index != @index- M; y0 q% H* i& Z2 @$ \5 V1 B
end2 \2 q1 E5 y( c
end
#--------------------------------------------------------------------------" i2 R0 q# p: Q' |' k* w6 m
# ● 判断鼠标位于菜单的第几行、第几列
$ u$ A1 d' z2 y+ W
#--------------------------------------------------------------------------
1 [4 m9 [2 B. X
def mouse_window_area
3 ]+ M- o+ m v. [/ c% U
if viewport.nil # necessary!
+ h# q I7 s" @; T: k4 g& T
vp_x, vp_y = 0, 0
, v) F: R0 `: F) e1 P
else' V4 L& n6 O* h. {& o m( L
vp_x = viewport.rect.x - viewport.ox
% _+ U5 M k: j
vp_y = viewport.rect.y - viewport.oy3 \. o0 G6 x7 ?( E t+ x4 |/ ~+ L, N: J
end
- H$ v U6 a) X* V v& {$ r
mouse_x, mouse_y = Mouse.mouse_x, Mouse.mouse_y- F# c1 @ c1 j
item_x1 = vp_x + x + standard_padding
9 i( g% w# K( F
item_y1 = vp_y + y + standard_padding7 C- K1 ^( s" C& a
item_x2 = vp_x + x - standard_padding + width
0 F; R( ]) }2 |/ k
item_y2 = vp_y + y - standard_padding + height
; g9 Y( @! I% c0 N1 n' `. b
if mouse_x item_x1/ [' a4 V" g" X9 _- C C7 P
mouse_col = -1* S4 F$ B5 c( ]3 L4 o$ M/ ~
elsif mouse_x item_x2+ K2 p5 m2 f5 F/ j1 ^! q
mouse_col = -2
" L* T' a; R. Z/ `8 O* K' L+ y
else
# o" ?9 l1 Y% m) t1 ?
mouse_col = col_max (mouse_x - item_x1) (item_x2 - item_x1)
Q4 J: S) {- T. p
end
8 k& b* N# z* ^
if mouse_y item_y12 u7 i% W2 L, G1 b( l3 j) g
mouse_row = -10 E j1 k! _$ j: z1 @, G" Z
elsif mouse_y item_y2+ Z4 W9 g& {9 D1 l+ \6 k1 N! [
mouse_row = -2
$ h1 i: n( J- o' h
else: q) x4 O& {8 P# w2 D8 K3 Q
mouse_row = page_row_max (mouse_y - item_y1 - 1) (item_y2 - item_y1)$ V9 u- H7 R/ j1 _
end
/ K# P% T. K, r" y% e) S
return mouse_row, mouse_col$ k3 u4 V# D! X4 I9 q# i
end0 r) N# G+ l$ I
#--------------------------------------------------------------------------
- i3 @( W7 E7 U3 P7 P
# ● 方向键移动光标时将鼠标移动到对应的光标位置- L% Z& C3 r$ P+ k
#--------------------------------------------------------------------------
, f% w6 {/ u; [! J
def set_mouse_pos
4 i0 ^) u. t9 y+ }8 l
if viewport.nil # necessary!% o# q1 S1 Z8 ]# H
vp_x, vp_y = 0, 05 n# E: ]) A) K( p
else. C' R( L6 Z, g6 u3 [; w
vp_x = viewport.rect.x - viewport.ox! s: f) ~* s( [- H+ h
vp_y = viewport.rect.y - viewport.oy
, Y3 ~7 U4 v1 |& y/ Q/ L6 j) t
end
* W- ]' [7 i3 b; [
item_x1 = vp_x + x + standard_padding
/ B9 [# }1 g+ V! F) _/ O
item_y1 = vp_y + y + standard_padding
: ~ O2 z& Y. {
get_index = [url=home.php?mod=space&uid=370741]@Index[/url] 0 0 @index
; L8 W# u7 ?) ?* ?+ m: e
row = get_index col_max - top_row
2 N1 {" y/ x/ P; n
col = get_index % col_max" B# S3 ?/ q! j! s6 V/ E
new_x = item_x1 + item_width (col + 0.5)2 k2 P! h. l% b$ X; u
new_y = item_y1 + item_height (row + 0.5)* `3 }# s5 ]2 ], Q c
Mouse.set_mouse_pos(new_x, new_y)1 h& h }, J3 I2 o
end6 d5 P3 B: U7 D- O0 W
#--------------------------------------------------------------------------. f! H# e) L" _; @1 j$ J# f) y/ o
# ● 判断菜单是否需要卷动
7 O! n f, z( X5 Y" o
#--------------------------------------------------------------------------
8 Y, ^) ~- }4 q2 L7 P
def need_scroll
1 ~3 o" p x0 q- K! G
item_max col_max page_row_max% _% r7 X Y. l7 [& A# V- E. L) k
end
- T) e% n, W; c3 D( z8 r( ~
#--------------------------------------------------------------------------) T+ ^1 @6 w' a+ X
# ● 判断是否为水平卷动菜单% w k# _: X, s8 q
#--------------------------------------------------------------------------$ f. N4 G F' Z7 L$ S
def is_horzcommand
' G9 I. c1 y2 D9 [- \
return false+ i9 g, i" j9 C/ T
end) K* Z7 v3 T0 K6 k
end+ B4 [. O( e1 `* \ ~( z- e# l9 i; X. v
9 W7 d6 Z9 T& g6 O, k- k- \+ |
class Window_HorzCommand
# q. n. L' \6 T) h1 N1 C; H3 j
#--------------------------------------------------------------------------+ a3 d9 @- M4 I- Y( Z
# ● 判断是否为水平卷动菜单- n/ B7 j: x2 S' H
#--------------------------------------------------------------------------+ Z3 H* _% C; Q+ X* E
def is_horzcommand
8 N- {2 _; b) a# Y+ z0 J* q
return true
8 ~+ P/ b3 j k; z/ T
end
- s" d( P1 L P6 q* V7 H
end
1 p; n# {: {; i+ |( |, D
* B0 \2 ^$ ^7 ^, C! ]$ D
#==============================================================================4 J) y: a% c0 p" F0 E! A! q9 o
# ■ Window_NameInput
3 O6 U$ o& ] x: d; G
#------------------------------------------------------------------------------
( N/ D0 j6 z* b/ p# }% l
# 　名字输入画面中，选择文字的窗口。
' N6 ~( D: z# ?
#==============================================================================
( H: k$ o( C: N$ ?- r
class Window_NameInput$ s) U6 j. N: O% o; m% D
#--------------------------------------------------------------------------
! ]8 A, Z$ s# z: U
# ● 设置列数( c; o' y3 C; u5 W$ R& I% W
#--------------------------------------------------------------------------; c1 F) ?# P0 U5 s
def col_max
1 N Z+ g+ A6 j( @
return 10
" Y6 i' N' ?$ P* {" o* ^. F7 {
end* B$ _' v6 u) l! C8 x3 }" k+ `
#--------------------------------------------------------------------------
! T% b; ?. J+ E" f# x$ F; d% S
# ● 设置填充的Item个数5 ^. C( [" r0 w$ |$ q* c
#--------------------------------------------------------------------------3 j8 \' T! `0 S, [; r8 n
def item_max
, e, h: K& Z& I" G7 ]8 t
return 90
0 o& W* \% }6 |# V" W" O
end5 `) O& P4 {, w) }* Q5 I
#--------------------------------------------------------------------------& V z s x* q. b
# ● 设置填充的Item个数
. A" _) k. M: ~* h3 N5 t
#--------------------------------------------------------------------------. z# s3 E( F/ O
def item_width
4 r" M9 \2 [; q) c- Y: K
return 32, |' L. [8 z* C2 R
end
+ a! I2 b2 A% c/ U7 ^
#--------------------------------------------------------------------------9 g) f3 R. q& Q ]# N
# ● 判断鼠标位于菜单的第几行、第几列
2 j* r! U" b: [- h
#--------------------------------------------------------------------------
4 i1 a7 \1 J3 Y$ g$ q4 P/ {
def mouse_window_area. x! ^1 B- G8 F/ D
if viewport.nil
( [# e) d( z- [/ |* u
vp_x, vp_y = 0, 0
9 y0 ~/ {/ q2 ]1 b
else
4 |9 W$ C8 L9 ~" x
vp_x = viewport.rect.x - viewport.ox
2 |& e1 n c: ], e9 ~7 X
vp_y = viewport.rect.y - viewport.oy
+ z$ X" s K; B! F+ I
end) b( n) z- r" o, z$ A/ k$ B
mouse_x, mouse_y = Mouse.mouse_x, Mouse.mouse_y6 E. x- ]$ _) H" S1 S8 P
item_x1 = vp_x + x + standard_padding
5 w' r, v9 |6 e! T
item_y1 = vp_y + y + standard_padding
5 R, _3 P( \ m7 A/ u7 B8 D" E
item_x2 = vp_x + x - standard_padding + width
; P! W, n! B3 ~
item_y2 = vp_y + y - standard_padding + height
/ W2 \, ?4 @1 S$ U
if mouse_x item_x1
! _( ?8 q6 H, P4 x5 S
mouse_col = -1
2 L# Q( Z8 ?# ~+ T1 t
elsif mouse_x item_x2
; K4 B. O" k+ ^5 O2 m- i" U9 d
mouse_col = -29 G7 T$ Q. O% u/ q7 @) @
elsif mouse_x item_x1 + 160
5 [: I1 C7 w v0 L5 y
mouse_col = (mouse_x - item_x1)32: \3 o/ M+ z0 K
elsif mouse_x item_x2 - 160
% J4 j/ p9 q( o( L, i
mouse_col = 9 - (item_x2 - mouse_x)32
. G/ T' d4 Y% T; h: k% J" C
else* T; A. G1 w, ~) T, ?% {/ A
mouse_col = mouse_x x + width2 5 4) P& o# s2 F7 r% k+ E) j6 ?
end
/ E$ _1 c: S5 }! C! G
if mouse_y item_y1* l. Y. i# }" N# G
mouse_row = -1: _& l' o/ a2 g* }/ g) ~2 B% ?! ~
elsif mouse_y item_y2" Z! o2 u( n( k3 |
mouse_row = -2
$ j3 s" ~4 v+ G8 N4 z3 m) O% O
else
- l4 P( }/ Q x' x) K$ w
mouse_row = page_row_max (mouse_y - item_y1 - 1)(item_y2 - item_y1)% \# J5 \; Q& ^
end- A( X6 I" i! L! [: F
return mouse_row, mouse_col4 B% k3 ` t' S W8 T* t/ R
end8 o7 ?2 X5 D# l% T/ y% t
#--------------------------------------------------------------------------
& [/ N) l E- I. D
# ● 方向键移动光标时将鼠标移动到对应的光标位置
' U- ^- t) W4 c2 N
#--------------------------------------------------------------------------( f1 }; O0 V: ] J5 p8 y0 W
def set_mouse_pos
8 S8 `) a1 m. `9 r- D6 B
if viewport.nil # necessary!
! u; o% K+ U r! {4 n+ U. N4 M
vp_x, vp_y = 0, 0$ }7 T/ u$ Q6 M# C8 [: U
else
" J+ r. S) `9 Y! g' [+ M
vp_x = viewport.rect.x - viewport.ox
0 l+ D6 C8 A7 m: g( b+ {
vp_y = viewport.rect.y - viewport.oy
6 S/ ^9 C$ _7 F% i5 d4 |# N5 `
end0 L& N5 W$ [/ B2 a. e
item_x1 = vp_x + x + standard_padding 4 | C) B2 t, P" S5 C1 ? g
item_y1 = vp_y + y + standard_padding8 ^$ |4 G4 k- x1 g; n% u# ?& ]
get_index = @index 0 0 @index
$ P2 u6 p3 ?* ~) M
row = get_index col_max - top_row
) s$ ]( k' O+ e* \, O. h8 \5 W
col = get_index % col_max) d/ u) q! J6 I! @) u
new_x = item_x1 + item_width (col + 0.5)
: j7 e- g2 x6 p, {+ \& @) j/ v; D
new_y = item_y1 + item_height (row + 0.5)
( R3 Q+ \5 o* n6 M* |% J1 s
new_x += 14 if col 4
* Z$ i$ a5 `8 G. `
Mouse.set_mouse_pos(new_x, new_y)
Y3 Z' T1 v- V. v
end' `! c5 F% T7 U- J5 L t
end
* l1 U! I% B! ]8 |+ Q/ I
' b$ M! T( {2 B9 L; x
#==============================================================================8 j* l, q4 ?6 g* ]) x0 P
# ■ Window_NumberInput
7 f9 K. W: Q$ Z; s9 m1 C6 B/ D
#------------------------------------------------------------------------------3 b! B( i0 o8 r6 F$ S
# 　重写了数值输入的方法以适应鼠标
! ^$ l8 w( K Y* i) O
#==============================================================================& V) Y3 Z: ~2 \' @7 W3 }
class Window_NumberInput Window_Base
. I8 x. D: d% c3 G
#--------------------------------------------------------------------------# r4 p/ y7 G1 G% X; [7 |0 L5 Z
# ● 定义实例变量
; ^: L5 E% B$ h) `+ ]) b
#--------------------------------------------------------------------------9 n! S0 V! l; D6 Z: ]: e( X+ ^
attr_reader extra_window
6 J* L( k; `7 h! n2 q/ T
#--------------------------------------------------------------------------) ^4 d, V; E; |6 C$ H
# ● 初始化
2 W `; D e3 I/ n0 r' g, f( i
#--------------------------------------------------------------------------
( e6 Y2 o8 o: c5 \7 X
alias sion_mouse_initialize initialize0 r; S: X% J/ }, s7 q
def initialize(arg)+ D2 K+ w' R7 `- f
sion_mouse_initialize(arg)
3 \, S( O5 @5 f! T. ?6 q
create_extra_window6 F6 E( M! X! l) M% U4 g/ R
end
( h+ r" K$ {" [" X
#--------------------------------------------------------------------------$ D- H% F: m8 x! l+ n
# ● 启动
+ w7 \% r% C' W6 X( z. ]+ z( j
#--------------------------------------------------------------------------+ M# l7 `8 s0 e9 ]
alias sion_mouse_start start
* H7 e0 V* O; }% j
def start+ P( Y# | `( k D$ G g* v0 J. m
sion_mouse_start
$ F: S) G: ^* Y |+ o: U
deactivate
. O: K I; m8 i3 V) R
extra_start. s; R" }3 b2 f9 R7 z- b4 G- o9 Q7 B
end$ v5 T5 W, A$ |* g% |, x. i* i" D" ~
#--------------------------------------------------------------------------) ^" `% p8 E# q2 p8 y* t) }* ?
# ● 创建新的数值输入窗口
, Z: t7 i N; N( A8 E( ?1 J) X
#--------------------------------------------------------------------------
2 J' l9 j U- g: T D5 Y7 e. {
def create_extra_window% T. s/ }& F' N# f8 i, q2 A
@extra_window = Window_NumberInput_Ex.new
% K0 y1 d( n3 s2 t* N( {
@extra_window.x = (Graphics.width - @extra_window.width) 2& ^0 j" f% R( H' I. ~- i1 @
@extra_window.number_proc = Proc.new {n [url=home.php?mod=space&uid=27178]@Number[/url] = n }6 t3 ?0 y$ H3 M! U9 B
@extra_window.index_proc = Proc.new {n @index = n }2 K% u( }( h5 o# _; Z
@extra_window.close_proc = Proc.new { close }( g6 g, s0 U2 u5 n+ W1 k3 Y& k
@extra_window.refresh_proc = Proc.new { refresh }% g) C! R3 f7 e
end
$ r' K- n3 v, b; M7 ?8 d
#--------------------------------------------------------------------------* U0 @' }0 J: U- ~, A
# ● 激活新窗口
5 A, ^! i% I/ I7 e" e/ d9 G
#--------------------------------------------------------------------------
" ?; R o; `4 R* |7 |3 S( Z' c
def extra_start
* R- G3 Y, `7 I. ]
case $game_message.position/ Y% W3 Q( E; D8 u
when 0; @extra_window.y = y + height + 4
. L( h6 d; ^4 z5 y
when 1; @extra_window.y = @message_window.y - @extra_window.height - 8/ v$ l0 c( y- X- B
when 2; @extra_window.y = y - @extra_window.height - 4
& J2 X+ C* b- Z
else ; @extra_window.y = 8+ X) q e* O! l- n; e
end2 _- N4 g8 w+ F0 J. Y6 t& K
@extra_window.variable_id = $game_message.num_input_variable_id
* q( _: l0 U7 C1 ]! k- c, q3 H
@extra_window.digits_max = @digits_max3 y6 ^$ L4 C* Z2 f& o
@extra_window.number = @number
; f, _& v4 o' ?
@extra_window.open
6 ~7 [% X1 @, |5 @. N
@extra_window.activate
, m( L6 w& E" N1 i# E+ I
end
9 z* A$ V' y$ T' u+ r* ?' |
#--------------------------------------------------------------------------
. I* K; b C7 S" |1 o& K" L
# ● 更新
4 n# f; f1 F( z0 U
#--------------------------------------------------------------------------$ {+ J$ E1 p7 Z% o& ?
def update
8 F# K* b+ z: v5 X! n
super
+ b& P$ I' m7 K8 Y
@extra_window.update: T8 D' `' E$ s( e- H' V m
update_cursor, y) m' F) ~( @. U `$ k7 s0 q
end
, L/ D I7 O& i, A- Z$ E& l
#--------------------------------------------------------------------------
. G- F9 v. m* E9 b: e
# ● 关闭窗口: h$ _+ V; l2 J8 P' {% b
#--------------------------------------------------------------------------
0 F) W* j6 V; W' h/ ^7 X, [
def close
2 Z& H2 b6 G6 m: z, H3 u9 f. ~
super
+ p; t2 B2 l6 x2 L9 X
@extra_window.close
" M) E4 V1 w: t% M1 q# E6 b, z; ]
@extra_window.deactivate) y7 ^, f4 H, D
end
+ m# L+ ]. ^ Z6 a' E
end
: N& s+ T# t, o5 x1 v9 U
# X) b, n5 l% \5 y# z4 W% L* `
#==============================================================================
4 X) b+ O' ?" X; h# x8 U1 z
# ■ Window_NumberInput_Ex
; s# a/ A Z! V( @. `% }+ A
#------------------------------------------------------------------------------$ N( `4 U# q/ ?% H/ j
# 　新的数值输入窗口(NewClass)
* j& n3 S _5 m( X ^
#==============================================================================
/ R# S+ E. ^0 K3 a5 Z
class Window_NumberInput_Ex Window_Selectable1 o. x( l* b2 P; f2 k% E
#--------------------------------------------------------------------------( x+ G. F4 x0 U% r
# ● 定义实例变量
% h5 G! n2 {7 X# z: @8 Z5 t
#--------------------------------------------------------------------------. j/ f* x) S% R g. {9 y- U/ r& w
attr_accessor number_proc9 n( t6 u6 z8 h' X4 T
attr_accessor index_proc3 Y- l! m2 y2 ^
attr_accessor close_proc t, W: I& a& p7 ^+ v3 T
attr_accessor refresh_proc
L8 R4 K' ]) F# j2 D
attr_accessor number
3 z2 b- t) d; v" V
attr_accessor digits_max0 h' `+ i/ ^) k! R4 f* C6 K
attr_accessor variable_id$ T, o6 C5 y5 R; g- S7 T* N
#--------------------------------------------------------------------------1 Z+ Z* z: Y) C/ z. o0 u
# ● 数字表
; z# t* V9 L# f+ ~2 V1 V, l
#--------------------------------------------------------------------------5 j: A0 \/ \7 ~. L& w& ^* Q
TABLE = [ 7, 8, 9,
4 M: _8 _ g% n( u& P
4, 5, 6, W! t8 j& ]- d
1, 2, 3,
0 b: s9 d s% V0 m3 l& E
'←',0,'确定',]
0 O% v) t9 G- G& @+ X2 F, |) _8 n, n+ X
#--------------------------------------------------------------------------1 ?* I6 F: y! p0 s* l
# ● 初始化对象
7 D4 ^6 c9 j4 Z1 [' M6 T8 N
#--------------------------------------------------------------------------, ^% T; u1 W ]. a4 l
def initialize( W: Y* v6 _) W: U# s1 o0 t
super(0, 0, 120, fitting_height(4))
5 ?8 ^' F& B1 P* Z
self.openness = 0+ Z4 R* c" A! F9 B
@index = 0
0 |% A1 d2 }9 o+ A5 K; L; k8 c
@number = 05 {" o1 Q: c: K9 U, w
@old_window_index = 0
* Z E: W5 \2 R/ R4 \/ |
@digits_max = 0
+ p% `8 W/ v! C5 |
12.times {i draw_text(item_rect(i), TABLE[i], 1) }, w" p" S2 W! Q# m* B! D
end
! n" t. J- `( F
#--------------------------------------------------------------------------
7 \ T$ Q- F( C: T D
# ● 获取项目的绘制矩形2 o+ k# p. k3 L" J# Z1 \
#--------------------------------------------------------------------------
1 h0 S4 \ ?5 i4 {8 A+ r
def item_rect(index)) z- d( \2 ^, s- G( U
rect = Rect.new) }" L; p9 i* G$ A" y9 I: A1 r
rect.x = index % 3 322 m1 l6 F. L# E! e5 a& t
rect.y = index 3 line_height' o4 T' r7 z) a6 G3 N
rect.width = 32, T3 c( Y; R6 ^% [
rect.height = line_height
5 H! @- @* D4 g f
return rect
# b4 Q; Z7 p. r( r! [! A
end7 P* `8 t3 @, C5 W
#--------------------------------------------------------------------------
0 a( q3 ^8 L P4 o! K' m" y8 @
# ● 将光标设置到鼠标所在的位置6 _! [, c. C% P% s' Q
#--------------------------------------------------------------------------
! ^5 _; I" L$ k& w
def set_cursor
7 ]* O: C3 M" c8 i- J
mouse_row, mouse_col = mouse_window_area/ f4 \8 S* m! Q; q
if mouse_row = 0 && mouse_col = 0
/ Z- |# B- u# o+ ]7 z8 V
new_index = mouse_row 3 + mouse_col
' O& p0 i4 S$ d, J
select(new_index) if new_index = 11
# E j8 p, Z) N' Q; D' v
end
e# s: ] I, I* q% P+ |
end. H- t6 C6 q% _& C3 {
#--------------------------------------------------------------------------
8 g- k. i7 `7 T% |
# ● 判断鼠标位于新数值输入窗口的第几行、第几列
! G& y0 u* V% d2 v
#--------------------------------------------------------------------------
2 ]+ D, H" q% B
def mouse_window_area" d# e( i( G, Y7 ]* d; Q$ P
if viewport.nil0 I7 [' c: a6 z5 V' B
vp_x, vp_y = 0, 0
5 I& r4 c# u4 ? f7 f, T
else
8 j7 K( Q' O& x* e1 _0 ?5 t
vp_x = viewport.rect.x - viewport.ox8 i5 B1 Q2 R" N- e4 |- E1 S2 r( f
vp_y = viewport.rect.y - viewport.oy! m3 u T, ^" e9 Y4 Z. @* S( P
end
' B; u0 Y: Y5 v! X* y% l' z* J
mouse_x, mouse_y = Mouse.mouse_x, Mouse.mouse_y( o( S2 [8 P2 Z; S( J, Z, y
item_x1 = vp_x + x + standard_padding + w6 Q( ]% j9 A; Y* L
item_y1 = vp_y + y + standard_padding
2 V3 K+ ^8 V) k1 `. c
item_x2 = vp_x + x - standard_padding + width
( v8 ?; H+ k/ g4 j! c- g
item_y2 = vp_y + y - standard_padding + height
0 O! Q: W; s! K6 H0 }
if mouse_x item_x1
, s, @1 o8 f0 i( q. k6 [5 B
mouse_col = -14 q: r' D% t9 o3 N! x+ d- \5 L. |( D( G+ R
elsif mouse_x item_x26 l" y$ _$ ]! Z
mouse_col = -2
( j) b0 S" R& q$ k [
else
0 a$ B: u) |5 r1 G4 L5 K
mouse_col = (mouse_x - item_x1) 32
W" t# ^6 d6 C+ j8 S+ ~) b
end; R9 _* h; J$ o( B% S; e
if mouse_y item_y1
9 Z+ J$ H; H- |( r z% T" k
mouse_row = -1
, S" E {$ ^! r! [4 a2 E9 P1 g
elsif mouse_y item_y2) | Q3 H( ~( ?' z
mouse_row = -23 a2 `2 C; v/ h, q: G7 W
else
4 O' @0 A7 {% G5 Q* q
mouse_row = 4 (mouse_y - item_y1 - 1) (item_y2 - item_y1)& I/ A3 j l; C) \7 J3 t0 E% `# o
end
: N. N6 a* W. r. \5 D0 s2 n3 l! L
return mouse_row, mouse_col
- @, _5 e# t. `% D) [' O3 p3 m
end
1 ?( K$ U/ C) ~4 h1 x' q7 A2 f; H+ ]+ w
#--------------------------------------------------------------------------
$ \6 g: M0 d: M4 P4 W$ [
# ● 获取文字. G' a* Y1 R: ^6 J5 a7 N
#--------------------------------------------------------------------------
# Y6 G% O8 T& f# [9 G& n
def get_number! M+ J" i% R5 d5 o( k
return false if @index == 9 @index == 11
' A4 x o1 @+ ~( y2 X
return TABLE[@index]. {1 Q! c4 G7 ?; ^7 e0 U2 y" z
end9 L' W4 }1 i$ } B; H4 L; l
#--------------------------------------------------------------------------
; T7 k. H. A0 a! k) i7 D" k# \; i, R
# ● 判定光标位置是否在“退格”上! ~1 q( g! b/ j/ F3 R/ X
#--------------------------------------------------------------------------% I$ H5 g7 G# `$ `& L
def is_delete8 Y! u0 R( R2 f* K6 }
@index == 9
2 k% A: R& t' S, Z
end
) e2 G: Y. |/ D& B6 |8 ]( V+ Y
#--------------------------------------------------------------------------
0 m0 o# v9 z9 a/ V& g
# ● 判定光标位置是否在“确定”上/ m) U) _3 @7 B+ R+ s* l
#--------------------------------------------------------------------------
( O* ?% t% i. C8 [( i
def is_ok( N% \/ ^9 q' L9 ^
@index == 11
& n/ d% Y, {0 k5 v
end
5 L/ O& p# q, n) [
#--------------------------------------------------------------------------
9 @& x( |' }" O$ q- E/ A. _
# ● 更新光标7 |3 Y$ |; Y0 s+ g5 }% j
#--------------------------------------------------------------------------
; D% B. r. w; m% F9 z8 I
def update_cursor1 G% [* |8 L6 l+ z) ?
cursor_rect.set(item_rect(@index))
! R ^! {3 ~* d7 w6 q! n
end
) q1 G" j6 B8 K0 B
#--------------------------------------------------------------------------
" {2 y7 @( |! Z3 M' V
# ● 判定光标是否可以移动
( C& p4 F8 ~& M% D$ b( ~) Q7 h
#--------------------------------------------------------------------------
" ?5 t) @, {) z
def cursor_movable3 C4 C3 W/ F, G
active9 |' w( h6 n( T9 W4 R5 P
end8 [2 r0 {6 X+ w( x
#--------------------------------------------------------------------------
3 }9 r" e: D6 ?4 U5 m
# ● 光标向下移动 z7 d% q' x) Z7 y ]# E* ^
# wrap 允许循环: ~1 ?- X, q: y
#--------------------------------------------------------------------------6 Q5 T* H' k& g9 P
def cursor_down(wrap); ~* @" L8 k: B- @
if @index 9 or wrap
: L. M1 k7 d! N& M* w
@index = (index + 3) % 12
% J+ G" j4 K9 p# F% i/ H5 [
end
7 c1 R B2 O) B) w3 S9 }% ^
end
5 o/ r% D8 I4 {8 @/ d5 ^
#--------------------------------------------------------------------------0 V* u5 ~7 B# g8 L |: i
# ● 光标向上移动' U" t6 |- f. t+ Z2 J* Y
# wrap 允许循环
. C& K |* c7 V" |# G
#--------------------------------------------------------------------------
/ ^1 `! u. Q! Z
def cursor_up(wrap)! W1 G U' T1 ^' j n
if @index = 3 or wrap6 i, n4 o0 Q: ^7 p; F
@index = (index + 9) % 12+ c7 v4 l( j, M: s, a8 K) h1 v9 q
end
, k- ~: E) ]( W* ^
end
( a/ N9 ^& \7 I3 C8 p/ S1 c2 s# S
#--------------------------------------------------------------------------+ ?: a H% f9 [ A$ G9 u
# ● 光标向右移动
: M ]4 n/ I3 U+ k# G8 k
# wrap 允许循环
0 ?( H: D! h/ _
#--------------------------------------------------------------------------/ a$ E `# k# @
def cursor_right(wrap)
2 [; ?- d7 P; b% T* }
if @index % 3 2) O6 }5 |, y+ @& u9 V9 T% ^
@index += 13 Q9 V% d e2 k0 y* t
elsif wrap9 m+ C. a7 C* a; X! \
@index -= 2
* {& Q( ]3 y3 n* f- q, T; b
end0 l+ H+ K# E; F _3 g5 q
end/ D* f* }( R7 r4 O
#--------------------------------------------------------------------------: o; ?4 I. T% M' r) [& `
# ● 光标向左移动/ R. S( {- b1 O3 d) L
# wrap 允许循环
6 h; B5 k' j$ T' R" u+ D' c
#--------------------------------------------------------------------------
& A( h, b3 T( q$ t" F- Z4 g
def cursor_left(wrap)
$ L- i( ]3 \$ c0 b
if @index % 3 0
( X" B$ P0 @$ }2 u) q. c3 c* q
@index -= 16 Y- w4 ]8 t3 m
elsif wrap; {: M# j* }4 W$ r3 j' T5 M
@index += 2
5 o& g9 v% Q: p
end
9 D) X; V6 x- \; {1 o7 S5 M
end
: P% {! ]7 ~2 Q& }8 ~
#--------------------------------------------------------------------------$ C3 e1 u% B) |1 ~( s0 g/ K4 l
# ● 处理光标的移动
& @* G& ]! ~5 m% L0 N. \
#--------------------------------------------------------------------------
& D: D/ D- C& K8 E0 \1 B! h
def process_cursor_move- e$ j8 o/ I* c* [& W( c& Q5 T5 }* Q8 q
super# I' u/ K) I0 s1 U* P& B
update_cursor- G o: \9 H d
end6 d$ x4 D9 J1 R) b
#--------------------------------------------------------------------------0 U; m5 e N8 e4 a5 P5 N7 |5 [
# ● “确定”、“删除字符”和“取消输入”的处理
! ^* z+ x9 V" i4 G" |8 S0 F
#--------------------------------------------------------------------------
+ T \1 ~6 U+ p5 n5 J
def process_handling) r/ R* I. V! J" F1 r) ^* |
return unless open && active( X# g9 ^1 y* B3 H6 n! `" s% d
process_jump if Input.trigger(A)
1 a5 K, f& g5 } x+ R
process_back if Input.repeat(B)
* {# Q) j* o# ~6 u
process_ok if Input.trigger(C)
% _: P5 S% O3 b
end i. f( b) w a! o4 f7 ^
#--------------------------------------------------------------------------3 t8 `) N0 c9 X: `9 [5 [
# ● 跳转“确定”' P. c5 c- m5 c0 l! Q
#--------------------------------------------------------------------------+ u9 A5 p4 K' e
def process_jump
' |( @ W: `' e- n2 O( z" `2 H
if @index != 11
! a6 Y8 q/ }0 {9 w" y$ ^( Y$ h& q$ Z
@index = 11
& y1 v3 U0 f3 R. v
Sound.play_cursor; s5 @0 _6 D7 d8 ~+ A6 z
end
9 V5 G3 q y r. Z5 h3 h
end) N( O/ q, w* D+ I! ~
#--------------------------------------------------------------------------" P+ O4 r- [( K3 d4 R
# ● 后退一个字符# C: v0 A; c1 ]$ l' I2 I
#--------------------------------------------------------------------------$ x+ z7 d. ?0 K4 W( ?$ N
def process_back. b1 f8 }% n# Z, J
Sound.play_cancel
" Y4 ?0 {: L6 S, O( |8 [2 e
place = 10 (@digits_max - 1 - @old_window_index); h9 @% J+ Q: P$ \7 z
n = (@number place) % 102 w5 j, b( B$ U, f1 k. K% P
@number -= n place& K6 z8 N! b7 F6 V
@number_proc.call(@number): G! f2 o0 R* W! S' A6 t1 Q1 j3 R: U
@old_window_index -= 1 if @old_window_index 0& D- R! U' R* u& `7 s1 o9 k
@index_proc.call(@old_window_index): v; |0 x- f+ f8 i) s" D
@refresh_proc.call# @" I* n% R; B' v* }' F7 K8 t
end$ M. w' ^ ]' u# i6 e
#--------------------------------------------------------------------------2 r0 l/ \2 x1 D# }8 f4 V
# ● 按下确定键时的处理. t3 O' a* u" M0 E5 W7 d4 V' L: b
#--------------------------------------------------------------------------% X8 Q! e) c: u
def process_ok3 L9 n" i5 J% F
if get_number" x$ Y. e. B! a) |7 k# S1 a
Sound.play_cursor
9 W& g# b, D) d2 I) Y1 P9 Z
place = 10 (@digits_max - 1 - @old_window_index)
/ _6 y! Q& T- j, C& G
n = get_number - (@number place) % 10
6 G- X8 j3 C! H" C, K7 |
@number += n place8 g3 U+ j0 U! G, n9 g
@number_proc.call(@number)0 ]5 a' x# S |" r( c' G4 `6 n9 c
@old_window_index += 1 if @old_window_index @digits_max - 1
2 Z# P: v5 b/ m9 Y, w8 E5 }
@index_proc.call(@old_window_index)
, L! z5 R( ^1 u$ d+ D
@refresh_proc.call
3 h6 ], Q/ ]0 a9 k
elsif is_delete
! m B: J8 T) d/ M8 h+ x, y
process_back4 C( w0 f3 x- M+ |
elsif is_ok: p l' o% H8 Q
on_input_ok' F) C- z r' I. h% A
end& M8 \6 a! T( C4 g/ Y& Z; y
end
1 m5 F0 i: m/ b3 L
#--------------------------------------------------------------------------7 O9 f) U% O/ U
# ● 确定
/ S3 _# o4 ]$ a6 G$ [) P6 c" n
#--------------------------------------------------------------------------! G* B7 N% f/ D" i( |- d
def on_input_ok1 q; [/ o/ }8 c+ d3 w
@index = 0( u+ ^0 o! ]: U& ]2 `2 X
@old_window_index = 0
- o9 F5 p K4 N
$game_variables[@variable_id] = @number
# B8 m/ H7 F' S+ J) g+ Z0 f n
Sound.play_ok- L( l/ D3 q' M$ u1 k! m+ j& n9 b6 o$ ]
@close_proc.call- u5 J2 e( k7 ]; z1 l7 } R
end* ^8 C$ S1 @+ g( h2 N3 T. V" `4 |
#--------------------------------------------------------------------------. v+ R" A+ T- U$ w9 p v& u1 U
# ● 方向键移动光标时将鼠标移动到对应的光标位置
1 U. T" }/ S$ d
#--------------------------------------------------------------------------
+ S# O3 E8 G: |/ ^# g+ Z
def set_mouse_pos0 w1 T( ? z1 v/ v+ k& U
if viewport.nil # necessary!
3 v, n0 X2 v' _
vp_x, vp_y = 0, 01 ~% O, ]5 D( V/ w6 {
else
9 a2 ?' l: \; ?$ g* i
vp_x = viewport.rect.x - viewport.ox
. B. b5 d( ^, |4 v$ _. t5 j/ l
vp_y = viewport.rect.y - viewport.oy
9 a- i7 D4 c9 _3 j' f& h2 R* T
end
9 n- J) `# w6 M& I
item_x1 = vp_x + x + standard_padding
) d# V! F! }5 T1 t- S% R- T
item_y1 = vp_y + y + standard_padding5 Y! a' p4 X. N' c4 D( S8 _9 x
get_index = @index 0 0 @index
, J/ @9 }# `: ?! x& }
new_x = item_x1 + 32 (get_index % 3 + 0.5)- Z8 c+ Y* ^: Q- d/ l. o$ w
new_y = item_y1 + 24 (get_index 3 + 0.5)/ {. u2 U* b H" w) {' Y
Mouse.set_mouse_pos(new_x, new_y)
; s1 }; }* J# g4 h5 a. N) J2 R
end
' j6 l3 i W- K+ P+ A7 \" [
end( O) o+ D' G. O5 }. f
6 A" F/ T3 L" E0 `9 o& c
#==============================================================================2 l7 r4 ^. Z! F+ i6 d, I4 Y+ z* m
# ■ Window_Message& k: u) k: Z( r* |. z% y
#------------------------------------------------------------------------------
4 U* w" s5 c/ f2 u' E0 F; w( |
# 　显示文字信息的窗口。
# e6 L- l& r* N
#==============================================================================% J$ x7 K6 }: b* Z
class Window_Message Window_Base
& |1 j" A# ?; p* R* b' I, Y
#--------------------------------------------------------------------------
# v5 u6 h: S* x7 g% b8 d6 U
# ● 处理数值的输入（覆盖原方法）, _: K9 _1 I( f
#--------------------------------------------------------------------------+ [; J% S8 a) d4 X( V
def input_number
. H9 m: h7 D9 U, @
@number_window.start
* b0 q4 G1 I5 \0 F8 U7 P
Fiber.yield while @number_window.extra_window.active) a3 N' i) j% R$ x# z
end
$ `& a* _3 d7 f
end3 \# t) ?! g( ~# F7 m( a
1 K" i. r$ Z0 B) n/ f" C
#==============================================================================
6 C0 i: e+ [: X- x* D/ y, a" t- A
# ■ Window_PartyCommand
' K! \5 @4 h0 ^0 {
#------------------------------------------------------------------------------' A# Q' A0 l2 c2 V0 u! @, O/ G# d: S
# 　战斗画面中，选择“战斗／撤退”的窗口。! u" {* v( i! D& N l1 T
#==============================================================================
class Window_PartyCommand Window_Command" `# t% o- {/ k: y7 R; Y! [. K5 `
#--------------------------------------------------------------------------
+ Z w0 m# A- x% D' O
# ● 方向键移动光标时将鼠标移动到对应的光标位置3 {! U U, _! o$ ~' v& K
#--------------------------------------------------------------------------9 H4 F* _* I0 R& k0 S- A! f
def set_mouse_pos
7 v; w, o" X4 n
if viewport.nil6 | l4 Q! d$ r- s# H( A
vp_x, vp_y = 0, 0
. }/ K7 `* c) }. F$ d7 j* o C
else6 r8 W( M8 a! n! h1 @0 n: w
#vp_x = viewport.rect.x - viewport.ox
3 Z6 b" R& h, D* {" [, X
vp_y = viewport.rect.y - viewport.oy2 q$ ~4 T7 O5 x9 H. p
end, ^/ b5 G( n" _; m) f( S; y
item_x1 = x + standard_padding / X2 h% V% N1 s; V
item_y1 = vp_y + y + standard_padding! h. X/ Q( R9 A0 p+ J" V1 I& [' v
get_index = @index 0 0 @index & [& Y! P; S/ t- Y8 R) K8 y, A) O( k+ O6 Y
row = get_index col_max - top_row
# s$ n7 N9 s& d
col = get_index % col_max$ E$ N h7 g7 b/ Q" W
new_x = item_x1 + item_width (col + 0.5)
! _9 a# m$ @9 W8 G
new_y = item_y1 + item_height (row + 0.5)- W) s* A0 ]4 d8 A7 n9 J
Mouse.set_mouse_pos(new_x, new_y)+ o9 X# Z; B. h) w6 [6 o( q
end
8 t) L6 \$ j8 I7 ~& F: t
end
$ u' w5 D- ^3 c3 @
. G' }% ?3 V( |. V! O
#==============================================================================% ?8 z: L1 k0 ^4 Y) M& [$ o6 \) h% m
# ■ Window_ActorCommand
1 N( E7 n* J- Z" L4 y9 p
#------------------------------------------------------------------------------7 R* {% Y* S% \9 w2 Y$ K! c/ u
# 　战斗画面中，选择角色行动的窗口。
+ B: G E4 m4 y% C7 v$ \
#==============================================================================6 C- f* \. A& J* T
class Window_ActorCommand Window_Command
' q+ c \1 k/ O. o2 N
#--------------------------------------------------------------------------
0 d* l- a9 l9 U1 R+ G+ P
# ● 方向键移动光标时将鼠标移动到对应的光标位置2 s/ Q% A( C: S- F
#--------------------------------------------------------------------------" k0 B( ~; G' {8 l9 _
def set_mouse_pos
. H8 f1 W9 {. {8 E- }8 c
if viewport.nil/ b; V6 `% s: |" e R
vp_x, vp_y = 0, 0
: I+ ?9 ~. U8 C |- X( E+ J: @
else, m: {5 |& w* }7 @2 o
#vp_x = viewport.rect.x - viewport.ox
0 R9 z) A% w% L2 G) q
vp_y = viewport.rect.y - viewport.oy
) S. E- `6 Y6 z1 a* b& C: C
end* a+ }' Z+ r- V" H" F2 Y
item_x1 = Graphics.width - width + standard_padding- Y0 `" T) A% g9 s1 f, D
item_y1 = vp_y + y + standard_padding6 |# ?3 L; I1 D* c
get_index = @index 0 0 @index ) N/ G9 D% N% f" i* m+ S) D
row = get_index col_max - top_row
$ Z5 T7 G# E% C2 K# ~0 c" a4 t1 Z, z
col = get_index % col_max% I2 d4 {* K( W9 `5 S
new_x = item_x1 + item_width (col + 0.5)
' w3 N _: n- W
new_y = item_y1 + item_height (row + 0.5)& f8 k' u4 P$ {2 S8 S9 l
Mouse.set_mouse_pos(new_x, new_y)
* C0 A8 Y x; C
end
I* D# U: ^1 P
end
) k/ [: a7 q$ R: l
- ^2 V% s) o; ]$ O: B& R( W: P
#==============================================================================
7 h2 h3 `2 m/ I0 c& |5 v3 O
# ■ Game_Player( E- d* x1 i* g1 i- B4 `
#------------------------------------------------------------------------------9 d( K6 Q5 s: Z9 l$ G0 R
# 　处理玩家人物的类。拥有事件启动的判定、地图的卷动等功能。4 l1 v) o3 h* t: I8 r: [: y% T
# 本类的实例请参考 $game_player 。
+ B$ g& m. \+ D3 G, S# M& Y
#==============================================================================
( @* I% d) M) ^( h% k% |
class Game_Player Game_Character8 M2 ~4 Z: E! x8 a2 I1 e
#--------------------------------------------------------------------------! D4 m2 G6 K3 |) o7 u2 T9 T
# ● 由方向移动（覆盖原方法）
, T9 G& D; y. j8 Q" o7 y4 V& A. _( L
#--------------------------------------------------------------------------( n0 p! G/ g7 x
def move_by_input
6 n8 n/ {" o. g1 k9 C
return if !movable $game_map.interpreter.running: q# M& f7 u5 C
if Input.dir4 0
& u% |- u! \+ I
move_straight(Input.dir4) ; I3 ]0 L7 L' v, I: C
reset_move_path
0 w& o% t' o- p6 K+ o
else
, J, X" K* f7 f% |& G6 O% w
move_by_mouse" w r$ v5 f) L3 k, W, o
end
) h5 R& o4 p8 a1 k C8 O- r* b
end
; Y# {3 z8 V. i# d, @+ t
#--------------------------------------------------------------------------- B( l5 ^# Q. C# a7 p/ i
# ● 非移动中的处理（覆盖原方法）
) c6 N7 a# i* {$ h/ n4 N
# last_moving 此前是否正在移动
5 U( E/ `2 f9 b, }# E. [
#--------------------------------------------------------------------------
" f4 Y! d2 o4 v8 Q. Z5 V
def update_nonmoving(last_moving)
5 [4 F, _3 i' {' M
return if $game_map.interpreter.running
, V! p: s& ` T3 n, o! g H @6 d
if last_moving
* |: F( I, S/ H6 V$ ^1 U
$game_party.on_player_walk
" B; X, U6 r- `# t
return if check_touch_event/ X3 l8 U. w0 n* b% e0 B' C- m9 y
end
& S4 `/ Z3 y. I2 s7 ?7 J& \
if movable && Input.trigger(C)6 w$ j$ K* Z# Z# p$ f: i
return if Mouse.press(0x01) # 防止按下鼠标左键绘制路径时触发事件或载具切换
' U* t% Y* U; |: B
return if get_on_off_vehicle+ U3 v1 I8 U$ _% b% F# h; [
return if check_action_event
2 R; U, z7 }6 n( Q# t
end3 t a( q( P& v
update_encounter if last_moving2 k0 ?$ }4 u! S& [" N W
end% J8 X4 [! f- V: S( s% @* |
#--------------------------------------------------------------------------5 Q" C, h6 [! H A
# ● 判定是否跑步状态（覆盖原方法）( K7 p8 ~ w* Z* ]- d
#--------------------------------------------------------------------------! }6 M. [: r/ B1 R) ]
def dash0 T, v9 m% T5 G& |* \! z( z, g$ U! |
return false if @move_route_forcing- t, ^! z4 y5 a0 o
return false if $game_map.disable_dash
4 S: K. A2 y9 O+ q+ a
return false if vehicle; U" Q( p7 B Y9 }# P% C
return Input.press(A) @mouse_dash$ ?) |7 A, w x& l! M( [
end
$ T4 j& ]: {/ T1 c
#--------------------------------------------------------------------------- f* s Y4 t/ \6 O
# ● 初始化5 U' K$ V$ M( d3 P2 Z" g. \
#--------------------------------------------------------------------------
2 ^4 R, l9 t& s6 W1 Y. k6 U
alias sion_mouse_initialize initialize
) W v* c4 ^8 y; u" k
def initialize
7 M( ]: j* V ]2 \' }5 g
sion_mouse_initialize0 V8 ~3 i9 S) b. z
reset_move_path
% ~. p1 u% B# g! ^7 E6 T6 p
@moveto_x = 04 H1 O# t. I" R; x% P* j
@moveto_y = 0
( i4 ~. T+ R; Q
end/ _5 Y) U/ V! O) f! D$ O2 V% p
#--------------------------------------------------------------------------" R: l& z$ b. ?. n) x8 ]6 t
# ● 更新
2 n- {( J7 P" J
#--------------------------------------------------------------------------
2 m, f& M, s" x8 ~! Y ~
alias sion_mouse_update update
" c2 k7 M1 ^' H3 Y) L' R! y U6 w! O
def update
! Q) e( U- U. T( O8 o4 X
sion_mouse_update
: t) X$ u- X8 f1 k
clear_unreachable_sign5 q! ~* s6 {+ |; B3 D; F/ l) y/ F
end
! a0 `4 P) u0 T4 `( n" B, S v- R
#--------------------------------------------------------------------------
. u4 v0 x- B3 E! D% F6 }, S
# ● 处理卷动9 Y% p7 q* J+ d
#--------------------------------------------------------------------------
1 I" u/ ?2 k% i6 E `1 S5 \
alias sion_mouse_update_scroll update_scroll
5 S* Y6 V( s5 R$ W6 O1 W1 l) @; [
def update_scroll(last_real_x, last_real_y)
4 R! B$ |( @" ^! B
return if $game_map.scrolling
8 f" }* a) D: f: _8 }
KsOfSionNew_Scroll new_update_scroll
1 A9 b; ~1 _% l; k
sion_mouse_update_scroll(last_real_x, last_real_y); D" ]. @- c; G$ T3 m& C
end* \3 d' ?: w2 G! k. R0 z- w' r
#--------------------------------------------------------------------------5 H b* K" E5 h0 Q; Y
# ● 重置移动路径相关信息 c' c: j. E) K/ `& N* a4 z
#--------------------------------------------------------------------------$ N8 ~. C) Q$ a
def reset_move_path
$ P4 m7 m' ~+ z* v
@mouse_dash = false3 _! B% R; u( ~6 R
@mouse_move_path = []
S) U+ V) v& Z# I4 J4 y3 l! r( Q
$mouse_move_sign.transparent = true. f1 k- V( m7 y/ E3 S9 [
end, g# L3 f$ ^9 \. ^2 k
#--------------------------------------------------------------------------8 L7 }5 Z' h/ V6 m+ j
# ● 新的卷动地图方法
$ H% x# l& K; c5 r, d
#--------------------------------------------------------------------------1 m3 t$ W9 G/ t% Q5 a, @; C
def new_update_scroll3 Q2 W, H; Q1 B) s5 F
horz_speed = 2 @move_speed KsOfSionMap_Scroll_Spd Graphics.width0 h7 r u# k1 i! m, q6 W5 |
vert_speed = 2 @move_speed KsOfSionMap_Scroll_Spd Graphics.height; C2 e1 b M u, @& d# `
ax = $game_map.adjust_x(@real_x); Z1 _* x! W8 y1 a
ay = $game_map.adjust_y(@real_y)
% h2 u3 [$ E0 `' S
$game_map.scroll_down (vert_speed (ay - center_y)) if ay center_y
A2 _2 m0 O# c
$game_map.scroll_left (horz_speed (center_x - ax)) if ax center_x
5 o8 u) h o- n2 M2 _; a0 B
$game_map.scroll_right(horz_speed (ax - center_x)) if ax center_x& s4 R# [, X( [' @. w; W5 C7 t
$game_map.scroll_up (vert_speed (center_y - ay)) if ay center_y* j6 K5 \' d: S- B1 I4 O( h- l
end
# f- B! m5 C' e0 M. Y
#--------------------------------------------------------------------------
( U/ h" @8 p9 d& _9 h5 ~
# ● 消除不能抵达图标- E) G; W+ C# F+ @6 E, @0 i
#--------------------------------------------------------------------------. L8 _' q. P( N% g( l: c2 D
def clear_unreachable_sign
" v# K v1 H4 I6 l
return if Mouse.press(0x01)
# H' |+ Z2 g' Z. [7 p
if $mouse_move_sign.direction == 4 && Mouse.click_count % 20 == 0
$ ?1 z/ d( g) t% V% J
$mouse_move_sign.transparent = true
1 R# P1 @+ {0 }- f$ H
$mouse_move_sign.direction = 21 ^* {" c' A! {! B( U+ u
end
/ {4 J' z$ _3 |( ~* J" S4 B" q
end
# H) @" B4 m) B1 R- ^4 ]
#--------------------------------------------------------------------------
8 U f/ F. {3 c/ C- ?
# ● 由鼠标移动8 p* @) k/ C" H8 F
#--------------------------------------------------------------------------
. L& X. ?$ ^* W0 d& t- i2 P
def move_by_mouse# e2 S, H& q: j! i6 N Y! j
unless @mouse_move_path.empty # 移动路线数组不为空则执行移动9 }; v6 j7 z g5 P, I
dir = @mouse_move_path.shift( B% F( X9 Q/ y! f% P
if passable(x, y, dir) && !@mouse_move_path.empty! C8 @+ t8 U: K" `: u/ s
move_straight(dir)# F" [" v% e8 E: g5 c
elsif @mouse_move_path.empty # 判断是否是最后一步
1 P& `" |& A3 V, o* E9 t: L
x2 = $game_map.round_x_with_direction(x, dir)
0 Y: M" D: z6 p/ @" S, M9 d
y2 = $game_map.round_y_with_direction(y, dir)
0 l' [! A, s2 q5 J8 b. o
move_straight(dir) unless dir.zero0 N* n. ^; S$ W
unless x == x2 && y == y2 # 如果移动失败，检查是否启动前方事件、上下载具6 L1 H0 e0 M E4 N& y1 A
check_event_trigger_there([0,1,2])& g% [8 ~) l- \- f b. {
get_on_off_vehicle unless $game_map.setup_starting_event
% C6 M& H, L* u* i
end6 J+ m; i" B2 y4 z# a% m
$mouse_move_sign.transparent = true if $mouse_move_sign.direction == 2
" J- T5 S0 V. x1 F
@mouse_dash = false
7 v+ N2 u3 ~# p$ }
elsif @mouse_move_path[0].zero # 目标点无法抵达，调整朝向→目标点 M( S, U5 l+ H: a- d1 k0 a
@mouse_move_path.shift% a2 q" _% M, {2 d2 n: K
@direction = dir
4 b( P) r4 ^ l' I$ E0 \
@mouse_dash = false
& K1 d5 U( k9 g& f* x+ N \# }
else
' S/ |" g/ e% ~& P
draw_move_path
1 ]1 X# o$ }& E* N3 y1 ?' v
end
+ j+ P& x& E, A! q8 A
end
6 p) L: |3 s2 X* c( H5 F
end
6 j! X5 ?3 D% m; H
#--------------------------------------------------------------------------# V" Z/ b4 B1 h$ U# i& N1 b0 M9 Y
# ● 地图界面按下鼠标左键的处理
* X, }- _$ A: |2 X+ I2 b
#--------------------------------------------------------------------------
0 l8 U* v, t' ]' j
def left_button_action# ]7 m; ]% a: _8 P/ Z
return if !drawable $game_map.interpreter.running
4 o' Q% v5 h: u6 H; T6 v
get_mouse_pos
' `* e" R. V& {# e/ W2 n: u
$mouse_move_sign.moveto(@moveto_x, @moveto_y) # 移动路径点指示图0 ]" O7 F+ M+ p; t5 R
if @shift_event
1 c5 Q I/ b) w7 F
if Mouse.trigger(0x01)
6 H9 a" l( H G
@shift_event.jump(@moveto_x - @shift_event.x,
/ E7 I! [6 p- ~
@moveto_y - @shift_event.y)/ j5 x0 L$ n+ k% I2 q; S
@shift_event = nil; H+ Q( ? S; k' A8 }0 ]9 O* s5 u
end
. y" ^& l8 g8 p- {; g1 q0 c
return
3 N* y% s3 T. f K
end E& D& i; O) h6 X
if @moveto_x == x && @moveto_y == y # 判断目标点是否与角色重合
J' f# O% j1 x6 ?- X
return if moving (vehicle && !vehicle.movable)4 F& g9 l) [/ d F/ V9 T
check_event_trigger_here([0]) # 判断是否触发重合点事件8 v+ s: O* l3 U9 A' T* c2 i, d
get_on_off_vehicle if !$game_map.setup_starting_event &&
0 a3 k9 \' R: B# \
$game_map.airship.pos(x, y) # 判断是否要上、下飞艇
& ^- k% _- V7 G! E
return+ b$ u" F' f/ Y3 k0 T
end# c. ^' x! }" H9 k
# 判断是否用鼠标启动事件# Y9 J# T( C& i8 b( ]6 r
$game_map.events_xy(@moveto_x, @moveto_y).each do event$ }# Q1 x K1 y7 P n8 T
if event.mouse_start
) }$ [6 `% @% |( R3 b
reset_move_path
5 d3 Q) _3 k; ~+ [7 S K& u7 V
event.start if Mouse.trigger(0x01)
- X+ x; r( E( ?+ d" X2 N
return
. k. @ E6 n/ W- Q3 F
end: K/ P( H. H1 @: }1 q7 J6 `5 G+ ]
end
8 @! t# N' R1 j. `
@mouse_dash = true if Mouse.double_click # 双击冲刺* Q! W- H" G/ ]( W+ @
return if Mouse.left_state % 10 != 1 # 按住鼠标左键10帧绘制1次路径
2 m" Q: U. R3 E# `! ^) n& K2 f
for i in 1..4 # 判断目标点是否为角色周围四点
5 S* U5 h2 ~: L
if x == $game_map.round_x_with_direction(@moveto_x, i 2) &&
+ q) q" |, V7 l3 E. b
y == $game_map.round_y_with_direction(@moveto_y, i 2)
- n; U) s( U h9 j+ o- ?, }; i7 H
$mouse_move_sign.transparent = true! T7 i2 u9 z9 S0 F/ ~ J- m) B3 j
@mouse_move_path = [10 - i 2] if Mouse.trigger(0x01)5 k% w2 g$ C: b, K# P
return; end9 m) s/ T% G+ g
end
0 m- H9 h$ s6 _: @+ |" X4 S
draw_move_path2 h, e# X D# V: T, T! N
end
5 O- S) k {% r* e1 G! [6 x1 e
#--------------------------------------------------------------------------
" e, q5 H. |: F: @# l) }
# ● 取得鼠标处对应地图坐标点
$ e. R. f/ s7 o8 z/ [( u8 Q
#--------------------------------------------------------------------------
1 t2 g8 u) o6 d u7 `
def get_mouse_pos- ]) E$ y" G8 `+ }% @+ ]
$game_map.get_mouse_map_xy- u7 v2 R) R5 n6 F# C. p5 h) i
@moveto_x = $game_map.mouse_map_x
% I4 F a" {5 k9 C9 g
@moveto_y = $game_map.mouse_map_y6 m4 x* D4 g- [* z* u
#mouse_x, mouse_y = Mouse.get_mouse_pos* @0 }- k( r% _. t
#@moveto_x = $game_map.round_x(x + (mouse_x - 9 t' J, E! m2 X) S+ `1 \. I
# ($game_map.adjust_x(x) 32 + 16).to_i + 16) 32)# m9 n# s' c* D7 h
#@moveto_y = $game_map.round_y(y + 1 + (mouse_y - n9 @# D) i/ Z- H8 q& J0 {, G
# ($game_map.adjust_y(y) 32 + 16).to_i - 16) 32)
" X( R, } k" @4 W- I: m9 U
end5 r% D6 z' Z, b3 r" F, w. Q
#--------------------------------------------------------------------------4 K3 Y# R, I) r
# ● 绘制移动路径 @array[move_directions...]
6 ?8 ]; \! ]7 p
#--------------------------------------------------------------------------
, r. \" E: @* m) f/ x
def draw_move_path- }/ J; X% r+ |4 e0 ]
#temp = Time.now" O( M @- t7 c! J8 x8 s+ m
case @vehicle_type
- A' \* f$ E4 f& F( u9 d! A n
when walk. J! T H/ X( |0 h0 m
draw_walk_path
" r* h+ x, x2 s/ A& P! Z8 w, N
when boat
+ m+ l7 O5 O2 I; t, l: b
draw_boat_path
. J# G) B. Y9 s/ l1 T
when ship
4 G# i! \2 }4 r( a0 {
draw_ship_path' q+ O! t' W( W7 H* p
when airship) o' N8 _+ {# d1 J1 t8 t2 ?: O/ S
draw_air_path( N+ g$ C4 j) i. J2 T8 E# X
end
! a$ a" |3 H0 F
#p (Time.now.to_f - temp.to_f) # 测试效率
2 G/ |# u, ~- d/ @! u4 T7 t1 h- p1 ~
end. r$ i# e6 L4 \) d i
#--------------------------------------------------------------------------$ ?2 B$ K( E4 t; S; l1 q; a' N$ o
# ● 判定是否可以绘制移动路径7 d% w$ s. e# v. U" s
#--------------------------------------------------------------------------
! U& ?! C ]6 x ^4 d; K! U
def drawable+ t* I& t5 L! i6 R" v5 `; ~
return false if @move_route_forcing @followers.gathering
+ q% ]! ^0 U2 Q- c
return false if @vehicle_getting_on @vehicle_getting_off
' s1 ^0 V8 g' l. m# ]) M' l2 c
return false if $game_message.busy $game_message.visible
2 W" M+ l( \$ y2 e: \- ~
return true
4 }& ~9 v, x) O. U0 v' g1 v( ^
end
4 R- h, {5 @$ ~3 a5 R: w
#--------------------------------------------------------------------------% A, k+ a+ S6 Z a! N' x; X) H
# ● 绘制walk移动路径 @array[move_directions...]- h6 R. \2 S' r
#--------------------------------------------------------------------------" Y& _2 Z; G b! i, p- }
def draw_walk_path
$ p, [5 W# x' H- N! w/ n4 C5 o$ Z
# 准备绘制路径表格0 }# Y1 j$ g z' K( }
sheet = Table.new($game_map.width, $game_map.height)
. C* P" Y# j E$ C
reversed_chase_path = []; chase_path = []
, ?4 c) Z8 Q) U" x; ^' H) Z
reversed_chase_point = []; chase_point = []' c; a: U" _, @( M! N) W& E# e
new_start_points = [x, y]; new_end_points = [@moveto_x, @moveto_y] {- J7 R' p' Q8 z9 |
sheet[x, y] = 1; sheet[@moveto_x, @moveto_y] = 22 c/ Z) Z2 `9 c' [) x9 ?5 `
reach_point = false9 k6 A1 k6 l8 Q' W0 L8 A* O
step = 38 y: x [: b5 C5 U
loop do #loop1 开始填充表格
, e# t u; u- O( B$ o1 I! [
draw_path = false( s. \2 |% h& q! |2 }% u8 S! m
check_points = new_start_points- D" t' G: ~; {6 d- R, S" O9 E P
new_start_points = []. j8 p# T3 q& f* G
loop do #loop2 从起点开始正向填充" ?% P. l1 c' R4 T" j% c
point_x = check_points.shift
$ U/ L, m! @; Y! q% a3 Y
break if point_x == nil
- T( s* P) P/ @5 X/ |9 M I
point_y = check_points.shift; E& G. Q( N, E! G% J9 O+ S
left_x = $game_map.round_x(point_x - 1)
/ F3 F, h: J1 [/ V
right_x = $game_map.round_x(point_x + 1)
% Z- [4 f4 g4 P; x
up_y = $game_map.round_y(point_y - 1)/ A; R( x! N- k2 y0 Q
down_y = $game_map.round_y(point_y + 1)
3 `0 G2 @! n" [. G* b
# 判断路径是否连通
& x% Q& U6 B$ V/ O0 `8 a. g
path_step = step - 1
# k0 f0 P* o' F2 m, ]1 t u
if sheet[left_x, point_y] == path_step &&2 \# ^1 c+ r6 Q+ [. S+ b* N; Q
$game_map.passable(left_x, point_y, 6) &&
5 s8 s. o5 u, q# e, y2 B
$game_map.passable(point_x, point_y, 4)
: h$ l7 U& }- O
chase_path.push(4)
2 w/ o8 l8 _6 D3 k
chase_point = [left_x, point_y]% f' [, U& ]% T; G( W, Z
reversed_chase_point = [point_x, point_y]3 ?1 e7 P4 [# O$ q2 v0 @
reach_point = true; break
& _3 l$ u! [: C% s
elsif sheet[right_x, point_y] == path_step &&
# h3 r* }$ P6 M$ ]4 F- K& U1 o" U
$game_map.passable(right_x, point_y, 4) &&" [+ j' u- A4 m7 H% M
$game_map.passable(point_x, point_y, 6)
" t7 u1 v! p5 {9 l5 @ T% j
chase_path.push(6)7 M- f" J2 H3 L7 E$ q$ J
chase_point = [right_x, point_y]
* q' f/ c6 o5 T. L. o
reversed_chase_point = [point_x, point_y]1 i, k; c9 P) s7 ~
reach_point = true; break
8 [9 Y& y' f9 Q$ c L# P8 h8 I, V+ _
elsif sheet[point_x, up_y] == path_step &&$ j X3 p5 F2 i) K9 x0 ~" R$ W
$game_map.passable(point_x, up_y, 2) &&
( Y+ ?6 L# h5 R4 T# U# g
$game_map.passable(point_x, point_y, 8)
" D; ^4 N, J, |/ u; F6 K' {& p
chase_path.push(8)
& X' b1 F# K' i6 O1 C
chase_point = [point_x, up_y]/ b/ e3 p0 ~* w: o3 L
reversed_chase_point = [point_x, point_y]/ O) `- B; d2 ^. \/ b
reach_point = true; break
: q& s/ c$ Y% p+ p4 E7 w) [
elsif sheet[point_x, down_y] == path_step &&6 I5 Q4 u+ c, Q' A
$game_map.passable(point_x, down_y, 8) &&* O3 u' R _8 F% s' r* q
$game_map.passable(point_x, point_y, 2)
1 f5 ~) B$ L0 f5 o
chase_path.push(2)
. e$ A6 Y$ P* a' `3 O# O& a
chase_point = [point_x, down_y]
2 ]+ ]1 m/ P: }
reversed_chase_point = [point_x, point_y]; t# J( k M' c# s( A7 y K- L* V
reach_point = true; break. j& |: ~0 t) M5 c/ z2 ?% `
end
+ i* f d5 o& B# @3 e
# 以需要抵达该点的步数填充路径表格 #
6 Y# ]% _1 \- C0 c
if sheet[left_x, point_y] == 0 && T- `1 C+ T0 i" D% r {- V; I
$game_map.passable(left_x, point_y, 6) &&8 b$ E. J4 w. H# h: [, O8 @
!collide_with_events(left_x, point_y) &&6 q% c R! ]0 \0 z& `7 G
$game_map.passable(point_x, point_y, 4) &&
; x; P8 |/ J g) L- o
!collide_with_vehicles(left_x, point_y) #judge_end5 F& R* t' N% u7 X; g( h
sheet[left_x, point_y] = step e# D! \: r6 X# Y( X. j
draw_path = true
_1 i) A, j5 b( B
new_start_points.push(left_x, point_y)
0 i/ [8 j# w8 W7 `" K1 M
end
3 o3 u3 J. ]* h& D( A0 m5 o
if sheet[right_x, point_y] == 0 &&
2 m/ r1 q N1 J( Y4 s/ z
$game_map.passable(right_x, point_y, 4) &&; Z5 S) I6 S' Z" Y
!collide_with_events(right_x, point_y) &&
% Q' a1 l) Q* q9 V, ~
$game_map.passable(point_x, point_y, 6) &&
" g; R. ~% V" L; [* _
!collide_with_vehicles(right_x, point_y)#judge_end* A/ O; M8 b5 c: s# d, c; d+ U
sheet[right_x, point_y] = step
; Z4 x1 n. g9 p* r. {0 J9 n. d. E
draw_path = true: I# Z& y% O- O
new_start_points.push(right_x, point_y)
! x) i+ j* x/ g4 J! A/ Q t( S5 d
end
R7 ^) e+ r8 R6 W- ]$ o
if sheet[point_x, up_y] == 0 &&' R z9 r" O. E( }0 ~) t1 h' c! b
$game_map.passable(point_x, up_y, 2) &&* J$ v7 q1 E3 r2 {/ a+ b U
!collide_with_events(point_x, up_y) &&
$ f4 W1 f; B- @, m. f2 n% i8 l
$game_map.passable(point_x, point_y, 8) &&
. { b% a( f% ~3 m/ ?
!collide_with_vehicles(point_x, up_y) #judge_end$ t6 h. s4 `; u, t% G0 c# L8 k
sheet[point_x, up_y] = step
8 a* d F' ^0 r( z( K1 q
draw_path = true& N, w& R5 E: Z! `7 G) d6 o" u
new_start_points.push(point_x, up_y)
. B/ v/ V) o# k/ T; C$ X) L
end
7 z. P# \ w* x
if sheet[point_x, down_y] == 0 &&5 q4 J- W% f" T1 ^0 e
$game_map.passable(point_x, down_y, 8) &&' v0 g& n7 E2 @2 C" t
!collide_with_events(point_x, down_y) &&
1 C9 {6 z& N% W4 k% `% `
$game_map.passable(point_x, point_y, 2) &&2 h6 ]7 L3 A# k. p8 ^8 g; c
!collide_with_vehicles(point_x, down_y) #judge_end- z; `. w1 ?5 J7 Q- N
sheet[point_x, down_y] = step9 F( t* @& ~" q) V8 t% h6 n' q& L
draw_path = true
" k! |& R: l/ {3 J
new_start_points.push(point_x, down_y) _2 [* ?) C3 N o! _) H& d8 Q
end: g$ X' P6 T c/ u
end#endOfLoop2, U+ V( l' k; [1 ~( b: g& i
break if !draw_path reach_point! E& a- X' U# {5 W. A( o! g
draw_path = false5 U# T" w' N4 J
check_points = new_end_points
/ M7 g. x: V' ~4 f3 j
new_end_points = []4 Y) U; z3 m6 H: n+ p9 ?" H7 f
step += 1
% }7 r0 G9 q6 K; t
break if step KsOfSionBreak_Steps &&
) F, {! q1 q1 N+ I8 ?3 j; m
!Input.press(KsOfSionFind_Path_Key)
7 K* ~* B) v' P& G% c
loop do #loop3 从终点开始反向填充2 o/ K' L; Y; g2 b+ `- J
point_x = check_points.shift t' x$ P; H& L0 [- I
break if point_x == nil
& T' Z* Q* B' L' f# y& O
point_y = check_points.shift( Q1 U9 ?. Z; ]: m
left_x = $game_map.round_x(point_x - 1)9 W7 j% r0 }' U* w
right_x = $game_map.round_x(point_x + 1)
" m S: n( a9 O: l* Y) ^
up_y = $game_map.round_y(point_y - 1)
: V. x2 X" c/ K9 }& s) o/ T
down_y = $game_map.round_y(point_y + 1)4 j" R: X6 H- C" {
# 判断路径是否连通
% y. H) }7 \( {
path_step = step - 1
6 {) h. q/ _6 p$ H8 l- _0 C
if sheet[left_x, point_y] == path_step &&/ u7 G6 M+ q1 @* H7 M/ p" y# C
$game_map.passable(left_x, point_y, 6) &&/ a1 n1 S1 k5 ~1 Y
$game_map.passable(point_x, point_y, 4): @- G" K% \0 U5 Y9 L
chase_path.push(6)9 x5 d. e' N f$ |( q
chase_point = [point_x, point_y]
( ]; h, f/ _/ J- M& l
reversed_chase_point = [left_x, point_y]
0 q; ?$ }2 Q2 H# w; m8 t
reach_point = true; break
3 r0 O5 J9 e" ^+ K2 I" h+ a
elsif sheet[right_x, point_y] == path_step &&
3 P7 O1 g2 C0 B5 U% M; | V
$game_map.passable(right_x, point_y, 4) && s4 I; m* y7 P- [/ t
$game_map.passable(point_x, point_y, 6)( u( s" G! i) }9 \4 ?7 t
chase_path.push(4)
; }0 Q! e! A* k8 P. R3 ~
chase_point = [point_x, point_y]
* I! E: w: \, o6 K
reversed_chase_point = [right_x, point_y]
0 B1 I) i4 h( ?( k, W# ?
reach_point = true; break* O2 I8 v8 K- t+ G1 c& d
elsif sheet[point_x, up_y] == path_step &&" Q4 v+ ?0 Y2 r$ g2 S
$game_map.passable(point_x, up_y, 2) &&
) x' k9 [; c) m( u! H
$game_map.passable(point_x, point_y, 8) i+ A7 Y0 e( ]6 c6 t2 Z
chase_path.push(2)
( Y$ P! D: k; x0 h# V0 y8 d: M& J
chase_point = [point_x, point_y]
) U+ _1 M u2 U
reversed_chase_point = [point_x, up_y]
: Y0 V9 e( G& [( c/ I1 T8 `
reach_point = true; break
( W9 r' J/ g3 ^! e
elsif sheet[point_x, down_y] == path_step &&$ T- O% X6 m' {
$game_map.passable(point_x, down_y, 8) &&
' B8 ]0 [# z) A7 f
$game_map.passable(point_x, point_y, 2)' R% V8 r) b* T+ U q
chase_path.push(8)9 r3 s8 N1 j7 M9 r% ?( d- m
chase_point = [point_x, point_y]
; L: d9 r( h! [) ?- W- L( j
reversed_chase_point = [point_x, down_y]
# ^( @2 S( U+ n! {$ b# ~% x
reach_point = true; break# a! L( w! C, `
end
% m% [0 @2 x0 T" c4 X8 J
# 以需要抵达该点的步数填充路径表格 #! j+ O1 E( I$ T# i) i
if sheet[left_x, point_y] == 0 &&6 Z; e. o, N0 I) z7 z' F8 C
$game_map.passable(left_x, point_y, 6) &&
8 b2 g q- g6 C. d3 O% c0 B4 y
!collide_with_events(left_x, point_y) &&" `- T5 ^6 M/ v+ _6 B& k: R& M& f
$game_map.passable(point_x, point_y, 4) &&, e7 j6 e1 k4 I- M) y) Y
!collide_with_vehicles(left_x, point_y) #judge_end7 C# M! ^; ]4 }8 y+ S; t
sheet[left_x, point_y] = step
2 \) |% k6 |# A
draw_path = true1 U2 }5 O, E E3 x) s U
new_end_points.push(left_x, point_y)
% {8 J" z$ m8 M- W, W, Q
end
5 a9 w1 P5 A2 _9 a; E) z7 z7 O1 T5 @
if sheet[right_x, point_y] == 0 &&
3 O6 y7 v9 Q# I# X: ]7 [- {
$game_map.passable(right_x, point_y, 4) &&
) A" w1 _% h" C* }- e" z
!collide_with_events(right_x, point_y) &&
. i5 T8 v$ n5 G2 m; g( J# v% J
$game_map.passable(point_x, point_y, 6) &&- \9 S W/ H: a/ J" z8 L
!collide_with_vehicles(right_x, point_y)#judge_end$ @8 s4 u( }1 p
sheet[right_x, point_y] = step
; z, R3 y& ^7 @
draw_path = true
& @4 l b# b: F% v. w
new_end_points.push(right_x, point_y)$ T: @% y4 e' u1 b; ?
end
8 g2 X$ `$ A# j% Z- ^3 ^# Z
if sheet[point_x, up_y] == 0 &&4 g, N- m( P$ m3 q. [1 {& e
$game_map.passable(point_x, up_y, 2) &&
4 q+ Q- T) W' K6 Q
!collide_with_events(point_x, up_y) &&" z B1 M! A& [4 B& _& c
$game_map.passable(point_x, point_y, 8) &&
( E$ `+ z4 d5 w# Q
!collide_with_vehicles(point_x, up_y) #judge_end
3 w* m0 ^3 \2 |$ j
sheet[point_x, up_y] = step
$ Q( ?: h7 [$ l* U
draw_path = true
2 b4 Q- L/ u/ v9 F
new_end_points.push(point_x, up_y)
; x; q$ t- _) k- G5 Q0 G
end/ K d4 u& w( Y6 J4 g% G V
if sheet[point_x, down_y] == 0 &&( K) j4 ]" u$ ~ r; x
$game_map.passable(point_x, down_y, 8) &&
, a; {" k# [ \$ S3 t' }- b5 {
!collide_with_events(point_x, down_y) &&
, r% b$ h2 _$ k/ ^4 g& j: W0 I0 V
$game_map.passable(point_x, point_y, 2) &&; G# r( o+ N' F- a
!collide_with_vehicles(point_x, down_y) #judge_end7 |" Q; u9 ]6 C5 H8 e9 v! G5 L# @
sheet[point_x, down_y] = step
. D' p# k$ m8 s3 N
draw_path = true
+ h- R& s/ d6 O, L1 ?
new_end_points.push(point_x, down_y)
" i2 J( k: w( ?4 A
end
# {: m+ l3 [: [! g7 v
end#endOfLoop3
|0 v/ W3 y8 u# j# B: j6 z; i
break if !draw_path reach_point
" l, a; Y5 U, k
step += 1
! p9 D: d! U d: ?# Y9 V0 N
end #endOfLoop1 路径表格填充完毕% L- J$ u2 v6 I
$mouse_move_sign.transparent = false
0 U7 y- f# d! Z! p/ e: _) x
# 判断指定地点能否抵达
" N& j& q/ ^3 W Y+ M* g: i
if reach_point
1 {) X' s" v8 p
$mouse_move_sign.direction = 2. E( y6 v2 X0 }$ k
else
$ f) c$ r4 x) m* R8 ]% Q1 U/ F
not_reach_point
3 w. z, g/ q9 P
return. E$ q9 Z3 g) X3 L4 r
end
8 _& ^" o- D; K8 o5 v
# 根据路径表格绘制最短移动路径（反向）2 {# y5 u5 x& D* E; o
steps = step 2 2 + 1& `# o6 G+ Q" Z# n9 Q t6 ~$ q5 I) r
loop_times = step 2" L: C; B# {& o5 s" S
point_x, point_y = reversed_chase_point[0], reversed_chase_point[1]8 E* u0 l2 u6 p
for i in 1..loop_times # forLoop6 \( f# ` Y$ `9 l( r8 C' V
steps -= 2! T. u _/ v5 H/ ?2 r8 P
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs #反过来？蛋疼了……
: n4 B0 F. z, b
if sheet[$game_map.round_x(point_x - 1), point_y] == steps &&4 `6 I8 K. s1 t0 y) M
$game_map.passable($game_map.round_x(point_x - 1), point_y, 6) &&
: i9 ]' w- Q. x
$game_map.passable(point_x, point_y, 4) #judge_end
$ N0 v( O% u2 C% D4 o6 Q# q2 o
reversed_chase_path.push(6)
; \6 P1 u/ V* r+ B$ p3 J8 f
point_x = $game_map.round_x(point_x - 1)
' z7 Y, \; Q. @& M5 o
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps &&8 ]- o( @3 f7 E6 j& i/ d8 N
$game_map.passable($game_map.round_x(point_x + 1), point_y, 4) &&
+ D2 L/ I0 ]& l3 x9 r2 p! r8 {. u. ]
$game_map.passable(point_x, point_y, 6) #judge_end
! O0 R3 F( A; a: P, i
reversed_chase_path.push(4) k% [7 ^9 E& [5 p2 b
point_x = $game_map.round_x(point_x + 1)1 i: k6 f% L: a7 x8 \8 x# B+ w
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps &&
; [- y$ J4 l' U$ [1 d6 B/ {: n
$game_map.passable(point_x, $game_map.round_y(point_y + 1), 8) &&
$ ~, f# [( i8 g/ S
$game_map.passable(point_x, point_y, 2) #judge_end8 ?- h7 d. ?- e, ?
reversed_chase_path.push(8)
1 k# i* w8 p5 b, a
point_y = $game_map.round_y(point_y + 1)/ ~& \# M* ?6 V# r) j
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps &&, S: g1 N$ q7 o' b
$game_map.passable(point_x, $game_map.round_y(point_y - 1), 2) &&
8 |4 K7 V U, n! m7 w7 y/ X
$game_map.passable(point_x, point_y, 8) #judge_end
$ ?& C+ v8 k# C$ G( L
reversed_chase_path.push(2)& ]4 u, I, O: \0 @) ]
point_y = $game_map.round_y(point_y - 1)* R3 x4 F L% b b) H# j
end5 r5 P8 @/ ?, A2 ^; ~! M! \1 n
else+ @# b0 n. x$ e+ T5 t+ E
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps &&
- a- D$ p% W9 J- \8 W( x+ X j
$game_map.passable(point_x, $game_map.round_y(point_y + 1), 8) &&
* f/ O# N) u9 ^& F# M/ m1 g
$game_map.passable(point_x, point_y, 2) #judge_end) ^* m7 S+ ]3 ]' Q
reversed_chase_path.push(8)# b. U0 V& q8 k: B- I d
point_y = $game_map.round_y(point_y + 1)
: W' S! u9 w _8 ]; p1 f; }
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps &&
7 Q, k5 w. A6 E2 }! J
$game_map.passable(point_x, $game_map.round_y(point_y - 1), 2) &&$ x* u" \7 ~$ d
$game_map.passable(point_x, point_y, 8) #judge_end
8 p5 [+ j; Z+ k# D
reversed_chase_path.push(2)
3 }, l" U/ b, M; t; t$ {
point_y = $game_map.round_y(point_y - 1)! S) y" j% d9 B" n3 I4 L& {( v
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps &&* K5 }1 a( s9 [0 l) V F a
$game_map.passable($game_map.round_x(point_x - 1), point_y, 6) &&; Y8 G( l9 m, {; e, O4 t# S
$game_map.passable(point_x, point_y, 4) #judge_end
: D9 s7 }# T/ [1 b& R4 d: c& J
reversed_chase_path.push(6)1 D* A! {9 I! c h
point_x = $game_map.round_x(point_x - 1)
+ ^4 c' V7 S) P) U
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps &&
3 E% l& F2 V6 F; i$ c8 z
$game_map.passable($game_map.round_x(point_x + 1), point_y, 4) &&. ?% B1 R2 G; I2 `' ]( X @
$game_map.passable(point_x, point_y, 6) #judge_end
. h1 v( [) M# ]- v# D
reversed_chase_path.push(4)
( @ F, }! k; P7 S+ Y7 o. Z
point_x = $game_map.round_x(point_x + 1)* t& r W: N* [. f; O' A) H
end$ P4 Z0 A/ }8 ^2 G9 {- V8 [) G( v
end8 `) j0 g L+ X0 h6 Z6 ?
end #endOfForLoop P; h2 x, C- c1 ^
# 根据路径表格绘制最短移动路径（正向）# g& \( G# D8 V1 O! \% j( g% p! y
steps = step 2 2
! U: c0 R. I% J
loop_times = step 2
9 |+ K Y4 |+ P
point_x, point_y = chase_point[0], chase_point[1]
0 [; h: V2 V4 T, t
for i in 2..loop_times # forLoop
* K. l( l- Y+ Y! n
steps -= 2
8 ]6 {7 }, V7 w0 `/ Z8 Z8 L
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs' k* d8 L4 c/ g" F! p- Y
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps &&
# [! K: f) T6 {/ W" H. ~3 r
$game_map.passable(point_x, $game_map.round_y(point_y + 1), 8) &&- E7 y: h: L% R6 [
$game_map.passable(point_x, point_y, 2) #judge_end
# ^2 j+ v( u" ]& h2 X
chase_path.push(2)
% i$ R- h' o& C( I7 u
point_y = $game_map.round_y(point_y + 1)
1 n/ q% ], ]3 B% _. j. _ [4 G
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps &&
0 }0 j/ z$ U" X( v3 ?
$game_map.passable(point_x, $game_map.round_y(point_y - 1), 2) &&+ B6 V. Q$ y! E9 @
$game_map.passable(point_x, point_y, 8) #judge_end
' P2 C4 R$ P2 Y* D9 F% ?# o
chase_path.push(8)0 c5 b \# P B& L, ~
point_y = $game_map.round_y(point_y - 1)
+ r& A e# u, t* u. T: \3 }4 o
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps &&: r/ _9 H3 \( V; N) @) s" H
$game_map.passable($game_map.round_x(point_x - 1), point_y, 6) &&
4 a# g. u& c( I# G0 u
$game_map.passable(point_x, point_y, 4) #judge_end
6 E8 t/ C% B1 J+ I
chase_path.push(4)4 L6 K2 ^9 J/ o7 g" c8 i
point_x = $game_map.round_x(point_x - 1)- ^" s1 a! n. a) F L; K, N1 |
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps &&- @- P: X$ {+ y( ?0 t& P1 D
$game_map.passable($game_map.round_x(point_x + 1), point_y, 4) &&# ^8 j1 {" u `2 f' q( ~) V& H
$game_map.passable(point_x, point_y, 6) #judge_end9 M3 v3 {5 x% P8 ?; H
chase_path.push(6)
: k# Q# \* A$ d8 j( `' |; Z* k
point_x = $game_map.round_x(point_x + 1)5 @5 m; o7 A9 Q* a! r& l: U
end
( {: b) b8 m; w* l5 A3 [
else
% v- J. O( @2 C4 U
if sheet[$game_map.round_x(point_x - 1), point_y] == steps &&
) d9 L- X4 t2 D! Y
$game_map.passable($game_map.round_x(point_x - 1), point_y, 6) &&! P+ a; r3 s& P$ Q6 _! C8 U
$game_map.passable(point_x, point_y, 4) #judge_end
0 p, e" B+ `5 ?" v% E
chase_path.push(4)
! j3 V, B$ T& [0 E" s
point_x = $game_map.round_x(point_x - 1)
2 o/ l! y$ R5 Y; P" n: M
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps &&4 F# m% F$ t( p5 O- T* h8 c, S
$game_map.passable($game_map.round_x(point_x + 1), point_y, 4) &&
Y+ j4 M" w. r/ S& X- a. H
$game_map.passable(point_x, point_y, 6) #judge_end; U2 Q$ Y, P/ F7 }7 s- l' Q
chase_path.push(6)9 u4 c( R! t. _8 w0 `/ }
point_x = $game_map.round_x(point_x + 1)
- X. H/ [" g# S, n, E
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps &&9 z6 S% V7 m% w5 u- o0 U) Z
$game_map.passable(point_x, $game_map.round_y(point_y + 1), 8) &&
# `7 S# O" D* Z( X& p
$game_map.passable(point_x, point_y, 2) #judge_end5 V! f5 m! |2 e
chase_path.push(2), y( |. ^+ o3 T: H" H
point_y = $game_map.round_y(point_y + 1)4 L4 ~3 [1 [: q$ G1 {3 p
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps &&: B5 Y: @& D" p/ _3 b
$game_map.passable(point_x, $game_map.round_y(point_y - 1), 2) &&- q% k. p; U5 i1 L$ F% }
$game_map.passable(point_x, point_y, 8) #judge_end
) B! M6 r, X, {* F9 l
chase_path.push(8)
: Z0 c/ E# H# L& l6 Z; W
point_y = $game_map.round_y(point_y - 1)) C3 b; u( u0 e6 o7 z! ~: b
end
! R* q* O2 | f- f1 F6 s
end
2 i5 G: u( W" E4 o2 r1 \
end #endOfForLoop; m; `( ~* k z4 k( G/ r
@mouse_move_path = reversed_chase_path.reverse + chase_path
, e9 f' s% P* W# o! W
end#walk
9 I5 S/ M5 C) j- ~: }/ t' R
#--------------------------------------------------------------------------" D3 V/ K! f9 J. E( t
# ● 绘制boat的移动路径 @array[move_directions...]
: J3 q7 `5 c* F0 }
#--------------------------------------------------------------------------. s& L/ O* \) L3 ]/ H7 q
def draw_boat_path, H0 F% h @* h& ^
# 准备绘制路径表格
% G) h; A6 A9 r$ X0 H+ M
sheet = Table.new($game_map.width, $game_map.height)
' N" K$ i2 }* u" \% \- I
reversed_chase_path = []; chase_path = []
3 ~$ F% |6 p! d
reversed_chase_point = []; chase_point = []7 g0 _& r+ x* V b4 e' o
new_start_points = [x, y]; new_end_points = [@moveto_x, @moveto_y]9 V$ ~5 X$ d, ~4 C
sheet[x, y] = 1; sheet[@moveto_x, @moveto_y] = 2
$ k' s- r- B1 a
reach_point = false* K& v3 Y) I7 ~5 _
step = 3
) @+ _; u0 d6 S k: f: `, F; Y
loop do #loop1 开始填充表格
6 w" H4 v) c" m' n: R6 w& r) z" q. _
draw_path = false
) F+ F J7 ]# c' W- E
check_points = new_start_points
4 ^ Y: _6 [/ ^3 ?( Y: _
new_start_points = []. @$ I5 R1 K8 v
loop do #loop2 从起点开始正向填充
1 W9 V" |9 |" v* P; i# W, T1 q8 Z
point_x = check_points.shift% S9 f; C- C9 Y: u1 a. ?. b
break if point_x == nil& ~$ {. C& Q* A( @# W9 A# D' j
point_y = check_points.shift
7 V" a2 t0 f6 Z6 K% b
left_x = $game_map.round_x(point_x - 1)
# `8 }( q$ y* w4 E& v4 h- }$ b
right_x = $game_map.round_x(point_x + 1)4 `5 W. q: H( m+ Q4 y$ {
up_y = $game_map.round_y(point_y - 1)6 u% y1 B3 q0 R* G% w ~
down_y = $game_map.round_y(point_y + 1)
, P2 V: T- h6 z- M5 r& E
# 判断路径是否连通
/ p' d9 H, c) o! }
path_step = step - 1
) Q; ]- W/ O" y3 l% a4 A2 K' [
if sheet[left_x, point_y] == path_step
+ @8 d: P% v/ ~3 l6 D/ V3 z+ Z
chase_path.push(4). y4 D, f0 r) k: v! a/ V& u. a
chase_point = [left_x, point_y]
, Y; B! i. G' p7 l5 ?8 G
reversed_chase_point = [point_x, point_y]5 D% {. p5 n# g# r
reach_point = true; break7 ~. p0 Z2 w# ?! y
elsif sheet[right_x, point_y] == path_step7 k1 K i* T& W5 }; U* N
chase_path.push(6)
* I+ g4 u7 V+ H5 w9 J0 M5 [+ Z
chase_point = [right_x, point_y]
) w/ z* H- g1 u0 l
reversed_chase_point = [point_x, point_y]
! A2 D( t# D8 \; I; w' _ y; i5 Z
reach_point = true; break8 I7 P4 F, Z# X% y2 ~* [, c: q
elsif sheet[point_x, up_y] == path_step
2 j& f' F# S5 c3 @
chase_path.push(8)
8 D! P1 t, w& N4 w5 h
chase_point = [point_x, up_y]
, W1 ]7 u1 q+ Q) F; ]9 p- E. e+ `0 {
reversed_chase_point = [point_x, point_y]7 a: w$ W& C; m9 `0 B5 X
reach_point = true; break
# I1 }% ~: [$ K( j+ w
elsif sheet[point_x, down_y] == path_step
# A. ]5 i! U1 v9 q: ?/ b
chase_path.push(2)
% ^/ N3 f3 g+ p+ K+ a; Z) \/ u% @
chase_point = [point_x, down_y]" j1 y* q8 L. s6 D- C9 c6 k
reversed_chase_point = [point_x, point_y]
- O. _2 {& Z: Y& R' U
reach_point = true; break. R; C, L- u4 q* S
end! f+ z0 s, {: w e: O+ f/ t
# 以需要抵达该点的步数填充路径表格 #) ^ \1 P% X$ o9 S( L
if sheet[left_x, point_y] == 0 &&4 q! P& I7 J% V# | y
$game_map.boat_passable(left_x, point_y) &&
" k1 z" J3 r/ @: Q) a: I3 Z
!collide_with_events(left_x, point_y) &&
5 A+ t/ E# }8 c' {, n0 ]& _
!collide_with_vehicles(left_x, point_y) #judge_end. o% X7 ?: c+ x' n" s$ k
sheet[left_x, point_y] = step
. Y8 D7 J% ` o4 {$ E7 e
draw_path = true3 h0 A- m/ \5 B5 o6 g: U9 o' v
new_start_points.push(left_x, point_y). i* k& p1 K, g1 t3 b, c. S1 o2 S
end; b' Q( a2 P2 a1 g& P- Y* X' M- \6 g
if sheet[right_x, point_y] == 0 &&
: g- @! d" M1 j" R
$game_map.boat_passable(right_x, point_y) &&
( A9 x% `+ G1 V" p8 r
!collide_with_events(right_x, point_y) &&9 o& h2 S y" d. i5 ?
!collide_with_vehicles(right_x, point_y) #judge_end
1 g+ @% W( {8 J, Y
sheet[right_x, point_y] = step
; [+ L3 j" Z' v# E% W. b
draw_path = true1 Y; w* T G9 p% @
new_start_points.push(right_x, point_y)
* {. q5 ]" J* S6 D' O
end* q( N2 c, w7 ~: B
if sheet[point_x, up_y] == 0 &&2 u' d2 i7 `4 q( V' m4 V* G) _
$game_map.boat_passable(point_x, up_y) &&/ f5 h3 Z* k4 W7 o
!collide_with_events(point_x, up_y) &&1 H& O0 P' d4 P- W
!collide_with_vehicles(point_x, up_y) #judge_end a, j; `4 n1 z5 ]& e* O& T
sheet[point_x, up_y] = step l# ^/ e9 `5 w$ n
draw_path = true
1 X/ F- D( E0 Q" j
new_start_points.push(point_x, up_y)3 i8 Z* U' Y; @' q8 {0 S; o
end8 W$ ], o) Z7 D/ H! B2 W/ n
if sheet[point_x, down_y] == 0 &&9 [' ^8 C4 ?1 Y5 M( @
$game_map.boat_passable(point_x, down_y) &&
! P* Z- B2 }8 @/ X
!collide_with_events(point_x, down_y) &&
& B# i" h7 X+ K; Q# ]% R
!collide_with_vehicles(point_x, down_y) #judge_end0 E( {, N1 L5 H; o' a8 E
sheet[point_x, down_y] = step6 f e* S+ {: E1 X0 q+ y
draw_path = true
/ R( D5 V5 X; a: E
new_start_points.push(point_x, down_y)
9 }, t: @( x/ e: I
end
" T. w- r, ^1 Y/ w/ g w+ i
end#endOfLoop2
5 P. X' k7 l2 z' L' n Y2 O
break if !draw_path reach_point; Q k3 Z( e. Z& Q8 \
draw_path = false
^! l: w7 L) G6 J- Q
check_points = new_end_points! V' o/ v) O1 h1 X0 F+ {
new_end_points = []4 p( t: {/ K- X, \$ w; X! J
step += 17 p$ C' U8 C8 b/ J
break if step KsOfSionBreak_Steps &&+ m e2 S8 ~; f+ c. E( m
!Input.press(KsOfSionFind_Path_Key)5 f: z/ k e2 F( o& n) P" w
loop do #loop3 从终点开始反向填充
4 L. t4 T1 \5 I7 O: P
point_x = check_points.shift" V$ ^& n6 L8 K" z u
break if point_x == nil( u9 z: i; p! h! C( S" h3 O' A! M
point_y = check_points.shift# _) P: k; F: s7 A# T; L
left_x = $game_map.round_x(point_x - 1)
6 T7 n) c& X8 f0 E
right_x = $game_map.round_x(point_x + 1)
0 ^- M- o! f( {. j6 R, ~
up_y = $game_map.round_y(point_y - 1)0 ~4 d$ ]0 W Q
down_y = $game_map.round_y(point_y + 1)# W* _1 C" I# y; \
# 判断路径是否连通
path_step = step - 1
7 K- T3 G" v2 ?8 e3 v4 h
if sheet[left_x, point_y] == path_step L! P5 r9 Q1 x2 C; n
chase_path.push(6)
! {) g8 J5 {( P0 m8 u$ V- L) {
chase_point = [point_x, point_y]
: i% h3 J1 D2 w2 v
reversed_chase_point = [left_x, point_y]" i, c7 z0 v# s) k% ^% ^2 r
reach_point = true; break- v0 }5 |( H) k) F) }# Q& U
elsif sheet[right_x, point_y] == path_step$ b$ a$ a1 [3 F! x, K8 S2 ^* c
chase_path.push(4)- r- \, w) P! U, i2 w |
chase_point = [point_x, point_y]
! l/ A$ c+ h3 R+ d
reversed_chase_point = [right_x, point_y]
5 R+ Z- \9 G- m0 S
reach_point = true; break4 x7 g2 d3 o% S% Y5 s% e+ J
elsif sheet[point_x, up_y] == path_step- C' a; |/ M- I3 c4 V0 N3 r8 ?
chase_path.push(2)" \; c: h% K3 c) V% q/ c8 D
chase_point = [point_x, point_y]
& a# `% u, f8 [" X
reversed_chase_point = [point_x, up_y]' }% R4 s" A& Z' f
reach_point = true; break
8 U- l0 h, B! l4 e: Y6 O0 w0 b
elsif sheet[point_x, down_y] == path_step
S. N; @! c( s3 [: g% l
chase_path.push(8)
2 w R/ N" o$ v) t) {+ Z, l+ x# T6 d
chase_point = [point_x, point_y]8 j9 L" J. D9 N
reversed_chase_point = [point_x, down_y], [- k5 Y4 I# X9 f2 [
reach_point = true; break* l/ \) R# v, K' ]6 w8 P
end! y! ^1 U1 a' E, C4 ~
# 以需要抵达该点的步数填充路径表格 #, x+ W( ?9 w! P K4 K; b# Y
if sheet[left_x, point_y] == 0 &&8 l8 @* c1 }9 F- k) c9 y
$game_map.boat_passable(left_x, point_y) &&9 k7 E+ ~- H G
!collide_with_events(left_x, point_y) &&
8 u! S. { N6 x9 O4 `) W
!collide_with_vehicles(left_x, point_y) #judge_end
0 g& B4 d1 B5 q/ W
sheet[left_x, point_y] = step
' u& n8 u% ^2 T" o. j7 g; ]
draw_path = true
1 v( D, o9 Z A* e/ w" |2 Z* M
new_end_points.push(left_x, point_y)3 D5 p H, Y: ~
end( Q w. T4 [3 b3 U( ]5 z1 u6 Y
if sheet[right_x, point_y] == 0 &&
) w* _; w* X% x9 z& T. C \6 g2 \- K
$game_map.boat_passable(right_x, point_y) &&' ]7 P2 a* ^# B4 W
!collide_with_events(right_x, point_y) &&3 j$ P' J1 I% p/ z. c" c# k5 \
!collide_with_vehicles(right_x, point_y) #judge_end
7 P. A: a; e; A$ e; o4 ]
sheet[right_x, point_y] = step& v& p9 _7 W+ R! k8 j7 Y6 Z
draw_path = true, o6 f% E/ A8 t+ a) |/ v4 R
new_end_points.push(right_x, point_y)
$ Y# n: i6 h, N' W8 z
end
' M. a) u7 G6 }# a8 {( p8 A
if sheet[point_x, up_y] == 0 &&
. h6 K$ T& e- ~6 s' C2 O6 e) U
$game_map.boat_passable(point_x, up_y) &&+ `& S% e% A, n( Y
!collide_with_events(point_x, up_y) &&* U" @9 F$ e) l: `
!collide_with_vehicles(point_x, up_y) #judge_end$ A; @& T. [* s0 s, @* P
sheet[point_x, up_y] = step
$ S& O% ~3 O) o! V
draw_path = true
' j( I! X. z% R t, l! e
new_end_points.push(point_x, up_y), ~" O' P. I: b- h0 g' a1 q h
end) [6 l& p( i7 K8 N
if sheet[point_x, down_y] == 0 &&
4 Q3 f, m7 _$ C. H9 [# T$ Q0 k
$game_map.boat_passable(point_x, down_y) &&7 Z l* _# w7 I9 V- Q
!collide_with_events(point_x, down_y) &&6 Q8 i! R1 i- G- A
!collide_with_vehicles(point_x, down_y) #judge_end
" Q. v: j( [- ^* ?; K) j+ _
sheet[point_x, down_y] = step
' e8 M, l" x: F3 O; |/ a7 w
draw_path = true4 _4 u# ^7 v( N" g7 E4 w4 h
new_end_points.push(point_x, down_y)( j! d( @; w W7 x: [) T) q( g
end- D/ m" c7 C( h w5 m
end#endOfLoop39 u. x. t( {9 J% k) [' I. D
break if !draw_path reach_point5 m4 K& ?0 e* z
step += 1" M x. h5 C6 p
end #endOfLoop1 路径表格填充完毕
" D1 m1 W7 r" }# {! Q
$mouse_move_sign.transparent = false
7 I0 \- u% Z- U \9 ]
# 判断指定地点能否抵达+ I/ Y3 L( @) E
if reach_point; x; Q& j* ?2 j6 F9 ?
$mouse_move_sign.direction = 2- K: S+ ~# b0 Y
else* x) w N0 l" q9 e) e0 y
not_reach_point
( Q# }2 y0 m# A9 c! l
return7 S- W9 N9 x$ y2 v
end
% K& E+ y) q9 R7 N, c' C
# 根据路径表格绘制最短移动路径（正向）
3 {4 U X7 h! N2 e8 W
steps = step 2 2, e u" H5 Z5 v% j6 }! \
loop_times = step 2 r+ U* i6 z/ j8 l
point_x, point_y = chase_point[0], chase_point[1]
4 \* `/ m7 D$ _# u
for i in 2..loop_times # forLoop% T# l1 N2 w) l7 f8 p* M' V+ p
steps -= 2) g; i4 r5 U% z, C' S
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs
6 ^+ [( _' m5 O/ W9 }* |3 n
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps* u* ]9 o/ ^+ s( W F+ x- i
chase_path.push(2)
/ R) [, y! B( M) f5 I! w: J
point_y = $game_map.round_y(point_y + 1)7 O$ N% G6 S1 E0 \
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps
6 I! ]' G1 H7 A! O
chase_path.push(8)8 d& `" h: n0 d# @; _$ W8 X
point_y = $game_map.round_y(point_y - 1)! r2 F% Y* m% M% C9 K7 d7 Q9 {3 {/ l
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps
5 W4 b' d, {) [1 ~, u7 h
chase_path.push(4)6 D+ T' k+ J/ h
point_x = $game_map.round_x(point_x - 1)# e" K( H/ e* e
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps# I; ^8 j5 j. h7 q
chase_path.push(6). S$ q2 W. X5 c: |' [
point_x = $game_map.round_x(point_x + 1)- y* w/ `, u2 j4 F7 F7 J1 i6 p
end
. }8 N( I) v. J! C8 k
else
( h. |# r& f% N* p, A6 T" F7 I; }# P
if sheet[$game_map.round_x(point_x - 1), point_y] == steps8 o2 k/ P; h$ f+ N* v
chase_path.push(4)& H$ c: e* D! c
point_x = $game_map.round_x(point_x - 1)
* ?5 S2 F$ p0 n9 J7 h/ v. E
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps: v8 X6 D9 Z+ p0 @% C% y
chase_path.push(6)* r6 z7 d. R: K# f ~0 F# l4 l+ N: i
point_x = $game_map.round_x(point_x + 1)
; s0 F% n; f2 t
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps
# D& {7 M# b$ W8 ^; v f% s
chase_path.push(2)& A6 M5 B* S9 H& V
point_y = $game_map.round_y(point_y + 1)* `7 H; U3 B, M: M" e3 ^/ N2 T
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps
. ^1 {9 n* o) I. r) N
chase_path.push(8)
* D! l( O! F" V3 [2 {5 w$ u) Y
point_y = $game_map.round_y(point_y - 1)
. h* z) r9 c7 Z/ _; ~
end8 i1 @0 N2 {$ l; O! y6 i
end
5 `% g! m5 o( y+ P; L: ~
end #endOfForLoop; T: a, j& _6 C
# 如果指定点无法抵达或者登陆0 J* R6 o% n( K5 D& [' A# Y
return not_reach_point unless landable(@moveto_x, @moveto_y, chase_path)" S# ~& P: v' V0 v$ a, \
# 根据路径表格绘制最短移动路径（反向）! C2 d! o; l' ^: f' d
steps = step 2 2 + 1
6 }$ C. p: v: |8 o0 j4 K: T2 y) G
loop_times = step 2, G* U7 B4 m: t( J6 y0 n9 W8 A
point_x, point_y = reversed_chase_point[0], reversed_chase_point[1]1 U+ ^# A% t+ |! e$ ~
for i in 1..loop_times # forLoop
; B7 e6 \. F2 `/ s) A% E
steps -= 2
2 K2 Q7 U o; w- r2 `- b
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs0 X) s J t6 I( \; E% j; ~* U+ u
if sheet[$game_map.round_x(point_x - 1), point_y] == steps
0 t$ g9 }- _/ S' z0 J4 l( P
reversed_chase_path.push(6)/ N! E$ v# k* n6 D; S
point_x = $game_map.round_x(point_x - 1)
9 i& R) W3 i' Q% L G8 M" W1 u
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps8 u5 K6 d! V, T" a. f+ R3 c
reversed_chase_path.push(4)* ]/ ]1 r* o) a. N6 W
point_x = $game_map.round_x(point_x + 1)
* `! G/ |2 |1 _% |7 f2 H: Z
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps
6 k; v* ?: l( d/ M5 T/ F
reversed_chase_path.push(8)2 V. B5 |$ i2 i* _; R' f5 c* T# S
point_y = $game_map.round_y(point_y + 1)7 N3 p- A v6 a4 @' E
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps
% B7 l% M! j5 X" I4 `7 R. X
reversed_chase_path.push(2); s7 R3 V6 o- w
point_y = $game_map.round_y(point_y - 1)
* K. h& I" f8 ~" y' S
end; t% l1 W1 [* l+ w" N7 A7 u
else8 q. B( f* [. Z& b4 t9 v& d
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps
1 G) e) L% v$ L
reversed_chase_path.push(8)
- x g$ N' }0 e% z; K' g$ i
point_y = $game_map.round_y(point_y + 1)
8 |1 Z) ^* V& Y) h
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps
( q' z) t) Q2 z% l( X* H3 b
reversed_chase_path.push(2); s7 r- }7 K& ]0 w' }
point_y = $game_map.round_y(point_y - 1)
/ i9 ~# c8 [/ G; i3 E
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps& e6 O* \0 m! j1 ?4 R$ Y# D
reversed_chase_path.push(6)
. I+ M9 R& n% ~9 j5 u4 ~3 }& u h* [
point_x = $game_map.round_x(point_x - 1)+ z7 K7 ^7 ~* m! R9 d: I1 t( l$ H
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps3 `8 z/ P( ^! t1 _4 [
reversed_chase_path.push(4)
1 A/ c+ x, k: `) V& G( c
point_x = $game_map.round_x(point_x + 1), X0 w2 O8 [ A1 C% m3 E* @
end
& J. D ?9 k8 b6 z
end
* f5 j- {$ L, L) O2 T8 R. D* N
end #endOfForLoop1 r- L1 ]# W/ e/ [$ ]
@mouse_move_path = reversed_chase_path.reverse + chase_path
4 }, Q$ D4 P9 h' ^- q+ O
end#boat
# S4 R6 y" N' z1 `. E% [
#--------------------------------------------------------------------------
$ R: V7 w# s* d, @- S* G: u0 H e
# ● 绘制ship的移动路径 @array[move_directions...]
7 O- e. P/ t& R) P
#--------------------------------------------------------------------------! {& r' L. k2 l
def draw_ship_path
$ R/ }2 Z, [/ q4 j. g
# 准备绘制路径表格& X. P: L# h* b3 S( Y' }
sheet = Table.new($game_map.width, $game_map.height)6 V7 F3 E: I$ M* D: V U8 o
reversed_chase_path = []; chase_path = []1 m- D. Q$ l$ z4 Z5 s5 P* Y
reversed_chase_point = []; chase_point = []% [9 l; o5 M' s$ A/ i3 O
new_start_points = [x, y]; new_end_points = [@moveto_x, @moveto_y]
+ W5 h/ h7 r5 I' y
sheet[x, y] = 1; sheet[@moveto_x, @moveto_y] = 2
6 j6 M3 |9 I5 M m% P
reach_point = false
|8 T: h2 l2 ], P* P- p2 c
step = 36 g( q. ^6 f, w/ P& F8 ^' a
loop do #loop1 开始填充表格; x# d& x4 @( p7 ^1 e
draw_path = false0 P: J8 Q# i" J2 U9 Q
check_points = new_start_points
9 h; }7 P7 [" G
new_start_points = []
9 L+ ~4 e! l0 E4 ^
loop do #loop2 从起点开始正向填充" D. S7 b& ?& q
point_x = check_points.shift
3 e! X! N; J" k
break if point_x == nil' J" m& v F9 S: Q( N4 o
point_y = check_points.shift# E) p( U' Z6 D B! d) s' Q
left_x = $game_map.round_x(point_x - 1)& e/ P) \% E$ v$ t! l+ V$ q# r9 i
right_x = $game_map.round_x(point_x + 1)! Y+ p7 B5 B |5 O: s3 }
up_y = $game_map.round_y(point_y - 1)
0 V9 ~9 g6 O' ~6 |) e
down_y = $game_map.round_y(point_y + 1)
0 q; @* \& o4 u. G {8 h
# 判断路径是否连通 h. _0 z2 z' L8 C1 p% `
path_step = step - 1 X) T- C. p: y8 P9 I. C# o
if sheet[left_x, point_y] == path_step
6 [$ }* y' p+ F
chase_path.push(4)
& \5 D/ y! S; ~# t Q9 Q/ v0 ~$ H
chase_point = [left_x, point_y]
( \3 q. S. z* k5 ]2 F: C
reversed_chase_point = [point_x, point_y]
, t# m/ U1 O3 b! j+ m5 ?
reach_point = true; break0 w: g. f' Y% u0 R# l4 a$ B( U
elsif sheet[right_x, point_y] == path_step4 u4 q8 J; z7 V9 u9 [0 S" |
chase_path.push(6)
/ L4 L8 C. h, l. S
chase_point = [right_x, point_y]4 C; g3 S* ?0 Y
reversed_chase_point = [point_x, point_y]
, A/ V" ~. q0 {
reach_point = true; break
5 j$ p% F8 f0 j' c$ A( w
elsif sheet[point_x, up_y] == path_step
* c& \/ G+ T. Q' H1 {# m
chase_path.push(8)
' i/ h* F# g5 |6 i" o" u2 ]) R
chase_point = [point_x, up_y]
" d4 _" k* }( F( ]3 ^ `
reversed_chase_point = [point_x, point_y]
6 k+ w, E8 k" i' P8 j& w \
reach_point = true; break
. E& e( C& o3 J( l
elsif sheet[point_x, down_y] == path_step4 K" q' z' k* M2 h- y) ]- e
chase_path.push(2)3 C E+ o, x! w: Z/ j8 J2 x
chase_point = [point_x, down_y]
; ]% ?4 B9 o; s8 o3 u* c6 a: W
reversed_chase_point = [point_x, point_y]2 v: w# Y( x- k ~+ B1 U
reach_point = true; break
end
3 {' T+ L: R" H
# 以需要抵达该点的步数填充路径表格 #3 u- q* D6 ^+ z/ z; |" [
if sheet[left_x, point_y] == 0 &&
$ a% Q, X/ z P6 e7 }4 K) a9 P
$game_map.ship_passable(left_x, point_y) &&
! M3 T+ B3 J, ]5 ~
!collide_with_events(left_x, point_y) &&
( \: h! T3 w" |/ \1 u3 f# m1 Y
!collide_with_vehicles(left_x, point_y) #judge_end0 R, t, ?( V. x$ ?0 U8 x
sheet[left_x, point_y] = step; Y9 h& b6 z; x- Q2 V- u4 G
draw_path = true( x2 B7 J) _# A& U+ R! d
new_start_points.push(left_x, point_y)
% u3 |; S, t/ ^0 m4 u
end E H! h/ n0 j: i; E" _/ `7 L6 z# ~
if sheet[right_x, point_y] == 0 &&
, {1 j1 W# h, g6 v1 x9 q$ u
$game_map.ship_passable(right_x, point_y) &&
$ R# j7 |5 W6 ?/ }5 Z0 n3 W" p
!collide_with_events(right_x, point_y) &&- m6 v5 D0 m$ \8 H
!collide_with_vehicles(right_x, point_y) #judge_end" f2 ]# N' |" b) F/ p4 h7 p! b
sheet[right_x, point_y] = step! K. O7 M: ~1 v. L8 i7 @: r# e6 h
draw_path = true: c$ e1 |" `6 Z
new_start_points.push(right_x, point_y)
5 ^# m7 A2 u/ P w6 d" v
end
p7 b+ b1 G' E
if sheet[point_x, up_y] == 0 &&9 G1 |7 U: C( H* d1 M& x! K
$game_map.ship_passable(point_x, up_y) &&
$ p" b+ W; ]/ R2 W. v
!collide_with_events(point_x, up_y) &&
6 [# L7 G! Q3 t) \9 L% g [% m
!collide_with_vehicles(point_x, up_y) #judge_end
9 c L1 p# G' N0 Y
sheet[point_x, up_y] = step
% n" A8 U* V2 R# f5 X4 M3 K
draw_path = true. d3 t0 k. u4 q; x- C
new_start_points.push(point_x, up_y)8 C# v4 `* _# t! c
end
0 z# G; ^+ R" G2 p
if sheet[point_x, down_y] == 0 &&/ G1 ^2 g' B; K
$game_map.ship_passable(point_x, down_y) &&
1 T) e; L C- W1 E1 U# h; z
!collide_with_events(point_x, down_y) &&4 v t+ |+ I* V- i2 X. m8 }
!collide_with_vehicles(point_x, down_y) #judge_end2 x2 Q9 x5 ?8 g# Y9 ?- o
sheet[point_x, down_y] = step# |1 F3 ~! O' r
draw_path = true
' V1 J% {4 ]4 A+ E' B8 }- V
new_start_points.push(point_x, down_y)
* a+ H" M! @3 X) b
end
( b, i# v9 S5 i2 U$ q: g4 b0 h
end#endOfLoop27 Q1 a+ M; t) ?4 s' S) m" g
break if !draw_path reach_point0 P3 L, @9 d: G
draw_path = false
" p, `5 E8 X/ o$ B+ c# A
check_points = new_end_points H( c: T# j) I& t
new_end_points = []
' o! k: D; U; C- E
step += 1) E% T% p6 }) |0 T& R1 H: L1 H
break if step KsOfSionBreak_Steps &&
6 K2 J1 X/ M+ K5 s
!Input.press(KsOfSionFind_Path_Key)" Y+ _4 W6 ] E1 y% n9 T
loop do #loop3 从终点开始反向填充: T* b a! R1 v& ~; R
point_x = check_points.shift
* c# c) v7 i4 W5 l# D- j
break if point_x == nil
% c5 P% y Y/ {% M k
point_y = check_points.shift5 G8 o0 U$ G9 t |
left_x = $game_map.round_x(point_x - 1)
0 W2 f6 K2 ^' v2 ^& Y! A
right_x = $game_map.round_x(point_x + 1)
3 m0 j" d; l4 i1 V$ |/ l8 E+ [
up_y = $game_map.round_y(point_y - 1)" S+ G8 I" p, M
down_y = $game_map.round_y(point_y + 1)- A2 I! g4 }: n3 D% U
# 判断路径是否连通
" z& Y0 m2 [& v) s! n k) x: f& F
path_step = step - 1
+ W9 X7 L$ [( u( ?
if sheet[left_x, point_y] == path_step/ T5 \* ^9 q y- ^* T+ H8 U$ g
chase_path.push(6)
% [" A) u; p' y8 X0 Q- H1 a
chase_point = [point_x, point_y]
2 Q% R% M8 G% \2 j* _5 ]; ~8 r
reversed_chase_point = [left_x, point_y], U, x& q# K$ Y; B3 f- W% N
reach_point = true; break
# l" }! \6 b$ j- J
elsif sheet[right_x, point_y] == path_step
1 w: q, R2 y8 x6 h+ ~
chase_path.push(4)
chase_point = [point_x, point_y]1 P/ A0 d/ M0 g" J. K( Q6 Y
reversed_chase_point = [right_x, point_y]
7 c5 Y- L* O5 p8 i4 K3 t' P s6 _
reach_point = true; break+ R6 [1 N+ I" y/ K% v
elsif sheet[point_x, up_y] == path_step2 d7 u0 o9 J' W: u' ]2 m; {
chase_path.push(2)
/ p9 w2 U+ q, a2 S
chase_point = [point_x, point_y]
& Z- K0 O) [( \3 |
reversed_chase_point = [point_x, up_y]
; Y# \ N, | q z1 H
reach_point = true; break
3 I/ g+ O, `! i3 X' }9 A# b
elsif sheet[point_x, down_y] == path_step9 o1 B' S( H( J
chase_path.push(8)+ c; a, d a) y4 s
chase_point = [point_x, point_y]6 c( g2 G9 p& K, z% V' E
reversed_chase_point = [point_x, down_y]" s; l1 S. x; F
reach_point = true; break
: e% e5 f! q( }, R* |3 D: n: ?$ F
end- n# d( b7 J& ]+ b$ `
# 以需要抵达该点的步数填充路径表格 #
" t2 Y# B, a( y% |) x6 n2 J( y& t
if sheet[left_x, point_y] == 0 &&
6 x& l& V0 E: Y/ b) d; h- ]: F
$game_map.ship_passable(left_x, point_y) &&; E) `3 j3 V) l; z
!collide_with_events(left_x, point_y) &&; }* c! E, c9 d* ~
!collide_with_vehicles(left_x, point_y) #judge_end
E- o) A2 N; P5 e. r2 ]. a! y, ?/ c
sheet[left_x, point_y] = step d- M/ r$ b* Y5 ]- z8 N
draw_path = true& X$ D' d( j. I) g) l$ H' @
new_end_points.push(left_x, point_y)5 S+ z" [$ O& O: q6 _
end: v+ X0 h: Q% R( `0 O) z
if sheet[right_x, point_y] == 0 &&7 p- f% ~. ]6 g3 P7 a
$game_map.ship_passable(right_x, point_y) &&
$ H5 p0 l; s2 A: J' K
!collide_with_events(right_x, point_y) &&1 ~% K, \4 j+ q8 @( L7 x
!collide_with_vehicles(right_x, point_y) #judge_end
2 s ] u1 S' l5 z) Z
sheet[right_x, point_y] = step& Y! g( y6 J/ b' Q
draw_path = true4 t4 z; D) u* \
new_end_points.push(right_x, point_y)
) K+ { {) B& y2 H C) M
end! r+ E9 h! l/ S! q. C
if sheet[point_x, up_y] == 0 &&1 L+ D! S! c2 b. |# Q+ i/ G; k) R
$game_map.ship_passable(point_x, up_y) &&
* D& O5 F# t% ?3 M9 \6 V: }5 s
!collide_with_events(point_x, up_y) &&( U" c8 O+ K% e2 K1 n+ u
!collide_with_vehicles(point_x, up_y) #judge_end+ X: d* v* |% J0 i# ^+ [) k2 ]7 s1 q
sheet[point_x, up_y] = step" V7 c& P0 Q# E P8 j( i2 r4 y
draw_path = true/ Z7 ]! ~4 t) i' I
new_end_points.push(point_x, up_y)
/ `0 M: B+ R/ h8 m, c
end% A6 J; ]: y( S& Z0 N8 {5 c2 x+ E5 W
if sheet[point_x, down_y] == 0 &&) w1 X$ s1 [* Q( @
$game_map.ship_passable(point_x, down_y) &&
- S G, T }: w. I5 G
!collide_with_events(point_x, down_y) &&
2 o( L) F7 t+ D2 [4 w
!collide_with_vehicles(point_x, down_y) #judge_end- {# I$ q1 r& ^+ L4 Y) d
sheet[point_x, down_y] = step
2 S+ v9 A; H6 E8 B/ j
draw_path = true
) w9 u2 v: }: H+ K, C+ d$ j
new_end_points.push(point_x, down_y)
1 s7 t: o9 X6 p* A( m
end
5 U q8 T h! q3 z
end#endOfLoop3
& A2 k- }) s, o% D& X1 ?
break if !draw_path reach_point
) @- I8 K, }! _& j3 C/ y+ o+ y
step += 1
* H; v' P0 a8 H6 f |8 W/ n& W
end #endOfLoop1 路径表格填充完毕2 h/ d, y+ l' s) i$ R4 F; D
$mouse_move_sign.transparent = false: ^( u9 N( Y* E8 k# E
# 判断指定地点能否抵达1 J6 \' f! q# R9 b
if reach_point2 G% k6 p2 y% T% Z
$mouse_move_sign.direction = 2; g( v9 q' o3 J( Z* s X9 C
else
7 P4 V; n( D: b+ ~8 S
not_reach_point t9 X8 r* S$ ^2 h- ?8 j
return
2 q9 s% d9 C+ u% y
end4 X5 F1 Z* S; ^2 n7 P$ O
# 根据路径表格绘制最短移动路径（正向）! ^8 s p$ V: k
steps = step 2 2
8 p! i6 d" U; i, _) ]/ w
loop_times = step 2- [2 {' O4 \* ~) b! q! t7 y# D" g
point_x, point_y = chase_point[0], chase_point[1]. K9 l1 j1 |$ t9 N
for i in 2..loop_times # forLoop- h$ j4 q, {2 ?" V( ^# R
steps -= 2
# u5 K" z6 {. [9 ~2 S
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs
* t0 g5 O1 z. S I
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps9 Y$ {( ^' V7 j0 t" c
chase_path.push(2)( t0 {5 R% U0 Z& b# J: ]( y: }- T
point_y = $game_map.round_y(point_y + 1)2 P. u2 i: Q. B; v. {; l
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps0 ~+ v$ |$ g$ a2 {1 @# ~
chase_path.push(8): n* t1 N2 t1 Z# R" v
point_y = $game_map.round_y(point_y - 1)
- c4 |, `6 z' ]# s) V3 [5 p1 O
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps
* ]1 v3 e+ }# h6 R( M
chase_path.push(4)
+ i4 j; G: K& F2 U7 h
point_x = $game_map.round_x(point_x - 1)
; V) S1 ^- D3 K* K+ v* E
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps
6 _% r4 o) `! S
chase_path.push(6)
) T& M: ]6 S G- z9 A
point_x = $game_map.round_x(point_x + 1)7 j- w; P# {/ U( J! C0 S# E
end
2 Y, b. H: ?9 t8 g$ d
else
4 I2 M8 w* d H: z
if sheet[$game_map.round_x(point_x - 1), point_y] == steps* C4 t! T4 }" J- C* P9 J
chase_path.push(4)
3 s. f8 \1 H+ u' y5 G
point_x = $game_map.round_x(point_x - 1)" W+ g) {* r' N6 ]
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps
% U# U8 S: @7 o6 I3 d
chase_path.push(6)
8 {( O5 ^ c3 N7 q; V% ]
point_x = $game_map.round_x(point_x + 1)5 d- @( M0 H6 A3 O( O! P7 o. }, E K
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps
, h& `+ z7 |+ ~6 j, q+ D
chase_path.push(2)$ h8 f9 q8 J6 X0 ~& g* Y0 P
point_y = $game_map.round_y(point_y + 1)( H) u* U2 D a' r7 p- n' D1 \3 i
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps
; j# O E% ? ^6 t# ^
chase_path.push(8)% S: z) O5 O0 C- a
point_y = $game_map.round_y(point_y - 1), g% v4 t* o6 |. W- u. ?6 @
end5 I! k% M# I6 X& g! I5 }( g
end
3 [. @; f5 T" m# K" \/ l+ m
end #endOfForLoop
* W: r( g0 N3 p; _" K; T
# 如果指定点无法抵达或者登陆
4 I+ J3 L) J( h0 d7 t/ X% n) k. l
return not_reach_point unless landable(@moveto_x, @moveto_y, chase_path)) H# G$ P6 j7 o; w: U, Y0 D$ }
# 根据路径表格绘制最短移动路径（反向）; j$ ~: W g, w9 L
steps = step 2 2 + 14 ~& }; P1 A+ S( W; p
loop_times = step 2
5 y' a q' Z! Y, @2 \
point_x, point_y = reversed_chase_point[0], reversed_chase_point[1]1 s- A) O! ?2 O/ p* R; y! o B
for i in 1..loop_times # forLoop
) Q6 }9 Z- m5 O9 h
steps -= 2
: g' e; H. ]5 f1 M6 T5 L% q1 r& S
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs
9 K7 u h; N$ y5 ]5 k/ s9 U! b$ y
if sheet[$game_map.round_x(point_x - 1), point_y] == steps
/ y: \7 m9 @; u8 j1 D
reversed_chase_path.push(6)
4 ~' ^5 |: Y6 Z5 o$ G) v
point_x = $game_map.round_x(point_x - 1)
+ p8 m2 g* X* o% a l) }* _+ J1 z
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps
, I5 ?* f4 }8 y- l: \3 {
reversed_chase_path.push(4)
& O+ B( |6 H( m; Z3 v
point_x = $game_map.round_x(point_x + 1)& J- @, r: O: u' t4 B/ ]7 b0 P
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps
5 }0 \9 C3 N$ r8 v9 a
reversed_chase_path.push(8)
2 C. K% a: ~# R. k6 Y; _
point_y = $game_map.round_y(point_y + 1)2 G7 t2 }& m; [/ L( M! C7 ^5 k/ Y
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps+ S' h1 b" W1 Z- Q0 w
reversed_chase_path.push(2)
& f( M" p) w3 v% k3 d0 T& ?$ o
point_y = $game_map.round_y(point_y - 1)
6 I- {* h( W, D9 ]& l0 n7 I* M
end
" A; y1 V6 `& w
else
" }1 P) j8 ~( b
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps2 F: a* {% V% ]
reversed_chase_path.push(8)
7 T! e0 G3 r2 T5 u9 N2 a
point_y = $game_map.round_y(point_y + 1)% X) |) x5 }. B+ s# e. Y8 c
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps2 T' ~+ t( X2 @& {/ a
reversed_chase_path.push(2)
2 n: F0 z N5 a& Q
point_y = $game_map.round_y(point_y - 1)9 I% g- t! S9 }3 J# l1 n: n
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps
8 @! U7 t( {0 |" J5 o' t0 }; a' r) [
reversed_chase_path.push(6)
2 R8 T! N! n% U- g, P; S' R
point_x = $game_map.round_x(point_x - 1)
# I( W: X/ q2 i, Z* N
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps
2 s% @, E' K- P/ S3 R
reversed_chase_path.push(4)
- b/ r. w5 X+ v/ u6 U6 ?
point_x = $game_map.round_x(point_x + 1)4 j p. l" D+ w
end5 P) x* V9 I; ?4 y' u- o' l+ O
end
( f- I9 e6 i% r' J& I9 Y" l
end #endOfForLoop
$ @5 J# _' Z+ ^# \7 `# a/ l
@mouse_move_path = reversed_chase_path.reverse + chase_path
4 |5 X. I/ R r" A7 s+ u
end#ship
" k; z& v- X' W
#--------------------------------------------------------------------------
9 J7 e8 l$ H8 O
# ● 绘制airship的移动路径 @array[move_directions...]
) ?2 s; ]( K# n7 S
#--------------------------------------------------------------------------
% c9 k2 R( T( `4 \) k
def draw_air_path; f, X6 A2 n7 U& u! t, U
$mouse_move_sign.transparent = false9 q b1 U/ t# s5 R: |; C* j x5 a
# 准备绘制路径表格- Q& ?- n1 b$ f b* ]% O! x! e
sheet = Table.new($game_map.width, $game_map.height)) X! U* V7 O7 B7 V( A
new_check_point = [x, y]; sheet[x, y] = 1* b/ w+ s+ v' D# l+ D# C8 H
reach_point = false; step = 2
) g1 V- r- f% p6 B
loop do #loop1/ J; C+ C2 X# y& b0 i; u1 v2 u
check_point = new_check_point& K, a% M0 e: o$ E
new_check_point = []. `. D1 k5 X$ ~9 ?4 U: N4 H, P
loop do #loop2
" A$ r% T5 k- m8 v. O2 t
point_x = check_point.shift
! T8 h, A* }9 N- f
break if point_x == nil; z3 n* K+ }8 L0 @' |
point_y = check_point.shift3 N# ~3 X6 L0 z6 W4 A1 j0 W& G
if point_x == @moveto_x && point_y == @moveto_y
6 w* Z% f- n- S. f7 B3 h
reach_point = true; break3 c& m" v: L2 w# k; P, v
end) ]1 H4 i" }, V/ n. \
left_x = $game_map.round_x(point_x - 1)
! u5 X' N6 w( f
right_x = $game_map.round_x(point_x + 1)
9 ]- U% j5 a- K- ?4 C% n8 Q
up_y = $game_map.round_y(point_y - 1)
- F3 ~3 q. }( w
down_y = $game_map.round_y(point_y + 1)
# R6 z$ n7 p; D9 I4 G
# 以需要抵达该点的步数填充路径表格 #( l+ k% _, |6 J& }3 W$ }; f
if sheet[left_x, point_y] == 01 L0 X4 x" P! F
sheet[left_x, point_y] = step
# Q0 N3 \# W f* R( K( O
new_check_point.push(left_x, point_y)9 e+ _" J9 c1 l( L1 S q
end
! R% u# E: F. S v# [* b
if sheet[right_x, point_y] == 0
, }: Q3 a; o( U' m Q
sheet[right_x, point_y] = step
( B+ [# w* _6 Z& }3 n
new_check_point.push(right_x, point_y)
/ N$ E) y7 ]. I4 p r, r7 [& p
end7 } J! O+ X' A
if sheet[point_x, up_y] == 0
{5 u& f3 K- I+ z3 Y( u
sheet[point_x, up_y] = step
4 a5 b$ Q! X u! X4 U0 s% A
new_check_point.push(point_x, up_y)
' I4 `& L3 u: o/ T
end
. h, p: d o" h! k
if sheet[point_x, down_y] == 0& u- M: J! K K( @. f
sheet[point_x, down_y] = step
; j8 a; W4 g: w% |* z+ S7 H
new_check_point.push(point_x, down_y)
2 ?. y! D: W/ K# |; o
end
/ i& i x+ f( B' [* @
end#endOfLoop2, E/ c! N7 p" Y
break if reach_point
3 [; ~" H. ]& k, s! \) i3 t
step += 1
' u$ w \. \/ n" |& \* F" Y b
end #endOfLoop1
6 ?% r$ w6 ~$ \2 b D
# 根据路径表格绘制最短移动路径 #
0 G5 J( }) L5 \1 w; U7 N; l, a, R
reversed_chase_path = []; step -= 1/ ?' a. Q- d, J5 j8 y1 u
point_x, point_y = @moveto_x, @moveto_y# O9 u; ^2 P# E+ [8 i7 K
for i in 2..step
2 r$ W7 M0 |" _& a; W7 b
step -= 1
! F" |: k+ u; O7 T% l
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs) S+ K2 W( F8 y6 _, }
if sheet[$game_map.round_x(point_x - 1), point_y] == step0 ?8 e4 ?, Z H7 s4 H2 e
reversed_chase_path.push(6)% i3 w2 u2 M" p+ j, K+ X
point_x = $game_map.round_x(point_x - 1)0 q9 N: [- O' |
elsif sheet[$game_map.round_x(point_x + 1), point_y] == step5 R k5 H2 X$ W3 J p! r
reversed_chase_path.push(4)
9 I8 z$ ^ d8 G5 S/ R" d
point_x = $game_map.round_x(point_x + 1)
& `+ t; t6 O3 o$ ^5 T
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == step
5 C+ @; j. r; N7 F. m- k8 ]
reversed_chase_path.push(8)( \9 d7 d9 v, ~
point_y = $game_map.round_y(point_y + 1)! ?: Y" ^. |/ H7 }
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == step
( W; n% N1 m1 T
reversed_chase_path.push(2)
, p6 @3 a+ t3 i. U1 m/ Y! B
point_y = $game_map.round_y(point_y - 1)
, ]3 A- B8 {# t2 ^( {) S
end
# z1 ?! O# b @/ L9 s- b5 O
else
if sheet[point_x, $game_map.round_y(point_y + 1)] == step
( m+ K' p. j0 P
reversed_chase_path.push(8)
+ c4 ?6 v! D& d/ \7 w* f
point_y = $game_map.round_y(point_y + 1)
5 T+ k6 I4 u1 y7 `6 ~& C
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == step
" x6 ?) ~4 |2 f& K6 |8 y. @
reversed_chase_path.push(2)' E4 b# C/ R# t' Q' C2 G7 C1 p
point_y = $game_map.round_y(point_y - 1)
; G' _. A5 u4 `- U
elsif sheet[$game_map.round_x(point_x - 1), point_y] == step. m k( ^, F0 l2 ]+ |8 H
reversed_chase_path.push(6)7 Q$ E1 D' b+ ], W$ m
point_x = $game_map.round_x(point_x - 1)+ I5 x" c0 F/ e" {6 l0 }
elsif sheet[$game_map.round_x(point_x + 1), point_y] == step
- c% J6 @ \5 ]" c, D
reversed_chase_path.push(4)
/ |/ [0 K* y; V2 U% c/ t9 O
point_x = $game_map.round_x(point_x + 1)! R' Q# w. I1 q E" y/ _4 z
end
D0 ]+ F2 E r0 B+ P! o2 {
end
) {3 Z' J& P9 q3 S- Y! C1 W
end #endOfForLoop
( z* c1 V. _+ n6 y) W
@mouse_move_path = reversed_chase_path.reverse6 w( W8 Y' t* R, D+ b P& W
end#airship# n% b0 q- T$ L
#--------------------------------------------------------------------------: Y# Q G# \2 O7 M0 ]8 f
# ● 目标点无法抵达时的处理，用于各路径绘制方法内部
! W8 k3 i- S( t2 t1 e/ V) j5 ?
#--------------------------------------------------------------------------
?0 ?; i5 @8 b7 M
def not_reach_point8 B8 P2 L. v, n( t3 z$ }7 K
$mouse_move_sign.direction = 43 j+ G4 ~8 w2 m$ a1 c5 N0 F
dx = 0; dy = 0; dir = 0
# R2 M6 \! S5 y' U: r& l# `
if @moveto_x - x 0
/ X) Y0 a: B, K) p* d. |* E
if @moveto_x - x $game_map.width - @moveto_x + x &&8 e3 Q% U5 f5 Z# d( J1 Y. V+ J6 }
$game_map.loop_vertical
9 X* A/ o; }: L* M' z
dx = $game_map.width - @moveto_x + x; dir = 44 z4 Z8 \7 v8 l* m8 r* F3 _% {: a
else7 p/ l; k$ P* I; A$ n6 i% s
dx = @moveto_x - x; dir = 6
V& c: @- C0 g$ N
end
: g+ C( S# l: K/ b5 p5 I: v
else
* Y' R% m4 K. U/ }/ F
if x - @moveto_x $game_map.width - x + @moveto_x &&' }6 Y4 ?* l' n$ Y1 [3 e
$game_map.loop_vertical
" j0 ]/ J+ D+ q* w/ r3 }1 w
dx = $game_map.width - x + @moveto_x; dir = 6; N6 [4 Q" g+ Q
else
2 d6 K, F: }6 g; D% i
dx = x - @moveto_x; dir = 42 D3 m J- v' v" f# [- [
end
: O) {8 y& l7 L: o
end
+ f2 H5 r( u( W. ?& ^" ?* z/ J
if @moveto_y - y 0
' f4 Y1 P. w* a/ P- B% ]- N$ r; h
if @moveto_y - y $game_map.height - @moveto_y + y &&
' ^$ F: w+ ^% M4 ^- V0 ~6 @) c
$game_map.loop_horizontal6 R# c3 J B9 U3 _9 x
dy = $game_map.height - @moveto_y + y
1 r1 O% i8 _; b: w i |
dir = 8 if dy dx8 O6 o# q D- z+ `- U
else
" K* V+ F7 Z8 A/ n3 w; k
dy = @moveto_y - y6 M/ ~" v# c# b, ^" K1 X
dir = 2 if dy dx
2 y* | a* G# w& J
end
8 |( _& i, K. i8 p; h
else. B8 R) x/ @. P
if y - @moveto_y $game_map.height - y + @moveto_y &&
: J# U* M: J' O) \. A$ A
$game_map.loop_horizontal# G; X Y0 O" B3 {. _
dy = $game_map.height - y + @moveto_y5 Z3 A. o0 H1 ?/ s- T) K1 X
dir = 2 if dy dx
2 z! z1 }9 g0 ]8 |5 O
else
# v5 n+ N5 M1 k
dy = y - @moveto_y) S9 t! R- @, ^
dir = 8 if dy dx
4 f$ H- o ~$ r+ K& e, a
end1 u& x- m. I, O# D* V/ p
end
* c3 Z. O/ V$ P/ o: M; g: E" g
@mouse_move_path = [dir, 0] # 0方向用于防止移动过程中触发事件
5 {9 W3 ?7 A3 `. M
end
1 c/ f/ x2 L' l/ l! X5 n( \
#--------------------------------------------------------------------------7 u- o3 g& |* X6 b( M
# ● 判断目标点是否能抵达、登陆，用于船只路径绘制0 T U m/ G4 D M N
#--------------------------------------------------------------------------
0 x; z9 X3 \4 V$ [6 Z
def landable(x, y, path)
' J1 c. \, C% m. @ u0 R1 [+ O
case @vehicle_type
; G# `+ t& q/ Q$ n% n- N. O# o
when ship; return $game_map.ship_passable(x, y) % U; B, }# v% p P1 A. E! @: W
$game_map.passable(x, y, 10 - path[-1])( c5 n( R5 x6 R
when boat; return $game_map.boat_passable(x, y)
6 e9 x5 C; h' y7 Y/ X
$game_map.passable(x, y, 10 - path[-1])
) x, U: W0 ^2 r$ U
end5 Q ^5 z- X) T0 }" R# _
end+ G( V/ u" [- A' k" r: ^
end- T, y N+ I; L+ ]/ z, F+ r. ?
' Q/ d# [% l3 Z
#==============================================================================
: C4 L! g8 Q' X6 l6 I3 W( c
# ■ Game_Map& M; u$ W$ n5 ^& O
#------------------------------------------------------------------------------9 q! h; G# e# Z! m2 R( `. P- T( }
# 　管理地图的类。拥有卷动地图以及判断通行度的功能。, s! h3 |8 x o
# 本类的实例请参考 $game_map 。
+ z1 a0 V, s3 `" T( ]3 ?2 O! n
#==============================================================================. Y2 F) [" }4 [7 s, }
class Game_Map _! Q2 i6 ]9 |/ r
#--------------------------------------------------------------------------
* f( r+ U4 @& e2 L
# ● 定义实例变量+ u0 a8 }8 W) t* m6 v; K
#--------------------------------------------------------------------------
1 E; ~$ m# e/ [0 F( S8 Y" j/ B
attr_reader mouse_map_x # 使用前需先使用 get_mouse_map_xy 方法来更新数据2 f0 h8 u5 _% d: `+ m% W8 z' T
attr_reader mouse_map_y # 同上
8 c1 U6 U" X: ?
#--------------------------------------------------------------------------! j+ c& |1 o( k! ~9 w
# ● 初始化对象
' d$ P3 w' _. @3 H& @( {
#--------------------------------------------------------------------------$ R$ M; j' M5 @7 Y
alias sion_mouse_initialize initialize/ `- o" p1 G! H9 O, Q% c6 m" M
def initialize& K/ n9 y$ A- L! G) z2 V# ~
sion_mouse_initialize: a0 B4 y8 L8 O+ v
creat_move_sign ###9 ^! W2 }2 M+ \: s: l
set_constants0 d' v, o) ^6 H: [2 h( a
end9 k& K& x- @1 ]1 W+ o b
#--------------------------------------------------------------------------
O( S4 T6 C1 t
# ● 更新画面
, g# c2 W0 d! I4 r
# main 事件解释器更新的标志4 y+ W' s5 ]2 w) [7 c
#--------------------------------------------------------------------------- q( S" ?" {" S- h: X
alias sion_mouse_update update
/ a5 H/ o3 Z1 L! C3 s- i0 s
def update(main = false)
+ j' ?1 m2 E' ^ l/ @
sion_mouse_update(main)
8 W& i; {$ Q0 s9 M6 g$ R+ H
update_move_sign& F5 U+ h7 D0 o- b
end" }6 j( L) w% j
#--------------------------------------------------------------------------# X9 @- |8 j% ^3 _ A" [+ H
# ● 创建显示路径点的事件
a4 Q7 E' L6 ?
#--------------------------------------------------------------------------
5 U+ o& y& b" P7 r S% ~/ P
def creat_move_sign1 T, {% k' v! N4 f" ]) Y! I
$mouse_move_sign = Move_Sign.new
! F7 n) c$ p$ ^! O' ]7 A9 k
end
3 d3 u& U% A/ F6 q2 C6 Y& m4 Z
#--------------------------------------------------------------------------
' I f+ C+ T+ t, ?2 B
# ● 更新显示路径点的事件: O. Y0 {8 K& f% }, O: G; p4 Y
#--------------------------------------------------------------------------
* `: a3 ~6 s+ ~
def set_constants
$ u) }! }' y4 Z" L' s0 C3 s$ Q
@mouse_pos_setted = true
; g1 u3 X% P5 v+ o
@set_pos_prepared = false
" V. ?! f$ s4 |" r2 k; x4 w- ?1 j
@mouse_old_x = 09 K9 J8 D, s: |8 F
@mouse_old_y = 09 ]/ I' F% j V9 G" U3 ]( J! j
end( c& k; Z: T. C3 i. c
#--------------------------------------------------------------------------
7 M9 L1 {* T# I, m, s6 r
# ● 更新显示路径点的事件
Z7 s+ t" x) b( w6 o) m* G
#--------------------------------------------------------------------------* ^) H7 `* B! X3 e
def update_move_sign
+ Y2 [6 W& A- R) L: t$ I8 r
$mouse_move_sign.update2 n; K6 c' V Q# l+ V( p
end
9 x" D2 B! i' Z# L) x2 D
#--------------------------------------------------------------------------& a' d* U; c: E# G
# ● 获取鼠标位于的地图块的x、y坐标0 i% I) x3 i% l4 ^. L
#--------------------------------------------------------------------------" m, F! r& w U& O. E& ?7 U
def get_mouse_map_xy0 d% H* L' j) }8 w( ^& E
mouse_x, mouse_y = Mouse.mouse_x, Mouse.mouse_y
* g$ i, R9 l* t
@mouse_map_x = round_x((@display_x + mouse_x 32.0).to_i)
6 W" U+ d4 z% p" O" a
@mouse_map_y = round_y((@display_y + mouse_y 32.0).to_i)
( h+ b0 A8 X( G% N/ X$ b
end* g. d/ U/ @( ~/ C+ y0 n5 a; E
#--------------------------------------------------------------------------6 B) V( X# O' C, S+ W7 i
# ● 返回地图画面时重设鼠标坐标
4 r+ b2 c1 { u# }1 b
#--------------------------------------------------------------------------7 B8 ^+ e# C7 n
def reset_mouse_pos4 ?8 J6 {) P0 w# r( u. d
return if @mouse_pos_setted4 ?9 d0 {) z' a
Mouse.set_mouse_pos(@mouse_old_x, @mouse_old_y)
% n e8 ?3 A6 V
@mouse_pos_setted = true5 A1 f# B# @; j7 A: a# r4 D/ B
@set_pos_prepared = false
3 o/ C, t5 G7 h: q9 H2 k* }
end6 ~) u! P* Y+ z6 T
#--------------------------------------------------------------------------
# c; K/ [5 t/ t5 x
# ● 重设鼠标的坐标
# p6 k% g9 E; c2 s W$ n( o# s" e" |
#--------------------------------------------------------------------------% ^' e7 [+ b+ j/ ?2 r! |: u1 L0 l
def prepare_reset_mouse_pos8 V9 _$ `. W3 }4 m# p
return if @set_pos_prepared j8 Z5 q# D- i* a4 ^6 q. ~
@mouse_pos_setted = false
$ v0 a5 H# ?2 G( z( L
@mouse_old_x = Mouse.mouse_x. W' \/ y# a+ g. l, T; R# Y
@mouse_old_y = Mouse.mouse_y
" E7 A9 J& o0 G9 y
@set_pos_prepared = true# z$ T1 o0 e1 _
end
5 B0 g7 M" }! a* o H
end
% L3 d N+ x1 s: Y- U- ^; j
. b5 K! `; |5 X& q% Q# {
#==============================================================================3 R1 ^0 f2 ~) ^3 Z
# ■ Spriteset_Map# D* P3 N$ f" @* L' d1 e: G, i
#------------------------------------------------------------------------------1 z# s p* H, z* D+ H" F B
# 　处理地图画面精灵和图块的类。本类在 Scene_Map 类的内部使用。% r+ u3 z) q% a( n8 h
#==============================================================================
9 K1 b- {4 O. _0 Z
class Spriteset_Map* H0 G; G' h3 W) d0 f& D4 I
#--------------------------------------------------------------------------4 f8 q" N$ X5 @' ~% ?
# ● 生成路径点精灵
{& S- e- m, X4 x" L. b
#--------------------------------------------------------------------------
: v4 P' S! T- B+ i7 z8 u6 n
alias sion_mouse_create_characters create_characters0 {2 |/ }' X; o
def create_characters2 d; O- J% d* v4 p- }8 i2 D/ J
sion_mouse_create_characters
& D0 `) ]0 e! S9 p
@character_sprites.push(Sprite_Character.new(@viewport1, $mouse_move_sign))
: \) z8 W2 A/ P& m; K
end3 l& r' b$ i9 O$ E. t) o
end4 T3 R' k- }) F' |; C
" z6 F" S7 ]$ c1 S0 w1 }* E
#==============================================================================7 p' z5 p$ |! ]/ s1 r
# ■ Scene_Map
7 u: A0 Q8 o; Q
#------------------------------------------------------------------------------
6 r9 I2 z, v; p0 U; h& B0 C
# 　地图画面: p1 X* L7 T+ b& b6 C2 h5 S
#==============================================================================
' t8 a' _$ K5 Q$ y+ O3 }
class Scene_Map Scene_Base
4 V& B P8 P" B. u2 X! Y
#--------------------------------------------------------------------------# w9 J' u' X+ ~/ A
# ● 画面更新
+ Y5 u/ o6 z: b+ |$ R0 p% r
#--------------------------------------------------------------------------) Z8 y* K( Q# z+ Q# Y
alias sion_mouse_update_scene update_scene
W$ y- d% w7 B. h2 \5 p
def update_scene
H. b8 }5 N( P0 E, S, C& m0 `
sion_mouse_update_scene% A7 `9 K& m _2 C
update_mouse_action unless scene_changing& |' h' W q8 S% R9 S
end
( _( q: J) i) N, j' ~% r
#--------------------------------------------------------------------------
1 |) Z% ~, `2 A* e+ L
# ● 场所移动前的处理6 I/ N" z* I5 ~4 O' c' |0 D
#--------------------------------------------------------------------------6 _1 j4 ^. y9 ^ J# Q* \
alias sion_mouse_pre_transfer pre_transfer3 U0 s% L7 K; j# U
def pre_transfer
7 Q! x, ?/ k) q6 V# n+ A
$game_player.reset_move_path o0 Z6 m4 l8 _) `9 C
sion_mouse_pre_transfer
, U/ P4 g3 g- Y* D& ^1 }
end# o; ?6 N7 p- ~+ ^ P5 Q
#--------------------------------------------------------------------------
6 n* N# h) `( |5 ~: e
# ● 监听鼠标左键的按下
9 y- r. m3 ~) N% |7 Y. Q' }# Y
#--------------------------------------------------------------------------7 @ ?; l$ i1 }
def update_mouse_action
7 i& h0 j E0 S! Q, Y
$game_player.left_button_action if Mouse.press(0x01)5 Z D# _: v [ B$ H- N# u
end. @ ~$ |4 ]' ^. n
end. t7 i& l9 P! D& W9 [
( `* ~9 A- A& ~: ?/ ?; n" L
#==============================================================================/ ?# s' E1 M. D1 Y
# ■ Scene_File4 V7 f& [2 B6 @
#------------------------------------------------------------------------------# X) C% h F* d* l$ B# \: n6 W8 V
# 　存档画面和读档画面共同的父类
( Q& m" L; V: W3 O3 x
#==============================================================================7 u- V6 E- }" v3 X6 P: e( ~' ]
class Scene_File Scene_MenuBase8 ~$ h1 @' C1 N* d2 n2 ]2 g3 u- |
#--------------------------------------------------------------------------
) d8 G8 j& Y/ x( k7 \2 `9 \3 T) b
# ● 开始处理+ N. e+ d9 c2 P, b( N# ~
#--------------------------------------------------------------------------7 l' j1 B9 n0 M( N# \ U. y* |2 N0 z
alias sion_mouse_start start
, S/ _/ N/ m! r8 S% `& W
def start8 l/ p% k( J& S/ u i0 v" }) ^
sion_mouse_start9 S! H) ^* h! L. z8 O3 F1 }4 I9 S3 E
@move_state = 0
7 c" Q! A5 m6 {4 }3 w
set_mouse_pos
) c% L4 m0 n8 s* B @+ R
end& f% l# f* }. L$ ^4 a) _- Q K
#--------------------------------------------------------------------------
% K* p0 T" H4 X( h1 c/ ?$ M
# ● 更新画面0 h) l! |8 T6 A
#--------------------------------------------------------------------------
. F$ \! G ^; r' S6 \
alias sion_mouse_update update
! b8 \+ }1 T. S# c
def update; w' J# N( N( ?6 @0 i9 ^7 S, D
sion_mouse_update0 p% x, Q+ }; D3 S
Input.dir4.zero set_cursor set_mouse_pos# [( s U. y) K: E
end
6 f" k# E d- Q
#--------------------------------------------------------------------------& O& ?% {0 B( d& Z& u( M
# ● 更新光标
4 U# N5 t; p/ e7 p3 \/ H
#--------------------------------------------------------------------------
_, H3 `2 _. k! c9 F
def set_cursor
7 K7 G# ~/ ^' Z, _
@move_state += 1+ o# Z6 ~1 u2 S* M# H, Z
last_index = @index
1 {% i4 @# @5 f# m
if mouse_which_window == -2
1 O h% y* L0 p' f
if (@move_state - 1) % 6 == 0/ f/ L- S+ N/ O9 O: ?
@index = (@index + 1) % item_max if @index item_max - 11 k' O5 x) g2 ?0 A# P8 C
end
! S7 T: [( L0 P1 J6 L/ G
elsif mouse_which_window == -1
: q+ M/ z4 X! N$ P8 }# i
if (@move_state - 1) % 6 == 0
1 P6 h0 v9 t0 r4 ?2 S
@index = (@index - 1 + item_max) % item_max if @index 0
1 l! w/ f. ~; [1 O& Y1 o) @
end" w7 ^. g- S5 E
else& B) @( _# y5 W: [; Z% t- G! n* N
@move_state = 0' \6 u7 a7 O& c" u- v3 U. y7 D
@index = top_index + mouse_which_window# e- I. b1 z+ c! S2 W, l
end7 R- w9 \3 z# }) j+ X' v( p
ensure_cursor_visible
6 c+ z4 J1 p. ]# u- ~( i( A
if @index != last_index
5 h' A+ S- [ B+ D5 U; [1 ]
@savefile_windows[last_index].selected = false
+ i4 `7 r/ ?( ?) z& [
@savefile_windows[@index].selected = true
' G U8 x9 }6 M
end
9 c7 l7 u/ @2 \. R
end7 j8 L/ P; x- O$ O, c3 v
#--------------------------------------------------------------------------
5 o3 {0 g" m8 \ K' k8 K
# ● 判断鼠标位于哪个窗口9 P! K- J! I' k; p2 v$ y
#--------------------------------------------------------------------------
9 ]7 y. P! B$ e' ?
def mouse_which_window5 ^' h, ~$ b. p+ t' q
mouse_x, mouse_y = Mouse.mouse_x, Mouse.mouse_y
: v% x5 f+ V/ E: q1 h. C$ k0 R
if mouse_y @help_window.height + 14
* v: ~1 X- \; ~6 A+ U+ s% g4 A$ h
mouse_row = -1
- k+ w$ ~4 [; A
elsif mouse_y Graphics.height - 14
5 }+ o+ C; T6 k
mouse_row = -20 b3 Z5 M& i4 g- e6 ]
else& q+ j$ y' t7 C, _4 p
mouse_row = 4 (mouse_y - @help_window.height)
$ Y5 A3 ?( A( E C' n* H0 v1 D
(Graphics.height - @help_window.height)
% s1 y+ D/ }* |! s% J
end
& S- _9 q1 a2 V! j+ h- i& l
return mouse_row
# z& } Z1 h; y" n* C C+ G3 |
end
$ P* P+ D- t: y3 H, @% U
#--------------------------------------------------------------------------8 c# t0 g) q' `. w* w" X$ g/ D
# ● 方向键移动光标时将鼠标移动到对应的光标位置
9 H$ D7 o, G% K. I. `1 t
#--------------------------------------------------------------------------
G$ Z6 v( B1 Q! d6 k9 C
def set_mouse_pos
) c, q1 Z7 ~% Z+ S
new_x = 40: J: f/ e1 O2 N1 U+ O8 w! R: X
new_y = @help_window.height + savefile_height (@index - top_index) + 24
0 S! O. y5 {/ d( ?1 d# _
Mouse.set_mouse_pos(new_x, new_y)
5 g9 s/ Y$ t) N9 q" ^
end
j9 |" y6 [# h% T x7 b
end
- b8 q7 r& o+ b/ i
7 i+ |+ E) F, G8 Q0 K' }
#==============================================================================) D$ i* O9 X |4 D0 r
# ■ Game_Event+ E D/ T& h; l' U* S
#------------------------------------------------------------------------------
' u: U. _4 `1 S" e# |% j
# 　处理事件的类。拥有条件判断、事件页的切换、并行处理、执行事件等功能。
# ?0 s/ C5 S ~2 |! t" n7 t% h. \" s
# 在 Game_Map 类的内部使用。
3 W! s/ H. R9 q' b+ w- A2 i
#==============================================================================7 h8 L8 ]+ E: K/ ^
class Game_Event Game_Character
) t8 r5 _0 ?1 m S! C
#--------------------------------------------------------------------------3 ^! Z( N* J0 s
# ● 事件启动: y6 ]+ C5 k' P! [
#--------------------------------------------------------------------------6 r1 W6 {) N) f6 W* }1 Y4 F0 z% z
alias sion_mouse_start start1 ^5 W r% I; R$ a0 F$ G5 y
def start
3 ^! [! @! \4 p8 q& T
return if mouse_start && !Mouse.press(0x01)
4 [( u5 S; j( a) C/ I; w
sion_mouse_start
( y* V9 `) s1 n% Z5 W: `9 E% n3 d$ \
end
# t+ B; c& c+ ]; D
#--------------------------------------------------------------------------
: U$ D# L' N" C+ u F+ t
# ● 判断事件是否由鼠标启动
( R+ G* R' D$ `9 U) S: n
#--------------------------------------------------------------------------
9 a6 d! ~8 t5 P* ?; o" Z: G
def mouse_start
4 d# @8 s: c$ _% M( F
return false if empty
8 d7 W3 |! O- v5 O
@list.each do index
( G! i" W) J8 d* f5 k2 O B- p1 @
return true if (index.code == 108 index.code == 408) &&2 a: f' Y% J9 }/ C
index.parameters[0].include('鼠标启动')
9 k/ l6 ]' f5 I
end& q# N: R3 [* y, F5 n6 V
return false
. ^( L! [' S) D2 N" N8 M
end
# G! c9 q. w& Q1 o% \4 x
end
- ~5 {5 s" ~0 q+ `# w; i3 r/ c6 m
' ^& X" n9 {/ \4 { c
####泥煤的height. R7 C7 r/ X2 R5 I8 O, d; k
# @height = height6 J8 W l) Y A8 Z
9 x f2 Q9 n; n% t8 j" M! S1 K# a
class Area_Response
/ h. Y5 f7 b& q; x5 ~4 e
attr_accessor type
+ n- ~4 e% [/ ~$ E0 Y
attr_reader ox
' `7 d9 H& R/ i- \ o
attr_reader oy q' w8 J6 B/ k" t: s! g. g
attr_reader width, e% {. p$ C7 @
attr_reader height
8 [: J/ r/ b, C- V
attr_reader switch_id$ w/ O- M3 H% V+ y4 o3 d
def initialize(type, ox, oy, width = 32, height = 32, switch_id = nil)# W7 R8 b* y! s4 B) {9 M
@type = type( R% a* y$ i2 r# G3 @3 M
@ox = ox
4 c, \0 }& r. q$ n6 t
@oy = oy7 Z8 v f) Y; j7 k
@width = width
- }3 |1 J2 @/ l" o3 q/ ]8 ?- B5 r
@height = height$ g4 q) O* u5 `$ b! Z" g
@switch_id = switch_id- Z8 J3 j! d) f" D" e& [) G+ h" \
end2 ^1 I, s- E0 y- v
end
$ N, O, ?8 ^' ?% T7 n7 M
) ^; t2 s/ @. Z1 Y% `
$area_responses = []2 B( M, ~! h) q' q/ p
0 H+ x3 I$ O; B+ P" X4 M
class Scene_Map
( l0 i1 Z& {* g' g3 F/ {# W
alias update_mouse_2013421 update_mouse_action
7 l. b7 J" }. ~2 L6 e
def update_mouse_action
6 ]. P2 z* G; m' L9 Q4 o% A$ V) B
update_area_response
5 W5 e5 m1 ]- [" q0 n
update_mouse_20134212 k% y% n3 O Y& U P: F
end$ s7 ?8 E% Q7 \8 c2 i$ N5 V
def update_area_response8 M) e& d3 h! V. p( \- K
responses = $area_responses
7 y- n* E& A! G2 I1 r" U4 X# s
responses.each {response) T' J$ B& |% l: T0 |" ]
ox = response.ox
& d0 c/ @4 _' E; g; F0 Y: b# }/ o
oy = response.oy
& @' ~9 h, d( p/ @- O2 n+ ]5 {
width = response.width
0 {; u7 f% I& \1 x. R6 a9 V* i
height = response.height5 {0 ?) F) Q7 ^4 l5 t$ i
switch_id = response.switch_id% {: S' P; H" z T0 ~# s9 z9 T$ t
case response.type
" ~1 w& a( ], ^1 L- }' j
when 0
; b- @. e9 f6 Q3 h
if mouse_in_area(ox, oy, width, height)
$ W1 C4 O+ R# P+ W- x9 r
$game_switches[switch_id] = true# L- C: |6 k8 y
$area_responses.delete(response)( t- T T$ Q: G. g7 o
end
, U/ s0 z4 C! D1 [. s9 ^
when 1
# C# y3 ~9 y) `& w" z5 Z+ @
if mouse_in_area(ox, oy, width, height) && Mouse.trigger(0x01)
8 x t* U4 M; ]" o# m6 }/ R
$game_switches[switch_id] = true
" b4 {, J4 j7 c b
$area_responses.delete(response)' I" c% M& [) o; g# K9 z! }
end; S( B6 T3 p( x$ ?2 G
when 2
. U4 U2 ]1 l/ ~: g# L" y
if mouse_in_area(ox, oy, width, height)
) ~1 S4 b. s7 G" f
$game_switches[switch_id] = true0 J' B( s& Q# l* ~2 y
else
* z; x8 U! ?* @$ \6 K) z
$game_switches[switch_id] = false5 D, d( X, U1 ^( @ F
end
4 U3 |# H- k$ p/ n5 C( l( }; h
when 3
% n6 A/ M8 j4 e/ u, t# R. p
if mouse_in_area((ox - $game_map.display_x) 32 ,/ r0 Q- b2 }0 C$ G" l
(oy - $game_map.display_y) 32, width, height)
7 V2 [. { V. m5 f3 V; e6 y4 y( p
$game_map.events_xy(ox, oy).each {event( ]# J0 w: U5 O/ T0 C" f" c
event.start
0 N' T/ m: l& h
$area_responses.delete(response)) O3 p9 w5 b. Z9 j% t
return
. G9 v! }, k0 P7 ~
} . E8 u( \* [% P% x
end
6 q. ^5 I: {& k1 t
when 43 D H6 L9 A, m5 m C i e
if mouse_in_area((ox - $game_map.display_x) 32,( G5 [ z/ Y6 S$ }
(oy - $game_map.display_y) 32, width, height)9 `+ m# t `0 x ]. Q, r& A
$game_map.events_xy(ox, oy).each {event
5 r2 R5 o, e9 j! t! w
event.start1 w: @2 t0 u0 {( ?8 L$ v: z
return
+ E! c7 B- U7 T4 `. Q
}
7 R3 N t4 l- ~1 O/ Y0 s% B
end* T( ]& I0 `8 H- h
end
: _ Y7 {) S7 f* p% w, q
}
/ `- m) e! p6 b0 A/ o q
end( k6 v2 ?' b7 ^% E8 f- X
def mouse_in_area(ox, oy, width, height)
/ Y6 g Z4 f/ m* v3 {) V
Mouse.mouse_x = ox && Mouse.mouse_x = ox + width &&, j- g7 \9 d! D+ _. {. B
Mouse.mouse_y = oy && Mouse.mouse_y = oy + height9 c% P/ W% L7 f' n% b+ L+ o v
end
0 C& A- Z; q; q' o1 o- j( X- P8 T
end
% {) h& `: f& q; Q/ v
class Game_Interpreter
2 J; b: z3 T, T8 Y) ]# ?
def area_response(arg)- C$ ]( ? x, a
$area_responses.push(Area_Response.new(arg))1 T5 r. j3 A4 l! F( s4 Q) W+ H
end5 Y4 e" ?2 h8 w0 J
end- k9 X; u& D! T* g2 y4 a5 D$ ]. x

复制代码

帐号		自动登录	找回密码
密码			注册会员