Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #==============================================================================|
- # ** 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
- #------------------------------------------------------------------------------|
- #==============================================================================|
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement