存放腳本

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

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

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

x

純屬給LBQ腳本:

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

复制代码

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