存放腳本

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

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

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

x

純屬給LBQ腳本:

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

复制代码

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