Help with Theo's Interact Alert

● ARCHIVED · READ-ONLY

Started by LanceGardner Aug 27, 2014, 09:37 PM 10 posts View original ↗

LanceGardner

#1 Aug 27, 2014, 09:37 PM Source

Hey, I am using a script by Theo designed to display text over interactable objects. I have the script pasted above Main, below Materials, obviously. I have the comment correctly placed in the event as per instructions. So why is nothing showing up? :( Here's the code - he requires credit if anyone else wishes to use it, but it's freely available:

http://www.rpgmakervxace.net/topic/24295-theo-interact-hover-notification/

Note: I have tried this in a new project and it works just fine. So I guess it's either script compatibility issues or having a variable already set to something? The other scripts I use are

Victor

Basic Module, Target Arrow, Animated Battle and Battlers, ATB, Materia, Damage Pop-Up, Multiple Troops, Terrain States, Toggle Target, Trait Control, Actor Events, Custom Descriptions, Progressive Timer, Pixel Movement, Moving Platforms and Free Jump

Galv

New Item, Region Effects

Modern Algebra

Quest Log, Monster Catalogue

Yanfly's Victory Aftermath

Hopefully it's the variable thing. He doesn't know of any script compatibility issues but if anyone who understands coding can glance at the script and say whether they think its likely to collide with something... I would be much obliged. Thanks!

Spoiler

Code:

# =============================================================================# TheoAllen - Interact Hover Notification# Version : 1.1# Contact : www.rpgmakerid.com (or) [URL="http://theolized.blogspot.com#"]http://theolized.blogspot.com#[/URL] (English Documentation)# =============================================================================($imported ||= {})[:Theo_InteractNotif] = true# =============================================================================# Change Logs:# -----------------------------------------------------------------------------# 2014.05.30 - Change notetag to be more reasonable# 2013.08.21 - Bugfix when changing map# 2013.08.04 - Bugfix at Event Page Condition# 2013.07.24 - Finished script# ==============================================================================begin  Introduction :  This script displays notification text over event. Only event with action  button as trigger and not an empty event will be displaying the text    How to use :  Put this script below material but above main  Put comments in event in this format <interact: notif>  So, it will display the notification text    Terms of Use :  Credit me, TheoAllen. You are free to edit this script by your own. As long  as you don't claim it yours. For commercial purpose, don't forget to give me  a free copy of the game.=end# =============================================================================# Configuration :# =============================================================================module THEO  module Interact        # Default text of hover notif. Set it to "" if you don't want to each    # event displays notification    DefaultNotif = ""        # Opacity change per frame (not frame duration, remember)    FadeSpeed = 20        # Higher value means, higher place over event    Displacement = 15        # Maximum width of notification    Width  = 300        # Font settings    FontName = ["Calibri"]    FontSize = 18    FontBold = true    FontItalic = false      endend# =============================================================================# End of config. Unless you're a mighty scripting god, do not touch anything # pass this line. # =============================================================================class Game_Event < Game_Character  attr_accessor :hover_notif    alias theo_ihn_page_setting setup_page_settings  def setup_page_settings    theo_ihn_page_setting    setup_hover_notif  end      def setup_hover_notif    @hover_notif = THEO::Interact::DefaultNotif    @list.each do |command|      next unless command.code == 108 || command.code == 408      if command.parameters[0] =~ /<interact\s*:\s+(.*)>/i        @hover_notif = $1.to_s      end    end  end    def list_is_empty?    list.all? do |command|      command.code == 0 ||      command.code == 108 ||      command.code == 408 ||      command.code == 118    end  end    def trigger_is_possible?     return false if list_is_empty?    return false if trigger != 0    return true  end    def meet_with_player?    return in_front_of_player? if normal_priority?    return below_or_above_player?  end    def in_front_of_player?    self.x == $game_player.front_x && self.y == $game_player.front_y  end    def below_or_above_player?    self.x == $game_player.x && self.y == $game_player.y  end    def showing_hover_notif?    return false unless @hover_notif    return false if @hover_notif.empty?    return false if @erased    return false if $game_map.interpreter.running?    return trigger_is_possible? && meet_with_player?  end  endclass Game_Player < Game_Character    def front_x    $game_map.round_x_with_direction(@x,@direction)  end    def front_y    $game_map.round_y_with_direction(@y,@direction)  end  endclass Window_InteractNotif < Window_Base  include THEO::Interact    def initialize(event)    super(0,0,Width,fitting_height(1))    self.opacity = 0    self.contents_opacity = 0    @event = event    setup_font    update_placement    refresh  end    def setup_font    font = contents.font    font.size = FontSize    font.name = FontName    font.bold = FontBold    font.italic = FontItalic  end    def refresh    contents.clear    @text = @event.hover_notif    draw_text(contents.rect,@text,1)  end    def update    super    update_placement    update_opacity    refresh if need_refresh?  end    def update_placement    self.x = @event.screen_x - self.width/2    self.y = @event.screen_y - self.height - Displacement  end    def update_opacity    if @event.showing_hover_notif?      update_fadein    else      update_fadeout    end      end    def need_refresh?    @text != @event.hover_notif  end    def line_height    FontSize  end    def fade_speed    return FadeSpeed  end    def update_fadein    self.contents_opacity += fade_speed  end    def update_fadeout    self.contents_opacity -= fade_speed  end  endclass Scene_Map < Scene_Base    alias theo_ihn_start start  def start    theo_ihn_start    create_hover_notif_window  end    def create_hover_notif_window    @notif_windows = []    $game_map.events.values.each do |event|      @notif_windows.push(Window_InteractNotif.new(event))    end  end    alias theo_ihn_update update  def update    theo_ihn_update    update_notif_windows  end    def update_notif_windows    @notif_windows.each do |window|      window.update    end  end    alias theo_ihn_dispose_all dispose_all_windows  def dispose_all_windows    theo_ihn_dispose_all    dispose_hover_notif  end    def dispose_hover_notif    @notif_windows.each do |window|      window.dispose    end  end    alias theo_ihn_pre_trans pre_transfer  def pre_transfer    theo_ihn_pre_trans    dispose_hover_notif  end    alias theo_ihn_post_trans post_transfer  def post_transfer    create_hover_notif_window    theo_ihn_post_trans  end  end

Andar

#2 Aug 27, 2014, 09:43 PM Source

Please put spoiler tags around the script, it makes your post better readable

Can you give us a screenshot of the event?

Perhaps you misunderstood how to place the tag, or there is some other error in the event (instead of being a script incompatibility)
LanceGardner

#3 Aug 27, 2014, 09:45 PM Source

Dear Andar,

I will edit the tags in now, sorry I am fairly new to posting. I did not misunderstand how to place the tag because as I said it works fine in a new project. I have compared them several times - it's just a simple comment in an event. In fact I copy and pasted the event between the two projects. It works in the empty one, but not in my main one. Hence I feel it's most likely a script compatibility issue :/

EDIT: Regarding the event, it's just a test event. I pulled a random npc graphic as the image, priority is same as character. Trigger is Action Button. First line is Comment: <interact: Talk>. Second line is "Text: Hi" (just a normal text command).
Euphoria

#4 Aug 27, 2014, 09:51 PM Source

Since you don't have very many scripts, copy them all into the blank project, where Theo's was working, then delete them one by one, checking to see if theo's script starts working in between each delete. The last one you delete before it works, is the compatibility issue, and then you can ask someone to make a fix for those two.

Also you still haven't put the spoiler tags in your main post, if you don't know how to:

[*spoiler]

script here

[*/spoiler]

and take the *'s out.
Andar

#5 Aug 27, 2014, 09:53 PM Source

OK, then it's probably indeed a script compatibility problem - it can't be a previously set variable because the notifications doesn't use the game variables.

Try reordering the scripts, about half the script incompatibilites can be solved this way (when they happen because of an alias sequence problem, the script with the wrong sequence just needs to be the last script).

If reorderin the added script doesn't solve this, you'll have to wait until a scripter has enough time to check your list of scripts - please link the other scripts as well, that usually speeds up the problem solving (the scripter would have to spent time looking where those scripts are if you don't link them).
LanceGardner

#6 Aug 27, 2014, 10:03 PM Source

I've found the issue. It's with Victor's Pixel Movement, here's the script.

Spoiler
# ** Victor Engine - Pixel Movement
#------------------------------------------------------------------------------
# Author : Victor Sant
#
# Version History:
# v 1.00 - 2012.05.29 > First release
# v 1.01 - 2012.05.29 > Compatibility with Terrain States
# v 1.02 - 2012.07.03 > Compatibility with Basic Module 1.23
# v 1.03 - 2012.07.05 > Added 'over event' tag for objects over blocked tiles
#                      > Added Steps settings for events
# v 1.04 - 2012.07.24 > Compatibility with Moving Platform
#                      > Added <each step trigger> tag for events
# v 1.05 - 2012.07.30 > Fixed issue when characters moves toward the same spot
# v 1.06 - 2012.08.03 > Compatibility with Anti Lag
# v 1.07 - 2012.08.03 > Fixed collision with tile graphics events
# v 1.08 - 2012.08.18 > Fixed issue with Pixel Movement and Vehicles
#                      > Fixed issue with some notetags
#                      > Fixed issue with chasing events
# v 1.09 - 2013.01.07 > Fixed issue with vehicles passing through all tiles
# v 1.10 - 2013.01.24 > Fixed issue with diagonal movement and VE_DIAGONAL_FIX
#------------------------------------------------------------------------------
# This script allows to replace the tile based movement where the player
# walks a whole 32 pixel tile each step with one that he walks only 4 pixels.
# It also give a better collision system for events.
#------------------------------------------------------------------------------
# Compatibility
#   Requires the script 'Victor Engine - Basic Module' v 1.25 or higher
#   If used with 'Victor Engine - Animated Battle' place this bellow it.
#   If used with 'Victor Engine - Follower Control' place this bellow it.
#   If used with 'Victor Engine - Follower Options' place this bellow it.
#
# * Overwrite methods
#   class Game_Actor < Game_Battler
#     def turn_end_on_map
#
#   class Game_Map
#     def layered_tiles(x, y)
#     def events_xy(x, y)
#     def events_xy_nt(x, y)
#     def x_with_direction(x, d, times = 1)
#     def y_with_direction(y, d, times = 1)
#     def round_x_with_direction(x, d)
#     def round_y_with_direction
#
#   class Game_CharacterBase
#     def region_id
#     def move_straight(d, turn_ok = true)
#     def move_diagonal(horz, vert)
#     def collide_with_events?(x, y)
#     def collide_with_vehicles?(x, y)
#
#   class Game_Player < Game_Character
#     def check_event_trigger_there(triggers)
#     def start_map_event(x, y, triggers, normal)
#     def update_nonmoving(last_moving)
#     def get_on_vehicle
#     def increase_steps
#
#   class Game_Follower < Game_Character
#     def chase_preceding_character
#
#   class Game_Event < Game_Character
#     def collide_with_player_characters?(x, y)
#
#   class Game_Vehicle < Game_Character
#     def land_ok?(x, y, d)
#
# * Alias methods
#   class Game_Actor < Game_Battler
#     def check_floor_effect
#
#   class Game_CharacterBase
#     def init_public_members
#     def update
#
#   class Game_Event < Game_Character
#     def start
#
#   class Game_Player < Game_Character
#     def get_off_vehicle
#     def clear_transfer_info
#     def update
#
#   class Game_Event < Game_Character
#     def start
#
#------------------------------------------------------------------------------
# Instructions:
# To instal the script, open you script editor and paste this script on
# a new section bellow the Materials section. This script must also
# be bellow the script 'Victor Engine - Basic'
#
#------------------------------------------------------------------------------
# Event Comment boxes note tags:
#   Tags to be used on events Comment boxes.
#
# <move steps: x>
#   Setup the number of steps each "Move" command will execute. The default
#   value is 8 (1 tile)
#     x : number of steps
#
# <event size: x, y>
#   Collision area size, in pixels for event collisions.
#     x : collision area width
#     y : collision area height
#
# <front collision>
#   Events with this tag won't start if the the collision between events and
#   the player occur between their edges.
#
# <no side collision fix>
#   Events with this tag won't have the "slide" effect when the edges of the
#   events collide with the player
#
# <over tile>
#   Events with this tag will start even when placed over blocked tiles.
#   By default, if the passage is blocked the event don't start.
#
# <each step trigger>
#   By default, events with through or bellow character priority triggers
#   only one time for each 8 steps above them. With this tag though, the
#   event will trigger every step.
#
#------------------------------------------------------------------------------
# Additional instructions:
#
# All events and tiles have a "slide" effect when the player faces the edge
# of a tile or event. I added this function since it would be a pain to
# be in the exact position to go throug a narrow path.
# This can be disabled for events, but not for tiles.
#
# By default, event collision size is the same as the event bitmap box, no
# matter how the sprite is set inside of the box. If you want different
# collision size you must setup manually in the event with the tag
# <event size: x, y>
#
# Events over blocked tiles will not start properly unless the event have
# the tag <over tile>
#
#==============================================================================

#==============================================================================
# ** Victor Engine
#------------------------------------------------------------------------------
#   Setting module for the Victor Engine
#==============================================================================

module Victor_Engine
#--------------------------------------------------------------------------
# * Player collision area
#   Different from events, player collision don't rely on the graphic size
#   Player collision area can be of 2 types:
#   - 32 x 32 box if VE_PLAYER_BIG_COLLISION = true
#   - 24 x 24 box if VE_PLAYER_BIG_COLLISION = false
#--------------------------------------------------------------------------
VE_PLAYER_BIG_COLLISION = true
#--------------------------------------------------------------------------
# * required
#   This method checks for the existance of the basic module and other
#   VE scripts required for this script to work, don't edit this
#--------------------------------------------------------------------------
def self.required(name, req, version, type = nil)
    if !$imported[:ve_basic_module]
      msg = "The script '%s' requires the script\n"
      msg += "'VE - Basic Module' v%s or higher above it to work properly\n"
      msg += "Go to http://victorscripts.wordpress.com/ to download this script."
      msgbox(sprintf(msg, self.script_name(name), version))
      exit
    else
      self.required_script(name, req, version, type)
    end
end
#--------------------------------------------------------------------------
# * script_name
#   Get the script name base on the imported value
#--------------------------------------------------------------------------
def self.script_name(name, ext = "VE")
    name = name.to_s.gsub("_", " ").upcase.split
    name.collect! {|char| char == ext ? "#{char} -" : char.capitalize }
    name.join(" ")
end
end

$imported ||= {}
$imported[:ve_pixel_movement] = 1.10
Victor_Engine.required:)ve_pixel_movement, :ve_basic_module, 1.25, :above)
Victor_Engine.required:)ve_pixel_movement, :ve_map_battle, 1.00, :bellow)
Victor_Engine.required:)ve_pixel_movement, :ve_diagonal_move, 1.00, :bellow)

