Sideview Battle System Tankentai XP - Version 2.2xp

[Atoa]

@Runningbaka
And what this have to do with the script? '-'

 

[Runningbaka]

I didn't know if it was your game, or something, that had something to do with the script.

 

[Luthur]

Hey, I know this has been asked before, but I can't find an answer anywhere. How do you move the command window? I mean the bit with the choices for Attack, Skill, Defend, etc. How do I move it?

Thanks

EDIT: Never mind, I've done it.

EDIT 2: How do you remove the window that says the actor's name?

 

[CoolAndrew11]

Has anyone gotten this amazing script to work with Pixel Movement?

 

[Atoa]

@fox5
It not only was asked before, it already was answered.
in the next update i will add this option, but for now theres no option for change battle window postion, so you must edit the script at your own risk.
The same for the actor name window.

@CoolAndrew11
Pixel movemnt? this is a battle script, so it affects only Scene_Battle (and some parts of menu), but has nothing to do with Scene_Map, i don't see why it wouldn't work.

 

[freezingicekirby]

Has anyone gotten this amazing script to work with Pixel Movement?

I was able to. I used a script that allowed me to use Pixel movement, 8-Way movement, and "Dash".

Here was the script I used. Click "Expand/Contract" to see the code.

# ‘S•ûŒüƒhƒbƒgˆÚ“® Ver ƒÃ+++

# ”z•zŒ³EƒTƒ|[ƒgURL

# [url=http://members.jcom.home.ne.jp/cogwheel/]http://members.jcom.home.ne.jp/cogwheel/[/url]

 

#==============================================================================

# ¡ 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

 

[CoolAndrew11]

Has anyone gotten this amazing script to work with Pixel Movement?

I was able to. I used a script that allowed me to use Pixel movement, 8-Way movement, and "Dash".

Here was the script I used. Click "Expand/Contract" to see the code.

Edit: Thanks. It works. Is there any way I can customize what's passable with this script? (by pixel)

 

[freezingicekirby]

Thanks. It works. Is there any way I can customize what's passable with this script? (by pixel)

Now that... I couldn't tell you. Sorry :sad:

 

[CoolAndrew11]

Thanks. It works. Is there any way I can customize what's passable with this script? (by pixel)

Now that... I couldn't tell you. Sorry :sad:

Heh. no problem man. You already did your good deed for the day and helped a noob out =) lol

 

[RPGuy]

Hi everyone

I got some questions on the script again :p

I made a new spell, but my guy runs up to the enemies and then the spell goes. Where in the scripts do I change it to be normal?

Can I add items normally? Or do I need to do scripting for em?

 

[Gulch666]

attacker animation issue? ^

 

[Legna]

probobly stupid question but i reeeeeeely gots ta know and fast! (not fast but im bored and cant do anything til i know anyway i cant *open* the file i can FIND (which does nothing but tell me i cant open it) or SAVE but then if i save that gives me these 2 options again so how do i open it please tell meeee :'(

 

[Runningbaka]

Atoa (or anyone else) do you have any ideas on my problem??
I could make a video if that would help...

 

[Gulch666]

probobly stupid question but i reeeeeeely gots ta know and fast! (not fast but im bored and cant do anything til i know anyway i cant *open* the file i can FIND (which does nothing but tell me i cant open it) or SAVE but then if i save that gives me these 2 options again so how do i open it please tell meeee :'(

wtf are you talking about? that makes absolutely no sense

 

[freezingicekirby]

probobly stupid question but i reeeeeeely gots ta know and fast! (not fast but im bored and cant do anything til i know anyway i cant *open* the file i can FIND (which does nothing but tell me i cant open it) or SAVE but then if i save that gives me these 2 options again so how do i open it please tell meeee :'(

wtf are you talking about? that makes absolutely no sense

I think he was trying to say (and I'm just taking a stab in the dark) that when he plays his game, it allows him to save his game, but whenever he tries to load, it gives him an error... or maybe he's talking about actually opening the Game.rxproj into RMXP?

No offense intended by this Legna, but could you perhaps give us more detail, and please use better sentence structure?

 

[Runningbaka]

I have posted here the link to the video I made better explaining my problem. If any of you could take a look at it, I would glady appreciate it.

http://www.youtube.com/watch?v=9ereXVF4OTc

~Runningbaka

 

[Atoa]

Lol, that really weird, but i'm 100% sure that it's not related to the script.

So i suggest you create an topic on RMXP support since there you find more help.

 

[cairn]

the error when trying to load a saved game can happen if you add a script in between the save time and the load time to the project.

 

[zchin]

Having it without the huge animated battler thing is great but not very customizable in the graphics department though. Do you thing that you can modify it to make it use the animated battler because it is just formatted for the RTP size person.

 

[artxia98]

-.- I cant get enemies into sprite form.