Save-Point

Save-Point
Full Version: Save-Point
You're currently viewing a stripped down version of our content. View the full version with proper formatting.
Board Message
Sorry, you do not have permission to access this resource.
Save-Point
Save-Point - 8 Way Pixelmovement Script

Save-Point

Save-Point > Material Development > Scripts Database > Script Requests > 8 Way Pixelmovement Script
Full Version: 8 Way Pixelmovement Script
You're currently viewing a stripped down version of our content. View the full version with proper formatting.

Ryu-ka

04-16-2010, 04:57 AM
So basically I've been in need for a pixelmovement script that's compatible with this script:

Current 8 Way Script

I'm not exactly sure why, but the other pixelmovement scripts I've tried using glitch whenever I try to us it with the current 8 way script.

Edit: Also, if it helps to know, I also have ParaDog's dash charset script.

Dash Script

sakhawat21

06-03-2010, 08:10 PM
Well, first remove those scripts from your script database. Now, paste the following above main (NOTE: I don't mean to insert a new script! Just make a new line above all the contents including the comments and paste the script.)

Code:
#==============================================================================
# ¡ Sprite_Shadow (Sprite_Ombre )
# Based on Genzai Kawakami's shadows, dynamisme&features by Rataime, extra features Boushy
#==============================================================================

CATERPILLAR_COMPATIBLE = true

class Game_Party
attr_reader :characters
end

class Sprite_Shadow < RPG::Sprite

attr_accessor :character

def initialize(viewport, character = nil,source = nil,anglemin=0,anglemax=0,distancemax=0)
   super(viewport)
   @anglemin=anglemin.to_f
   @anglemax=anglemax.to_f
   @distancemax=distancemax.to_f
   @character = character
   @source = source
   update
end

def update
   super
  
   if @tile_id != @character.tile_id or
      @character_name != @character.character_name or
      @character_hue != @character.character_hue
     @tile_id = @character.tile_id
     @character_name = @character.character_name
     @character_hue = @character.character_hue
     if @tile_id >= 384
       self.bitmap = RPG::Cache.tile($game_map.tileset_name,
         @tile_id, @character.character_hue)
       self.src_rect.set(0, 0, 32, 32)
       self.ox = 16
       self.oy = 32
     else
       self.bitmap = RPG::Cache.character(@character.character_name,
         @character.character_hue)
       @cw = bitmap.width / 4
       @ch = bitmap.height / 4
       self.ox = @cw / 2
       self.oy = @ch
     end
   end
   self.visible = (not @character.transparent)
   if @tile_id == 0
     sx = @character.pattern * @cw
     sy = (@character.direction - 2) / 2 * @ch
     if self.angle>90 or angle<-90
       if @character.direction== 6
              sy = ( 4- 2) / 2 * @ch
       end
       if @character.direction== 4
              sy = ( 6- 2) / 2 * @ch
       end
       if @character.direction== 2
              sy = ( 8- 2) / 2 * @ch
       end
       if @character.direction== 8
              sy = ( 2- 2) / 2 * @ch
       end
     end
     self.src_rect.set(sx, sy, @cw, @ch)
   end
   self.x = @character.screen_x
   self.y = @character.screen_y-5
   self.z = @character.screen_z(@ch)-1
   self.opacity = @character.opacity
   self.blend_type = @character.blend_type
   self.bush_depth = @character.bush_depth
   if @character.animation_id != 0
     animation = $data_animations[@character.animation_id]
     animation(animation, true)
     @character.animation_id = 0
   end
   @deltax=@source.x-self.x
   @deltay= @source.y-self.y
   self.angle = 57.3*Math.atan2(@deltax, @deltay )
   @angle_trigo=self.angle+90
   if @angle_trigo<0
     @angle_trigo=360+@angle_trigo
   end
   self.color = Color.new(0, 0, 0)
   @distance = ((@deltax ** 2) + (@deltay ** 2))
   if$game_map.shadows==-1
     self.opacity = 0
   else
     self.opacity = 1200000/(@distance+6000)  
   end
   @distance = @distance ** 0.5
   if @distancemax !=0 and @distance>=@distancemax
     self.opacity=0
   end
   if @anglemin !=0 or @anglemax !=0
      if (@angle_trigo<@anglemin or @angle_trigo>@anglemax) and @anglemin<@anglemax
        self.opacity=0
      end
      if (@angle_trigo<@anglemin and @angle_trigo>@anglemax) and @anglemin>@anglemax
        self.opacity=0
      end    
   end
end
end

#===================================================
# ¥ CLASS Sprite_Character edit
#===================================================

class Sprite_Character < RPG::Sprite
alias shadow_initialize initialize

def initialize(viewport, character = nil)
   @character = character
   super(viewport)
   @ombrelist=[]
   if (character.is_a?(Game_Event) and character.list!=nil and character.list[0].code == 108 and character.list[0].parameters == ["s"])
     if (character.list[1]!=nil and character.list[1].code == 108)
       @anglemin=character.list[1].parameters[0]
     end
     if (character.list[2]!=nil and character.list[2].code == 108)
       @anglemax=character.list[2].parameters[0]
     end
     if (character.list[3]!=nil and character.list[3].code == 108)
       @distancemax=character.list[3].parameters[0]
     end
    for i in $game_map.events.keys.sort
     if ($game_map.events[i].is_a?(Game_Event) and $game_map.events[i].list!=nil and $game_map.events[i].list[0].code == 108 and $game_map.events[i].list[0].parameters == ["o"])
       @ombrelist[i+1] = Sprite_Shadow.new(viewport, $game_map.events[i],self,@anglemin,@anglemax,@distancemax)
     end
    end
    @ombrelist[1] = Sprite_Shadow.new(viewport, $game_player,self,@anglemin,@anglemax,@distancemax)
#===================================================
# œ Compatibility with fukuyama's caterpillar script
#===================================================
if CATERPILLAR_COMPATIBLE and $game_party.characters!=nil

for member in $game_party.characters
   @ombrelist.push(Sprite_Shadow.new(viewport, member,self,@anglemin,@anglemax,@distancemax))
end

end
#===================================================
# œ End of the compatibility
#===================================================
   end
   shadow_initialize(viewport, @character)
end

alias shadow_update update

def update
   shadow_update
   if @ombrelist!=[]
     for i in 1..@ombrelist.size
       if @ombrelist[i]!=nil
         @ombrelist[i].update
       end
     end
   end
end

end

#===================================================
# ¥ CLASS Scene_Save edit
#===================================================
class Scene_Save < Scene_File

alias shadows_write_save_data write_save_data

def write_save_data(file)
   $game_map.shadows = nil
   shadows_write_save_data(file)
end
end

#===================================================
# ¥ CLASS Game_Map edit
#===================================================
class Game_Map
attr_accessor :shadows
end
#==============================================================================
# ¡ Game_Player
#------------------------------------------------------------------------------
# @ƒvƒŒƒCƒ„[‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·BƒCƒxƒ“ƒg‚Ì‹N“®”»’è‚âAƒ}ƒbƒv‚̃XƒNƒ[ƒ‹‚È‚Ç‚Ì
# ‹@”\‚ðŽ‚Á‚Ä‚¢‚Ü‚·B‚±‚̃Nƒ‰ƒX‚̃Cƒ“ƒXƒ^ƒ“ƒX‚Í $game_player ‚ÅŽQÆ‚³‚ê‚Ü‚·B
#==============================================================================

class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  # œ ’萔
  #--------------------------------------------------------------------------
  UP    = 0                   # ã•ûŒü‚Ì—]—T(0 <= UP <= 63)
  SIDE  = 0                   # ¶‰E•ûŒü‚Ì—]—T(0 <= SIDE <= 63)
  SLANT = false               # ˆÚ“®ƒ‹[ƒg‚̎΂߈ړ®ŽžA‘¬“xC³
  #--------------------------------------------------------------------------
  # œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
  #--------------------------------------------------------------------------
  attr_reader   :walk                     # ƒvƒŒ[ƒ„[ˆÚ“®‘¬“x
  attr_reader   :event                    # ƒCƒxƒ“ƒgŽžˆÚ“®‘¬“x
  attr_accessor :move_speed               # ˆÚ“®‘¬“x
  #--------------------------------------------------------------------------
  # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
  #--------------------------------------------------------------------------
  def initialize
    super
    # @walk:•às‘¬“x @dash:ƒ_ƒbƒVƒ…ŽžˆÚ“®‘¬“x
    # @event:ƒCƒxƒ“ƒgŽžˆÚ“®‘¬“xi0‚ÌŽž‚́AƒCƒxƒ“ƒgŽž‚É‘¬“x•ÏX‚ð‚µ‚È‚¢j
    @walk  = 4
    @dash  = 5
    @event = 4
    @dot_m = true
    @revise_x = 0
    @revise_y = 0
    @move == false
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV
  #--------------------------------------------------------------------------
  alias :update_original :update
  def update
    #ƒ_ƒbƒVƒ…‹@”\BƒGƒ“ƒ^[ƒL[‚ª‰Ÿ‚³‚ê‚Ä‚¢‚éŠÔAˆÚ“®‘¬“x‚ð•ÏX‚·‚éB
    unless moving? or $game_system.map_interpreter.running? or
            @move_route_forcing or $game_temp.message_window_showing
      if @walk != @dash
        if Input.press?(Input::C)
          if @move_speed != @dash
            @move_speed = @dash
          end
        else
          if @move_speed != @walk
            @move_speed = @walk
          end
        end
      end
    end
    if @revise_x == nil and @revise_y == nil
      @revise_x = 0
      @revise_y = 0
    end
    unless @dot_m
      update_original
      return
    end
    if @move_route_forcing
      # ƒ[ƒJƒ‹•Ï”‚Ɉړ®’†‚©‚Ç‚¤‚©‚ð‹L‰¯
      last_moving = moving?
      # ƒ[ƒJƒ‹•Ï”‚ɍÀ•W‚ð‹L‰¯
      last_real_x = @real_x
      last_real_y = @real_y
      # À•W‚ª‚¸‚ê‚Ä‚¢‚éê‡
      if (@revise_x != 0 or @revise_y != 0) and not jumping? and @move == true
        if @revise_x != @real_x - @x * 128 or @revise_y != @real_y - @y * 128
          @revise_x = @real_x - @x * 128
          @revise_y = @real_y - @y * 128
        end
        # ˆÚ“®‹——£distance1‚Æ–Ú•W‹——£distance2‚ðÝ’è
        distance1 = 2 ** @move_speed
        distance2 = Math.sqrt(@revise_x ** 2 + @revise_y ** 2)
        # ˆÚ“®‹——£‚ª–Ú•W‹——£‚ð‰z‚¦‚½ê‡
        if distance1 > distance2
          # ‹­§“I‚ɕ␳À•W‚ð—ë‚É‚·‚é
          @real_x = @real_x - @revise_x
          @real_y = @real_y - @revise_y
          @revise_x = 0
          @revise_y = 0
          anime_update
        # ˆÚ“®‹——£‚ª–Ú•W‹——£‚É’B‚µ‚È‚¢ê‡
        else
          # ˆÚ“®‹——£•ª–Ú•W‹——£‚ɋ߂­
          @real_x -= (distance1 * @revise_x / distance2).round
          @real_y -= (distance1 * @revise_y / distance2).round
          @revise_x = @real_x - @x * 128
          @revise_y = @real_y - @y * 128
          anime_update
        end
      else
        super
      end
    else
      @move = false
      # ˆÚ“®’†AƒCƒxƒ“ƒgŽÀs’†AˆÚ“®ƒ‹[ƒg‹­§’†A
      # ƒƒbƒZ[ƒWƒEƒBƒ“ƒhƒE•\Ž¦’†‚Ì‚¢‚¸‚ê‚Å‚à‚È‚¢ê‡
      unless moving? or $game_system.map_interpreter.running? or
             @move_route_forcing or $game_temp.message_window_showing
        @event_run = false
        # •ûŒüƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ê‚Ä‚¢‚ê‚΁A‚»‚Ì•ûŒü‚ÖƒvƒŒƒCƒ„[‚ðˆÚ“®
        case Input.dir8
        when 1
          move_lower_left_p
        when 2
          move_down_p
        when 3
          move_lower_right_p
        when 4
          move_left_p
        when 6
          move_right_p
        when 7
          move_upper_left_p
        when 8
          move_up_p
        when 9
          move_upper_right_p
        end
      end
      # ƒ[ƒJƒ‹•Ï”‚ɍÀ•W‚ð‹L‰¯
      last_real_x = @real_x
      last_real_y = @real_y
      # ˆÚ“®ˆ—
      @real_x = @x * 128 + @revise_x
      @real_y = @y * 128 + @revise_y
      # ƒ[ƒJƒ‹•Ï”‚Ɉړ®’†‚©‚Ç‚¤‚©‚ð‹L‰¯
      last_moving = moving?
      # À•WXV
      move_on
      # Œ»Ý‚̍À•W‚ƈȑO‚̍À•W‚ªˆÙ‚È‚éê‡
      if (last_real_x != @real_x or last_real_y != @real_y)
        @move_distance = 0 if @move_distance == nil
        @move_distance += Math.sqrt((last_real_x - @real_x) ** 2 +
                                      (last_real_y - @real_y) ** 2)
        if @move_distance >= 128
          @move_distance %= 128
          increase_steps
        end
        # ƒAƒjƒ[ƒVƒ‡ƒ“‚ðXV
        anime_update
      elsif @walk_anime
        @pattern = @original_pattern
      end
    end
    # ƒLƒƒƒ‰ƒNƒ^[‚ª‰º‚Ɉړ®‚µA‚©‚‰æ–ʏã‚̈ʒu‚ª’†‰›‚æ‚艺‚̏ꍇ
    if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
      # ƒ}ƒbƒv‚ð‰º‚ÉƒXƒNƒ[ƒ‹
      $game_map.scroll_down(@real_y - last_real_y)
    end
    # ƒLƒƒƒ‰ƒNƒ^[‚ª¶‚Ɉړ®‚µA‚©‚‰æ–ʏã‚̈ʒu‚ª’†‰›‚æ‚荶‚̏ꍇ
    if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
      # ƒ}ƒbƒv‚ð¶‚ÉƒXƒNƒ[ƒ‹
      $game_map.scroll_left(last_real_x - @real_x)
    end
    # ƒLƒƒƒ‰ƒNƒ^[‚ª‰E‚Ɉړ®‚µA‚©‚‰æ–ʏã‚̈ʒu‚ª’†‰›‚æ‚è‰E‚̏ꍇ
    if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
      # ƒ}ƒbƒv‚ð‰E‚ɃXƒNƒ[ƒ‹
      $game_map.scroll_right(@real_x - last_real_x)
    end
    # ƒLƒƒƒ‰ƒNƒ^[‚ªã‚Ɉړ®‚µA‚©‚‰æ–ʏã‚̈ʒu‚ª’†‰›‚æ‚èã‚̏ꍇ
    if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
      # ƒ}ƒbƒv‚ðã‚ɃXƒNƒ[ƒ‹
      $game_map.scroll_up(last_real_y - @real_y)
    end
    # ‘O‰ñƒvƒŒƒCƒ„[‚ªˆÚ“®’†‚¾‚Á‚½ê‡
    if last_moving
      # “¯ˆÊ’u‚̃Cƒxƒ“ƒg‚Ƃ̐ڐG‚É‚æ‚éƒCƒxƒ“ƒg‹N“®”»’è
      result = check_event_trigger_here([1,2])
      if result == true
        if (last_real_x / 128.0).round != @x and
            (last_real_y / 128.0).round != @y
          if @direction == 2 or @direction == 8
            if (last_real_x / 128.0).round > @x
              turn_left
            else
              turn_right
            end
          else
            if (last_real_y / 128.0).round > @y
              turn_up
            else
              turn_down
            end
          end
        elsif (last_real_x / 128.0).round > @x
          turn_left
        elsif (last_real_x / 128.0).round < @x
          turn_right
        elsif (last_real_y / 128.0).round > @y
          turn_up
        elsif (last_real_y / 128.0).round < @y
          turn_down
        end
      end
      # ‹N“®‚µ‚½ƒCƒxƒ“ƒg‚ª‚È‚¢ê‡
      if result == false
        # ƒfƒoƒbƒOƒ‚[ƒh‚ª ON ‚©‚ CTRL ƒL[‚ª‰Ÿ‚³‚ê‚Ä‚¢‚éê‡‚ðœ‚«
        unless $DEBUG and Input.press?(Input::CTRL)
          # ƒGƒ“ƒJƒEƒ“ƒg ƒJƒEƒ“ƒgƒ_ƒEƒ“
          if @encounter_count > 0
            @encounter_count -= 1
          end
        end
      end
    end
    # C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
    if Input.trigger?(Input::C)
      # “¯ˆÊ’u‚¨‚æ‚ѐ³–ʂ̃Cƒxƒ“ƒg‹N“®”»’è
      check_event_trigger_here([0])
      check_event_trigger_there([0,1,2])
    end
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®”»’è
  #--------------------------------------------------------------------------
  def moving?
    unless @dot_m
      result = super
      return result
    end
    # ‹­§ˆÚ“®‚̏ꍇƒIƒŠƒWƒiƒ‹‚Ì”»’è‚ð‚³‚¹‚é
    if @move_route_forcing
      if @move == false
        return false
      end
      super
    # ’ʏ펞‚ÍŒ»À•W‚ªŽÀÀ•W‚ƈقȂéê‡‚݈̂ړ®’†‚Æ”»’è
    else
      return (@x != (@real_x / 128.0).round or @y != (@real_y / 128.0).round)
    end
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®”»’è
  #--------------------------------------------------------------------------
  def moving_a?
    if @move == false
      if (@move_route.list[@move_route_index].code <= 14 or
          @move_route.list[@move_route_index].code == 25)
        @move = true
      end
      return false
    end
    moving?
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ƒWƒƒƒ“ƒv)
  #--------------------------------------------------------------------------
  def update_jump
    # ƒWƒƒƒ“ƒvƒJƒEƒ“ƒg‚ð 1 Œ¸‚ç‚·
    @jump_count -= 1
    # V‚µ‚¢À•W‚ðŒvŽZ
    @real_x = (@real_x * @jump_count + @x * 128) / (@jump_count + 1)
    @real_y = (@real_y * @jump_count + @y * 128) / (@jump_count + 1)
    if @jump_count == 0
      @revise_x = 0
      @revise_y = 0
    end
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®ƒ^ƒCƒv : ƒJƒXƒ^ƒ€
  #--------------------------------------------------------------------------
  def move_type_custom
    unless @dot_m
      super
      return
    end
    # ’âŽ~’†‚Å‚È‚¯‚ê‚Î’†’f
    if jumping? or moving_a?
      return
    end
    # ˆÚ“®ƒRƒ}ƒ“ƒh‚̃ŠƒXƒg‚̍Ōã‚É“ž’B‚·‚é‚܂Ń‹[ƒv
    while @move_route_index < @move_route.list.size
      # ˆÚ“®ƒRƒ}ƒ“ƒh‚ðŽæ“¾
      command = @move_route.list[@move_route_index]
      # ƒRƒ}ƒ“ƒhƒR[ƒh 0 ”Ô (ƒŠƒXƒg‚̍Ōã) ‚̏ꍇ
      if command.code == 0
        # ƒIƒvƒVƒ‡ƒ“ [“®ì‚ðŒJ‚è•Ô‚·] ‚ª ON ‚̏ꍇ
        if @move_route.repeat
          # ˆÚ“®ƒ‹[ƒg‚̃Cƒ“ƒfƒbƒNƒX‚ðÅ‰‚É–ß‚·
          @move_route_index = 0
        end
        # ƒIƒvƒVƒ‡ƒ“ [“®ì‚ðŒJ‚è•Ô‚·] ‚ª OFF ‚̏ꍇ
        unless @move_route.repeat
          # ˆÚ“®ƒ‹[ƒg‹­§’†‚̏ꍇ
          if @move_route_forcing and not @move_route.repeat
            # ˆÚ“®ƒ‹[ƒg‚Ì‹­§‚ð‰ðœ
            @move_route_forcing = false
            # ƒIƒŠƒWƒiƒ‹‚̈ړ®ƒ‹[ƒg‚𕜋A
            @move_route = @original_move_route
            @move_route_index = @original_move_route_index
            @original_move_route = nil
          end
          # ’âŽ~ƒJƒEƒ“ƒg‚ðƒNƒŠƒA
          @stop_count = 0
        end
        return
      end
      # ˆÚ“®ŒnƒRƒ}ƒ“ƒh (‰º‚Ɉړ®`ƒWƒƒƒ“ƒv) ‚̏ꍇ
      if command.code <= 14
        # ƒRƒ}ƒ“ƒhƒR[ƒh‚Å•ªŠò
        case command.code
        when 1  # ‰º‚Ɉړ®
          move_down
        when 2  # ¶‚Ɉړ®
          move_left
        when 3  # ‰E‚Ɉړ®
          move_right
        when 4  # ã‚Ɉړ®
          move_up
        when 5  # ¶‰º‚Ɉړ®
          move_lower_left
        when 6  # ‰E‰º‚Ɉړ®
          move_lower_right
        when 7  # ¶ã‚Ɉړ®
          move_upper_left
        when 8  # ‰Eã‚Ɉړ®
          move_upper_right
        when 9  # ƒ‰ƒ“ƒ_ƒ€‚Ɉړ®
          move_random
        when 10  # ƒvƒŒƒCƒ„[‚ɋ߂­
          move_toward_player
        when 11  # ƒvƒŒƒCƒ„[‚©‚牓‚´‚©‚é
          move_away_from_player
        when 12  # ˆê•à‘Oi
          move_forward
        when 13  # ˆê•àŒã‘Þ
          move_backward
        when 14  # ƒWƒƒƒ“ƒv
          jump(command.parameters[0], command.parameters[1])
        end
        # ƒIƒvƒVƒ‡ƒ“ [ˆÚ“®‚Å‚«‚È‚¢ê‡‚Í–³Ž‹] ‚ª OFF ‚ŁAˆÚ“®Ž¸”s‚̏ꍇ
        if not @move_route.skippable and not moving? and not jumping?
          return
        end
        @move_route_index += 1
        return
      end
      # ƒEƒFƒCƒg‚̏ꍇ
      if command.code == 15
        # ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ðÝ’è
        @wait_count = command.parameters[0] * 2 - 1
        @move_route_index += 1
        return
      end
      # Œü‚«•ÏXŒn‚̃Rƒ}ƒ“ƒh‚̏ꍇ
      if command.code >= 16 and command.code <= 26
        # ƒRƒ}ƒ“ƒhƒR[ƒh‚Å•ªŠò
        case command.code
        when 16  # ‰º‚ðŒü‚­
          turn_down
        when 17  # ¶‚ðŒü‚­
          turn_left
        when 18  # ‰E‚ðŒü‚­
          turn_right
        when 19  # ã‚ðŒü‚­
          turn_up
        when 20  # ‰E‚É 90 “x‰ñ“]
          turn_right_90
        when 21  # ¶‚É 90 “x‰ñ“]
          turn_left_90
        when 22  # 180 “x‰ñ“]
          turn_180
        when 23  # ‰E‚©¶‚É 90 “x‰ñ“]
          turn_right_or_left_90
        when 24  # ƒ‰ƒ“ƒ_ƒ€‚É•ûŒü“]Š·
          turn_random
        when 25  # ƒvƒŒƒCƒ„[‚Ì•û‚ðŒü‚­
          turn_toward_player
        when 26  # ƒvƒŒƒCƒ„[‚Ì‹t‚ðŒü‚­
          turn_away_from_player
        end
        @move_route_index += 1
        return
      end
      # ‚»‚Ì‘¼‚̃Rƒ}ƒ“ƒh‚̏ꍇ
      if command.code >= 27
        # ƒRƒ}ƒ“ƒhƒR[ƒh‚Å•ªŠò
        case command.code
        when 27  # ƒXƒCƒbƒ` ON
          $game_switches[command.parameters[0]] = true
          $game_map.need_refresh = true
        when 28  # ƒXƒCƒbƒ` OFF
          $game_switches[command.parameters[0]] = false
          $game_map.need_refresh = true
        when 29  # ˆÚ“®‘¬“x‚̕ύX
          @move_speed = command.parameters[0]
        when 30  # ˆÚ“®•p“x‚̕ύX
          @move_frequency = command.parameters[0]
        when 31  # ˆÚ“®ŽžƒAƒjƒ ON
          @walk_anime = true
        when 32  # ˆÚ“®ŽžƒAƒjƒ OFF
          @walk_anime = false
        when 33  # ’âŽ~ŽžƒAƒjƒ ON
          @step_anime = true
        when 34  # ’âŽ~ŽžƒAƒjƒ OFF
          @step_anime = false
        when 35  # Œü‚«ŒÅ’è ON
          @direction_fix = true
        when 36  # Œü‚«ŒÅ’è OFF
          @direction_fix = false
        when 37  # ‚·‚蔲‚¯ ON
          @through = true
        when 38  # ‚·‚蔲‚¯ OFF
          @through = false
        when 39  # Å‘O–Ê‚É•\Ž¦ ON
          @always_on_top = true
        when 40  # Å‘O–Ê‚É•\Ž¦ OFF
          @always_on_top = false
        when 41  # ƒOƒ‰ƒtƒBƒbƒN•ÏX
          @tile_id = 0
          @character_name = command.parameters[0]
          @character_hue = command.parameters[1]
          if @original_direction != command.parameters[2]
            @direction = command.parameters[2]
            @original_direction = @direction
            @prelock_direction = 0
          end
          if @original_pattern != command.parameters[3]
            @pattern = command.parameters[3]
            @original_pattern = @pattern
          end
        when 42  # •s“§–¾“x‚̕ύX
          @opacity = command.parameters[0]
        when 43  # ‡¬•û–@‚̕ύX
          @blend_type = command.parameters[0]
        when 44  # SE ‚̉‰‘t
          $game_system.se_play(command.parameters[0])
        when 45  # ƒXƒNƒŠƒvƒg
          result = eval(command.parameters[0])
        end
        @move_route_index += 1
        return
      end
    end
  end
  #--------------------------------------------------------------------------
  # œ ‰º‚Ɉړ®
  #--------------------------------------------------------------------------
  def move_down_p
    # ‰º‚ðŒü‚­
    turn_down
    # ˆÚ“®‹——£‚ðŽZo
    distance = 2 ** @move_speed
    down1(((@x * 128 + @revise_x) / 128.0).round,
          ((@y * 128 + @revise_y) / 128.0).round, distance, true)
  end
  #--------------------------------------------------------------------------
  # œ ‰º‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚P
  #--------------------------------------------------------------------------
  def down1(x, y, distance, down = false)
    result = down2(x, y, distance)
    if result == false
      @event_run = check_event_trigger_touch(x, y+1)
      return result
    end
    if @revise_x < -SIDE
      result = down2(x, y + 1, distance, 4)
      result &= down2(x - 1, y, distance)
      if result == false
        if down
          move_lower_right_p
          if @revise_x > SIDE
            @revise_x = SIDE
          end
        end
        return result
      end
    elsif @revise_x > SIDE
      result = down2(x, y + 1, distance, 6)
      result &= down2(x + 1, y, distance)
      if result == false
        if down
          move_lower_left_p
          if @revise_x < -SIDE
            @revise_x = -SIDE
          end
        end
        return result
      end
    end
    # ‰º‚Ɉړ®‰Â”\‚È‚ç‚΋——£•ªˆÚ“®
    @revise_y += distance
    return result
  end
  #--------------------------------------------------------------------------
  # œ ‰º‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚Q
  #--------------------------------------------------------------------------
  def down2(x, y, distance, d = 2)
    if @revise_y + distance > 0
      unless passable?(x, y, d)
        if @revise_y < 0
          @revise_y = 0
        end
        return false
      end
    end
    return true
  end
  #--------------------------------------------------------------------------
  # œ ¶‚Ɉړ®
  #--------------------------------------------------------------------------
  def move_left_p
    # ¶‚ðŒü‚­
    turn_left
    distance = 2 ** @move_speed
    left1(((@x * 128 + @revise_x) / 128.0).round,
          ((@y * 128 + @revise_y) / 128.0).round, distance, true)
  end
  #--------------------------------------------------------------------------
  # œ ¶‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚P
  #--------------------------------------------------------------------------
  def left1(x, y, distance, left = false)
    result = left2(x, y, distance)
    if result == false
      @event_run = check_event_trigger_touch(x-1, y)
      return result
    end
    if @revise_y < -UP
      result = left2(x - 1, y, distance, 8)
      result &= left2(x, y - 1, distance)
      if result == false
        if left
          move_lower_left_p
          if @revise_y > 0
            @revise_y = 0
          end
        end
        return result
      end
    elsif @revise_y > 0
      result = left2(x - 1, y, distance, 2)
      result &= left2(x, y + 1, distance)
      if result == false
        if left
          move_upper_left_p
          if @revise_y < -UP
            @revise_y = -UP
          end
        end
        return result
      end
    end
    @revise_x -= distance
    return result
  end
  #--------------------------------------------------------------------------
  # œ ¶‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚Q
  #--------------------------------------------------------------------------
  def left2(x, y, distance, d = 4)
    if @revise_x - distance < -SIDE
      unless passable?(x, y, d)
        if @revise_x > -SIDE
          @revise_x = -SIDE
        end
        return false
      end
    end
    return true
  end
  #--------------------------------------------------------------------------
  # œ ‰E‚Ɉړ®
  #--------------------------------------------------------------------------
  def move_right_p
      # ‰E‚ðŒü‚­
      turn_right
    distance = 2 ** @move_speed
    right1(((@x * 128 + @revise_x) / 128.0).round,
            ((@y * 128 + @revise_y) / 128.0).round, distance, true)
  end
  #--------------------------------------------------------------------------
  # œ ‰E‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚P
  #--------------------------------------------------------------------------
  def right1(x, y, distance, right = false)
    result = right2(x, y, distance)
    if result == false
      @event_run = check_event_trigger_touch(x+1, y)
      return result
    end
    if @revise_y < -UP
      result = right2(x + 1, y, distance, 8)
      result &= right2(x, y - 1, distance)
      if result == false
        if right
          move_lower_right_p
          if @revise_y > 0
            @revise_y = 0
          end
        end
        return result
      end
    elsif @revise_y > 0
      result = right2(x + 1, y, distance, 2)
      result &= right2(x, y + 1, distance)
      if result == false
        if right
          move_upper_right_p
          if @revise_y < -UP
            @revise_y = -UP
          end
        end
        return result
      end
    end
    @revise_x += distance
    return result
  end
  #--------------------------------------------------------------------------
  # œ ‰E‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚Q
  #--------------------------------------------------------------------------
  def right2(x, y, distance, d = 6)
    if @revise_x + distance > SIDE
      unless passable?(x, y, d)
        if @revise_x < SIDE
          @revise_x = SIDE
        end
        return false
      end
    end
    return true
  end
  #--------------------------------------------------------------------------
  # œ ã‚Ɉړ®
  #--------------------------------------------------------------------------
  def move_up_p
    # ã‚ðŒü‚­
    turn_up
    # ‰º‚Ɉړ®
    distance = 2 ** @move_speed
    up1(((@x * 128 + @revise_x) / 128.0).round,
        ((@y * 128 + @revise_y) / 128.0).round, distance, true)
  end
  #--------------------------------------------------------------------------
  # œ ã‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚P
  #--------------------------------------------------------------------------
  def up1(x, y, distance, up = false)
    result = up2(x, y, distance)
    if result == false
      @event_run = check_event_trigger_touch(x, y-1)
      return result
    end
    if @revise_x < -SIDE
      result = up2(x, y - 1, distance, 4)
      result &= up2(x - 1, y, distance)
      if result == false
        if up
          move_upper_right_p
          if @revise_x > SIDE
            @revise_x = SIDE
          end
        end
        return result
      end
    elsif @revise_x > SIDE
      result = up2(x, y - 1, distance, 6)
      result &= up2(x + 1, y, distance)
      if result == false
        if up
          move_upper_left_p
          if @revise_x < -SIDE
            @revise_x = -SIDE
          end
        end
        return result
      end
    end
    @revise_y -= distance
    return result
  end
  #--------------------------------------------------------------------------
  # œ ã‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚Q
  #--------------------------------------------------------------------------
  def up2(x, y, distance, d = 8)
    if @revise_y - distance < -UP
      unless passable?(x, y, d)
        if @revise_y > -UP
          @revise_y = -UP
        end
        return false
      end
    end
    return true
  end
  #--------------------------------------------------------------------------
  # œ ¶‰º‚Ɉړ®
  #--------------------------------------------------------------------------
  def move_lower_left_p
    # Œü‚«ŒÅ’è‚Å‚È‚¢ê‡
    unless @direction_fix
      # ‰EŒü‚«‚¾‚Á‚½ê‡‚͍¶‚ðAãŒü‚«‚¾‚Á‚½ê‡‚͉º‚ðŒü‚­
      @direction = (@direction == 6 ? 4 : @direction == 8 ? 2 : @direction)
    end
    # ¶‰º‚Ɉړ®
    distance = (2 ** @move_speed) / Math.sqrt(2)
    if @direction == 2
      turn_left unless down1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
      turn_down if @event_run
      unless @event_run
        if last_move?(@real_x, @real_y, 2, distance)
          result = check_event_trigger_here([1,2], false)
          if result == true
            return
          end
        end
        move_on
        if @revise_y > 0 and -UP > @revise_y - distance
          @revise_y = 0
        end
        turn_down unless left1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
        turn_left if @event_run
      end
    else
      turn_down unless left1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
      turn_left if @event_run
      unless @event_run
        if last_move?(@real_x, @real_y, 4, distance)
          result = check_event_trigger_here([1,2], false)
          if result == true
            return
          end
        end
        move_on
        if  @revise_x + distance> SIDE and -SIDE > @revise_x
          @revise_x = -SIDE
        end
        turn_left unless down1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
        turn_down if @event_run
      end
    end
  end
  #--------------------------------------------------------------------------
  # œ ‰E‰º‚Ɉړ®
  #--------------------------------------------------------------------------
  def move_lower_right_p
    # Œü‚«ŒÅ’è‚Å‚È‚¢ê‡
    unless @direction_fix
      # ¶Œü‚«‚¾‚Á‚½ê‡‚͉E‚ðAãŒü‚«‚¾‚Á‚½ê‡‚͉º‚ðŒü‚­
      @direction = (@direction == 4 ? 6 : @direction == 8 ? 2 : @direction)
    end
    # ‰E‰º‚Ɉړ®
    distance = (2 ** @move_speed) / Math.sqrt(2)
    if @direction == 2
      turn_right unless down1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
      turn_down if @event_run
      unless @event_run
        if last_move?(@real_x, @real_y, 2, distance)
          result = check_event_trigger_here([1,2], false)
          if result == true
            return
          end
        end
        move_on
        if @revise_y > 0 and -UP > @revise_y - distance
          @revise_y = 0
        end
        turn_down unless right1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
        turn_right if @event_run
      end
    else
      turn_down unless right1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
      turn_right if @event_run
      unless @event_run
        if last_move?(@real_x, @real_y, 6, distance)
          result = check_event_trigger_here([1,2], false)
          if result == true
            return
          end
        end
        move_on
        if @revise_x > SIDE and -SIDE > @revise_x - distance
          @revise_x = SIDE
        end
        turn_right unless down1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
        turn_down if @event_run
      end
    end
  end
  #--------------------------------------------------------------------------
  # œ ¶ã‚Ɉړ®
  #--------------------------------------------------------------------------
  def move_upper_left_p
    # Œü‚«ŒÅ’è‚Å‚È‚¢ê‡
    unless @direction_fix
      # ‰EŒü‚«‚¾‚Á‚½ê‡‚͍¶‚ðA‰ºŒü‚«‚¾‚Á‚½ê‡‚͏ã‚ðŒü‚­
      @direction = (@direction == 6 ? 4 : @direction == 2 ? 8 : @direction)
    end
    # ¶ã‚Ɉړ®
    distance = (2 ** @move_speed) / Math.sqrt(2)
    if @direction == 8
      turn_left unless up1(((@x * 128 + @revise_x) / 128.0).round,
                            ((@y * 128 + @revise_y) / 128.0).round, distance)
      turn_up if @event_run
      unless @event_run
        if last_move?(@real_x, @real_y, 8, distance)
          result = check_event_trigger_here([1,2], false)
          if result == true
            return
          end
        end
        move_on
        if @revise_y + distance > 0 and -UP > @revise_y
          @revise_y = -UP
        end
        turn_up unless left1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
        turn_left if @event_run
      end
    else
      turn_up unless left1(((@x * 128 + @revise_x) / 128.0).round,
                            ((@y * 128 + @revise_y) / 128.0).round, distance)
      turn_left if @event_run
      unless @event_run
        if last_move?(@real_x, @real_y, 4, distance)
          result = check_event_trigger_here([1,2], false)
          if result == true
            return
          end
        end
        move_on
        if @revise_x > SIDE and -SIDE > @revise_x - distance
          @revise_x = SIDE
        end
        turn_left unless up1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
        turn_up if @event_run
      end
    end
  end
  #--------------------------------------------------------------------------
  # œ ‰Eã‚Ɉړ®
  #--------------------------------------------------------------------------
  def move_upper_right_p
    # Œü‚«ŒÅ’è‚Å‚È‚¢ê‡
    unless @direction_fix
      # ¶Œü‚«‚¾‚Á‚½ê‡‚͉E‚ðA‰ºŒü‚«‚¾‚Á‚½ê‡‚͏ã‚ðŒü‚­
      @direction = (@direction == 4 ? 6 : @direction == 2 ? 8 : @direction)
    end
    # ‰Eã‚Ɉړ®
    distance = (2 ** @move_speed) / Math.sqrt(2)
    if @direction == 8
      turn_right unless up1(((@x * 128 + @revise_x) / 128.0).round,
                            ((@y * 128 + @revise_y) / 128.0).round, distance)
      turn_up if @event_run
      unless @event_run
        if last_move?(@real_x, @real_y, 8, distance)
          result = check_event_trigger_here([1,2], false)
          if result == true
            return
          end
        end
        move_on
        if @revise_y + distance > 0 and -UP > @revise_y
          @revise_y = -UP
        end
        turn_up unless right1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
        turn_right if @event_run
      end
    else
      turn_up unless right1(((@x * 128 + @revise_x) / 128.0).round,
                            ((@y * 128 + @revise_y) / 128.0).round, distance)
      turn_right if @event_run
      unless @event_run
        if last_move?(@real_x, @real_y, 6, distance)
          result = check_event_trigger_here([1,2], false)
          if result == true
            return
          end
        end
        move_on
        if @revise_x > SIDE and -SIDE > @revise_x - distance
          @revise_x = SIDE
        end
        turn_right unless up1(((@x * 128 + @revise_x) / 128.0).round,
                              ((@y * 128 + @revise_y) / 128.0).round, distance)
        turn_up if @event_run
      end
    end
  end
  #--------------------------------------------------------------------------
  # œ “¯ˆÊ’u‚̃Cƒxƒ“ƒg‹N“®”»’è
  #--------------------------------------------------------------------------
  def check_event_trigger_here(triggers, run = true)
    result = false
    # ƒCƒxƒ“ƒgŽÀs’†‚̏ꍇ
    if $game_system.map_interpreter.running?
      return result
    end
    # ‘SƒCƒxƒ“ƒg‚̃‹[ƒv
    for event in $game_map.events.values
      # ƒCƒxƒ“ƒg‚̍À•W‚ƃgƒŠƒK[‚ªˆê’v‚µ‚½ê‡
      if event.x == ((@x * 128 + @revise_x) / 128.0).round and
          event.y == ((@y * 128 + @revise_y) / 128.0).round and
          triggers.include?(event.trigger)
        # ƒWƒƒƒ“ƒv’†ˆÈŠO‚ŁA‹N“®”»’肪“¯ˆÊ’u‚̃Cƒxƒ“ƒg‚È‚ç
        if not event.jumping? and event.over_trigger?
          if event.list.size > 1
            if run == true
              event.start
            end
            result = true
          end
        end
      end
    end
    return result
  end
  #--------------------------------------------------------------------------
  # œ À•WC³
  #--------------------------------------------------------------------------
  def move_on
    if @y < (@y + @revise_y / 128.0).round
      @y += 1
      @revise_y -= 128
    end
    if @x > (@x + @revise_x / 128.0).round
      @x -= 1
      @revise_x += 128
    end
    if @x < (@x + @revise_x / 128.0).round
      @x += 1
      @revise_x -= 128
    end
    if @y > (@y + @revise_y / 128.0).round
      @y -= 1
      @revise_y += 128
    end
  end
  #--------------------------------------------------------------------------
  # œ ƒAƒjƒ[ƒVƒ‡ƒ“ƒAƒbƒvƒf[ƒg
  #--------------------------------------------------------------------------
  def anime_update
    # ˆÚ“®ŽžƒAƒjƒ‚ª ON ‚̏ꍇ
    if @walk_anime
      # ƒAƒjƒƒJƒEƒ“ƒg‚ð 1.5 ‘‚â‚·
      @anime_count += 1.5
    # ˆÚ“®ŽžƒAƒjƒ‚ª OFF ‚ŁA’âŽ~ŽžƒAƒjƒ‚ª ON ‚̏ꍇ
    elsif @step_anime
      # ƒAƒjƒƒJƒEƒ“ƒg‚ð 1 ‘‚â‚·
      @anime_count += 1
    end
    # ƒAƒjƒƒJƒEƒ“ƒg‚ªÅ‘å’l‚ð’´‚¦‚½ê‡
    # ¦Å‘å’l‚́AŠî–{’l 18 ‚©‚çˆÚ“®‘¬“x * 1 ‚ðˆø‚¢‚½’l
    if @anime_count > 18 - @move_speed * 2
      # ’âŽ~ŽžƒAƒjƒ‚ª OFF ‚©‚ ’âŽ~’†‚̏ꍇ
      if not @step_anime and @stop_count > 0
        # ƒpƒ^[ƒ“‚ðƒIƒŠƒWƒiƒ‹‚É–ß‚·
        @pattern = @original_pattern
      # ’âŽ~ŽžƒAƒjƒ‚ª ON ‚Ü‚½‚Í ˆÚ“®’†‚̏ꍇ
      else
        # ƒpƒ^[ƒ“‚ðXV
        @pattern = (@pattern + 1) % 4
      end
      # ƒAƒjƒƒJƒEƒ“ƒg‚ðƒNƒŠƒA
      @anime_count = 0
    end
  end
  #--------------------------------------------------------------------------
  # œ Žw’èˆÊ’u‚Ɉړ®
  #--------------------------------------------------------------------------
  # ƒIƒŠƒWƒiƒ‹‚̃Cƒxƒ“ƒg‚ð‰ü–¼
  alias :moveto_original :moveto
  def moveto(x, y)
    # •â³À•W‚ð‰Šú‰»
    @revise_x = 0
    @revise_y = 0
    # ƒIƒŠƒWƒiƒ‹‚̃Cƒxƒ“ƒg‚ðŒÄ‚яo‚µ
    moveto_original(x, y)
  end
  #--------------------------------------------------------------------------
  # œ ˆÚ“®‚µ‚½‚©‚Ç‚¤‚©‚Ì”»’è
  #--------------------------------------------------------------------------
  def last_move?(x, y, direction, distance)
    if direction == 2 or direction == 6
      distance *= -1
    end
    if (direction == 2 or direction == 8) and
        (y / 128.0).round != ((y - distance) / 128.0).round
      return true
    end
    if (direction == 4 or direction == 6) and
        (x / 128.0).round != ((x - distance) / 128.0).round
      return true
    end
    return false
  end
