存放腳本

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

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

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

x

純屬給LBQ腳本:

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

复制代码

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