#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
# This class handles actors. It's used within the Game_Actors class
# ($game_actors) and referenced by the Game_Party class ($game_party).
#==============================================================================

class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# * Overwrite method: turn_end_on_map
#--------------------------------------------------------------------------
def turn_end_on_map
    if $game_player.steps % (steps_for_turn * 8) == 0
      on_turn_end
      perform_map_damage_effect if @result.hp_damage > 0
    end
end
#--------------------------------------------------------------------------
# * Alias method: init_public_members
#--------------------------------------------------------------------------
alias :check_floor_effect_ve_pixel_movement :check_floor_effect
def check_floor_effect
    return if check_damage_floor
    check_floor_effect_ve_pixel_movement
end
#--------------------------------------------------------------------------
# * New method: check_damage_floor
#--------------------------------------------------------------------------
def check_damage_floor
    $game_player.damage_floor % 8 != 0
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
#--------------------------------------------------------------------------
# * Overwrite method: layered_tiles
#--------------------------------------------------------------------------
def layered_tiles(x, y)
    x2 = (x - 0.5).ceil
    y2 = (y - 0.125).ceil
    [2, 1, 0].collect {|z| tile_id(x2, y2, z) }
end
#--------------------------------------------------------------------------
# * Overwrite method: events_xy
#--------------------------------------------------------------------------
def events_xy(x, y)
    event_list.select {|event| event.near?(x, y) }
end
#--------------------------------------------------------------------------
# * Overwrite method: events_xy_nt
#--------------------------------------------------------------------------
def events_xy_nt(x, y)
    event_list.select {|event| event.near_nt?(x, y) }
end
#--------------------------------------------------------------------------
# * Overwrite method: x_with_direction
#--------------------------------------------------------------------------
def x_with_direction(x, d, times = 1)
    x + (d == 6 ? times * 0.125 : d == 4 ? -times * 0.125 : 0)
end
#--------------------------------------------------------------------------
# * Overwrite method: y_with_direction
#--------------------------------------------------------------------------
def y_with_direction(y, d, times = 1)
    y + (d == 2 ? times * 0.125 : d == 8 ? -times * 0.125 : 0)
end
#--------------------------------------------------------------------------
# * Overwrite method: round_x_with_direction
#--------------------------------------------------------------------------
def round_x_with_direction(x, d)
    round_x(x + (d == 6 ? 0.125 : d == 4 ? -0.125 : 0))
end
#--------------------------------------------------------------------------
# * Overwrite method: round_y_with_direction
#--------------------------------------------------------------------------
def round_y_with_direction(y, d)
    round_y(y + (d == 2 ? 0.125 : d == 8 ? -0.125 : 0))
end
#--------------------------------------------------------------------------
# * New method: check_x_with_direction
#--------------------------------------------------------------------------
def check_x_with_direction(x, d)
    round_x(x + (d == 6 ? 1 : d == 4 ? -1 : 0))
end
#--------------------------------------------------------------------------
# * New method: check_y_with_direction
#--------------------------------------------------------------------------
def check_y_with_direction(y, d)
    round_y(y + (d == 2 ? 1 : d == 8 ? -1 : 0))
end
end

#==============================================================================
# ** Game_CharacterBase
#------------------------------------------------------------------------------
# This class deals with characters. Common to all characters, stores basic
# data, such as coordinates and graphics. It's used as a superclass of the
# Game_Character class.
#==============================================================================

class Game_CharacterBase
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :next_movement
attr_accessor :side_collision
attr_accessor :damage_floor
attr_accessor :move_list
attr_accessor :steps
#--------------------------------------------------------------------------
# * Overwrite method: region_id
#--------------------------------------------------------------------------
def region_id
    $game_map.region_id((@x - 0.5).ceil, (@y - 0.125).ceil)
end
#--------------------------------------------------------------------------
# * Overwrite method: collide_with_events?
#--------------------------------------------------------------------------
def collide_with_events?(x, y)
    $game_map.events_xy_nt(x, y).any? do |event|
      event.collision_condition?(x, y, bw, bh, event?, @id, @side_collision)
    end
end
#--------------------------------------------------------------------------
# * Overwrite method: collide_with_vehicles?
#--------------------------------------------------------------------------
def collide_with_vehicles?(x, y)
    $game_map.vehicles.compact.any? do |vehicle|
      next if vehicle.map_id != $game_map.map_id
      vehicle.collision_condition?(x, y, bw, bh, self)
    end
end
#--------------------------------------------------------------------------
# * Overwrite method: move_straight
#--------------------------------------------------------------------------
def move_straight(d, turn_ok = true)
    @move_list += [{d: [d], turn: turn_ok}] * step_times
end
#--------------------------------------------------------------------------
# * Overwrite method: move_straight
#--------------------------------------------------------------------------
def move_diagonal(horz, vert)
    @move_list += [{d: [horz, vert], turn: true}] * step_times
end
#--------------------------------------------------------------------------
# * Alias method: init_public_members
#--------------------------------------------------------------------------
alias :init_public_members_ve_pixel_movement :init_public_members
def init_public_members
    init_public_members_ve_pixel_movement
    @move_list     = []
    @next_movement = []
    @over_event    = 0
    @damage_floor = 0
    @steps         = 0
end
#--------------------------------------------------------------------------
# * Alias method: update
#--------------------------------------------------------------------------
alias :update_ve_pixel_movement :update
def update
    update_move_straight
    update_move_diagonal
    update_ve_pixel_movement
end
#--------------------------------------------------------------------------
# * New method: update_move_straight
#--------------------------------------------------------------------------
def update_move_straight
    return if moving? || @move_list.empty?
    return if @move_list.first[ :D ].size > 1
    @move_value = @move_list.shift
    d           = @move_value[ :D ].first
    if passable?(@x, @y, d)
      move_straight_pixel(d)
    elsif @move_value[:turn]
      @move_list.clear
      check_event_trigger_move(d)
    else
      @move_list.clear
    end
end
#--------------------------------------------------------------------------
# * New method: move_straight_pixel
#--------------------------------------------------------------------------
def move_straight_pixel(d)
    @diagonal_move = false
    setup_movement(d, d)
    @real_x = $game_map.x_with_direction(@x, reverse_dir(d))
    @real_y = $game_map.y_with_direction(@y, reverse_dir(d))
    @moved = player?
end
#--------------------------------------------------------------------------
# * Overwrite method: update_move_diagonal
#--------------------------------------------------------------------------
def update_move_diagonal
    return if moving? || @move_list.empty?
    return if @move_list.first[ :D ].size < 2
    @move_value = @move_list.shift
    horz        = @move_value[ :D ].first
    vert        = @move_value[ :D ].last
    move_diagonal_pixel(horz, vert) if diagonal_passable?(x, y, horz, vert)
