PHP код:
#==============================================================================
# ** Quasi Movement v0.85
# Require Module Quasi
# [url]http://quasixi.wordpress.com/2014/09/23/quasi/[/url]
#==============================================================================
# Changed how movement works. Allows players to choose how many pixels to move
# per movement. In better terms, allows players to make characters have a pixel
# movement or still by by a grid like 32x32 or even 16x16.
# Changed how collisions work. Events now have bounding boxes surrounding them.
# If two boxes touch there will be a collision. Boxes can be set in each event,
# further detail in the instructions.
#==============================================================================
# Change Log
#------------------------------------------------------------------------------
# v0.8 - Changed movement speed back to vxa default
# - Changed bbox comment box it is now:
# <bbox:width,height,ox,oy> (just added the < >)
# - Adjusted map passibility, still needs work
# Region boxes work much better then tile passibilty.
# - Added a mid move passibilty check for more accurate passibilty
# - Added Region boxes (more on step 6)
# - Added Region Friction (more on step 7)
# --
# v0.7 - Pre-Released for feedback
#------------------------------------------------------------------------------
# To do / Upcoming
#------------------------------------------------------------------------------
# - Fix follower distance
# - Add a push out of box, if you somehow got inside a box with through off.
# - Fix tile passablity so you don't need use regions.
# - Find more bugs~
#==============================================================================
module Quasi
module Movement
#------------------------------------------------------------------------------
# Instructions:
# Step 1. Set GRID to the amount of pixels you want to move per movement.
# Default is 1, meaning pixel movement. This can be changed back
# to 32 which is vxa default tile movement.
#------------------------------------------------------------------------------
GRID = 1
#------------------------------------------------------------------------------
# Step 2. Set DIR8 to true or false. When true it will allow for 8 direction
# movement, when false it will not. Diagonal movement was modified
# if the diagonal movement isn't possible it will attempt the two
# directions seperatly to see if they work.
# Example: Player tries to move UP/RIGHT (Diag 9) but it's not passible
# Player will see if UP is passible, if it's not it will try
# RIGHT. If neither work, player won't move
#------------------------------------------------------------------------------
DIR8 = true
#------------------------------------------------------------------------------
# Step 3. Set DIAGSPEED. This adjusts the speed when moving diagonal. Set to
# 0 if you want to stay at same speed, default at -0.5
#------------------------------------------------------------------------------
DIAGSPEED = -0.5
#------------------------------------------------------------------------------
# Step 4. Set PLAYERBOX. This sets the bounding box for the player character.
# by default it is [24,16,4,8] More details on setting bounding boxes
# a few lines below.
# - Events will also default to these values.
#------------------------------------------------------------------------------
PLAYERBOX = [24,16,4,16]
#------------------------------------------------------------------------------
# Step 5. -Bounding boxes-
# How to set up on event:
# Make a comment anywhere in the event with the following setup:
# <bbox=width,height,ox,oy>
# bbox= :Starts the set up for the bounding box
# width :The width of the box, default 32
# height :The height of the box, default 32
# ox :The x orgin of the box, default is 0
# oy :The y orgin of the box, default is 0
#
# ox and oy can be left out, they will default to 0 if blank.
# 0 ox and oy means box starts from top left cornor of the event.
# Example Boxes:
# <bbox=32,32>
# Creates the default box which is 32x32 starting at the top left, good
# for block tiles. Notice how ox and oy are left out.
# <bbox=24,16,4,16>
# Creates a box that is 24x16. The box is pushed to the left 4 pixels
# and down 16. This is a good box for vxa characters that are 32x32.
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
# Step 6. REGION BOXES. Theses give region bounding boxes.
# Regions, unlike character boxes, can have multiple boxes.
# They are set up like:
# REGIONBOXES{
# REGION NUMBER => [box parameters], # Single box
# REGION NUMBER => [[box 1 parameters],[box 2 parameters]], # Multiple boxes
# } # < ends the hash *Important!*
#
# *NOTE* Region boxes only work if you're inside the box, unlike event boxes
# what this means is, you should not make the box go outside of the
# region tile, can keep it within a 32x32 box.
# *NOTE 2* Region boxes are used to replace tile passibility for now
# tile passibility doesn't work as well as region boxes do!
# I created most of the passages with region boxes below.
# *FINAL NOTE* Region boxes prioritize over tile passibilty,
# so even if the tile is set to no direction, it will use
# the region passibilty instead, if there's a region on that tile.
# **Check Map1 in the demo for example on how they are used**
#------------------------------------------------------------------------------
REGIONBOXES = {
# Passage(4 DIR), UP not allowed
46 => [32,4],
# Passage(4 DIR), UP/RIGHT not allowed
47 => [[32,4],[4,32,28]],
# Passage(4 DIR), RIGHT not allowed
55 => [4,32,28],
# Passage(4 DIR), DOWN/RIGHT not allowed
63 => [[32,4,0,28],[4,32,28]],
# Passage(4 DIR), UP/LEFT not allowed
45 => [[32,4],[4,32]],
# Passage(4 DIR), LEFT not allowed
53 => [4,32],
# Passage(4 DIR), DOWN/LEFT not allowed
61 => [[32,4,0,28],[4,32]],
# Passage(4 DIR), DOWN not allowed
62 => [32,4,0,28],
# Passage, NO DIR allowed
54 => [32,32],
44 => [32,32],
# Passage, ANY DIR allowed (not needed was used for testing.)
52 => [0,0],
}
#------------------------------------------------------------------------------
# Step 7. REGION FRICTION. Just a little extra.(Incomplete)
# Allows regions to adjust friction, ex: sliding tiles (sliding on ice)
# Setup:
# REGIONFRICTION = {
# REGION ID => NUMBER OF TILES TO SLIDE,
# } # < ends the hash *Important!*
# Tiles it slides go by 32x32 tiles and ignores the GRID variable from
# Step 1. Friction speeds need to get added, as well as negative friction
# which slow you down.
#------------------------------------------------------------------------------
REGIONFRICTION = {
60 => 99,
}
#------------------------------------------------------------------------------
# For testing purposes, set the bottom value to true to see the boxes.
# Only shows during play testing.
# *Does not show region boxes!*
#------------------------------------------------------------------------------
SHOWBOXES = true
end
end
#==============================================================================#
# By Quasi ([url]http://quasixi.wordpress.com/[/url])
# - 9/22/14
#==============================================================================#
# ** Stop! Do not edit anything below, unless you know what you **
# ** are doing! **
#==============================================================================#
$imported = {} if $imported.nil?
$imported["Quasi_Movement"] = 0.85
if $imported["Quasi"]
#==============================================================================
# ** Game_CharacterBase
#------------------------------------------------------------------------------
# This base class handles characters. It retains basic information, such as
# coordinates and graphics, shared by all characters.
#==============================================================================
class Game_CharacterBase
alias qm_init init_public_members
alias qm_moveto moveto
alias qm_update update
alias qm_straighten straighten
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :px
attr_reader :py
attr_reader :velocity
attr_accessor :friction
#--------------------------------------------------------------------------
# * Initialize Public Member Variables
#--------------------------------------------------------------------------
def init_public_members
qm_init
@px = 0
@py = 0
@npx = 0
@npy = 0
@velocity = 0
@friction = 0
@diag = false
@grid = Quasi::Movement::GRID
end
#--------------------------------------------------------------------------
# * Determine if Passable
# d : Direction (2,4,6,8)
#--------------------------------------------------------------------------
def passable?(x, y, d)
x1 = d == 4 ? x-move_tiles : d == 6 ? x+move_tiles : x
y1 = d == 8 ? y-move_tiles : d == 2 ? y+move_tiles : y
x2 = $game_map.round_px(x1)
y2 = $game_map.round_py(y1)
x3 = $game_map.round_x((x1/32.0).round)
y3 = $game_map.round_y((y1/32.0).round)
return false unless $game_map.valid?(x3, y3)
return true if @through || debug_through?
return false unless midpassable?(x,y,d)
return false unless map_passable?(x2, y2, d)
#return false unless map_passable?(x2, y2, reverse_dir(d))
return false if collide_with_box?(x2, y2)
return true
end
#--------------------------------------------------------------------------
# * Determine if Midpoint is Passable
# d : Direction (2,4,6,8)
#--------------------------------------------------------------------------
def midpassable?(x, y, d)
half_tiles = move_tiles/2.0
x2 = $game_map.round_px_with_direction(x, d, half_tiles)
y2 = $game_map.round_py_with_direction(y, d, half_tiles)
return false unless map_passable?(x2, y2, d)
return false unless map_passable?(x2, y2, reverse_dir(d))
return false if collide_with_box?(x2, y2)
return true
end
#--------------------------------------------------------------------------
# * Determine if Map is Passable
# d : Direction (2,4,6,8)
#--------------------------------------------------------------------------
def map_passable?(x, y, d)
rbox = Quasi::Movement::REGIONBOXES.keys
e = edge(x,y)[d]
if rbox.include?($game_map.region_id(e[0][0],e[0][1])) ||
rbox.include?($game_map.region_id(e[1][0],e[1][1]))
(regionpass?(e[0][0],e[0][1],x,y) && regionpass?(e[1][0],e[1][1],x,y))
else
($game_map.passable?(e[0][0], e[0][1], d) && $game_map.passable?(e[1][0], e[1][1], d))
end
end
#--------------------------------------------------------------------------
# * Determine Diagonal Passability
# horz : Horizontal (4 or 6)
# vert : Vertical (2 or 8)
#--------------------------------------------------------------------------
def diagonal_passable?(x, y, horz, vert)
x2 = $game_map.round_px_with_direction(x, horz, move_tiles)
y2 = $game_map.round_py_with_direction(y, vert, move_tiles)
(passable?(x, y, vert) && passable?(x, y2, horz)) ||
(passable?(x, y, horz) && passable?(x2, y, vert))
end
#--------------------------------------------------------------------------
# * Detect Collision with Character
#--------------------------------------------------------------------------
def collide_with_box?(x, y)
boxes = $game_map.bounding_xy(box_xy(x,y))
if !boxes.empty?
boxes.keep_if {|e| e != self}
end
!boxes.empty? || collide_with_vehicles?(x,y)
end
#--------------------------------------------------------------------------
# * Detect Collision with Vehicle
#--------------------------------------------------------------------------
def collide_with_vehicles?(x, y)
$game_map.boat.pos_nt?((x/32).round, (y/32).round) ||
$game_map.ship.pos_nt?((x/32).round, (y/32).round)
end
#--------------------------------------------------------------------------
# * Determine Triggering of Frontal Touch Event
#--------------------------------------------------------------------------
def check_event_trigger_touch_front
x1 = $game_map.round_px_with_direction(@px, @direction, move_tiles)
y1 = $game_map.round_py_with_direction(@py, @direction, move_tiles)
check_event_trigger_touch(x1, y1)
end
#--------------------------------------------------------------------------
# * Determine if Moving
#--------------------------------------------------------------------------
def moving?
@velocity > 0
end
#--------------------------------------------------------------------------
# * Determine if Sliding
#--------------------------------------------------------------------------
def sliding?
@friction > 0
end
#--------------------------------------------------------------------------
# * Get Move Speed (Account for Dash)
#--------------------------------------------------------------------------
def real_move_speed
@move_speed + (dash? ? 1 : 0) + (@diag ? Quasi::Movement::DIAGSPEED : 0)
end
#--------------------------------------------------------------------------
# * Move to Designated Position
#--------------------------------------------------------------------------
def moveto(x, y)
@px = x * 32.0
@py = y * 32.0
@npx = @px
@npy = @py
qm_moveto(x,y)
end
#--------------------------------------------------------------------------
# * Straighten Position
#--------------------------------------------------------------------------
def straighten
qm_straighten
@friction = 0
end
#--------------------------------------------------------------------------
# * How many tiles are you moving
#--------------------------------------------------------------------------
def move_tiles
@grid < real_move_speed ? real_move_speed : @grid
end
def speed
2**real_move_speed / 8.0
end
#--------------------------------------------------------------------------
# * Frame Update
# Aliased, added an update friction
#--------------------------------------------------------------------------
def update
check_friction if moving?
return update_friction if sliding?
qm_update
end
#--------------------------------------------------------------------------
# * Update While Moving
#--------------------------------------------------------------------------
def update_move
@px = [@px - speed, @npx].max if @npx < @px
@px = [@px + speed, @npx].min if @npx > @px
@py = [@py - speed, @npy].max if @npy < @py
@py = [@py + speed, @npy].min if @npy > @py
@real_x = @px/32.0 if @real_x != @px/32.0
@real_y = @py/32.0 if @real_y != @py/32.0
@x = @px/32.0 if @x != @px/32.0
@y = @py/32.0 if @y != @py/32.0
@velocity -= speed
update_bush_depth unless moving?
end
#--------------------------------------------------------------------------
# * Update Friction
#--------------------------------------------------------------------------
def update_friction
if passable?(@px, @py, @direction)
@friction = [@friction-1,0].max if !moving?
return if @friction == 0
move_straight(@direction) if !moving?
else
@friction = 0
end
update_move if moving?
end
#--------------------------------------------------------------------------
# * Check for Friction
#--------------------------------------------------------------------------
def check_friction
regfric = Quasi::Movement::REGIONFRICTION.keys
mid = v_center(@npx,@npy)
mx = (mid[0]/32).truncate
my = (mid[1]/32).truncate
if regfric.include?($game_map.region_id(mx,my))
if @friction == 0
@friction = (32.0/move_tiles)*Quasi::Movement::REGIONFRICTION[$game_map.region_id(mx,my)]
end
else
@friction = 0
end
end
#--------------------------------------------------------------------------
# * Move Straight
# d: Direction (2,4,6,8)
# turn_ok : Allows change of direction on the spot
#--------------------------------------------------------------------------
def move_straight(d, turn_ok = true)
@move_succeed = passable?(@px, @py, d)
orginal_speed = @move_speed
if !@move_succeed && self.is_a?(Game_Player)
while !@move_succeed
break if @move_speed < 1
@move_speed -= 0.5
@move_succeed = passable?(@px, @py, d)
end
end
if @move_succeed
set_direction(d)
@diag = false
@velocity = move_tiles
@npx = $game_map.round_px_with_direction(@px, d, move_tiles)
@npy = $game_map.round_py_with_direction(@py, d, move_tiles)
@px = $game_map.px_with_direction(@npx, reverse_dir(d), move_tiles)
@py = $game_map.py_with_direction(@npy, reverse_dir(d), move_tiles)
increase_steps
elsif turn_ok
set_direction(d)
check_event_trigger_touch_front
end
@move_speed = orginal_speed
@velocity = 0 if !@move_succeed
end
#--------------------------------------------------------------------------
# * Move Diagonally
# horz: Horizontal (4 or 6)
# vert: Vertical (2 or 8)
#--------------------------------------------------------------------------
def move_diagonal(horz, vert)
@move_succeed = diagonal_passable?(@px, @py, horz, vert)
orginal_speed = @move_speed
if !@move_succeed && self.is_a?(Game_Player)
while !@move_succeed
break if @move_speed < 1
@move_speed -= 0.5
@move_succeed = diagonal_passable?(@px, @py, horz, vert)
end
end
if @move_succeed
@diag = true
@velocity = move_tiles
@npx = $game_map.round_px_with_direction(@px, horz, move_tiles)
@npy = $game_map.round_py_with_direction(@py, vert, move_tiles)
@px = $game_map.px_with_direction(@npx, reverse_dir(horz), move_tiles)
@py = $game_map.py_with_direction(@npy, reverse_dir(vert), move_tiles)
increase_steps
end
@move_speed = orginal_speed
set_direction(horz) if @direction == reverse_dir(horz)
set_direction(vert) if @direction == reverse_dir(vert)
if !@move_succeed
if passable?(@px, @py, horz)
move_straight(horz)
elsif passable?(@px, @py, vert)
move_straight(vert)
end
end
end
#--------------------------------------------------------------------------
# * Bounding box array
#--------------------------------------------------------------------------
def bounding_box
return @boundingbox if @boundingbox
@boundingbox = [32,32,0,0]
end
#--------------------------------------------------------------------------
# * Make Bounding box
#--------------------------------------------------------------------------
def box_xy(x=@px,y=@py)
bb = bounding_box
ox = bb[2].nil? ? 0 : bb[2]
oy = bb[3].nil? ? 0 : bb[3]
oy -= shift_y
bx = x+ox..x+bb[0]+ox
by = y+oy..y+bb[1]+oy
return [bx, by]
end
#--------------------------------------------------------------------------
# * Check for Bounding box Collision
# Returns true if boxes are inside each other.
#--------------------------------------------------------------------------
def box?(objbox,through=nil)
through = through.nil? ? @through : through
return if !bounding_box || through
pass1 = (objbox[0].first <= box_xy[0].last) && (objbox[0].last >= box_xy[0].first)
pass2 = (objbox[1].first <= box_xy[1].last) && (objbox[1].last >= box_xy[1].first)
return pass1 && pass2
end
#--------------------------------------------------------------------------
# * Find the boxes vertices
# returns array [top left, top right, bottom left, bottom right]
#--------------------------------------------------------------------------
def vertices(x=@px,y=@py)
x1 = box_xy(x,y)[0]
y1 = box_xy(x,y)[1]
tl = [x1.first,y1.first]
tr = [x1.last,y1.first]
bl = [x1.first,y1.last]
br = [x1.last,y1.last]
return [tl, tr, bl, br]
end
#--------------------------------------------------------------------------
# * Find facing edge in 32 grid terms
#--------------------------------------------------------------------------
def edge(x=@px,y=@py)
x1 = box_xy(x,y)[0]
y1 = box_xy(x,y)[1]
tl = [(x1.first/32.0).truncate,(y1.first/32.0).truncate]
tr = [(x1.last/32.0).truncate,(y1.first/32.0).truncate]
bl = [(x1.first/32.0).truncate,(y1.last/32.0).truncate]
br = [(x1.last/32.0).truncate,(y1.last/32.0).truncate]
return {2 => [bl,br], 4 => [tl,bl], 6 => [tr, br], 8 => [tl, tr]}
end
#--------------------------------------------------------------------------
# * Find center of box
#--------------------------------------------------------------------------
def v_center(x=@px,y=@py)
x1 = box_xy(x,y)[0]
y1 = box_xy(x,y)[1]
mx = x1.first + ((x1.last - x1.first) / 2.0)
my = y1.first + ((y1.last - y1.first) / 2.0)
return [mx,my]
end
#--------------------------------------------------------------------------
# * Makes region box (Should probably be in game_map)
#--------------------------------------------------------------------------
def regbox(x,y)
bb = Quasi::Movement::REGIONBOXES[$game_map.region_id(x,y)]
return if !bb
regbox = []
if bb[0].is_a?(Array)
bb.each do |box|
x1 = x * 32; y1 = y * 32
ox = box[2].nil? ? 0 : box[2]
oy = box[3].nil? ? 0 : box[3]
bx = x1+ox..x1+box[0]+ox
by = y1+oy..y1+box[1]+oy
regbox << [bx,by]
end
else
x1 = x * 32; y1 = y * 32
ox = bb[2].nil? ? 0 : bb[2]
oy = bb[3].nil? ? 0 : bb[3]
bx = x1+ox..x1+bb[0]+ox
by = y1+oy..y1+bb[1]+oy
regbox = [bx, by]
end
return regbox
end
#--------------------------------------------------------------------------
# * Region box Collision
# Makes region box then passes it through a check.
# Returns true if region is passable ( No box collision. )
#--------------------------------------------------------------------------
def regionpass?(x,y,nx,ny)
bb = regbox(x,y)
return true if !bb || @through
if bb[0].is_a?(Array)
pass = []
bb.each do |box|
pass << regbox?(box,nx,ny)
end
return pass.count(false) == pass.size
else
return regbox?(bb,nx,ny) == false
end
end
#--------------------------------------------------------------------------
# * Returns true if boxes are inside each other.
#--------------------------------------------------------------------------
def regbox?(regbox,nx,ny)
insidex = (box_xy(nx,ny)[0].last >= regbox[0].first) && (box_xy(nx,ny)[0].first <= regbox[0].last)
insidey = (box_xy(nx,ny)[1].last >= regbox[1].first) && (box_xy(nx,ny)[1].first <= regbox[1].last)
return insidex && insidey
end
end
#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
# This class handles maps. It includes scrolling and passage determination
# functions. The instance of this class is referenced by $game_map.
#==============================================================================
class Game_Map
#--------------------------------------------------------------------------
# * Calculate PX Coordinate After Loop Adjustment
#--------------------------------------------------------------------------
def round_px(x)
loop_horizontal? ? (x + (width*32)) % (width*32) : x
end
#--------------------------------------------------------------------------
# * Calculate PY Coordinate After Loop Adjustment
#--------------------------------------------------------------------------
def round_py(y)
loop_vertical? ? (y + (height*32)) % (height*32) : y
end
#--------------------------------------------------------------------------
# * Calculate PX Coordinate Shifted One Tile in Specific Direction
# (No Loop Adjustment)
#--------------------------------------------------------------------------
def px_with_direction(x, d, v)
x + (d == 6 ? v : d == 4 ? -v : 0)
end
#--------------------------------------------------------------------------
# * Calculate PY Coordinate Shifted One Tile in Specific Direction
# (No Loop Adjustment)
#--------------------------------------------------------------------------
def py_with_direction(y, d, v)
y + (d == 2 ? v : d == 8 ? -v : 0)
end
#--------------------------------------------------------------------------
# * Calculate PX Coordinate Shifted One Pixel in Specific Direction
# (With Loop Adjustment)
#--------------------------------------------------------------------------
def round_px_with_direction(x, d, v)
round_px(x + (d == 6 ? v : d == 4 ? -v : 0))
end
#--------------------------------------------------------------------------
# * Calculate PY Coordinate Shifted One Pixel in Specific Direction
# (With Loop Adjustment)
#--------------------------------------------------------------------------
def round_py_with_direction(y, d, v)
round_py(y + (d == 2 ? v : d == 8 ? -v : 0))
end
#--------------------------------------------------------------------------
# * Get Array of Event Bounding Box at Designated Coordinates
#--------------------------------------------------------------------------
def bounding_xy(objbox,through=nil)
@events.values.select {|event| event.box?(objbox,through) }
end
end
#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
# This class handles events. Functions include event page switching via
# condition determinants and running parallel process events. Used within the
# Game_Map class.
#==============================================================================
class Game_Event < Game_Character
alias qme_setup setup_page_settings
#--------------------------------------------------------------------------
# * Detect Collision with Character
#--------------------------------------------------------------------------
def collide_with_box?(x, y)
super || collide_with_player_characters?(x, y)
end
#--------------------------------------------------------------------------
# * Detect Collision with Player (Including Followers)
#--------------------------------------------------------------------------
def collide_with_player_characters?(x, y)
normal_priority? && $game_player.box?(box_xy(x,y))
end
#--------------------------------------------------------------------------
# * Determine if Touch Event is Triggered
#--------------------------------------------------------------------------
def check_event_trigger_touch(x, y)
return if $game_map.interpreter.running?
if @trigger == 2 && $game_player.box?(box_xy(x,y), false)
start if !jumping? && normal_priority?
end
end
#--------------------------------------------------------------------------
# * Bounding box
#--------------------------------------------------------------------------
def bounding_box
return @boundingbox if @boundingbox
pb = Quasi::Movement::PLAYERBOX
dimension = grab_comment(/<bbox.*=(.*)>/i, "#{pb[0]},#{pb[1]},#{pb[2]},#{pb[3]}")
@boundingbox = dimension.split(",").map {|s| s.to_i}
end
#--------------------------------------------------------------------------
# * Set Up Event Page Settings
#--------------------------------------------------------------------------
def setup_page_settings
qme_setup
sub_qmove
end
#--------------------------------------------------------------------------
# * Replace q_move with real moves
#--------------------------------------------------------------------------
def sub_qmove
move = {
2 => ROUTE_MOVE_DOWN,
4 => ROUTE_MOVE_LEFT,
6 => ROUTE_MOVE_RIGHT,
8 => ROUTE_MOVE_UP,
1 => ROUTE_MOVE_LOWER_L,
3 => ROUTE_MOVE_LOWER_R,
7 => ROUTE_MOVE_UPPER_L,
9 => ROUTE_MOVE_UPPER_R
}
@move_route.list.each do |list|
next unless list.parameters[0] =~ /qmove/
qmove = list.parameters[0].delete "qmove()"
qmove = qmove.split(",").map {|s| s.to_i}
(qmove[1]/real_move_speed).times do
@move_route.list << RPG::MoveCommand.new(move[qmove[0]])
end
end
@move_route.list.each do |list|
next unless list.parameters[0] =~ /qmove/ || list.code == 0
@move_route.list.delete(list)
end
@move_route.list << RPG::MoveCommand.new(0)
@original_move_route = @move_route
end
#--------------------------------------------------------------------------
# * Filler method, gets replaced with an actual method in event setup.
#--------------------------------------------------------------------------
def qmove(filler,method)
end
end
#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
# This class handles the player. It includes event starting determinants and
# map scrolling functions. The instance of this class is referenced by
# $game_player.
#==============================================================================
class Game_Player < Game_Character
alias qm_movable? movable?
#--------------------------------------------------------------------------
# * Determine if Movement is Possible
#--------------------------------------------------------------------------
def movable?
return false if sliding?
qm_movable?
end
#--------------------------------------------------------------------------
# * Processing of Movement via Input from Directional Buttons
#--------------------------------------------------------------------------
def move_by_input
return if !movable? || $game_map.interpreter.running?
if Quasi::Movement::DIR8
if Input.dir8 > 0
dia = {7 => [4,8], 1 => [4,2], 9 => [6,8], 3 => [6,2]}
if [1,7,9,3].include?(Input.dir8)
move_diagonal(dia[Input.dir8][0], dia[Input.dir8][1])
else
move_straight(Input.dir8)
end
end
else
move_straight(Input.dir4) if Input.dir4 > 0
end
end
#--------------------------------------------------------------------------
# * Trigger Map Event
# triggers : Trigger array
# normal : Is priority set to [Same as Characters] ?
#--------------------------------------------------------------------------
def start_map_event(x, y, triggers, normal)
return if $game_map.interpreter.running?
$game_map.bounding_xy(box_xy(x,y),false).each do |event|
if event.trigger_in?(triggers) && event.normal_priority? == normal
event.start
end
end
end
#--------------------------------------------------------------------------
# * Determine if Same Position Event is Triggered
#--------------------------------------------------------------------------
def check_event_trigger_here(triggers)
start_map_event(@px, @py, triggers, false)
end
#--------------------------------------------------------------------------
# * Determine if Front Event is Triggered
#--------------------------------------------------------------------------
def check_event_trigger_there(triggers)
d = @direction
x1 = d == 4 ? @px-move_tiles : d == 6 ? @px+move_tiles : @px
y1 = d == 8 ? @py-move_tiles : d == 2 ? @py+move_tiles : @py
x2 = $game_map.round_x((x1 / 32.0).round)
y2 = $game_map.round_y((y1 / 32.0).round)
start_map_event(x1, y1, triggers, true)
return if $game_map.any_event_starting?
x3 = d == 4 ? x1-move_tiles : d == 6 ? x1+move_tiles : x1
y3 = d == 8 ? y1-move_tiles : d == 2 ? y1+move_tiles : y1
x4 = $game_map.round_x((x3 / 32.0).round)
y4 = $game_map.round_y((y3 / 32.0).round)
start_map_event(x3, y3, triggers, true)
end
#--------------------------------------------------------------------------
# * Move Straight
#--------------------------------------------------------------------------
def move_straight(d, turn_ok = true)
@followers.move if passable?(@px, @py, d)
super
end
#--------------------------------------------------------------------------
# * Move Diagonally
#--------------------------------------------------------------------------
def move_diagonal(horz, vert)
@followers.move if diagonal_passable?(@px, @py, horz, vert)
super
end
#--------------------------------------------------------------------------
# * Bounding box
#--------------------------------------------------------------------------
def bounding_box
return @boundingbox if @boundingbox
@boundingbox = Quasi::Movement::PLAYERBOX
end
end
#==============================================================================
# ** Sprite_Character
#------------------------------------------------------------------------------
# This sprite is used to display characters. It observes an instance of the
# Game_Character class and automatically changes sprite state.
#==============================================================================
class Sprite_Character < Sprite_Base
alias qbox_init initialize
alias qbox_update update
alias qbox_dispose dispose
#--------------------------------------------------------------------------
# * Object Initialization
# character : Game_Character
#--------------------------------------------------------------------------
def initialize(viewport, character = nil)
qbox_init(viewport, character)
start_box if Quasi::Movement::SHOWBOXES && $TEST
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
qbox_update
update_box if Quasi::Movement::SHOWBOXES
end
#--------------------------------------------------------------------------
# * Start Box Display
#--------------------------------------------------------------------------
def start_box
if @character.is_a?(Game_Follower)
return unless @character.visible?
end
return if @character.transparent
@box_sprite = Sprite.new(viewport)
bb = @character.bounding_box
bbox = bb[2].nil? ? 0 : bb[2]
bboy = bb[3].nil? ? 0 : bb[3]
@box_sprite.bitmap = Bitmap.new(bb[0],bb[1])
@box_sprite.bitmap.fill_rect(@box_sprite.bitmap.rect,Color.new(255,0,0,255))
@box_sprite.ox += 16 - bbox
@box_sprite.oy += 32 - bboy
@box_sprite.x = @character.x
@box_sprite.y = @character.y
@box_sprite.z = z
@box_sprite.blend_type = 1
end
#--------------------------------------------------------------------------
# * Free
#--------------------------------------------------------------------------
def dispose
qbox_dispose
dispose_box if Quasi::Movement::SHOWBOXES
end
#--------------------------------------------------------------------------
# * Free Box
#--------------------------------------------------------------------------
def dispose_box
@box_sprite.dispose if @box_sprite
end
#--------------------------------------------------------------------------
# * Update Box
#--------------------------------------------------------------------------
def update_box
return unless @box_sprite
@box_sprite.x = x if @box_sprite.x != x
@box_sprite.y = y if @box_sprite.y != y
end
end
else
msgbox(sprintf("[Quasi Movement] Requires Quasi module to run."))
end
Хорошо!: 
Плохо!: 
Сообщение от kuroki
Ответить с цитированием
Социальные закладки