end

#==============================================================================
# ¡ Game_Character (•ªŠ„’è‹` 1)
#------------------------------------------------------------------------------
# @ƒLƒƒƒ‰ƒNƒ^[‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·B‚±‚̃Nƒ‰ƒX‚Í Game_Player ƒNƒ‰ƒX‚Æ Game_Event
# ƒNƒ‰ƒX‚̃X[ƒp[ƒNƒ‰ƒX‚Æ‚µ‚ÄŽg—p‚³‚ê‚Ü‚·B
#==============================================================================

class Game_Character
  #--------------------------------------------------------------------------
  # œ ‰æ–Ê X À•W‚̎擾
  #--------------------------------------------------------------------------
  def screen_x
    # ŽÀÀ•W‚ƃ}ƒbƒv‚Ì•\Ž¦ˆÊ’u‚©‚ç‰æ–ʍÀ•W‚ð‹‚ß‚é
    return ((@real_x - $game_map.display_x) / 4).ceil + 16
  end
  #--------------------------------------------------------------------------
  # œ ‰æ–Ê Y À•W‚̎擾
  #--------------------------------------------------------------------------
  def screen_y
    # ŽÀÀ•W‚ƃ}ƒbƒv‚Ì•\Ž¦ˆÊ’u‚©‚ç‰æ–ʍÀ•W‚ð‹‚ß‚é
    y = ((@real_y - $game_map.display_y) / 4).ceil + 32
    # ƒWƒƒƒ“ƒvƒJƒEƒ“ƒg‚ɉž‚¶‚Ä Y À•W‚ð¬‚³‚­‚·‚é
    if @jump_count >= @jump_peak
      n = @jump_count - @jump_peak
    else
      n = @jump_peak - @jump_count
    end
    return y - (@jump_peak * @jump_peak - n * n) / 2
  end
  #--------------------------------------------------------------------------
  # œ ƒtƒŒ[ƒ€XV (ˆÚ“®)
  #--------------------------------------------------------------------------
  def update_move
    # ˆÚ“®‘¬“x‚©‚çƒ}ƒbƒvÀ•WŒn‚ł̈ړ®‹——£‚É•ÏŠ·
    distance = 2 ** @move_speed
    if @x * 128 != @real_x and @y * 128 != @real_y and Game_Player::SLANT
      distance /= Math.sqrt(2)
    end
    # ˜_—À•W‚ªŽÀÀ•W‚æ‚艺‚̏ꍇ
    if @y * 128 > @real_y
      # ‰º‚Ɉړ®
      @real_y = [@real_y + distance, @y * 128].min
    end
    # ˜_—À•W‚ªŽÀÀ•W‚æ‚荶‚̏ꍇ
    if @x * 128 < @real_x
      # ¶‚Ɉړ®
      @real_x = [@real_x - distance, @x * 128].max
    end
    # ˜_—À•W‚ªŽÀÀ•W‚æ‚è‰E‚̏ꍇ
    if @x * 128 > @real_x
      # ‰E‚Ɉړ®
      @real_x = [@real_x + distance, @x * 128].min
    end
    # ˜_—À•W‚ªŽÀÀ•W‚æ‚èã‚̏ꍇ
    if @y * 128 < @real_y
      # ã‚Ɉړ®
      @real_y = [@real_y - distance, @y * 128].max
    end
    # ˆÚ“®ŽžƒAƒjƒ‚ª ON ‚̏ꍇ
    if @walk_anime
      # ƒAƒjƒƒJƒEƒ“ƒg‚ð 1.5 ‘‚â‚·
      @anime_count += 1.5
    # ˆÚ“®ŽžƒAƒjƒ‚ª OFF ‚ŁA’âŽ~ŽžƒAƒjƒ‚ª ON ‚̏ꍇ
    elsif @step_anime
      # ƒAƒjƒƒJƒEƒ“ƒg‚ð 1 ‘‚â‚·
      @anime_count += 1
    end
  end
