存放腳本

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

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

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

x

純屬給LBQ腳本:

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

复制代码

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