DoubleX RMVXA Pixel Movement
DoubleX RMVXA Pixel Movement
Version: v1.01a
Introduction
Lets users set the smallest number of pixel covered per move command
Prerequisites
* Little RGSS3 scripting proficiency to fully utilize this script
Script
"script"
Code:
#==============================================================================|
# ** Script Info |
#------------------------------------------------------------------------------|
# * Script Name |
# DoubleX RMVXA Pixel Movement |
#------------------------------------------------------------------------------|
# * Functions |
# Lets users set the smallest number of pixel covered per move command |
#------------------------------------------------------------------------------|
# * Terms Of Use |
# You shall keep this script's Script Info part's contents intact |
# You shalln't claim that this script is written by anyone other than |
# DoubleX or his aliases |
# None of the above applies to DoubleX or his aliases |
#------------------------------------------------------------------------------|
# * Prerequisites |
# Abilities: |
# 1. Little RGSS3 scripting proficiency to fully utilize this script |
#------------------------------------------------------------------------------|
# * Instructions |
# 1. Open the script editor and put this script into an open slot between |
# Materials and Main, save to take effect. |
#------------------------------------------------------------------------------|
# * Links |
# Script Usage 101: |
# 1. forums.rpgmakerweb.com/index.php?/topic/32752-rmvxa-script-usage-101/ |
# 2. rpgmakervxace.net/topic/27475-rmvxa-script-usage-101/ |
# This script: |
# 1. http://pastebin.com/RPF8dDDR |
# Mentioned Patreon Supporters: |
# https://www.patreon.com/posts/71738797 |
#------------------------------------------------------------------------------|
# * Authors |
# DoubleX |
#------------------------------------------------------------------------------|
# * Changelog |
# v1.01a(GMT 1600 14-8-2015): |
# 1. Lets users set a key/script call to set a char to have integer coors |
# 2. Fixed event triggered by player touch not triggering bug |
# 3. Fixed encounters simply not working bug |
# 4. Fixed the bullet through paper problem when moving diagonally |
# 5. Found the origin of the starting map not passable bug with either |
# vehicle's starting positions being uninitialized by users |
# 6. Increased this script's correctness, effectiveness and efficiency |
# 7. Little RGSS3 scripting proficiency's needed to fully utilize the script|
# v1.00a(GMT 1600 12-8-2015): |
# 1. 1st version of this script finished |
#==============================================================================|
#==============================================================================|
# ** (v1.01a+)Script Call Info |
#------------------------------------------------------------------------------|
# * Character manipulations |
# 1. pixel_movement_nearest_tile |
# - Sets the x and y psotions of the char to be their nearest integers |
#==============================================================================|
($doublex_rmvxa ||= {})[:Pixel_Movement] = "v1.01a"
#==============================================================================|
# ** Script Configurations |
# You only need to edit this part as it's about what this script does |
#------------------------------------------------------------------------------|
module DoubleX_RMVXA
module Pixel_Movement
# Sets the global minimum pixel covered per move command as MIN_PIXEL_MOVE
# It must return a natural number
# If an object moves faster than MIN_PIXEL_MOVE per frame, that object's
# original speed will be used instead
# Errors might come if MIN_PIXEL_MOVE is increased during the game execution
# If MIN_PIXEL_MOVE_VAR_ID is a natural number, the value of variable with
# id MIN_PIXEL_MOVE_VAR_ID will be used instead of using MIN_PIXEL_MOVE
MIN_PIXEL_MOVE = 1
MIN_PIXEL_MOVE_VAR_ID = 0
# (v1.01a+)Sets the key to set the player's x and y positions as their
# nearest integers as NEAREST_TILE_KEY
# It must return a symbol and should return a keymap binding symbol
# Using a custom keymap binding script might help setting NEAREST_TILE_KEY
# If NEAREST_TILE_KEY_VAR_ID is a natural number, the value of variable with
# id NEAREST_TILE_KEY_VAR_ID will be used instead of using NEAREST_TILE_KEY
NEAREST_TILE_KEY = :X
NEAREST_TILE_KEY_VAR_ID = 0
#==============================================================================|
# ** Script Implementations |
# You need not edit this part as it's about how this script works |
#------------------------------------------------------------------------------|
# * Script Support Info: |
# 1. Prerequisites |
# - Basic knowledge of pixel movement |
# - Some RGSS3 scripting proficiency to fully comprehend this script |
# 2. Method documentation |
# - The 1st part describes why this method's rewritten/aliased for |
# rewritten/aliased methods or what the method does for new methods |
# - The 2nd part describes what the arguments of the method are |
# - The 3rd part informs which version rewritten, aliased or created this|
# method |
# - The 4th part informs whether the method's rewritten or new |
# - The 5th part describes how this method works for new methods only, |
# and describes the parts added, removed or rewritten for rewritten or |
# aliased methods only |
# Example: |
# #--------------------------------------------------------------------------| |
# # Why rewrite/alias/What this method does | |
# #--------------------------------------------------------------------------| |
# # *argv: What these variables are |
# # &argb: What this block is |
# def def_name(*argv, &argb) # Version X+; Rewrite/New |
# # Added/Removed/Rewritten to do something/How this method works |
# def_name_code |
# # |
# end # def_name |
#------------------------------------------------------------------------------|
#--------------------------------------------------------------------------|
# Helper methods simplifying the uses of the configuration value |
#--------------------------------------------------------------------------|
def self.min_pixel_move
return MIN_PIXEL_MOVE if MIN_PIXEL_MOVE_VAR_ID <= 0
$game_variables[MIN_PIXEL_MOVE_VAR_ID]
end # min_pixel_move
def self.nearest_tile_key # v1.01a+
return NEAREST_TILE_KEY if NEAREST_TILE_KEY_VAR_ID <= 0
$game_variables[NEAREST_TILE_KEY_VAR_ID]
end # nearest_tile_key
end # Pixel_Movement
end # DoubleX_RMVXA
class Game_Map # Edit
def x_with_direction(x, d) # Rewrite
# Rewritten
return x + DoubleX_RMVXA::Pixel_Movement.min_pixel_move / 32.0 if d == 6
return x - DoubleX_RMVXA::Pixel_Movement.min_pixel_move / 32.0 if d == 4
x
#
end # x_with_direction
def y_with_direction(y, d) # Rewrite
# Rewritten
return y + DoubleX_RMVXA::Pixel_Movement.min_pixel_move / 32.0 if d == 2
return y - DoubleX_RMVXA::Pixel_Movement.min_pixel_move / 32.0 if d == 8
y
#
end # y_with_direction
def round_x_with_direction(x, d) # Rewrite
round_x(x_with_direction(x, d)) # Rewritten
end # round_x_with_direction
def round_y_with_direction(y, d) # Rewrite
round_y(y_with_direction(y, d)) # Rewritten
end # round_y_with_direction
def valid?(x, y) # Rewrite
x >= 0 && x <= width - 1 && y >= 0 && y <= height - 1 # Rewritten
end # valid?
#----------------------------------------------------------------------------|
# Uses a unit bounding square to detect overlapped tiles instead |
#----------------------------------------------------------------------------|
alias layered_tiles_flag_pixel_movement? layered_tiles_flag?
def layered_tiles_flag?(x, y, bit, &argb)
# Rewritten
(x == (x = x.to_i) ? [x] : [x, x + 1]).each { |xi|
(y == (y = y.to_i) ? [y] : [y, y + 1]).each { |yi|
return true if layered_tiles_flag_pixel_movement?(x, y, bit, &argb)
}
}
false
#
end # layered_tiles_flag?
end # Game_Map
class Game_CharacterBase # Edit
#----------------------------------------------------------------------------|
# New private instance variables |
#----------------------------------------------------------------------------|
# @pixel_movement_diff: The movement distance of the current frame
# @pixel_movement_dist: The accumulated movement distance
#----------------------------------------------------------------------------|
# Uses a unit bounding square to detect character collisions instead |
#----------------------------------------------------------------------------|
def pos?(x, y) # Rewrite
# Rewritten to regard just touching as edges as colliding
x + 1 >= @x && x <= @x + 1 && y + 1 >= @y && y <= @y + 1
#
end # pos?
#----------------------------------------------------------------------------|
# Uses a unit bounding square to detect character collisions instead |
#----------------------------------------------------------------------------|
def pos_nt?(x, y) # Rewrite
# Rewritten to regard just touching the edges as not colliding
!@through && x + 1 > @x && x < @x + 1 && y + 1 > @y && y < @y + 1
#
end # pos_nt?
#----------------------------------------------------------------------------|
# Uses a unit bounding square to detect character collisions instead |
#----------------------------------------------------------------------------|
def passable?(x, y, d) # Rewrite
x2 = $game_map.round_x_with_direction(x, d)
y2 = $game_map.round_y_with_direction(y, d)
# Rewritten to check if all overlapped tiles are valid and passable as well
xs = x2 == (x2i = x2.to_i) ? [x2i] : [x2i, x2i + 1]
ys = y2 == (y2i = y2.to_i) ? [y2i] : [y2i, y2i + 1]
xs.each { |xi|
ys.each { |yi| return false unless $game_map.valid?(xi, yi) }
}
return true if @through || debug_through?
(x == (x = x.to_i) ? [x] : [x, x + 1]).each { |xi|
(y == (y = y.to_i) ? [y] : [y, y + 1]).each { |yi|
return false unless map_passable?(xi, yi, d)
}
}
rd = reverse_dir(d)
xs.each { |xi|
ys.each { |yi| return false unless map_passable?(xi, yi, rd) }
}
#
!collide_with_characters?(x2, y2)
end # passable?
#----------------------------------------------------------------------------|
# Prevents an event from being falsely considered as colliding with itself |
#----------------------------------------------------------------------------|
def collide_with_events?(x, y) # Rewrite
return true if is_a?(Game_Event)
($game_map.events_xy_nt(x, y) - [self]).any? { |e| e.normal_priority? }
end # collide_with_events?
def move_straight(d, turn_ok = true) # Rewrite
@move_succeed = passable?(@x, @y, d)
if @move_succeed
set_direction(d)
@x = $game_map.round_x_with_direction(@x, d)
@y = $game_map.round_y_with_direction(@y, d)
@real_x = $game_map.x_with_direction(@x, reverse_dir(d))
@real_y = $game_map.y_with_direction(@y, reverse_dir(d))
# Rewritten to prevent character from being locked into impassable places
set_pixel_movement_min
last_x = @real_x
last_y = @real_y
pixel_movement_straight(last_x, last_y, d) unless passable?(@x, @y, d)
@pixel_movement_diff = ((@x - last_x) ** 2 + (@y - last_y) ** 2) ** 0.5
@pixel_movement_dist += @pixel_movement_diff
while @pixel_movement_dist >= 1
increase_steps
@pixel_movement_dist -= 1
end
#
elsif turn_ok
set_direction(d)
check_event_trigger_touch_front
end
end # move_straight
def move_diagonal(horz, vert) # Rewrite
@move_succeed = diagonal_passable?(@x, @y, horz, vert)
if @move_succeed
@x = $game_map.round_x_with_direction(@x, horz)
@y = $game_map.round_y_with_direction(@y, vert)
@real_x = $game_map.x_with_direction(@x, reverse_dir(horz))
@real_y = $game_map.y_with_direction(@y, reverse_dir(vert))
# Rewritten to prevent character from being locked into impassable places
set_pixel_movement_min
set_pixel_movement_diagonal(horz, vert)
@pixel_movement_diff = ((@x - @real_x) ** 2 + (@y - @real_y) ** 2) ** 0.5
@pixel_movement_dist += @pixel_movement_diff
while @pixel_movement_dist >= 1
increase_steps
@pixel_movement_dist -= 1
end
#
increase_steps
end
set_direction(horz) if @direction == reverse_dir(horz)
set_direction(vert) if @direction == reverse_dir(vert)
end # move_diagonal
alias init_private_members_pixel_movement init_private_members
def init_private_members(*argv, &argb)
init_private_members_pixel_movement(*argv, &argb)
@pixel_movement_diff = @pixel_movement_dist = 0 # Added
end # init_private_members
#----------------------------------------------------------------------------|
# Checks if events collide with the players as well |
#----------------------------------------------------------------------------|
alias collide_with_characters_pixel_movement? collide_with_characters?
def collide_with_characters?(x, y)
return true if $game_player != self && $game_player.pos_nt?(x, y) # Added
collide_with_characters_pixel_movement?(x, y)
end # collide_with_characters?
#----------------------------------------------------------------------------|
# Sets the number of pixel covered per frame to be at least that of the char|
#----------------------------------------------------------------------------|
def set_pixel_movement_min # New
dpf = distance_per_frame
if @x > @real_x
@x = [@real_x + dpf, $game_map.width - 1].min if @x < @real_x + dpf
elsif @x < @real_x
@x = [@real_x - dpf, 0].max if @x > @real_x - dpf
end
if @y > @real_y
@y = [@real_y + dpf, $game_map.height - 1].min if @y < @real_y + dpf
elsif @y < @real_y
@y = [@real_y - dpf, 0].max if @y > @real_y - dpf
end
end # set_pixel_movement_min
#----------------------------------------------------------------------------|
# Prevents the character from being locked into an impassable place |
#----------------------------------------------------------------------------|
# last_x : The real x coordinate right before moving straight
# last_y : The real y coordinate right before moving straight
# d: The movement direction
def pixel_movement_straight(last_x, last_y, d) # New
mpm = DoubleX_RMVXA::Pixel_Movement.min_pixel_move / 32.0
# Uses a binary search to find the point making the char to become passable
while (@x - last_x).abs > mpm || (@y - last_y).abs > mpm
@real_x = (@x + last_x) / 2
@real_y = (@y + last_y) / 2
if passable?(@real_x, @real_y, d)
last_x = @real_x
next last_y = @real_y
end
@x = @real_x
@y = @real_y
end
#
@real_x = @x
@real_y = @y
end # pixel_movement_straight
#----------------------------------------------------------------------------|
# Fixes the bullet through paper problem when moving diagonally |
#----------------------------------------------------------------------------|
# horz: The horizontal direction component
# vert: The vertical direction component
def set_pixel_movement_diagonal(horz, vert) # New
# Sets the maximum number of pixels covered that are still passable
mpm = DoubleX_RMVXA::Pixel_Movement.min_pixel_move / 32.0
xi = @real_x
yi = @real_y
xs = (@x - @real_x) / (@x - @real_x).abs
ys = (@y - @real_y) / (@y - @real_y).abs
while xi * xs <= @x * xs && yi * ys <= @y * ys &&
diagonal_passable?(xi, yi, horz, vert)
xi += mpm * xs
yi += mpm * ys
end
@x = xi
@y = yi
#
end # set_pixel_movement_diagonal
#----------------------------------------------------------------------------|
# Tries to set the real x and y positions to be their nearest integers |
#----------------------------------------------------------------------------|
def pixel_movement_nearest_tile # v1.01a+; New
test_x = ((@x * 2).to_i + 1) / 2
test_y = ((@y * 2).to_i + 1) / 2
[2, 4, 6, 8].each { |d| return unless passable?(test_x, test_y, d) }
@x = test_x
@y = test_y
end # pixel_movement_nearest_tile
end # Game_CharacterBase
class Game_Player < Game_Character # v1.01a+; Edit
def update # Rewrite
last_real_x = @real_x
last_real_y = @real_y
last_moving = moving?
move_by_input
super
update_scroll(last_real_x, last_real_y)
update_vehicle
# Rewritten
unless $game_map.interpreter.running?
moving? ? pixel_movement_update : update_nonmoving(last_moving)
end
#
@followers.update
# Added
return unless Input.trigger?(DoubleX_RMVXA::Pixel_Movement.nearest_tile_key)
pixel_movement_nearest_tile
#
end # update
# last_moving: The moving flag at the last frame
def update_nonmoving(last_moving) # Rewrite
# Rewritten
return if last_moving && check_touch_event
movable? && Input.trigger?(:C) && (get_on_off_vehicle || check_action_event)
#
end # update_nonmoving
alias move_by_input_pixel_movement move_by_input
def move_by_input
# Added
@pixel_movement_diff = ((@x - @real_x) ** 2 + (@y - @real_y) ** 2) ** 0.5
#
move_by_input_pixel_movement
end # move_by_input
alias encounter_progress_value_pixel_movement encounter_progress_value
def encounter_progress_value
encounter_progress_value_pixel_movement * @pixel_movement_diff # Rewritten
end # encounter_progress_value
def moving? # New
@pixel_movement_diff != 0
end # moving?
def pixel_movement_update # New
$game_party.on_player_walk
check_touch_event || update_encounter
end # pixel_movement_update
end # Game_Player
#------------------------------------------------------------------------------|
#==============================================================================|Instructions
Open the script editor and put this script into an open slot between Materials and Main. Save to take effect.
FAQ
None so far
Credits and Thanks
None
Terms and Conditions
You shall keep this script's Script Info part's contents intact
You shalln't claim that this script is written by anyone other than DoubleX or his aliases
None of the above applies to DoubleX or his aliases
Changelog
v1.01a(GMT 1600 14-8-2015):
1. Lets users set a key/script call to set a char to have integer coors
2. Fixed event triggered by player touch not triggering bug
3. Fixed encounters simply not working bug
4. Fixed the bullet through paper problem when moving diagonally
5. Found the origin of the starting map not passable bug with either vehicle's starting positions being uninitialized by users
6. Increased this script's correctness, effectiveness and efficiency
7. Little RGSS3 scripting proficiency's needed to fully utilize the script
v1.00a(GMT 1600 12-8-2015):1. 1st version of this script finished