end
#--------------------------------------------------------------------------
# * New method: move_diagonal_pixel
#--------------------------------------------------------------------------
def move_diagonal_pixel(horz, vert)
    @diagonal_move = true
    setup_movement(horz, vert)
    @real_x = $game_map.x_with_direction(@x, reverse_dir(horz))
    @real_y = $game_map.y_with_direction(@y, reverse_dir(vert))
    @moved = player?
end
#--------------------------------------------------------------------------
# * New method: character_collision?
#--------------------------------------------------------------------------
def character_collision?(x, y, d)
    x2 = $game_map.round_x_with_direction(x, d)
    y2 = $game_map.round_y_with_direction(y, d)
    @through || debug_through? || !collide_with_characters?(x2, y2)
end
#--------------------------------------------------------------------------
# * New method: step_times
#--------------------------------------------------------------------------
def step_times
    return 8
end
#--------------------------------------------------------------------------
# * New method: near_nt?
#--------------------------------------------------------------------------
def near_nt?(x, y)
    near?(x, y) && !@through
end
#--------------------------------------------------------------------------
# * New method: near?
#--------------------------------------------------------------------------
def near?(x, y)
    w = step_over? ? [bw * 0.625, 0.5].max : [bw, 1.0].max
    h = step_over? ? [bh * 0.625, 0.5].max : [bh, 1.0].max
    @real_x > x - w && @real_x < x + w && @real_y > y - h && @real_y < y + h
end
#--------------------------------------------------------------------------
# * New method: setup_movement
#--------------------------------------------------------------------------
def setup_movement(horz, vert)
    @x = $game_map.round_x_with_direction(@x, horz)
    @y = $game_map.round_y_with_direction(@y, vert)
    add_next_movement(horz == vert ? horz : [horz, vert])
    set_direction(horz) if @direction == reverse_dir(horz) || horz == vert
    set_direction(vert) if @direction == reverse_dir(vert) && horz != vert
    follower_control_move_update(horz, vert)
    increase_steps
end
#--------------------------------------------------------------------------
# * New method: check_event_trigger_move
#--------------------------------------------------------------------------
def check_event_trigger_move(d)
    set_direction(d)
    check_event_trigger_touch_front
end
#--------------------------------------------------------------------------
# * New method: collision_condition?
#--------------------------------------------------------------------------
def collision_condition?(x, y, bw, bh, event, event_id, side)
    return false if event && self.id == event_id
    return false unless collision?(x, y, bw, bh)
    return false unless normal_priority? || event
    return false if side && !side_collision?
    return true
end
#--------------------------------------------------------------------------
# * New method: follower_control_move_update
#--------------------------------------------------------------------------
def follower_control_move_update(horz, vert)
    return unless $imported[:ve_followers_options]
    return unless player? || follower?
    add_move_update(horz == vert ? [horz] : [horz, vert])
end
#--------------------------------------------------------------------------
# * New method: passable?
#--------------------------------------------------------------------------
def passable?(x, y, d)
    x = fix_position(x)
    y = fix_position(y)
    passable1 = passable_tile?(x, y, d)
    passable2 = character_collision?(x, y, d)
    fix_movement(x, y, d) if player? && !passable1 && passable2
    fix_collision(x, y, d) if player? && !passable2 && passable1
    passable1 && passable2
end
#--------------------------------------------------------------------------
# * New method: passable_tile?
#--------------------------------------------------------------------------
def passable_tile?(x, y, d)
    result = true
    result = passable_down?(x, y) if d == 2
    result = passable_left?(x, y) if d == 4
    result = passable_right?(x, y) if d == 6
    result = passable_up?(x, y)    if d == 8
    result
end
#--------------------------------------------------------------------------
# * New method: locked_tile?
#--------------------------------------------------------------------------
def locked_tile?(x, y, d = 0)
    list = [2, 4, 6, 8] - [d]
    list.all? {|d| !map_passable?(x, y, d) }
end
#--------------------------------------------------------------------------
# * New method: locked_move?
#--------------------------------------------------------------------------
def locked_move?(x, y)
    !passable_down?(x, y) && !passable_left?(x, y)
    !passable_right?(x, y) && !passable_up?(x, y)
end
#--------------------------------------------------------------------------
# * New method: passable_down?
#--------------------------------------------------------------------------
def passable_down?(x, y)
    passable_normal?(x.ceil, y.to_i, 2, 4, x.ceil?) &&
    passable_normal?(x.to_i, y.to_i, 2, 6, x.ceil?)
end
#--------------------------------------------------------------------------
# * New method: passable_left?
#--------------------------------------------------------------------------
def passable_left?(x, y)
    passable_normal?(x.ceil, y.ceil, 4, 8, y.ceil?) &&
    passable_normal?(x.ceil, y.to_i, 4, 2, y.ceil?)
end
#--------------------------------------------------------------------------
# * New method: passable_right?
#--------------------------------------------------------------------------
def passable_right?(x, y)
    passable_normal?(x.to_i, y.ceil, 6, 8, y.ceil?) &&
    passable_normal?(x.to_i, y.to_i, 6, 2, y.ceil?)
end
#--------------------------------------------------------------------------
# * New method: passable_up?
#--------------------------------------------------------------------------
def passable_up?(x, y)
    passable_normal?(x.ceil, y.ceil, 8, 4, x.ceil?) &&
    passable_normal?(x.to_i, y.ceil, 8, 6, x.ceil?)
end
#--------------------------------------------------------------------------
# * New method: passable_normal?
#--------------------------------------------------------------------------
def passable_normal?(x, y, d, d2, ceil = false)
    x1 = $game_map.round_x(x)
    y1 = $game_map.round_y(y)
    x2 = $game_map.check_x_with_direction(x1, d)
    y2 = $game_map.check_y_with_direction(y1, d)
    x3 = $game_map.round_x_with_direction(x1, d)
    y3 = $game_map.round_y_with_direction(y1, d)
    return false unless $game_map.valid?(x3, y3)
    return true if @through || debug_through?
    return false unless map_passable?(x2, y2, d2) || !ceil
    return false unless move_passable1?(x1, y1, x2, y2, d)
    return false unless move_passable2?(x1, y1, x2, y2, d)
    return true
end
#--------------------------------------------------------------------------
# * New method: move_passable1?
#--------------------------------------------------------------------------
def move_passable1?(x1, y1, x2, y2, d)
    map_passable?(x1, y1, d) || map_passable?(x2, y2, d)
end
#--------------------------------------------------------------------------
# * New method: move_passable?
#--------------------------------------------------------------------------
def move_passable2?(x1, y1, x2, y2, d)
    map_passable?(x2, y2, reverse_dir(d)) && (map_passable?(x1, y1, d) ||
    locked_tile?(x1, y1))
end
#--------------------------------------------------------------------------
# * New method: fix_movement
#--------------------------------------------------------------------------
def fix_movement(x, y, d)
    return if (@diagonal && @diagonal != 0) || @diagonal_move
    fix_movement_horiz(x, y, d) if (d == 2 || d == 8) && x.ceil?
    fix_movement_vert(x, y, d) if (d == 4 || d == 6) && y.ceil?
end
#--------------------------------------------------------------------------
# * New method: fix_movement_horiz
#--------------------------------------------------------------------------
def fix_movement_horiz(x, y, d)
    adjust = x - x.to_i
    fix_move_straight(4) if fix_movement_left?(x, y, d) && adjust < 0.5
    fix_move_straight(6) if fix_movement_right?(x, y, d) && adjust > 0.5