end

#==============================================================================
# ¡ Game_Event
#------------------------------------------------------------------------------
# @ƒCƒxƒ“ƒg‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·BðŒ”»’è‚É‚æ‚éƒCƒxƒ“ƒgƒy[ƒWØ‚è‘Ö‚¦‚âA•À—ñˆ—
# ƒCƒxƒ“ƒgŽÀs‚È‚Ç‚Ì‹@”\‚ðŽ‚Á‚Ä‚¨‚èAGame_Map ƒNƒ‰ƒX‚Ì“à•”‚ÅŽg—p‚³‚ê‚Ü‚·B
#==============================================================================

class Game_Event < Game_Character
  #--------------------------------------------------------------------------
  # œ ƒCƒxƒ“ƒg‹N“®
  #--------------------------------------------------------------------------
  def start
    # ŽÀs“à—e‚ª‹ó‚Å‚È‚¢ê‡
    if @list.size > 1
      # $game_player.event ‚ª0‚Å‚È‚¢ê‡
      if $game_player.event != 0
        # ˆÚ“®‘¬“x‚ð $game_player.event ‚É‚·‚é
        $game_player.move_speed = $game_player.event
      elsif self.trigger == 0
        $game_player.move_speed = $game_player.walk
      end
      @starting = true
    end
  end
end

I didn't script this!
Credits: Based on Genzai Kawakami's shadows, dynamisme&features by Rataime, extra features Boushy

And yeah last thing, credit these guyz if you use the script.
Ow, You may notice the title of the script as "Sprite Shadow". That's true. But using this script enables the 8 way movement + Pixel movement + Dash and all.. I couldn't understand the language it was written (the part which is used for the features you wanted) so I couldn't edit it.
Save-Point > Material Development > Scripts Database > Script Requests > 8 Way Pixelmovement Script