存放腳本

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

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

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

x

純屬給LBQ腳本:

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

复制代码

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