end
#--------------------------------------------------------------------------
# * New method: fix_movement_ver
#--------------------------------------------------------------------------
def fix_movement_vert(x, y, d)
    adjust = y - y.to_i
    fix_move_straight(2) if fix_movement_down?(x, y, d) && adjust > 0.5
    fix_move_straight(8) if fix_movement_up?(x, y, d)   && adjust < 0.5
end
#--------------------------------------------------------------------------
# * New method: fix_movement_down?
#--------------------------------------------------------------------------
def fix_movement_down?(x, y, d)
    passable_normal?(x.to_i, y.ceil, d, 0, false) && movement_fix?(x, y, 2)
end
#--------------------------------------------------------------------------
# * New method: fix_movement_left?
#--------------------------------------------------------------------------
def fix_movement_left?(x, y, d)
    passable_normal?(x.to_i, y.to_i, d, 0, false) && movement_fix?(x, y, 4)
end
#--------------------------------------------------------------------------
# * New method: fix_movement_right?
#--------------------------------------------------------------------------
def fix_movement_right?(x, y, d)
    passable_normal?(x.ceil, y.to_i, d, 0, false) && movement_fix?(x, y, 6)
end
#--------------------------------------------------------------------------
# * New method: fix_movement_up?
#--------------------------------------------------------------------------
def fix_movement_up?(x, y, d)
    passable_normal?(x.to_i, y.to_i, d, 0, false) && movement_fix?(x, y, 8)
end
#--------------------------------------------------------------------------
# * New method: movement_fix?
#--------------------------------------------------------------------------
def movement_fix?(x, y, d)
    passable_tile?(x, y, d) && character_collision?(x, y, d)
end
#--------------------------------------------------------------------------
# * New method: fix_collision
#--------------------------------------------------------------------------
def fix_collision(x, y, d)
    return if (@diagonal && @diagonal != 0) || @diagonal_move
    @side_collision = true
    fix_collision_horiz(x, y, d) if (d == 2 || d == 8)
    fix_collision_vert(x, y, d) if (d == 4 || d == 6)
    @side_collision = false
end
#--------------------------------------------------------------------------
# * New method: fix_collision_horiz
#--------------------------------------------------------------------------
def fix_collision_horiz(x, y, d)
    fix_move_straight(4) if fix_collision_left?(x, y, d)
    fix_move_straight(6) if fix_collision_right?(x, y, d)
end
#--------------------------------------------------------------------------
# * New method: fix_collision_vert
#--------------------------------------------------------------------------
def fix_collision_vert(x, y, d)
    fix_move_straight(2) if fix_collision_down?(x, y, d)
    fix_move_straight(8) if fix_collision_up?(x, y, d)
end
#--------------------------------------------------------------------------
# * New method: fix_collision_down?
#--------------------------------------------------------------------------
def fix_collision_down?(x, y, d)
    !character_collision?(x, y, d) && collision_fix?(x, y, d, 2)
end
#--------------------------------------------------------------------------
# * New method: fix_collision_left?
#--------------------------------------------------------------------------
def fix_collision_left?(x, y, d)
    !character_collision?(x, y, d) && collision_fix?(x, y, d, 4)
end
#--------------------------------------------------------------------------
# * New method: fix_collision_right?
#--------------------------------------------------------------------------
def fix_collision_right?(x, y, d)
    !character_collision?(x, y, d) && collision_fix?(x, y, d, 6)
end
#--------------------------------------------------------------------------
# * New method: fix_collision_up?
#--------------------------------------------------------------------------
def fix_collision_up?(x, y, d)
    !character_collision?(x, y, d) && collision_fix?(x, y, d, 8)
end
#--------------------------------------------------------------------------
# * New method: collision_fix?
#--------------------------------------------------------------------------
def collision_fix?(x, y, d, d2)
    side_collision_fix?(x, y, d, d2, 2) && side_fix?(x, y, d2)
end
#--------------------------------------------------------------------------
# * New method: side_collision_fix?
#--------------------------------------------------------------------------
def side_collision_fix?(x, y, d, d2, t)
    t.times.any? do |i|
      x2, y2 = x, y
      y2 += (t - i) * 0.125 if d2 == 2
      x2 -= (t - i) * 0.125 if d2 == 4
      x2 += (t - i) * 0.125 if d2 == 6
      y2 -= (t - i) * 0.125 if d2 == 8
      character_collision?(x2, y2, d)
    end
end
#--------------------------------------------------------------------------
# * New method: side_fix?
#--------------------------------------------------------------------------
def side_fix?(x, y, d)
    passable_tile?(x, y, d) && character_collision?(x, y, d)
end
#--------------------------------------------------------------------------
# * New method: fix_move_straight
#--------------------------------------------------------------------------
def fix_move_straight(d)
    return if moving?
    @x = $game_map.round_x_with_direction(@x, d)
    @y = $game_map.round_y_with_direction(@y, d)
    follower_control_move_update(d, d)
    add_next_movement(d)
    increase_steps
    @moved = player?
end
#--------------------------------------------------------------------------
# * New method: add_next_movement
#--------------------------------------------------------------------------
def add_next_movement(d)
    return unless follower? || player?
    return if $imported[:ve_followers_control]# && follower_control_block
    @next_movement.push(d)
end
#--------------------------------------------------------------------------
# * New method: follower_control_block
#--------------------------------------------------------------------------
def follower_control_block
    return true if follower? && origin_position
    return true if $game_player.followers.gathering_origin?
    return false
end
#--------------------------------------------------------------------------
# * New method: front_collision?
#--------------------------------------------------------------------------
def front_collision?(x, y, d)
    return false if (@diagonal && @diagonal != 0) || @diagonal_move
    result = !front_collision_horiz(x, y, d) if (d == 2 || d == 8)
    result = !front_collision_vert(x, y, d) if (d == 4 || d == 6)
    result
end
#--------------------------------------------------------------------------
# * New method: front_collision_horiz
#--------------------------------------------------------------------------
def front_collision_horiz(x, y, d)
    side_collision_fix?(x, y, d, 4, 4) || side_collision_fix?(x, y, d, 6, 4)
end
#--------------------------------------------------------------------------
# * New method: front_collision_vert
#--------------------------------------------------------------------------
def front_collision_vert(x, y, d)
    side_collision_fix?(x, y, d, 2, 4) || side_collision_fix?(x, y, d, 8, 4)
end
#--------------------------------------------------------------------------
# * New method: step_over?
#--------------------------------------------------------------------------
def step_over?
    @through
end
#--------------------------------------------------------------------------
# * New method: bw
#--------------------------------------------------------------------------
def bw
    setup_bitmap_dimension unless @bw && character_name == @character_name_wh
    @bw
end
#--------------------------------------------------------------------------
# * New method: bh
#--------------------------------------------------------------------------
def bh
    setup_bitmap_dimension unless @bh && character_name == @character_name_wh
    @bh
end
#--------------------------------------------------------------------------
# * New method: setup_bitmap_dimension
#--------------------------------------------------------------------------
def setup_bitmap_dimension
    @character_name_wh = character_name
    bitmap = Cache.character(character_name).clone
    sign = @character_name[/^[\!\$]./]
    if character_name != "" && @tile_id == 0 && sign && sign.include?('$')
      @bw = bitmap.width / 32.0 / frames
      @bh = bitmap.height / 32.0 / 4
    elsif character_name != "" && @tile_id == 0
      @bw = bitmap.width / 32.0 / (frames * 4)
      @bh = bitmap.height / 32.0 / 8
    else
      @bw = 1.0
      @bh = 1.0
    end
    bitmap.dispose
end
#--------------------------------------------------------------------------
# * New method: collision?
#--------------------------------------------------------------------------
def collision?(x, y, w, h)
    ax1, ay1, ax2, ay2 = setup_rect(x, y, w, h)
    bx1, by1, bx2, by2 = setup_rect(@x, @y, bw, bh)
    ax2 > bx1 && ax1 < bx2 && ay2 > by1 && ay1 < by2
end
#--------------------------------------------------------------------------
# * New method: over?
#--------------------------------------------------------------------------
def over?(x, y)
    ax1, ay1, ax2, ay2 = setup_rect(x, y - 0.125, 0, 0)
    bx1, by1, bx2, by2 = setup_rect(@real_x, @real_y, bw, bh - 0.125)
    ax2 >= bx1 && ax1 <= bx2 && ay2 >= by1 && ay1 <= by2
end
#--------------------------------------------------------------------------
# * New method: setup_rect
#--------------------------------------------------------------------------
def setup_rect(x, y, w, h)
    x1 = x - w / 2.0
    y1 = y - h
    x2 = x1 + w
    y2 = y1 + h
    [x1, y1, x2, y2]
end
#--------------------------------------------------------------------------
# * New method: align_with
#--------------------------------------------------------------------------
def align_with(x, y)
    d = @direction
    @x = $game_map.round_x_with_direction(x, 0) if d == 2 || d == 8
    @y = $game_map.round_y_with_direction(y, 0) if d == 6 || d == 4
    dx = (d == 2 || d == 8) ? (@x - @real_x) / 0.125 : 0
    dy = (d == 4 || d == 6) ? (@y - @real_y) / 0.125 : 0
    set_direction(dx > 0 ? 6 : dx < 0 ? 4 : dy > 0 ? 2 : dy < 0 ? 8 : d)
    @real_x = $game_map.x_with_direction(@x, reverse_dir(@direction), dx.abs)
    @real_y = $game_map.y_with_direction(@y, reverse_dir(@direction), dy.abs)
    update_for_align while moving?
    @direction = d
end
#--------------------------------------------------------------------------
# * New method: update_for_align
#--------------------------------------------------------------------------
def update_for_align
    SceneManager.scene.update_basic
    SceneManager.scene.spriteset.update
    $game_map.update(true)
    $game_timer.update
    update_animation
    update_move
end
#--------------------------------------------------------------------------
# * New method: fix_position
#--------------------------------------------------------------------------
def fix_position(n)
    (n * 64 / 8).round / 8.0
end
end

#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
# This class handles maps. It includes event starting determinants and map
# scrolling functions. The instance of this class is referenced by $game_map.
#==============================================================================

class Game_Player < Game_Character
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :over_event
attr_accessor :land_test
#--------------------------------------------------------------------------
# * Overwrite method: check_event_trigger_there
#--------------------------------------------------------------------------
def check_event_trigger_there(triggers)
    x2 = $game_map.round_x_with_direction(@x, @direction)
    y2 = $game_map.round_y_with_direction(@y, @direction)
    start_map_event(x2, y2, triggers, true)
    return if $game_map.any_event_starting?
    return unless counter_tile?
    x3 = $game_map.check_x_with_direction(x2, @direction)
    y3 = $game_map.check_y_with_direction(y2, @direction)
    start_map_event(x3, y3, triggers, true)
end
#--------------------------------------------------------------------------
# * Overwrite method: start_map_event
#--------------------------------------------------------------------------
def start_map_event(x, y, triggers, normal)
    return if $game_map.interpreter.running?
    $game_map.events_xy(x, y).each do |event|
      event.start if check_event_contiontion(x, y, event, triggers, normal)
    end
end
#--------------------------------------------------------------------------
# * Overwrite method: update_nonmoving
#--------------------------------------------------------------------------
def update_nonmoving(last_moving)
    return if $game_map.interpreter.running?
    moved = @moved
    @moved = false
    if last_moving || moved
      $game_party.on_player_walk
      return if check_touch_event
    end
    if movable? && Input.trigger?:)C)
      return if get_on_off_vehicle
      return if check_action_event
    end
    @over_event -= 1 if @over_event > 0 && (last_moving || moved)
    update_encounter if last_moving || moved
end
#--------------------------------------------------------------------------
# * Overwrite method: get_on_vehicle
#--------------------------------------------------------------------------
def get_on_vehicle
    setup_vehicle
    enter_vehicle if vehicle
    @vehicle_getting_on
end
#--------------------------------------------------------------------------
# * Overwrite method: increase_steps
#--------------------------------------------------------------------------
def increase_steps
    super
    if normal_walk?
      @steps += 1
      $game_player.damage_floor = 0 unless on_damage_floor?
      $game_player.damage_floor += 1
      $game_party.increase_steps if @steps % 8 == 0
    end
end
#--------------------------------------------------------------------------
# * Alias method: clear_transfer_info
#--------------------------------------------------------------------------
alias :clear_transfer_info_ve_pixel_movement :clear_transfer_info
def clear_transfer_info
    clear_transfer_info_ve_pixel_movement
    clear_next_movement
end
#--------------------------------------------------------------------------
# * Alias method: update
#--------------------------------------------------------------------------
alias :update_ve_gp_pixel_movement :update
def update
    @followers.move unless $imported[:ve_followers_options]
    update_ve_gp_pixel_movement
end
#--------------------------------------------------------------------------
# * Alias method: move_by_input
#--------------------------------------------------------------------------
alias :move_by_input_ve_gp_pixel_movement :move_by_input
def move_by_input
    return unless @move_list.empty?
    move_by_input_ve_gp_pixel_movement
end
#--------------------------------------------------------------------------
# * Alias method: move_by_input
#--------------------------------------------------------------------------
alias :update_vehicle_get_on_ve_gp_pixel_movement :update_vehicle_get_on
def update_vehicle_get_on
    return unless @move_list.empty?
    @followers.gather   unless @followers.gathered?
    @through = false    if @followers.gathered?
    clear_next_movement if @followers.gathered?
    update_vehicle_get_on_ve_gp_pixel_movement if @followers.gathered?
end
#--------------------------------------------------------------------------
# * Alias method: update_vehicle_get_off
#--------------------------------------------------------------------------
alias :update_vehicle_get_off_ve_gp_pixel_movement :update_vehicle_get_off
def update_vehicle_get_off
    return unless @move_list.empty?
    @followers.gather   unless @followers.gathered?
    clear_next_movement if @followers.gathered?
    @through = false    if !@followers.gathering? && vehicle.altitude == 0
    update_vehicle_get_off_ve_gp_pixel_movement if @followers.gathered?
end
#--------------------------------------------------------------------------
# * Alias method: get_off_vehicle
#--------------------------------------------------------------------------
alias :get_off_vehicle_ve_gp_pixel_movement :get_off_vehicle
def get_off_vehicle
    result = get_off_vehicle_ve_gp_pixel_movement
    clear_vehicle_off if result
    result
end
#--------------------------------------------------------------------------
# * New method: clear_vehicle_off
#--------------------------------------------------------------------------
def clear_vehicle_off
    @through = true
    clear_next_movement
    @followers.synchronize(@x, @y, @direction)
end
#--------------------------------------------------------------------------
# * New method: check_event_contiontion
#--------------------------------------------------------------------------
def check_event_contiontion(x, y, event, triggers, normal)
    passable = passable_tile?(@x, @y, @direction)
    w = (counter_tile? || !passable) ? 1.0 : bw
    h = (counter_tile? || !passable) ? 1.0 : bh
    return false unless event.trigger_in?(triggers)
    return false unless event.event_priority?(normal)
    return false unless passable || event.over_tile? || counter_tile?
    return false unless event.collision?(x, y, w, h) || !jumping?
    return false unless !event.in_front? || front_collision?(x, y, @direction)
    return true
end
#--------------------------------------------------------------------------
# * New method: counter_tile?
#--------------------------------------------------------------------------
def counter_tile?
    x = $game_map.check_x_with_direction(@x, @direction)
    y = $game_map.check_y_with_direction(@y, @direction)
    $game_map.counter?(x, y)
end
#--------------------------------------------------------------------------
# * New method: setup_vehicle
#--------------------------------------------------------------------------
def setup_vehicle
    $game_map.vehicles.compact.each do |vehicle|
      next unless vehicle.enter_vechicle?(@x, @y, @direction)
      @vehicle_type = vehicle.type
      break if vehicle
    end
end
#--------------------------------------------------------------------------
# * New method: enter_vehicle
#--------------------------------------------------------------------------
def enter_vehicle
    align_with(vehicle.x, vehicle.y) unless in_airship?
    @vehicle_getting_on = true
    force_move_forward unless in_airship?
    @through = true
    @followers.gather
end
#--------------------------------------------------------------------------
# * New method: clear_next_movement
#--------------------------------------------------------------------------
def clear_next_movement
    @next_movement.clear
    @followers.clear_move_list
    @followers.clear_next_movement
end
#--------------------------------------------------------------------------
# * New method: step_times
#--------------------------------------------------------------------------
def step_times
    (move_route_forcing || not_driving?) ? super : 1
end
#--------------------------------------------------------------------------
# * New method: not_driving?
#--------------------------------------------------------------------------
def not_driving?
    vehicle && !vehicle.driving
end
#--------------------------------------------------------------------------
# * New method: move_straight
#--------------------------------------------------------------------------
def move_straight(d, turn_ok = true)
    super
end
#--------------------------------------------------------------------------
# * New method: move_diagonal
#--------------------------------------------------------------------------
def move_diagonal(horz, vert)
    super
end
#--------------------------------------------------------------------------
# * New method: setup_bitmap_dimension
#--------------------------------------------------------------------------
def setup_bitmap_dimension
    @bw = VE_PLAYER_BIG_COLLISION ? 1.0 : 0.75
    @bh = VE_PLAYER_BIG_COLLISION ? 1.0 : 0.75
end
end

#==============================================================================
# ** Game_Follower
#------------------------------------------------------------------------------
# This class handles the followers. Followers are the actors of the party
# that follows the leader in a line. It's used within the Game_Followers class.
#==============================================================================

class Game_Follower < Game_Character
#--------------------------------------------------------------------------
# * Overwrite method: chase_preceding_character
#--------------------------------------------------------------------------
def chase_preceding_character
    return if $imported[:ve_followers_control] && cant_follow_character
    return if $imported[:ve_followers_options]
    unless moving? || @move_list.size > 0
      move_size = @preceding_character.next_movement.size
      if move_size >= 8 || (move_size > 0 && gathering?)
        update_chasing
      elsif gathering? && !gathered?
        move_toward_player
        @move_list.clear if gathered?
      end
    end
end
#--------------------------------------------------------------------------
# * New method: update_chasing
#--------------------------------------------------------------------------
def update_chasing
    next_move = @preceding_character.next_movement.shift
    move_straight(next_move) if next_move.numeric?
    move_diagonal(*next_move) if next_move.array?
end
#--------------------------------------------------------------------------
# * New method: gathered?
#--------------------------------------------------------------------------
def gathered?
    pos?($game_player.x, $game_player.y)
end
#--------------------------------------------------------------------------
# * New method: move_straight
#--------------------------------------------------------------------------
def move_straight(d, turn_ok = true)
    super
end
#--------------------------------------------------------------------------
# * New method: move_diagonal
#--------------------------------------------------------------------------
def move_diagonal(horz, vert)
    super
end
#--------------------------------------------------------------------------
# * New method: movement_size
#--------------------------------------------------------------------------
def movement_size
    gathering? ? 0 : 8
end
#--------------------------------------------------------------------------
# * New method: step_times
#--------------------------------------------------------------------------
def step_times
    move_route_forcing ? super : 1
end
#--------------------------------------------------------------------------
# * New method: setup_bitmap_dimension
#--------------------------------------------------------------------------
def setup_bitmap_dimension
    @bw = VE_PLAYER_BIG_COLLISION ? 1.0 : 0.75
    @bh = VE_PLAYER_BIG_COLLISION ? 1.0 : 0.75
end
end

#==============================================================================
# ** Game_Followers
#------------------------------------------------------------------------------
# This class handles the followers. It's a wrapper for the built-in class
# "Array." It's used within the Game_Player class.
#==============================================================================

class Game_Followers
#--------------------------------------------------------------------------
# * New method: clear_next_movement
#--------------------------------------------------------------------------
def clear_next_movement
    each {|follower| follower.next_movement.clear }
end
#--------------------------------------------------------------------------
# * New method: clear_move_list
#--------------------------------------------------------------------------
def clear_move_list
    each {|follower| follower.move_list.clear }
end
#--------------------------------------------------------------------------
# * New method: gathered?
#--------------------------------------------------------------------------
def gathered?
    @data.all? {|follower| follower.gathered? }
end
end

#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
# This class deals with events. It handles functions including event page
# switching via condition determinants, and running parallel process events.
# It's used within the Game_Map class.
#==============================================================================

class Game_Event < Game_Character
#--------------------------------------------------------------------------
# * Overwrite method: collide_with_player_characters?
#--------------------------------------------------------------------------
def collide_with_player_characters?(x, y)
    normal_priority? && player_collision?(x, y)
end
#--------------------------------------------------------------------------
# * Alias method: start
#--------------------------------------------------------------------------
alias :start_ve_pixel_movement :start
def start
    start_ve_pixel_movement
    $game_player.over_event = 8 if step_over? && !step_trigger?
end
#--------------------------------------------------------------------------
# * Alias method: setup_page_settings
#--------------------------------------------------------------------------
alias :setup_page_settings_ve_pixel_movement :setup_page_settings
def setup_page_settings
    setup_page_settings_ve_pixel_movement
    @move_steps   = note =~ /<MOVE STEPS: (\d+)>/i ? $1.to_i : nil
    @step_trigger = note =~ /<EACH STEP TRIGGER>/i ? true : false
    @in_front     = note =~ /<FRONT COLLISION>/i   ? true : false
    @over_tile    = note =~ /<OVER TILE>/i         ? true : false
    @side_fix     = note =~ /<NO SIDE COLLISION FIX>/i ? false : true
end
#--------------------------------------------------------------------------
# * New method: player_collision?
#--------------------------------------------------------------------------
def player_collision?(x, y)
    $game_map.actors.any? {|actor| actor.collision?(x, y, bh, bw)}
end
#--------------------------------------------------------------------------
# * New method: event_priority?
#--------------------------------------------------------------------------
def event_priority?(normal)
    (normal_priority? == normal || (@through && !normal)) &&
    (normal_priority? || @trigger == 0 || $game_player.over_event == 0)
end
#--------------------------------------------------------------------------
# * New method: check_event_trigger_touch
#--------------------------------------------------------------------------
def check_event_trigger_touch(x, y)
    return if $game_map.interpreter.running?
    if @trigger == 2 && $game_player.collision?(x, y, bh, bw)
      start if !jumping? && normal_priority?
    end
end
#--------------------------------------------------------------------------
# * New method: step_over?
#--------------------------------------------------------------------------
def step_over?
    super || (@character_name == "" && @tile_id == 0) || @priority_type == 0
end
#--------------------------------------------------------------------------
# * New method: step_times
#--------------------------------------------------------------------------
def step_times
    @move_steps ? @move_steps : super
end
#--------------------------------------------------------------------------
# * New method: step_trigger?
#--------------------------------------------------------------------------
def step_trigger?
    @step_trigger
end
#--------------------------------------------------------------------------
# * New method: in_front?
#--------------------------------------------------------------------------
def in_front?
    @in_front
end
#--------------------------------------------------------------------------
# * New method: over_tile?
#--------------------------------------------------------------------------
def over_tile?
    @over_tile
end
#--------------------------------------------------------------------------
# * New method: side_collision?
#--------------------------------------------------------------------------
def side_collision?
    @side_fix
end
#--------------------------------------------------------------------------
# * New method: setup_bitmap_dimension
#--------------------------------------------------------------------------
def setup_bitmap_dimension
    regexp = /<EVENT SIZE: (\d+), (\d+)>/i
    note   =~ regexp ? setup_custom_dimension($1.to_i, $2.to_i) : super
end
#--------------------------------------------------------------------------
# * New method: setup_custom_dimension
#--------------------------------------------------------------------------
def setup_custom_dimension(x, y)
    x1 = (x / 8).to_i
    y1 = (y / 8).to_i
    @bw = x1 / 4.0
    @bh = y1 / 4.0
end
end

#==============================================================================
# ** Game_Vehicle
#------------------------------------------------------------------------------
# This class handles vehicles. It's used within the Game_Map class. If there
# are no vehicles on the current map, the coordinates is set to (-1,-1).
#==============================================================================

class Game_Vehicle < Game_Character
#--------------------------------------------------------------------------
# * Overwrite method: land_ok?
#--------------------------------------------------------------------------
def land_ok?(x, y, d)
    @type == :airship ? airship_landable?(x, y) : check_landable?(x, y, d)
end
#--------------------------------------------------------------------------
# * New method: land_test
#--------------------------------------------------------------------------
def land_test
    @land_test
end
#--------------------------------------------------------------------------
# * New method: step_over?
#--------------------------------------------------------------------------
def step_over?
    above? || super
end
#--------------------------------------------------------------------------
# * New method: check_landable?
#--------------------------------------------------------------------------
def check_landable?(x, y, d)
    x2 = $game_map.check_x_with_direction(x, d)
    y2 = $game_map.check_y_with_direction(y, d)
    @land_test = true
    result = passable?(x2, y2, d)
    @land_test = false
    result
end
#--------------------------------------------------------------------------
# * New method: airship_landable?
#--------------------------------------------------------------------------
def airship_landable?(x, y)
    [2, 4, 6, 8].any? {|d| passable?(x, y, d) }
end
#--------------------------------------------------------------------------
# * New method: passable_normal?
#--------------------------------------------------------------------------
def passable_normal?(x, y, d ,d2, ceil = false)
    @land_test ? landable_normal?(x, y, d ,d2, ceil) : super(x, y, d ,d2, ceil)
end
#--------------------------------------------------------------------------
# * New method: landable_normal?
#--------------------------------------------------------------------------
def landable_normal?(x, y, d ,d2, ceil)
    x1 = $game_map.round_x(x)
    y1 = $game_map.round_y(y)
    return false unless $game_map.valid?(x1, y1)
    return true if @through || debug_through?
    return false unless map_passable?(x1, y1, d)
    return false unless map_passable?(x1, y1, d2) || !ceil
    return false unless map_passable?(x1, y1, reverse_dir(d))
    return true
end
#--------------------------------------------------------------------------
# * New method: enter_vechicle?
#--------------------------------------------------------------------------
def enter_vechicle?(x, y, d)
    return false if @map_id != $game_map.map_id
    x2 = $game_map.round_x_with_direction(x, d)
    y2 = $game_map.round_y_with_direction(y, d)
    x3 = $game_map.check_x_with_direction(@x, reverse_dir(d))
    y3 = $game_map.check_y_with_direction(@y, reverse_dir(d))
    ( above? && collision?(x, y - 0.125, bw * 0.75, bh * 0.75)) ||
    (!above? && collision?(x2, y2, bw, bh) && map_passable?(x3, y3, d))
end
#--------------------------------------------------------------------------
# * New method: collision_condition?
#--------------------------------------------------------------------------
def collision_condition?(x, y, bw, bh, player)
    return false if step_over?
    return false if player.player? && self == player.vehicle
    return false if !collision?(x, y, bw, bh)
    return true
end
end

Euphoria I assume you posted that before I edited spoiler tags in, or else I am misunderstanding what you mean.
Evgenij

#7 Aug 28, 2014, 08:34 AM Source

In theos script change this:

class Game_Player < Game_Character def front_x $game_map.round_x_with_direction(@x,@direction) end def front_y $game_map.round_y_with_direction(@y,@direction) end endto this:

class Game_Player < Game_Character def front_x $game_map.check_x_with_direction(@x,@direction) end def front_y $game_map.check_y_with_direction(@y,@direction) end endIt requires the pixelmovement by victor. and the player needs to stand perfectly before the event.
LanceGardner

#8 Aug 28, 2014, 10:07 AM Source

Firstly, thank you very much for your help. Your solution does work (to some extent), as the text now appears at least. However, you still need to be very precise with facing the object, and from the side particularly, it can be difficult to line-up right. Is there any way to make it a bit less strict in its detection?

Once again, thank you VERY much for your help.
Evgenij

#9 Aug 28, 2014, 10:23 AM Source

Just add .round to the values:

class Game_Player < Game_Character   def front_x    $game_map.check_x_with_direction(@x,@direction).round end   def front_y    $game_map.check_y_with_direction(@y,@direction).round end endEdit:

And you may change this:

def below_or_above_player?    self.x == $game_player.x && self.y == $game_player.y endto this:

def below_or_above_player?    self.x == $game_player.x.round && self.y == $game_player.y.round endTo make "Below Player"-Events not so strict.
LanceGardner

#10 Aug 28, 2014, 10:26 AM Source

Thank you! Now the script works exactly as I'd like. I've linked to this thread in the Script Author's blog in case anybody else has this problem too.